2 * This is the new netlink-based wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/list.h>
12 #include <linux/if_ether.h>
13 #include <linux/ieee80211.h>
14 #include <linux/nl80211.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/netlink.h>
17 #include <linux/etherdevice.h>
18 #include <net/net_namespace.h>
19 #include <net/genetlink.h>
20 #include <net/cfg80211.h>
26 /* the netlink family */
27 static struct genl_family nl80211_fam = {
28 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
29 .name = "nl80211", /* have users key off the name instead */
30 .hdrsize = 0, /* no private header */
31 .version = 1, /* no particular meaning now */
32 .maxattr = NL80211_ATTR_MAX,
36 /* internal helper: get rdev and dev */
37 static int get_rdev_dev_by_info_ifindex(struct genl_info *info,
38 struct cfg80211_registered_device **rdev,
39 struct net_device **dev)
41 struct nlattr **attrs = info->attrs;
44 if (!attrs[NL80211_ATTR_IFINDEX])
47 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
48 *dev = dev_get_by_index(genl_info_net(info), ifindex);
52 *rdev = cfg80211_get_dev_from_ifindex(genl_info_net(info), ifindex);
55 return PTR_ERR(*rdev);
61 /* policy for the attributes */
62 static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
63 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
64 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
66 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
67 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
68 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
69 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
70 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
71 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
72 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
73 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
75 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
76 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
77 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
79 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
80 [NL80211_ATTR_PREV_BSSID] = { .type = NLA_BINARY, .len = ETH_ALEN },
82 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
83 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
84 .len = WLAN_MAX_KEY_LEN },
85 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
86 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
87 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
88 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
90 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
91 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
92 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
93 .len = IEEE80211_MAX_DATA_LEN },
94 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
95 .len = IEEE80211_MAX_DATA_LEN },
96 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
97 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
98 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
99 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
100 .len = NL80211_MAX_SUPP_RATES },
101 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
102 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
103 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
104 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
105 .len = IEEE80211_MAX_MESH_ID_LEN },
106 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
108 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
109 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
111 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
112 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
113 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
114 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
115 .len = NL80211_MAX_SUPP_RATES },
117 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
119 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
120 .len = NL80211_HT_CAPABILITY_LEN },
122 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
123 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
124 .len = IEEE80211_MAX_DATA_LEN },
125 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
126 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
128 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
129 .len = IEEE80211_MAX_SSID_LEN },
130 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
131 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
132 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
133 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
134 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
135 [NL80211_ATTR_STA_FLAGS2] = {
136 .len = sizeof(struct nl80211_sta_flag_update),
138 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
139 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
140 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
141 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
142 [NL80211_ATTR_PID] = { .type = NLA_U32 },
143 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
144 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
145 .len = WLAN_PMKID_LEN },
146 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
147 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
148 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
149 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
150 .len = IEEE80211_MAX_DATA_LEN },
151 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
152 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
153 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
154 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
155 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
158 /* policy for the attributes */
159 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
160 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
161 [NL80211_KEY_IDX] = { .type = NLA_U8 },
162 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
163 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
164 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
165 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
168 /* ifidx get helper */
169 static int nl80211_get_ifidx(struct netlink_callback *cb)
173 res = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
174 nl80211_fam.attrbuf, nl80211_fam.maxattr,
179 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
182 res = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
189 static bool is_valid_ie_attr(const struct nlattr *attr)
197 pos = nla_data(attr);
218 /* message building helper */
219 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
222 /* since there is no private header just add the generic one */
223 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
226 static int nl80211_msg_put_channel(struct sk_buff *msg,
227 struct ieee80211_channel *chan)
229 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
232 if (chan->flags & IEEE80211_CHAN_DISABLED)
233 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
234 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
235 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
236 if (chan->flags & IEEE80211_CHAN_NO_IBSS)
237 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
238 if (chan->flags & IEEE80211_CHAN_RADAR)
239 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
241 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
242 DBM_TO_MBM(chan->max_power));
250 /* netlink command implementations */
258 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
260 struct nlattr *tb[NL80211_KEY_MAX + 1];
261 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
266 k->def = !!tb[NL80211_KEY_DEFAULT];
267 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
269 if (tb[NL80211_KEY_IDX])
270 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
272 if (tb[NL80211_KEY_DATA]) {
273 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
274 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
277 if (tb[NL80211_KEY_SEQ]) {
278 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
279 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
282 if (tb[NL80211_KEY_CIPHER])
283 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
288 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
290 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
291 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
292 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
295 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
296 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
297 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
300 if (info->attrs[NL80211_ATTR_KEY_IDX])
301 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
303 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
304 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
306 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
307 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
312 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
316 memset(k, 0, sizeof(*k));
319 if (info->attrs[NL80211_ATTR_KEY])
320 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
322 err = nl80211_parse_key_old(info, k);
327 if (k->def && k->defmgmt)
332 if (k->idx < 4 || k->idx > 5)
335 if (k->idx < 0 || k->idx > 3)
338 if (k->idx < 0 || k->idx > 5)
346 static struct cfg80211_cached_keys *
347 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
350 struct key_parse parse;
352 struct cfg80211_cached_keys *result;
353 int rem, err, def = 0;
355 result = kzalloc(sizeof(*result), GFP_KERNEL);
357 return ERR_PTR(-ENOMEM);
360 result->defmgmt = -1;
362 nla_for_each_nested(key, keys, rem) {
363 memset(&parse, 0, sizeof(parse));
366 err = nl80211_parse_key_new(key, &parse);
372 if (parse.idx < 0 || parse.idx > 4)
378 result->def = parse.idx;
379 } else if (parse.defmgmt)
381 err = cfg80211_validate_key_settings(rdev, &parse.p,
385 result->params[parse.idx].cipher = parse.p.cipher;
386 result->params[parse.idx].key_len = parse.p.key_len;
387 result->params[parse.idx].key = result->data[parse.idx];
388 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
397 static int nl80211_key_allowed(struct wireless_dev *wdev)
399 ASSERT_WDEV_LOCK(wdev);
401 if (!netif_running(wdev->netdev))
404 switch (wdev->iftype) {
405 case NL80211_IFTYPE_AP:
406 case NL80211_IFTYPE_AP_VLAN:
408 case NL80211_IFTYPE_ADHOC:
409 if (!wdev->current_bss)
412 case NL80211_IFTYPE_STATION:
413 if (wdev->sme_state != CFG80211_SME_CONNECTED)
423 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
424 struct cfg80211_registered_device *dev)
427 struct nlattr *nl_bands, *nl_band;
428 struct nlattr *nl_freqs, *nl_freq;
429 struct nlattr *nl_rates, *nl_rate;
430 struct nlattr *nl_modes;
431 struct nlattr *nl_cmds;
432 enum ieee80211_band band;
433 struct ieee80211_channel *chan;
434 struct ieee80211_rate *rate;
436 u16 ifmodes = dev->wiphy.interface_modes;
438 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
442 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
443 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
445 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION,
446 cfg80211_rdev_list_generation);
448 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
449 dev->wiphy.retry_short);
450 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
451 dev->wiphy.retry_long);
452 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
453 dev->wiphy.frag_threshold);
454 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
455 dev->wiphy.rts_threshold);
456 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
457 dev->wiphy.coverage_class);
459 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
460 dev->wiphy.max_scan_ssids);
461 NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
462 dev->wiphy.max_scan_ie_len);
464 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
465 sizeof(u32) * dev->wiphy.n_cipher_suites,
466 dev->wiphy.cipher_suites);
468 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
469 dev->wiphy.max_num_pmkids);
471 nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
473 goto nla_put_failure;
478 NLA_PUT_FLAG(msg, i);
483 nla_nest_end(msg, nl_modes);
485 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
487 goto nla_put_failure;
489 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
490 if (!dev->wiphy.bands[band])
493 nl_band = nla_nest_start(msg, band);
495 goto nla_put_failure;
498 if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
499 NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
500 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
501 &dev->wiphy.bands[band]->ht_cap.mcs);
502 NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
503 dev->wiphy.bands[band]->ht_cap.cap);
504 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
505 dev->wiphy.bands[band]->ht_cap.ampdu_factor);
506 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
507 dev->wiphy.bands[band]->ht_cap.ampdu_density);
510 /* add frequencies */
511 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
513 goto nla_put_failure;
515 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
516 nl_freq = nla_nest_start(msg, i);
518 goto nla_put_failure;
520 chan = &dev->wiphy.bands[band]->channels[i];
522 if (nl80211_msg_put_channel(msg, chan))
523 goto nla_put_failure;
525 nla_nest_end(msg, nl_freq);
528 nla_nest_end(msg, nl_freqs);
531 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
533 goto nla_put_failure;
535 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
536 nl_rate = nla_nest_start(msg, i);
538 goto nla_put_failure;
540 rate = &dev->wiphy.bands[band]->bitrates[i];
541 NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
543 if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
545 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
547 nla_nest_end(msg, nl_rate);
550 nla_nest_end(msg, nl_rates);
552 nla_nest_end(msg, nl_band);
554 nla_nest_end(msg, nl_bands);
556 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
558 goto nla_put_failure;
563 if (dev->ops->op) { \
565 NLA_PUT_U32(msg, i, NL80211_CMD_ ## n); \
569 CMD(add_virtual_intf, NEW_INTERFACE);
570 CMD(change_virtual_intf, SET_INTERFACE);
571 CMD(add_key, NEW_KEY);
572 CMD(add_beacon, NEW_BEACON);
573 CMD(add_station, NEW_STATION);
574 CMD(add_mpath, NEW_MPATH);
575 CMD(set_mesh_params, SET_MESH_PARAMS);
576 CMD(change_bss, SET_BSS);
577 CMD(auth, AUTHENTICATE);
578 CMD(assoc, ASSOCIATE);
579 CMD(deauth, DEAUTHENTICATE);
580 CMD(disassoc, DISASSOCIATE);
581 CMD(join_ibss, JOIN_IBSS);
582 CMD(set_pmksa, SET_PMKSA);
583 CMD(del_pmksa, DEL_PMKSA);
584 CMD(flush_pmksa, FLUSH_PMKSA);
585 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
586 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
588 if (dev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
590 NLA_PUT_U32(msg, i, NL80211_CMD_SET_WIPHY_NETNS);
592 CMD(set_channel, SET_CHANNEL);
596 if (dev->ops->connect || dev->ops->auth) {
598 NLA_PUT_U32(msg, i, NL80211_CMD_CONNECT);
601 if (dev->ops->disconnect || dev->ops->deauth) {
603 NLA_PUT_U32(msg, i, NL80211_CMD_DISCONNECT);
606 nla_nest_end(msg, nl_cmds);
608 return genlmsg_end(msg, hdr);
611 genlmsg_cancel(msg, hdr);
615 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
618 int start = cb->args[0];
619 struct cfg80211_registered_device *dev;
621 mutex_lock(&cfg80211_mutex);
622 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
623 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
627 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
628 cb->nlh->nlmsg_seq, NLM_F_MULTI,
634 mutex_unlock(&cfg80211_mutex);
641 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
644 struct cfg80211_registered_device *dev;
646 dev = cfg80211_get_dev_from_info(info);
650 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
654 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
657 cfg80211_unlock_rdev(dev);
659 return genlmsg_reply(msg, info);
664 cfg80211_unlock_rdev(dev);
668 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
669 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
670 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
671 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
672 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
673 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
676 static int parse_txq_params(struct nlattr *tb[],
677 struct ieee80211_txq_params *txq_params)
679 if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
680 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
681 !tb[NL80211_TXQ_ATTR_AIFS])
684 txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
685 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
686 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
687 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
688 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
693 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
696 * You can only set the channel explicitly for AP, mesh
697 * and WDS type interfaces; all others have their channel
698 * managed via their respective "establish a connection"
699 * command (connect, join, ...)
701 * Monitors are special as they are normally slaved to
702 * whatever else is going on, so they behave as though
703 * you tried setting the wiphy channel itself.
706 wdev->iftype == NL80211_IFTYPE_AP ||
707 wdev->iftype == NL80211_IFTYPE_WDS ||
708 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
709 wdev->iftype == NL80211_IFTYPE_MONITOR;
712 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
713 struct wireless_dev *wdev,
714 struct genl_info *info)
716 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
720 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
723 if (!nl80211_can_set_dev_channel(wdev))
726 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
727 channel_type = nla_get_u32(info->attrs[
728 NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
729 if (channel_type != NL80211_CHAN_NO_HT &&
730 channel_type != NL80211_CHAN_HT20 &&
731 channel_type != NL80211_CHAN_HT40PLUS &&
732 channel_type != NL80211_CHAN_HT40MINUS)
736 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
738 mutex_lock(&rdev->devlist_mtx);
741 result = cfg80211_set_freq(rdev, wdev, freq, channel_type);
744 result = cfg80211_set_freq(rdev, NULL, freq, channel_type);
746 mutex_unlock(&rdev->devlist_mtx);
751 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
753 struct cfg80211_registered_device *rdev;
754 struct net_device *netdev;
759 result = get_rdev_dev_by_info_ifindex(info, &rdev, &netdev);
763 result = __nl80211_set_channel(rdev, netdev->ieee80211_ptr, info);
771 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
773 struct cfg80211_registered_device *rdev;
774 struct net_device *netdev = NULL;
775 struct wireless_dev *wdev;
776 int result, rem_txq_params = 0;
777 struct nlattr *nl_txq_params;
779 u8 retry_short = 0, retry_long = 0;
780 u32 frag_threshold = 0, rts_threshold = 0;
781 u8 coverage_class = 0;
786 * Try to find the wiphy and netdev. Normally this
787 * function shouldn't need the netdev, but this is
788 * done for backward compatibility -- previously
789 * setting the channel was done per wiphy, but now
790 * it is per netdev. Previous userland like hostapd
791 * also passed a netdev to set_wiphy, so that it is
792 * possible to let that go to the right netdev!
794 mutex_lock(&cfg80211_mutex);
796 if (info->attrs[NL80211_ATTR_IFINDEX]) {
797 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
799 netdev = dev_get_by_index(genl_info_net(info), ifindex);
800 if (netdev && netdev->ieee80211_ptr) {
801 rdev = wiphy_to_dev(netdev->ieee80211_ptr->wiphy);
802 mutex_lock(&rdev->mtx);
808 rdev = __cfg80211_rdev_from_info(info);
810 mutex_unlock(&cfg80211_mutex);
811 result = PTR_ERR(rdev);
818 mutex_lock(&rdev->mtx);
819 } else if (netif_running(netdev) &&
820 nl80211_can_set_dev_channel(netdev->ieee80211_ptr))
821 wdev = netdev->ieee80211_ptr;
826 * end workaround code, by now the rdev is available
827 * and locked, and wdev may or may not be NULL.
830 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
831 result = cfg80211_dev_rename(
832 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
834 mutex_unlock(&cfg80211_mutex);
839 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
840 struct ieee80211_txq_params txq_params;
841 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
843 if (!rdev->ops->set_txq_params) {
844 result = -EOPNOTSUPP;
848 nla_for_each_nested(nl_txq_params,
849 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
851 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
852 nla_data(nl_txq_params),
853 nla_len(nl_txq_params),
855 result = parse_txq_params(tb, &txq_params);
859 result = rdev->ops->set_txq_params(&rdev->wiphy,
866 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
867 result = __nl80211_set_channel(rdev, wdev, info);
874 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
875 retry_short = nla_get_u8(
876 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
877 if (retry_short == 0) {
881 changed |= WIPHY_PARAM_RETRY_SHORT;
884 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
885 retry_long = nla_get_u8(
886 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
887 if (retry_long == 0) {
891 changed |= WIPHY_PARAM_RETRY_LONG;
894 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
895 frag_threshold = nla_get_u32(
896 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
897 if (frag_threshold < 256) {
901 if (frag_threshold != (u32) -1) {
903 * Fragments (apart from the last one) are required to
904 * have even length. Make the fragmentation code
905 * simpler by stripping LSB should someone try to use
906 * odd threshold value.
908 frag_threshold &= ~0x1;
910 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
913 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
914 rts_threshold = nla_get_u32(
915 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
916 changed |= WIPHY_PARAM_RTS_THRESHOLD;
919 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
920 coverage_class = nla_get_u8(
921 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
922 changed |= WIPHY_PARAM_COVERAGE_CLASS;
926 u8 old_retry_short, old_retry_long;
927 u32 old_frag_threshold, old_rts_threshold;
928 u8 old_coverage_class;
930 if (!rdev->ops->set_wiphy_params) {
931 result = -EOPNOTSUPP;
935 old_retry_short = rdev->wiphy.retry_short;
936 old_retry_long = rdev->wiphy.retry_long;
937 old_frag_threshold = rdev->wiphy.frag_threshold;
938 old_rts_threshold = rdev->wiphy.rts_threshold;
939 old_coverage_class = rdev->wiphy.coverage_class;
941 if (changed & WIPHY_PARAM_RETRY_SHORT)
942 rdev->wiphy.retry_short = retry_short;
943 if (changed & WIPHY_PARAM_RETRY_LONG)
944 rdev->wiphy.retry_long = retry_long;
945 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
946 rdev->wiphy.frag_threshold = frag_threshold;
947 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
948 rdev->wiphy.rts_threshold = rts_threshold;
949 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
950 rdev->wiphy.coverage_class = coverage_class;
952 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
954 rdev->wiphy.retry_short = old_retry_short;
955 rdev->wiphy.retry_long = old_retry_long;
956 rdev->wiphy.frag_threshold = old_frag_threshold;
957 rdev->wiphy.rts_threshold = old_rts_threshold;
958 rdev->wiphy.coverage_class = old_coverage_class;
963 mutex_unlock(&rdev->mtx);
972 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
973 struct cfg80211_registered_device *rdev,
974 struct net_device *dev)
978 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
982 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
983 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
984 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
985 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
987 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION,
988 rdev->devlist_generation ^
989 (cfg80211_rdev_list_generation << 2));
991 return genlmsg_end(msg, hdr);
994 genlmsg_cancel(msg, hdr);
998 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
1002 int wp_start = cb->args[0];
1003 int if_start = cb->args[1];
1004 struct cfg80211_registered_device *rdev;
1005 struct wireless_dev *wdev;
1007 mutex_lock(&cfg80211_mutex);
1008 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1009 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
1011 if (wp_idx < wp_start) {
1017 mutex_lock(&rdev->devlist_mtx);
1018 list_for_each_entry(wdev, &rdev->netdev_list, list) {
1019 if (if_idx < if_start) {
1023 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
1024 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1025 rdev, wdev->netdev) < 0) {
1026 mutex_unlock(&rdev->devlist_mtx);
1031 mutex_unlock(&rdev->devlist_mtx);
1036 mutex_unlock(&cfg80211_mutex);
1038 cb->args[0] = wp_idx;
1039 cb->args[1] = if_idx;
1044 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
1046 struct sk_buff *msg;
1047 struct cfg80211_registered_device *dev;
1048 struct net_device *netdev;
1051 err = get_rdev_dev_by_info_ifindex(info, &dev, &netdev);
1055 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1059 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
1064 cfg80211_unlock_rdev(dev);
1066 return genlmsg_reply(msg, info);
1072 cfg80211_unlock_rdev(dev);
1076 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
1077 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
1078 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
1079 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
1080 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
1081 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
1084 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
1086 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
1094 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
1095 nla, mntr_flags_policy))
1098 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
1100 *mntrflags |= (1<<flag);
1105 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
1106 struct net_device *netdev, u8 use_4addr,
1107 enum nl80211_iftype iftype)
1110 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
1116 case NL80211_IFTYPE_AP_VLAN:
1117 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
1120 case NL80211_IFTYPE_STATION:
1121 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
1131 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
1133 struct cfg80211_registered_device *rdev;
1134 struct vif_params params;
1136 enum nl80211_iftype otype, ntype;
1137 struct net_device *dev;
1138 u32 _flags, *flags = NULL;
1139 bool change = false;
1141 memset(¶ms, 0, sizeof(params));
1145 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1149 otype = ntype = dev->ieee80211_ptr->iftype;
1151 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1152 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1155 if (ntype > NL80211_IFTYPE_MAX) {
1161 if (info->attrs[NL80211_ATTR_MESH_ID]) {
1162 if (ntype != NL80211_IFTYPE_MESH_POINT) {
1166 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
1167 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1171 if (info->attrs[NL80211_ATTR_4ADDR]) {
1172 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
1174 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
1178 params.use_4addr = -1;
1181 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
1182 if (ntype != NL80211_IFTYPE_MONITOR) {
1186 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
1196 err = cfg80211_change_iface(rdev, dev, ntype, flags, ¶ms);
1200 if (!err && params.use_4addr != -1)
1201 dev->ieee80211_ptr->use_4addr = params.use_4addr;
1205 cfg80211_unlock_rdev(rdev);
1211 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
1213 struct cfg80211_registered_device *rdev;
1214 struct vif_params params;
1216 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
1219 memset(¶ms, 0, sizeof(params));
1221 if (!info->attrs[NL80211_ATTR_IFNAME])
1224 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1225 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1226 if (type > NL80211_IFTYPE_MAX)
1232 rdev = cfg80211_get_dev_from_info(info);
1234 err = PTR_ERR(rdev);
1238 if (!rdev->ops->add_virtual_intf ||
1239 !(rdev->wiphy.interface_modes & (1 << type))) {
1244 if (type == NL80211_IFTYPE_MESH_POINT &&
1245 info->attrs[NL80211_ATTR_MESH_ID]) {
1246 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
1247 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1250 if (info->attrs[NL80211_ATTR_4ADDR]) {
1251 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
1252 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
1257 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
1258 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
1260 err = rdev->ops->add_virtual_intf(&rdev->wiphy,
1261 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
1262 type, err ? NULL : &flags, ¶ms);
1265 cfg80211_unlock_rdev(rdev);
1271 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
1273 struct cfg80211_registered_device *rdev;
1275 struct net_device *dev;
1279 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1283 if (!rdev->ops->del_virtual_intf) {
1288 err = rdev->ops->del_virtual_intf(&rdev->wiphy, dev);
1291 cfg80211_unlock_rdev(rdev);
1298 struct get_key_cookie {
1299 struct sk_buff *msg;
1304 static void get_key_callback(void *c, struct key_params *params)
1307 struct get_key_cookie *cookie = c;
1310 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
1311 params->key_len, params->key);
1314 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
1315 params->seq_len, params->seq);
1318 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
1321 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
1323 goto nla_put_failure;
1326 NLA_PUT(cookie->msg, NL80211_KEY_DATA,
1327 params->key_len, params->key);
1330 NLA_PUT(cookie->msg, NL80211_KEY_SEQ,
1331 params->seq_len, params->seq);
1334 NLA_PUT_U32(cookie->msg, NL80211_KEY_CIPHER,
1337 NLA_PUT_U8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx);
1339 nla_nest_end(cookie->msg, key);
1346 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
1348 struct cfg80211_registered_device *rdev;
1350 struct net_device *dev;
1352 u8 *mac_addr = NULL;
1353 struct get_key_cookie cookie = {
1357 struct sk_buff *msg;
1359 if (info->attrs[NL80211_ATTR_KEY_IDX])
1360 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1365 if (info->attrs[NL80211_ATTR_MAC])
1366 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1370 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1374 if (!rdev->ops->get_key) {
1379 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1385 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
1386 NL80211_CMD_NEW_KEY);
1394 cookie.idx = key_idx;
1396 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1397 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1399 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1401 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, mac_addr,
1402 &cookie, get_key_callback);
1408 goto nla_put_failure;
1410 genlmsg_end(msg, hdr);
1411 err = genlmsg_reply(msg, info);
1419 cfg80211_unlock_rdev(rdev);
1427 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
1429 struct cfg80211_registered_device *rdev;
1430 struct key_parse key;
1432 struct net_device *dev;
1433 int (*func)(struct wiphy *wiphy, struct net_device *netdev,
1436 err = nl80211_parse_key(info, &key);
1443 /* only support setting default key */
1444 if (!key.def && !key.defmgmt)
1449 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1454 func = rdev->ops->set_default_key;
1456 func = rdev->ops->set_default_mgmt_key;
1463 wdev_lock(dev->ieee80211_ptr);
1464 err = nl80211_key_allowed(dev->ieee80211_ptr);
1466 err = func(&rdev->wiphy, dev, key.idx);
1468 #ifdef CONFIG_CFG80211_WEXT
1470 if (func == rdev->ops->set_default_key)
1471 dev->ieee80211_ptr->wext.default_key = key.idx;
1473 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
1476 wdev_unlock(dev->ieee80211_ptr);
1479 cfg80211_unlock_rdev(rdev);
1488 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
1490 struct cfg80211_registered_device *rdev;
1492 struct net_device *dev;
1493 struct key_parse key;
1494 u8 *mac_addr = NULL;
1496 err = nl80211_parse_key(info, &key);
1503 if (info->attrs[NL80211_ATTR_MAC])
1504 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1508 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1512 if (!rdev->ops->add_key) {
1517 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx, mac_addr)) {
1522 wdev_lock(dev->ieee80211_ptr);
1523 err = nl80211_key_allowed(dev->ieee80211_ptr);
1525 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx,
1527 wdev_unlock(dev->ieee80211_ptr);
1530 cfg80211_unlock_rdev(rdev);
1538 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
1540 struct cfg80211_registered_device *rdev;
1542 struct net_device *dev;
1543 u8 *mac_addr = NULL;
1544 struct key_parse key;
1546 err = nl80211_parse_key(info, &key);
1550 if (info->attrs[NL80211_ATTR_MAC])
1551 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1555 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1559 if (!rdev->ops->del_key) {
1564 wdev_lock(dev->ieee80211_ptr);
1565 err = nl80211_key_allowed(dev->ieee80211_ptr);
1567 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx, mac_addr);
1569 #ifdef CONFIG_CFG80211_WEXT
1571 if (key.idx == dev->ieee80211_ptr->wext.default_key)
1572 dev->ieee80211_ptr->wext.default_key = -1;
1573 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
1574 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
1577 wdev_unlock(dev->ieee80211_ptr);
1580 cfg80211_unlock_rdev(rdev);
1589 static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
1591 int (*call)(struct wiphy *wiphy, struct net_device *dev,
1592 struct beacon_parameters *info);
1593 struct cfg80211_registered_device *rdev;
1595 struct net_device *dev;
1596 struct beacon_parameters params;
1599 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
1604 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1608 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1613 switch (info->genlhdr->cmd) {
1614 case NL80211_CMD_NEW_BEACON:
1615 /* these are required for NEW_BEACON */
1616 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
1617 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
1618 !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1623 call = rdev->ops->add_beacon;
1625 case NL80211_CMD_SET_BEACON:
1626 call = rdev->ops->set_beacon;
1639 memset(¶ms, 0, sizeof(params));
1641 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
1643 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
1647 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
1648 params.dtim_period =
1649 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
1653 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1654 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1656 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1660 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
1661 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1663 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1672 err = call(&rdev->wiphy, dev, ¶ms);
1675 cfg80211_unlock_rdev(rdev);
1683 static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1685 struct cfg80211_registered_device *rdev;
1687 struct net_device *dev;
1691 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1695 if (!rdev->ops->del_beacon) {
1700 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1704 err = rdev->ops->del_beacon(&rdev->wiphy, dev);
1707 cfg80211_unlock_rdev(rdev);
1715 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1716 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
1717 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1718 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
1719 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
1722 static int parse_station_flags(struct genl_info *info,
1723 struct station_parameters *params)
1725 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
1730 * Try parsing the new attribute first so userspace
1731 * can specify both for older kernels.
1733 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
1735 struct nl80211_sta_flag_update *sta_flags;
1737 sta_flags = nla_data(nla);
1738 params->sta_flags_mask = sta_flags->mask;
1739 params->sta_flags_set = sta_flags->set;
1740 if ((params->sta_flags_mask |
1741 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
1746 /* if present, parse the old attribute */
1748 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
1752 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
1753 nla, sta_flags_policy))
1756 params->sta_flags_mask = (1 << __NL80211_STA_FLAG_AFTER_LAST) - 1;
1757 params->sta_flags_mask &= ~1;
1759 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
1761 params->sta_flags_set |= (1<<flag);
1766 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1767 int flags, struct net_device *dev,
1768 const u8 *mac_addr, struct station_info *sinfo)
1771 struct nlattr *sinfoattr, *txrate;
1774 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1778 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1779 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1781 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, sinfo->generation);
1783 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1785 goto nla_put_failure;
1786 if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1787 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1788 sinfo->inactive_time);
1789 if (sinfo->filled & STATION_INFO_RX_BYTES)
1790 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
1792 if (sinfo->filled & STATION_INFO_TX_BYTES)
1793 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
1795 if (sinfo->filled & STATION_INFO_LLID)
1796 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
1798 if (sinfo->filled & STATION_INFO_PLID)
1799 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
1801 if (sinfo->filled & STATION_INFO_PLINK_STATE)
1802 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
1803 sinfo->plink_state);
1804 if (sinfo->filled & STATION_INFO_SIGNAL)
1805 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
1807 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
1808 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
1810 goto nla_put_failure;
1812 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
1813 bitrate = cfg80211_calculate_bitrate(&sinfo->txrate);
1815 NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
1817 if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
1818 NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
1820 if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
1821 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
1822 if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
1823 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
1825 nla_nest_end(msg, txrate);
1827 if (sinfo->filled & STATION_INFO_RX_PACKETS)
1828 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS,
1830 if (sinfo->filled & STATION_INFO_TX_PACKETS)
1831 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_PACKETS,
1833 nla_nest_end(msg, sinfoattr);
1835 return genlmsg_end(msg, hdr);
1838 genlmsg_cancel(msg, hdr);
1842 static int nl80211_dump_station(struct sk_buff *skb,
1843 struct netlink_callback *cb)
1845 struct station_info sinfo;
1846 struct cfg80211_registered_device *dev;
1847 struct net_device *netdev;
1848 u8 mac_addr[ETH_ALEN];
1849 int ifidx = cb->args[0];
1850 int sta_idx = cb->args[1];
1854 ifidx = nl80211_get_ifidx(cb);
1860 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
1866 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
1872 if (!dev->ops->dump_station) {
1878 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
1885 if (nl80211_send_station(skb,
1886 NETLINK_CB(cb->skb).pid,
1887 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1897 cb->args[1] = sta_idx;
1900 cfg80211_unlock_rdev(dev);
1907 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1909 struct cfg80211_registered_device *rdev;
1911 struct net_device *dev;
1912 struct station_info sinfo;
1913 struct sk_buff *msg;
1914 u8 *mac_addr = NULL;
1916 memset(&sinfo, 0, sizeof(sinfo));
1918 if (!info->attrs[NL80211_ATTR_MAC])
1921 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1925 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
1929 if (!rdev->ops->get_station) {
1934 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo);
1938 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1942 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
1943 dev, mac_addr, &sinfo) < 0)
1946 err = genlmsg_reply(msg, info);
1952 cfg80211_unlock_rdev(rdev);
1961 * Get vlan interface making sure it is running and on the right wiphy.
1963 static int get_vlan(struct genl_info *info,
1964 struct cfg80211_registered_device *rdev,
1965 struct net_device **vlan)
1967 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
1971 *vlan = dev_get_by_index(genl_info_net(info),
1972 nla_get_u32(vlanattr));
1975 if (!(*vlan)->ieee80211_ptr)
1977 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
1979 if (!netif_running(*vlan))
1985 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
1987 struct cfg80211_registered_device *rdev;
1989 struct net_device *dev;
1990 struct station_parameters params;
1991 u8 *mac_addr = NULL;
1993 memset(¶ms, 0, sizeof(params));
1995 params.listen_interval = -1;
1997 if (info->attrs[NL80211_ATTR_STA_AID])
2000 if (!info->attrs[NL80211_ATTR_MAC])
2003 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2005 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
2006 params.supported_rates =
2007 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2008 params.supported_rates_len =
2009 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2012 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
2013 params.listen_interval =
2014 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
2016 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
2018 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
2020 if (parse_station_flags(info, ¶ms))
2023 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
2024 params.plink_action =
2025 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
2029 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2033 err = get_vlan(info, rdev, ¶ms.vlan);
2037 /* validate settings */
2040 switch (dev->ieee80211_ptr->iftype) {
2041 case NL80211_IFTYPE_AP:
2042 case NL80211_IFTYPE_AP_VLAN:
2043 /* disallow mesh-specific things */
2044 if (params.plink_action)
2047 case NL80211_IFTYPE_STATION:
2048 /* disallow everything but AUTHORIZED flag */
2049 if (params.plink_action)
2053 if (params.supported_rates)
2057 if (params.listen_interval >= 0)
2059 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
2062 case NL80211_IFTYPE_MESH_POINT:
2063 /* disallow things mesh doesn't support */
2068 if (params.listen_interval >= 0)
2070 if (params.supported_rates)
2072 if (params.sta_flags_mask)
2082 if (!rdev->ops->change_station) {
2087 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, ¶ms);
2091 dev_put(params.vlan);
2092 cfg80211_unlock_rdev(rdev);
2100 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
2102 struct cfg80211_registered_device *rdev;
2104 struct net_device *dev;
2105 struct station_parameters params;
2106 u8 *mac_addr = NULL;
2108 memset(¶ms, 0, sizeof(params));
2110 if (!info->attrs[NL80211_ATTR_MAC])
2113 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
2116 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
2119 if (!info->attrs[NL80211_ATTR_STA_AID])
2122 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2123 params.supported_rates =
2124 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2125 params.supported_rates_len =
2126 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2127 params.listen_interval =
2128 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
2130 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
2131 if (!params.aid || params.aid > IEEE80211_MAX_AID)
2134 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
2136 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
2138 if (parse_station_flags(info, ¶ms))
2143 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2147 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2148 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN) {
2153 err = get_vlan(info, rdev, ¶ms.vlan);
2157 /* validate settings */
2160 if (!rdev->ops->add_station) {
2165 if (!netif_running(dev)) {
2170 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, ¶ms);
2174 dev_put(params.vlan);
2175 cfg80211_unlock_rdev(rdev);
2183 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
2185 struct cfg80211_registered_device *rdev;
2187 struct net_device *dev;
2188 u8 *mac_addr = NULL;
2190 if (info->attrs[NL80211_ATTR_MAC])
2191 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2195 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2199 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2200 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
2201 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2206 if (!rdev->ops->del_station) {
2211 err = rdev->ops->del_station(&rdev->wiphy, dev, mac_addr);
2214 cfg80211_unlock_rdev(rdev);
2222 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
2223 int flags, struct net_device *dev,
2224 u8 *dst, u8 *next_hop,
2225 struct mpath_info *pinfo)
2228 struct nlattr *pinfoattr;
2230 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
2234 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2235 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
2236 NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
2238 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, pinfo->generation);
2240 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
2242 goto nla_put_failure;
2243 if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
2244 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
2246 if (pinfo->filled & MPATH_INFO_SN)
2247 NLA_PUT_U32(msg, NL80211_MPATH_INFO_SN,
2249 if (pinfo->filled & MPATH_INFO_METRIC)
2250 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
2252 if (pinfo->filled & MPATH_INFO_EXPTIME)
2253 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
2255 if (pinfo->filled & MPATH_INFO_FLAGS)
2256 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
2258 if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
2259 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
2260 pinfo->discovery_timeout);
2261 if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
2262 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
2263 pinfo->discovery_retries);
2265 nla_nest_end(msg, pinfoattr);
2267 return genlmsg_end(msg, hdr);
2270 genlmsg_cancel(msg, hdr);
2274 static int nl80211_dump_mpath(struct sk_buff *skb,
2275 struct netlink_callback *cb)
2277 struct mpath_info pinfo;
2278 struct cfg80211_registered_device *dev;
2279 struct net_device *netdev;
2281 u8 next_hop[ETH_ALEN];
2282 int ifidx = cb->args[0];
2283 int path_idx = cb->args[1];
2287 ifidx = nl80211_get_ifidx(cb);
2293 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
2299 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
2305 if (!dev->ops->dump_mpath) {
2310 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2316 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
2317 dst, next_hop, &pinfo);
2323 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
2324 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2325 netdev, dst, next_hop,
2334 cb->args[1] = path_idx;
2337 cfg80211_unlock_rdev(dev);
2344 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
2346 struct cfg80211_registered_device *rdev;
2348 struct net_device *dev;
2349 struct mpath_info pinfo;
2350 struct sk_buff *msg;
2352 u8 next_hop[ETH_ALEN];
2354 memset(&pinfo, 0, sizeof(pinfo));
2356 if (!info->attrs[NL80211_ATTR_MAC])
2359 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2363 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2367 if (!rdev->ops->get_mpath) {
2372 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2377 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo);
2381 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2385 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
2386 dev, dst, next_hop, &pinfo) < 0)
2389 err = genlmsg_reply(msg, info);
2395 cfg80211_unlock_rdev(rdev);
2403 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
2405 struct cfg80211_registered_device *rdev;
2407 struct net_device *dev;
2409 u8 *next_hop = NULL;
2411 if (!info->attrs[NL80211_ATTR_MAC])
2414 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2417 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2418 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2422 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2426 if (!rdev->ops->change_mpath) {
2431 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2436 if (!netif_running(dev)) {
2441 err = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
2444 cfg80211_unlock_rdev(rdev);
2451 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
2453 struct cfg80211_registered_device *rdev;
2455 struct net_device *dev;
2457 u8 *next_hop = NULL;
2459 if (!info->attrs[NL80211_ATTR_MAC])
2462 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2465 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2466 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2470 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2474 if (!rdev->ops->add_mpath) {
2479 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2484 if (!netif_running(dev)) {
2489 err = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
2492 cfg80211_unlock_rdev(rdev);
2500 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
2502 struct cfg80211_registered_device *rdev;
2504 struct net_device *dev;
2507 if (info->attrs[NL80211_ATTR_MAC])
2508 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2512 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2516 if (!rdev->ops->del_mpath) {
2521 err = rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
2524 cfg80211_unlock_rdev(rdev);
2532 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
2534 struct cfg80211_registered_device *rdev;
2536 struct net_device *dev;
2537 struct bss_parameters params;
2539 memset(¶ms, 0, sizeof(params));
2540 /* default to not changing parameters */
2541 params.use_cts_prot = -1;
2542 params.use_short_preamble = -1;
2543 params.use_short_slot_time = -1;
2544 params.ap_isolate = -1;
2546 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
2547 params.use_cts_prot =
2548 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
2549 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
2550 params.use_short_preamble =
2551 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
2552 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
2553 params.use_short_slot_time =
2554 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
2555 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
2556 params.basic_rates =
2557 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2558 params.basic_rates_len =
2559 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2561 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
2562 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
2566 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2570 if (!rdev->ops->change_bss) {
2575 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
2580 err = rdev->ops->change_bss(&rdev->wiphy, dev, ¶ms);
2583 cfg80211_unlock_rdev(rdev);
2591 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
2592 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2593 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2594 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2595 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2596 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2597 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2600 static int parse_reg_rule(struct nlattr *tb[],
2601 struct ieee80211_reg_rule *reg_rule)
2603 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
2604 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
2606 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
2608 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
2610 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
2612 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2614 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2617 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
2619 freq_range->start_freq_khz =
2620 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
2621 freq_range->end_freq_khz =
2622 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
2623 freq_range->max_bandwidth_khz =
2624 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
2626 power_rule->max_eirp =
2627 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
2629 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
2630 power_rule->max_antenna_gain =
2631 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
2636 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
2642 * You should only get this when cfg80211 hasn't yet initialized
2643 * completely when built-in to the kernel right between the time
2644 * window between nl80211_init() and regulatory_init(), if that is
2647 mutex_lock(&cfg80211_mutex);
2648 if (unlikely(!cfg80211_regdomain)) {
2649 mutex_unlock(&cfg80211_mutex);
2650 return -EINPROGRESS;
2652 mutex_unlock(&cfg80211_mutex);
2654 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2657 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2659 r = regulatory_hint_user(data);
2664 static int nl80211_get_mesh_params(struct sk_buff *skb,
2665 struct genl_info *info)
2667 struct cfg80211_registered_device *rdev;
2668 struct mesh_config cur_params;
2670 struct net_device *dev;
2672 struct nlattr *pinfoattr;
2673 struct sk_buff *msg;
2677 /* Look up our device */
2678 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2682 if (!rdev->ops->get_mesh_params) {
2687 /* Get the mesh params */
2688 err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params);
2692 /* Draw up a netlink message to send back */
2693 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2698 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2699 NL80211_CMD_GET_MESH_PARAMS);
2701 goto nla_put_failure;
2702 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
2704 goto nla_put_failure;
2705 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2706 NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
2707 cur_params.dot11MeshRetryTimeout);
2708 NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
2709 cur_params.dot11MeshConfirmTimeout);
2710 NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
2711 cur_params.dot11MeshHoldingTimeout);
2712 NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
2713 cur_params.dot11MeshMaxPeerLinks);
2714 NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
2715 cur_params.dot11MeshMaxRetries);
2716 NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
2717 cur_params.dot11MeshTTL);
2718 NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
2719 cur_params.auto_open_plinks);
2720 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2721 cur_params.dot11MeshHWMPmaxPREQretries);
2722 NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
2723 cur_params.path_refresh_time);
2724 NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2725 cur_params.min_discovery_timeout);
2726 NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2727 cur_params.dot11MeshHWMPactivePathTimeout);
2728 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2729 cur_params.dot11MeshHWMPpreqMinInterval);
2730 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2731 cur_params.dot11MeshHWMPnetDiameterTraversalTime);
2732 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
2733 cur_params.dot11MeshHWMPRootMode);
2734 nla_nest_end(msg, pinfoattr);
2735 genlmsg_end(msg, hdr);
2736 err = genlmsg_reply(msg, info);
2740 genlmsg_cancel(msg, hdr);
2744 cfg80211_unlock_rdev(rdev);
2752 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
2754 if (table[attr_num]) {\
2755 cfg.param = nla_fn(table[attr_num]); \
2756 mask |= (1 << (attr_num - 1)); \
2760 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
2761 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
2762 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
2763 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
2764 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
2765 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
2766 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
2767 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
2769 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
2770 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
2771 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
2772 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
2773 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
2774 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
2777 static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
2781 struct cfg80211_registered_device *rdev;
2782 struct net_device *dev;
2783 struct mesh_config cfg;
2784 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
2785 struct nlattr *parent_attr;
2787 parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
2790 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
2791 parent_attr, nl80211_meshconf_params_policy))
2796 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2800 if (!rdev->ops->set_mesh_params) {
2805 /* This makes sure that there aren't more than 32 mesh config
2806 * parameters (otherwise our bitfield scheme would not work.) */
2807 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
2809 /* Fill in the params struct */
2811 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
2812 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
2813 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
2814 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
2815 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
2816 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
2817 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
2818 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
2819 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
2820 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
2821 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
2822 mask, NL80211_MESHCONF_TTL, nla_get_u8);
2823 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
2824 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
2825 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
2826 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2828 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
2829 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
2830 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
2831 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2833 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
2834 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2836 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
2837 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2839 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
2840 dot11MeshHWMPnetDiameterTraversalTime,
2841 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2843 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
2844 dot11MeshHWMPRootMode, mask,
2845 NL80211_MESHCONF_HWMP_ROOTMODE,
2849 err = rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask);
2853 cfg80211_unlock_rdev(rdev);
2861 #undef FILL_IN_MESH_PARAM_IF_SET
2863 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
2865 struct sk_buff *msg;
2867 struct nlattr *nl_reg_rules;
2871 mutex_lock(&cfg80211_mutex);
2873 if (!cfg80211_regdomain)
2876 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2882 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2883 NL80211_CMD_GET_REG);
2885 goto nla_put_failure;
2887 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
2888 cfg80211_regdomain->alpha2);
2890 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
2892 goto nla_put_failure;
2894 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
2895 struct nlattr *nl_reg_rule;
2896 const struct ieee80211_reg_rule *reg_rule;
2897 const struct ieee80211_freq_range *freq_range;
2898 const struct ieee80211_power_rule *power_rule;
2900 reg_rule = &cfg80211_regdomain->reg_rules[i];
2901 freq_range = ®_rule->freq_range;
2902 power_rule = ®_rule->power_rule;
2904 nl_reg_rule = nla_nest_start(msg, i);
2906 goto nla_put_failure;
2908 NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS,
2910 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START,
2911 freq_range->start_freq_khz);
2912 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END,
2913 freq_range->end_freq_khz);
2914 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
2915 freq_range->max_bandwidth_khz);
2916 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
2917 power_rule->max_antenna_gain);
2918 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
2919 power_rule->max_eirp);
2921 nla_nest_end(msg, nl_reg_rule);
2924 nla_nest_end(msg, nl_reg_rules);
2926 genlmsg_end(msg, hdr);
2927 err = genlmsg_reply(msg, info);
2931 genlmsg_cancel(msg, hdr);
2934 mutex_unlock(&cfg80211_mutex);
2938 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
2940 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
2941 struct nlattr *nl_reg_rule;
2942 char *alpha2 = NULL;
2943 int rem_reg_rules = 0, r = 0;
2944 u32 num_rules = 0, rule_idx = 0, size_of_regd;
2945 struct ieee80211_regdomain *rd = NULL;
2947 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2950 if (!info->attrs[NL80211_ATTR_REG_RULES])
2953 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2955 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2958 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
2962 mutex_lock(&cfg80211_mutex);
2964 if (!reg_is_valid_request(alpha2)) {
2969 size_of_regd = sizeof(struct ieee80211_regdomain) +
2970 (num_rules * sizeof(struct ieee80211_reg_rule));
2972 rd = kzalloc(size_of_regd, GFP_KERNEL);
2978 rd->n_reg_rules = num_rules;
2979 rd->alpha2[0] = alpha2[0];
2980 rd->alpha2[1] = alpha2[1];
2982 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2984 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
2985 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
2987 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
2993 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
2999 BUG_ON(rule_idx != num_rules);
3003 mutex_unlock(&cfg80211_mutex);
3008 mutex_unlock(&cfg80211_mutex);
3013 static int validate_scan_freqs(struct nlattr *freqs)
3015 struct nlattr *attr1, *attr2;
3016 int n_channels = 0, tmp1, tmp2;
3018 nla_for_each_nested(attr1, freqs, tmp1) {
3021 * Some hardware has a limited channel list for
3022 * scanning, and it is pretty much nonsensical
3023 * to scan for a channel twice, so disallow that
3024 * and don't require drivers to check that the
3025 * channel list they get isn't longer than what
3026 * they can scan, as long as they can scan all
3027 * the channels they registered at once.
3029 nla_for_each_nested(attr2, freqs, tmp2)
3030 if (attr1 != attr2 &&
3031 nla_get_u32(attr1) == nla_get_u32(attr2))
3038 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
3040 struct cfg80211_registered_device *rdev;
3041 struct net_device *dev;
3042 struct cfg80211_scan_request *request;
3043 struct cfg80211_ssid *ssid;
3044 struct ieee80211_channel *channel;
3045 struct nlattr *attr;
3046 struct wiphy *wiphy;
3047 int err, tmp, n_ssids = 0, n_channels, i;
3048 enum ieee80211_band band;
3051 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3056 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
3060 wiphy = &rdev->wiphy;
3062 if (!rdev->ops->scan) {
3067 if (!netif_running(dev)) {
3072 if (rdev->scan_req) {
3077 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
3078 n_channels = validate_scan_freqs(
3079 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
3087 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
3088 if (wiphy->bands[band])
3089 n_channels += wiphy->bands[band]->n_channels;
3092 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
3093 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
3096 if (n_ssids > wiphy->max_scan_ssids) {
3101 if (info->attrs[NL80211_ATTR_IE])
3102 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3106 if (ie_len > wiphy->max_scan_ie_len) {
3111 request = kzalloc(sizeof(*request)
3112 + sizeof(*ssid) * n_ssids
3113 + sizeof(channel) * n_channels
3114 + ie_len, GFP_KERNEL);
3121 request->ssids = (void *)&request->channels[n_channels];
3122 request->n_ssids = n_ssids;
3125 request->ie = (void *)(request->ssids + n_ssids);
3127 request->ie = (void *)(request->channels + n_channels);
3131 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
3132 /* user specified, bail out if channel not found */
3133 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
3134 struct ieee80211_channel *chan;
3136 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
3143 /* ignore disabled channels */
3144 if (chan->flags & IEEE80211_CHAN_DISABLED)
3147 request->channels[i] = chan;
3152 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
3154 if (!wiphy->bands[band])
3156 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
3157 struct ieee80211_channel *chan;
3159 chan = &wiphy->bands[band]->channels[j];
3161 if (chan->flags & IEEE80211_CHAN_DISABLED)
3164 request->channels[i] = chan;
3175 request->n_channels = i;
3178 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
3179 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
3180 if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
3184 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
3185 request->ssids[i].ssid_len = nla_len(attr);
3190 if (info->attrs[NL80211_ATTR_IE]) {
3191 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3192 memcpy((void *)request->ie,
3193 nla_data(info->attrs[NL80211_ATTR_IE]),
3198 request->wiphy = &rdev->wiphy;
3200 rdev->scan_req = request;
3201 err = rdev->ops->scan(&rdev->wiphy, dev, request);
3204 nl80211_send_scan_start(rdev, dev);
3210 rdev->scan_req = NULL;
3214 cfg80211_unlock_rdev(rdev);
3222 static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags,
3223 struct cfg80211_registered_device *rdev,
3224 struct wireless_dev *wdev,
3225 struct cfg80211_internal_bss *intbss)
3227 struct cfg80211_bss *res = &intbss->pub;
3232 ASSERT_WDEV_LOCK(wdev);
3234 hdr = nl80211hdr_put(msg, pid, seq, flags,
3235 NL80211_CMD_NEW_SCAN_RESULTS);
3239 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation);
3240 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex);
3242 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
3244 goto nla_put_failure;
3245 if (!is_zero_ether_addr(res->bssid))
3246 NLA_PUT(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid);
3247 if (res->information_elements && res->len_information_elements)
3248 NLA_PUT(msg, NL80211_BSS_INFORMATION_ELEMENTS,
3249 res->len_information_elements,
3250 res->information_elements);
3251 if (res->beacon_ies && res->len_beacon_ies &&
3252 res->beacon_ies != res->information_elements)
3253 NLA_PUT(msg, NL80211_BSS_BEACON_IES,
3254 res->len_beacon_ies, res->beacon_ies);
3256 NLA_PUT_U64(msg, NL80211_BSS_TSF, res->tsf);
3257 if (res->beacon_interval)
3258 NLA_PUT_U16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval);
3259 NLA_PUT_U16(msg, NL80211_BSS_CAPABILITY, res->capability);
3260 NLA_PUT_U32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq);
3261 NLA_PUT_U32(msg, NL80211_BSS_SEEN_MS_AGO,
3262 jiffies_to_msecs(jiffies - intbss->ts));
3264 switch (rdev->wiphy.signal_type) {
3265 case CFG80211_SIGNAL_TYPE_MBM:
3266 NLA_PUT_U32(msg, NL80211_BSS_SIGNAL_MBM, res->signal);
3268 case CFG80211_SIGNAL_TYPE_UNSPEC:
3269 NLA_PUT_U8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal);
3275 switch (wdev->iftype) {
3276 case NL80211_IFTYPE_STATION:
3277 if (intbss == wdev->current_bss)
3278 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3279 NL80211_BSS_STATUS_ASSOCIATED);
3280 else for (i = 0; i < MAX_AUTH_BSSES; i++) {
3281 if (intbss != wdev->auth_bsses[i])
3283 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3284 NL80211_BSS_STATUS_AUTHENTICATED);
3288 case NL80211_IFTYPE_ADHOC:
3289 if (intbss == wdev->current_bss)
3290 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3291 NL80211_BSS_STATUS_IBSS_JOINED);
3297 nla_nest_end(msg, bss);
3299 return genlmsg_end(msg, hdr);
3302 genlmsg_cancel(msg, hdr);
3306 static int nl80211_dump_scan(struct sk_buff *skb,
3307 struct netlink_callback *cb)
3309 struct cfg80211_registered_device *rdev;
3310 struct net_device *dev;
3311 struct cfg80211_internal_bss *scan;
3312 struct wireless_dev *wdev;
3313 int ifidx = cb->args[0];
3314 int start = cb->args[1], idx = 0;
3318 ifidx = nl80211_get_ifidx(cb);
3321 cb->args[0] = ifidx;
3323 dev = dev_get_by_index(sock_net(skb->sk), ifidx);
3327 rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
3329 err = PTR_ERR(rdev);
3330 goto out_put_netdev;
3333 wdev = dev->ieee80211_ptr;
3336 spin_lock_bh(&rdev->bss_lock);
3337 cfg80211_bss_expire(rdev);
3339 list_for_each_entry(scan, &rdev->bss_list, list) {
3342 if (nl80211_send_bss(skb,
3343 NETLINK_CB(cb->skb).pid,
3344 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3345 rdev, wdev, scan) < 0) {
3352 spin_unlock_bh(&rdev->bss_lock);
3357 cfg80211_unlock_rdev(rdev);
3364 static int nl80211_send_survey(struct sk_buff *msg, u32 pid, u32 seq,
3365 int flags, struct net_device *dev,
3366 struct survey_info *survey)
3369 struct nlattr *infoattr;
3371 /* Survey without a channel doesn't make sense */
3372 if (!survey->channel)
3375 hdr = nl80211hdr_put(msg, pid, seq, flags,
3376 NL80211_CMD_NEW_SURVEY_RESULTS);
3380 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
3382 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
3384 goto nla_put_failure;
3386 NLA_PUT_U32(msg, NL80211_SURVEY_INFO_FREQUENCY,
3387 survey->channel->center_freq);
3388 if (survey->filled & SURVEY_INFO_NOISE_DBM)
3389 NLA_PUT_U8(msg, NL80211_SURVEY_INFO_NOISE,
3392 nla_nest_end(msg, infoattr);
3394 return genlmsg_end(msg, hdr);
3397 genlmsg_cancel(msg, hdr);
3401 static int nl80211_dump_survey(struct sk_buff *skb,
3402 struct netlink_callback *cb)
3404 struct survey_info survey;
3405 struct cfg80211_registered_device *dev;
3406 struct net_device *netdev;
3407 int ifidx = cb->args[0];
3408 int survey_idx = cb->args[1];
3412 ifidx = nl80211_get_ifidx(cb);
3415 cb->args[0] = ifidx;
3419 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
3425 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
3431 if (!dev->ops->dump_survey) {
3437 res = dev->ops->dump_survey(&dev->wiphy, netdev, survey_idx,
3444 if (nl80211_send_survey(skb,
3445 NETLINK_CB(cb->skb).pid,
3446 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3454 cb->args[1] = survey_idx;
3457 cfg80211_unlock_rdev(dev);
3464 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
3466 return auth_type <= NL80211_AUTHTYPE_MAX;
3469 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
3471 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
3472 NL80211_WPA_VERSION_2));
3475 static bool nl80211_valid_akm_suite(u32 akm)
3477 return akm == WLAN_AKM_SUITE_8021X ||
3478 akm == WLAN_AKM_SUITE_PSK;
3481 static bool nl80211_valid_cipher_suite(u32 cipher)
3483 return cipher == WLAN_CIPHER_SUITE_WEP40 ||
3484 cipher == WLAN_CIPHER_SUITE_WEP104 ||
3485 cipher == WLAN_CIPHER_SUITE_TKIP ||
3486 cipher == WLAN_CIPHER_SUITE_CCMP ||
3487 cipher == WLAN_CIPHER_SUITE_AES_CMAC;
3491 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
3493 struct cfg80211_registered_device *rdev;
3494 struct net_device *dev;
3495 struct ieee80211_channel *chan;
3496 const u8 *bssid, *ssid, *ie = NULL;
3497 int err, ssid_len, ie_len = 0;
3498 enum nl80211_auth_type auth_type;
3499 struct key_parse key;
3500 bool local_state_change;
3502 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3505 if (!info->attrs[NL80211_ATTR_MAC])
3508 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
3511 if (!info->attrs[NL80211_ATTR_SSID])
3514 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
3517 err = nl80211_parse_key(info, &key);
3522 if (!key.p.key || !key.p.key_len)
3524 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
3525 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
3526 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
3527 key.p.key_len != WLAN_KEY_LEN_WEP104))
3538 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
3542 if (!rdev->ops->auth) {
3547 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3552 if (!netif_running(dev)) {
3557 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3558 chan = ieee80211_get_channel(&rdev->wiphy,
3559 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3560 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3565 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3566 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3568 if (info->attrs[NL80211_ATTR_IE]) {
3569 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3570 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3573 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3574 if (!nl80211_valid_auth_type(auth_type)) {
3579 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
3581 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
3582 ssid, ssid_len, ie, ie_len,
3583 key.p.key, key.p.key_len, key.idx,
3584 local_state_change);
3587 cfg80211_unlock_rdev(rdev);
3594 static int nl80211_crypto_settings(struct genl_info *info,
3595 struct cfg80211_crypto_settings *settings,
3598 memset(settings, 0, sizeof(*settings));
3600 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
3602 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
3606 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3607 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3608 settings->n_ciphers_pairwise = len / sizeof(u32);
3610 if (len % sizeof(u32))
3613 if (settings->n_ciphers_pairwise > cipher_limit)
3616 memcpy(settings->ciphers_pairwise, data, len);
3618 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3619 if (!nl80211_valid_cipher_suite(
3620 settings->ciphers_pairwise[i]))
3624 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
3625 settings->cipher_group =
3626 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
3627 if (!nl80211_valid_cipher_suite(settings->cipher_group))
3631 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
3632 settings->wpa_versions =
3633 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
3634 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
3638 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
3642 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
3643 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
3644 settings->n_akm_suites = len / sizeof(u32);
3646 if (len % sizeof(u32))
3649 memcpy(settings->akm_suites, data, len);
3651 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3652 if (!nl80211_valid_akm_suite(settings->akm_suites[i]))
3659 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
3661 struct cfg80211_registered_device *rdev;
3662 struct net_device *dev;
3663 struct cfg80211_crypto_settings crypto;
3664 struct ieee80211_channel *chan;
3665 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
3666 int err, ssid_len, ie_len = 0;
3667 bool use_mfp = false;
3669 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3672 if (!info->attrs[NL80211_ATTR_MAC] ||
3673 !info->attrs[NL80211_ATTR_SSID] ||
3674 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
3679 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
3683 if (!rdev->ops->assoc) {
3688 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3693 if (!netif_running(dev)) {
3698 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3700 chan = ieee80211_get_channel(&rdev->wiphy,
3701 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3702 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3707 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3708 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3710 if (info->attrs[NL80211_ATTR_IE]) {
3711 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3712 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3715 if (info->attrs[NL80211_ATTR_USE_MFP]) {
3716 enum nl80211_mfp mfp =
3717 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
3718 if (mfp == NL80211_MFP_REQUIRED)
3720 else if (mfp != NL80211_MFP_NO) {
3726 if (info->attrs[NL80211_ATTR_PREV_BSSID])
3727 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3729 err = nl80211_crypto_settings(info, &crypto, 1);
3731 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
3732 ssid, ssid_len, ie, ie_len, use_mfp,
3736 cfg80211_unlock_rdev(rdev);
3743 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
3745 struct cfg80211_registered_device *rdev;
3746 struct net_device *dev;
3747 const u8 *ie = NULL, *bssid;
3748 int err, ie_len = 0;
3750 bool local_state_change;
3752 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3755 if (!info->attrs[NL80211_ATTR_MAC])
3758 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3763 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
3767 if (!rdev->ops->deauth) {
3772 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3777 if (!netif_running(dev)) {
3782 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3784 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3785 if (reason_code == 0) {
3786 /* Reason Code 0 is reserved */
3791 if (info->attrs[NL80211_ATTR_IE]) {
3792 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3793 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3796 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
3798 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
3799 local_state_change);
3802 cfg80211_unlock_rdev(rdev);
3809 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
3811 struct cfg80211_registered_device *rdev;
3812 struct net_device *dev;
3813 const u8 *ie = NULL, *bssid;
3814 int err, ie_len = 0;
3816 bool local_state_change;
3818 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3821 if (!info->attrs[NL80211_ATTR_MAC])
3824 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3829 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
3833 if (!rdev->ops->disassoc) {
3838 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3843 if (!netif_running(dev)) {
3848 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3850 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3851 if (reason_code == 0) {
3852 /* Reason Code 0 is reserved */
3857 if (info->attrs[NL80211_ATTR_IE]) {
3858 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3859 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3862 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
3864 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
3865 local_state_change);
3868 cfg80211_unlock_rdev(rdev);
3875 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
3877 struct cfg80211_registered_device *rdev;
3878 struct net_device *dev;
3879 struct cfg80211_ibss_params ibss;
3880 struct wiphy *wiphy;
3881 struct cfg80211_cached_keys *connkeys = NULL;
3884 memset(&ibss, 0, sizeof(ibss));
3886 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3889 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
3890 !info->attrs[NL80211_ATTR_SSID] ||
3891 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3894 ibss.beacon_interval = 100;
3896 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
3897 ibss.beacon_interval =
3898 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3899 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
3905 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
3909 if (!rdev->ops->join_ibss) {
3914 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3919 if (!netif_running(dev)) {
3924 wiphy = &rdev->wiphy;
3926 if (info->attrs[NL80211_ATTR_MAC])
3927 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3928 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3929 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3931 if (info->attrs[NL80211_ATTR_IE]) {
3932 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3933 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3936 ibss.channel = ieee80211_get_channel(wiphy,
3937 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3938 if (!ibss.channel ||
3939 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
3940 ibss.channel->flags & IEEE80211_CHAN_DISABLED) {
3945 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
3946 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3948 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
3949 connkeys = nl80211_parse_connkeys(rdev,
3950 info->attrs[NL80211_ATTR_KEYS]);
3951 if (IS_ERR(connkeys)) {
3952 err = PTR_ERR(connkeys);
3958 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
3960 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
3962 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
3963 struct ieee80211_supported_band *sband =
3964 wiphy->bands[ibss.channel->band];
3972 for (i = 0; i < n_rates; i++) {
3973 int rate = (rates[i] & 0x7f) * 5;
3976 for (j = 0; j < sband->n_bitrates; j++) {
3977 if (sband->bitrates[j].bitrate == rate) {
3979 ibss.basic_rates |= BIT(j);
3990 * If no rates were explicitly configured,
3991 * use the mandatory rate set for 11b or
3992 * 11a for maximum compatibility.
3994 struct ieee80211_supported_band *sband =
3995 wiphy->bands[ibss.channel->band];
3997 u32 flag = ibss.channel->band == IEEE80211_BAND_5GHZ ?
3998 IEEE80211_RATE_MANDATORY_A :
3999 IEEE80211_RATE_MANDATORY_B;
4001 for (j = 0; j < sband->n_bitrates; j++) {
4002 if (sband->bitrates[j].flags & flag)
4003 ibss.basic_rates |= BIT(j);
4007 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
4010 cfg80211_unlock_rdev(rdev);
4019 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
4021 struct cfg80211_registered_device *rdev;
4022 struct net_device *dev;
4027 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4031 if (!rdev->ops->leave_ibss) {
4036 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
4041 if (!netif_running(dev)) {
4046 err = cfg80211_leave_ibss(rdev, dev, false);
4049 cfg80211_unlock_rdev(rdev);
4056 #ifdef CONFIG_NL80211_TESTMODE
4057 static struct genl_multicast_group nl80211_testmode_mcgrp = {
4061 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
4063 struct cfg80211_registered_device *rdev;
4066 if (!info->attrs[NL80211_ATTR_TESTDATA])
4071 rdev = cfg80211_get_dev_from_info(info);
4073 err = PTR_ERR(rdev);
4078 if (rdev->ops->testmode_cmd) {
4079 rdev->testmode_info = info;
4080 err = rdev->ops->testmode_cmd(&rdev->wiphy,
4081 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
4082 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
4083 rdev->testmode_info = NULL;
4086 cfg80211_unlock_rdev(rdev);
4093 static struct sk_buff *
4094 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
4095 int approxlen, u32 pid, u32 seq, gfp_t gfp)
4097 struct sk_buff *skb;
4099 struct nlattr *data;
4101 skb = nlmsg_new(approxlen + 100, gfp);
4105 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE);
4111 NLA_PUT_U32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4112 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
4114 ((void **)skb->cb)[0] = rdev;
4115 ((void **)skb->cb)[1] = hdr;
4116 ((void **)skb->cb)[2] = data;
4125 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
4128 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
4130 if (WARN_ON(!rdev->testmode_info))
4133 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
4134 rdev->testmode_info->snd_pid,
4135 rdev->testmode_info->snd_seq,
4138 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
4140 int cfg80211_testmode_reply(struct sk_buff *skb)
4142 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
4143 void *hdr = ((void **)skb->cb)[1];
4144 struct nlattr *data = ((void **)skb->cb)[2];
4146 if (WARN_ON(!rdev->testmode_info)) {
4151 nla_nest_end(skb, data);
4152 genlmsg_end(skb, hdr);
4153 return genlmsg_reply(skb, rdev->testmode_info);
4155 EXPORT_SYMBOL(cfg80211_testmode_reply);
4157 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
4158 int approxlen, gfp_t gfp)
4160 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
4162 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
4164 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
4166 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
4168 void *hdr = ((void **)skb->cb)[1];
4169 struct nlattr *data = ((void **)skb->cb)[2];
4171 nla_nest_end(skb, data);
4172 genlmsg_end(skb, hdr);
4173 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
4175 EXPORT_SYMBOL(cfg80211_testmode_event);
4178 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
4180 struct cfg80211_registered_device *rdev;
4181 struct net_device *dev;
4182 struct cfg80211_connect_params connect;
4183 struct wiphy *wiphy;
4184 struct cfg80211_cached_keys *connkeys = NULL;
4187 memset(&connect, 0, sizeof(connect));
4189 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4192 if (!info->attrs[NL80211_ATTR_SSID] ||
4193 !nla_len(info->attrs[NL80211_ATTR_SSID]))
4196 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
4198 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
4199 if (!nl80211_valid_auth_type(connect.auth_type))
4202 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
4204 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
4206 err = nl80211_crypto_settings(info, &connect.crypto,
4207 NL80211_MAX_NR_CIPHER_SUITES);
4212 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4216 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
4221 if (!netif_running(dev)) {
4226 wiphy = &rdev->wiphy;
4228 if (info->attrs[NL80211_ATTR_MAC])
4229 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4230 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4231 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
4233 if (info->attrs[NL80211_ATTR_IE]) {
4234 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4235 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4238 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
4240 ieee80211_get_channel(wiphy,
4241 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
4242 if (!connect.channel ||
4243 connect.channel->flags & IEEE80211_CHAN_DISABLED) {
4249 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
4250 connkeys = nl80211_parse_connkeys(rdev,
4251 info->attrs[NL80211_ATTR_KEYS]);
4252 if (IS_ERR(connkeys)) {
4253 err = PTR_ERR(connkeys);
4259 err = cfg80211_connect(rdev, dev, &connect, connkeys);
4262 cfg80211_unlock_rdev(rdev);
4271 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
4273 struct cfg80211_registered_device *rdev;
4274 struct net_device *dev;
4278 if (!info->attrs[NL80211_ATTR_REASON_CODE])
4279 reason = WLAN_REASON_DEAUTH_LEAVING;
4281 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
4288 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4292 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
4297 if (!netif_running(dev)) {
4302 err = cfg80211_disconnect(rdev, dev, reason, true);
4305 cfg80211_unlock_rdev(rdev);
4312 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
4314 struct cfg80211_registered_device *rdev;
4319 if (!info->attrs[NL80211_ATTR_PID])
4322 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
4326 rdev = cfg80211_get_dev_from_info(info);
4328 err = PTR_ERR(rdev);
4332 net = get_net_ns_by_pid(pid);
4340 /* check if anything to do */
4341 if (net_eq(wiphy_net(&rdev->wiphy), net))
4344 err = cfg80211_switch_netns(rdev, net);
4348 cfg80211_unlock_rdev(rdev);
4354 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
4356 struct cfg80211_registered_device *rdev;
4357 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
4358 struct cfg80211_pmksa *pmksa) = NULL;
4360 struct net_device *dev;
4361 struct cfg80211_pmksa pmksa;
4363 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
4365 if (!info->attrs[NL80211_ATTR_MAC])
4368 if (!info->attrs[NL80211_ATTR_PMKID])
4373 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4377 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
4378 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4380 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
4385 switch (info->genlhdr->cmd) {
4386 case NL80211_CMD_SET_PMKSA:
4387 rdev_ops = rdev->ops->set_pmksa;
4389 case NL80211_CMD_DEL_PMKSA:
4390 rdev_ops = rdev->ops->del_pmksa;
4402 err = rdev_ops(&rdev->wiphy, dev, &pmksa);
4405 cfg80211_unlock_rdev(rdev);
4413 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
4415 struct cfg80211_registered_device *rdev;
4417 struct net_device *dev;
4421 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4425 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
4430 if (!rdev->ops->flush_pmksa) {
4435 err = rdev->ops->flush_pmksa(&rdev->wiphy, dev);
4438 cfg80211_unlock_rdev(rdev);
4447 static int nl80211_remain_on_channel(struct sk_buff *skb,
4448 struct genl_info *info)
4450 struct cfg80211_registered_device *rdev;
4451 struct net_device *dev;
4452 struct ieee80211_channel *chan;
4453 struct sk_buff *msg;
4456 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
4460 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
4461 !info->attrs[NL80211_ATTR_DURATION])
4464 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
4467 * We should be on that channel for at least one jiffie,
4468 * and more than 5 seconds seems excessive.
4470 if (!duration || !msecs_to_jiffies(duration) || duration > 5000)
4475 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4479 if (!rdev->ops->remain_on_channel) {
4484 if (!netif_running(dev)) {
4489 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
4490 channel_type = nla_get_u32(
4491 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
4492 if (channel_type != NL80211_CHAN_NO_HT &&
4493 channel_type != NL80211_CHAN_HT20 &&
4494 channel_type != NL80211_CHAN_HT40PLUS &&
4495 channel_type != NL80211_CHAN_HT40MINUS) {
4501 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
4502 chan = rdev_freq_to_chan(rdev, freq, channel_type);
4508 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4514 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
4515 NL80211_CMD_REMAIN_ON_CHANNEL);
4522 err = rdev->ops->remain_on_channel(&rdev->wiphy, dev, chan,
4523 channel_type, duration, &cookie);
4528 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, cookie);
4530 genlmsg_end(msg, hdr);
4531 err = genlmsg_reply(msg, info);
4539 cfg80211_unlock_rdev(rdev);
4546 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
4547 struct genl_info *info)
4549 struct cfg80211_registered_device *rdev;
4550 struct net_device *dev;
4554 if (!info->attrs[NL80211_ATTR_COOKIE])
4559 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4563 if (!rdev->ops->cancel_remain_on_channel) {
4568 if (!netif_running(dev)) {
4573 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
4575 err = rdev->ops->cancel_remain_on_channel(&rdev->wiphy, dev, cookie);
4578 cfg80211_unlock_rdev(rdev);
4585 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
4586 u8 *rates, u8 rates_len)
4591 for (i = 0; i < rates_len; i++) {
4592 int rate = (rates[i] & 0x7f) * 5;
4594 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
4595 struct ieee80211_rate *srate =
4596 &sband->bitrates[ridx];
4597 if (rate == srate->bitrate) {
4602 if (ridx == sband->n_bitrates)
4603 return 0; /* rate not found */
4609 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
4610 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
4611 .len = NL80211_MAX_SUPP_RATES },
4614 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
4615 struct genl_info *info)
4617 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
4618 struct cfg80211_registered_device *rdev;
4619 struct cfg80211_bitrate_mask mask;
4621 struct net_device *dev;
4622 struct nlattr *tx_rates;
4623 struct ieee80211_supported_band *sband;
4625 if (info->attrs[NL80211_ATTR_TX_RATES] == NULL)
4630 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4634 if (!rdev->ops->set_bitrate_mask) {
4639 memset(&mask, 0, sizeof(mask));
4640 /* Default to all rates enabled */
4641 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
4642 sband = rdev->wiphy.bands[i];
4643 mask.control[i].legacy =
4644 sband ? (1 << sband->n_bitrates) - 1 : 0;
4648 * The nested attribute uses enum nl80211_band as the index. This maps
4649 * directly to the enum ieee80211_band values used in cfg80211.
4651 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
4653 enum ieee80211_band band = nla_type(tx_rates);
4654 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
4658 sband = rdev->wiphy.bands[band];
4659 if (sband == NULL) {
4663 nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
4664 nla_len(tx_rates), nl80211_txattr_policy);
4665 if (tb[NL80211_TXRATE_LEGACY]) {
4666 mask.control[band].legacy = rateset_to_mask(
4668 nla_data(tb[NL80211_TXRATE_LEGACY]),
4669 nla_len(tb[NL80211_TXRATE_LEGACY]));
4670 if (mask.control[band].legacy == 0) {
4677 err = rdev->ops->set_bitrate_mask(&rdev->wiphy, dev, NULL, &mask);
4681 cfg80211_unlock_rdev(rdev);
4687 static int nl80211_register_action(struct sk_buff *skb, struct genl_info *info)
4689 struct cfg80211_registered_device *rdev;
4690 struct net_device *dev;
4693 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
4696 if (nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]) < 1)
4701 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4705 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4706 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
4711 /* not much point in registering if we can't reply */
4712 if (!rdev->ops->action) {
4717 err = cfg80211_mlme_register_action(dev->ieee80211_ptr, info->snd_pid,
4718 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
4719 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
4721 cfg80211_unlock_rdev(rdev);
4728 static int nl80211_action(struct sk_buff *skb, struct genl_info *info)
4730 struct cfg80211_registered_device *rdev;
4731 struct net_device *dev;
4732 struct ieee80211_channel *chan;
4733 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
4734 bool channel_type_valid = false;
4739 struct sk_buff *msg;
4741 if (!info->attrs[NL80211_ATTR_FRAME] ||
4742 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
4747 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4751 if (!rdev->ops->action) {
4756 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4757 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
4762 if (!netif_running(dev)) {
4767 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
4768 channel_type = nla_get_u32(
4769 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
4770 if (channel_type != NL80211_CHAN_NO_HT &&
4771 channel_type != NL80211_CHAN_HT20 &&
4772 channel_type != NL80211_CHAN_HT40PLUS &&
4773 channel_type != NL80211_CHAN_HT40MINUS) {
4777 channel_type_valid = true;
4780 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
4781 chan = rdev_freq_to_chan(rdev, freq, channel_type);
4787 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4793 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
4794 NL80211_CMD_ACTION);
4800 err = cfg80211_mlme_action(rdev, dev, chan, channel_type,
4802 nla_data(info->attrs[NL80211_ATTR_FRAME]),
4803 nla_len(info->attrs[NL80211_ATTR_FRAME]),
4808 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, cookie);
4810 genlmsg_end(msg, hdr);
4811 err = genlmsg_reply(msg, info);
4819 cfg80211_unlock_rdev(rdev);
4826 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
4828 struct cfg80211_registered_device *rdev;
4829 struct wireless_dev *wdev;
4830 struct net_device *dev;
4835 if (!info->attrs[NL80211_ATTR_PS_STATE]) {
4840 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
4842 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED) {
4849 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4853 wdev = dev->ieee80211_ptr;
4855 if (!rdev->ops->set_power_mgmt) {
4860 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
4862 if (state == wdev->ps)
4867 if (rdev->ops->set_power_mgmt(wdev->wiphy, dev, wdev->ps,
4869 /* assume this means it's off */
4873 cfg80211_unlock_rdev(rdev);
4881 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
4883 struct cfg80211_registered_device *rdev;
4884 enum nl80211_ps_state ps_state;
4885 struct wireless_dev *wdev;
4886 struct net_device *dev;
4887 struct sk_buff *msg;
4893 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4897 wdev = dev->ieee80211_ptr;
4899 if (!rdev->ops->set_power_mgmt) {
4904 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4910 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
4911 NL80211_CMD_GET_POWER_SAVE);
4918 ps_state = NL80211_PS_ENABLED;
4920 ps_state = NL80211_PS_DISABLED;
4922 NLA_PUT_U32(msg, NL80211_ATTR_PS_STATE, ps_state);
4924 genlmsg_end(msg, hdr);
4925 err = genlmsg_reply(msg, info);
4935 cfg80211_unlock_rdev(rdev);
4944 static struct nla_policy
4945 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] __read_mostly = {
4946 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
4947 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
4948 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
4951 static int nl80211_set_cqm_rssi(struct genl_info *info,
4952 s32 threshold, u32 hysteresis)
4954 struct cfg80211_registered_device *rdev;
4955 struct wireless_dev *wdev;
4956 struct net_device *dev;
4964 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
4968 wdev = dev->ieee80211_ptr;
4970 if (!rdev->ops->set_cqm_rssi_config) {
4975 if (wdev->iftype != NL80211_IFTYPE_STATION) {
4980 err = rdev->ops->set_cqm_rssi_config(wdev->wiphy, dev,
4981 threshold, hysteresis);
4984 cfg80211_unlock_rdev(rdev);
4991 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
4993 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
4997 cqm = info->attrs[NL80211_ATTR_CQM];
5003 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
5004 nl80211_attr_cqm_policy);
5008 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
5009 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
5012 threshold = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
5013 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
5014 err = nl80211_set_cqm_rssi(info, threshold, hysteresis);
5022 static struct genl_ops nl80211_ops[] = {
5024 .cmd = NL80211_CMD_GET_WIPHY,
5025 .doit = nl80211_get_wiphy,
5026 .dumpit = nl80211_dump_wiphy,
5027 .policy = nl80211_policy,
5028 /* can be retrieved by unprivileged users */
5031 .cmd = NL80211_CMD_SET_WIPHY,
5032 .doit = nl80211_set_wiphy,
5033 .policy = nl80211_policy,
5034 .flags = GENL_ADMIN_PERM,
5037 .cmd = NL80211_CMD_GET_INTERFACE,
5038 .doit = nl80211_get_interface,
5039 .dumpit = nl80211_dump_interface,
5040 .policy = nl80211_policy,
5041 /* can be retrieved by unprivileged users */
5044 .cmd = NL80211_CMD_SET_INTERFACE,
5045 .doit = nl80211_set_interface,
5046 .policy = nl80211_policy,
5047 .flags = GENL_ADMIN_PERM,
5050 .cmd = NL80211_CMD_NEW_INTERFACE,
5051 .doit = nl80211_new_interface,
5052 .policy = nl80211_policy,
5053 .flags = GENL_ADMIN_PERM,
5056 .cmd = NL80211_CMD_DEL_INTERFACE,
5057 .doit = nl80211_del_interface,
5058 .policy = nl80211_policy,
5059 .flags = GENL_ADMIN_PERM,
5062 .cmd = NL80211_CMD_GET_KEY,
5063 .doit = nl80211_get_key,
5064 .policy = nl80211_policy,
5065 .flags = GENL_ADMIN_PERM,
5068 .cmd = NL80211_CMD_SET_KEY,
5069 .doit = nl80211_set_key,
5070 .policy = nl80211_policy,
5071 .flags = GENL_ADMIN_PERM,
5074 .cmd = NL80211_CMD_NEW_KEY,
5075 .doit = nl80211_new_key,
5076 .policy = nl80211_policy,
5077 .flags = GENL_ADMIN_PERM,
5080 .cmd = NL80211_CMD_DEL_KEY,
5081 .doit = nl80211_del_key,
5082 .policy = nl80211_policy,
5083 .flags = GENL_ADMIN_PERM,
5086 .cmd = NL80211_CMD_SET_BEACON,
5087 .policy = nl80211_policy,
5088 .flags = GENL_ADMIN_PERM,
5089 .doit = nl80211_addset_beacon,
5092 .cmd = NL80211_CMD_NEW_BEACON,
5093 .policy = nl80211_policy,
5094 .flags = GENL_ADMIN_PERM,
5095 .doit = nl80211_addset_beacon,
5098 .cmd = NL80211_CMD_DEL_BEACON,
5099 .policy = nl80211_policy,
5100 .flags = GENL_ADMIN_PERM,
5101 .doit = nl80211_del_beacon,
5104 .cmd = NL80211_CMD_GET_STATION,
5105 .doit = nl80211_get_station,
5106 .dumpit = nl80211_dump_station,
5107 .policy = nl80211_policy,
5110 .cmd = NL80211_CMD_SET_STATION,
5111 .doit = nl80211_set_station,
5112 .policy = nl80211_policy,
5113 .flags = GENL_ADMIN_PERM,
5116 .cmd = NL80211_CMD_NEW_STATION,
5117 .doit = nl80211_new_station,
5118 .policy = nl80211_policy,
5119 .flags = GENL_ADMIN_PERM,
5122 .cmd = NL80211_CMD_DEL_STATION,
5123 .doit = nl80211_del_station,
5124 .policy = nl80211_policy,
5125 .flags = GENL_ADMIN_PERM,
5128 .cmd = NL80211_CMD_GET_MPATH,
5129 .doit = nl80211_get_mpath,
5130 .dumpit = nl80211_dump_mpath,
5131 .policy = nl80211_policy,
5132 .flags = GENL_ADMIN_PERM,
5135 .cmd = NL80211_CMD_SET_MPATH,
5136 .doit = nl80211_set_mpath,
5137 .policy = nl80211_policy,
5138 .flags = GENL_ADMIN_PERM,
5141 .cmd = NL80211_CMD_NEW_MPATH,
5142 .doit = nl80211_new_mpath,
5143 .policy = nl80211_policy,
5144 .flags = GENL_ADMIN_PERM,
5147 .cmd = NL80211_CMD_DEL_MPATH,
5148 .doit = nl80211_del_mpath,
5149 .policy = nl80211_policy,
5150 .flags = GENL_ADMIN_PERM,
5153 .cmd = NL80211_CMD_SET_BSS,
5154 .doit = nl80211_set_bss,
5155 .policy = nl80211_policy,
5156 .flags = GENL_ADMIN_PERM,
5159 .cmd = NL80211_CMD_GET_REG,
5160 .doit = nl80211_get_reg,
5161 .policy = nl80211_policy,
5162 /* can be retrieved by unprivileged users */
5165 .cmd = NL80211_CMD_SET_REG,
5166 .doit = nl80211_set_reg,
5167 .policy = nl80211_policy,
5168 .flags = GENL_ADMIN_PERM,
5171 .cmd = NL80211_CMD_REQ_SET_REG,
5172 .doit = nl80211_req_set_reg,
5173 .policy = nl80211_policy,
5174 .flags = GENL_ADMIN_PERM,
5177 .cmd = NL80211_CMD_GET_MESH_PARAMS,
5178 .doit = nl80211_get_mesh_params,
5179 .policy = nl80211_policy,
5180 /* can be retrieved by unprivileged users */
5183 .cmd = NL80211_CMD_SET_MESH_PARAMS,
5184 .doit = nl80211_set_mesh_params,
5185 .policy = nl80211_policy,
5186 .flags = GENL_ADMIN_PERM,
5189 .cmd = NL80211_CMD_TRIGGER_SCAN,
5190 .doit = nl80211_trigger_scan,
5191 .policy = nl80211_policy,
5192 .flags = GENL_ADMIN_PERM,
5195 .cmd = NL80211_CMD_GET_SCAN,
5196 .policy = nl80211_policy,
5197 .dumpit = nl80211_dump_scan,
5200 .cmd = NL80211_CMD_AUTHENTICATE,
5201 .doit = nl80211_authenticate,
5202 .policy = nl80211_policy,
5203 .flags = GENL_ADMIN_PERM,
5206 .cmd = NL80211_CMD_ASSOCIATE,
5207 .doit = nl80211_associate,
5208 .policy = nl80211_policy,
5209 .flags = GENL_ADMIN_PERM,
5212 .cmd = NL80211_CMD_DEAUTHENTICATE,
5213 .doit = nl80211_deauthenticate,
5214 .policy = nl80211_policy,
5215 .flags = GENL_ADMIN_PERM,
5218 .cmd = NL80211_CMD_DISASSOCIATE,
5219 .doit = nl80211_disassociate,
5220 .policy = nl80211_policy,
5221 .flags = GENL_ADMIN_PERM,
5224 .cmd = NL80211_CMD_JOIN_IBSS,
5225 .doit = nl80211_join_ibss,
5226 .policy = nl80211_policy,
5227 .flags = GENL_ADMIN_PERM,
5230 .cmd = NL80211_CMD_LEAVE_IBSS,
5231 .doit = nl80211_leave_ibss,
5232 .policy = nl80211_policy,
5233 .flags = GENL_ADMIN_PERM,
5235 #ifdef CONFIG_NL80211_TESTMODE
5237 .cmd = NL80211_CMD_TESTMODE,
5238 .doit = nl80211_testmode_do,
5239 .policy = nl80211_policy,
5240 .flags = GENL_ADMIN_PERM,
5244 .cmd = NL80211_CMD_CONNECT,
5245 .doit = nl80211_connect,
5246 .policy = nl80211_policy,
5247 .flags = GENL_ADMIN_PERM,
5250 .cmd = NL80211_CMD_DISCONNECT,
5251 .doit = nl80211_disconnect,
5252 .policy = nl80211_policy,
5253 .flags = GENL_ADMIN_PERM,
5256 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
5257 .doit = nl80211_wiphy_netns,
5258 .policy = nl80211_policy,
5259 .flags = GENL_ADMIN_PERM,
5262 .cmd = NL80211_CMD_GET_SURVEY,
5263 .policy = nl80211_policy,
5264 .dumpit = nl80211_dump_survey,
5267 .cmd = NL80211_CMD_SET_PMKSA,
5268 .doit = nl80211_setdel_pmksa,
5269 .policy = nl80211_policy,
5270 .flags = GENL_ADMIN_PERM,
5273 .cmd = NL80211_CMD_DEL_PMKSA,
5274 .doit = nl80211_setdel_pmksa,
5275 .policy = nl80211_policy,
5276 .flags = GENL_ADMIN_PERM,
5279 .cmd = NL80211_CMD_FLUSH_PMKSA,
5280 .doit = nl80211_flush_pmksa,
5281 .policy = nl80211_policy,
5282 .flags = GENL_ADMIN_PERM,
5285 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
5286 .doit = nl80211_remain_on_channel,
5287 .policy = nl80211_policy,
5288 .flags = GENL_ADMIN_PERM,
5291 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
5292 .doit = nl80211_cancel_remain_on_channel,
5293 .policy = nl80211_policy,
5294 .flags = GENL_ADMIN_PERM,
5297 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
5298 .doit = nl80211_set_tx_bitrate_mask,
5299 .policy = nl80211_policy,
5300 .flags = GENL_ADMIN_PERM,
5303 .cmd = NL80211_CMD_REGISTER_ACTION,
5304 .doit = nl80211_register_action,
5305 .policy = nl80211_policy,
5306 .flags = GENL_ADMIN_PERM,
5309 .cmd = NL80211_CMD_ACTION,
5310 .doit = nl80211_action,
5311 .policy = nl80211_policy,
5312 .flags = GENL_ADMIN_PERM,
5315 .cmd = NL80211_CMD_SET_POWER_SAVE,
5316 .doit = nl80211_set_power_save,
5317 .policy = nl80211_policy,
5318 .flags = GENL_ADMIN_PERM,
5321 .cmd = NL80211_CMD_GET_POWER_SAVE,
5322 .doit = nl80211_get_power_save,
5323 .policy = nl80211_policy,
5324 /* can be retrieved by unprivileged users */
5327 .cmd = NL80211_CMD_SET_CQM,
5328 .doit = nl80211_set_cqm,
5329 .policy = nl80211_policy,
5330 .flags = GENL_ADMIN_PERM,
5333 .cmd = NL80211_CMD_SET_CHANNEL,
5334 .doit = nl80211_set_channel,
5335 .policy = nl80211_policy,
5336 .flags = GENL_ADMIN_PERM,
5340 static struct genl_multicast_group nl80211_mlme_mcgrp = {
5344 /* multicast groups */
5345 static struct genl_multicast_group nl80211_config_mcgrp = {
5348 static struct genl_multicast_group nl80211_scan_mcgrp = {
5351 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
5352 .name = "regulatory",
5355 /* notification functions */
5357 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
5359 struct sk_buff *msg;
5361 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5365 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
5370 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5371 nl80211_config_mcgrp.id, GFP_KERNEL);
5374 static int nl80211_add_scan_req(struct sk_buff *msg,
5375 struct cfg80211_registered_device *rdev)
5377 struct cfg80211_scan_request *req = rdev->scan_req;
5378 struct nlattr *nest;
5381 ASSERT_RDEV_LOCK(rdev);
5386 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
5388 goto nla_put_failure;
5389 for (i = 0; i < req->n_ssids; i++)
5390 NLA_PUT(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid);
5391 nla_nest_end(msg, nest);
5393 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
5395 goto nla_put_failure;
5396 for (i = 0; i < req->n_channels; i++)
5397 NLA_PUT_U32(msg, i, req->channels[i]->center_freq);
5398 nla_nest_end(msg, nest);
5401 NLA_PUT(msg, NL80211_ATTR_IE, req->ie_len, req->ie);
5408 static int nl80211_send_scan_msg(struct sk_buff *msg,
5409 struct cfg80211_registered_device *rdev,
5410 struct net_device *netdev,
5411 u32 pid, u32 seq, int flags,
5416 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
5420 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5421 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5423 /* ignore errors and send incomplete event anyway */
5424 nl80211_add_scan_req(msg, rdev);
5426 return genlmsg_end(msg, hdr);
5429 genlmsg_cancel(msg, hdr);
5433 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
5434 struct net_device *netdev)
5436 struct sk_buff *msg;
5438 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
5442 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
5443 NL80211_CMD_TRIGGER_SCAN) < 0) {
5448 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5449 nl80211_scan_mcgrp.id, GFP_KERNEL);
5452 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
5453 struct net_device *netdev)
5455 struct sk_buff *msg;
5457 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5461 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
5462 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
5467 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5468 nl80211_scan_mcgrp.id, GFP_KERNEL);
5471 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
5472 struct net_device *netdev)
5474 struct sk_buff *msg;
5476 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5480 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
5481 NL80211_CMD_SCAN_ABORTED) < 0) {
5486 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5487 nl80211_scan_mcgrp.id, GFP_KERNEL);
5491 * This can happen on global regulatory changes or device specific settings
5492 * based on custom world regulatory domains.
5494 void nl80211_send_reg_change_event(struct regulatory_request *request)
5496 struct sk_buff *msg;
5499 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5503 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
5509 /* Userspace can always count this one always being set */
5510 NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator);
5512 if (request->alpha2[0] == '0' && request->alpha2[1] == '0')
5513 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
5514 NL80211_REGDOM_TYPE_WORLD);
5515 else if (request->alpha2[0] == '9' && request->alpha2[1] == '9')
5516 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
5517 NL80211_REGDOM_TYPE_CUSTOM_WORLD);
5518 else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
5520 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
5521 NL80211_REGDOM_TYPE_INTERSECTION);
5523 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
5524 NL80211_REGDOM_TYPE_COUNTRY);
5525 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2);
5528 if (wiphy_idx_valid(request->wiphy_idx))
5529 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx);
5531 if (genlmsg_end(msg, hdr) < 0) {
5537 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
5544 genlmsg_cancel(msg, hdr);
5548 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
5549 struct net_device *netdev,
5550 const u8 *buf, size_t len,
5551 enum nl80211_commands cmd, gfp_t gfp)
5553 struct sk_buff *msg;
5556 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5560 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
5566 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5567 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5568 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
5570 if (genlmsg_end(msg, hdr) < 0) {
5575 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5576 nl80211_mlme_mcgrp.id, gfp);
5580 genlmsg_cancel(msg, hdr);
5584 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
5585 struct net_device *netdev, const u8 *buf,
5586 size_t len, gfp_t gfp)
5588 nl80211_send_mlme_event(rdev, netdev, buf, len,
5589 NL80211_CMD_AUTHENTICATE, gfp);
5592 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
5593 struct net_device *netdev, const u8 *buf,
5594 size_t len, gfp_t gfp)
5596 nl80211_send_mlme_event(rdev, netdev, buf, len,
5597 NL80211_CMD_ASSOCIATE, gfp);
5600 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
5601 struct net_device *netdev, const u8 *buf,
5602 size_t len, gfp_t gfp)
5604 nl80211_send_mlme_event(rdev, netdev, buf, len,
5605 NL80211_CMD_DEAUTHENTICATE, gfp);
5608 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
5609 struct net_device *netdev, const u8 *buf,
5610 size_t len, gfp_t gfp)
5612 nl80211_send_mlme_event(rdev, netdev, buf, len,
5613 NL80211_CMD_DISASSOCIATE, gfp);
5616 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
5617 struct net_device *netdev, int cmd,
5618 const u8 *addr, gfp_t gfp)
5620 struct sk_buff *msg;
5623 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5627 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
5633 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5634 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5635 NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT);
5636 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
5638 if (genlmsg_end(msg, hdr) < 0) {
5643 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5644 nl80211_mlme_mcgrp.id, gfp);
5648 genlmsg_cancel(msg, hdr);
5652 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
5653 struct net_device *netdev, const u8 *addr,
5656 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
5660 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
5661 struct net_device *netdev, const u8 *addr,
5664 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
5668 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
5669 struct net_device *netdev, const u8 *bssid,
5670 const u8 *req_ie, size_t req_ie_len,
5671 const u8 *resp_ie, size_t resp_ie_len,
5672 u16 status, gfp_t gfp)
5674 struct sk_buff *msg;
5677 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
5681 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
5687 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5688 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5690 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
5691 NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status);
5693 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
5695 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
5697 if (genlmsg_end(msg, hdr) < 0) {
5702 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5703 nl80211_mlme_mcgrp.id, gfp);
5707 genlmsg_cancel(msg, hdr);
5712 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
5713 struct net_device *netdev, const u8 *bssid,
5714 const u8 *req_ie, size_t req_ie_len,
5715 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
5717 struct sk_buff *msg;
5720 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
5724 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
5730 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5731 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5732 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
5734 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
5736 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
5738 if (genlmsg_end(msg, hdr) < 0) {
5743 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5744 nl80211_mlme_mcgrp.id, gfp);
5748 genlmsg_cancel(msg, hdr);
5753 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
5754 struct net_device *netdev, u16 reason,
5755 const u8 *ie, size_t ie_len, bool from_ap)
5757 struct sk_buff *msg;
5760 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
5764 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
5770 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5771 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5772 if (from_ap && reason)
5773 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason);
5775 NLA_PUT_FLAG(msg, NL80211_ATTR_DISCONNECTED_BY_AP);
5777 NLA_PUT(msg, NL80211_ATTR_IE, ie_len, ie);
5779 if (genlmsg_end(msg, hdr) < 0) {
5784 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5785 nl80211_mlme_mcgrp.id, GFP_KERNEL);
5789 genlmsg_cancel(msg, hdr);
5794 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
5795 struct net_device *netdev, const u8 *bssid,
5798 struct sk_buff *msg;
5801 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5805 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
5811 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5812 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5813 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
5815 if (genlmsg_end(msg, hdr) < 0) {
5820 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5821 nl80211_mlme_mcgrp.id, gfp);
5825 genlmsg_cancel(msg, hdr);
5829 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
5830 struct net_device *netdev, const u8 *addr,
5831 enum nl80211_key_type key_type, int key_id,
5832 const u8 *tsc, gfp_t gfp)
5834 struct sk_buff *msg;
5837 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5841 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
5847 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5848 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5850 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
5851 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
5852 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
5854 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
5856 if (genlmsg_end(msg, hdr) < 0) {
5861 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5862 nl80211_mlme_mcgrp.id, gfp);
5866 genlmsg_cancel(msg, hdr);
5870 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
5871 struct ieee80211_channel *channel_before,
5872 struct ieee80211_channel *channel_after)
5874 struct sk_buff *msg;
5876 struct nlattr *nl_freq;
5878 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
5882 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
5889 * Since we are applying the beacon hint to a wiphy we know its
5890 * wiphy_idx is valid
5892 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy));
5895 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
5897 goto nla_put_failure;
5898 if (nl80211_msg_put_channel(msg, channel_before))
5899 goto nla_put_failure;
5900 nla_nest_end(msg, nl_freq);
5903 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
5905 goto nla_put_failure;
5906 if (nl80211_msg_put_channel(msg, channel_after))
5907 goto nla_put_failure;
5908 nla_nest_end(msg, nl_freq);
5910 if (genlmsg_end(msg, hdr) < 0) {
5916 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
5923 genlmsg_cancel(msg, hdr);
5927 static void nl80211_send_remain_on_chan_event(
5928 int cmd, struct cfg80211_registered_device *rdev,
5929 struct net_device *netdev, u64 cookie,
5930 struct ieee80211_channel *chan,
5931 enum nl80211_channel_type channel_type,
5932 unsigned int duration, gfp_t gfp)
5934 struct sk_buff *msg;
5937 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
5941 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
5947 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
5948 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
5949 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq);
5950 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, channel_type);
5951 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, cookie);
5953 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL)
5954 NLA_PUT_U32(msg, NL80211_ATTR_DURATION, duration);
5956 if (genlmsg_end(msg, hdr) < 0) {
5961 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
5962 nl80211_mlme_mcgrp.id, gfp);
5966 genlmsg_cancel(msg, hdr);
5970 void nl80211_send_remain_on_channel(struct cfg80211_registered_device *rdev,
5971 struct net_device *netdev, u64 cookie,
5972 struct ieee80211_channel *chan,
5973 enum nl80211_channel_type channel_type,
5974 unsigned int duration, gfp_t gfp)
5976 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
5977 rdev, netdev, cookie, chan,
5978 channel_type, duration, gfp);
5981 void nl80211_send_remain_on_channel_cancel(
5982 struct cfg80211_registered_device *rdev, struct net_device *netdev,
5983 u64 cookie, struct ieee80211_channel *chan,
5984 enum nl80211_channel_type channel_type, gfp_t gfp)
5986 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
5987 rdev, netdev, cookie, chan,
5988 channel_type, 0, gfp);
5991 void nl80211_send_sta_event(struct cfg80211_registered_device *rdev,
5992 struct net_device *dev, const u8 *mac_addr,
5993 struct station_info *sinfo, gfp_t gfp)
5995 struct sk_buff *msg;
5997 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
6001 if (nl80211_send_station(msg, 0, 0, 0, dev, mac_addr, sinfo) < 0) {
6006 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
6007 nl80211_mlme_mcgrp.id, gfp);
6010 int nl80211_send_action(struct cfg80211_registered_device *rdev,
6011 struct net_device *netdev, u32 nlpid,
6012 int freq, const u8 *buf, size_t len, gfp_t gfp)
6014 struct sk_buff *msg;
6018 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
6022 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ACTION);
6028 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
6029 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
6030 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FREQ, freq);
6031 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
6033 err = genlmsg_end(msg, hdr);
6039 err = genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
6045 genlmsg_cancel(msg, hdr);
6050 void nl80211_send_action_tx_status(struct cfg80211_registered_device *rdev,
6051 struct net_device *netdev, u64 cookie,
6052 const u8 *buf, size_t len, bool ack,
6055 struct sk_buff *msg;
6058 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
6062 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ACTION_TX_STATUS);
6068 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
6069 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
6070 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
6071 NLA_PUT_U64(msg, NL80211_ATTR_COOKIE, cookie);
6073 NLA_PUT_FLAG(msg, NL80211_ATTR_ACK);
6075 if (genlmsg_end(msg, hdr) < 0) {
6080 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
6084 genlmsg_cancel(msg, hdr);
6089 nl80211_send_cqm_rssi_notify(struct cfg80211_registered_device *rdev,
6090 struct net_device *netdev,
6091 enum nl80211_cqm_rssi_threshold_event rssi_event,
6094 struct sk_buff *msg;
6095 struct nlattr *pinfoattr;
6098 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
6102 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
6108 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
6109 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
6111 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
6113 goto nla_put_failure;
6115 NLA_PUT_U32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
6118 nla_nest_end(msg, pinfoattr);
6120 if (genlmsg_end(msg, hdr) < 0) {
6125 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
6126 nl80211_mlme_mcgrp.id, gfp);
6130 genlmsg_cancel(msg, hdr);
6134 static int nl80211_netlink_notify(struct notifier_block * nb,
6135 unsigned long state,
6138 struct netlink_notify *notify = _notify;
6139 struct cfg80211_registered_device *rdev;
6140 struct wireless_dev *wdev;
6142 if (state != NETLINK_URELEASE)
6147 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list)
6148 list_for_each_entry_rcu(wdev, &rdev->netdev_list, list)
6149 cfg80211_mlme_unregister_actions(wdev, notify->pid);
6156 static struct notifier_block nl80211_netlink_notifier = {
6157 .notifier_call = nl80211_netlink_notify,
6160 /* initialisation/exit functions */
6162 int nl80211_init(void)
6166 err = genl_register_family_with_ops(&nl80211_fam,
6167 nl80211_ops, ARRAY_SIZE(nl80211_ops));
6171 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
6175 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
6179 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
6183 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
6187 #ifdef CONFIG_NL80211_TESTMODE
6188 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
6193 err = netlink_register_notifier(&nl80211_netlink_notifier);
6199 genl_unregister_family(&nl80211_fam);
6203 void nl80211_exit(void)
6205 netlink_unregister_notifier(&nl80211_netlink_notifier);
6206 genl_unregister_family(&nl80211_fam);