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 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type);
27 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
28 struct genl_info *info,
29 struct cfg80211_crypto_settings *settings,
32 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
33 struct genl_info *info);
34 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
35 struct genl_info *info);
37 /* the netlink family */
38 static struct genl_family nl80211_fam = {
39 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
40 .name = "nl80211", /* have users key off the name instead */
41 .hdrsize = 0, /* no private header */
42 .version = 1, /* no particular meaning now */
43 .maxattr = NL80211_ATTR_MAX,
45 .pre_doit = nl80211_pre_doit,
46 .post_doit = nl80211_post_doit,
49 /* internal helper: get rdev and dev */
50 static int get_rdev_dev_by_ifindex(struct net *netns, struct nlattr **attrs,
51 struct cfg80211_registered_device **rdev,
52 struct net_device **dev)
56 if (!attrs[NL80211_ATTR_IFINDEX])
59 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
60 *dev = dev_get_by_index(netns, ifindex);
64 *rdev = cfg80211_get_dev_from_ifindex(netns, ifindex);
67 return PTR_ERR(*rdev);
73 /* policy for the attributes */
74 static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
75 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
76 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
78 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
79 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
80 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
81 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
82 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
83 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
84 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
85 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
87 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
88 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
89 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
91 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
92 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
94 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
95 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
96 .len = WLAN_MAX_KEY_LEN },
97 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
98 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
99 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
100 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
101 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
103 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
104 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
105 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
106 .len = IEEE80211_MAX_DATA_LEN },
107 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
108 .len = IEEE80211_MAX_DATA_LEN },
109 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
110 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
111 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
112 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
113 .len = NL80211_MAX_SUPP_RATES },
114 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
115 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
116 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
117 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
118 .len = IEEE80211_MAX_MESH_ID_LEN },
119 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
121 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
122 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
124 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
125 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
126 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
127 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
128 .len = NL80211_MAX_SUPP_RATES },
129 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
131 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
132 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
134 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
136 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
137 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
138 .len = IEEE80211_MAX_DATA_LEN },
139 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
140 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
142 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
143 .len = IEEE80211_MAX_SSID_LEN },
144 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
145 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
146 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
147 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
148 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
149 [NL80211_ATTR_STA_FLAGS2] = {
150 .len = sizeof(struct nl80211_sta_flag_update),
152 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
153 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
154 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
155 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
156 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
157 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
158 [NL80211_ATTR_PID] = { .type = NLA_U32 },
159 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
160 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
161 .len = WLAN_PMKID_LEN },
162 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
163 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
164 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
165 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
166 .len = IEEE80211_MAX_DATA_LEN },
167 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
168 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
169 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
170 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
171 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
172 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
173 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
174 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
175 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
176 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
177 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
178 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
179 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
180 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
181 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
182 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
183 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
184 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
185 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
186 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
187 .len = IEEE80211_MAX_DATA_LEN },
188 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
189 .len = IEEE80211_MAX_DATA_LEN },
190 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
191 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
192 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
193 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
194 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
195 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
196 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
197 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
198 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
199 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
200 .len = IEEE80211_MAX_DATA_LEN },
201 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
202 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
203 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
204 .len = NL80211_HT_CAPABILITY_LEN
206 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
207 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
208 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
211 /* policy for the key attributes */
212 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
213 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
214 [NL80211_KEY_IDX] = { .type = NLA_U8 },
215 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
216 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
217 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
218 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
219 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
220 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
223 /* policy for the key default flags */
224 static const struct nla_policy
225 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
226 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
227 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
230 /* policy for WoWLAN attributes */
231 static const struct nla_policy
232 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
233 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
234 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
235 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
236 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
237 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
238 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
239 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
240 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
243 /* policy for GTK rekey offload attributes */
244 static const struct nla_policy
245 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
246 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
247 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
248 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
251 static const struct nla_policy
252 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
253 [NL80211_ATTR_SCHED_SCAN_MATCH_SSID] = { .type = NLA_BINARY,
254 .len = IEEE80211_MAX_SSID_LEN },
257 /* ifidx get helper */
258 static int nl80211_get_ifidx(struct netlink_callback *cb)
262 res = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
263 nl80211_fam.attrbuf, nl80211_fam.maxattr,
268 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
271 res = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
277 static int nl80211_prepare_netdev_dump(struct sk_buff *skb,
278 struct netlink_callback *cb,
279 struct cfg80211_registered_device **rdev,
280 struct net_device **dev)
282 int ifidx = cb->args[0];
286 ifidx = nl80211_get_ifidx(cb);
294 *dev = __dev_get_by_index(sock_net(skb->sk), ifidx);
300 *rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
302 err = PTR_ERR(*rdev);
312 static void nl80211_finish_netdev_dump(struct cfg80211_registered_device *rdev)
314 cfg80211_unlock_rdev(rdev);
319 static bool is_valid_ie_attr(const struct nlattr *attr)
327 pos = nla_data(attr);
348 /* message building helper */
349 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
352 /* since there is no private header just add the generic one */
353 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
356 static int nl80211_msg_put_channel(struct sk_buff *msg,
357 struct ieee80211_channel *chan)
359 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
361 goto nla_put_failure;
363 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
364 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
365 goto nla_put_failure;
366 if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
367 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN))
368 goto nla_put_failure;
369 if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
370 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
371 goto nla_put_failure;
372 if ((chan->flags & IEEE80211_CHAN_RADAR) &&
373 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
374 goto nla_put_failure;
376 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
377 DBM_TO_MBM(chan->max_power)))
378 goto nla_put_failure;
386 /* netlink command implementations */
393 bool def_uni, def_multi;
396 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
398 struct nlattr *tb[NL80211_KEY_MAX + 1];
399 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
404 k->def = !!tb[NL80211_KEY_DEFAULT];
405 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
414 if (tb[NL80211_KEY_IDX])
415 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
417 if (tb[NL80211_KEY_DATA]) {
418 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
419 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
422 if (tb[NL80211_KEY_SEQ]) {
423 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
424 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
427 if (tb[NL80211_KEY_CIPHER])
428 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
430 if (tb[NL80211_KEY_TYPE]) {
431 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
432 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
436 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
437 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
438 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
439 tb[NL80211_KEY_DEFAULT_TYPES],
440 nl80211_key_default_policy);
444 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
445 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
451 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
453 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
454 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
455 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
458 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
459 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
460 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
463 if (info->attrs[NL80211_ATTR_KEY_IDX])
464 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
466 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
467 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
469 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
470 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
479 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
480 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
481 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
485 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
486 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
487 int err = nla_parse_nested(
488 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
489 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
490 nl80211_key_default_policy);
494 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
495 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
501 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
505 memset(k, 0, sizeof(*k));
509 if (info->attrs[NL80211_ATTR_KEY])
510 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
512 err = nl80211_parse_key_old(info, k);
517 if (k->def && k->defmgmt)
521 if (k->def_uni || !k->def_multi)
527 if (k->idx < 4 || k->idx > 5)
530 if (k->idx < 0 || k->idx > 3)
533 if (k->idx < 0 || k->idx > 5)
541 static struct cfg80211_cached_keys *
542 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
545 struct key_parse parse;
547 struct cfg80211_cached_keys *result;
548 int rem, err, def = 0;
550 result = kzalloc(sizeof(*result), GFP_KERNEL);
552 return ERR_PTR(-ENOMEM);
555 result->defmgmt = -1;
557 nla_for_each_nested(key, keys, rem) {
558 memset(&parse, 0, sizeof(parse));
561 err = nl80211_parse_key_new(key, &parse);
567 if (parse.idx < 0 || parse.idx > 4)
573 result->def = parse.idx;
574 if (!parse.def_uni || !parse.def_multi)
576 } else if (parse.defmgmt)
578 err = cfg80211_validate_key_settings(rdev, &parse.p,
579 parse.idx, false, NULL);
582 result->params[parse.idx].cipher = parse.p.cipher;
583 result->params[parse.idx].key_len = parse.p.key_len;
584 result->params[parse.idx].key = result->data[parse.idx];
585 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
594 static int nl80211_key_allowed(struct wireless_dev *wdev)
596 ASSERT_WDEV_LOCK(wdev);
598 switch (wdev->iftype) {
599 case NL80211_IFTYPE_AP:
600 case NL80211_IFTYPE_AP_VLAN:
601 case NL80211_IFTYPE_P2P_GO:
602 case NL80211_IFTYPE_MESH_POINT:
604 case NL80211_IFTYPE_ADHOC:
605 if (!wdev->current_bss)
608 case NL80211_IFTYPE_STATION:
609 case NL80211_IFTYPE_P2P_CLIENT:
610 if (wdev->sme_state != CFG80211_SME_CONNECTED)
620 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
622 struct nlattr *nl_modes = nla_nest_start(msg, attr);
626 goto nla_put_failure;
630 if ((ifmodes & 1) && nla_put_flag(msg, i))
631 goto nla_put_failure;
636 nla_nest_end(msg, nl_modes);
643 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
646 struct nlattr *nl_combis;
649 nl_combis = nla_nest_start(msg,
650 NL80211_ATTR_INTERFACE_COMBINATIONS);
652 goto nla_put_failure;
654 for (i = 0; i < wiphy->n_iface_combinations; i++) {
655 const struct ieee80211_iface_combination *c;
656 struct nlattr *nl_combi, *nl_limits;
658 c = &wiphy->iface_combinations[i];
660 nl_combi = nla_nest_start(msg, i + 1);
662 goto nla_put_failure;
664 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
666 goto nla_put_failure;
668 for (j = 0; j < c->n_limits; j++) {
669 struct nlattr *nl_limit;
671 nl_limit = nla_nest_start(msg, j + 1);
673 goto nla_put_failure;
674 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
676 goto nla_put_failure;
677 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
679 goto nla_put_failure;
680 nla_nest_end(msg, nl_limit);
683 nla_nest_end(msg, nl_limits);
685 if (c->beacon_int_infra_match &&
686 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
687 goto nla_put_failure;
688 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
689 c->num_different_channels) ||
690 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
692 goto nla_put_failure;
694 nla_nest_end(msg, nl_combi);
697 nla_nest_end(msg, nl_combis);
704 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
705 struct cfg80211_registered_device *dev)
708 struct nlattr *nl_bands, *nl_band;
709 struct nlattr *nl_freqs, *nl_freq;
710 struct nlattr *nl_rates, *nl_rate;
711 struct nlattr *nl_cmds;
712 enum ieee80211_band band;
713 struct ieee80211_channel *chan;
714 struct ieee80211_rate *rate;
716 const struct ieee80211_txrx_stypes *mgmt_stypes =
717 dev->wiphy.mgmt_stypes;
719 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
723 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx) ||
724 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy)) ||
725 nla_put_u32(msg, NL80211_ATTR_GENERATION,
726 cfg80211_rdev_list_generation) ||
727 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
728 dev->wiphy.retry_short) ||
729 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
730 dev->wiphy.retry_long) ||
731 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
732 dev->wiphy.frag_threshold) ||
733 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
734 dev->wiphy.rts_threshold) ||
735 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
736 dev->wiphy.coverage_class) ||
737 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
738 dev->wiphy.max_scan_ssids) ||
739 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
740 dev->wiphy.max_sched_scan_ssids) ||
741 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
742 dev->wiphy.max_scan_ie_len) ||
743 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
744 dev->wiphy.max_sched_scan_ie_len) ||
745 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
746 dev->wiphy.max_match_sets))
747 goto nla_put_failure;
749 if ((dev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
750 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
751 goto nla_put_failure;
752 if ((dev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
753 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
754 goto nla_put_failure;
755 if ((dev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
756 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
757 goto nla_put_failure;
758 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
759 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
760 goto nla_put_failure;
761 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
762 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
763 goto nla_put_failure;
764 if ((dev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
765 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
766 goto nla_put_failure;
768 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
769 sizeof(u32) * dev->wiphy.n_cipher_suites,
770 dev->wiphy.cipher_suites))
771 goto nla_put_failure;
773 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
774 dev->wiphy.max_num_pmkids))
775 goto nla_put_failure;
777 if ((dev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
778 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
779 goto nla_put_failure;
781 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
782 dev->wiphy.available_antennas_tx) ||
783 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
784 dev->wiphy.available_antennas_rx))
785 goto nla_put_failure;
787 if ((dev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
788 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
789 dev->wiphy.probe_resp_offload))
790 goto nla_put_failure;
792 if ((dev->wiphy.available_antennas_tx ||
793 dev->wiphy.available_antennas_rx) && dev->ops->get_antenna) {
794 u32 tx_ant = 0, rx_ant = 0;
796 res = dev->ops->get_antenna(&dev->wiphy, &tx_ant, &rx_ant);
798 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_TX,
800 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_RX,
802 goto nla_put_failure;
806 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
807 dev->wiphy.interface_modes))
808 goto nla_put_failure;
810 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
812 goto nla_put_failure;
814 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
815 if (!dev->wiphy.bands[band])
818 nl_band = nla_nest_start(msg, band);
820 goto nla_put_failure;
823 if (dev->wiphy.bands[band]->ht_cap.ht_supported &&
824 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
825 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
826 &dev->wiphy.bands[band]->ht_cap.mcs) ||
827 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
828 dev->wiphy.bands[band]->ht_cap.cap) ||
829 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
830 dev->wiphy.bands[band]->ht_cap.ampdu_factor) ||
831 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
832 dev->wiphy.bands[band]->ht_cap.ampdu_density)))
833 goto nla_put_failure;
835 /* add frequencies */
836 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
838 goto nla_put_failure;
840 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
841 nl_freq = nla_nest_start(msg, i);
843 goto nla_put_failure;
845 chan = &dev->wiphy.bands[band]->channels[i];
847 if (nl80211_msg_put_channel(msg, chan))
848 goto nla_put_failure;
850 nla_nest_end(msg, nl_freq);
853 nla_nest_end(msg, nl_freqs);
856 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
858 goto nla_put_failure;
860 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
861 nl_rate = nla_nest_start(msg, i);
863 goto nla_put_failure;
865 rate = &dev->wiphy.bands[band]->bitrates[i];
866 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
868 goto nla_put_failure;
869 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
871 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
872 goto nla_put_failure;
874 nla_nest_end(msg, nl_rate);
877 nla_nest_end(msg, nl_rates);
879 nla_nest_end(msg, nl_band);
881 nla_nest_end(msg, nl_bands);
883 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
885 goto nla_put_failure;
890 if (dev->ops->op) { \
892 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
893 goto nla_put_failure; \
897 CMD(add_virtual_intf, NEW_INTERFACE);
898 CMD(change_virtual_intf, SET_INTERFACE);
899 CMD(add_key, NEW_KEY);
900 CMD(start_ap, START_AP);
901 CMD(add_station, NEW_STATION);
902 CMD(add_mpath, NEW_MPATH);
903 CMD(update_mesh_config, SET_MESH_CONFIG);
904 CMD(change_bss, SET_BSS);
905 CMD(auth, AUTHENTICATE);
906 CMD(assoc, ASSOCIATE);
907 CMD(deauth, DEAUTHENTICATE);
908 CMD(disassoc, DISASSOCIATE);
909 CMD(join_ibss, JOIN_IBSS);
910 CMD(join_mesh, JOIN_MESH);
911 CMD(set_pmksa, SET_PMKSA);
912 CMD(del_pmksa, DEL_PMKSA);
913 CMD(flush_pmksa, FLUSH_PMKSA);
914 if (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
915 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
916 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
918 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
919 if (dev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
921 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
922 goto nla_put_failure;
924 if (dev->ops->set_monitor_channel || dev->ops->start_ap ||
925 dev->ops->join_mesh) {
927 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
928 goto nla_put_failure;
930 CMD(set_wds_peer, SET_WDS_PEER);
931 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
932 CMD(tdls_mgmt, TDLS_MGMT);
933 CMD(tdls_oper, TDLS_OPER);
935 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
936 CMD(sched_scan_start, START_SCHED_SCAN);
937 CMD(probe_client, PROBE_CLIENT);
938 CMD(set_noack_map, SET_NOACK_MAP);
939 if (dev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
941 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
942 goto nla_put_failure;
945 #ifdef CONFIG_NL80211_TESTMODE
946 CMD(testmode_cmd, TESTMODE);
951 if (dev->ops->connect || dev->ops->auth) {
953 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
954 goto nla_put_failure;
957 if (dev->ops->disconnect || dev->ops->deauth) {
959 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
960 goto nla_put_failure;
963 nla_nest_end(msg, nl_cmds);
965 if (dev->ops->remain_on_channel &&
966 (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
967 nla_put_u32(msg, NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
968 dev->wiphy.max_remain_on_channel_duration))
969 goto nla_put_failure;
971 if ((dev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
972 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
973 goto nla_put_failure;
977 struct nlattr *nl_ftypes, *nl_ifs;
978 enum nl80211_iftype ift;
980 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
982 goto nla_put_failure;
984 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
985 nl_ftypes = nla_nest_start(msg, ift);
987 goto nla_put_failure;
989 stypes = mgmt_stypes[ift].tx;
992 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
993 (i << 4) | IEEE80211_FTYPE_MGMT))
994 goto nla_put_failure;
998 nla_nest_end(msg, nl_ftypes);
1001 nla_nest_end(msg, nl_ifs);
1003 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1005 goto nla_put_failure;
1007 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1008 nl_ftypes = nla_nest_start(msg, ift);
1010 goto nla_put_failure;
1012 stypes = mgmt_stypes[ift].rx;
1015 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1016 (i << 4) | IEEE80211_FTYPE_MGMT))
1017 goto nla_put_failure;
1021 nla_nest_end(msg, nl_ftypes);
1023 nla_nest_end(msg, nl_ifs);
1026 if (dev->wiphy.wowlan.flags || dev->wiphy.wowlan.n_patterns) {
1027 struct nlattr *nl_wowlan;
1029 nl_wowlan = nla_nest_start(msg,
1030 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1032 goto nla_put_failure;
1034 if (((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_ANY) &&
1035 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1036 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_DISCONNECT) &&
1037 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1038 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1039 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1040 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1041 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1042 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1043 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1044 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1045 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1046 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1047 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1048 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1049 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1050 goto nla_put_failure;
1051 if (dev->wiphy.wowlan.n_patterns) {
1052 struct nl80211_wowlan_pattern_support pat = {
1053 .max_patterns = dev->wiphy.wowlan.n_patterns,
1055 dev->wiphy.wowlan.pattern_min_len,
1057 dev->wiphy.wowlan.pattern_max_len,
1059 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1061 goto nla_put_failure;
1064 nla_nest_end(msg, nl_wowlan);
1067 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1068 dev->wiphy.software_iftypes))
1069 goto nla_put_failure;
1071 if (nl80211_put_iface_combinations(&dev->wiphy, msg))
1072 goto nla_put_failure;
1074 if ((dev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
1075 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1076 dev->wiphy.ap_sme_capa))
1077 goto nla_put_failure;
1079 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS,
1080 dev->wiphy.features))
1081 goto nla_put_failure;
1083 if (dev->wiphy.ht_capa_mod_mask &&
1084 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1085 sizeof(*dev->wiphy.ht_capa_mod_mask),
1086 dev->wiphy.ht_capa_mod_mask))
1087 goto nla_put_failure;
1089 return genlmsg_end(msg, hdr);
1092 genlmsg_cancel(msg, hdr);
1096 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1099 int start = cb->args[0];
1100 struct cfg80211_registered_device *dev;
1102 mutex_lock(&cfg80211_mutex);
1103 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
1104 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
1108 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
1109 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1115 mutex_unlock(&cfg80211_mutex);
1122 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
1124 struct sk_buff *msg;
1125 struct cfg80211_registered_device *dev = info->user_ptr[0];
1127 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1131 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0) {
1136 return genlmsg_reply(msg, info);
1139 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
1140 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
1141 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
1142 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
1143 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
1144 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
1147 static int parse_txq_params(struct nlattr *tb[],
1148 struct ieee80211_txq_params *txq_params)
1150 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
1151 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
1152 !tb[NL80211_TXQ_ATTR_AIFS])
1155 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
1156 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
1157 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
1158 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
1159 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
1161 if (txq_params->ac >= NL80211_NUM_ACS)
1167 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
1170 * You can only set the channel explicitly for WDS interfaces,
1171 * all others have their channel managed via their respective
1172 * "establish a connection" command (connect, join, ...)
1174 * For AP/GO and mesh mode, the channel can be set with the
1175 * channel userspace API, but is only stored and passed to the
1176 * low-level driver when the AP starts or the mesh is joined.
1177 * This is for backward compatibility, userspace can also give
1178 * the channel in the start-ap or join-mesh commands instead.
1180 * Monitors are special as they are normally slaved to
1181 * whatever else is going on, so they have their own special
1182 * operation to set the monitor channel if possible.
1185 wdev->iftype == NL80211_IFTYPE_AP ||
1186 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
1187 wdev->iftype == NL80211_IFTYPE_MONITOR ||
1188 wdev->iftype == NL80211_IFTYPE_P2P_GO;
1191 static bool nl80211_valid_channel_type(struct genl_info *info,
1192 enum nl80211_channel_type *channel_type)
1194 enum nl80211_channel_type tmp;
1196 if (!info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE])
1199 tmp = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1200 if (tmp != NL80211_CHAN_NO_HT &&
1201 tmp != NL80211_CHAN_HT20 &&
1202 tmp != NL80211_CHAN_HT40PLUS &&
1203 tmp != NL80211_CHAN_HT40MINUS)
1207 *channel_type = tmp;
1212 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
1213 struct wireless_dev *wdev,
1214 struct genl_info *info)
1216 struct ieee80211_channel *channel;
1217 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
1220 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
1223 iftype = wdev->iftype;
1225 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
1228 if (!nl80211_can_set_dev_channel(wdev))
1231 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
1232 !nl80211_valid_channel_type(info, &channel_type))
1235 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
1237 mutex_lock(&rdev->devlist_mtx);
1239 case NL80211_IFTYPE_AP:
1240 case NL80211_IFTYPE_P2P_GO:
1241 if (wdev->beacon_interval) {
1245 channel = rdev_freq_to_chan(rdev, freq, channel_type);
1246 if (!channel || !cfg80211_can_beacon_sec_chan(&rdev->wiphy,
1252 wdev->preset_chan = channel;
1253 wdev->preset_chantype = channel_type;
1256 case NL80211_IFTYPE_MESH_POINT:
1257 result = cfg80211_set_mesh_freq(rdev, wdev, freq, channel_type);
1259 case NL80211_IFTYPE_MONITOR:
1260 result = cfg80211_set_monitor_channel(rdev, freq, channel_type);
1265 mutex_unlock(&rdev->devlist_mtx);
1270 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
1272 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1273 struct net_device *netdev = info->user_ptr[1];
1275 return __nl80211_set_channel(rdev, netdev->ieee80211_ptr, info);
1278 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
1280 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1281 struct net_device *dev = info->user_ptr[1];
1282 struct wireless_dev *wdev = dev->ieee80211_ptr;
1285 if (!info->attrs[NL80211_ATTR_MAC])
1288 if (netif_running(dev))
1291 if (!rdev->ops->set_wds_peer)
1294 if (wdev->iftype != NL80211_IFTYPE_WDS)
1297 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1298 return rdev->ops->set_wds_peer(wdev->wiphy, dev, bssid);
1302 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
1304 struct cfg80211_registered_device *rdev;
1305 struct net_device *netdev = NULL;
1306 struct wireless_dev *wdev;
1307 int result = 0, rem_txq_params = 0;
1308 struct nlattr *nl_txq_params;
1310 u8 retry_short = 0, retry_long = 0;
1311 u32 frag_threshold = 0, rts_threshold = 0;
1312 u8 coverage_class = 0;
1315 * Try to find the wiphy and netdev. Normally this
1316 * function shouldn't need the netdev, but this is
1317 * done for backward compatibility -- previously
1318 * setting the channel was done per wiphy, but now
1319 * it is per netdev. Previous userland like hostapd
1320 * also passed a netdev to set_wiphy, so that it is
1321 * possible to let that go to the right netdev!
1323 mutex_lock(&cfg80211_mutex);
1325 if (info->attrs[NL80211_ATTR_IFINDEX]) {
1326 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
1328 netdev = dev_get_by_index(genl_info_net(info), ifindex);
1329 if (netdev && netdev->ieee80211_ptr) {
1330 rdev = wiphy_to_dev(netdev->ieee80211_ptr->wiphy);
1331 mutex_lock(&rdev->mtx);
1337 rdev = __cfg80211_rdev_from_info(info);
1339 mutex_unlock(&cfg80211_mutex);
1340 return PTR_ERR(rdev);
1346 mutex_lock(&rdev->mtx);
1347 } else if (nl80211_can_set_dev_channel(netdev->ieee80211_ptr))
1348 wdev = netdev->ieee80211_ptr;
1353 * end workaround code, by now the rdev is available
1354 * and locked, and wdev may or may not be NULL.
1357 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
1358 result = cfg80211_dev_rename(
1359 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
1361 mutex_unlock(&cfg80211_mutex);
1366 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
1367 struct ieee80211_txq_params txq_params;
1368 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
1370 if (!rdev->ops->set_txq_params) {
1371 result = -EOPNOTSUPP;
1380 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
1381 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
1386 if (!netif_running(netdev)) {
1391 nla_for_each_nested(nl_txq_params,
1392 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
1394 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
1395 nla_data(nl_txq_params),
1396 nla_len(nl_txq_params),
1398 result = parse_txq_params(tb, &txq_params);
1402 result = rdev->ops->set_txq_params(&rdev->wiphy,
1410 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
1411 result = __nl80211_set_channel(rdev, wdev, info);
1416 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
1417 enum nl80211_tx_power_setting type;
1420 if (!rdev->ops->set_tx_power) {
1421 result = -EOPNOTSUPP;
1425 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
1426 type = nla_get_u32(info->attrs[idx]);
1428 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
1429 (type != NL80211_TX_POWER_AUTOMATIC)) {
1434 if (type != NL80211_TX_POWER_AUTOMATIC) {
1435 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
1436 mbm = nla_get_u32(info->attrs[idx]);
1439 result = rdev->ops->set_tx_power(&rdev->wiphy, type, mbm);
1444 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
1445 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
1447 if ((!rdev->wiphy.available_antennas_tx &&
1448 !rdev->wiphy.available_antennas_rx) ||
1449 !rdev->ops->set_antenna) {
1450 result = -EOPNOTSUPP;
1454 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
1455 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
1457 /* reject antenna configurations which don't match the
1458 * available antenna masks, except for the "all" mask */
1459 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
1460 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) {
1465 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
1466 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
1468 result = rdev->ops->set_antenna(&rdev->wiphy, tx_ant, rx_ant);
1475 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
1476 retry_short = nla_get_u8(
1477 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
1478 if (retry_short == 0) {
1482 changed |= WIPHY_PARAM_RETRY_SHORT;
1485 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
1486 retry_long = nla_get_u8(
1487 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
1488 if (retry_long == 0) {
1492 changed |= WIPHY_PARAM_RETRY_LONG;
1495 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
1496 frag_threshold = nla_get_u32(
1497 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
1498 if (frag_threshold < 256) {
1502 if (frag_threshold != (u32) -1) {
1504 * Fragments (apart from the last one) are required to
1505 * have even length. Make the fragmentation code
1506 * simpler by stripping LSB should someone try to use
1507 * odd threshold value.
1509 frag_threshold &= ~0x1;
1511 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
1514 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
1515 rts_threshold = nla_get_u32(
1516 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
1517 changed |= WIPHY_PARAM_RTS_THRESHOLD;
1520 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
1521 coverage_class = nla_get_u8(
1522 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
1523 changed |= WIPHY_PARAM_COVERAGE_CLASS;
1527 u8 old_retry_short, old_retry_long;
1528 u32 old_frag_threshold, old_rts_threshold;
1529 u8 old_coverage_class;
1531 if (!rdev->ops->set_wiphy_params) {
1532 result = -EOPNOTSUPP;
1536 old_retry_short = rdev->wiphy.retry_short;
1537 old_retry_long = rdev->wiphy.retry_long;
1538 old_frag_threshold = rdev->wiphy.frag_threshold;
1539 old_rts_threshold = rdev->wiphy.rts_threshold;
1540 old_coverage_class = rdev->wiphy.coverage_class;
1542 if (changed & WIPHY_PARAM_RETRY_SHORT)
1543 rdev->wiphy.retry_short = retry_short;
1544 if (changed & WIPHY_PARAM_RETRY_LONG)
1545 rdev->wiphy.retry_long = retry_long;
1546 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
1547 rdev->wiphy.frag_threshold = frag_threshold;
1548 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
1549 rdev->wiphy.rts_threshold = rts_threshold;
1550 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
1551 rdev->wiphy.coverage_class = coverage_class;
1553 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
1555 rdev->wiphy.retry_short = old_retry_short;
1556 rdev->wiphy.retry_long = old_retry_long;
1557 rdev->wiphy.frag_threshold = old_frag_threshold;
1558 rdev->wiphy.rts_threshold = old_rts_threshold;
1559 rdev->wiphy.coverage_class = old_coverage_class;
1564 mutex_unlock(&rdev->mtx);
1571 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
1572 struct cfg80211_registered_device *rdev,
1573 struct net_device *dev)
1577 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
1581 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
1582 nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
1583 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name) ||
1584 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
1585 dev->ieee80211_ptr->iftype) ||
1586 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1587 rdev->devlist_generation ^
1588 (cfg80211_rdev_list_generation << 2)))
1589 goto nla_put_failure;
1591 if (rdev->ops->get_channel) {
1592 struct ieee80211_channel *chan;
1593 enum nl80211_channel_type channel_type;
1595 chan = rdev->ops->get_channel(&rdev->wiphy, &channel_type);
1597 (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
1598 chan->center_freq) ||
1599 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
1601 goto nla_put_failure;
1604 return genlmsg_end(msg, hdr);
1607 genlmsg_cancel(msg, hdr);
1611 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
1615 int wp_start = cb->args[0];
1616 int if_start = cb->args[1];
1617 struct cfg80211_registered_device *rdev;
1618 struct wireless_dev *wdev;
1620 mutex_lock(&cfg80211_mutex);
1621 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1622 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
1624 if (wp_idx < wp_start) {
1630 mutex_lock(&rdev->devlist_mtx);
1631 list_for_each_entry(wdev, &rdev->netdev_list, list) {
1632 if (if_idx < if_start) {
1636 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
1637 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1638 rdev, wdev->netdev) < 0) {
1639 mutex_unlock(&rdev->devlist_mtx);
1644 mutex_unlock(&rdev->devlist_mtx);
1649 mutex_unlock(&cfg80211_mutex);
1651 cb->args[0] = wp_idx;
1652 cb->args[1] = if_idx;
1657 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
1659 struct sk_buff *msg;
1660 struct cfg80211_registered_device *dev = info->user_ptr[0];
1661 struct net_device *netdev = info->user_ptr[1];
1663 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1667 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
1673 return genlmsg_reply(msg, info);
1676 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
1677 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
1678 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
1679 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
1680 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
1681 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
1684 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
1686 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
1694 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
1695 nla, mntr_flags_policy))
1698 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
1700 *mntrflags |= (1<<flag);
1705 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
1706 struct net_device *netdev, u8 use_4addr,
1707 enum nl80211_iftype iftype)
1710 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
1716 case NL80211_IFTYPE_AP_VLAN:
1717 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
1720 case NL80211_IFTYPE_STATION:
1721 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
1731 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
1733 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1734 struct vif_params params;
1736 enum nl80211_iftype otype, ntype;
1737 struct net_device *dev = info->user_ptr[1];
1738 u32 _flags, *flags = NULL;
1739 bool change = false;
1741 memset(¶ms, 0, sizeof(params));
1743 otype = ntype = dev->ieee80211_ptr->iftype;
1745 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1746 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1749 if (ntype > NL80211_IFTYPE_MAX)
1753 if (info->attrs[NL80211_ATTR_MESH_ID]) {
1754 struct wireless_dev *wdev = dev->ieee80211_ptr;
1756 if (ntype != NL80211_IFTYPE_MESH_POINT)
1758 if (netif_running(dev))
1762 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
1763 IEEE80211_MAX_MESH_ID_LEN);
1764 wdev->mesh_id_up_len =
1765 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1766 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
1767 wdev->mesh_id_up_len);
1771 if (info->attrs[NL80211_ATTR_4ADDR]) {
1772 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
1774 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
1778 params.use_4addr = -1;
1781 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
1782 if (ntype != NL80211_IFTYPE_MONITOR)
1784 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
1794 err = cfg80211_change_iface(rdev, dev, ntype, flags, ¶ms);
1798 if (!err && params.use_4addr != -1)
1799 dev->ieee80211_ptr->use_4addr = params.use_4addr;
1804 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
1806 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1807 struct vif_params params;
1808 struct net_device *dev;
1810 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
1813 memset(¶ms, 0, sizeof(params));
1815 if (!info->attrs[NL80211_ATTR_IFNAME])
1818 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1819 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1820 if (type > NL80211_IFTYPE_MAX)
1824 if (!rdev->ops->add_virtual_intf ||
1825 !(rdev->wiphy.interface_modes & (1 << type)))
1828 if (info->attrs[NL80211_ATTR_4ADDR]) {
1829 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
1830 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
1835 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
1836 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
1838 dev = rdev->ops->add_virtual_intf(&rdev->wiphy,
1839 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
1840 type, err ? NULL : &flags, ¶ms);
1842 return PTR_ERR(dev);
1844 if (type == NL80211_IFTYPE_MESH_POINT &&
1845 info->attrs[NL80211_ATTR_MESH_ID]) {
1846 struct wireless_dev *wdev = dev->ieee80211_ptr;
1849 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
1850 IEEE80211_MAX_MESH_ID_LEN);
1851 wdev->mesh_id_up_len =
1852 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1853 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
1854 wdev->mesh_id_up_len);
1861 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
1863 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1864 struct net_device *dev = info->user_ptr[1];
1866 if (!rdev->ops->del_virtual_intf)
1869 return rdev->ops->del_virtual_intf(&rdev->wiphy, dev);
1872 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
1874 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1875 struct net_device *dev = info->user_ptr[1];
1878 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
1881 if (!rdev->ops->set_noack_map)
1884 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
1886 return rdev->ops->set_noack_map(&rdev->wiphy, dev, noack_map);
1889 struct get_key_cookie {
1890 struct sk_buff *msg;
1895 static void get_key_callback(void *c, struct key_params *params)
1898 struct get_key_cookie *cookie = c;
1901 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
1902 params->key_len, params->key)) ||
1904 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
1905 params->seq_len, params->seq)) ||
1907 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
1909 goto nla_put_failure;
1911 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
1913 goto nla_put_failure;
1916 nla_put(cookie->msg, NL80211_KEY_DATA,
1917 params->key_len, params->key)) ||
1919 nla_put(cookie->msg, NL80211_KEY_SEQ,
1920 params->seq_len, params->seq)) ||
1922 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
1924 goto nla_put_failure;
1926 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
1927 goto nla_put_failure;
1929 nla_nest_end(cookie->msg, key);
1936 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
1938 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1940 struct net_device *dev = info->user_ptr[1];
1942 const u8 *mac_addr = NULL;
1944 struct get_key_cookie cookie = {
1948 struct sk_buff *msg;
1950 if (info->attrs[NL80211_ATTR_KEY_IDX])
1951 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1956 if (info->attrs[NL80211_ATTR_MAC])
1957 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1959 pairwise = !!mac_addr;
1960 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
1961 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1962 if (kt >= NUM_NL80211_KEYTYPES)
1964 if (kt != NL80211_KEYTYPE_GROUP &&
1965 kt != NL80211_KEYTYPE_PAIRWISE)
1967 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
1970 if (!rdev->ops->get_key)
1973 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1977 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
1978 NL80211_CMD_NEW_KEY);
1980 return PTR_ERR(hdr);
1983 cookie.idx = key_idx;
1985 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
1986 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
1987 goto nla_put_failure;
1989 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
1990 goto nla_put_failure;
1992 if (pairwise && mac_addr &&
1993 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
1996 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, pairwise,
1997 mac_addr, &cookie, get_key_callback);
2003 goto nla_put_failure;
2005 genlmsg_end(msg, hdr);
2006 return genlmsg_reply(msg, info);
2015 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
2017 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2018 struct key_parse key;
2020 struct net_device *dev = info->user_ptr[1];
2022 err = nl80211_parse_key(info, &key);
2029 /* only support setting default key */
2030 if (!key.def && !key.defmgmt)
2033 wdev_lock(dev->ieee80211_ptr);
2036 if (!rdev->ops->set_default_key) {
2041 err = nl80211_key_allowed(dev->ieee80211_ptr);
2045 err = rdev->ops->set_default_key(&rdev->wiphy, dev, key.idx,
2046 key.def_uni, key.def_multi);
2051 #ifdef CONFIG_CFG80211_WEXT
2052 dev->ieee80211_ptr->wext.default_key = key.idx;
2055 if (key.def_uni || !key.def_multi) {
2060 if (!rdev->ops->set_default_mgmt_key) {
2065 err = nl80211_key_allowed(dev->ieee80211_ptr);
2069 err = rdev->ops->set_default_mgmt_key(&rdev->wiphy,
2074 #ifdef CONFIG_CFG80211_WEXT
2075 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
2080 wdev_unlock(dev->ieee80211_ptr);
2085 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
2087 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2089 struct net_device *dev = info->user_ptr[1];
2090 struct key_parse key;
2091 const u8 *mac_addr = NULL;
2093 err = nl80211_parse_key(info, &key);
2100 if (info->attrs[NL80211_ATTR_MAC])
2101 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2103 if (key.type == -1) {
2105 key.type = NL80211_KEYTYPE_PAIRWISE;
2107 key.type = NL80211_KEYTYPE_GROUP;
2111 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2112 key.type != NL80211_KEYTYPE_GROUP)
2115 if (!rdev->ops->add_key)
2118 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
2119 key.type == NL80211_KEYTYPE_PAIRWISE,
2123 wdev_lock(dev->ieee80211_ptr);
2124 err = nl80211_key_allowed(dev->ieee80211_ptr);
2126 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx,
2127 key.type == NL80211_KEYTYPE_PAIRWISE,
2129 wdev_unlock(dev->ieee80211_ptr);
2134 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
2136 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2138 struct net_device *dev = info->user_ptr[1];
2139 u8 *mac_addr = NULL;
2140 struct key_parse key;
2142 err = nl80211_parse_key(info, &key);
2146 if (info->attrs[NL80211_ATTR_MAC])
2147 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2149 if (key.type == -1) {
2151 key.type = NL80211_KEYTYPE_PAIRWISE;
2153 key.type = NL80211_KEYTYPE_GROUP;
2157 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2158 key.type != NL80211_KEYTYPE_GROUP)
2161 if (!rdev->ops->del_key)
2164 wdev_lock(dev->ieee80211_ptr);
2165 err = nl80211_key_allowed(dev->ieee80211_ptr);
2167 if (key.type == NL80211_KEYTYPE_PAIRWISE && mac_addr &&
2168 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2172 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx,
2173 key.type == NL80211_KEYTYPE_PAIRWISE,
2176 #ifdef CONFIG_CFG80211_WEXT
2178 if (key.idx == dev->ieee80211_ptr->wext.default_key)
2179 dev->ieee80211_ptr->wext.default_key = -1;
2180 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
2181 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
2184 wdev_unlock(dev->ieee80211_ptr);
2189 static int nl80211_parse_beacon(struct genl_info *info,
2190 struct cfg80211_beacon_data *bcn)
2192 bool haveinfo = false;
2194 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]) ||
2195 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]) ||
2196 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
2197 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]))
2200 memset(bcn, 0, sizeof(*bcn));
2202 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
2203 bcn->head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2204 bcn->head_len = nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2210 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
2211 bcn->tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2213 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2220 if (info->attrs[NL80211_ATTR_IE]) {
2221 bcn->beacon_ies = nla_data(info->attrs[NL80211_ATTR_IE]);
2222 bcn->beacon_ies_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2225 if (info->attrs[NL80211_ATTR_IE_PROBE_RESP]) {
2226 bcn->proberesp_ies =
2227 nla_data(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2228 bcn->proberesp_ies_len =
2229 nla_len(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2232 if (info->attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
2233 bcn->assocresp_ies =
2234 nla_data(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2235 bcn->assocresp_ies_len =
2236 nla_len(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2239 if (info->attrs[NL80211_ATTR_PROBE_RESP]) {
2241 nla_data(info->attrs[NL80211_ATTR_PROBE_RESP]);
2242 bcn->probe_resp_len =
2243 nla_len(info->attrs[NL80211_ATTR_PROBE_RESP]);
2249 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
2251 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2252 struct net_device *dev = info->user_ptr[1];
2253 struct wireless_dev *wdev = dev->ieee80211_ptr;
2254 struct cfg80211_ap_settings params;
2257 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2258 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2261 if (!rdev->ops->start_ap)
2264 if (wdev->beacon_interval)
2267 memset(¶ms, 0, sizeof(params));
2269 /* these are required for START_AP */
2270 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
2271 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
2272 !info->attrs[NL80211_ATTR_BEACON_HEAD])
2275 err = nl80211_parse_beacon(info, ¶ms.beacon);
2279 params.beacon_interval =
2280 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
2281 params.dtim_period =
2282 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
2284 err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
2289 * In theory, some of these attributes should be required here
2290 * but since they were not used when the command was originally
2291 * added, keep them optional for old user space programs to let
2292 * them continue to work with drivers that do not need the
2293 * additional information -- drivers must check!
2295 if (info->attrs[NL80211_ATTR_SSID]) {
2296 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
2298 nla_len(info->attrs[NL80211_ATTR_SSID]);
2299 if (params.ssid_len == 0 ||
2300 params.ssid_len > IEEE80211_MAX_SSID_LEN)
2304 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
2305 params.hidden_ssid = nla_get_u32(
2306 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
2307 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
2308 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
2309 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
2313 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
2315 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
2316 params.auth_type = nla_get_u32(
2317 info->attrs[NL80211_ATTR_AUTH_TYPE]);
2318 if (!nl80211_valid_auth_type(params.auth_type))
2321 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
2323 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
2324 NL80211_MAX_NR_CIPHER_SUITES);
2328 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
2329 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
2331 params.inactivity_timeout = nla_get_u16(
2332 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
2335 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2336 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
2338 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
2339 !nl80211_valid_channel_type(info, &channel_type))
2342 params.channel = rdev_freq_to_chan(rdev,
2343 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
2345 if (!params.channel)
2347 params.channel_type = channel_type;
2348 } else if (wdev->preset_chan) {
2349 params.channel = wdev->preset_chan;
2350 params.channel_type = wdev->preset_chantype;
2354 if (!cfg80211_can_beacon_sec_chan(&rdev->wiphy, params.channel,
2355 params.channel_type))
2358 err = rdev->ops->start_ap(&rdev->wiphy, dev, ¶ms);
2360 wdev->beacon_interval = params.beacon_interval;
2364 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
2366 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2367 struct net_device *dev = info->user_ptr[1];
2368 struct wireless_dev *wdev = dev->ieee80211_ptr;
2369 struct cfg80211_beacon_data params;
2372 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2373 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2376 if (!rdev->ops->change_beacon)
2379 if (!wdev->beacon_interval)
2382 err = nl80211_parse_beacon(info, ¶ms);
2386 return rdev->ops->change_beacon(&rdev->wiphy, dev, ¶ms);
2389 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
2391 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2392 struct net_device *dev = info->user_ptr[1];
2393 struct wireless_dev *wdev = dev->ieee80211_ptr;
2396 if (!rdev->ops->stop_ap)
2399 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2400 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2403 if (!wdev->beacon_interval)
2406 err = rdev->ops->stop_ap(&rdev->wiphy, dev);
2408 wdev->beacon_interval = 0;
2412 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
2413 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
2414 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
2415 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
2416 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
2417 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
2418 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
2421 static int parse_station_flags(struct genl_info *info,
2422 enum nl80211_iftype iftype,
2423 struct station_parameters *params)
2425 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
2430 * Try parsing the new attribute first so userspace
2431 * can specify both for older kernels.
2433 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
2435 struct nl80211_sta_flag_update *sta_flags;
2437 sta_flags = nla_data(nla);
2438 params->sta_flags_mask = sta_flags->mask;
2439 params->sta_flags_set = sta_flags->set;
2440 if ((params->sta_flags_mask |
2441 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
2446 /* if present, parse the old attribute */
2448 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
2452 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
2453 nla, sta_flags_policy))
2457 * Only allow certain flags for interface types so that
2458 * other attributes are silently ignored. Remember that
2459 * this is backward compatibility code with old userspace
2460 * and shouldn't be hit in other cases anyway.
2463 case NL80211_IFTYPE_AP:
2464 case NL80211_IFTYPE_AP_VLAN:
2465 case NL80211_IFTYPE_P2P_GO:
2466 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2467 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2468 BIT(NL80211_STA_FLAG_WME) |
2469 BIT(NL80211_STA_FLAG_MFP);
2471 case NL80211_IFTYPE_P2P_CLIENT:
2472 case NL80211_IFTYPE_STATION:
2473 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2474 BIT(NL80211_STA_FLAG_TDLS_PEER);
2476 case NL80211_IFTYPE_MESH_POINT:
2477 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2478 BIT(NL80211_STA_FLAG_MFP) |
2479 BIT(NL80211_STA_FLAG_AUTHORIZED);
2484 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
2486 params->sta_flags_set |= (1<<flag);
2488 /* no longer support new API additions in old API */
2489 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
2497 static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
2500 struct nlattr *rate;
2503 rate = nla_nest_start(msg, attr);
2505 goto nla_put_failure;
2507 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
2508 bitrate = cfg80211_calculate_bitrate(info);
2510 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate)) ||
2511 ((info->flags & RATE_INFO_FLAGS_MCS) &&
2512 nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs)) ||
2513 ((info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) &&
2514 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH)) ||
2515 ((info->flags & RATE_INFO_FLAGS_SHORT_GI) &&
2516 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI)))
2517 goto nla_put_failure;
2519 nla_nest_end(msg, rate);
2526 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
2528 struct cfg80211_registered_device *rdev,
2529 struct net_device *dev,
2530 const u8 *mac_addr, struct station_info *sinfo)
2533 struct nlattr *sinfoattr, *bss_param;
2535 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
2539 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2540 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
2541 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
2542 goto nla_put_failure;
2544 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
2546 goto nla_put_failure;
2547 if ((sinfo->filled & STATION_INFO_CONNECTED_TIME) &&
2548 nla_put_u32(msg, NL80211_STA_INFO_CONNECTED_TIME,
2549 sinfo->connected_time))
2550 goto nla_put_failure;
2551 if ((sinfo->filled & STATION_INFO_INACTIVE_TIME) &&
2552 nla_put_u32(msg, NL80211_STA_INFO_INACTIVE_TIME,
2553 sinfo->inactive_time))
2554 goto nla_put_failure;
2555 if ((sinfo->filled & STATION_INFO_RX_BYTES) &&
2556 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
2558 goto nla_put_failure;
2559 if ((sinfo->filled & STATION_INFO_TX_BYTES) &&
2560 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
2562 goto nla_put_failure;
2563 if ((sinfo->filled & STATION_INFO_LLID) &&
2564 nla_put_u16(msg, NL80211_STA_INFO_LLID, sinfo->llid))
2565 goto nla_put_failure;
2566 if ((sinfo->filled & STATION_INFO_PLID) &&
2567 nla_put_u16(msg, NL80211_STA_INFO_PLID, sinfo->plid))
2568 goto nla_put_failure;
2569 if ((sinfo->filled & STATION_INFO_PLINK_STATE) &&
2570 nla_put_u8(msg, NL80211_STA_INFO_PLINK_STATE,
2571 sinfo->plink_state))
2572 goto nla_put_failure;
2573 switch (rdev->wiphy.signal_type) {
2574 case CFG80211_SIGNAL_TYPE_MBM:
2575 if ((sinfo->filled & STATION_INFO_SIGNAL) &&
2576 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL,
2578 goto nla_put_failure;
2579 if ((sinfo->filled & STATION_INFO_SIGNAL_AVG) &&
2580 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL_AVG,
2582 goto nla_put_failure;
2587 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
2588 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
2589 NL80211_STA_INFO_TX_BITRATE))
2590 goto nla_put_failure;
2592 if (sinfo->filled & STATION_INFO_RX_BITRATE) {
2593 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
2594 NL80211_STA_INFO_RX_BITRATE))
2595 goto nla_put_failure;
2597 if ((sinfo->filled & STATION_INFO_RX_PACKETS) &&
2598 nla_put_u32(msg, NL80211_STA_INFO_RX_PACKETS,
2600 goto nla_put_failure;
2601 if ((sinfo->filled & STATION_INFO_TX_PACKETS) &&
2602 nla_put_u32(msg, NL80211_STA_INFO_TX_PACKETS,
2604 goto nla_put_failure;
2605 if ((sinfo->filled & STATION_INFO_TX_RETRIES) &&
2606 nla_put_u32(msg, NL80211_STA_INFO_TX_RETRIES,
2608 goto nla_put_failure;
2609 if ((sinfo->filled & STATION_INFO_TX_FAILED) &&
2610 nla_put_u32(msg, NL80211_STA_INFO_TX_FAILED,
2612 goto nla_put_failure;
2613 if ((sinfo->filled & STATION_INFO_BEACON_LOSS_COUNT) &&
2614 nla_put_u32(msg, NL80211_STA_INFO_BEACON_LOSS,
2615 sinfo->beacon_loss_count))
2616 goto nla_put_failure;
2617 if (sinfo->filled & STATION_INFO_BSS_PARAM) {
2618 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
2620 goto nla_put_failure;
2622 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
2623 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
2624 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
2625 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
2626 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
2627 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
2628 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
2629 sinfo->bss_param.dtim_period) ||
2630 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
2631 sinfo->bss_param.beacon_interval))
2632 goto nla_put_failure;
2634 nla_nest_end(msg, bss_param);
2636 if ((sinfo->filled & STATION_INFO_STA_FLAGS) &&
2637 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
2638 sizeof(struct nl80211_sta_flag_update),
2640 goto nla_put_failure;
2641 if ((sinfo->filled & STATION_INFO_T_OFFSET) &&
2642 nla_put_u64(msg, NL80211_STA_INFO_T_OFFSET,
2644 goto nla_put_failure;
2645 nla_nest_end(msg, sinfoattr);
2647 if ((sinfo->filled & STATION_INFO_ASSOC_REQ_IES) &&
2648 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
2649 sinfo->assoc_req_ies))
2650 goto nla_put_failure;
2652 return genlmsg_end(msg, hdr);
2655 genlmsg_cancel(msg, hdr);
2659 static int nl80211_dump_station(struct sk_buff *skb,
2660 struct netlink_callback *cb)
2662 struct station_info sinfo;
2663 struct cfg80211_registered_device *dev;
2664 struct net_device *netdev;
2665 u8 mac_addr[ETH_ALEN];
2666 int sta_idx = cb->args[1];
2669 err = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
2673 if (!dev->ops->dump_station) {
2679 memset(&sinfo, 0, sizeof(sinfo));
2680 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
2687 if (nl80211_send_station(skb,
2688 NETLINK_CB(cb->skb).pid,
2689 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2690 dev, netdev, mac_addr,
2699 cb->args[1] = sta_idx;
2702 nl80211_finish_netdev_dump(dev);
2707 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
2709 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2710 struct net_device *dev = info->user_ptr[1];
2711 struct station_info sinfo;
2712 struct sk_buff *msg;
2713 u8 *mac_addr = NULL;
2716 memset(&sinfo, 0, sizeof(sinfo));
2718 if (!info->attrs[NL80211_ATTR_MAC])
2721 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2723 if (!rdev->ops->get_station)
2726 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo);
2730 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2734 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
2735 rdev, dev, mac_addr, &sinfo) < 0) {
2740 return genlmsg_reply(msg, info);
2744 * Get vlan interface making sure it is running and on the right wiphy.
2746 static struct net_device *get_vlan(struct genl_info *info,
2747 struct cfg80211_registered_device *rdev)
2749 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
2750 struct net_device *v;
2756 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
2758 return ERR_PTR(-ENODEV);
2760 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
2765 if (!netif_running(v)) {
2773 return ERR_PTR(ret);
2776 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
2778 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2780 struct net_device *dev = info->user_ptr[1];
2781 struct station_parameters params;
2782 u8 *mac_addr = NULL;
2784 memset(¶ms, 0, sizeof(params));
2786 params.listen_interval = -1;
2787 params.plink_state = -1;
2789 if (info->attrs[NL80211_ATTR_STA_AID])
2792 if (!info->attrs[NL80211_ATTR_MAC])
2795 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2797 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
2798 params.supported_rates =
2799 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2800 params.supported_rates_len =
2801 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2804 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
2805 params.listen_interval =
2806 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
2808 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
2810 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
2812 if (!rdev->ops->change_station)
2815 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
2818 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
2819 params.plink_action =
2820 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
2822 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE])
2823 params.plink_state =
2824 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
2826 switch (dev->ieee80211_ptr->iftype) {
2827 case NL80211_IFTYPE_AP:
2828 case NL80211_IFTYPE_AP_VLAN:
2829 case NL80211_IFTYPE_P2P_GO:
2830 /* disallow mesh-specific things */
2831 if (params.plink_action)
2834 /* TDLS can't be set, ... */
2835 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
2838 * ... but don't bother the driver with it. This works around
2839 * a hostapd/wpa_supplicant issue -- it always includes the
2840 * TLDS_PEER flag in the mask even for AP mode.
2842 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2844 /* accept only the listed bits */
2845 if (params.sta_flags_mask &
2846 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
2847 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2848 BIT(NL80211_STA_FLAG_WME) |
2849 BIT(NL80211_STA_FLAG_MFP)))
2852 /* must be last in here for error handling */
2853 params.vlan = get_vlan(info, rdev);
2854 if (IS_ERR(params.vlan))
2855 return PTR_ERR(params.vlan);
2857 case NL80211_IFTYPE_P2P_CLIENT:
2858 case NL80211_IFTYPE_STATION:
2860 * Don't allow userspace to change the TDLS_PEER flag,
2861 * but silently ignore attempts to change it since we
2862 * don't have state here to verify that it doesn't try
2863 * to change the flag.
2865 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2867 case NL80211_IFTYPE_ADHOC:
2868 /* disallow things sta doesn't support */
2869 if (params.plink_action)
2873 if (params.listen_interval >= 0)
2875 /* reject any changes other than AUTHORIZED */
2876 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
2879 case NL80211_IFTYPE_MESH_POINT:
2880 /* disallow things mesh doesn't support */
2885 if (params.listen_interval >= 0)
2888 * No special handling for TDLS here -- the userspace
2889 * mesh code doesn't have this bug.
2891 if (params.sta_flags_mask &
2892 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2893 BIT(NL80211_STA_FLAG_MFP) |
2894 BIT(NL80211_STA_FLAG_AUTHORIZED)))
2901 /* be aware of params.vlan when changing code here */
2903 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, ¶ms);
2906 dev_put(params.vlan);
2911 static struct nla_policy
2912 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] __read_mostly = {
2913 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
2914 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
2917 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
2919 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2921 struct net_device *dev = info->user_ptr[1];
2922 struct station_parameters params;
2923 u8 *mac_addr = NULL;
2925 memset(¶ms, 0, sizeof(params));
2927 if (!info->attrs[NL80211_ATTR_MAC])
2930 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
2933 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
2936 if (!info->attrs[NL80211_ATTR_STA_AID])
2939 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2940 params.supported_rates =
2941 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2942 params.supported_rates_len =
2943 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2944 params.listen_interval =
2945 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
2947 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
2948 if (!params.aid || params.aid > IEEE80211_MAX_AID)
2951 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
2953 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
2955 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
2956 params.plink_action =
2957 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
2959 if (!rdev->ops->add_station)
2962 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
2965 switch (dev->ieee80211_ptr->iftype) {
2966 case NL80211_IFTYPE_AP:
2967 case NL80211_IFTYPE_AP_VLAN:
2968 case NL80211_IFTYPE_P2P_GO:
2969 /* parse WME attributes if sta is WME capable */
2970 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
2971 (params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)) &&
2972 info->attrs[NL80211_ATTR_STA_WME]) {
2973 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
2976 nla = info->attrs[NL80211_ATTR_STA_WME];
2977 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
2978 nl80211_sta_wme_policy);
2982 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
2983 params.uapsd_queues =
2984 nla_get_u8(tb[NL80211_STA_WME_UAPSD_QUEUES]);
2985 if (params.uapsd_queues &
2986 ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
2989 if (tb[NL80211_STA_WME_MAX_SP])
2991 nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
2994 ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
2997 params.sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
2999 /* TDLS peers cannot be added */
3000 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3002 /* but don't bother the driver with it */
3003 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3005 /* must be last in here for error handling */
3006 params.vlan = get_vlan(info, rdev);
3007 if (IS_ERR(params.vlan))
3008 return PTR_ERR(params.vlan);
3010 case NL80211_IFTYPE_MESH_POINT:
3011 /* TDLS peers cannot be added */
3012 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3015 case NL80211_IFTYPE_STATION:
3016 /* Only TDLS peers can be added */
3017 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3019 /* Can only add if TDLS ... */
3020 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
3022 /* ... with external setup is supported */
3023 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
3030 /* be aware of params.vlan when changing code here */
3032 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, ¶ms);
3035 dev_put(params.vlan);
3039 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
3041 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3042 struct net_device *dev = info->user_ptr[1];
3043 u8 *mac_addr = NULL;
3045 if (info->attrs[NL80211_ATTR_MAC])
3046 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3048 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3049 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
3050 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
3051 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3054 if (!rdev->ops->del_station)
3057 return rdev->ops->del_station(&rdev->wiphy, dev, mac_addr);
3060 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
3061 int flags, struct net_device *dev,
3062 u8 *dst, u8 *next_hop,
3063 struct mpath_info *pinfo)
3066 struct nlattr *pinfoattr;
3068 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
3072 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3073 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
3074 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
3075 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
3076 goto nla_put_failure;
3078 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
3080 goto nla_put_failure;
3081 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
3082 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
3084 goto nla_put_failure;
3085 if (((pinfo->filled & MPATH_INFO_SN) &&
3086 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
3087 ((pinfo->filled & MPATH_INFO_METRIC) &&
3088 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
3090 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
3091 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
3093 ((pinfo->filled & MPATH_INFO_FLAGS) &&
3094 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
3096 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
3097 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
3098 pinfo->discovery_timeout)) ||
3099 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
3100 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
3101 pinfo->discovery_retries)))
3102 goto nla_put_failure;
3104 nla_nest_end(msg, pinfoattr);
3106 return genlmsg_end(msg, hdr);
3109 genlmsg_cancel(msg, hdr);
3113 static int nl80211_dump_mpath(struct sk_buff *skb,
3114 struct netlink_callback *cb)
3116 struct mpath_info pinfo;
3117 struct cfg80211_registered_device *dev;
3118 struct net_device *netdev;
3120 u8 next_hop[ETH_ALEN];
3121 int path_idx = cb->args[1];
3124 err = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
3128 if (!dev->ops->dump_mpath) {
3133 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
3139 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
3140 dst, next_hop, &pinfo);
3146 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
3147 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3148 netdev, dst, next_hop,
3157 cb->args[1] = path_idx;
3160 nl80211_finish_netdev_dump(dev);
3164 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
3166 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3168 struct net_device *dev = info->user_ptr[1];
3169 struct mpath_info pinfo;
3170 struct sk_buff *msg;
3172 u8 next_hop[ETH_ALEN];
3174 memset(&pinfo, 0, sizeof(pinfo));
3176 if (!info->attrs[NL80211_ATTR_MAC])
3179 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3181 if (!rdev->ops->get_mpath)
3184 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
3187 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo);
3191 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3195 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
3196 dev, dst, next_hop, &pinfo) < 0) {
3201 return genlmsg_reply(msg, info);
3204 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
3206 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3207 struct net_device *dev = info->user_ptr[1];
3209 u8 *next_hop = NULL;
3211 if (!info->attrs[NL80211_ATTR_MAC])
3214 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
3217 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3218 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
3220 if (!rdev->ops->change_mpath)
3223 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
3226 return rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
3229 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
3231 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3232 struct net_device *dev = info->user_ptr[1];
3234 u8 *next_hop = NULL;
3236 if (!info->attrs[NL80211_ATTR_MAC])
3239 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
3242 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3243 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
3245 if (!rdev->ops->add_mpath)
3248 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
3251 return rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
3254 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
3256 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3257 struct net_device *dev = info->user_ptr[1];
3260 if (info->attrs[NL80211_ATTR_MAC])
3261 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3263 if (!rdev->ops->del_mpath)
3266 return rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
3269 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
3271 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3272 struct net_device *dev = info->user_ptr[1];
3273 struct bss_parameters params;
3275 memset(¶ms, 0, sizeof(params));
3276 /* default to not changing parameters */
3277 params.use_cts_prot = -1;
3278 params.use_short_preamble = -1;
3279 params.use_short_slot_time = -1;
3280 params.ap_isolate = -1;
3281 params.ht_opmode = -1;
3283 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
3284 params.use_cts_prot =
3285 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
3286 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
3287 params.use_short_preamble =
3288 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
3289 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
3290 params.use_short_slot_time =
3291 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
3292 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
3293 params.basic_rates =
3294 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
3295 params.basic_rates_len =
3296 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
3298 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
3299 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
3300 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
3302 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
3304 if (!rdev->ops->change_bss)
3307 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3308 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3311 return rdev->ops->change_bss(&rdev->wiphy, dev, ¶ms);
3314 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
3315 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
3316 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
3317 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
3318 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
3319 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
3320 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
3323 static int parse_reg_rule(struct nlattr *tb[],
3324 struct ieee80211_reg_rule *reg_rule)
3326 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
3327 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
3329 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
3331 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
3333 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
3335 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
3337 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
3340 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
3342 freq_range->start_freq_khz =
3343 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
3344 freq_range->end_freq_khz =
3345 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
3346 freq_range->max_bandwidth_khz =
3347 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
3349 power_rule->max_eirp =
3350 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
3352 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
3353 power_rule->max_antenna_gain =
3354 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
3359 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
3365 * You should only get this when cfg80211 hasn't yet initialized
3366 * completely when built-in to the kernel right between the time
3367 * window between nl80211_init() and regulatory_init(), if that is
3370 mutex_lock(&cfg80211_mutex);
3371 if (unlikely(!cfg80211_regdomain)) {
3372 mutex_unlock(&cfg80211_mutex);
3373 return -EINPROGRESS;
3375 mutex_unlock(&cfg80211_mutex);
3377 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
3380 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
3382 r = regulatory_hint_user(data);
3387 static int nl80211_get_mesh_config(struct sk_buff *skb,
3388 struct genl_info *info)
3390 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3391 struct net_device *dev = info->user_ptr[1];
3392 struct wireless_dev *wdev = dev->ieee80211_ptr;
3393 struct mesh_config cur_params;
3396 struct nlattr *pinfoattr;
3397 struct sk_buff *msg;
3399 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
3402 if (!rdev->ops->get_mesh_config)
3406 /* If not connected, get default parameters */
3407 if (!wdev->mesh_id_len)
3408 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
3410 err = rdev->ops->get_mesh_config(&rdev->wiphy, dev,
3417 /* Draw up a netlink message to send back */
3418 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3421 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
3422 NL80211_CMD_GET_MESH_CONFIG);
3425 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
3427 goto nla_put_failure;
3428 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3429 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
3430 cur_params.dot11MeshRetryTimeout) ||
3431 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
3432 cur_params.dot11MeshConfirmTimeout) ||
3433 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
3434 cur_params.dot11MeshHoldingTimeout) ||
3435 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
3436 cur_params.dot11MeshMaxPeerLinks) ||
3437 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
3438 cur_params.dot11MeshMaxRetries) ||
3439 nla_put_u8(msg, NL80211_MESHCONF_TTL,
3440 cur_params.dot11MeshTTL) ||
3441 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
3442 cur_params.element_ttl) ||
3443 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
3444 cur_params.auto_open_plinks) ||
3445 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
3446 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
3447 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
3448 cur_params.dot11MeshHWMPmaxPREQretries) ||
3449 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
3450 cur_params.path_refresh_time) ||
3451 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
3452 cur_params.min_discovery_timeout) ||
3453 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
3454 cur_params.dot11MeshHWMPactivePathTimeout) ||
3455 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
3456 cur_params.dot11MeshHWMPpreqMinInterval) ||
3457 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
3458 cur_params.dot11MeshHWMPperrMinInterval) ||
3459 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
3460 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
3461 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
3462 cur_params.dot11MeshHWMPRootMode) ||
3463 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
3464 cur_params.dot11MeshHWMPRannInterval) ||
3465 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
3466 cur_params.dot11MeshGateAnnouncementProtocol) ||
3467 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
3468 cur_params.dot11MeshForwarding) ||
3469 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
3470 cur_params.rssi_threshold) ||
3471 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
3472 cur_params.ht_opmode))
3473 goto nla_put_failure;
3474 nla_nest_end(msg, pinfoattr);
3475 genlmsg_end(msg, hdr);
3476 return genlmsg_reply(msg, info);
3479 genlmsg_cancel(msg, hdr);
3485 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
3486 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
3487 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
3488 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
3489 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
3490 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
3491 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
3492 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
3493 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
3494 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
3496 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
3497 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
3498 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
3499 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
3500 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
3501 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
3502 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
3503 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
3504 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
3505 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
3506 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
3507 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32},
3508 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16},
3511 static const struct nla_policy
3512 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
3513 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
3514 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
3515 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
3516 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
3517 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
3518 .len = IEEE80211_MAX_DATA_LEN },
3519 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
3522 static int nl80211_parse_mesh_config(struct genl_info *info,
3523 struct mesh_config *cfg,
3526 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
3529 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
3531 if (table[attr_num]) {\
3532 cfg->param = nla_fn(table[attr_num]); \
3533 mask |= (1 << (attr_num - 1)); \
3538 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
3540 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
3541 info->attrs[NL80211_ATTR_MESH_CONFIG],
3542 nl80211_meshconf_params_policy))
3545 /* This makes sure that there aren't more than 32 mesh config
3546 * parameters (otherwise our bitfield scheme would not work.) */
3547 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
3549 /* Fill in the params struct */
3550 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
3551 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
3552 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
3553 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
3554 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
3555 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
3556 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
3557 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
3558 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
3559 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
3560 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
3561 mask, NL80211_MESHCONF_TTL, nla_get_u8);
3562 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl,
3563 mask, NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
3564 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
3565 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
3566 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
3567 mask, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
3569 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
3570 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
3572 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
3573 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
3574 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
3575 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
3577 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
3578 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
3580 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
3581 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
3583 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
3584 mask, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
3586 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3587 dot11MeshHWMPnetDiameterTraversalTime,
3588 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
3590 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3591 dot11MeshHWMPRootMode, mask,
3592 NL80211_MESHCONF_HWMP_ROOTMODE,
3594 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3595 dot11MeshHWMPRannInterval, mask,
3596 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
3598 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3599 dot11MeshGateAnnouncementProtocol, mask,
3600 NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
3602 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding,
3603 mask, NL80211_MESHCONF_FORWARDING, nla_get_u8);
3604 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold,
3605 mask, NL80211_MESHCONF_RSSI_THRESHOLD, nla_get_u32);
3606 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode,
3607 mask, NL80211_MESHCONF_HT_OPMODE, nla_get_u16);
3613 #undef FILL_IN_MESH_PARAM_IF_SET
3616 static int nl80211_parse_mesh_setup(struct genl_info *info,
3617 struct mesh_setup *setup)
3619 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
3621 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
3623 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
3624 info->attrs[NL80211_ATTR_MESH_SETUP],
3625 nl80211_mesh_setup_params_policy))
3628 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
3629 setup->sync_method =
3630 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
3631 IEEE80211_SYNC_METHOD_VENDOR :
3632 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
3634 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
3635 setup->path_sel_proto =
3636 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
3637 IEEE80211_PATH_PROTOCOL_VENDOR :
3638 IEEE80211_PATH_PROTOCOL_HWMP;
3640 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
3641 setup->path_metric =
3642 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
3643 IEEE80211_PATH_METRIC_VENDOR :
3644 IEEE80211_PATH_METRIC_AIRTIME;
3647 if (tb[NL80211_MESH_SETUP_IE]) {
3648 struct nlattr *ieattr =
3649 tb[NL80211_MESH_SETUP_IE];
3650 if (!is_valid_ie_attr(ieattr))
3652 setup->ie = nla_data(ieattr);
3653 setup->ie_len = nla_len(ieattr);
3655 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
3656 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
3661 static int nl80211_update_mesh_config(struct sk_buff *skb,
3662 struct genl_info *info)
3664 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3665 struct net_device *dev = info->user_ptr[1];
3666 struct wireless_dev *wdev = dev->ieee80211_ptr;
3667 struct mesh_config cfg;
3671 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
3674 if (!rdev->ops->update_mesh_config)
3677 err = nl80211_parse_mesh_config(info, &cfg, &mask);
3682 if (!wdev->mesh_id_len)
3686 err = rdev->ops->update_mesh_config(&rdev->wiphy, dev,
3694 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
3696 struct sk_buff *msg;
3698 struct nlattr *nl_reg_rules;
3702 mutex_lock(&cfg80211_mutex);
3704 if (!cfg80211_regdomain)
3707 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3713 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
3714 NL80211_CMD_GET_REG);
3718 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
3719 cfg80211_regdomain->alpha2) ||
3720 (cfg80211_regdomain->dfs_region &&
3721 nla_put_u8(msg, NL80211_ATTR_DFS_REGION,
3722 cfg80211_regdomain->dfs_region)))
3723 goto nla_put_failure;
3725 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
3727 goto nla_put_failure;
3729 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
3730 struct nlattr *nl_reg_rule;
3731 const struct ieee80211_reg_rule *reg_rule;
3732 const struct ieee80211_freq_range *freq_range;
3733 const struct ieee80211_power_rule *power_rule;
3735 reg_rule = &cfg80211_regdomain->reg_rules[i];
3736 freq_range = ®_rule->freq_range;
3737 power_rule = ®_rule->power_rule;
3739 nl_reg_rule = nla_nest_start(msg, i);
3741 goto nla_put_failure;
3743 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
3745 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
3746 freq_range->start_freq_khz) ||
3747 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
3748 freq_range->end_freq_khz) ||
3749 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
3750 freq_range->max_bandwidth_khz) ||
3751 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
3752 power_rule->max_antenna_gain) ||
3753 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
3754 power_rule->max_eirp))
3755 goto nla_put_failure;
3757 nla_nest_end(msg, nl_reg_rule);
3760 nla_nest_end(msg, nl_reg_rules);
3762 genlmsg_end(msg, hdr);
3763 err = genlmsg_reply(msg, info);
3767 genlmsg_cancel(msg, hdr);
3772 mutex_unlock(&cfg80211_mutex);
3776 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
3778 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
3779 struct nlattr *nl_reg_rule;
3780 char *alpha2 = NULL;
3781 int rem_reg_rules = 0, r = 0;
3782 u32 num_rules = 0, rule_idx = 0, size_of_regd;
3784 struct ieee80211_regdomain *rd = NULL;
3786 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
3789 if (!info->attrs[NL80211_ATTR_REG_RULES])
3792 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
3794 if (info->attrs[NL80211_ATTR_DFS_REGION])
3795 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
3797 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
3800 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
3804 mutex_lock(&cfg80211_mutex);
3806 if (!reg_is_valid_request(alpha2)) {
3811 size_of_regd = sizeof(struct ieee80211_regdomain) +
3812 (num_rules * sizeof(struct ieee80211_reg_rule));
3814 rd = kzalloc(size_of_regd, GFP_KERNEL);
3820 rd->n_reg_rules = num_rules;
3821 rd->alpha2[0] = alpha2[0];
3822 rd->alpha2[1] = alpha2[1];
3825 * Disable DFS master mode if the DFS region was
3826 * not supported or known on this kernel.
3828 if (reg_supported_dfs_region(dfs_region))
3829 rd->dfs_region = dfs_region;
3831 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
3833 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
3834 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
3836 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
3842 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
3848 BUG_ON(rule_idx != num_rules);
3852 mutex_unlock(&cfg80211_mutex);
3857 mutex_unlock(&cfg80211_mutex);
3862 static int validate_scan_freqs(struct nlattr *freqs)
3864 struct nlattr *attr1, *attr2;
3865 int n_channels = 0, tmp1, tmp2;
3867 nla_for_each_nested(attr1, freqs, tmp1) {
3870 * Some hardware has a limited channel list for
3871 * scanning, and it is pretty much nonsensical
3872 * to scan for a channel twice, so disallow that
3873 * and don't require drivers to check that the
3874 * channel list they get isn't longer than what
3875 * they can scan, as long as they can scan all
3876 * the channels they registered at once.
3878 nla_for_each_nested(attr2, freqs, tmp2)
3879 if (attr1 != attr2 &&
3880 nla_get_u32(attr1) == nla_get_u32(attr2))
3887 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
3889 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3890 struct net_device *dev = info->user_ptr[1];
3891 struct cfg80211_scan_request *request;
3892 struct nlattr *attr;
3893 struct wiphy *wiphy;
3894 int err, tmp, n_ssids = 0, n_channels, i;
3897 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3900 wiphy = &rdev->wiphy;
3902 if (!rdev->ops->scan)
3908 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
3909 n_channels = validate_scan_freqs(
3910 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
3914 enum ieee80211_band band;
3917 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
3918 if (wiphy->bands[band])
3919 n_channels += wiphy->bands[band]->n_channels;
3922 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
3923 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
3926 if (n_ssids > wiphy->max_scan_ssids)
3929 if (info->attrs[NL80211_ATTR_IE])
3930 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3934 if (ie_len > wiphy->max_scan_ie_len)
3937 request = kzalloc(sizeof(*request)
3938 + sizeof(*request->ssids) * n_ssids
3939 + sizeof(*request->channels) * n_channels
3940 + ie_len, GFP_KERNEL);
3945 request->ssids = (void *)&request->channels[n_channels];
3946 request->n_ssids = n_ssids;
3949 request->ie = (void *)(request->ssids + n_ssids);
3951 request->ie = (void *)(request->channels + n_channels);
3955 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
3956 /* user specified, bail out if channel not found */
3957 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
3958 struct ieee80211_channel *chan;
3960 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
3967 /* ignore disabled channels */
3968 if (chan->flags & IEEE80211_CHAN_DISABLED)
3971 request->channels[i] = chan;
3975 enum ieee80211_band band;
3978 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
3980 if (!wiphy->bands[band])
3982 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
3983 struct ieee80211_channel *chan;
3985 chan = &wiphy->bands[band]->channels[j];
3987 if (chan->flags & IEEE80211_CHAN_DISABLED)
3990 request->channels[i] = chan;
4001 request->n_channels = i;
4004 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
4005 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
4006 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
4010 request->ssids[i].ssid_len = nla_len(attr);
4011 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
4016 if (info->attrs[NL80211_ATTR_IE]) {
4017 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4018 memcpy((void *)request->ie,
4019 nla_data(info->attrs[NL80211_ATTR_IE]),
4023 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4024 if (wiphy->bands[i])
4026 (1 << wiphy->bands[i]->n_bitrates) - 1;
4028 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
4029 nla_for_each_nested(attr,
4030 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
4032 enum ieee80211_band band = nla_type(attr);
4034 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
4038 err = ieee80211_get_ratemask(wiphy->bands[band],
4041 &request->rates[band]);
4048 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
4051 request->wiphy = &rdev->wiphy;
4053 rdev->scan_req = request;
4054 err = rdev->ops->scan(&rdev->wiphy, dev, request);
4057 nl80211_send_scan_start(rdev, dev);
4061 rdev->scan_req = NULL;
4068 static int nl80211_start_sched_scan(struct sk_buff *skb,
4069 struct genl_info *info)
4071 struct cfg80211_sched_scan_request *request;
4072 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4073 struct net_device *dev = info->user_ptr[1];
4074 struct nlattr *attr;
4075 struct wiphy *wiphy;
4076 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
4078 enum ieee80211_band band;
4080 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
4082 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
4083 !rdev->ops->sched_scan_start)
4086 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4089 if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
4092 interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
4096 wiphy = &rdev->wiphy;
4098 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4099 n_channels = validate_scan_freqs(
4100 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
4106 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
4107 if (wiphy->bands[band])
4108 n_channels += wiphy->bands[band]->n_channels;
4111 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
4112 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
4116 if (n_ssids > wiphy->max_sched_scan_ssids)
4119 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH])
4120 nla_for_each_nested(attr,
4121 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
4125 if (n_match_sets > wiphy->max_match_sets)
4128 if (info->attrs[NL80211_ATTR_IE])
4129 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4133 if (ie_len > wiphy->max_sched_scan_ie_len)
4136 mutex_lock(&rdev->sched_scan_mtx);
4138 if (rdev->sched_scan_req) {
4143 request = kzalloc(sizeof(*request)
4144 + sizeof(*request->ssids) * n_ssids
4145 + sizeof(*request->match_sets) * n_match_sets
4146 + sizeof(*request->channels) * n_channels
4147 + ie_len, GFP_KERNEL);
4154 request->ssids = (void *)&request->channels[n_channels];
4155 request->n_ssids = n_ssids;
4158 request->ie = (void *)(request->ssids + n_ssids);
4160 request->ie = (void *)(request->channels + n_channels);
4165 request->match_sets = (void *)(request->ie + ie_len);
4166 else if (request->ssids)
4167 request->match_sets =
4168 (void *)(request->ssids + n_ssids);
4170 request->match_sets =
4171 (void *)(request->channels + n_channels);
4173 request->n_match_sets = n_match_sets;
4176 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4177 /* user specified, bail out if channel not found */
4178 nla_for_each_nested(attr,
4179 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
4181 struct ieee80211_channel *chan;
4183 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
4190 /* ignore disabled channels */
4191 if (chan->flags & IEEE80211_CHAN_DISABLED)
4194 request->channels[i] = chan;
4199 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
4201 if (!wiphy->bands[band])
4203 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
4204 struct ieee80211_channel *chan;
4206 chan = &wiphy->bands[band]->channels[j];
4208 if (chan->flags & IEEE80211_CHAN_DISABLED)
4211 request->channels[i] = chan;
4222 request->n_channels = i;
4225 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
4226 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
4228 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
4232 request->ssids[i].ssid_len = nla_len(attr);
4233 memcpy(request->ssids[i].ssid, nla_data(attr),
4240 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
4241 nla_for_each_nested(attr,
4242 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
4244 struct nlattr *ssid;
4246 nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
4247 nla_data(attr), nla_len(attr),
4248 nl80211_match_policy);
4249 ssid = tb[NL80211_ATTR_SCHED_SCAN_MATCH_SSID];
4251 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
4255 memcpy(request->match_sets[i].ssid.ssid,
4256 nla_data(ssid), nla_len(ssid));
4257 request->match_sets[i].ssid.ssid_len =
4264 if (info->attrs[NL80211_ATTR_IE]) {
4265 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4266 memcpy((void *)request->ie,
4267 nla_data(info->attrs[NL80211_ATTR_IE]),
4272 request->wiphy = &rdev->wiphy;
4273 request->interval = interval;
4275 err = rdev->ops->sched_scan_start(&rdev->wiphy, dev, request);
4277 rdev->sched_scan_req = request;
4278 nl80211_send_sched_scan(rdev, dev,
4279 NL80211_CMD_START_SCHED_SCAN);
4286 mutex_unlock(&rdev->sched_scan_mtx);
4290 static int nl80211_stop_sched_scan(struct sk_buff *skb,
4291 struct genl_info *info)
4293 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4296 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
4297 !rdev->ops->sched_scan_stop)
4300 mutex_lock(&rdev->sched_scan_mtx);
4301 err = __cfg80211_stop_sched_scan(rdev, false);
4302 mutex_unlock(&rdev->sched_scan_mtx);
4307 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
4309 struct cfg80211_registered_device *rdev,
4310 struct wireless_dev *wdev,
4311 struct cfg80211_internal_bss *intbss)
4313 struct cfg80211_bss *res = &intbss->pub;
4317 ASSERT_WDEV_LOCK(wdev);
4319 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).pid, seq, flags,
4320 NL80211_CMD_NEW_SCAN_RESULTS);
4324 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
4326 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation) ||
4327 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
4328 goto nla_put_failure;
4330 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
4332 goto nla_put_failure;
4333 if ((!is_zero_ether_addr(res->bssid) &&
4334 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)) ||
4335 (res->information_elements && res->len_information_elements &&
4336 nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
4337 res->len_information_elements,
4338 res->information_elements)) ||
4339 (res->beacon_ies && res->len_beacon_ies &&
4340 res->beacon_ies != res->information_elements &&
4341 nla_put(msg, NL80211_BSS_BEACON_IES,
4342 res->len_beacon_ies, res->beacon_ies)))
4343 goto nla_put_failure;
4345 nla_put_u64(msg, NL80211_BSS_TSF, res->tsf))
4346 goto nla_put_failure;
4347 if (res->beacon_interval &&
4348 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
4349 goto nla_put_failure;
4350 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
4351 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
4352 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
4353 jiffies_to_msecs(jiffies - intbss->ts)))
4354 goto nla_put_failure;
4356 switch (rdev->wiphy.signal_type) {
4357 case CFG80211_SIGNAL_TYPE_MBM:
4358 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
4359 goto nla_put_failure;
4361 case CFG80211_SIGNAL_TYPE_UNSPEC:
4362 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
4363 goto nla_put_failure;
4369 switch (wdev->iftype) {
4370 case NL80211_IFTYPE_P2P_CLIENT:
4371 case NL80211_IFTYPE_STATION:
4372 if (intbss == wdev->current_bss &&
4373 nla_put_u32(msg, NL80211_BSS_STATUS,
4374 NL80211_BSS_STATUS_ASSOCIATED))
4375 goto nla_put_failure;
4377 case NL80211_IFTYPE_ADHOC:
4378 if (intbss == wdev->current_bss &&
4379 nla_put_u32(msg, NL80211_BSS_STATUS,
4380 NL80211_BSS_STATUS_IBSS_JOINED))
4381 goto nla_put_failure;
4387 nla_nest_end(msg, bss);
4389 return genlmsg_end(msg, hdr);
4392 genlmsg_cancel(msg, hdr);
4396 static int nl80211_dump_scan(struct sk_buff *skb,
4397 struct netlink_callback *cb)
4399 struct cfg80211_registered_device *rdev;
4400 struct net_device *dev;
4401 struct cfg80211_internal_bss *scan;
4402 struct wireless_dev *wdev;
4403 int start = cb->args[1], idx = 0;
4406 err = nl80211_prepare_netdev_dump(skb, cb, &rdev, &dev);
4410 wdev = dev->ieee80211_ptr;
4413 spin_lock_bh(&rdev->bss_lock);
4414 cfg80211_bss_expire(rdev);
4416 cb->seq = rdev->bss_generation;
4418 list_for_each_entry(scan, &rdev->bss_list, list) {
4421 if (nl80211_send_bss(skb, cb,
4422 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4423 rdev, wdev, scan) < 0) {
4429 spin_unlock_bh(&rdev->bss_lock);
4433 nl80211_finish_netdev_dump(rdev);
4438 static int nl80211_send_survey(struct sk_buff *msg, u32 pid, u32 seq,
4439 int flags, struct net_device *dev,
4440 struct survey_info *survey)
4443 struct nlattr *infoattr;
4445 hdr = nl80211hdr_put(msg, pid, seq, flags,
4446 NL80211_CMD_NEW_SURVEY_RESULTS);
4450 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
4451 goto nla_put_failure;
4453 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
4455 goto nla_put_failure;
4457 if (nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
4458 survey->channel->center_freq))
4459 goto nla_put_failure;
4461 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
4462 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
4463 goto nla_put_failure;
4464 if ((survey->filled & SURVEY_INFO_IN_USE) &&
4465 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
4466 goto nla_put_failure;
4467 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME) &&
4468 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME,
4469 survey->channel_time))
4470 goto nla_put_failure;
4471 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_BUSY) &&
4472 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY,
4473 survey->channel_time_busy))
4474 goto nla_put_failure;
4475 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) &&
4476 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY,
4477 survey->channel_time_ext_busy))
4478 goto nla_put_failure;
4479 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_RX) &&
4480 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_RX,
4481 survey->channel_time_rx))
4482 goto nla_put_failure;
4483 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_TX) &&
4484 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_TX,
4485 survey->channel_time_tx))
4486 goto nla_put_failure;
4488 nla_nest_end(msg, infoattr);
4490 return genlmsg_end(msg, hdr);
4493 genlmsg_cancel(msg, hdr);
4497 static int nl80211_dump_survey(struct sk_buff *skb,
4498 struct netlink_callback *cb)
4500 struct survey_info survey;
4501 struct cfg80211_registered_device *dev;
4502 struct net_device *netdev;
4503 int survey_idx = cb->args[1];
4506 res = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
4510 if (!dev->ops->dump_survey) {
4516 struct ieee80211_channel *chan;
4518 res = dev->ops->dump_survey(&dev->wiphy, netdev, survey_idx,
4525 /* Survey without a channel doesn't make sense */
4526 if (!survey.channel) {
4531 chan = ieee80211_get_channel(&dev->wiphy,
4532 survey.channel->center_freq);
4533 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
4538 if (nl80211_send_survey(skb,
4539 NETLINK_CB(cb->skb).pid,
4540 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4548 cb->args[1] = survey_idx;
4551 nl80211_finish_netdev_dump(dev);
4555 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
4557 return auth_type <= NL80211_AUTHTYPE_MAX;
4560 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
4562 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
4563 NL80211_WPA_VERSION_2));
4566 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
4568 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4569 struct net_device *dev = info->user_ptr[1];
4570 struct ieee80211_channel *chan;
4571 const u8 *bssid, *ssid, *ie = NULL;
4572 int err, ssid_len, ie_len = 0;
4573 enum nl80211_auth_type auth_type;
4574 struct key_parse key;
4575 bool local_state_change;
4577 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4580 if (!info->attrs[NL80211_ATTR_MAC])
4583 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
4586 if (!info->attrs[NL80211_ATTR_SSID])
4589 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
4592 err = nl80211_parse_key(info, &key);
4597 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
4599 if (!key.p.key || !key.p.key_len)
4601 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
4602 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
4603 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
4604 key.p.key_len != WLAN_KEY_LEN_WEP104))
4616 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
4617 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
4626 if (!rdev->ops->auth)
4629 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4630 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4633 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4634 chan = ieee80211_get_channel(&rdev->wiphy,
4635 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
4636 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
4639 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4640 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
4642 if (info->attrs[NL80211_ATTR_IE]) {
4643 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4644 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4647 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
4648 if (!nl80211_valid_auth_type(auth_type))
4651 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
4654 * Since we no longer track auth state, ignore
4655 * requests to only change local state.
4657 if (local_state_change)
4660 return cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
4661 ssid, ssid_len, ie, ie_len,
4662 key.p.key, key.p.key_len, key.idx);
4665 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
4666 struct genl_info *info,
4667 struct cfg80211_crypto_settings *settings,
4670 memset(settings, 0, sizeof(*settings));
4672 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
4674 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
4676 proto = nla_get_u16(
4677 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
4678 settings->control_port_ethertype = cpu_to_be16(proto);
4679 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
4682 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
4683 settings->control_port_no_encrypt = true;
4685 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
4687 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
4691 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
4692 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
4693 settings->n_ciphers_pairwise = len / sizeof(u32);
4695 if (len % sizeof(u32))
4698 if (settings->n_ciphers_pairwise > cipher_limit)
4701 memcpy(settings->ciphers_pairwise, data, len);
4703 for (i = 0; i < settings->n_ciphers_pairwise; i++)
4704 if (!cfg80211_supported_cipher_suite(
4706 settings->ciphers_pairwise[i]))
4710 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
4711 settings->cipher_group =
4712 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
4713 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
4714 settings->cipher_group))
4718 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
4719 settings->wpa_versions =
4720 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
4721 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
4725 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
4729 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
4730 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
4731 settings->n_akm_suites = len / sizeof(u32);
4733 if (len % sizeof(u32))
4736 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
4739 memcpy(settings->akm_suites, data, len);
4745 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
4747 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4748 struct net_device *dev = info->user_ptr[1];
4749 struct cfg80211_crypto_settings crypto;
4750 struct ieee80211_channel *chan;
4751 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
4752 int err, ssid_len, ie_len = 0;
4753 bool use_mfp = false;
4755 struct ieee80211_ht_cap *ht_capa = NULL;
4756 struct ieee80211_ht_cap *ht_capa_mask = NULL;
4758 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4761 if (!info->attrs[NL80211_ATTR_MAC] ||
4762 !info->attrs[NL80211_ATTR_SSID] ||
4763 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
4766 if (!rdev->ops->assoc)
4769 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4770 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4773 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4775 chan = ieee80211_get_channel(&rdev->wiphy,
4776 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
4777 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
4780 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4781 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
4783 if (info->attrs[NL80211_ATTR_IE]) {
4784 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4785 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4788 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4789 enum nl80211_mfp mfp =
4790 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4791 if (mfp == NL80211_MFP_REQUIRED)
4793 else if (mfp != NL80211_MFP_NO)
4797 if (info->attrs[NL80211_ATTR_PREV_BSSID])
4798 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
4800 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
4801 flags |= ASSOC_REQ_DISABLE_HT;
4803 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
4805 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]);
4807 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
4810 ht_capa = nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4813 err = nl80211_crypto_settings(rdev, info, &crypto, 1);
4815 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
4816 ssid, ssid_len, ie, ie_len, use_mfp,
4817 &crypto, flags, ht_capa,
4823 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
4825 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4826 struct net_device *dev = info->user_ptr[1];
4827 const u8 *ie = NULL, *bssid;
4830 bool local_state_change;
4832 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4835 if (!info->attrs[NL80211_ATTR_MAC])
4838 if (!info->attrs[NL80211_ATTR_REASON_CODE])
4841 if (!rdev->ops->deauth)
4844 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4845 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4848 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4850 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
4851 if (reason_code == 0) {
4852 /* Reason Code 0 is reserved */
4856 if (info->attrs[NL80211_ATTR_IE]) {
4857 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4858 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4861 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
4863 return cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
4864 local_state_change);
4867 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
4869 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4870 struct net_device *dev = info->user_ptr[1];
4871 const u8 *ie = NULL, *bssid;
4874 bool local_state_change;
4876 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4879 if (!info->attrs[NL80211_ATTR_MAC])
4882 if (!info->attrs[NL80211_ATTR_REASON_CODE])
4885 if (!rdev->ops->disassoc)
4888 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4889 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4892 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4894 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
4895 if (reason_code == 0) {
4896 /* Reason Code 0 is reserved */
4900 if (info->attrs[NL80211_ATTR_IE]) {
4901 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4902 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4905 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
4907 return cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
4908 local_state_change);
4912 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
4913 int mcast_rate[IEEE80211_NUM_BANDS],
4916 struct wiphy *wiphy = &rdev->wiphy;
4920 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
4921 struct ieee80211_supported_band *sband;
4923 sband = wiphy->bands[band];
4927 for (i = 0; i < sband->n_bitrates; i++) {
4928 if (sband->bitrates[i].bitrate == rateval) {
4929 mcast_rate[band] = i + 1;
4939 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
4941 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4942 struct net_device *dev = info->user_ptr[1];
4943 struct cfg80211_ibss_params ibss;
4944 struct wiphy *wiphy;
4945 struct cfg80211_cached_keys *connkeys = NULL;
4948 memset(&ibss, 0, sizeof(ibss));
4950 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4953 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
4954 !info->attrs[NL80211_ATTR_SSID] ||
4955 !nla_len(info->attrs[NL80211_ATTR_SSID]))
4958 ibss.beacon_interval = 100;
4960 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
4961 ibss.beacon_interval =
4962 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
4963 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
4967 if (!rdev->ops->join_ibss)
4970 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
4973 wiphy = &rdev->wiphy;
4975 if (info->attrs[NL80211_ATTR_MAC]) {
4976 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4978 if (!is_valid_ether_addr(ibss.bssid))
4981 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4982 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
4984 if (info->attrs[NL80211_ATTR_IE]) {
4985 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4986 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4989 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
4990 enum nl80211_channel_type channel_type;
4992 if (!nl80211_valid_channel_type(info, &channel_type))
4995 if (channel_type != NL80211_CHAN_NO_HT &&
4996 !(wiphy->features & NL80211_FEATURE_HT_IBSS))
4999 ibss.channel_type = channel_type;
5001 ibss.channel_type = NL80211_CHAN_NO_HT;
5004 ibss.channel = rdev_freq_to_chan(rdev,
5005 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
5007 if (!ibss.channel ||
5008 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
5009 ibss.channel->flags & IEEE80211_CHAN_DISABLED)
5012 /* Both channels should be able to initiate communication */
5013 if ((ibss.channel_type == NL80211_CHAN_HT40PLUS ||
5014 ibss.channel_type == NL80211_CHAN_HT40MINUS) &&
5015 !cfg80211_can_beacon_sec_chan(&rdev->wiphy, ibss.channel,
5019 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
5020 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
5022 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
5024 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5026 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5027 struct ieee80211_supported_band *sband =
5028 wiphy->bands[ibss.channel->band];
5030 err = ieee80211_get_ratemask(sband, rates, n_rates,
5036 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
5037 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
5038 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
5041 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
5042 connkeys = nl80211_parse_connkeys(rdev,
5043 info->attrs[NL80211_ATTR_KEYS]);
5044 if (IS_ERR(connkeys))
5045 return PTR_ERR(connkeys);
5049 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
5051 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
5057 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
5059 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5060 struct net_device *dev = info->user_ptr[1];
5062 if (!rdev->ops->leave_ibss)
5065 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
5068 return cfg80211_leave_ibss(rdev, dev, false);
5071 #ifdef CONFIG_NL80211_TESTMODE
5072 static struct genl_multicast_group nl80211_testmode_mcgrp = {
5076 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
5078 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5081 if (!info->attrs[NL80211_ATTR_TESTDATA])
5085 if (rdev->ops->testmode_cmd) {
5086 rdev->testmode_info = info;
5087 err = rdev->ops->testmode_cmd(&rdev->wiphy,
5088 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
5089 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
5090 rdev->testmode_info = NULL;
5096 static int nl80211_testmode_dump(struct sk_buff *skb,
5097 struct netlink_callback *cb)
5099 struct cfg80211_registered_device *rdev;
5107 * 0 is a valid index, but not valid for args[0],
5108 * so we need to offset by 1.
5110 phy_idx = cb->args[0] - 1;
5112 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
5113 nl80211_fam.attrbuf, nl80211_fam.maxattr,
5117 if (nl80211_fam.attrbuf[NL80211_ATTR_WIPHY]) {
5118 phy_idx = nla_get_u32(
5119 nl80211_fam.attrbuf[NL80211_ATTR_WIPHY]);
5121 struct net_device *netdev;
5123 err = get_rdev_dev_by_ifindex(sock_net(skb->sk),
5124 nl80211_fam.attrbuf,
5129 phy_idx = rdev->wiphy_idx;
5130 cfg80211_unlock_rdev(rdev);
5132 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
5134 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
5138 data = nla_data((void *)cb->args[1]);
5139 data_len = nla_len((void *)cb->args[1]);
5142 mutex_lock(&cfg80211_mutex);
5143 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
5145 mutex_unlock(&cfg80211_mutex);
5148 cfg80211_lock_rdev(rdev);
5149 mutex_unlock(&cfg80211_mutex);
5151 if (!rdev->ops->testmode_dump) {
5157 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).pid,
5158 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5159 NL80211_CMD_TESTMODE);
5160 struct nlattr *tmdata;
5162 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
5163 genlmsg_cancel(skb, hdr);
5167 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
5169 genlmsg_cancel(skb, hdr);
5172 err = rdev->ops->testmode_dump(&rdev->wiphy, skb, cb,
5174 nla_nest_end(skb, tmdata);
5176 if (err == -ENOBUFS || err == -ENOENT) {
5177 genlmsg_cancel(skb, hdr);
5180 genlmsg_cancel(skb, hdr);
5184 genlmsg_end(skb, hdr);
5189 cb->args[0] = phy_idx + 1;
5191 cfg80211_unlock_rdev(rdev);
5195 static struct sk_buff *
5196 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
5197 int approxlen, u32 pid, u32 seq, gfp_t gfp)
5199 struct sk_buff *skb;
5201 struct nlattr *data;
5203 skb = nlmsg_new(approxlen + 100, gfp);
5207 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE);
5213 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
5214 goto nla_put_failure;
5215 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
5217 ((void **)skb->cb)[0] = rdev;
5218 ((void **)skb->cb)[1] = hdr;
5219 ((void **)skb->cb)[2] = data;
5228 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
5231 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
5233 if (WARN_ON(!rdev->testmode_info))
5236 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
5237 rdev->testmode_info->snd_pid,
5238 rdev->testmode_info->snd_seq,
5241 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
5243 int cfg80211_testmode_reply(struct sk_buff *skb)
5245 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
5246 void *hdr = ((void **)skb->cb)[1];
5247 struct nlattr *data = ((void **)skb->cb)[2];
5249 if (WARN_ON(!rdev->testmode_info)) {
5254 nla_nest_end(skb, data);
5255 genlmsg_end(skb, hdr);
5256 return genlmsg_reply(skb, rdev->testmode_info);
5258 EXPORT_SYMBOL(cfg80211_testmode_reply);
5260 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
5261 int approxlen, gfp_t gfp)
5263 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
5265 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
5267 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
5269 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
5271 void *hdr = ((void **)skb->cb)[1];
5272 struct nlattr *data = ((void **)skb->cb)[2];
5274 nla_nest_end(skb, data);
5275 genlmsg_end(skb, hdr);
5276 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
5278 EXPORT_SYMBOL(cfg80211_testmode_event);
5281 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
5283 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5284 struct net_device *dev = info->user_ptr[1];
5285 struct cfg80211_connect_params connect;
5286 struct wiphy *wiphy;
5287 struct cfg80211_cached_keys *connkeys = NULL;
5290 memset(&connect, 0, sizeof(connect));
5292 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5295 if (!info->attrs[NL80211_ATTR_SSID] ||
5296 !nla_len(info->attrs[NL80211_ATTR_SSID]))
5299 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
5301 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
5302 if (!nl80211_valid_auth_type(connect.auth_type))
5305 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
5307 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
5309 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
5310 NL80211_MAX_NR_CIPHER_SUITES);
5314 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5315 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5318 wiphy = &rdev->wiphy;
5320 connect.bg_scan_period = -1;
5321 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
5322 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
5323 connect.bg_scan_period =
5324 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
5327 if (info->attrs[NL80211_ATTR_MAC])
5328 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5329 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5330 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5332 if (info->attrs[NL80211_ATTR_IE]) {
5333 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5334 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5337 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
5339 ieee80211_get_channel(wiphy,
5340 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
5341 if (!connect.channel ||
5342 connect.channel->flags & IEEE80211_CHAN_DISABLED)
5346 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
5347 connkeys = nl80211_parse_connkeys(rdev,
5348 info->attrs[NL80211_ATTR_KEYS]);
5349 if (IS_ERR(connkeys))
5350 return PTR_ERR(connkeys);
5353 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
5354 connect.flags |= ASSOC_REQ_DISABLE_HT;
5356 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
5357 memcpy(&connect.ht_capa_mask,
5358 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
5359 sizeof(connect.ht_capa_mask));
5361 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
5362 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
5364 memcpy(&connect.ht_capa,
5365 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
5366 sizeof(connect.ht_capa));
5369 err = cfg80211_connect(rdev, dev, &connect, connkeys);
5375 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
5377 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5378 struct net_device *dev = info->user_ptr[1];
5381 if (!info->attrs[NL80211_ATTR_REASON_CODE])
5382 reason = WLAN_REASON_DEAUTH_LEAVING;
5384 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5389 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5390 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5393 return cfg80211_disconnect(rdev, dev, reason, true);
5396 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
5398 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5403 if (!info->attrs[NL80211_ATTR_PID])
5406 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
5408 net = get_net_ns_by_pid(pid);
5410 return PTR_ERR(net);
5414 /* check if anything to do */
5415 if (!net_eq(wiphy_net(&rdev->wiphy), net))
5416 err = cfg80211_switch_netns(rdev, net);
5422 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
5424 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5425 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
5426 struct cfg80211_pmksa *pmksa) = NULL;
5427 struct net_device *dev = info->user_ptr[1];
5428 struct cfg80211_pmksa pmksa;
5430 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
5432 if (!info->attrs[NL80211_ATTR_MAC])
5435 if (!info->attrs[NL80211_ATTR_PMKID])
5438 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
5439 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5441 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5442 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5445 switch (info->genlhdr->cmd) {
5446 case NL80211_CMD_SET_PMKSA:
5447 rdev_ops = rdev->ops->set_pmksa;
5449 case NL80211_CMD_DEL_PMKSA:
5450 rdev_ops = rdev->ops->del_pmksa;
5460 return rdev_ops(&rdev->wiphy, dev, &pmksa);
5463 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
5465 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5466 struct net_device *dev = info->user_ptr[1];
5468 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5469 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5472 if (!rdev->ops->flush_pmksa)
5475 return rdev->ops->flush_pmksa(&rdev->wiphy, dev);
5478 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
5480 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5481 struct net_device *dev = info->user_ptr[1];
5482 u8 action_code, dialog_token;
5486 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
5487 !rdev->ops->tdls_mgmt)
5490 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
5491 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
5492 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
5493 !info->attrs[NL80211_ATTR_IE] ||
5494 !info->attrs[NL80211_ATTR_MAC])
5497 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
5498 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
5499 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
5500 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
5502 return rdev->ops->tdls_mgmt(&rdev->wiphy, dev, peer, action_code,
5503 dialog_token, status_code,
5504 nla_data(info->attrs[NL80211_ATTR_IE]),
5505 nla_len(info->attrs[NL80211_ATTR_IE]));
5508 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
5510 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5511 struct net_device *dev = info->user_ptr[1];
5512 enum nl80211_tdls_operation operation;
5515 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
5516 !rdev->ops->tdls_oper)
5519 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
5520 !info->attrs[NL80211_ATTR_MAC])
5523 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
5524 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
5526 return rdev->ops->tdls_oper(&rdev->wiphy, dev, peer, operation);
5529 static int nl80211_remain_on_channel(struct sk_buff *skb,
5530 struct genl_info *info)
5532 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5533 struct net_device *dev = info->user_ptr[1];
5534 struct ieee80211_channel *chan;
5535 struct sk_buff *msg;
5538 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
5542 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
5543 !info->attrs[NL80211_ATTR_DURATION])
5546 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
5548 if (!rdev->ops->remain_on_channel ||
5549 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
5553 * We should be on that channel for at least a minimum amount of
5554 * time (10ms) but no longer than the driver supports.
5556 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
5557 duration > rdev->wiphy.max_remain_on_channel_duration)
5560 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
5561 !nl80211_valid_channel_type(info, &channel_type))
5564 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
5565 chan = rdev_freq_to_chan(rdev, freq, channel_type);
5569 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5573 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
5574 NL80211_CMD_REMAIN_ON_CHANNEL);
5581 err = rdev->ops->remain_on_channel(&rdev->wiphy, dev, chan,
5582 channel_type, duration, &cookie);
5587 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
5588 goto nla_put_failure;
5590 genlmsg_end(msg, hdr);
5592 return genlmsg_reply(msg, info);
5601 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
5602 struct genl_info *info)
5604 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5605 struct net_device *dev = info->user_ptr[1];
5608 if (!info->attrs[NL80211_ATTR_COOKIE])
5611 if (!rdev->ops->cancel_remain_on_channel)
5614 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
5616 return rdev->ops->cancel_remain_on_channel(&rdev->wiphy, dev, cookie);
5619 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
5620 u8 *rates, u8 rates_len)
5625 for (i = 0; i < rates_len; i++) {
5626 int rate = (rates[i] & 0x7f) * 5;
5628 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
5629 struct ieee80211_rate *srate =
5630 &sband->bitrates[ridx];
5631 if (rate == srate->bitrate) {
5636 if (ridx == sband->n_bitrates)
5637 return 0; /* rate not found */
5643 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
5644 u8 *rates, u8 rates_len,
5645 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
5649 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
5651 for (i = 0; i < rates_len; i++) {
5654 ridx = rates[i] / 8;
5655 rbit = BIT(rates[i] % 8);
5657 /* check validity */
5658 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
5661 /* check availability */
5662 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
5671 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
5672 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
5673 .len = NL80211_MAX_SUPP_RATES },
5674 [NL80211_TXRATE_MCS] = { .type = NLA_BINARY,
5675 .len = NL80211_MAX_SUPP_HT_RATES },
5678 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
5679 struct genl_info *info)
5681 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
5682 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5683 struct cfg80211_bitrate_mask mask;
5685 struct net_device *dev = info->user_ptr[1];
5686 struct nlattr *tx_rates;
5687 struct ieee80211_supported_band *sband;
5689 if (info->attrs[NL80211_ATTR_TX_RATES] == NULL)
5692 if (!rdev->ops->set_bitrate_mask)
5695 memset(&mask, 0, sizeof(mask));
5696 /* Default to all rates enabled */
5697 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
5698 sband = rdev->wiphy.bands[i];
5699 mask.control[i].legacy =
5700 sband ? (1 << sband->n_bitrates) - 1 : 0;
5702 memcpy(mask.control[i].mcs,
5703 sband->ht_cap.mcs.rx_mask,
5704 sizeof(mask.control[i].mcs));
5706 memset(mask.control[i].mcs, 0,
5707 sizeof(mask.control[i].mcs));
5711 * The nested attribute uses enum nl80211_band as the index. This maps
5712 * directly to the enum ieee80211_band values used in cfg80211.
5714 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
5715 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
5717 enum ieee80211_band band = nla_type(tx_rates);
5718 if (band < 0 || band >= IEEE80211_NUM_BANDS)
5720 sband = rdev->wiphy.bands[band];
5723 nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
5724 nla_len(tx_rates), nl80211_txattr_policy);
5725 if (tb[NL80211_TXRATE_LEGACY]) {
5726 mask.control[band].legacy = rateset_to_mask(
5728 nla_data(tb[NL80211_TXRATE_LEGACY]),
5729 nla_len(tb[NL80211_TXRATE_LEGACY]));
5730 if ((mask.control[band].legacy == 0) &&
5731 nla_len(tb[NL80211_TXRATE_LEGACY]))
5734 if (tb[NL80211_TXRATE_MCS]) {
5735 if (!ht_rateset_to_mask(
5737 nla_data(tb[NL80211_TXRATE_MCS]),
5738 nla_len(tb[NL80211_TXRATE_MCS]),
5739 mask.control[band].mcs))
5743 if (mask.control[band].legacy == 0) {
5744 /* don't allow empty legacy rates if HT
5745 * is not even supported. */
5746 if (!rdev->wiphy.bands[band]->ht_cap.ht_supported)
5749 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
5750 if (mask.control[band].mcs[i])
5753 /* legacy and mcs rates may not be both empty */
5754 if (i == IEEE80211_HT_MCS_MASK_LEN)
5759 return rdev->ops->set_bitrate_mask(&rdev->wiphy, dev, NULL, &mask);
5762 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
5764 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5765 struct net_device *dev = info->user_ptr[1];
5766 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
5768 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
5771 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
5772 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
5774 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5775 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
5776 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
5777 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5778 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5779 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
5780 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5783 /* not much point in registering if we can't reply */
5784 if (!rdev->ops->mgmt_tx)
5787 return cfg80211_mlme_register_mgmt(dev->ieee80211_ptr, info->snd_pid,
5789 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
5790 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
5793 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
5795 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5796 struct net_device *dev = info->user_ptr[1];
5797 struct ieee80211_channel *chan;
5798 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
5799 bool channel_type_valid = false;
5804 struct sk_buff *msg = NULL;
5805 unsigned int wait = 0;
5806 bool offchan, no_cck, dont_wait_for_ack;
5808 dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
5810 if (!info->attrs[NL80211_ATTR_FRAME] ||
5811 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
5814 if (!rdev->ops->mgmt_tx)
5817 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5818 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
5819 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
5820 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5821 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5822 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
5823 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5826 if (info->attrs[NL80211_ATTR_DURATION]) {
5827 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
5829 wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
5832 * We should wait on the channel for at least a minimum amount
5833 * of time (10ms) but no longer than the driver supports.
5835 if (wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
5836 wait > rdev->wiphy.max_remain_on_channel_duration)
5841 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
5842 if (!nl80211_valid_channel_type(info, &channel_type))
5844 channel_type_valid = true;
5847 offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
5849 if (offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
5852 no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5854 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
5855 chan = rdev_freq_to_chan(rdev, freq, channel_type);
5859 if (!dont_wait_for_ack) {
5860 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5864 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
5873 err = cfg80211_mlme_mgmt_tx(rdev, dev, chan, offchan, channel_type,
5874 channel_type_valid, wait,
5875 nla_data(info->attrs[NL80211_ATTR_FRAME]),
5876 nla_len(info->attrs[NL80211_ATTR_FRAME]),
5877 no_cck, dont_wait_for_ack, &cookie);
5882 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
5883 goto nla_put_failure;
5885 genlmsg_end(msg, hdr);
5886 return genlmsg_reply(msg, info);
5898 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
5900 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5901 struct net_device *dev = info->user_ptr[1];
5904 if (!info->attrs[NL80211_ATTR_COOKIE])
5907 if (!rdev->ops->mgmt_tx_cancel_wait)
5910 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5911 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
5912 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
5913 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5914 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5915 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5918 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
5920 return rdev->ops->mgmt_tx_cancel_wait(&rdev->wiphy, dev, cookie);
5923 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
5925 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5926 struct wireless_dev *wdev;
5927 struct net_device *dev = info->user_ptr[1];
5932 if (!info->attrs[NL80211_ATTR_PS_STATE])
5935 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
5937 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
5940 wdev = dev->ieee80211_ptr;
5942 if (!rdev->ops->set_power_mgmt)
5945 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
5947 if (state == wdev->ps)
5950 err = rdev->ops->set_power_mgmt(wdev->wiphy, dev, state,
5957 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
5959 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5960 enum nl80211_ps_state ps_state;
5961 struct wireless_dev *wdev;
5962 struct net_device *dev = info->user_ptr[1];
5963 struct sk_buff *msg;
5967 wdev = dev->ieee80211_ptr;
5969 if (!rdev->ops->set_power_mgmt)
5972 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5976 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
5977 NL80211_CMD_GET_POWER_SAVE);
5984 ps_state = NL80211_PS_ENABLED;
5986 ps_state = NL80211_PS_DISABLED;
5988 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
5989 goto nla_put_failure;
5991 genlmsg_end(msg, hdr);
5992 return genlmsg_reply(msg, info);
6001 static struct nla_policy
6002 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] __read_mostly = {
6003 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
6004 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
6005 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
6008 static int nl80211_set_cqm_rssi(struct genl_info *info,
6009 s32 threshold, u32 hysteresis)
6011 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6012 struct wireless_dev *wdev;
6013 struct net_device *dev = info->user_ptr[1];
6018 wdev = dev->ieee80211_ptr;
6020 if (!rdev->ops->set_cqm_rssi_config)
6023 if (wdev->iftype != NL80211_IFTYPE_STATION &&
6024 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
6027 return rdev->ops->set_cqm_rssi_config(wdev->wiphy, dev,
6028 threshold, hysteresis);
6031 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
6033 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
6037 cqm = info->attrs[NL80211_ATTR_CQM];
6043 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
6044 nl80211_attr_cqm_policy);
6048 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
6049 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
6052 threshold = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
6053 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
6054 err = nl80211_set_cqm_rssi(info, threshold, hysteresis);
6062 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
6064 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6065 struct net_device *dev = info->user_ptr[1];
6066 struct mesh_config cfg;
6067 struct mesh_setup setup;
6070 /* start with default */
6071 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
6072 memcpy(&setup, &default_mesh_setup, sizeof(setup));
6074 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
6075 /* and parse parameters if given */
6076 err = nl80211_parse_mesh_config(info, &cfg, NULL);
6081 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
6082 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
6085 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
6086 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
6088 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
6089 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
6090 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
6093 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
6094 /* parse additional setup parameters if given */
6095 err = nl80211_parse_mesh_setup(info, &setup);
6100 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6101 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
6103 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
6104 !nl80211_valid_channel_type(info, &channel_type))
6107 setup.channel = rdev_freq_to_chan(rdev,
6108 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
6112 setup.channel_type = channel_type;
6114 /* cfg80211_join_mesh() will sort it out */
6115 setup.channel = NULL;
6118 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
6121 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
6123 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6124 struct net_device *dev = info->user_ptr[1];
6126 return cfg80211_leave_mesh(rdev, dev);
6129 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
6131 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6132 struct sk_buff *msg;
6135 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns)
6138 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6142 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
6143 NL80211_CMD_GET_WOWLAN);
6145 goto nla_put_failure;
6148 struct nlattr *nl_wowlan;
6150 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
6152 goto nla_put_failure;
6154 if ((rdev->wowlan->any &&
6155 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6156 (rdev->wowlan->disconnect &&
6157 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6158 (rdev->wowlan->magic_pkt &&
6159 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6160 (rdev->wowlan->gtk_rekey_failure &&
6161 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6162 (rdev->wowlan->eap_identity_req &&
6163 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6164 (rdev->wowlan->four_way_handshake &&
6165 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6166 (rdev->wowlan->rfkill_release &&
6167 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
6168 goto nla_put_failure;
6169 if (rdev->wowlan->n_patterns) {
6170 struct nlattr *nl_pats, *nl_pat;
6173 nl_pats = nla_nest_start(msg,
6174 NL80211_WOWLAN_TRIG_PKT_PATTERN);
6176 goto nla_put_failure;
6178 for (i = 0; i < rdev->wowlan->n_patterns; i++) {
6179 nl_pat = nla_nest_start(msg, i + 1);
6181 goto nla_put_failure;
6182 pat_len = rdev->wowlan->patterns[i].pattern_len;
6183 if (nla_put(msg, NL80211_WOWLAN_PKTPAT_MASK,
6184 DIV_ROUND_UP(pat_len, 8),
6185 rdev->wowlan->patterns[i].mask) ||
6186 nla_put(msg, NL80211_WOWLAN_PKTPAT_PATTERN,
6188 rdev->wowlan->patterns[i].pattern))
6189 goto nla_put_failure;
6190 nla_nest_end(msg, nl_pat);
6192 nla_nest_end(msg, nl_pats);
6195 nla_nest_end(msg, nl_wowlan);
6198 genlmsg_end(msg, hdr);
6199 return genlmsg_reply(msg, info);
6206 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
6208 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6209 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
6210 struct cfg80211_wowlan no_triggers = {};
6211 struct cfg80211_wowlan new_triggers = {};
6212 struct wiphy_wowlan_support *wowlan = &rdev->wiphy.wowlan;
6214 bool prev_enabled = rdev->wowlan;
6216 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns)
6219 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS])
6222 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
6223 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
6224 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
6225 nl80211_wowlan_policy);
6229 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
6230 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
6232 new_triggers.any = true;
6235 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
6236 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
6238 new_triggers.disconnect = true;
6241 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
6242 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
6244 new_triggers.magic_pkt = true;
6247 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
6250 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
6251 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
6253 new_triggers.gtk_rekey_failure = true;
6256 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
6257 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
6259 new_triggers.eap_identity_req = true;
6262 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
6263 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
6265 new_triggers.four_way_handshake = true;
6268 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
6269 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
6271 new_triggers.rfkill_release = true;
6274 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
6277 int rem, pat_len, mask_len;
6278 struct nlattr *pat_tb[NUM_NL80211_WOWLAN_PKTPAT];
6280 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
6283 if (n_patterns > wowlan->n_patterns)
6286 new_triggers.patterns = kcalloc(n_patterns,
6287 sizeof(new_triggers.patterns[0]),
6289 if (!new_triggers.patterns)
6292 new_triggers.n_patterns = n_patterns;
6295 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
6297 nla_parse(pat_tb, MAX_NL80211_WOWLAN_PKTPAT,
6298 nla_data(pat), nla_len(pat), NULL);
6300 if (!pat_tb[NL80211_WOWLAN_PKTPAT_MASK] ||
6301 !pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN])
6303 pat_len = nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]);
6304 mask_len = DIV_ROUND_UP(pat_len, 8);
6305 if (nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]) !=
6308 if (pat_len > wowlan->pattern_max_len ||
6309 pat_len < wowlan->pattern_min_len)
6312 new_triggers.patterns[i].mask =
6313 kmalloc(mask_len + pat_len, GFP_KERNEL);
6314 if (!new_triggers.patterns[i].mask) {
6318 new_triggers.patterns[i].pattern =
6319 new_triggers.patterns[i].mask + mask_len;
6320 memcpy(new_triggers.patterns[i].mask,
6321 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]),
6323 new_triggers.patterns[i].pattern_len = pat_len;
6324 memcpy(new_triggers.patterns[i].pattern,
6325 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]),
6331 if (memcmp(&new_triggers, &no_triggers, sizeof(new_triggers))) {
6332 struct cfg80211_wowlan *ntrig;
6333 ntrig = kmemdup(&new_triggers, sizeof(new_triggers),
6339 cfg80211_rdev_free_wowlan(rdev);
6340 rdev->wowlan = ntrig;
6343 cfg80211_rdev_free_wowlan(rdev);
6344 rdev->wowlan = NULL;
6347 if (rdev->ops->set_wakeup && prev_enabled != !!rdev->wowlan)
6348 rdev->ops->set_wakeup(&rdev->wiphy, rdev->wowlan);
6352 for (i = 0; i < new_triggers.n_patterns; i++)
6353 kfree(new_triggers.patterns[i].mask);
6354 kfree(new_triggers.patterns);
6358 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
6360 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6361 struct net_device *dev = info->user_ptr[1];
6362 struct wireless_dev *wdev = dev->ieee80211_ptr;
6363 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
6364 struct cfg80211_gtk_rekey_data rekey_data;
6367 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
6370 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
6371 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
6372 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
6373 nl80211_rekey_policy);
6377 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
6379 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
6381 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
6384 memcpy(rekey_data.kek, nla_data(tb[NL80211_REKEY_DATA_KEK]),
6386 memcpy(rekey_data.kck, nla_data(tb[NL80211_REKEY_DATA_KCK]),
6388 memcpy(rekey_data.replay_ctr,
6389 nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]),
6390 NL80211_REPLAY_CTR_LEN);
6393 if (!wdev->current_bss) {
6398 if (!rdev->ops->set_rekey_data) {
6403 err = rdev->ops->set_rekey_data(&rdev->wiphy, dev, &rekey_data);
6409 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
6410 struct genl_info *info)
6412 struct net_device *dev = info->user_ptr[1];
6413 struct wireless_dev *wdev = dev->ieee80211_ptr;
6415 if (wdev->iftype != NL80211_IFTYPE_AP &&
6416 wdev->iftype != NL80211_IFTYPE_P2P_GO)
6419 if (wdev->ap_unexpected_nlpid)
6422 wdev->ap_unexpected_nlpid = info->snd_pid;
6426 static int nl80211_probe_client(struct sk_buff *skb,
6427 struct genl_info *info)
6429 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6430 struct net_device *dev = info->user_ptr[1];
6431 struct wireless_dev *wdev = dev->ieee80211_ptr;
6432 struct sk_buff *msg;
6438 if (wdev->iftype != NL80211_IFTYPE_AP &&
6439 wdev->iftype != NL80211_IFTYPE_P2P_GO)
6442 if (!info->attrs[NL80211_ATTR_MAC])
6445 if (!rdev->ops->probe_client)
6448 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6452 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
6453 NL80211_CMD_PROBE_CLIENT);
6460 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6462 err = rdev->ops->probe_client(&rdev->wiphy, dev, addr, &cookie);
6466 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
6467 goto nla_put_failure;
6469 genlmsg_end(msg, hdr);
6471 return genlmsg_reply(msg, info);
6480 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
6482 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6484 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
6487 if (rdev->ap_beacons_nlpid)
6490 rdev->ap_beacons_nlpid = info->snd_pid;
6495 #define NL80211_FLAG_NEED_WIPHY 0x01
6496 #define NL80211_FLAG_NEED_NETDEV 0x02
6497 #define NL80211_FLAG_NEED_RTNL 0x04
6498 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
6499 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
6500 NL80211_FLAG_CHECK_NETDEV_UP)
6502 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
6503 struct genl_info *info)
6505 struct cfg80211_registered_device *rdev;
6506 struct net_device *dev;
6508 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
6513 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
6514 rdev = cfg80211_get_dev_from_info(info);
6518 return PTR_ERR(rdev);
6520 info->user_ptr[0] = rdev;
6521 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
6522 err = get_rdev_dev_by_ifindex(genl_info_net(info), info->attrs,
6529 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
6530 !netif_running(dev)) {
6531 cfg80211_unlock_rdev(rdev);
6537 info->user_ptr[0] = rdev;
6538 info->user_ptr[1] = dev;
6544 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
6545 struct genl_info *info)
6547 if (info->user_ptr[0])
6548 cfg80211_unlock_rdev(info->user_ptr[0]);
6549 if (info->user_ptr[1])
6550 dev_put(info->user_ptr[1]);
6551 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
6555 static struct genl_ops nl80211_ops[] = {
6557 .cmd = NL80211_CMD_GET_WIPHY,
6558 .doit = nl80211_get_wiphy,
6559 .dumpit = nl80211_dump_wiphy,
6560 .policy = nl80211_policy,
6561 /* can be retrieved by unprivileged users */
6562 .internal_flags = NL80211_FLAG_NEED_WIPHY,
6565 .cmd = NL80211_CMD_SET_WIPHY,
6566 .doit = nl80211_set_wiphy,
6567 .policy = nl80211_policy,
6568 .flags = GENL_ADMIN_PERM,
6569 .internal_flags = NL80211_FLAG_NEED_RTNL,
6572 .cmd = NL80211_CMD_GET_INTERFACE,
6573 .doit = nl80211_get_interface,
6574 .dumpit = nl80211_dump_interface,
6575 .policy = nl80211_policy,
6576 /* can be retrieved by unprivileged users */
6577 .internal_flags = NL80211_FLAG_NEED_NETDEV,
6580 .cmd = NL80211_CMD_SET_INTERFACE,
6581 .doit = nl80211_set_interface,
6582 .policy = nl80211_policy,
6583 .flags = GENL_ADMIN_PERM,
6584 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6585 NL80211_FLAG_NEED_RTNL,
6588 .cmd = NL80211_CMD_NEW_INTERFACE,
6589 .doit = nl80211_new_interface,
6590 .policy = nl80211_policy,
6591 .flags = GENL_ADMIN_PERM,
6592 .internal_flags = NL80211_FLAG_NEED_WIPHY |
6593 NL80211_FLAG_NEED_RTNL,
6596 .cmd = NL80211_CMD_DEL_INTERFACE,
6597 .doit = nl80211_del_interface,
6598 .policy = nl80211_policy,
6599 .flags = GENL_ADMIN_PERM,
6600 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6601 NL80211_FLAG_NEED_RTNL,
6604 .cmd = NL80211_CMD_GET_KEY,
6605 .doit = nl80211_get_key,
6606 .policy = nl80211_policy,
6607 .flags = GENL_ADMIN_PERM,
6608 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6609 NL80211_FLAG_NEED_RTNL,
6612 .cmd = NL80211_CMD_SET_KEY,
6613 .doit = nl80211_set_key,
6614 .policy = nl80211_policy,
6615 .flags = GENL_ADMIN_PERM,
6616 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6617 NL80211_FLAG_NEED_RTNL,
6620 .cmd = NL80211_CMD_NEW_KEY,
6621 .doit = nl80211_new_key,
6622 .policy = nl80211_policy,
6623 .flags = GENL_ADMIN_PERM,
6624 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6625 NL80211_FLAG_NEED_RTNL,
6628 .cmd = NL80211_CMD_DEL_KEY,
6629 .doit = nl80211_del_key,
6630 .policy = nl80211_policy,
6631 .flags = GENL_ADMIN_PERM,
6632 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6633 NL80211_FLAG_NEED_RTNL,
6636 .cmd = NL80211_CMD_SET_BEACON,
6637 .policy = nl80211_policy,
6638 .flags = GENL_ADMIN_PERM,
6639 .doit = nl80211_set_beacon,
6640 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6641 NL80211_FLAG_NEED_RTNL,
6644 .cmd = NL80211_CMD_START_AP,
6645 .policy = nl80211_policy,
6646 .flags = GENL_ADMIN_PERM,
6647 .doit = nl80211_start_ap,
6648 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6649 NL80211_FLAG_NEED_RTNL,
6652 .cmd = NL80211_CMD_STOP_AP,
6653 .policy = nl80211_policy,
6654 .flags = GENL_ADMIN_PERM,
6655 .doit = nl80211_stop_ap,
6656 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6657 NL80211_FLAG_NEED_RTNL,
6660 .cmd = NL80211_CMD_GET_STATION,
6661 .doit = nl80211_get_station,
6662 .dumpit = nl80211_dump_station,
6663 .policy = nl80211_policy,
6664 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6665 NL80211_FLAG_NEED_RTNL,
6668 .cmd = NL80211_CMD_SET_STATION,
6669 .doit = nl80211_set_station,
6670 .policy = nl80211_policy,
6671 .flags = GENL_ADMIN_PERM,
6672 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6673 NL80211_FLAG_NEED_RTNL,
6676 .cmd = NL80211_CMD_NEW_STATION,
6677 .doit = nl80211_new_station,
6678 .policy = nl80211_policy,
6679 .flags = GENL_ADMIN_PERM,
6680 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6681 NL80211_FLAG_NEED_RTNL,
6684 .cmd = NL80211_CMD_DEL_STATION,
6685 .doit = nl80211_del_station,
6686 .policy = nl80211_policy,
6687 .flags = GENL_ADMIN_PERM,
6688 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6689 NL80211_FLAG_NEED_RTNL,
6692 .cmd = NL80211_CMD_GET_MPATH,
6693 .doit = nl80211_get_mpath,
6694 .dumpit = nl80211_dump_mpath,
6695 .policy = nl80211_policy,
6696 .flags = GENL_ADMIN_PERM,
6697 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6698 NL80211_FLAG_NEED_RTNL,
6701 .cmd = NL80211_CMD_SET_MPATH,
6702 .doit = nl80211_set_mpath,
6703 .policy = nl80211_policy,
6704 .flags = GENL_ADMIN_PERM,
6705 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6706 NL80211_FLAG_NEED_RTNL,
6709 .cmd = NL80211_CMD_NEW_MPATH,
6710 .doit = nl80211_new_mpath,
6711 .policy = nl80211_policy,
6712 .flags = GENL_ADMIN_PERM,
6713 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6714 NL80211_FLAG_NEED_RTNL,
6717 .cmd = NL80211_CMD_DEL_MPATH,
6718 .doit = nl80211_del_mpath,
6719 .policy = nl80211_policy,
6720 .flags = GENL_ADMIN_PERM,
6721 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6722 NL80211_FLAG_NEED_RTNL,
6725 .cmd = NL80211_CMD_SET_BSS,
6726 .doit = nl80211_set_bss,
6727 .policy = nl80211_policy,
6728 .flags = GENL_ADMIN_PERM,
6729 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6730 NL80211_FLAG_NEED_RTNL,
6733 .cmd = NL80211_CMD_GET_REG,
6734 .doit = nl80211_get_reg,
6735 .policy = nl80211_policy,
6736 /* can be retrieved by unprivileged users */
6739 .cmd = NL80211_CMD_SET_REG,
6740 .doit = nl80211_set_reg,
6741 .policy = nl80211_policy,
6742 .flags = GENL_ADMIN_PERM,
6745 .cmd = NL80211_CMD_REQ_SET_REG,
6746 .doit = nl80211_req_set_reg,
6747 .policy = nl80211_policy,
6748 .flags = GENL_ADMIN_PERM,
6751 .cmd = NL80211_CMD_GET_MESH_CONFIG,
6752 .doit = nl80211_get_mesh_config,
6753 .policy = nl80211_policy,
6754 /* can be retrieved by unprivileged users */
6755 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6756 NL80211_FLAG_NEED_RTNL,
6759 .cmd = NL80211_CMD_SET_MESH_CONFIG,
6760 .doit = nl80211_update_mesh_config,
6761 .policy = nl80211_policy,
6762 .flags = GENL_ADMIN_PERM,
6763 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6764 NL80211_FLAG_NEED_RTNL,
6767 .cmd = NL80211_CMD_TRIGGER_SCAN,
6768 .doit = nl80211_trigger_scan,
6769 .policy = nl80211_policy,
6770 .flags = GENL_ADMIN_PERM,
6771 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6772 NL80211_FLAG_NEED_RTNL,
6775 .cmd = NL80211_CMD_GET_SCAN,
6776 .policy = nl80211_policy,
6777 .dumpit = nl80211_dump_scan,
6780 .cmd = NL80211_CMD_START_SCHED_SCAN,
6781 .doit = nl80211_start_sched_scan,
6782 .policy = nl80211_policy,
6783 .flags = GENL_ADMIN_PERM,
6784 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6785 NL80211_FLAG_NEED_RTNL,
6788 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
6789 .doit = nl80211_stop_sched_scan,
6790 .policy = nl80211_policy,
6791 .flags = GENL_ADMIN_PERM,
6792 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6793 NL80211_FLAG_NEED_RTNL,
6796 .cmd = NL80211_CMD_AUTHENTICATE,
6797 .doit = nl80211_authenticate,
6798 .policy = nl80211_policy,
6799 .flags = GENL_ADMIN_PERM,
6800 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6801 NL80211_FLAG_NEED_RTNL,
6804 .cmd = NL80211_CMD_ASSOCIATE,
6805 .doit = nl80211_associate,
6806 .policy = nl80211_policy,
6807 .flags = GENL_ADMIN_PERM,
6808 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6809 NL80211_FLAG_NEED_RTNL,
6812 .cmd = NL80211_CMD_DEAUTHENTICATE,
6813 .doit = nl80211_deauthenticate,
6814 .policy = nl80211_policy,
6815 .flags = GENL_ADMIN_PERM,
6816 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6817 NL80211_FLAG_NEED_RTNL,
6820 .cmd = NL80211_CMD_DISASSOCIATE,
6821 .doit = nl80211_disassociate,
6822 .policy = nl80211_policy,
6823 .flags = GENL_ADMIN_PERM,
6824 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6825 NL80211_FLAG_NEED_RTNL,
6828 .cmd = NL80211_CMD_JOIN_IBSS,
6829 .doit = nl80211_join_ibss,
6830 .policy = nl80211_policy,
6831 .flags = GENL_ADMIN_PERM,
6832 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6833 NL80211_FLAG_NEED_RTNL,
6836 .cmd = NL80211_CMD_LEAVE_IBSS,
6837 .doit = nl80211_leave_ibss,
6838 .policy = nl80211_policy,
6839 .flags = GENL_ADMIN_PERM,
6840 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6841 NL80211_FLAG_NEED_RTNL,
6843 #ifdef CONFIG_NL80211_TESTMODE
6845 .cmd = NL80211_CMD_TESTMODE,
6846 .doit = nl80211_testmode_do,
6847 .dumpit = nl80211_testmode_dump,
6848 .policy = nl80211_policy,
6849 .flags = GENL_ADMIN_PERM,
6850 .internal_flags = NL80211_FLAG_NEED_WIPHY |
6851 NL80211_FLAG_NEED_RTNL,
6855 .cmd = NL80211_CMD_CONNECT,
6856 .doit = nl80211_connect,
6857 .policy = nl80211_policy,
6858 .flags = GENL_ADMIN_PERM,
6859 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6860 NL80211_FLAG_NEED_RTNL,
6863 .cmd = NL80211_CMD_DISCONNECT,
6864 .doit = nl80211_disconnect,
6865 .policy = nl80211_policy,
6866 .flags = GENL_ADMIN_PERM,
6867 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6868 NL80211_FLAG_NEED_RTNL,
6871 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
6872 .doit = nl80211_wiphy_netns,
6873 .policy = nl80211_policy,
6874 .flags = GENL_ADMIN_PERM,
6875 .internal_flags = NL80211_FLAG_NEED_WIPHY |
6876 NL80211_FLAG_NEED_RTNL,
6879 .cmd = NL80211_CMD_GET_SURVEY,
6880 .policy = nl80211_policy,
6881 .dumpit = nl80211_dump_survey,
6884 .cmd = NL80211_CMD_SET_PMKSA,
6885 .doit = nl80211_setdel_pmksa,
6886 .policy = nl80211_policy,
6887 .flags = GENL_ADMIN_PERM,
6888 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6889 NL80211_FLAG_NEED_RTNL,
6892 .cmd = NL80211_CMD_DEL_PMKSA,
6893 .doit = nl80211_setdel_pmksa,
6894 .policy = nl80211_policy,
6895 .flags = GENL_ADMIN_PERM,
6896 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6897 NL80211_FLAG_NEED_RTNL,
6900 .cmd = NL80211_CMD_FLUSH_PMKSA,
6901 .doit = nl80211_flush_pmksa,
6902 .policy = nl80211_policy,
6903 .flags = GENL_ADMIN_PERM,
6904 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6905 NL80211_FLAG_NEED_RTNL,
6908 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
6909 .doit = nl80211_remain_on_channel,
6910 .policy = nl80211_policy,
6911 .flags = GENL_ADMIN_PERM,
6912 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6913 NL80211_FLAG_NEED_RTNL,
6916 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
6917 .doit = nl80211_cancel_remain_on_channel,
6918 .policy = nl80211_policy,
6919 .flags = GENL_ADMIN_PERM,
6920 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6921 NL80211_FLAG_NEED_RTNL,
6924 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
6925 .doit = nl80211_set_tx_bitrate_mask,
6926 .policy = nl80211_policy,
6927 .flags = GENL_ADMIN_PERM,
6928 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6929 NL80211_FLAG_NEED_RTNL,
6932 .cmd = NL80211_CMD_REGISTER_FRAME,
6933 .doit = nl80211_register_mgmt,
6934 .policy = nl80211_policy,
6935 .flags = GENL_ADMIN_PERM,
6936 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6937 NL80211_FLAG_NEED_RTNL,
6940 .cmd = NL80211_CMD_FRAME,
6941 .doit = nl80211_tx_mgmt,
6942 .policy = nl80211_policy,
6943 .flags = GENL_ADMIN_PERM,
6944 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6945 NL80211_FLAG_NEED_RTNL,
6948 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
6949 .doit = nl80211_tx_mgmt_cancel_wait,
6950 .policy = nl80211_policy,
6951 .flags = GENL_ADMIN_PERM,
6952 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6953 NL80211_FLAG_NEED_RTNL,
6956 .cmd = NL80211_CMD_SET_POWER_SAVE,
6957 .doit = nl80211_set_power_save,
6958 .policy = nl80211_policy,
6959 .flags = GENL_ADMIN_PERM,
6960 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6961 NL80211_FLAG_NEED_RTNL,
6964 .cmd = NL80211_CMD_GET_POWER_SAVE,
6965 .doit = nl80211_get_power_save,
6966 .policy = nl80211_policy,
6967 /* can be retrieved by unprivileged users */
6968 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6969 NL80211_FLAG_NEED_RTNL,
6972 .cmd = NL80211_CMD_SET_CQM,
6973 .doit = nl80211_set_cqm,
6974 .policy = nl80211_policy,
6975 .flags = GENL_ADMIN_PERM,
6976 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6977 NL80211_FLAG_NEED_RTNL,
6980 .cmd = NL80211_CMD_SET_CHANNEL,
6981 .doit = nl80211_set_channel,
6982 .policy = nl80211_policy,
6983 .flags = GENL_ADMIN_PERM,
6984 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6985 NL80211_FLAG_NEED_RTNL,
6988 .cmd = NL80211_CMD_SET_WDS_PEER,
6989 .doit = nl80211_set_wds_peer,
6990 .policy = nl80211_policy,
6991 .flags = GENL_ADMIN_PERM,
6992 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6993 NL80211_FLAG_NEED_RTNL,
6996 .cmd = NL80211_CMD_JOIN_MESH,
6997 .doit = nl80211_join_mesh,
6998 .policy = nl80211_policy,
6999 .flags = GENL_ADMIN_PERM,
7000 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7001 NL80211_FLAG_NEED_RTNL,
7004 .cmd = NL80211_CMD_LEAVE_MESH,
7005 .doit = nl80211_leave_mesh,
7006 .policy = nl80211_policy,
7007 .flags = GENL_ADMIN_PERM,
7008 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7009 NL80211_FLAG_NEED_RTNL,
7012 .cmd = NL80211_CMD_GET_WOWLAN,
7013 .doit = nl80211_get_wowlan,
7014 .policy = nl80211_policy,
7015 /* can be retrieved by unprivileged users */
7016 .internal_flags = NL80211_FLAG_NEED_WIPHY |
7017 NL80211_FLAG_NEED_RTNL,
7020 .cmd = NL80211_CMD_SET_WOWLAN,
7021 .doit = nl80211_set_wowlan,
7022 .policy = nl80211_policy,
7023 .flags = GENL_ADMIN_PERM,
7024 .internal_flags = NL80211_FLAG_NEED_WIPHY |
7025 NL80211_FLAG_NEED_RTNL,
7028 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
7029 .doit = nl80211_set_rekey_data,
7030 .policy = nl80211_policy,
7031 .flags = GENL_ADMIN_PERM,
7032 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7033 NL80211_FLAG_NEED_RTNL,
7036 .cmd = NL80211_CMD_TDLS_MGMT,
7037 .doit = nl80211_tdls_mgmt,
7038 .policy = nl80211_policy,
7039 .flags = GENL_ADMIN_PERM,
7040 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7041 NL80211_FLAG_NEED_RTNL,
7044 .cmd = NL80211_CMD_TDLS_OPER,
7045 .doit = nl80211_tdls_oper,
7046 .policy = nl80211_policy,
7047 .flags = GENL_ADMIN_PERM,
7048 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7049 NL80211_FLAG_NEED_RTNL,
7052 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
7053 .doit = nl80211_register_unexpected_frame,
7054 .policy = nl80211_policy,
7055 .flags = GENL_ADMIN_PERM,
7056 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7057 NL80211_FLAG_NEED_RTNL,
7060 .cmd = NL80211_CMD_PROBE_CLIENT,
7061 .doit = nl80211_probe_client,
7062 .policy = nl80211_policy,
7063 .flags = GENL_ADMIN_PERM,
7064 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7065 NL80211_FLAG_NEED_RTNL,
7068 .cmd = NL80211_CMD_REGISTER_BEACONS,
7069 .doit = nl80211_register_beacons,
7070 .policy = nl80211_policy,
7071 .flags = GENL_ADMIN_PERM,
7072 .internal_flags = NL80211_FLAG_NEED_WIPHY |
7073 NL80211_FLAG_NEED_RTNL,
7076 .cmd = NL80211_CMD_SET_NOACK_MAP,
7077 .doit = nl80211_set_noack_map,
7078 .policy = nl80211_policy,
7079 .flags = GENL_ADMIN_PERM,
7080 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7081 NL80211_FLAG_NEED_RTNL,
7086 static struct genl_multicast_group nl80211_mlme_mcgrp = {
7090 /* multicast groups */
7091 static struct genl_multicast_group nl80211_config_mcgrp = {
7094 static struct genl_multicast_group nl80211_scan_mcgrp = {
7097 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
7098 .name = "regulatory",
7101 /* notification functions */
7103 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
7105 struct sk_buff *msg;
7107 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7111 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
7116 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7117 nl80211_config_mcgrp.id, GFP_KERNEL);
7120 static int nl80211_add_scan_req(struct sk_buff *msg,
7121 struct cfg80211_registered_device *rdev)
7123 struct cfg80211_scan_request *req = rdev->scan_req;
7124 struct nlattr *nest;
7127 ASSERT_RDEV_LOCK(rdev);
7132 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
7134 goto nla_put_failure;
7135 for (i = 0; i < req->n_ssids; i++) {
7136 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
7137 goto nla_put_failure;
7139 nla_nest_end(msg, nest);
7141 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
7143 goto nla_put_failure;
7144 for (i = 0; i < req->n_channels; i++) {
7145 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
7146 goto nla_put_failure;
7148 nla_nest_end(msg, nest);
7151 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
7152 goto nla_put_failure;
7159 static int nl80211_send_scan_msg(struct sk_buff *msg,
7160 struct cfg80211_registered_device *rdev,
7161 struct net_device *netdev,
7162 u32 pid, u32 seq, int flags,
7167 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
7171 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7172 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
7173 goto nla_put_failure;
7175 /* ignore errors and send incomplete event anyway */
7176 nl80211_add_scan_req(msg, rdev);
7178 return genlmsg_end(msg, hdr);
7181 genlmsg_cancel(msg, hdr);
7186 nl80211_send_sched_scan_msg(struct sk_buff *msg,
7187 struct cfg80211_registered_device *rdev,
7188 struct net_device *netdev,
7189 u32 pid, u32 seq, int flags, u32 cmd)
7193 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
7197 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7198 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
7199 goto nla_put_failure;
7201 return genlmsg_end(msg, hdr);
7204 genlmsg_cancel(msg, hdr);
7208 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
7209 struct net_device *netdev)
7211 struct sk_buff *msg;
7213 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7217 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
7218 NL80211_CMD_TRIGGER_SCAN) < 0) {
7223 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7224 nl80211_scan_mcgrp.id, GFP_KERNEL);
7227 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
7228 struct net_device *netdev)
7230 struct sk_buff *msg;
7232 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7236 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
7237 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
7242 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7243 nl80211_scan_mcgrp.id, GFP_KERNEL);
7246 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
7247 struct net_device *netdev)
7249 struct sk_buff *msg;
7251 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7255 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
7256 NL80211_CMD_SCAN_ABORTED) < 0) {
7261 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7262 nl80211_scan_mcgrp.id, GFP_KERNEL);
7265 void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
7266 struct net_device *netdev)
7268 struct sk_buff *msg;
7270 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7274 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
7275 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
7280 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7281 nl80211_scan_mcgrp.id, GFP_KERNEL);
7284 void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
7285 struct net_device *netdev, u32 cmd)
7287 struct sk_buff *msg;
7289 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7293 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
7298 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7299 nl80211_scan_mcgrp.id, GFP_KERNEL);
7303 * This can happen on global regulatory changes or device specific settings
7304 * based on custom world regulatory domains.
7306 void nl80211_send_reg_change_event(struct regulatory_request *request)
7308 struct sk_buff *msg;
7311 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7315 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
7321 /* Userspace can always count this one always being set */
7322 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
7323 goto nla_put_failure;
7325 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
7326 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7327 NL80211_REGDOM_TYPE_WORLD))
7328 goto nla_put_failure;
7329 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
7330 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7331 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
7332 goto nla_put_failure;
7333 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
7334 request->intersect) {
7335 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7336 NL80211_REGDOM_TYPE_INTERSECTION))
7337 goto nla_put_failure;
7339 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7340 NL80211_REGDOM_TYPE_COUNTRY) ||
7341 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
7343 goto nla_put_failure;
7346 if (wiphy_idx_valid(request->wiphy_idx) &&
7347 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
7348 goto nla_put_failure;
7350 genlmsg_end(msg, hdr);
7353 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
7360 genlmsg_cancel(msg, hdr);
7364 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
7365 struct net_device *netdev,
7366 const u8 *buf, size_t len,
7367 enum nl80211_commands cmd, gfp_t gfp)
7369 struct sk_buff *msg;
7372 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7376 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7382 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7383 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7384 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
7385 goto nla_put_failure;
7387 genlmsg_end(msg, hdr);
7389 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7390 nl80211_mlme_mcgrp.id, gfp);
7394 genlmsg_cancel(msg, hdr);
7398 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
7399 struct net_device *netdev, const u8 *buf,
7400 size_t len, gfp_t gfp)
7402 nl80211_send_mlme_event(rdev, netdev, buf, len,
7403 NL80211_CMD_AUTHENTICATE, gfp);
7406 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
7407 struct net_device *netdev, const u8 *buf,
7408 size_t len, gfp_t gfp)
7410 nl80211_send_mlme_event(rdev, netdev, buf, len,
7411 NL80211_CMD_ASSOCIATE, gfp);
7414 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
7415 struct net_device *netdev, const u8 *buf,
7416 size_t len, gfp_t gfp)
7418 nl80211_send_mlme_event(rdev, netdev, buf, len,
7419 NL80211_CMD_DEAUTHENTICATE, gfp);
7422 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
7423 struct net_device *netdev, const u8 *buf,
7424 size_t len, gfp_t gfp)
7426 nl80211_send_mlme_event(rdev, netdev, buf, len,
7427 NL80211_CMD_DISASSOCIATE, gfp);
7430 void nl80211_send_unprot_deauth(struct cfg80211_registered_device *rdev,
7431 struct net_device *netdev, const u8 *buf,
7432 size_t len, gfp_t gfp)
7434 nl80211_send_mlme_event(rdev, netdev, buf, len,
7435 NL80211_CMD_UNPROT_DEAUTHENTICATE, gfp);
7438 void nl80211_send_unprot_disassoc(struct cfg80211_registered_device *rdev,
7439 struct net_device *netdev, const u8 *buf,
7440 size_t len, gfp_t gfp)
7442 nl80211_send_mlme_event(rdev, netdev, buf, len,
7443 NL80211_CMD_UNPROT_DISASSOCIATE, gfp);
7446 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
7447 struct net_device *netdev, int cmd,
7448 const u8 *addr, gfp_t gfp)
7450 struct sk_buff *msg;
7453 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7457 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7463 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7464 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7465 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
7466 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
7467 goto nla_put_failure;
7469 genlmsg_end(msg, hdr);
7471 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7472 nl80211_mlme_mcgrp.id, gfp);
7476 genlmsg_cancel(msg, hdr);
7480 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
7481 struct net_device *netdev, const u8 *addr,
7484 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
7488 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
7489 struct net_device *netdev, const u8 *addr,
7492 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
7496 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
7497 struct net_device *netdev, const u8 *bssid,
7498 const u8 *req_ie, size_t req_ie_len,
7499 const u8 *resp_ie, size_t resp_ie_len,
7500 u16 status, gfp_t gfp)
7502 struct sk_buff *msg;
7505 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7509 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
7515 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7516 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7517 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
7518 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
7520 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
7522 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
7523 goto nla_put_failure;
7525 genlmsg_end(msg, hdr);
7527 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7528 nl80211_mlme_mcgrp.id, gfp);
7532 genlmsg_cancel(msg, hdr);
7537 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
7538 struct net_device *netdev, const u8 *bssid,
7539 const u8 *req_ie, size_t req_ie_len,
7540 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
7542 struct sk_buff *msg;
7545 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7549 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
7555 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7556 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7557 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
7559 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
7561 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
7562 goto nla_put_failure;
7564 genlmsg_end(msg, hdr);
7566 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7567 nl80211_mlme_mcgrp.id, gfp);
7571 genlmsg_cancel(msg, hdr);
7576 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
7577 struct net_device *netdev, u16 reason,
7578 const u8 *ie, size_t ie_len, bool from_ap)
7580 struct sk_buff *msg;
7583 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7587 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
7593 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7594 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7595 (from_ap && reason &&
7596 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
7598 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
7599 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
7600 goto nla_put_failure;
7602 genlmsg_end(msg, hdr);
7604 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7605 nl80211_mlme_mcgrp.id, GFP_KERNEL);
7609 genlmsg_cancel(msg, hdr);
7614 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
7615 struct net_device *netdev, const u8 *bssid,
7618 struct sk_buff *msg;
7621 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7625 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
7631 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7632 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7633 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
7634 goto nla_put_failure;
7636 genlmsg_end(msg, hdr);
7638 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7639 nl80211_mlme_mcgrp.id, gfp);
7643 genlmsg_cancel(msg, hdr);
7647 void nl80211_send_new_peer_candidate(struct cfg80211_registered_device *rdev,
7648 struct net_device *netdev,
7649 const u8 *macaddr, const u8* ie, u8 ie_len,
7652 struct sk_buff *msg;
7655 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7659 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
7665 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7666 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7667 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, macaddr) ||
7669 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
7670 goto nla_put_failure;
7672 genlmsg_end(msg, hdr);
7674 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7675 nl80211_mlme_mcgrp.id, gfp);
7679 genlmsg_cancel(msg, hdr);
7683 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
7684 struct net_device *netdev, const u8 *addr,
7685 enum nl80211_key_type key_type, int key_id,
7686 const u8 *tsc, gfp_t gfp)
7688 struct sk_buff *msg;
7691 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7695 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
7701 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7702 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7703 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
7704 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
7706 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
7707 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
7708 goto nla_put_failure;
7710 genlmsg_end(msg, hdr);
7712 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7713 nl80211_mlme_mcgrp.id, gfp);
7717 genlmsg_cancel(msg, hdr);
7721 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
7722 struct ieee80211_channel *channel_before,
7723 struct ieee80211_channel *channel_after)
7725 struct sk_buff *msg;
7727 struct nlattr *nl_freq;
7729 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
7733 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
7740 * Since we are applying the beacon hint to a wiphy we know its
7741 * wiphy_idx is valid
7743 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7744 goto nla_put_failure;
7747 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
7749 goto nla_put_failure;
7750 if (nl80211_msg_put_channel(msg, channel_before))
7751 goto nla_put_failure;
7752 nla_nest_end(msg, nl_freq);
7755 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
7757 goto nla_put_failure;
7758 if (nl80211_msg_put_channel(msg, channel_after))
7759 goto nla_put_failure;
7760 nla_nest_end(msg, nl_freq);
7762 genlmsg_end(msg, hdr);
7765 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
7772 genlmsg_cancel(msg, hdr);
7776 static void nl80211_send_remain_on_chan_event(
7777 int cmd, struct cfg80211_registered_device *rdev,
7778 struct net_device *netdev, u64 cookie,
7779 struct ieee80211_channel *chan,
7780 enum nl80211_channel_type channel_type,
7781 unsigned int duration, gfp_t gfp)
7783 struct sk_buff *msg;
7786 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7790 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7796 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7797 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7798 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
7799 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, channel_type) ||
7800 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7801 goto nla_put_failure;
7803 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
7804 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
7805 goto nla_put_failure;
7807 genlmsg_end(msg, hdr);
7809 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7810 nl80211_mlme_mcgrp.id, gfp);
7814 genlmsg_cancel(msg, hdr);
7818 void nl80211_send_remain_on_channel(struct cfg80211_registered_device *rdev,
7819 struct net_device *netdev, u64 cookie,
7820 struct ieee80211_channel *chan,
7821 enum nl80211_channel_type channel_type,
7822 unsigned int duration, gfp_t gfp)
7824 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
7825 rdev, netdev, cookie, chan,
7826 channel_type, duration, gfp);
7829 void nl80211_send_remain_on_channel_cancel(
7830 struct cfg80211_registered_device *rdev, struct net_device *netdev,
7831 u64 cookie, struct ieee80211_channel *chan,
7832 enum nl80211_channel_type channel_type, gfp_t gfp)
7834 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
7835 rdev, netdev, cookie, chan,
7836 channel_type, 0, gfp);
7839 void nl80211_send_sta_event(struct cfg80211_registered_device *rdev,
7840 struct net_device *dev, const u8 *mac_addr,
7841 struct station_info *sinfo, gfp_t gfp)
7843 struct sk_buff *msg;
7845 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7849 if (nl80211_send_station(msg, 0, 0, 0,
7850 rdev, dev, mac_addr, sinfo) < 0) {
7855 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7856 nl80211_mlme_mcgrp.id, gfp);
7859 void nl80211_send_sta_del_event(struct cfg80211_registered_device *rdev,
7860 struct net_device *dev, const u8 *mac_addr,
7863 struct sk_buff *msg;
7866 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7870 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
7876 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
7877 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
7878 goto nla_put_failure;
7880 genlmsg_end(msg, hdr);
7882 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7883 nl80211_mlme_mcgrp.id, gfp);
7887 genlmsg_cancel(msg, hdr);
7891 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
7892 const u8 *addr, gfp_t gfp)
7894 struct wireless_dev *wdev = dev->ieee80211_ptr;
7895 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
7896 struct sk_buff *msg;
7899 u32 nlpid = ACCESS_ONCE(wdev->ap_unexpected_nlpid);
7904 msg = nlmsg_new(100, gfp);
7908 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7914 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7915 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
7916 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
7917 goto nla_put_failure;
7919 err = genlmsg_end(msg, hdr);
7925 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
7929 genlmsg_cancel(msg, hdr);
7934 bool nl80211_unexpected_frame(struct net_device *dev, const u8 *addr, gfp_t gfp)
7936 return __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
7940 bool nl80211_unexpected_4addr_frame(struct net_device *dev,
7941 const u8 *addr, gfp_t gfp)
7943 return __nl80211_unexpected_frame(dev,
7944 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
7948 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
7949 struct net_device *netdev, u32 nlpid,
7950 int freq, int sig_dbm,
7951 const u8 *buf, size_t len, gfp_t gfp)
7953 struct sk_buff *msg;
7956 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7960 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
7966 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7967 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7968 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
7970 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
7971 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
7972 goto nla_put_failure;
7974 genlmsg_end(msg, hdr);
7976 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
7979 genlmsg_cancel(msg, hdr);
7984 void nl80211_send_mgmt_tx_status(struct cfg80211_registered_device *rdev,
7985 struct net_device *netdev, u64 cookie,
7986 const u8 *buf, size_t len, bool ack,
7989 struct sk_buff *msg;
7992 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7996 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
8002 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8003 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8004 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
8005 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
8006 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
8007 goto nla_put_failure;
8009 genlmsg_end(msg, hdr);
8011 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
8015 genlmsg_cancel(msg, hdr);
8020 nl80211_send_cqm_rssi_notify(struct cfg80211_registered_device *rdev,
8021 struct net_device *netdev,
8022 enum nl80211_cqm_rssi_threshold_event rssi_event,
8025 struct sk_buff *msg;
8026 struct nlattr *pinfoattr;
8029 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8033 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
8039 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8040 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
8041 goto nla_put_failure;
8043 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
8045 goto nla_put_failure;
8047 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
8049 goto nla_put_failure;
8051 nla_nest_end(msg, pinfoattr);
8053 genlmsg_end(msg, hdr);
8055 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8056 nl80211_mlme_mcgrp.id, gfp);
8060 genlmsg_cancel(msg, hdr);
8064 void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
8065 struct net_device *netdev, const u8 *bssid,
8066 const u8 *replay_ctr, gfp_t gfp)
8068 struct sk_buff *msg;
8069 struct nlattr *rekey_attr;
8072 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8076 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
8082 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8083 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8084 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
8085 goto nla_put_failure;
8087 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
8089 goto nla_put_failure;
8091 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
8092 NL80211_REPLAY_CTR_LEN, replay_ctr))
8093 goto nla_put_failure;
8095 nla_nest_end(msg, rekey_attr);
8097 genlmsg_end(msg, hdr);
8099 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8100 nl80211_mlme_mcgrp.id, gfp);
8104 genlmsg_cancel(msg, hdr);
8108 void nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
8109 struct net_device *netdev, int index,
8110 const u8 *bssid, bool preauth, gfp_t gfp)
8112 struct sk_buff *msg;
8113 struct nlattr *attr;
8116 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8120 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
8126 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8127 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
8128 goto nla_put_failure;
8130 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
8132 goto nla_put_failure;
8134 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
8135 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
8137 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
8138 goto nla_put_failure;
8140 nla_nest_end(msg, attr);
8142 genlmsg_end(msg, hdr);
8144 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8145 nl80211_mlme_mcgrp.id, gfp);
8149 genlmsg_cancel(msg, hdr);
8153 void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
8154 struct net_device *netdev, int freq,
8155 enum nl80211_channel_type type, gfp_t gfp)
8157 struct sk_buff *msg;
8160 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8164 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY);
8170 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8171 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
8172 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, type))
8173 goto nla_put_failure;
8175 genlmsg_end(msg, hdr);
8177 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8178 nl80211_mlme_mcgrp.id, gfp);
8182 genlmsg_cancel(msg, hdr);
8187 nl80211_send_cqm_pktloss_notify(struct cfg80211_registered_device *rdev,
8188 struct net_device *netdev, const u8 *peer,
8189 u32 num_packets, gfp_t gfp)
8191 struct sk_buff *msg;
8192 struct nlattr *pinfoattr;
8195 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8199 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
8205 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8206 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8207 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
8208 goto nla_put_failure;
8210 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
8212 goto nla_put_failure;
8214 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
8215 goto nla_put_failure;
8217 nla_nest_end(msg, pinfoattr);
8219 genlmsg_end(msg, hdr);
8221 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8222 nl80211_mlme_mcgrp.id, gfp);
8226 genlmsg_cancel(msg, hdr);
8230 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
8231 u64 cookie, bool acked, gfp_t gfp)
8233 struct wireless_dev *wdev = dev->ieee80211_ptr;
8234 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
8235 struct sk_buff *msg;
8239 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8243 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
8249 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8250 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
8251 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
8252 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
8253 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
8254 goto nla_put_failure;
8256 err = genlmsg_end(msg, hdr);
8262 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8263 nl80211_mlme_mcgrp.id, gfp);
8267 genlmsg_cancel(msg, hdr);
8270 EXPORT_SYMBOL(cfg80211_probe_status);
8272 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
8273 const u8 *frame, size_t len,
8274 int freq, int sig_dbm, gfp_t gfp)
8276 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
8277 struct sk_buff *msg;
8279 u32 nlpid = ACCESS_ONCE(rdev->ap_beacons_nlpid);
8284 msg = nlmsg_new(len + 100, gfp);
8288 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
8294 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8296 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
8298 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
8299 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
8300 goto nla_put_failure;
8302 genlmsg_end(msg, hdr);
8304 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
8308 genlmsg_cancel(msg, hdr);
8311 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
8313 static int nl80211_netlink_notify(struct notifier_block * nb,
8314 unsigned long state,
8317 struct netlink_notify *notify = _notify;
8318 struct cfg80211_registered_device *rdev;
8319 struct wireless_dev *wdev;
8321 if (state != NETLINK_URELEASE)
8326 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
8327 list_for_each_entry_rcu(wdev, &rdev->netdev_list, list)
8328 cfg80211_mlme_unregister_socket(wdev, notify->pid);
8329 if (rdev->ap_beacons_nlpid == notify->pid)
8330 rdev->ap_beacons_nlpid = 0;
8338 static struct notifier_block nl80211_netlink_notifier = {
8339 .notifier_call = nl80211_netlink_notify,
8342 /* initialisation/exit functions */
8344 int nl80211_init(void)
8348 err = genl_register_family_with_ops(&nl80211_fam,
8349 nl80211_ops, ARRAY_SIZE(nl80211_ops));
8353 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
8357 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
8361 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
8365 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
8369 #ifdef CONFIG_NL80211_TESTMODE
8370 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
8375 err = netlink_register_notifier(&nl80211_netlink_notifier);
8381 genl_unregister_family(&nl80211_fam);
8385 void nl80211_exit(void)
8387 netlink_unregister_notifier(&nl80211_netlink_notifier);
8388 genl_unregister_family(&nl80211_fam);