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 static struct cfg80211_registered_device *
74 __cfg80211_rdev_from_info(struct genl_info *info)
77 struct cfg80211_registered_device *bywiphyidx = NULL, *byifidx = NULL;
78 struct net_device *dev;
81 assert_cfg80211_lock();
83 if (info->attrs[NL80211_ATTR_WIPHY]) {
84 bywiphyidx = cfg80211_rdev_by_wiphy_idx(
85 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY]));
89 if (info->attrs[NL80211_ATTR_IFINDEX]) {
90 ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
91 dev = dev_get_by_index(genl_info_net(info), ifindex);
93 if (dev->ieee80211_ptr)
95 wiphy_to_dev(dev->ieee80211_ptr->wiphy);
101 if (bywiphyidx && byifidx) {
102 if (bywiphyidx != byifidx)
103 return ERR_PTR(-EINVAL);
105 return bywiphyidx; /* == byifidx */
117 * This function returns a pointer to the driver
118 * that the genl_info item that is passed refers to.
119 * If successful, it returns non-NULL and also locks
120 * the driver's mutex!
122 * This means that you need to call cfg80211_unlock_rdev()
123 * before being allowed to acquire &cfg80211_mutex!
125 * This is necessary because we need to lock the global
126 * mutex to get an item off the list safely, and then
127 * we lock the rdev mutex so it doesn't go away under us.
129 * We don't want to keep cfg80211_mutex locked
130 * for all the time in order to allow requests on
131 * other interfaces to go through at the same time.
133 * The result of this can be a PTR_ERR and hence must
134 * be checked with IS_ERR() for errors.
136 static struct cfg80211_registered_device *
137 cfg80211_get_dev_from_info(struct genl_info *info)
139 struct cfg80211_registered_device *rdev;
141 mutex_lock(&cfg80211_mutex);
142 rdev = __cfg80211_rdev_from_info(info);
144 /* if it is not an error we grab the lock on
145 * it to assure it won't be going away while
146 * we operate on it */
148 mutex_lock(&rdev->mtx);
150 mutex_unlock(&cfg80211_mutex);
155 /* policy for the attributes */
156 static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
157 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
158 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
160 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
161 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
162 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
163 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
164 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
165 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
166 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
167 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
169 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
170 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
171 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
173 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
174 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
176 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
177 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
178 .len = WLAN_MAX_KEY_LEN },
179 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
180 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
181 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
182 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
183 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
185 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
186 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
187 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
188 .len = IEEE80211_MAX_DATA_LEN },
189 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
190 .len = IEEE80211_MAX_DATA_LEN },
191 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
192 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
193 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
194 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
195 .len = NL80211_MAX_SUPP_RATES },
196 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
197 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
198 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
199 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
200 .len = IEEE80211_MAX_MESH_ID_LEN },
201 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
203 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
204 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
206 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
207 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
208 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
209 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
210 .len = NL80211_MAX_SUPP_RATES },
211 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
213 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
214 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
216 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
218 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
219 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
220 .len = IEEE80211_MAX_DATA_LEN },
221 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
222 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
224 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
225 .len = IEEE80211_MAX_SSID_LEN },
226 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
227 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
228 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
229 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
230 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
231 [NL80211_ATTR_STA_FLAGS2] = {
232 .len = sizeof(struct nl80211_sta_flag_update),
234 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
235 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
236 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
237 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
238 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
239 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
240 [NL80211_ATTR_PID] = { .type = NLA_U32 },
241 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
242 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
243 .len = WLAN_PMKID_LEN },
244 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
245 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
246 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
247 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
248 .len = IEEE80211_MAX_DATA_LEN },
249 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
250 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
251 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
252 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
253 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
254 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
255 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
256 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
257 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
258 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
259 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
260 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
261 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
262 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
263 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
264 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
265 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
266 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
267 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
268 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
269 .len = IEEE80211_MAX_DATA_LEN },
270 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
271 .len = IEEE80211_MAX_DATA_LEN },
272 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
273 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
274 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
275 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
276 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
277 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
278 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
279 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
280 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
281 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
282 .len = IEEE80211_MAX_DATA_LEN },
283 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
284 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
285 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
286 .len = NL80211_HT_CAPABILITY_LEN
288 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
289 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
290 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
293 /* policy for the key attributes */
294 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
295 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
296 [NL80211_KEY_IDX] = { .type = NLA_U8 },
297 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
298 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
299 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
300 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
301 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
302 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
305 /* policy for the key default flags */
306 static const struct nla_policy
307 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
308 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
309 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
312 /* policy for WoWLAN attributes */
313 static const struct nla_policy
314 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
315 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
316 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
317 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
318 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
319 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
320 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
321 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
322 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
325 /* policy for GTK rekey offload attributes */
326 static const struct nla_policy
327 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
328 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
329 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
330 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
333 static const struct nla_policy
334 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
335 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
336 .len = IEEE80211_MAX_SSID_LEN },
339 /* ifidx get helper */
340 static int nl80211_get_ifidx(struct netlink_callback *cb)
344 res = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
345 nl80211_fam.attrbuf, nl80211_fam.maxattr,
350 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
353 res = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
359 static int nl80211_prepare_netdev_dump(struct sk_buff *skb,
360 struct netlink_callback *cb,
361 struct cfg80211_registered_device **rdev,
362 struct net_device **dev)
364 int ifidx = cb->args[0];
368 ifidx = nl80211_get_ifidx(cb);
376 *dev = __dev_get_by_index(sock_net(skb->sk), ifidx);
382 *rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
384 err = PTR_ERR(*rdev);
394 static void nl80211_finish_netdev_dump(struct cfg80211_registered_device *rdev)
396 cfg80211_unlock_rdev(rdev);
401 static bool is_valid_ie_attr(const struct nlattr *attr)
409 pos = nla_data(attr);
430 /* message building helper */
431 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
434 /* since there is no private header just add the generic one */
435 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
438 static int nl80211_msg_put_channel(struct sk_buff *msg,
439 struct ieee80211_channel *chan)
441 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
443 goto nla_put_failure;
445 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
446 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
447 goto nla_put_failure;
448 if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
449 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN))
450 goto nla_put_failure;
451 if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
452 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
453 goto nla_put_failure;
454 if ((chan->flags & IEEE80211_CHAN_RADAR) &&
455 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
456 goto nla_put_failure;
458 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
459 DBM_TO_MBM(chan->max_power)))
460 goto nla_put_failure;
468 /* netlink command implementations */
475 bool def_uni, def_multi;
478 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
480 struct nlattr *tb[NL80211_KEY_MAX + 1];
481 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
486 k->def = !!tb[NL80211_KEY_DEFAULT];
487 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
496 if (tb[NL80211_KEY_IDX])
497 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
499 if (tb[NL80211_KEY_DATA]) {
500 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
501 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
504 if (tb[NL80211_KEY_SEQ]) {
505 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
506 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
509 if (tb[NL80211_KEY_CIPHER])
510 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
512 if (tb[NL80211_KEY_TYPE]) {
513 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
514 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
518 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
519 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
520 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
521 tb[NL80211_KEY_DEFAULT_TYPES],
522 nl80211_key_default_policy);
526 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
527 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
533 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
535 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
536 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
537 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
540 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
541 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
542 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
545 if (info->attrs[NL80211_ATTR_KEY_IDX])
546 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
548 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
549 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
551 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
552 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
561 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
562 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
563 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
567 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
568 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
569 int err = nla_parse_nested(
570 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
571 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
572 nl80211_key_default_policy);
576 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
577 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
583 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
587 memset(k, 0, sizeof(*k));
591 if (info->attrs[NL80211_ATTR_KEY])
592 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
594 err = nl80211_parse_key_old(info, k);
599 if (k->def && k->defmgmt)
603 if (k->def_uni || !k->def_multi)
609 if (k->idx < 4 || k->idx > 5)
612 if (k->idx < 0 || k->idx > 3)
615 if (k->idx < 0 || k->idx > 5)
623 static struct cfg80211_cached_keys *
624 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
627 struct key_parse parse;
629 struct cfg80211_cached_keys *result;
630 int rem, err, def = 0;
632 result = kzalloc(sizeof(*result), GFP_KERNEL);
634 return ERR_PTR(-ENOMEM);
637 result->defmgmt = -1;
639 nla_for_each_nested(key, keys, rem) {
640 memset(&parse, 0, sizeof(parse));
643 err = nl80211_parse_key_new(key, &parse);
649 if (parse.idx < 0 || parse.idx > 4)
655 result->def = parse.idx;
656 if (!parse.def_uni || !parse.def_multi)
658 } else if (parse.defmgmt)
660 err = cfg80211_validate_key_settings(rdev, &parse.p,
661 parse.idx, false, NULL);
664 result->params[parse.idx].cipher = parse.p.cipher;
665 result->params[parse.idx].key_len = parse.p.key_len;
666 result->params[parse.idx].key = result->data[parse.idx];
667 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
676 static int nl80211_key_allowed(struct wireless_dev *wdev)
678 ASSERT_WDEV_LOCK(wdev);
680 switch (wdev->iftype) {
681 case NL80211_IFTYPE_AP:
682 case NL80211_IFTYPE_AP_VLAN:
683 case NL80211_IFTYPE_P2P_GO:
684 case NL80211_IFTYPE_MESH_POINT:
686 case NL80211_IFTYPE_ADHOC:
687 if (!wdev->current_bss)
690 case NL80211_IFTYPE_STATION:
691 case NL80211_IFTYPE_P2P_CLIENT:
692 if (wdev->sme_state != CFG80211_SME_CONNECTED)
702 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
704 struct nlattr *nl_modes = nla_nest_start(msg, attr);
708 goto nla_put_failure;
712 if ((ifmodes & 1) && nla_put_flag(msg, i))
713 goto nla_put_failure;
718 nla_nest_end(msg, nl_modes);
725 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
728 struct nlattr *nl_combis;
731 nl_combis = nla_nest_start(msg,
732 NL80211_ATTR_INTERFACE_COMBINATIONS);
734 goto nla_put_failure;
736 for (i = 0; i < wiphy->n_iface_combinations; i++) {
737 const struct ieee80211_iface_combination *c;
738 struct nlattr *nl_combi, *nl_limits;
740 c = &wiphy->iface_combinations[i];
742 nl_combi = nla_nest_start(msg, i + 1);
744 goto nla_put_failure;
746 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
748 goto nla_put_failure;
750 for (j = 0; j < c->n_limits; j++) {
751 struct nlattr *nl_limit;
753 nl_limit = nla_nest_start(msg, j + 1);
755 goto nla_put_failure;
756 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
758 goto nla_put_failure;
759 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
761 goto nla_put_failure;
762 nla_nest_end(msg, nl_limit);
765 nla_nest_end(msg, nl_limits);
767 if (c->beacon_int_infra_match &&
768 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
769 goto nla_put_failure;
770 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
771 c->num_different_channels) ||
772 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
774 goto nla_put_failure;
776 nla_nest_end(msg, nl_combi);
779 nla_nest_end(msg, nl_combis);
786 static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
787 struct cfg80211_registered_device *dev)
790 struct nlattr *nl_bands, *nl_band;
791 struct nlattr *nl_freqs, *nl_freq;
792 struct nlattr *nl_rates, *nl_rate;
793 struct nlattr *nl_cmds;
794 enum ieee80211_band band;
795 struct ieee80211_channel *chan;
796 struct ieee80211_rate *rate;
798 const struct ieee80211_txrx_stypes *mgmt_stypes =
799 dev->wiphy.mgmt_stypes;
801 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
805 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx) ||
806 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy)) ||
807 nla_put_u32(msg, NL80211_ATTR_GENERATION,
808 cfg80211_rdev_list_generation) ||
809 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
810 dev->wiphy.retry_short) ||
811 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
812 dev->wiphy.retry_long) ||
813 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
814 dev->wiphy.frag_threshold) ||
815 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
816 dev->wiphy.rts_threshold) ||
817 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
818 dev->wiphy.coverage_class) ||
819 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
820 dev->wiphy.max_scan_ssids) ||
821 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
822 dev->wiphy.max_sched_scan_ssids) ||
823 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
824 dev->wiphy.max_scan_ie_len) ||
825 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
826 dev->wiphy.max_sched_scan_ie_len) ||
827 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
828 dev->wiphy.max_match_sets))
829 goto nla_put_failure;
831 if ((dev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
832 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
833 goto nla_put_failure;
834 if ((dev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
835 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
836 goto nla_put_failure;
837 if ((dev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
838 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
839 goto nla_put_failure;
840 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
841 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
842 goto nla_put_failure;
843 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
844 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
845 goto nla_put_failure;
846 if ((dev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
847 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
848 goto nla_put_failure;
850 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
851 sizeof(u32) * dev->wiphy.n_cipher_suites,
852 dev->wiphy.cipher_suites))
853 goto nla_put_failure;
855 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
856 dev->wiphy.max_num_pmkids))
857 goto nla_put_failure;
859 if ((dev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
860 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
861 goto nla_put_failure;
863 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
864 dev->wiphy.available_antennas_tx) ||
865 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
866 dev->wiphy.available_antennas_rx))
867 goto nla_put_failure;
869 if ((dev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
870 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
871 dev->wiphy.probe_resp_offload))
872 goto nla_put_failure;
874 if ((dev->wiphy.available_antennas_tx ||
875 dev->wiphy.available_antennas_rx) && dev->ops->get_antenna) {
876 u32 tx_ant = 0, rx_ant = 0;
878 res = dev->ops->get_antenna(&dev->wiphy, &tx_ant, &rx_ant);
880 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_TX,
882 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_RX,
884 goto nla_put_failure;
888 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
889 dev->wiphy.interface_modes))
890 goto nla_put_failure;
892 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
894 goto nla_put_failure;
896 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
897 if (!dev->wiphy.bands[band])
900 nl_band = nla_nest_start(msg, band);
902 goto nla_put_failure;
905 if (dev->wiphy.bands[band]->ht_cap.ht_supported &&
906 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
907 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
908 &dev->wiphy.bands[band]->ht_cap.mcs) ||
909 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
910 dev->wiphy.bands[band]->ht_cap.cap) ||
911 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
912 dev->wiphy.bands[band]->ht_cap.ampdu_factor) ||
913 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
914 dev->wiphy.bands[band]->ht_cap.ampdu_density)))
915 goto nla_put_failure;
917 /* add frequencies */
918 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
920 goto nla_put_failure;
922 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
923 nl_freq = nla_nest_start(msg, i);
925 goto nla_put_failure;
927 chan = &dev->wiphy.bands[band]->channels[i];
929 if (nl80211_msg_put_channel(msg, chan))
930 goto nla_put_failure;
932 nla_nest_end(msg, nl_freq);
935 nla_nest_end(msg, nl_freqs);
938 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
940 goto nla_put_failure;
942 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
943 nl_rate = nla_nest_start(msg, i);
945 goto nla_put_failure;
947 rate = &dev->wiphy.bands[band]->bitrates[i];
948 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
950 goto nla_put_failure;
951 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
953 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
954 goto nla_put_failure;
956 nla_nest_end(msg, nl_rate);
959 nla_nest_end(msg, nl_rates);
961 nla_nest_end(msg, nl_band);
963 nla_nest_end(msg, nl_bands);
965 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
967 goto nla_put_failure;
972 if (dev->ops->op) { \
974 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
975 goto nla_put_failure; \
979 CMD(add_virtual_intf, NEW_INTERFACE);
980 CMD(change_virtual_intf, SET_INTERFACE);
981 CMD(add_key, NEW_KEY);
982 CMD(start_ap, START_AP);
983 CMD(add_station, NEW_STATION);
984 CMD(add_mpath, NEW_MPATH);
985 CMD(update_mesh_config, SET_MESH_CONFIG);
986 CMD(change_bss, SET_BSS);
987 CMD(auth, AUTHENTICATE);
988 CMD(assoc, ASSOCIATE);
989 CMD(deauth, DEAUTHENTICATE);
990 CMD(disassoc, DISASSOCIATE);
991 CMD(join_ibss, JOIN_IBSS);
992 CMD(join_mesh, JOIN_MESH);
993 CMD(set_pmksa, SET_PMKSA);
994 CMD(del_pmksa, DEL_PMKSA);
995 CMD(flush_pmksa, FLUSH_PMKSA);
996 if (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
997 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
998 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1000 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1001 if (dev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1003 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1004 goto nla_put_failure;
1006 if (dev->ops->set_monitor_channel || dev->ops->start_ap ||
1007 dev->ops->join_mesh) {
1009 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1010 goto nla_put_failure;
1012 CMD(set_wds_peer, SET_WDS_PEER);
1013 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1014 CMD(tdls_mgmt, TDLS_MGMT);
1015 CMD(tdls_oper, TDLS_OPER);
1017 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
1018 CMD(sched_scan_start, START_SCHED_SCAN);
1019 CMD(probe_client, PROBE_CLIENT);
1020 CMD(set_noack_map, SET_NOACK_MAP);
1021 if (dev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1023 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1024 goto nla_put_failure;
1027 #ifdef CONFIG_NL80211_TESTMODE
1028 CMD(testmode_cmd, TESTMODE);
1033 if (dev->ops->connect || dev->ops->auth) {
1035 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1036 goto nla_put_failure;
1039 if (dev->ops->disconnect || dev->ops->deauth) {
1041 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1042 goto nla_put_failure;
1045 nla_nest_end(msg, nl_cmds);
1047 if (dev->ops->remain_on_channel &&
1048 (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
1049 nla_put_u32(msg, NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1050 dev->wiphy.max_remain_on_channel_duration))
1051 goto nla_put_failure;
1053 if ((dev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
1054 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1055 goto nla_put_failure;
1059 struct nlattr *nl_ftypes, *nl_ifs;
1060 enum nl80211_iftype ift;
1062 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1064 goto nla_put_failure;
1066 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1067 nl_ftypes = nla_nest_start(msg, ift);
1069 goto nla_put_failure;
1071 stypes = mgmt_stypes[ift].tx;
1074 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1075 (i << 4) | IEEE80211_FTYPE_MGMT))
1076 goto nla_put_failure;
1080 nla_nest_end(msg, nl_ftypes);
1083 nla_nest_end(msg, nl_ifs);
1085 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1087 goto nla_put_failure;
1089 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1090 nl_ftypes = nla_nest_start(msg, ift);
1092 goto nla_put_failure;
1094 stypes = mgmt_stypes[ift].rx;
1097 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1098 (i << 4) | IEEE80211_FTYPE_MGMT))
1099 goto nla_put_failure;
1103 nla_nest_end(msg, nl_ftypes);
1105 nla_nest_end(msg, nl_ifs);
1108 if (dev->wiphy.wowlan.flags || dev->wiphy.wowlan.n_patterns) {
1109 struct nlattr *nl_wowlan;
1111 nl_wowlan = nla_nest_start(msg,
1112 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1114 goto nla_put_failure;
1116 if (((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_ANY) &&
1117 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1118 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_DISCONNECT) &&
1119 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1120 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1121 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1122 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1123 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1124 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1125 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1126 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1127 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1128 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1129 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1130 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1131 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1132 goto nla_put_failure;
1133 if (dev->wiphy.wowlan.n_patterns) {
1134 struct nl80211_wowlan_pattern_support pat = {
1135 .max_patterns = dev->wiphy.wowlan.n_patterns,
1137 dev->wiphy.wowlan.pattern_min_len,
1139 dev->wiphy.wowlan.pattern_max_len,
1141 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1143 goto nla_put_failure;
1146 nla_nest_end(msg, nl_wowlan);
1149 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1150 dev->wiphy.software_iftypes))
1151 goto nla_put_failure;
1153 if (nl80211_put_iface_combinations(&dev->wiphy, msg))
1154 goto nla_put_failure;
1156 if ((dev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
1157 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1158 dev->wiphy.ap_sme_capa))
1159 goto nla_put_failure;
1161 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS,
1162 dev->wiphy.features))
1163 goto nla_put_failure;
1165 if (dev->wiphy.ht_capa_mod_mask &&
1166 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1167 sizeof(*dev->wiphy.ht_capa_mod_mask),
1168 dev->wiphy.ht_capa_mod_mask))
1169 goto nla_put_failure;
1171 return genlmsg_end(msg, hdr);
1174 genlmsg_cancel(msg, hdr);
1178 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1181 int start = cb->args[0];
1182 struct cfg80211_registered_device *dev;
1184 mutex_lock(&cfg80211_mutex);
1185 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
1186 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
1190 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
1191 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1197 mutex_unlock(&cfg80211_mutex);
1204 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
1206 struct sk_buff *msg;
1207 struct cfg80211_registered_device *dev = info->user_ptr[0];
1209 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1213 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0) {
1218 return genlmsg_reply(msg, info);
1221 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
1222 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
1223 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
1224 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
1225 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
1226 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
1229 static int parse_txq_params(struct nlattr *tb[],
1230 struct ieee80211_txq_params *txq_params)
1232 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
1233 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
1234 !tb[NL80211_TXQ_ATTR_AIFS])
1237 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
1238 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
1239 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
1240 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
1241 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
1243 if (txq_params->ac >= NL80211_NUM_ACS)
1249 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
1252 * You can only set the channel explicitly for WDS interfaces,
1253 * all others have their channel managed via their respective
1254 * "establish a connection" command (connect, join, ...)
1256 * For AP/GO and mesh mode, the channel can be set with the
1257 * channel userspace API, but is only stored and passed to the
1258 * low-level driver when the AP starts or the mesh is joined.
1259 * This is for backward compatibility, userspace can also give
1260 * the channel in the start-ap or join-mesh commands instead.
1262 * Monitors are special as they are normally slaved to
1263 * whatever else is going on, so they have their own special
1264 * operation to set the monitor channel if possible.
1267 wdev->iftype == NL80211_IFTYPE_AP ||
1268 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
1269 wdev->iftype == NL80211_IFTYPE_MONITOR ||
1270 wdev->iftype == NL80211_IFTYPE_P2P_GO;
1273 static bool nl80211_valid_channel_type(struct genl_info *info,
1274 enum nl80211_channel_type *channel_type)
1276 enum nl80211_channel_type tmp;
1278 if (!info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE])
1281 tmp = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1282 if (tmp != NL80211_CHAN_NO_HT &&
1283 tmp != NL80211_CHAN_HT20 &&
1284 tmp != NL80211_CHAN_HT40PLUS &&
1285 tmp != NL80211_CHAN_HT40MINUS)
1289 *channel_type = tmp;
1294 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
1295 struct wireless_dev *wdev,
1296 struct genl_info *info)
1298 struct ieee80211_channel *channel;
1299 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
1302 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
1305 iftype = wdev->iftype;
1307 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
1310 if (!nl80211_can_set_dev_channel(wdev))
1313 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
1314 !nl80211_valid_channel_type(info, &channel_type))
1317 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
1319 mutex_lock(&rdev->devlist_mtx);
1321 case NL80211_IFTYPE_AP:
1322 case NL80211_IFTYPE_P2P_GO:
1323 if (wdev->beacon_interval) {
1327 channel = rdev_freq_to_chan(rdev, freq, channel_type);
1328 if (!channel || !cfg80211_can_beacon_sec_chan(&rdev->wiphy,
1334 wdev->preset_chan = channel;
1335 wdev->preset_chantype = channel_type;
1338 case NL80211_IFTYPE_MESH_POINT:
1339 result = cfg80211_set_mesh_freq(rdev, wdev, freq, channel_type);
1341 case NL80211_IFTYPE_MONITOR:
1342 result = cfg80211_set_monitor_channel(rdev, freq, channel_type);
1347 mutex_unlock(&rdev->devlist_mtx);
1352 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
1354 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1355 struct net_device *netdev = info->user_ptr[1];
1357 return __nl80211_set_channel(rdev, netdev->ieee80211_ptr, info);
1360 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
1362 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1363 struct net_device *dev = info->user_ptr[1];
1364 struct wireless_dev *wdev = dev->ieee80211_ptr;
1367 if (!info->attrs[NL80211_ATTR_MAC])
1370 if (netif_running(dev))
1373 if (!rdev->ops->set_wds_peer)
1376 if (wdev->iftype != NL80211_IFTYPE_WDS)
1379 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1380 return rdev->ops->set_wds_peer(wdev->wiphy, dev, bssid);
1384 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
1386 struct cfg80211_registered_device *rdev;
1387 struct net_device *netdev = NULL;
1388 struct wireless_dev *wdev;
1389 int result = 0, rem_txq_params = 0;
1390 struct nlattr *nl_txq_params;
1392 u8 retry_short = 0, retry_long = 0;
1393 u32 frag_threshold = 0, rts_threshold = 0;
1394 u8 coverage_class = 0;
1397 * Try to find the wiphy and netdev. Normally this
1398 * function shouldn't need the netdev, but this is
1399 * done for backward compatibility -- previously
1400 * setting the channel was done per wiphy, but now
1401 * it is per netdev. Previous userland like hostapd
1402 * also passed a netdev to set_wiphy, so that it is
1403 * possible to let that go to the right netdev!
1405 mutex_lock(&cfg80211_mutex);
1407 if (info->attrs[NL80211_ATTR_IFINDEX]) {
1408 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
1410 netdev = dev_get_by_index(genl_info_net(info), ifindex);
1411 if (netdev && netdev->ieee80211_ptr) {
1412 rdev = wiphy_to_dev(netdev->ieee80211_ptr->wiphy);
1413 mutex_lock(&rdev->mtx);
1419 rdev = __cfg80211_rdev_from_info(info);
1421 mutex_unlock(&cfg80211_mutex);
1422 return PTR_ERR(rdev);
1428 mutex_lock(&rdev->mtx);
1429 } else if (nl80211_can_set_dev_channel(netdev->ieee80211_ptr))
1430 wdev = netdev->ieee80211_ptr;
1435 * end workaround code, by now the rdev is available
1436 * and locked, and wdev may or may not be NULL.
1439 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
1440 result = cfg80211_dev_rename(
1441 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
1443 mutex_unlock(&cfg80211_mutex);
1448 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
1449 struct ieee80211_txq_params txq_params;
1450 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
1452 if (!rdev->ops->set_txq_params) {
1453 result = -EOPNOTSUPP;
1462 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
1463 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
1468 if (!netif_running(netdev)) {
1473 nla_for_each_nested(nl_txq_params,
1474 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
1476 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
1477 nla_data(nl_txq_params),
1478 nla_len(nl_txq_params),
1480 result = parse_txq_params(tb, &txq_params);
1484 result = rdev->ops->set_txq_params(&rdev->wiphy,
1492 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
1493 result = __nl80211_set_channel(rdev, wdev, info);
1498 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
1499 enum nl80211_tx_power_setting type;
1502 if (!rdev->ops->set_tx_power) {
1503 result = -EOPNOTSUPP;
1507 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
1508 type = nla_get_u32(info->attrs[idx]);
1510 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
1511 (type != NL80211_TX_POWER_AUTOMATIC)) {
1516 if (type != NL80211_TX_POWER_AUTOMATIC) {
1517 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
1518 mbm = nla_get_u32(info->attrs[idx]);
1521 result = rdev->ops->set_tx_power(&rdev->wiphy, type, mbm);
1526 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
1527 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
1529 if ((!rdev->wiphy.available_antennas_tx &&
1530 !rdev->wiphy.available_antennas_rx) ||
1531 !rdev->ops->set_antenna) {
1532 result = -EOPNOTSUPP;
1536 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
1537 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
1539 /* reject antenna configurations which don't match the
1540 * available antenna masks, except for the "all" mask */
1541 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
1542 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) {
1547 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
1548 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
1550 result = rdev->ops->set_antenna(&rdev->wiphy, tx_ant, rx_ant);
1557 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
1558 retry_short = nla_get_u8(
1559 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
1560 if (retry_short == 0) {
1564 changed |= WIPHY_PARAM_RETRY_SHORT;
1567 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
1568 retry_long = nla_get_u8(
1569 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
1570 if (retry_long == 0) {
1574 changed |= WIPHY_PARAM_RETRY_LONG;
1577 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
1578 frag_threshold = nla_get_u32(
1579 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
1580 if (frag_threshold < 256) {
1584 if (frag_threshold != (u32) -1) {
1586 * Fragments (apart from the last one) are required to
1587 * have even length. Make the fragmentation code
1588 * simpler by stripping LSB should someone try to use
1589 * odd threshold value.
1591 frag_threshold &= ~0x1;
1593 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
1596 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
1597 rts_threshold = nla_get_u32(
1598 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
1599 changed |= WIPHY_PARAM_RTS_THRESHOLD;
1602 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
1603 coverage_class = nla_get_u8(
1604 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
1605 changed |= WIPHY_PARAM_COVERAGE_CLASS;
1609 u8 old_retry_short, old_retry_long;
1610 u32 old_frag_threshold, old_rts_threshold;
1611 u8 old_coverage_class;
1613 if (!rdev->ops->set_wiphy_params) {
1614 result = -EOPNOTSUPP;
1618 old_retry_short = rdev->wiphy.retry_short;
1619 old_retry_long = rdev->wiphy.retry_long;
1620 old_frag_threshold = rdev->wiphy.frag_threshold;
1621 old_rts_threshold = rdev->wiphy.rts_threshold;
1622 old_coverage_class = rdev->wiphy.coverage_class;
1624 if (changed & WIPHY_PARAM_RETRY_SHORT)
1625 rdev->wiphy.retry_short = retry_short;
1626 if (changed & WIPHY_PARAM_RETRY_LONG)
1627 rdev->wiphy.retry_long = retry_long;
1628 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
1629 rdev->wiphy.frag_threshold = frag_threshold;
1630 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
1631 rdev->wiphy.rts_threshold = rts_threshold;
1632 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
1633 rdev->wiphy.coverage_class = coverage_class;
1635 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
1637 rdev->wiphy.retry_short = old_retry_short;
1638 rdev->wiphy.retry_long = old_retry_long;
1639 rdev->wiphy.frag_threshold = old_frag_threshold;
1640 rdev->wiphy.rts_threshold = old_rts_threshold;
1641 rdev->wiphy.coverage_class = old_coverage_class;
1646 mutex_unlock(&rdev->mtx);
1653 static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
1654 struct cfg80211_registered_device *rdev,
1655 struct net_device *dev)
1659 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
1663 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
1664 nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
1665 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name) ||
1666 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
1667 dev->ieee80211_ptr->iftype) ||
1668 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1669 rdev->devlist_generation ^
1670 (cfg80211_rdev_list_generation << 2)))
1671 goto nla_put_failure;
1673 if (rdev->ops->get_channel) {
1674 struct ieee80211_channel *chan;
1675 enum nl80211_channel_type channel_type;
1677 chan = rdev->ops->get_channel(&rdev->wiphy, &channel_type);
1679 (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
1680 chan->center_freq) ||
1681 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
1683 goto nla_put_failure;
1686 return genlmsg_end(msg, hdr);
1689 genlmsg_cancel(msg, hdr);
1693 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
1697 int wp_start = cb->args[0];
1698 int if_start = cb->args[1];
1699 struct cfg80211_registered_device *rdev;
1700 struct wireless_dev *wdev;
1702 mutex_lock(&cfg80211_mutex);
1703 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1704 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
1706 if (wp_idx < wp_start) {
1712 mutex_lock(&rdev->devlist_mtx);
1713 list_for_each_entry(wdev, &rdev->netdev_list, list) {
1714 if (if_idx < if_start) {
1718 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
1719 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1720 rdev, wdev->netdev) < 0) {
1721 mutex_unlock(&rdev->devlist_mtx);
1726 mutex_unlock(&rdev->devlist_mtx);
1731 mutex_unlock(&cfg80211_mutex);
1733 cb->args[0] = wp_idx;
1734 cb->args[1] = if_idx;
1739 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
1741 struct sk_buff *msg;
1742 struct cfg80211_registered_device *dev = info->user_ptr[0];
1743 struct net_device *netdev = info->user_ptr[1];
1745 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
1749 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
1755 return genlmsg_reply(msg, info);
1758 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
1759 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
1760 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
1761 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
1762 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
1763 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
1766 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
1768 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
1776 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
1777 nla, mntr_flags_policy))
1780 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
1782 *mntrflags |= (1<<flag);
1787 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
1788 struct net_device *netdev, u8 use_4addr,
1789 enum nl80211_iftype iftype)
1792 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
1798 case NL80211_IFTYPE_AP_VLAN:
1799 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
1802 case NL80211_IFTYPE_STATION:
1803 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
1813 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
1815 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1816 struct vif_params params;
1818 enum nl80211_iftype otype, ntype;
1819 struct net_device *dev = info->user_ptr[1];
1820 u32 _flags, *flags = NULL;
1821 bool change = false;
1823 memset(¶ms, 0, sizeof(params));
1825 otype = ntype = dev->ieee80211_ptr->iftype;
1827 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1828 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1831 if (ntype > NL80211_IFTYPE_MAX)
1835 if (info->attrs[NL80211_ATTR_MESH_ID]) {
1836 struct wireless_dev *wdev = dev->ieee80211_ptr;
1838 if (ntype != NL80211_IFTYPE_MESH_POINT)
1840 if (netif_running(dev))
1844 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
1845 IEEE80211_MAX_MESH_ID_LEN);
1846 wdev->mesh_id_up_len =
1847 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1848 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
1849 wdev->mesh_id_up_len);
1853 if (info->attrs[NL80211_ATTR_4ADDR]) {
1854 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
1856 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
1860 params.use_4addr = -1;
1863 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
1864 if (ntype != NL80211_IFTYPE_MONITOR)
1866 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
1876 err = cfg80211_change_iface(rdev, dev, ntype, flags, ¶ms);
1880 if (!err && params.use_4addr != -1)
1881 dev->ieee80211_ptr->use_4addr = params.use_4addr;
1886 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
1888 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1889 struct vif_params params;
1890 struct net_device *dev;
1892 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
1895 memset(¶ms, 0, sizeof(params));
1897 if (!info->attrs[NL80211_ATTR_IFNAME])
1900 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1901 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1902 if (type > NL80211_IFTYPE_MAX)
1906 if (!rdev->ops->add_virtual_intf ||
1907 !(rdev->wiphy.interface_modes & (1 << type)))
1910 if (info->attrs[NL80211_ATTR_4ADDR]) {
1911 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
1912 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
1917 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
1918 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
1920 dev = rdev->ops->add_virtual_intf(&rdev->wiphy,
1921 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
1922 type, err ? NULL : &flags, ¶ms);
1924 return PTR_ERR(dev);
1926 if (type == NL80211_IFTYPE_MESH_POINT &&
1927 info->attrs[NL80211_ATTR_MESH_ID]) {
1928 struct wireless_dev *wdev = dev->ieee80211_ptr;
1931 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
1932 IEEE80211_MAX_MESH_ID_LEN);
1933 wdev->mesh_id_up_len =
1934 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1935 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
1936 wdev->mesh_id_up_len);
1943 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
1945 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1946 struct net_device *dev = info->user_ptr[1];
1948 if (!rdev->ops->del_virtual_intf)
1951 return rdev->ops->del_virtual_intf(&rdev->wiphy, dev);
1954 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
1956 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1957 struct net_device *dev = info->user_ptr[1];
1960 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
1963 if (!rdev->ops->set_noack_map)
1966 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
1968 return rdev->ops->set_noack_map(&rdev->wiphy, dev, noack_map);
1971 struct get_key_cookie {
1972 struct sk_buff *msg;
1977 static void get_key_callback(void *c, struct key_params *params)
1980 struct get_key_cookie *cookie = c;
1983 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
1984 params->key_len, params->key)) ||
1986 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
1987 params->seq_len, params->seq)) ||
1989 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
1991 goto nla_put_failure;
1993 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
1995 goto nla_put_failure;
1998 nla_put(cookie->msg, NL80211_KEY_DATA,
1999 params->key_len, params->key)) ||
2001 nla_put(cookie->msg, NL80211_KEY_SEQ,
2002 params->seq_len, params->seq)) ||
2004 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
2006 goto nla_put_failure;
2008 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
2009 goto nla_put_failure;
2011 nla_nest_end(cookie->msg, key);
2018 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
2020 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2022 struct net_device *dev = info->user_ptr[1];
2024 const u8 *mac_addr = NULL;
2026 struct get_key_cookie cookie = {
2030 struct sk_buff *msg;
2032 if (info->attrs[NL80211_ATTR_KEY_IDX])
2033 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
2038 if (info->attrs[NL80211_ATTR_MAC])
2039 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2041 pairwise = !!mac_addr;
2042 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
2043 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
2044 if (kt >= NUM_NL80211_KEYTYPES)
2046 if (kt != NL80211_KEYTYPE_GROUP &&
2047 kt != NL80211_KEYTYPE_PAIRWISE)
2049 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
2052 if (!rdev->ops->get_key)
2055 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2059 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2060 NL80211_CMD_NEW_KEY);
2062 return PTR_ERR(hdr);
2065 cookie.idx = key_idx;
2067 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2068 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
2069 goto nla_put_failure;
2071 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
2072 goto nla_put_failure;
2074 if (pairwise && mac_addr &&
2075 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2078 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, pairwise,
2079 mac_addr, &cookie, get_key_callback);
2085 goto nla_put_failure;
2087 genlmsg_end(msg, hdr);
2088 return genlmsg_reply(msg, info);
2097 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
2099 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2100 struct key_parse key;
2102 struct net_device *dev = info->user_ptr[1];
2104 err = nl80211_parse_key(info, &key);
2111 /* only support setting default key */
2112 if (!key.def && !key.defmgmt)
2115 wdev_lock(dev->ieee80211_ptr);
2118 if (!rdev->ops->set_default_key) {
2123 err = nl80211_key_allowed(dev->ieee80211_ptr);
2127 err = rdev->ops->set_default_key(&rdev->wiphy, dev, key.idx,
2128 key.def_uni, key.def_multi);
2133 #ifdef CONFIG_CFG80211_WEXT
2134 dev->ieee80211_ptr->wext.default_key = key.idx;
2137 if (key.def_uni || !key.def_multi) {
2142 if (!rdev->ops->set_default_mgmt_key) {
2147 err = nl80211_key_allowed(dev->ieee80211_ptr);
2151 err = rdev->ops->set_default_mgmt_key(&rdev->wiphy,
2156 #ifdef CONFIG_CFG80211_WEXT
2157 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
2162 wdev_unlock(dev->ieee80211_ptr);
2167 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
2169 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2171 struct net_device *dev = info->user_ptr[1];
2172 struct key_parse key;
2173 const u8 *mac_addr = NULL;
2175 err = nl80211_parse_key(info, &key);
2182 if (info->attrs[NL80211_ATTR_MAC])
2183 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2185 if (key.type == -1) {
2187 key.type = NL80211_KEYTYPE_PAIRWISE;
2189 key.type = NL80211_KEYTYPE_GROUP;
2193 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2194 key.type != NL80211_KEYTYPE_GROUP)
2197 if (!rdev->ops->add_key)
2200 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
2201 key.type == NL80211_KEYTYPE_PAIRWISE,
2205 wdev_lock(dev->ieee80211_ptr);
2206 err = nl80211_key_allowed(dev->ieee80211_ptr);
2208 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx,
2209 key.type == NL80211_KEYTYPE_PAIRWISE,
2211 wdev_unlock(dev->ieee80211_ptr);
2216 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
2218 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2220 struct net_device *dev = info->user_ptr[1];
2221 u8 *mac_addr = NULL;
2222 struct key_parse key;
2224 err = nl80211_parse_key(info, &key);
2228 if (info->attrs[NL80211_ATTR_MAC])
2229 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2231 if (key.type == -1) {
2233 key.type = NL80211_KEYTYPE_PAIRWISE;
2235 key.type = NL80211_KEYTYPE_GROUP;
2239 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2240 key.type != NL80211_KEYTYPE_GROUP)
2243 if (!rdev->ops->del_key)
2246 wdev_lock(dev->ieee80211_ptr);
2247 err = nl80211_key_allowed(dev->ieee80211_ptr);
2249 if (key.type == NL80211_KEYTYPE_PAIRWISE && mac_addr &&
2250 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2254 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx,
2255 key.type == NL80211_KEYTYPE_PAIRWISE,
2258 #ifdef CONFIG_CFG80211_WEXT
2260 if (key.idx == dev->ieee80211_ptr->wext.default_key)
2261 dev->ieee80211_ptr->wext.default_key = -1;
2262 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
2263 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
2266 wdev_unlock(dev->ieee80211_ptr);
2271 static int nl80211_parse_beacon(struct genl_info *info,
2272 struct cfg80211_beacon_data *bcn)
2274 bool haveinfo = false;
2276 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]) ||
2277 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]) ||
2278 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
2279 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]))
2282 memset(bcn, 0, sizeof(*bcn));
2284 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
2285 bcn->head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2286 bcn->head_len = nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2292 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
2293 bcn->tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2295 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2302 if (info->attrs[NL80211_ATTR_IE]) {
2303 bcn->beacon_ies = nla_data(info->attrs[NL80211_ATTR_IE]);
2304 bcn->beacon_ies_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2307 if (info->attrs[NL80211_ATTR_IE_PROBE_RESP]) {
2308 bcn->proberesp_ies =
2309 nla_data(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2310 bcn->proberesp_ies_len =
2311 nla_len(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2314 if (info->attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
2315 bcn->assocresp_ies =
2316 nla_data(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2317 bcn->assocresp_ies_len =
2318 nla_len(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2321 if (info->attrs[NL80211_ATTR_PROBE_RESP]) {
2323 nla_data(info->attrs[NL80211_ATTR_PROBE_RESP]);
2324 bcn->probe_resp_len =
2325 nla_len(info->attrs[NL80211_ATTR_PROBE_RESP]);
2331 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
2333 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2334 struct net_device *dev = info->user_ptr[1];
2335 struct wireless_dev *wdev = dev->ieee80211_ptr;
2336 struct cfg80211_ap_settings params;
2339 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2340 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2343 if (!rdev->ops->start_ap)
2346 if (wdev->beacon_interval)
2349 memset(¶ms, 0, sizeof(params));
2351 /* these are required for START_AP */
2352 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
2353 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
2354 !info->attrs[NL80211_ATTR_BEACON_HEAD])
2357 err = nl80211_parse_beacon(info, ¶ms.beacon);
2361 params.beacon_interval =
2362 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
2363 params.dtim_period =
2364 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
2366 err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
2371 * In theory, some of these attributes should be required here
2372 * but since they were not used when the command was originally
2373 * added, keep them optional for old user space programs to let
2374 * them continue to work with drivers that do not need the
2375 * additional information -- drivers must check!
2377 if (info->attrs[NL80211_ATTR_SSID]) {
2378 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
2380 nla_len(info->attrs[NL80211_ATTR_SSID]);
2381 if (params.ssid_len == 0 ||
2382 params.ssid_len > IEEE80211_MAX_SSID_LEN)
2386 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
2387 params.hidden_ssid = nla_get_u32(
2388 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
2389 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
2390 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
2391 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
2395 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
2397 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
2398 params.auth_type = nla_get_u32(
2399 info->attrs[NL80211_ATTR_AUTH_TYPE]);
2400 if (!nl80211_valid_auth_type(params.auth_type))
2403 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
2405 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
2406 NL80211_MAX_NR_CIPHER_SUITES);
2410 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
2411 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
2413 params.inactivity_timeout = nla_get_u16(
2414 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
2417 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2418 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
2420 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
2421 !nl80211_valid_channel_type(info, &channel_type))
2424 params.channel = rdev_freq_to_chan(rdev,
2425 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
2427 if (!params.channel)
2429 params.channel_type = channel_type;
2430 } else if (wdev->preset_chan) {
2431 params.channel = wdev->preset_chan;
2432 params.channel_type = wdev->preset_chantype;
2436 if (!cfg80211_can_beacon_sec_chan(&rdev->wiphy, params.channel,
2437 params.channel_type))
2440 err = rdev->ops->start_ap(&rdev->wiphy, dev, ¶ms);
2442 wdev->beacon_interval = params.beacon_interval;
2446 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
2448 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2449 struct net_device *dev = info->user_ptr[1];
2450 struct wireless_dev *wdev = dev->ieee80211_ptr;
2451 struct cfg80211_beacon_data params;
2454 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2455 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2458 if (!rdev->ops->change_beacon)
2461 if (!wdev->beacon_interval)
2464 err = nl80211_parse_beacon(info, ¶ms);
2468 return rdev->ops->change_beacon(&rdev->wiphy, dev, ¶ms);
2471 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
2473 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2474 struct net_device *dev = info->user_ptr[1];
2475 struct wireless_dev *wdev = dev->ieee80211_ptr;
2478 if (!rdev->ops->stop_ap)
2481 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2482 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2485 if (!wdev->beacon_interval)
2488 err = rdev->ops->stop_ap(&rdev->wiphy, dev);
2490 wdev->beacon_interval = 0;
2494 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
2495 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
2496 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
2497 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
2498 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
2499 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
2500 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
2503 static int parse_station_flags(struct genl_info *info,
2504 enum nl80211_iftype iftype,
2505 struct station_parameters *params)
2507 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
2512 * Try parsing the new attribute first so userspace
2513 * can specify both for older kernels.
2515 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
2517 struct nl80211_sta_flag_update *sta_flags;
2519 sta_flags = nla_data(nla);
2520 params->sta_flags_mask = sta_flags->mask;
2521 params->sta_flags_set = sta_flags->set;
2522 if ((params->sta_flags_mask |
2523 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
2528 /* if present, parse the old attribute */
2530 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
2534 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
2535 nla, sta_flags_policy))
2539 * Only allow certain flags for interface types so that
2540 * other attributes are silently ignored. Remember that
2541 * this is backward compatibility code with old userspace
2542 * and shouldn't be hit in other cases anyway.
2545 case NL80211_IFTYPE_AP:
2546 case NL80211_IFTYPE_AP_VLAN:
2547 case NL80211_IFTYPE_P2P_GO:
2548 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2549 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2550 BIT(NL80211_STA_FLAG_WME) |
2551 BIT(NL80211_STA_FLAG_MFP);
2553 case NL80211_IFTYPE_P2P_CLIENT:
2554 case NL80211_IFTYPE_STATION:
2555 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
2556 BIT(NL80211_STA_FLAG_TDLS_PEER);
2558 case NL80211_IFTYPE_MESH_POINT:
2559 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2560 BIT(NL80211_STA_FLAG_MFP) |
2561 BIT(NL80211_STA_FLAG_AUTHORIZED);
2566 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
2568 params->sta_flags_set |= (1<<flag);
2570 /* no longer support new API additions in old API */
2571 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
2579 static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
2582 struct nlattr *rate;
2585 rate = nla_nest_start(msg, attr);
2587 goto nla_put_failure;
2589 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
2590 bitrate = cfg80211_calculate_bitrate(info);
2592 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate)) ||
2593 ((info->flags & RATE_INFO_FLAGS_MCS) &&
2594 nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs)) ||
2595 ((info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) &&
2596 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH)) ||
2597 ((info->flags & RATE_INFO_FLAGS_SHORT_GI) &&
2598 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI)))
2599 goto nla_put_failure;
2601 nla_nest_end(msg, rate);
2608 static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
2610 struct cfg80211_registered_device *rdev,
2611 struct net_device *dev,
2612 const u8 *mac_addr, struct station_info *sinfo)
2615 struct nlattr *sinfoattr, *bss_param;
2617 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
2621 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2622 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
2623 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
2624 goto nla_put_failure;
2626 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
2628 goto nla_put_failure;
2629 if ((sinfo->filled & STATION_INFO_CONNECTED_TIME) &&
2630 nla_put_u32(msg, NL80211_STA_INFO_CONNECTED_TIME,
2631 sinfo->connected_time))
2632 goto nla_put_failure;
2633 if ((sinfo->filled & STATION_INFO_INACTIVE_TIME) &&
2634 nla_put_u32(msg, NL80211_STA_INFO_INACTIVE_TIME,
2635 sinfo->inactive_time))
2636 goto nla_put_failure;
2637 if ((sinfo->filled & STATION_INFO_RX_BYTES) &&
2638 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
2640 goto nla_put_failure;
2641 if ((sinfo->filled & STATION_INFO_TX_BYTES) &&
2642 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
2644 goto nla_put_failure;
2645 if ((sinfo->filled & STATION_INFO_LLID) &&
2646 nla_put_u16(msg, NL80211_STA_INFO_LLID, sinfo->llid))
2647 goto nla_put_failure;
2648 if ((sinfo->filled & STATION_INFO_PLID) &&
2649 nla_put_u16(msg, NL80211_STA_INFO_PLID, sinfo->plid))
2650 goto nla_put_failure;
2651 if ((sinfo->filled & STATION_INFO_PLINK_STATE) &&
2652 nla_put_u8(msg, NL80211_STA_INFO_PLINK_STATE,
2653 sinfo->plink_state))
2654 goto nla_put_failure;
2655 switch (rdev->wiphy.signal_type) {
2656 case CFG80211_SIGNAL_TYPE_MBM:
2657 if ((sinfo->filled & STATION_INFO_SIGNAL) &&
2658 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL,
2660 goto nla_put_failure;
2661 if ((sinfo->filled & STATION_INFO_SIGNAL_AVG) &&
2662 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL_AVG,
2664 goto nla_put_failure;
2669 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
2670 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
2671 NL80211_STA_INFO_TX_BITRATE))
2672 goto nla_put_failure;
2674 if (sinfo->filled & STATION_INFO_RX_BITRATE) {
2675 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
2676 NL80211_STA_INFO_RX_BITRATE))
2677 goto nla_put_failure;
2679 if ((sinfo->filled & STATION_INFO_RX_PACKETS) &&
2680 nla_put_u32(msg, NL80211_STA_INFO_RX_PACKETS,
2682 goto nla_put_failure;
2683 if ((sinfo->filled & STATION_INFO_TX_PACKETS) &&
2684 nla_put_u32(msg, NL80211_STA_INFO_TX_PACKETS,
2686 goto nla_put_failure;
2687 if ((sinfo->filled & STATION_INFO_TX_RETRIES) &&
2688 nla_put_u32(msg, NL80211_STA_INFO_TX_RETRIES,
2690 goto nla_put_failure;
2691 if ((sinfo->filled & STATION_INFO_TX_FAILED) &&
2692 nla_put_u32(msg, NL80211_STA_INFO_TX_FAILED,
2694 goto nla_put_failure;
2695 if ((sinfo->filled & STATION_INFO_BEACON_LOSS_COUNT) &&
2696 nla_put_u32(msg, NL80211_STA_INFO_BEACON_LOSS,
2697 sinfo->beacon_loss_count))
2698 goto nla_put_failure;
2699 if (sinfo->filled & STATION_INFO_BSS_PARAM) {
2700 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
2702 goto nla_put_failure;
2704 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
2705 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
2706 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
2707 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
2708 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
2709 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
2710 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
2711 sinfo->bss_param.dtim_period) ||
2712 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
2713 sinfo->bss_param.beacon_interval))
2714 goto nla_put_failure;
2716 nla_nest_end(msg, bss_param);
2718 if ((sinfo->filled & STATION_INFO_STA_FLAGS) &&
2719 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
2720 sizeof(struct nl80211_sta_flag_update),
2722 goto nla_put_failure;
2723 if ((sinfo->filled & STATION_INFO_T_OFFSET) &&
2724 nla_put_u64(msg, NL80211_STA_INFO_T_OFFSET,
2726 goto nla_put_failure;
2727 nla_nest_end(msg, sinfoattr);
2729 if ((sinfo->filled & STATION_INFO_ASSOC_REQ_IES) &&
2730 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
2731 sinfo->assoc_req_ies))
2732 goto nla_put_failure;
2734 return genlmsg_end(msg, hdr);
2737 genlmsg_cancel(msg, hdr);
2741 static int nl80211_dump_station(struct sk_buff *skb,
2742 struct netlink_callback *cb)
2744 struct station_info sinfo;
2745 struct cfg80211_registered_device *dev;
2746 struct net_device *netdev;
2747 u8 mac_addr[ETH_ALEN];
2748 int sta_idx = cb->args[1];
2751 err = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
2755 if (!dev->ops->dump_station) {
2761 memset(&sinfo, 0, sizeof(sinfo));
2762 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
2769 if (nl80211_send_station(skb,
2770 NETLINK_CB(cb->skb).pid,
2771 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2772 dev, netdev, mac_addr,
2781 cb->args[1] = sta_idx;
2784 nl80211_finish_netdev_dump(dev);
2789 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
2791 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2792 struct net_device *dev = info->user_ptr[1];
2793 struct station_info sinfo;
2794 struct sk_buff *msg;
2795 u8 *mac_addr = NULL;
2798 memset(&sinfo, 0, sizeof(sinfo));
2800 if (!info->attrs[NL80211_ATTR_MAC])
2803 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2805 if (!rdev->ops->get_station)
2808 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo);
2812 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2816 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
2817 rdev, dev, mac_addr, &sinfo) < 0) {
2822 return genlmsg_reply(msg, info);
2826 * Get vlan interface making sure it is running and on the right wiphy.
2828 static struct net_device *get_vlan(struct genl_info *info,
2829 struct cfg80211_registered_device *rdev)
2831 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
2832 struct net_device *v;
2838 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
2840 return ERR_PTR(-ENODEV);
2842 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
2847 if (!netif_running(v)) {
2855 return ERR_PTR(ret);
2858 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
2860 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2862 struct net_device *dev = info->user_ptr[1];
2863 struct station_parameters params;
2864 u8 *mac_addr = NULL;
2866 memset(¶ms, 0, sizeof(params));
2868 params.listen_interval = -1;
2869 params.plink_state = -1;
2871 if (info->attrs[NL80211_ATTR_STA_AID])
2874 if (!info->attrs[NL80211_ATTR_MAC])
2877 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2879 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
2880 params.supported_rates =
2881 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2882 params.supported_rates_len =
2883 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
2886 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
2887 params.listen_interval =
2888 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
2890 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
2892 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
2894 if (!rdev->ops->change_station)
2897 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
2900 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
2901 params.plink_action =
2902 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
2904 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE])
2905 params.plink_state =
2906 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
2908 switch (dev->ieee80211_ptr->iftype) {
2909 case NL80211_IFTYPE_AP:
2910 case NL80211_IFTYPE_AP_VLAN:
2911 case NL80211_IFTYPE_P2P_GO:
2912 /* disallow mesh-specific things */
2913 if (params.plink_action)
2916 /* TDLS can't be set, ... */
2917 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
2920 * ... but don't bother the driver with it. This works around
2921 * a hostapd/wpa_supplicant issue -- it always includes the
2922 * TLDS_PEER flag in the mask even for AP mode.
2924 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2926 /* accept only the listed bits */
2927 if (params.sta_flags_mask &
2928 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
2929 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
2930 BIT(NL80211_STA_FLAG_WME) |
2931 BIT(NL80211_STA_FLAG_MFP)))
2934 /* must be last in here for error handling */
2935 params.vlan = get_vlan(info, rdev);
2936 if (IS_ERR(params.vlan))
2937 return PTR_ERR(params.vlan);
2939 case NL80211_IFTYPE_P2P_CLIENT:
2940 case NL80211_IFTYPE_STATION:
2942 * Don't allow userspace to change the TDLS_PEER flag,
2943 * but silently ignore attempts to change it since we
2944 * don't have state here to verify that it doesn't try
2945 * to change the flag.
2947 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
2949 case NL80211_IFTYPE_ADHOC:
2950 /* disallow things sta doesn't support */
2951 if (params.plink_action)
2955 if (params.listen_interval >= 0)
2957 /* reject any changes other than AUTHORIZED */
2958 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
2961 case NL80211_IFTYPE_MESH_POINT:
2962 /* disallow things mesh doesn't support */
2967 if (params.listen_interval >= 0)
2970 * No special handling for TDLS here -- the userspace
2971 * mesh code doesn't have this bug.
2973 if (params.sta_flags_mask &
2974 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
2975 BIT(NL80211_STA_FLAG_MFP) |
2976 BIT(NL80211_STA_FLAG_AUTHORIZED)))
2983 /* be aware of params.vlan when changing code here */
2985 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, ¶ms);
2988 dev_put(params.vlan);
2993 static struct nla_policy
2994 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] __read_mostly = {
2995 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
2996 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
2999 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
3001 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3003 struct net_device *dev = info->user_ptr[1];
3004 struct station_parameters params;
3005 u8 *mac_addr = NULL;
3007 memset(¶ms, 0, sizeof(params));
3009 if (!info->attrs[NL80211_ATTR_MAC])
3012 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
3015 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
3018 if (!info->attrs[NL80211_ATTR_STA_AID])
3021 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3022 params.supported_rates =
3023 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3024 params.supported_rates_len =
3025 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3026 params.listen_interval =
3027 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
3029 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
3030 if (!params.aid || params.aid > IEEE80211_MAX_AID)
3033 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
3035 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
3037 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
3038 params.plink_action =
3039 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
3041 if (!rdev->ops->add_station)
3044 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
3047 switch (dev->ieee80211_ptr->iftype) {
3048 case NL80211_IFTYPE_AP:
3049 case NL80211_IFTYPE_AP_VLAN:
3050 case NL80211_IFTYPE_P2P_GO:
3051 /* parse WME attributes if sta is WME capable */
3052 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
3053 (params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)) &&
3054 info->attrs[NL80211_ATTR_STA_WME]) {
3055 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
3058 nla = info->attrs[NL80211_ATTR_STA_WME];
3059 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
3060 nl80211_sta_wme_policy);
3064 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
3065 params.uapsd_queues =
3066 nla_get_u8(tb[NL80211_STA_WME_UAPSD_QUEUES]);
3067 if (params.uapsd_queues &
3068 ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
3071 if (tb[NL80211_STA_WME_MAX_SP])
3073 nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
3076 ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
3079 params.sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
3081 /* TDLS peers cannot be added */
3082 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3084 /* but don't bother the driver with it */
3085 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3087 /* must be last in here for error handling */
3088 params.vlan = get_vlan(info, rdev);
3089 if (IS_ERR(params.vlan))
3090 return PTR_ERR(params.vlan);
3092 case NL80211_IFTYPE_MESH_POINT:
3093 /* TDLS peers cannot be added */
3094 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3097 case NL80211_IFTYPE_STATION:
3098 /* Only TDLS peers can be added */
3099 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3101 /* Can only add if TDLS ... */
3102 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
3104 /* ... with external setup is supported */
3105 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
3112 /* be aware of params.vlan when changing code here */
3114 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, ¶ms);
3117 dev_put(params.vlan);
3121 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
3123 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3124 struct net_device *dev = info->user_ptr[1];
3125 u8 *mac_addr = NULL;
3127 if (info->attrs[NL80211_ATTR_MAC])
3128 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3130 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3131 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
3132 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
3133 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3136 if (!rdev->ops->del_station)
3139 return rdev->ops->del_station(&rdev->wiphy, dev, mac_addr);
3142 static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
3143 int flags, struct net_device *dev,
3144 u8 *dst, u8 *next_hop,
3145 struct mpath_info *pinfo)
3148 struct nlattr *pinfoattr;
3150 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
3154 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3155 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
3156 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
3157 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
3158 goto nla_put_failure;
3160 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
3162 goto nla_put_failure;
3163 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
3164 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
3166 goto nla_put_failure;
3167 if (((pinfo->filled & MPATH_INFO_SN) &&
3168 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
3169 ((pinfo->filled & MPATH_INFO_METRIC) &&
3170 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
3172 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
3173 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
3175 ((pinfo->filled & MPATH_INFO_FLAGS) &&
3176 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
3178 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
3179 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
3180 pinfo->discovery_timeout)) ||
3181 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
3182 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
3183 pinfo->discovery_retries)))
3184 goto nla_put_failure;
3186 nla_nest_end(msg, pinfoattr);
3188 return genlmsg_end(msg, hdr);
3191 genlmsg_cancel(msg, hdr);
3195 static int nl80211_dump_mpath(struct sk_buff *skb,
3196 struct netlink_callback *cb)
3198 struct mpath_info pinfo;
3199 struct cfg80211_registered_device *dev;
3200 struct net_device *netdev;
3202 u8 next_hop[ETH_ALEN];
3203 int path_idx = cb->args[1];
3206 err = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
3210 if (!dev->ops->dump_mpath) {
3215 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
3221 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
3222 dst, next_hop, &pinfo);
3228 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
3229 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3230 netdev, dst, next_hop,
3239 cb->args[1] = path_idx;
3242 nl80211_finish_netdev_dump(dev);
3246 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
3248 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3250 struct net_device *dev = info->user_ptr[1];
3251 struct mpath_info pinfo;
3252 struct sk_buff *msg;
3254 u8 next_hop[ETH_ALEN];
3256 memset(&pinfo, 0, sizeof(pinfo));
3258 if (!info->attrs[NL80211_ATTR_MAC])
3261 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3263 if (!rdev->ops->get_mpath)
3266 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
3269 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo);
3273 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3277 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
3278 dev, dst, next_hop, &pinfo) < 0) {
3283 return genlmsg_reply(msg, info);
3286 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
3288 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3289 struct net_device *dev = info->user_ptr[1];
3291 u8 *next_hop = NULL;
3293 if (!info->attrs[NL80211_ATTR_MAC])
3296 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
3299 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3300 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
3302 if (!rdev->ops->change_mpath)
3305 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
3308 return rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
3311 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
3313 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3314 struct net_device *dev = info->user_ptr[1];
3316 u8 *next_hop = NULL;
3318 if (!info->attrs[NL80211_ATTR_MAC])
3321 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
3324 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3325 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
3327 if (!rdev->ops->add_mpath)
3330 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
3333 return rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
3336 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
3338 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3339 struct net_device *dev = info->user_ptr[1];
3342 if (info->attrs[NL80211_ATTR_MAC])
3343 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
3345 if (!rdev->ops->del_mpath)
3348 return rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
3351 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
3353 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3354 struct net_device *dev = info->user_ptr[1];
3355 struct bss_parameters params;
3357 memset(¶ms, 0, sizeof(params));
3358 /* default to not changing parameters */
3359 params.use_cts_prot = -1;
3360 params.use_short_preamble = -1;
3361 params.use_short_slot_time = -1;
3362 params.ap_isolate = -1;
3363 params.ht_opmode = -1;
3365 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
3366 params.use_cts_prot =
3367 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
3368 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
3369 params.use_short_preamble =
3370 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
3371 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
3372 params.use_short_slot_time =
3373 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
3374 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
3375 params.basic_rates =
3376 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
3377 params.basic_rates_len =
3378 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
3380 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
3381 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
3382 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
3384 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
3386 if (!rdev->ops->change_bss)
3389 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3390 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3393 return rdev->ops->change_bss(&rdev->wiphy, dev, ¶ms);
3396 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
3397 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
3398 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
3399 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
3400 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
3401 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
3402 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
3405 static int parse_reg_rule(struct nlattr *tb[],
3406 struct ieee80211_reg_rule *reg_rule)
3408 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
3409 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
3411 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
3413 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
3415 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
3417 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
3419 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
3422 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
3424 freq_range->start_freq_khz =
3425 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
3426 freq_range->end_freq_khz =
3427 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
3428 freq_range->max_bandwidth_khz =
3429 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
3431 power_rule->max_eirp =
3432 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
3434 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
3435 power_rule->max_antenna_gain =
3436 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
3441 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
3447 * You should only get this when cfg80211 hasn't yet initialized
3448 * completely when built-in to the kernel right between the time
3449 * window between nl80211_init() and regulatory_init(), if that is
3452 mutex_lock(&cfg80211_mutex);
3453 if (unlikely(!cfg80211_regdomain)) {
3454 mutex_unlock(&cfg80211_mutex);
3455 return -EINPROGRESS;
3457 mutex_unlock(&cfg80211_mutex);
3459 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
3462 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
3464 r = regulatory_hint_user(data);
3469 static int nl80211_get_mesh_config(struct sk_buff *skb,
3470 struct genl_info *info)
3472 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3473 struct net_device *dev = info->user_ptr[1];
3474 struct wireless_dev *wdev = dev->ieee80211_ptr;
3475 struct mesh_config cur_params;
3478 struct nlattr *pinfoattr;
3479 struct sk_buff *msg;
3481 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
3484 if (!rdev->ops->get_mesh_config)
3488 /* If not connected, get default parameters */
3489 if (!wdev->mesh_id_len)
3490 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
3492 err = rdev->ops->get_mesh_config(&rdev->wiphy, dev,
3499 /* Draw up a netlink message to send back */
3500 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3503 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
3504 NL80211_CMD_GET_MESH_CONFIG);
3507 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
3509 goto nla_put_failure;
3510 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3511 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
3512 cur_params.dot11MeshRetryTimeout) ||
3513 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
3514 cur_params.dot11MeshConfirmTimeout) ||
3515 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
3516 cur_params.dot11MeshHoldingTimeout) ||
3517 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
3518 cur_params.dot11MeshMaxPeerLinks) ||
3519 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
3520 cur_params.dot11MeshMaxRetries) ||
3521 nla_put_u8(msg, NL80211_MESHCONF_TTL,
3522 cur_params.dot11MeshTTL) ||
3523 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
3524 cur_params.element_ttl) ||
3525 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
3526 cur_params.auto_open_plinks) ||
3527 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
3528 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
3529 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
3530 cur_params.dot11MeshHWMPmaxPREQretries) ||
3531 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
3532 cur_params.path_refresh_time) ||
3533 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
3534 cur_params.min_discovery_timeout) ||
3535 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
3536 cur_params.dot11MeshHWMPactivePathTimeout) ||
3537 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
3538 cur_params.dot11MeshHWMPpreqMinInterval) ||
3539 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
3540 cur_params.dot11MeshHWMPperrMinInterval) ||
3541 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
3542 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
3543 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
3544 cur_params.dot11MeshHWMPRootMode) ||
3545 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
3546 cur_params.dot11MeshHWMPRannInterval) ||
3547 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
3548 cur_params.dot11MeshGateAnnouncementProtocol) ||
3549 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
3550 cur_params.dot11MeshForwarding) ||
3551 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
3552 cur_params.rssi_threshold) ||
3553 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
3554 cur_params.ht_opmode) ||
3555 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
3556 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
3557 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
3558 cur_params.dot11MeshHWMProotInterval) ||
3559 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3560 cur_params.dot11MeshHWMPconfirmationInterval))
3561 goto nla_put_failure;
3562 nla_nest_end(msg, pinfoattr);
3563 genlmsg_end(msg, hdr);
3564 return genlmsg_reply(msg, info);
3567 genlmsg_cancel(msg, hdr);
3573 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
3574 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
3575 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
3576 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
3577 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
3578 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
3579 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
3580 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
3581 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
3582 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
3583 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
3584 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
3585 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
3586 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
3587 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
3588 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
3589 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
3590 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
3591 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
3592 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
3593 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
3594 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
3595 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
3596 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
3597 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
3598 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
3601 static const struct nla_policy
3602 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
3603 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
3604 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
3605 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
3606 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
3607 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
3608 .len = IEEE80211_MAX_DATA_LEN },
3609 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
3612 static int nl80211_parse_mesh_config(struct genl_info *info,
3613 struct mesh_config *cfg,
3616 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
3619 #define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
3621 if (table[attr_num]) {\
3622 cfg->param = nla_fn(table[attr_num]); \
3623 mask |= (1 << (attr_num - 1)); \
3628 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
3630 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
3631 info->attrs[NL80211_ATTR_MESH_CONFIG],
3632 nl80211_meshconf_params_policy))
3635 /* This makes sure that there aren't more than 32 mesh config
3636 * parameters (otherwise our bitfield scheme would not work.) */
3637 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
3639 /* Fill in the params struct */
3640 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
3641 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
3643 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
3644 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
3646 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
3647 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
3649 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
3650 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
3652 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
3653 mask, NL80211_MESHCONF_MAX_RETRIES,
3655 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
3656 mask, NL80211_MESHCONF_TTL, nla_get_u8);
3657 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl,
3658 mask, NL80211_MESHCONF_ELEMENT_TTL,
3660 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
3661 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
3663 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor, mask,
3664 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
3666 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
3667 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
3669 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
3670 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
3672 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
3673 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
3675 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout, mask,
3676 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
3678 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
3679 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
3681 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
3682 mask, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
3684 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3685 dot11MeshHWMPnetDiameterTraversalTime, mask,
3686 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
3688 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask,
3689 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8);
3690 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask,
3691 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
3693 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3694 dot11MeshGateAnnouncementProtocol, mask,
3695 NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
3697 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding,
3698 mask, NL80211_MESHCONF_FORWARDING,
3700 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold,
3701 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
3703 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode,
3704 mask, NL80211_MESHCONF_HT_OPMODE,
3706 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
3708 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
3710 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval,
3711 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
3713 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
3714 dot11MeshHWMPconfirmationInterval, mask,
3715 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
3722 #undef FILL_IN_MESH_PARAM_IF_SET
3725 static int nl80211_parse_mesh_setup(struct genl_info *info,
3726 struct mesh_setup *setup)
3728 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
3730 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
3732 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
3733 info->attrs[NL80211_ATTR_MESH_SETUP],
3734 nl80211_mesh_setup_params_policy))
3737 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
3738 setup->sync_method =
3739 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
3740 IEEE80211_SYNC_METHOD_VENDOR :
3741 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
3743 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
3744 setup->path_sel_proto =
3745 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
3746 IEEE80211_PATH_PROTOCOL_VENDOR :
3747 IEEE80211_PATH_PROTOCOL_HWMP;
3749 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
3750 setup->path_metric =
3751 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
3752 IEEE80211_PATH_METRIC_VENDOR :
3753 IEEE80211_PATH_METRIC_AIRTIME;
3756 if (tb[NL80211_MESH_SETUP_IE]) {
3757 struct nlattr *ieattr =
3758 tb[NL80211_MESH_SETUP_IE];
3759 if (!is_valid_ie_attr(ieattr))
3761 setup->ie = nla_data(ieattr);
3762 setup->ie_len = nla_len(ieattr);
3764 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
3765 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
3770 static int nl80211_update_mesh_config(struct sk_buff *skb,
3771 struct genl_info *info)
3773 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3774 struct net_device *dev = info->user_ptr[1];
3775 struct wireless_dev *wdev = dev->ieee80211_ptr;
3776 struct mesh_config cfg;
3780 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
3783 if (!rdev->ops->update_mesh_config)
3786 err = nl80211_parse_mesh_config(info, &cfg, &mask);
3791 if (!wdev->mesh_id_len)
3795 err = rdev->ops->update_mesh_config(&rdev->wiphy, dev,
3803 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
3805 struct sk_buff *msg;
3807 struct nlattr *nl_reg_rules;
3811 mutex_lock(&cfg80211_mutex);
3813 if (!cfg80211_regdomain)
3816 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3822 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
3823 NL80211_CMD_GET_REG);
3827 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
3828 cfg80211_regdomain->alpha2) ||
3829 (cfg80211_regdomain->dfs_region &&
3830 nla_put_u8(msg, NL80211_ATTR_DFS_REGION,
3831 cfg80211_regdomain->dfs_region)))
3832 goto nla_put_failure;
3834 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
3836 goto nla_put_failure;
3838 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
3839 struct nlattr *nl_reg_rule;
3840 const struct ieee80211_reg_rule *reg_rule;
3841 const struct ieee80211_freq_range *freq_range;
3842 const struct ieee80211_power_rule *power_rule;
3844 reg_rule = &cfg80211_regdomain->reg_rules[i];
3845 freq_range = ®_rule->freq_range;
3846 power_rule = ®_rule->power_rule;
3848 nl_reg_rule = nla_nest_start(msg, i);
3850 goto nla_put_failure;
3852 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
3854 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
3855 freq_range->start_freq_khz) ||
3856 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
3857 freq_range->end_freq_khz) ||
3858 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
3859 freq_range->max_bandwidth_khz) ||
3860 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
3861 power_rule->max_antenna_gain) ||
3862 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
3863 power_rule->max_eirp))
3864 goto nla_put_failure;
3866 nla_nest_end(msg, nl_reg_rule);
3869 nla_nest_end(msg, nl_reg_rules);
3871 genlmsg_end(msg, hdr);
3872 err = genlmsg_reply(msg, info);
3876 genlmsg_cancel(msg, hdr);
3881 mutex_unlock(&cfg80211_mutex);
3885 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
3887 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
3888 struct nlattr *nl_reg_rule;
3889 char *alpha2 = NULL;
3890 int rem_reg_rules = 0, r = 0;
3891 u32 num_rules = 0, rule_idx = 0, size_of_regd;
3893 struct ieee80211_regdomain *rd = NULL;
3895 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
3898 if (!info->attrs[NL80211_ATTR_REG_RULES])
3901 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
3903 if (info->attrs[NL80211_ATTR_DFS_REGION])
3904 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
3906 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
3909 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
3913 mutex_lock(&cfg80211_mutex);
3915 if (!reg_is_valid_request(alpha2)) {
3920 size_of_regd = sizeof(struct ieee80211_regdomain) +
3921 (num_rules * sizeof(struct ieee80211_reg_rule));
3923 rd = kzalloc(size_of_regd, GFP_KERNEL);
3929 rd->n_reg_rules = num_rules;
3930 rd->alpha2[0] = alpha2[0];
3931 rd->alpha2[1] = alpha2[1];
3934 * Disable DFS master mode if the DFS region was
3935 * not supported or known on this kernel.
3937 if (reg_supported_dfs_region(dfs_region))
3938 rd->dfs_region = dfs_region;
3940 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
3942 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
3943 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
3945 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
3951 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
3957 BUG_ON(rule_idx != num_rules);
3961 mutex_unlock(&cfg80211_mutex);
3966 mutex_unlock(&cfg80211_mutex);
3971 static int validate_scan_freqs(struct nlattr *freqs)
3973 struct nlattr *attr1, *attr2;
3974 int n_channels = 0, tmp1, tmp2;
3976 nla_for_each_nested(attr1, freqs, tmp1) {
3979 * Some hardware has a limited channel list for
3980 * scanning, and it is pretty much nonsensical
3981 * to scan for a channel twice, so disallow that
3982 * and don't require drivers to check that the
3983 * channel list they get isn't longer than what
3984 * they can scan, as long as they can scan all
3985 * the channels they registered at once.
3987 nla_for_each_nested(attr2, freqs, tmp2)
3988 if (attr1 != attr2 &&
3989 nla_get_u32(attr1) == nla_get_u32(attr2))
3996 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
3998 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3999 struct net_device *dev = info->user_ptr[1];
4000 struct cfg80211_scan_request *request;
4001 struct nlattr *attr;
4002 struct wiphy *wiphy;
4003 int err, tmp, n_ssids = 0, n_channels, i;
4006 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4009 wiphy = &rdev->wiphy;
4011 if (!rdev->ops->scan)
4017 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4018 n_channels = validate_scan_freqs(
4019 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
4023 enum ieee80211_band band;
4026 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
4027 if (wiphy->bands[band])
4028 n_channels += wiphy->bands[band]->n_channels;
4031 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
4032 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
4035 if (n_ssids > wiphy->max_scan_ssids)
4038 if (info->attrs[NL80211_ATTR_IE])
4039 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4043 if (ie_len > wiphy->max_scan_ie_len)
4046 request = kzalloc(sizeof(*request)
4047 + sizeof(*request->ssids) * n_ssids
4048 + sizeof(*request->channels) * n_channels
4049 + ie_len, GFP_KERNEL);
4054 request->ssids = (void *)&request->channels[n_channels];
4055 request->n_ssids = n_ssids;
4058 request->ie = (void *)(request->ssids + n_ssids);
4060 request->ie = (void *)(request->channels + n_channels);
4064 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4065 /* user specified, bail out if channel not found */
4066 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
4067 struct ieee80211_channel *chan;
4069 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
4076 /* ignore disabled channels */
4077 if (chan->flags & IEEE80211_CHAN_DISABLED)
4080 request->channels[i] = chan;
4084 enum ieee80211_band band;
4087 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
4089 if (!wiphy->bands[band])
4091 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
4092 struct ieee80211_channel *chan;
4094 chan = &wiphy->bands[band]->channels[j];
4096 if (chan->flags & IEEE80211_CHAN_DISABLED)
4099 request->channels[i] = chan;
4110 request->n_channels = i;
4113 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
4114 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
4115 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
4119 request->ssids[i].ssid_len = nla_len(attr);
4120 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
4125 if (info->attrs[NL80211_ATTR_IE]) {
4126 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4127 memcpy((void *)request->ie,
4128 nla_data(info->attrs[NL80211_ATTR_IE]),
4132 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
4133 if (wiphy->bands[i])
4135 (1 << wiphy->bands[i]->n_bitrates) - 1;
4137 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
4138 nla_for_each_nested(attr,
4139 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
4141 enum ieee80211_band band = nla_type(attr);
4143 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
4147 err = ieee80211_get_ratemask(wiphy->bands[band],
4150 &request->rates[band]);
4157 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
4160 request->wiphy = &rdev->wiphy;
4162 rdev->scan_req = request;
4163 err = rdev->ops->scan(&rdev->wiphy, dev, request);
4166 nl80211_send_scan_start(rdev, dev);
4170 rdev->scan_req = NULL;
4177 static int nl80211_start_sched_scan(struct sk_buff *skb,
4178 struct genl_info *info)
4180 struct cfg80211_sched_scan_request *request;
4181 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4182 struct net_device *dev = info->user_ptr[1];
4183 struct nlattr *attr;
4184 struct wiphy *wiphy;
4185 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
4187 enum ieee80211_band band;
4189 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
4191 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
4192 !rdev->ops->sched_scan_start)
4195 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4198 if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
4201 interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
4205 wiphy = &rdev->wiphy;
4207 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4208 n_channels = validate_scan_freqs(
4209 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
4215 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
4216 if (wiphy->bands[band])
4217 n_channels += wiphy->bands[band]->n_channels;
4220 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
4221 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
4225 if (n_ssids > wiphy->max_sched_scan_ssids)
4228 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH])
4229 nla_for_each_nested(attr,
4230 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
4234 if (n_match_sets > wiphy->max_match_sets)
4237 if (info->attrs[NL80211_ATTR_IE])
4238 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4242 if (ie_len > wiphy->max_sched_scan_ie_len)
4245 mutex_lock(&rdev->sched_scan_mtx);
4247 if (rdev->sched_scan_req) {
4252 request = kzalloc(sizeof(*request)
4253 + sizeof(*request->ssids) * n_ssids
4254 + sizeof(*request->match_sets) * n_match_sets
4255 + sizeof(*request->channels) * n_channels
4256 + ie_len, GFP_KERNEL);
4263 request->ssids = (void *)&request->channels[n_channels];
4264 request->n_ssids = n_ssids;
4267 request->ie = (void *)(request->ssids + n_ssids);
4269 request->ie = (void *)(request->channels + n_channels);
4274 request->match_sets = (void *)(request->ie + ie_len);
4275 else if (request->ssids)
4276 request->match_sets =
4277 (void *)(request->ssids + n_ssids);
4279 request->match_sets =
4280 (void *)(request->channels + n_channels);
4282 request->n_match_sets = n_match_sets;
4285 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4286 /* user specified, bail out if channel not found */
4287 nla_for_each_nested(attr,
4288 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
4290 struct ieee80211_channel *chan;
4292 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
4299 /* ignore disabled channels */
4300 if (chan->flags & IEEE80211_CHAN_DISABLED)
4303 request->channels[i] = chan;
4308 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
4310 if (!wiphy->bands[band])
4312 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
4313 struct ieee80211_channel *chan;
4315 chan = &wiphy->bands[band]->channels[j];
4317 if (chan->flags & IEEE80211_CHAN_DISABLED)
4320 request->channels[i] = chan;
4331 request->n_channels = i;
4334 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
4335 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
4337 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
4341 request->ssids[i].ssid_len = nla_len(attr);
4342 memcpy(request->ssids[i].ssid, nla_data(attr),
4349 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
4350 nla_for_each_nested(attr,
4351 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
4353 struct nlattr *ssid;
4355 nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
4356 nla_data(attr), nla_len(attr),
4357 nl80211_match_policy);
4358 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
4360 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
4364 memcpy(request->match_sets[i].ssid.ssid,
4365 nla_data(ssid), nla_len(ssid));
4366 request->match_sets[i].ssid.ssid_len =
4373 if (info->attrs[NL80211_ATTR_IE]) {
4374 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4375 memcpy((void *)request->ie,
4376 nla_data(info->attrs[NL80211_ATTR_IE]),
4381 request->wiphy = &rdev->wiphy;
4382 request->interval = interval;
4384 err = rdev->ops->sched_scan_start(&rdev->wiphy, dev, request);
4386 rdev->sched_scan_req = request;
4387 nl80211_send_sched_scan(rdev, dev,
4388 NL80211_CMD_START_SCHED_SCAN);
4395 mutex_unlock(&rdev->sched_scan_mtx);
4399 static int nl80211_stop_sched_scan(struct sk_buff *skb,
4400 struct genl_info *info)
4402 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4405 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
4406 !rdev->ops->sched_scan_stop)
4409 mutex_lock(&rdev->sched_scan_mtx);
4410 err = __cfg80211_stop_sched_scan(rdev, false);
4411 mutex_unlock(&rdev->sched_scan_mtx);
4416 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
4418 struct cfg80211_registered_device *rdev,
4419 struct wireless_dev *wdev,
4420 struct cfg80211_internal_bss *intbss)
4422 struct cfg80211_bss *res = &intbss->pub;
4426 ASSERT_WDEV_LOCK(wdev);
4428 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).pid, seq, flags,
4429 NL80211_CMD_NEW_SCAN_RESULTS);
4433 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
4435 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation) ||
4436 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
4437 goto nla_put_failure;
4439 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
4441 goto nla_put_failure;
4442 if ((!is_zero_ether_addr(res->bssid) &&
4443 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)) ||
4444 (res->information_elements && res->len_information_elements &&
4445 nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
4446 res->len_information_elements,
4447 res->information_elements)) ||
4448 (res->beacon_ies && res->len_beacon_ies &&
4449 res->beacon_ies != res->information_elements &&
4450 nla_put(msg, NL80211_BSS_BEACON_IES,
4451 res->len_beacon_ies, res->beacon_ies)))
4452 goto nla_put_failure;
4454 nla_put_u64(msg, NL80211_BSS_TSF, res->tsf))
4455 goto nla_put_failure;
4456 if (res->beacon_interval &&
4457 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
4458 goto nla_put_failure;
4459 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
4460 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
4461 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
4462 jiffies_to_msecs(jiffies - intbss->ts)))
4463 goto nla_put_failure;
4465 switch (rdev->wiphy.signal_type) {
4466 case CFG80211_SIGNAL_TYPE_MBM:
4467 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
4468 goto nla_put_failure;
4470 case CFG80211_SIGNAL_TYPE_UNSPEC:
4471 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
4472 goto nla_put_failure;
4478 switch (wdev->iftype) {
4479 case NL80211_IFTYPE_P2P_CLIENT:
4480 case NL80211_IFTYPE_STATION:
4481 if (intbss == wdev->current_bss &&
4482 nla_put_u32(msg, NL80211_BSS_STATUS,
4483 NL80211_BSS_STATUS_ASSOCIATED))
4484 goto nla_put_failure;
4486 case NL80211_IFTYPE_ADHOC:
4487 if (intbss == wdev->current_bss &&
4488 nla_put_u32(msg, NL80211_BSS_STATUS,
4489 NL80211_BSS_STATUS_IBSS_JOINED))
4490 goto nla_put_failure;
4496 nla_nest_end(msg, bss);
4498 return genlmsg_end(msg, hdr);
4501 genlmsg_cancel(msg, hdr);
4505 static int nl80211_dump_scan(struct sk_buff *skb,
4506 struct netlink_callback *cb)
4508 struct cfg80211_registered_device *rdev;
4509 struct net_device *dev;
4510 struct cfg80211_internal_bss *scan;
4511 struct wireless_dev *wdev;
4512 int start = cb->args[1], idx = 0;
4515 err = nl80211_prepare_netdev_dump(skb, cb, &rdev, &dev);
4519 wdev = dev->ieee80211_ptr;
4522 spin_lock_bh(&rdev->bss_lock);
4523 cfg80211_bss_expire(rdev);
4525 cb->seq = rdev->bss_generation;
4527 list_for_each_entry(scan, &rdev->bss_list, list) {
4530 if (nl80211_send_bss(skb, cb,
4531 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4532 rdev, wdev, scan) < 0) {
4538 spin_unlock_bh(&rdev->bss_lock);
4542 nl80211_finish_netdev_dump(rdev);
4547 static int nl80211_send_survey(struct sk_buff *msg, u32 pid, u32 seq,
4548 int flags, struct net_device *dev,
4549 struct survey_info *survey)
4552 struct nlattr *infoattr;
4554 hdr = nl80211hdr_put(msg, pid, seq, flags,
4555 NL80211_CMD_NEW_SURVEY_RESULTS);
4559 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
4560 goto nla_put_failure;
4562 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
4564 goto nla_put_failure;
4566 if (nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
4567 survey->channel->center_freq))
4568 goto nla_put_failure;
4570 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
4571 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
4572 goto nla_put_failure;
4573 if ((survey->filled & SURVEY_INFO_IN_USE) &&
4574 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
4575 goto nla_put_failure;
4576 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME) &&
4577 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME,
4578 survey->channel_time))
4579 goto nla_put_failure;
4580 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_BUSY) &&
4581 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY,
4582 survey->channel_time_busy))
4583 goto nla_put_failure;
4584 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) &&
4585 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY,
4586 survey->channel_time_ext_busy))
4587 goto nla_put_failure;
4588 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_RX) &&
4589 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_RX,
4590 survey->channel_time_rx))
4591 goto nla_put_failure;
4592 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_TX) &&
4593 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_TX,
4594 survey->channel_time_tx))
4595 goto nla_put_failure;
4597 nla_nest_end(msg, infoattr);
4599 return genlmsg_end(msg, hdr);
4602 genlmsg_cancel(msg, hdr);
4606 static int nl80211_dump_survey(struct sk_buff *skb,
4607 struct netlink_callback *cb)
4609 struct survey_info survey;
4610 struct cfg80211_registered_device *dev;
4611 struct net_device *netdev;
4612 int survey_idx = cb->args[1];
4615 res = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
4619 if (!dev->ops->dump_survey) {
4625 struct ieee80211_channel *chan;
4627 res = dev->ops->dump_survey(&dev->wiphy, netdev, survey_idx,
4634 /* Survey without a channel doesn't make sense */
4635 if (!survey.channel) {
4640 chan = ieee80211_get_channel(&dev->wiphy,
4641 survey.channel->center_freq);
4642 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
4647 if (nl80211_send_survey(skb,
4648 NETLINK_CB(cb->skb).pid,
4649 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4657 cb->args[1] = survey_idx;
4660 nl80211_finish_netdev_dump(dev);
4664 static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
4666 return auth_type <= NL80211_AUTHTYPE_MAX;
4669 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
4671 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
4672 NL80211_WPA_VERSION_2));
4675 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
4677 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4678 struct net_device *dev = info->user_ptr[1];
4679 struct ieee80211_channel *chan;
4680 const u8 *bssid, *ssid, *ie = NULL;
4681 int err, ssid_len, ie_len = 0;
4682 enum nl80211_auth_type auth_type;
4683 struct key_parse key;
4684 bool local_state_change;
4686 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4689 if (!info->attrs[NL80211_ATTR_MAC])
4692 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
4695 if (!info->attrs[NL80211_ATTR_SSID])
4698 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
4701 err = nl80211_parse_key(info, &key);
4706 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
4708 if (!key.p.key || !key.p.key_len)
4710 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
4711 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
4712 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
4713 key.p.key_len != WLAN_KEY_LEN_WEP104))
4725 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
4726 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
4735 if (!rdev->ops->auth)
4738 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4739 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4742 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4743 chan = ieee80211_get_channel(&rdev->wiphy,
4744 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
4745 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
4748 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4749 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
4751 if (info->attrs[NL80211_ATTR_IE]) {
4752 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4753 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4756 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
4757 if (!nl80211_valid_auth_type(auth_type))
4760 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
4763 * Since we no longer track auth state, ignore
4764 * requests to only change local state.
4766 if (local_state_change)
4769 return cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
4770 ssid, ssid_len, ie, ie_len,
4771 key.p.key, key.p.key_len, key.idx);
4774 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
4775 struct genl_info *info,
4776 struct cfg80211_crypto_settings *settings,
4779 memset(settings, 0, sizeof(*settings));
4781 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
4783 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
4785 proto = nla_get_u16(
4786 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
4787 settings->control_port_ethertype = cpu_to_be16(proto);
4788 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
4791 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
4792 settings->control_port_no_encrypt = true;
4794 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
4796 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
4800 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
4801 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
4802 settings->n_ciphers_pairwise = len / sizeof(u32);
4804 if (len % sizeof(u32))
4807 if (settings->n_ciphers_pairwise > cipher_limit)
4810 memcpy(settings->ciphers_pairwise, data, len);
4812 for (i = 0; i < settings->n_ciphers_pairwise; i++)
4813 if (!cfg80211_supported_cipher_suite(
4815 settings->ciphers_pairwise[i]))
4819 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
4820 settings->cipher_group =
4821 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
4822 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
4823 settings->cipher_group))
4827 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
4828 settings->wpa_versions =
4829 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
4830 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
4834 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
4838 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
4839 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
4840 settings->n_akm_suites = len / sizeof(u32);
4842 if (len % sizeof(u32))
4845 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
4848 memcpy(settings->akm_suites, data, len);
4854 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
4856 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4857 struct net_device *dev = info->user_ptr[1];
4858 struct cfg80211_crypto_settings crypto;
4859 struct ieee80211_channel *chan;
4860 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
4861 int err, ssid_len, ie_len = 0;
4862 bool use_mfp = false;
4864 struct ieee80211_ht_cap *ht_capa = NULL;
4865 struct ieee80211_ht_cap *ht_capa_mask = NULL;
4867 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4870 if (!info->attrs[NL80211_ATTR_MAC] ||
4871 !info->attrs[NL80211_ATTR_SSID] ||
4872 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
4875 if (!rdev->ops->assoc)
4878 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4879 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4882 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4884 chan = ieee80211_get_channel(&rdev->wiphy,
4885 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
4886 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
4889 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4890 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
4892 if (info->attrs[NL80211_ATTR_IE]) {
4893 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4894 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4897 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4898 enum nl80211_mfp mfp =
4899 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4900 if (mfp == NL80211_MFP_REQUIRED)
4902 else if (mfp != NL80211_MFP_NO)
4906 if (info->attrs[NL80211_ATTR_PREV_BSSID])
4907 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
4909 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
4910 flags |= ASSOC_REQ_DISABLE_HT;
4912 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
4914 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]);
4916 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
4919 ht_capa = nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4922 err = nl80211_crypto_settings(rdev, info, &crypto, 1);
4924 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
4925 ssid, ssid_len, ie, ie_len, use_mfp,
4926 &crypto, flags, ht_capa,
4932 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
4934 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4935 struct net_device *dev = info->user_ptr[1];
4936 const u8 *ie = NULL, *bssid;
4939 bool local_state_change;
4941 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4944 if (!info->attrs[NL80211_ATTR_MAC])
4947 if (!info->attrs[NL80211_ATTR_REASON_CODE])
4950 if (!rdev->ops->deauth)
4953 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4954 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
4957 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
4959 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
4960 if (reason_code == 0) {
4961 /* Reason Code 0 is reserved */
4965 if (info->attrs[NL80211_ATTR_IE]) {
4966 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
4967 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4970 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
4972 return cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
4973 local_state_change);
4976 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
4978 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4979 struct net_device *dev = info->user_ptr[1];
4980 const u8 *ie = NULL, *bssid;
4983 bool local_state_change;
4985 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4988 if (!info->attrs[NL80211_ATTR_MAC])
4991 if (!info->attrs[NL80211_ATTR_REASON_CODE])
4994 if (!rdev->ops->disassoc)
4997 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
4998 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5001 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5003 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5004 if (reason_code == 0) {
5005 /* Reason Code 0 is reserved */
5009 if (info->attrs[NL80211_ATTR_IE]) {
5010 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5011 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5014 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
5016 return cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
5017 local_state_change);
5021 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
5022 int mcast_rate[IEEE80211_NUM_BANDS],
5025 struct wiphy *wiphy = &rdev->wiphy;
5029 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5030 struct ieee80211_supported_band *sband;
5032 sband = wiphy->bands[band];
5036 for (i = 0; i < sband->n_bitrates; i++) {
5037 if (sband->bitrates[i].bitrate == rateval) {
5038 mcast_rate[band] = i + 1;
5048 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
5050 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5051 struct net_device *dev = info->user_ptr[1];
5052 struct cfg80211_ibss_params ibss;
5053 struct wiphy *wiphy;
5054 struct cfg80211_cached_keys *connkeys = NULL;
5057 memset(&ibss, 0, sizeof(ibss));
5059 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5062 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
5063 !info->attrs[NL80211_ATTR_SSID] ||
5064 !nla_len(info->attrs[NL80211_ATTR_SSID]))
5067 ibss.beacon_interval = 100;
5069 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
5070 ibss.beacon_interval =
5071 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
5072 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
5076 if (!rdev->ops->join_ibss)
5079 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
5082 wiphy = &rdev->wiphy;
5084 if (info->attrs[NL80211_ATTR_MAC]) {
5085 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5087 if (!is_valid_ether_addr(ibss.bssid))
5090 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5091 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5093 if (info->attrs[NL80211_ATTR_IE]) {
5094 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5095 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5098 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
5099 enum nl80211_channel_type channel_type;
5101 if (!nl80211_valid_channel_type(info, &channel_type))
5104 if (channel_type != NL80211_CHAN_NO_HT &&
5105 !(wiphy->features & NL80211_FEATURE_HT_IBSS))
5108 ibss.channel_type = channel_type;
5110 ibss.channel_type = NL80211_CHAN_NO_HT;
5113 ibss.channel = rdev_freq_to_chan(rdev,
5114 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
5116 if (!ibss.channel ||
5117 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
5118 ibss.channel->flags & IEEE80211_CHAN_DISABLED)
5121 /* Both channels should be able to initiate communication */
5122 if ((ibss.channel_type == NL80211_CHAN_HT40PLUS ||
5123 ibss.channel_type == NL80211_CHAN_HT40MINUS) &&
5124 !cfg80211_can_beacon_sec_chan(&rdev->wiphy, ibss.channel,
5128 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
5129 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
5131 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
5133 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5135 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
5136 struct ieee80211_supported_band *sband =
5137 wiphy->bands[ibss.channel->band];
5139 err = ieee80211_get_ratemask(sband, rates, n_rates,
5145 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
5146 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
5147 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
5150 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
5151 connkeys = nl80211_parse_connkeys(rdev,
5152 info->attrs[NL80211_ATTR_KEYS]);
5153 if (IS_ERR(connkeys))
5154 return PTR_ERR(connkeys);
5158 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
5160 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
5166 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
5168 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5169 struct net_device *dev = info->user_ptr[1];
5171 if (!rdev->ops->leave_ibss)
5174 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
5177 return cfg80211_leave_ibss(rdev, dev, false);
5180 #ifdef CONFIG_NL80211_TESTMODE
5181 static struct genl_multicast_group nl80211_testmode_mcgrp = {
5185 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
5187 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5190 if (!info->attrs[NL80211_ATTR_TESTDATA])
5194 if (rdev->ops->testmode_cmd) {
5195 rdev->testmode_info = info;
5196 err = rdev->ops->testmode_cmd(&rdev->wiphy,
5197 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
5198 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
5199 rdev->testmode_info = NULL;
5205 static int nl80211_testmode_dump(struct sk_buff *skb,
5206 struct netlink_callback *cb)
5208 struct cfg80211_registered_device *rdev;
5216 * 0 is a valid index, but not valid for args[0],
5217 * so we need to offset by 1.
5219 phy_idx = cb->args[0] - 1;
5221 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
5222 nl80211_fam.attrbuf, nl80211_fam.maxattr,
5226 if (nl80211_fam.attrbuf[NL80211_ATTR_WIPHY]) {
5227 phy_idx = nla_get_u32(
5228 nl80211_fam.attrbuf[NL80211_ATTR_WIPHY]);
5230 struct net_device *netdev;
5232 err = get_rdev_dev_by_ifindex(sock_net(skb->sk),
5233 nl80211_fam.attrbuf,
5238 phy_idx = rdev->wiphy_idx;
5239 cfg80211_unlock_rdev(rdev);
5241 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
5243 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
5247 data = nla_data((void *)cb->args[1]);
5248 data_len = nla_len((void *)cb->args[1]);
5251 mutex_lock(&cfg80211_mutex);
5252 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
5254 mutex_unlock(&cfg80211_mutex);
5257 cfg80211_lock_rdev(rdev);
5258 mutex_unlock(&cfg80211_mutex);
5260 if (!rdev->ops->testmode_dump) {
5266 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).pid,
5267 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5268 NL80211_CMD_TESTMODE);
5269 struct nlattr *tmdata;
5271 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
5272 genlmsg_cancel(skb, hdr);
5276 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
5278 genlmsg_cancel(skb, hdr);
5281 err = rdev->ops->testmode_dump(&rdev->wiphy, skb, cb,
5283 nla_nest_end(skb, tmdata);
5285 if (err == -ENOBUFS || err == -ENOENT) {
5286 genlmsg_cancel(skb, hdr);
5289 genlmsg_cancel(skb, hdr);
5293 genlmsg_end(skb, hdr);
5298 cb->args[0] = phy_idx + 1;
5300 cfg80211_unlock_rdev(rdev);
5304 static struct sk_buff *
5305 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
5306 int approxlen, u32 pid, u32 seq, gfp_t gfp)
5308 struct sk_buff *skb;
5310 struct nlattr *data;
5312 skb = nlmsg_new(approxlen + 100, gfp);
5316 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE);
5322 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
5323 goto nla_put_failure;
5324 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
5326 ((void **)skb->cb)[0] = rdev;
5327 ((void **)skb->cb)[1] = hdr;
5328 ((void **)skb->cb)[2] = data;
5337 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
5340 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
5342 if (WARN_ON(!rdev->testmode_info))
5345 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
5346 rdev->testmode_info->snd_pid,
5347 rdev->testmode_info->snd_seq,
5350 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
5352 int cfg80211_testmode_reply(struct sk_buff *skb)
5354 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
5355 void *hdr = ((void **)skb->cb)[1];
5356 struct nlattr *data = ((void **)skb->cb)[2];
5358 if (WARN_ON(!rdev->testmode_info)) {
5363 nla_nest_end(skb, data);
5364 genlmsg_end(skb, hdr);
5365 return genlmsg_reply(skb, rdev->testmode_info);
5367 EXPORT_SYMBOL(cfg80211_testmode_reply);
5369 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
5370 int approxlen, gfp_t gfp)
5372 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
5374 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
5376 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
5378 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
5380 void *hdr = ((void **)skb->cb)[1];
5381 struct nlattr *data = ((void **)skb->cb)[2];
5383 nla_nest_end(skb, data);
5384 genlmsg_end(skb, hdr);
5385 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
5387 EXPORT_SYMBOL(cfg80211_testmode_event);
5390 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
5392 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5393 struct net_device *dev = info->user_ptr[1];
5394 struct cfg80211_connect_params connect;
5395 struct wiphy *wiphy;
5396 struct cfg80211_cached_keys *connkeys = NULL;
5399 memset(&connect, 0, sizeof(connect));
5401 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5404 if (!info->attrs[NL80211_ATTR_SSID] ||
5405 !nla_len(info->attrs[NL80211_ATTR_SSID]))
5408 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
5410 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
5411 if (!nl80211_valid_auth_type(connect.auth_type))
5414 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
5416 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
5418 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
5419 NL80211_MAX_NR_CIPHER_SUITES);
5423 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5424 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5427 wiphy = &rdev->wiphy;
5429 connect.bg_scan_period = -1;
5430 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
5431 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
5432 connect.bg_scan_period =
5433 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
5436 if (info->attrs[NL80211_ATTR_MAC])
5437 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5438 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5439 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5441 if (info->attrs[NL80211_ATTR_IE]) {
5442 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5443 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5446 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
5448 ieee80211_get_channel(wiphy,
5449 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
5450 if (!connect.channel ||
5451 connect.channel->flags & IEEE80211_CHAN_DISABLED)
5455 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
5456 connkeys = nl80211_parse_connkeys(rdev,
5457 info->attrs[NL80211_ATTR_KEYS]);
5458 if (IS_ERR(connkeys))
5459 return PTR_ERR(connkeys);
5462 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
5463 connect.flags |= ASSOC_REQ_DISABLE_HT;
5465 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
5466 memcpy(&connect.ht_capa_mask,
5467 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
5468 sizeof(connect.ht_capa_mask));
5470 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
5471 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
5473 memcpy(&connect.ht_capa,
5474 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
5475 sizeof(connect.ht_capa));
5478 err = cfg80211_connect(rdev, dev, &connect, connkeys);
5484 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
5486 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5487 struct net_device *dev = info->user_ptr[1];
5490 if (!info->attrs[NL80211_ATTR_REASON_CODE])
5491 reason = WLAN_REASON_DEAUTH_LEAVING;
5493 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5498 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5499 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5502 return cfg80211_disconnect(rdev, dev, reason, true);
5505 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
5507 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5512 if (!info->attrs[NL80211_ATTR_PID])
5515 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
5517 net = get_net_ns_by_pid(pid);
5519 return PTR_ERR(net);
5523 /* check if anything to do */
5524 if (!net_eq(wiphy_net(&rdev->wiphy), net))
5525 err = cfg80211_switch_netns(rdev, net);
5531 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
5533 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5534 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
5535 struct cfg80211_pmksa *pmksa) = NULL;
5536 struct net_device *dev = info->user_ptr[1];
5537 struct cfg80211_pmksa pmksa;
5539 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
5541 if (!info->attrs[NL80211_ATTR_MAC])
5544 if (!info->attrs[NL80211_ATTR_PMKID])
5547 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
5548 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5550 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5551 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5554 switch (info->genlhdr->cmd) {
5555 case NL80211_CMD_SET_PMKSA:
5556 rdev_ops = rdev->ops->set_pmksa;
5558 case NL80211_CMD_DEL_PMKSA:
5559 rdev_ops = rdev->ops->del_pmksa;
5569 return rdev_ops(&rdev->wiphy, dev, &pmksa);
5572 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
5574 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5575 struct net_device *dev = info->user_ptr[1];
5577 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5578 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5581 if (!rdev->ops->flush_pmksa)
5584 return rdev->ops->flush_pmksa(&rdev->wiphy, dev);
5587 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
5589 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5590 struct net_device *dev = info->user_ptr[1];
5591 u8 action_code, dialog_token;
5595 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
5596 !rdev->ops->tdls_mgmt)
5599 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
5600 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
5601 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
5602 !info->attrs[NL80211_ATTR_IE] ||
5603 !info->attrs[NL80211_ATTR_MAC])
5606 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
5607 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
5608 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
5609 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
5611 return rdev->ops->tdls_mgmt(&rdev->wiphy, dev, peer, action_code,
5612 dialog_token, status_code,
5613 nla_data(info->attrs[NL80211_ATTR_IE]),
5614 nla_len(info->attrs[NL80211_ATTR_IE]));
5617 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
5619 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5620 struct net_device *dev = info->user_ptr[1];
5621 enum nl80211_tdls_operation operation;
5624 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
5625 !rdev->ops->tdls_oper)
5628 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
5629 !info->attrs[NL80211_ATTR_MAC])
5632 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
5633 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
5635 return rdev->ops->tdls_oper(&rdev->wiphy, dev, peer, operation);
5638 static int nl80211_remain_on_channel(struct sk_buff *skb,
5639 struct genl_info *info)
5641 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5642 struct net_device *dev = info->user_ptr[1];
5643 struct ieee80211_channel *chan;
5644 struct sk_buff *msg;
5647 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
5651 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
5652 !info->attrs[NL80211_ATTR_DURATION])
5655 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
5657 if (!rdev->ops->remain_on_channel ||
5658 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
5662 * We should be on that channel for at least a minimum amount of
5663 * time (10ms) but no longer than the driver supports.
5665 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
5666 duration > rdev->wiphy.max_remain_on_channel_duration)
5669 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
5670 !nl80211_valid_channel_type(info, &channel_type))
5673 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
5674 chan = rdev_freq_to_chan(rdev, freq, channel_type);
5678 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5682 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
5683 NL80211_CMD_REMAIN_ON_CHANNEL);
5690 err = rdev->ops->remain_on_channel(&rdev->wiphy, dev, chan,
5691 channel_type, duration, &cookie);
5696 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
5697 goto nla_put_failure;
5699 genlmsg_end(msg, hdr);
5701 return genlmsg_reply(msg, info);
5710 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
5711 struct genl_info *info)
5713 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5714 struct net_device *dev = info->user_ptr[1];
5717 if (!info->attrs[NL80211_ATTR_COOKIE])
5720 if (!rdev->ops->cancel_remain_on_channel)
5723 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
5725 return rdev->ops->cancel_remain_on_channel(&rdev->wiphy, dev, cookie);
5728 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
5729 u8 *rates, u8 rates_len)
5734 for (i = 0; i < rates_len; i++) {
5735 int rate = (rates[i] & 0x7f) * 5;
5737 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
5738 struct ieee80211_rate *srate =
5739 &sband->bitrates[ridx];
5740 if (rate == srate->bitrate) {
5745 if (ridx == sband->n_bitrates)
5746 return 0; /* rate not found */
5752 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
5753 u8 *rates, u8 rates_len,
5754 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
5758 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
5760 for (i = 0; i < rates_len; i++) {
5763 ridx = rates[i] / 8;
5764 rbit = BIT(rates[i] % 8);
5766 /* check validity */
5767 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
5770 /* check availability */
5771 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
5780 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
5781 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
5782 .len = NL80211_MAX_SUPP_RATES },
5783 [NL80211_TXRATE_MCS] = { .type = NLA_BINARY,
5784 .len = NL80211_MAX_SUPP_HT_RATES },
5787 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
5788 struct genl_info *info)
5790 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
5791 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5792 struct cfg80211_bitrate_mask mask;
5794 struct net_device *dev = info->user_ptr[1];
5795 struct nlattr *tx_rates;
5796 struct ieee80211_supported_band *sband;
5798 if (info->attrs[NL80211_ATTR_TX_RATES] == NULL)
5801 if (!rdev->ops->set_bitrate_mask)
5804 memset(&mask, 0, sizeof(mask));
5805 /* Default to all rates enabled */
5806 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
5807 sband = rdev->wiphy.bands[i];
5808 mask.control[i].legacy =
5809 sband ? (1 << sband->n_bitrates) - 1 : 0;
5811 memcpy(mask.control[i].mcs,
5812 sband->ht_cap.mcs.rx_mask,
5813 sizeof(mask.control[i].mcs));
5815 memset(mask.control[i].mcs, 0,
5816 sizeof(mask.control[i].mcs));
5820 * The nested attribute uses enum nl80211_band as the index. This maps
5821 * directly to the enum ieee80211_band values used in cfg80211.
5823 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
5824 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
5826 enum ieee80211_band band = nla_type(tx_rates);
5827 if (band < 0 || band >= IEEE80211_NUM_BANDS)
5829 sband = rdev->wiphy.bands[band];
5832 nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
5833 nla_len(tx_rates), nl80211_txattr_policy);
5834 if (tb[NL80211_TXRATE_LEGACY]) {
5835 mask.control[band].legacy = rateset_to_mask(
5837 nla_data(tb[NL80211_TXRATE_LEGACY]),
5838 nla_len(tb[NL80211_TXRATE_LEGACY]));
5839 if ((mask.control[band].legacy == 0) &&
5840 nla_len(tb[NL80211_TXRATE_LEGACY]))
5843 if (tb[NL80211_TXRATE_MCS]) {
5844 if (!ht_rateset_to_mask(
5846 nla_data(tb[NL80211_TXRATE_MCS]),
5847 nla_len(tb[NL80211_TXRATE_MCS]),
5848 mask.control[band].mcs))
5852 if (mask.control[band].legacy == 0) {
5853 /* don't allow empty legacy rates if HT
5854 * is not even supported. */
5855 if (!rdev->wiphy.bands[band]->ht_cap.ht_supported)
5858 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
5859 if (mask.control[band].mcs[i])
5862 /* legacy and mcs rates may not be both empty */
5863 if (i == IEEE80211_HT_MCS_MASK_LEN)
5868 return rdev->ops->set_bitrate_mask(&rdev->wiphy, dev, NULL, &mask);
5871 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
5873 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5874 struct net_device *dev = info->user_ptr[1];
5875 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
5877 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
5880 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
5881 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
5883 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5884 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
5885 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
5886 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5887 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5888 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
5889 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5892 /* not much point in registering if we can't reply */
5893 if (!rdev->ops->mgmt_tx)
5896 return cfg80211_mlme_register_mgmt(dev->ieee80211_ptr, info->snd_pid,
5898 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
5899 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
5902 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
5904 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5905 struct net_device *dev = info->user_ptr[1];
5906 struct ieee80211_channel *chan;
5907 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
5908 bool channel_type_valid = false;
5913 struct sk_buff *msg = NULL;
5914 unsigned int wait = 0;
5915 bool offchan, no_cck, dont_wait_for_ack;
5917 dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
5919 if (!info->attrs[NL80211_ATTR_FRAME] ||
5920 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
5923 if (!rdev->ops->mgmt_tx)
5926 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5927 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
5928 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
5929 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5930 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5931 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
5932 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5935 if (info->attrs[NL80211_ATTR_DURATION]) {
5936 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
5938 wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
5941 * We should wait on the channel for at least a minimum amount
5942 * of time (10ms) but no longer than the driver supports.
5944 if (wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
5945 wait > rdev->wiphy.max_remain_on_channel_duration)
5950 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
5951 if (!nl80211_valid_channel_type(info, &channel_type))
5953 channel_type_valid = true;
5956 offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
5958 if (offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
5961 no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5963 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
5964 chan = rdev_freq_to_chan(rdev, freq, channel_type);
5968 if (!dont_wait_for_ack) {
5969 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5973 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
5982 err = cfg80211_mlme_mgmt_tx(rdev, dev, chan, offchan, channel_type,
5983 channel_type_valid, wait,
5984 nla_data(info->attrs[NL80211_ATTR_FRAME]),
5985 nla_len(info->attrs[NL80211_ATTR_FRAME]),
5986 no_cck, dont_wait_for_ack, &cookie);
5991 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
5992 goto nla_put_failure;
5994 genlmsg_end(msg, hdr);
5995 return genlmsg_reply(msg, info);
6007 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
6009 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6010 struct net_device *dev = info->user_ptr[1];
6013 if (!info->attrs[NL80211_ATTR_COOKIE])
6016 if (!rdev->ops->mgmt_tx_cancel_wait)
6019 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6020 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
6021 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
6022 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6023 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
6024 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6027 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
6029 return rdev->ops->mgmt_tx_cancel_wait(&rdev->wiphy, dev, cookie);
6032 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
6034 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6035 struct wireless_dev *wdev;
6036 struct net_device *dev = info->user_ptr[1];
6041 if (!info->attrs[NL80211_ATTR_PS_STATE])
6044 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
6046 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
6049 wdev = dev->ieee80211_ptr;
6051 if (!rdev->ops->set_power_mgmt)
6054 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
6056 if (state == wdev->ps)
6059 err = rdev->ops->set_power_mgmt(wdev->wiphy, dev, state,
6066 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
6068 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6069 enum nl80211_ps_state ps_state;
6070 struct wireless_dev *wdev;
6071 struct net_device *dev = info->user_ptr[1];
6072 struct sk_buff *msg;
6076 wdev = dev->ieee80211_ptr;
6078 if (!rdev->ops->set_power_mgmt)
6081 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6085 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
6086 NL80211_CMD_GET_POWER_SAVE);
6093 ps_state = NL80211_PS_ENABLED;
6095 ps_state = NL80211_PS_DISABLED;
6097 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
6098 goto nla_put_failure;
6100 genlmsg_end(msg, hdr);
6101 return genlmsg_reply(msg, info);
6110 static struct nla_policy
6111 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] __read_mostly = {
6112 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
6113 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
6114 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
6117 static int nl80211_set_cqm_rssi(struct genl_info *info,
6118 s32 threshold, u32 hysteresis)
6120 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6121 struct wireless_dev *wdev;
6122 struct net_device *dev = info->user_ptr[1];
6127 wdev = dev->ieee80211_ptr;
6129 if (!rdev->ops->set_cqm_rssi_config)
6132 if (wdev->iftype != NL80211_IFTYPE_STATION &&
6133 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
6136 return rdev->ops->set_cqm_rssi_config(wdev->wiphy, dev,
6137 threshold, hysteresis);
6140 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
6142 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
6146 cqm = info->attrs[NL80211_ATTR_CQM];
6152 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
6153 nl80211_attr_cqm_policy);
6157 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
6158 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
6161 threshold = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
6162 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
6163 err = nl80211_set_cqm_rssi(info, threshold, hysteresis);
6171 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
6173 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6174 struct net_device *dev = info->user_ptr[1];
6175 struct mesh_config cfg;
6176 struct mesh_setup setup;
6179 /* start with default */
6180 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
6181 memcpy(&setup, &default_mesh_setup, sizeof(setup));
6183 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
6184 /* and parse parameters if given */
6185 err = nl80211_parse_mesh_config(info, &cfg, NULL);
6190 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
6191 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
6194 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
6195 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
6197 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
6198 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
6199 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
6202 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
6203 /* parse additional setup parameters if given */
6204 err = nl80211_parse_mesh_setup(info, &setup);
6209 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6210 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
6212 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE] &&
6213 !nl80211_valid_channel_type(info, &channel_type))
6216 setup.channel = rdev_freq_to_chan(rdev,
6217 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]),
6221 setup.channel_type = channel_type;
6223 /* cfg80211_join_mesh() will sort it out */
6224 setup.channel = NULL;
6227 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
6230 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
6232 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6233 struct net_device *dev = info->user_ptr[1];
6235 return cfg80211_leave_mesh(rdev, dev);
6238 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
6240 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6241 struct sk_buff *msg;
6244 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns)
6247 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6251 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
6252 NL80211_CMD_GET_WOWLAN);
6254 goto nla_put_failure;
6257 struct nlattr *nl_wowlan;
6259 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
6261 goto nla_put_failure;
6263 if ((rdev->wowlan->any &&
6264 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
6265 (rdev->wowlan->disconnect &&
6266 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
6267 (rdev->wowlan->magic_pkt &&
6268 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
6269 (rdev->wowlan->gtk_rekey_failure &&
6270 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
6271 (rdev->wowlan->eap_identity_req &&
6272 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
6273 (rdev->wowlan->four_way_handshake &&
6274 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
6275 (rdev->wowlan->rfkill_release &&
6276 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
6277 goto nla_put_failure;
6278 if (rdev->wowlan->n_patterns) {
6279 struct nlattr *nl_pats, *nl_pat;
6282 nl_pats = nla_nest_start(msg,
6283 NL80211_WOWLAN_TRIG_PKT_PATTERN);
6285 goto nla_put_failure;
6287 for (i = 0; i < rdev->wowlan->n_patterns; i++) {
6288 nl_pat = nla_nest_start(msg, i + 1);
6290 goto nla_put_failure;
6291 pat_len = rdev->wowlan->patterns[i].pattern_len;
6292 if (nla_put(msg, NL80211_WOWLAN_PKTPAT_MASK,
6293 DIV_ROUND_UP(pat_len, 8),
6294 rdev->wowlan->patterns[i].mask) ||
6295 nla_put(msg, NL80211_WOWLAN_PKTPAT_PATTERN,
6297 rdev->wowlan->patterns[i].pattern))
6298 goto nla_put_failure;
6299 nla_nest_end(msg, nl_pat);
6301 nla_nest_end(msg, nl_pats);
6304 nla_nest_end(msg, nl_wowlan);
6307 genlmsg_end(msg, hdr);
6308 return genlmsg_reply(msg, info);
6315 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
6317 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6318 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
6319 struct cfg80211_wowlan no_triggers = {};
6320 struct cfg80211_wowlan new_triggers = {};
6321 struct wiphy_wowlan_support *wowlan = &rdev->wiphy.wowlan;
6323 bool prev_enabled = rdev->wowlan;
6325 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns)
6328 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS])
6331 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
6332 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
6333 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
6334 nl80211_wowlan_policy);
6338 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
6339 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
6341 new_triggers.any = true;
6344 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
6345 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
6347 new_triggers.disconnect = true;
6350 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
6351 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
6353 new_triggers.magic_pkt = true;
6356 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
6359 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
6360 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
6362 new_triggers.gtk_rekey_failure = true;
6365 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
6366 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
6368 new_triggers.eap_identity_req = true;
6371 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
6372 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
6374 new_triggers.four_way_handshake = true;
6377 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
6378 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
6380 new_triggers.rfkill_release = true;
6383 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
6386 int rem, pat_len, mask_len;
6387 struct nlattr *pat_tb[NUM_NL80211_WOWLAN_PKTPAT];
6389 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
6392 if (n_patterns > wowlan->n_patterns)
6395 new_triggers.patterns = kcalloc(n_patterns,
6396 sizeof(new_triggers.patterns[0]),
6398 if (!new_triggers.patterns)
6401 new_triggers.n_patterns = n_patterns;
6404 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
6406 nla_parse(pat_tb, MAX_NL80211_WOWLAN_PKTPAT,
6407 nla_data(pat), nla_len(pat), NULL);
6409 if (!pat_tb[NL80211_WOWLAN_PKTPAT_MASK] ||
6410 !pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN])
6412 pat_len = nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]);
6413 mask_len = DIV_ROUND_UP(pat_len, 8);
6414 if (nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]) !=
6417 if (pat_len > wowlan->pattern_max_len ||
6418 pat_len < wowlan->pattern_min_len)
6421 new_triggers.patterns[i].mask =
6422 kmalloc(mask_len + pat_len, GFP_KERNEL);
6423 if (!new_triggers.patterns[i].mask) {
6427 new_triggers.patterns[i].pattern =
6428 new_triggers.patterns[i].mask + mask_len;
6429 memcpy(new_triggers.patterns[i].mask,
6430 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]),
6432 new_triggers.patterns[i].pattern_len = pat_len;
6433 memcpy(new_triggers.patterns[i].pattern,
6434 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]),
6440 if (memcmp(&new_triggers, &no_triggers, sizeof(new_triggers))) {
6441 struct cfg80211_wowlan *ntrig;
6442 ntrig = kmemdup(&new_triggers, sizeof(new_triggers),
6448 cfg80211_rdev_free_wowlan(rdev);
6449 rdev->wowlan = ntrig;
6452 cfg80211_rdev_free_wowlan(rdev);
6453 rdev->wowlan = NULL;
6456 if (rdev->ops->set_wakeup && prev_enabled != !!rdev->wowlan)
6457 rdev->ops->set_wakeup(&rdev->wiphy, rdev->wowlan);
6461 for (i = 0; i < new_triggers.n_patterns; i++)
6462 kfree(new_triggers.patterns[i].mask);
6463 kfree(new_triggers.patterns);
6467 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
6469 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6470 struct net_device *dev = info->user_ptr[1];
6471 struct wireless_dev *wdev = dev->ieee80211_ptr;
6472 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
6473 struct cfg80211_gtk_rekey_data rekey_data;
6476 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
6479 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
6480 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
6481 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
6482 nl80211_rekey_policy);
6486 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
6488 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
6490 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
6493 memcpy(rekey_data.kek, nla_data(tb[NL80211_REKEY_DATA_KEK]),
6495 memcpy(rekey_data.kck, nla_data(tb[NL80211_REKEY_DATA_KCK]),
6497 memcpy(rekey_data.replay_ctr,
6498 nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]),
6499 NL80211_REPLAY_CTR_LEN);
6502 if (!wdev->current_bss) {
6507 if (!rdev->ops->set_rekey_data) {
6512 err = rdev->ops->set_rekey_data(&rdev->wiphy, dev, &rekey_data);
6518 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
6519 struct genl_info *info)
6521 struct net_device *dev = info->user_ptr[1];
6522 struct wireless_dev *wdev = dev->ieee80211_ptr;
6524 if (wdev->iftype != NL80211_IFTYPE_AP &&
6525 wdev->iftype != NL80211_IFTYPE_P2P_GO)
6528 if (wdev->ap_unexpected_nlpid)
6531 wdev->ap_unexpected_nlpid = info->snd_pid;
6535 static int nl80211_probe_client(struct sk_buff *skb,
6536 struct genl_info *info)
6538 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6539 struct net_device *dev = info->user_ptr[1];
6540 struct wireless_dev *wdev = dev->ieee80211_ptr;
6541 struct sk_buff *msg;
6547 if (wdev->iftype != NL80211_IFTYPE_AP &&
6548 wdev->iftype != NL80211_IFTYPE_P2P_GO)
6551 if (!info->attrs[NL80211_ATTR_MAC])
6554 if (!rdev->ops->probe_client)
6557 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6561 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
6562 NL80211_CMD_PROBE_CLIENT);
6569 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6571 err = rdev->ops->probe_client(&rdev->wiphy, dev, addr, &cookie);
6575 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
6576 goto nla_put_failure;
6578 genlmsg_end(msg, hdr);
6580 return genlmsg_reply(msg, info);
6589 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
6591 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6593 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
6596 if (rdev->ap_beacons_nlpid)
6599 rdev->ap_beacons_nlpid = info->snd_pid;
6604 #define NL80211_FLAG_NEED_WIPHY 0x01
6605 #define NL80211_FLAG_NEED_NETDEV 0x02
6606 #define NL80211_FLAG_NEED_RTNL 0x04
6607 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
6608 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
6609 NL80211_FLAG_CHECK_NETDEV_UP)
6611 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
6612 struct genl_info *info)
6614 struct cfg80211_registered_device *rdev;
6615 struct net_device *dev;
6617 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
6622 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
6623 rdev = cfg80211_get_dev_from_info(info);
6627 return PTR_ERR(rdev);
6629 info->user_ptr[0] = rdev;
6630 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
6631 err = get_rdev_dev_by_ifindex(genl_info_net(info), info->attrs,
6638 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
6639 !netif_running(dev)) {
6640 cfg80211_unlock_rdev(rdev);
6646 info->user_ptr[0] = rdev;
6647 info->user_ptr[1] = dev;
6653 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
6654 struct genl_info *info)
6656 if (info->user_ptr[0])
6657 cfg80211_unlock_rdev(info->user_ptr[0]);
6658 if (info->user_ptr[1])
6659 dev_put(info->user_ptr[1]);
6660 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
6664 static struct genl_ops nl80211_ops[] = {
6666 .cmd = NL80211_CMD_GET_WIPHY,
6667 .doit = nl80211_get_wiphy,
6668 .dumpit = nl80211_dump_wiphy,
6669 .policy = nl80211_policy,
6670 /* can be retrieved by unprivileged users */
6671 .internal_flags = NL80211_FLAG_NEED_WIPHY,
6674 .cmd = NL80211_CMD_SET_WIPHY,
6675 .doit = nl80211_set_wiphy,
6676 .policy = nl80211_policy,
6677 .flags = GENL_ADMIN_PERM,
6678 .internal_flags = NL80211_FLAG_NEED_RTNL,
6681 .cmd = NL80211_CMD_GET_INTERFACE,
6682 .doit = nl80211_get_interface,
6683 .dumpit = nl80211_dump_interface,
6684 .policy = nl80211_policy,
6685 /* can be retrieved by unprivileged users */
6686 .internal_flags = NL80211_FLAG_NEED_NETDEV,
6689 .cmd = NL80211_CMD_SET_INTERFACE,
6690 .doit = nl80211_set_interface,
6691 .policy = nl80211_policy,
6692 .flags = GENL_ADMIN_PERM,
6693 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6694 NL80211_FLAG_NEED_RTNL,
6697 .cmd = NL80211_CMD_NEW_INTERFACE,
6698 .doit = nl80211_new_interface,
6699 .policy = nl80211_policy,
6700 .flags = GENL_ADMIN_PERM,
6701 .internal_flags = NL80211_FLAG_NEED_WIPHY |
6702 NL80211_FLAG_NEED_RTNL,
6705 .cmd = NL80211_CMD_DEL_INTERFACE,
6706 .doit = nl80211_del_interface,
6707 .policy = nl80211_policy,
6708 .flags = GENL_ADMIN_PERM,
6709 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6710 NL80211_FLAG_NEED_RTNL,
6713 .cmd = NL80211_CMD_GET_KEY,
6714 .doit = nl80211_get_key,
6715 .policy = nl80211_policy,
6716 .flags = GENL_ADMIN_PERM,
6717 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6718 NL80211_FLAG_NEED_RTNL,
6721 .cmd = NL80211_CMD_SET_KEY,
6722 .doit = nl80211_set_key,
6723 .policy = nl80211_policy,
6724 .flags = GENL_ADMIN_PERM,
6725 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6726 NL80211_FLAG_NEED_RTNL,
6729 .cmd = NL80211_CMD_NEW_KEY,
6730 .doit = nl80211_new_key,
6731 .policy = nl80211_policy,
6732 .flags = GENL_ADMIN_PERM,
6733 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6734 NL80211_FLAG_NEED_RTNL,
6737 .cmd = NL80211_CMD_DEL_KEY,
6738 .doit = nl80211_del_key,
6739 .policy = nl80211_policy,
6740 .flags = GENL_ADMIN_PERM,
6741 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6742 NL80211_FLAG_NEED_RTNL,
6745 .cmd = NL80211_CMD_SET_BEACON,
6746 .policy = nl80211_policy,
6747 .flags = GENL_ADMIN_PERM,
6748 .doit = nl80211_set_beacon,
6749 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6750 NL80211_FLAG_NEED_RTNL,
6753 .cmd = NL80211_CMD_START_AP,
6754 .policy = nl80211_policy,
6755 .flags = GENL_ADMIN_PERM,
6756 .doit = nl80211_start_ap,
6757 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6758 NL80211_FLAG_NEED_RTNL,
6761 .cmd = NL80211_CMD_STOP_AP,
6762 .policy = nl80211_policy,
6763 .flags = GENL_ADMIN_PERM,
6764 .doit = nl80211_stop_ap,
6765 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6766 NL80211_FLAG_NEED_RTNL,
6769 .cmd = NL80211_CMD_GET_STATION,
6770 .doit = nl80211_get_station,
6771 .dumpit = nl80211_dump_station,
6772 .policy = nl80211_policy,
6773 .internal_flags = NL80211_FLAG_NEED_NETDEV |
6774 NL80211_FLAG_NEED_RTNL,
6777 .cmd = NL80211_CMD_SET_STATION,
6778 .doit = nl80211_set_station,
6779 .policy = nl80211_policy,
6780 .flags = GENL_ADMIN_PERM,
6781 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6782 NL80211_FLAG_NEED_RTNL,
6785 .cmd = NL80211_CMD_NEW_STATION,
6786 .doit = nl80211_new_station,
6787 .policy = nl80211_policy,
6788 .flags = GENL_ADMIN_PERM,
6789 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6790 NL80211_FLAG_NEED_RTNL,
6793 .cmd = NL80211_CMD_DEL_STATION,
6794 .doit = nl80211_del_station,
6795 .policy = nl80211_policy,
6796 .flags = GENL_ADMIN_PERM,
6797 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6798 NL80211_FLAG_NEED_RTNL,
6801 .cmd = NL80211_CMD_GET_MPATH,
6802 .doit = nl80211_get_mpath,
6803 .dumpit = nl80211_dump_mpath,
6804 .policy = nl80211_policy,
6805 .flags = GENL_ADMIN_PERM,
6806 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6807 NL80211_FLAG_NEED_RTNL,
6810 .cmd = NL80211_CMD_SET_MPATH,
6811 .doit = nl80211_set_mpath,
6812 .policy = nl80211_policy,
6813 .flags = GENL_ADMIN_PERM,
6814 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6815 NL80211_FLAG_NEED_RTNL,
6818 .cmd = NL80211_CMD_NEW_MPATH,
6819 .doit = nl80211_new_mpath,
6820 .policy = nl80211_policy,
6821 .flags = GENL_ADMIN_PERM,
6822 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6823 NL80211_FLAG_NEED_RTNL,
6826 .cmd = NL80211_CMD_DEL_MPATH,
6827 .doit = nl80211_del_mpath,
6828 .policy = nl80211_policy,
6829 .flags = GENL_ADMIN_PERM,
6830 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6831 NL80211_FLAG_NEED_RTNL,
6834 .cmd = NL80211_CMD_SET_BSS,
6835 .doit = nl80211_set_bss,
6836 .policy = nl80211_policy,
6837 .flags = GENL_ADMIN_PERM,
6838 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6839 NL80211_FLAG_NEED_RTNL,
6842 .cmd = NL80211_CMD_GET_REG,
6843 .doit = nl80211_get_reg,
6844 .policy = nl80211_policy,
6845 /* can be retrieved by unprivileged users */
6848 .cmd = NL80211_CMD_SET_REG,
6849 .doit = nl80211_set_reg,
6850 .policy = nl80211_policy,
6851 .flags = GENL_ADMIN_PERM,
6854 .cmd = NL80211_CMD_REQ_SET_REG,
6855 .doit = nl80211_req_set_reg,
6856 .policy = nl80211_policy,
6857 .flags = GENL_ADMIN_PERM,
6860 .cmd = NL80211_CMD_GET_MESH_CONFIG,
6861 .doit = nl80211_get_mesh_config,
6862 .policy = nl80211_policy,
6863 /* can be retrieved by unprivileged users */
6864 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6865 NL80211_FLAG_NEED_RTNL,
6868 .cmd = NL80211_CMD_SET_MESH_CONFIG,
6869 .doit = nl80211_update_mesh_config,
6870 .policy = nl80211_policy,
6871 .flags = GENL_ADMIN_PERM,
6872 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6873 NL80211_FLAG_NEED_RTNL,
6876 .cmd = NL80211_CMD_TRIGGER_SCAN,
6877 .doit = nl80211_trigger_scan,
6878 .policy = nl80211_policy,
6879 .flags = GENL_ADMIN_PERM,
6880 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6881 NL80211_FLAG_NEED_RTNL,
6884 .cmd = NL80211_CMD_GET_SCAN,
6885 .policy = nl80211_policy,
6886 .dumpit = nl80211_dump_scan,
6889 .cmd = NL80211_CMD_START_SCHED_SCAN,
6890 .doit = nl80211_start_sched_scan,
6891 .policy = nl80211_policy,
6892 .flags = GENL_ADMIN_PERM,
6893 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6894 NL80211_FLAG_NEED_RTNL,
6897 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
6898 .doit = nl80211_stop_sched_scan,
6899 .policy = nl80211_policy,
6900 .flags = GENL_ADMIN_PERM,
6901 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6902 NL80211_FLAG_NEED_RTNL,
6905 .cmd = NL80211_CMD_AUTHENTICATE,
6906 .doit = nl80211_authenticate,
6907 .policy = nl80211_policy,
6908 .flags = GENL_ADMIN_PERM,
6909 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6910 NL80211_FLAG_NEED_RTNL,
6913 .cmd = NL80211_CMD_ASSOCIATE,
6914 .doit = nl80211_associate,
6915 .policy = nl80211_policy,
6916 .flags = GENL_ADMIN_PERM,
6917 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6918 NL80211_FLAG_NEED_RTNL,
6921 .cmd = NL80211_CMD_DEAUTHENTICATE,
6922 .doit = nl80211_deauthenticate,
6923 .policy = nl80211_policy,
6924 .flags = GENL_ADMIN_PERM,
6925 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6926 NL80211_FLAG_NEED_RTNL,
6929 .cmd = NL80211_CMD_DISASSOCIATE,
6930 .doit = nl80211_disassociate,
6931 .policy = nl80211_policy,
6932 .flags = GENL_ADMIN_PERM,
6933 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6934 NL80211_FLAG_NEED_RTNL,
6937 .cmd = NL80211_CMD_JOIN_IBSS,
6938 .doit = nl80211_join_ibss,
6939 .policy = nl80211_policy,
6940 .flags = GENL_ADMIN_PERM,
6941 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6942 NL80211_FLAG_NEED_RTNL,
6945 .cmd = NL80211_CMD_LEAVE_IBSS,
6946 .doit = nl80211_leave_ibss,
6947 .policy = nl80211_policy,
6948 .flags = GENL_ADMIN_PERM,
6949 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6950 NL80211_FLAG_NEED_RTNL,
6952 #ifdef CONFIG_NL80211_TESTMODE
6954 .cmd = NL80211_CMD_TESTMODE,
6955 .doit = nl80211_testmode_do,
6956 .dumpit = nl80211_testmode_dump,
6957 .policy = nl80211_policy,
6958 .flags = GENL_ADMIN_PERM,
6959 .internal_flags = NL80211_FLAG_NEED_WIPHY |
6960 NL80211_FLAG_NEED_RTNL,
6964 .cmd = NL80211_CMD_CONNECT,
6965 .doit = nl80211_connect,
6966 .policy = nl80211_policy,
6967 .flags = GENL_ADMIN_PERM,
6968 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6969 NL80211_FLAG_NEED_RTNL,
6972 .cmd = NL80211_CMD_DISCONNECT,
6973 .doit = nl80211_disconnect,
6974 .policy = nl80211_policy,
6975 .flags = GENL_ADMIN_PERM,
6976 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6977 NL80211_FLAG_NEED_RTNL,
6980 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
6981 .doit = nl80211_wiphy_netns,
6982 .policy = nl80211_policy,
6983 .flags = GENL_ADMIN_PERM,
6984 .internal_flags = NL80211_FLAG_NEED_WIPHY |
6985 NL80211_FLAG_NEED_RTNL,
6988 .cmd = NL80211_CMD_GET_SURVEY,
6989 .policy = nl80211_policy,
6990 .dumpit = nl80211_dump_survey,
6993 .cmd = NL80211_CMD_SET_PMKSA,
6994 .doit = nl80211_setdel_pmksa,
6995 .policy = nl80211_policy,
6996 .flags = GENL_ADMIN_PERM,
6997 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
6998 NL80211_FLAG_NEED_RTNL,
7001 .cmd = NL80211_CMD_DEL_PMKSA,
7002 .doit = nl80211_setdel_pmksa,
7003 .policy = nl80211_policy,
7004 .flags = GENL_ADMIN_PERM,
7005 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7006 NL80211_FLAG_NEED_RTNL,
7009 .cmd = NL80211_CMD_FLUSH_PMKSA,
7010 .doit = nl80211_flush_pmksa,
7011 .policy = nl80211_policy,
7012 .flags = GENL_ADMIN_PERM,
7013 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7014 NL80211_FLAG_NEED_RTNL,
7017 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
7018 .doit = nl80211_remain_on_channel,
7019 .policy = nl80211_policy,
7020 .flags = GENL_ADMIN_PERM,
7021 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7022 NL80211_FLAG_NEED_RTNL,
7025 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
7026 .doit = nl80211_cancel_remain_on_channel,
7027 .policy = nl80211_policy,
7028 .flags = GENL_ADMIN_PERM,
7029 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7030 NL80211_FLAG_NEED_RTNL,
7033 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
7034 .doit = nl80211_set_tx_bitrate_mask,
7035 .policy = nl80211_policy,
7036 .flags = GENL_ADMIN_PERM,
7037 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7038 NL80211_FLAG_NEED_RTNL,
7041 .cmd = NL80211_CMD_REGISTER_FRAME,
7042 .doit = nl80211_register_mgmt,
7043 .policy = nl80211_policy,
7044 .flags = GENL_ADMIN_PERM,
7045 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7046 NL80211_FLAG_NEED_RTNL,
7049 .cmd = NL80211_CMD_FRAME,
7050 .doit = nl80211_tx_mgmt,
7051 .policy = nl80211_policy,
7052 .flags = GENL_ADMIN_PERM,
7053 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7054 NL80211_FLAG_NEED_RTNL,
7057 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
7058 .doit = nl80211_tx_mgmt_cancel_wait,
7059 .policy = nl80211_policy,
7060 .flags = GENL_ADMIN_PERM,
7061 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7062 NL80211_FLAG_NEED_RTNL,
7065 .cmd = NL80211_CMD_SET_POWER_SAVE,
7066 .doit = nl80211_set_power_save,
7067 .policy = nl80211_policy,
7068 .flags = GENL_ADMIN_PERM,
7069 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7070 NL80211_FLAG_NEED_RTNL,
7073 .cmd = NL80211_CMD_GET_POWER_SAVE,
7074 .doit = nl80211_get_power_save,
7075 .policy = nl80211_policy,
7076 /* can be retrieved by unprivileged users */
7077 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7078 NL80211_FLAG_NEED_RTNL,
7081 .cmd = NL80211_CMD_SET_CQM,
7082 .doit = nl80211_set_cqm,
7083 .policy = nl80211_policy,
7084 .flags = GENL_ADMIN_PERM,
7085 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7086 NL80211_FLAG_NEED_RTNL,
7089 .cmd = NL80211_CMD_SET_CHANNEL,
7090 .doit = nl80211_set_channel,
7091 .policy = nl80211_policy,
7092 .flags = GENL_ADMIN_PERM,
7093 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7094 NL80211_FLAG_NEED_RTNL,
7097 .cmd = NL80211_CMD_SET_WDS_PEER,
7098 .doit = nl80211_set_wds_peer,
7099 .policy = nl80211_policy,
7100 .flags = GENL_ADMIN_PERM,
7101 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7102 NL80211_FLAG_NEED_RTNL,
7105 .cmd = NL80211_CMD_JOIN_MESH,
7106 .doit = nl80211_join_mesh,
7107 .policy = nl80211_policy,
7108 .flags = GENL_ADMIN_PERM,
7109 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7110 NL80211_FLAG_NEED_RTNL,
7113 .cmd = NL80211_CMD_LEAVE_MESH,
7114 .doit = nl80211_leave_mesh,
7115 .policy = nl80211_policy,
7116 .flags = GENL_ADMIN_PERM,
7117 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7118 NL80211_FLAG_NEED_RTNL,
7121 .cmd = NL80211_CMD_GET_WOWLAN,
7122 .doit = nl80211_get_wowlan,
7123 .policy = nl80211_policy,
7124 /* can be retrieved by unprivileged users */
7125 .internal_flags = NL80211_FLAG_NEED_WIPHY |
7126 NL80211_FLAG_NEED_RTNL,
7129 .cmd = NL80211_CMD_SET_WOWLAN,
7130 .doit = nl80211_set_wowlan,
7131 .policy = nl80211_policy,
7132 .flags = GENL_ADMIN_PERM,
7133 .internal_flags = NL80211_FLAG_NEED_WIPHY |
7134 NL80211_FLAG_NEED_RTNL,
7137 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
7138 .doit = nl80211_set_rekey_data,
7139 .policy = nl80211_policy,
7140 .flags = GENL_ADMIN_PERM,
7141 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7142 NL80211_FLAG_NEED_RTNL,
7145 .cmd = NL80211_CMD_TDLS_MGMT,
7146 .doit = nl80211_tdls_mgmt,
7147 .policy = nl80211_policy,
7148 .flags = GENL_ADMIN_PERM,
7149 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7150 NL80211_FLAG_NEED_RTNL,
7153 .cmd = NL80211_CMD_TDLS_OPER,
7154 .doit = nl80211_tdls_oper,
7155 .policy = nl80211_policy,
7156 .flags = GENL_ADMIN_PERM,
7157 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7158 NL80211_FLAG_NEED_RTNL,
7161 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
7162 .doit = nl80211_register_unexpected_frame,
7163 .policy = nl80211_policy,
7164 .flags = GENL_ADMIN_PERM,
7165 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7166 NL80211_FLAG_NEED_RTNL,
7169 .cmd = NL80211_CMD_PROBE_CLIENT,
7170 .doit = nl80211_probe_client,
7171 .policy = nl80211_policy,
7172 .flags = GENL_ADMIN_PERM,
7173 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
7174 NL80211_FLAG_NEED_RTNL,
7177 .cmd = NL80211_CMD_REGISTER_BEACONS,
7178 .doit = nl80211_register_beacons,
7179 .policy = nl80211_policy,
7180 .flags = GENL_ADMIN_PERM,
7181 .internal_flags = NL80211_FLAG_NEED_WIPHY |
7182 NL80211_FLAG_NEED_RTNL,
7185 .cmd = NL80211_CMD_SET_NOACK_MAP,
7186 .doit = nl80211_set_noack_map,
7187 .policy = nl80211_policy,
7188 .flags = GENL_ADMIN_PERM,
7189 .internal_flags = NL80211_FLAG_NEED_NETDEV |
7190 NL80211_FLAG_NEED_RTNL,
7195 static struct genl_multicast_group nl80211_mlme_mcgrp = {
7199 /* multicast groups */
7200 static struct genl_multicast_group nl80211_config_mcgrp = {
7203 static struct genl_multicast_group nl80211_scan_mcgrp = {
7206 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
7207 .name = "regulatory",
7210 /* notification functions */
7212 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
7214 struct sk_buff *msg;
7216 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7220 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
7225 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7226 nl80211_config_mcgrp.id, GFP_KERNEL);
7229 static int nl80211_add_scan_req(struct sk_buff *msg,
7230 struct cfg80211_registered_device *rdev)
7232 struct cfg80211_scan_request *req = rdev->scan_req;
7233 struct nlattr *nest;
7236 ASSERT_RDEV_LOCK(rdev);
7241 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
7243 goto nla_put_failure;
7244 for (i = 0; i < req->n_ssids; i++) {
7245 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
7246 goto nla_put_failure;
7248 nla_nest_end(msg, nest);
7250 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
7252 goto nla_put_failure;
7253 for (i = 0; i < req->n_channels; i++) {
7254 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
7255 goto nla_put_failure;
7257 nla_nest_end(msg, nest);
7260 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
7261 goto nla_put_failure;
7268 static int nl80211_send_scan_msg(struct sk_buff *msg,
7269 struct cfg80211_registered_device *rdev,
7270 struct net_device *netdev,
7271 u32 pid, u32 seq, int flags,
7276 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
7280 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7281 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
7282 goto nla_put_failure;
7284 /* ignore errors and send incomplete event anyway */
7285 nl80211_add_scan_req(msg, rdev);
7287 return genlmsg_end(msg, hdr);
7290 genlmsg_cancel(msg, hdr);
7295 nl80211_send_sched_scan_msg(struct sk_buff *msg,
7296 struct cfg80211_registered_device *rdev,
7297 struct net_device *netdev,
7298 u32 pid, u32 seq, int flags, u32 cmd)
7302 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
7306 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7307 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
7308 goto nla_put_failure;
7310 return genlmsg_end(msg, hdr);
7313 genlmsg_cancel(msg, hdr);
7317 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
7318 struct net_device *netdev)
7320 struct sk_buff *msg;
7322 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7326 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
7327 NL80211_CMD_TRIGGER_SCAN) < 0) {
7332 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7333 nl80211_scan_mcgrp.id, GFP_KERNEL);
7336 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
7337 struct net_device *netdev)
7339 struct sk_buff *msg;
7341 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7345 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
7346 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
7351 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7352 nl80211_scan_mcgrp.id, GFP_KERNEL);
7355 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
7356 struct net_device *netdev)
7358 struct sk_buff *msg;
7360 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7364 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
7365 NL80211_CMD_SCAN_ABORTED) < 0) {
7370 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7371 nl80211_scan_mcgrp.id, GFP_KERNEL);
7374 void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
7375 struct net_device *netdev)
7377 struct sk_buff *msg;
7379 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7383 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
7384 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
7389 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7390 nl80211_scan_mcgrp.id, GFP_KERNEL);
7393 void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
7394 struct net_device *netdev, u32 cmd)
7396 struct sk_buff *msg;
7398 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7402 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
7407 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7408 nl80211_scan_mcgrp.id, GFP_KERNEL);
7412 * This can happen on global regulatory changes or device specific settings
7413 * based on custom world regulatory domains.
7415 void nl80211_send_reg_change_event(struct regulatory_request *request)
7417 struct sk_buff *msg;
7420 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7424 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
7430 /* Userspace can always count this one always being set */
7431 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
7432 goto nla_put_failure;
7434 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
7435 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7436 NL80211_REGDOM_TYPE_WORLD))
7437 goto nla_put_failure;
7438 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
7439 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7440 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
7441 goto nla_put_failure;
7442 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
7443 request->intersect) {
7444 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7445 NL80211_REGDOM_TYPE_INTERSECTION))
7446 goto nla_put_failure;
7448 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
7449 NL80211_REGDOM_TYPE_COUNTRY) ||
7450 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
7452 goto nla_put_failure;
7455 if (wiphy_idx_valid(request->wiphy_idx) &&
7456 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
7457 goto nla_put_failure;
7459 genlmsg_end(msg, hdr);
7462 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
7469 genlmsg_cancel(msg, hdr);
7473 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
7474 struct net_device *netdev,
7475 const u8 *buf, size_t len,
7476 enum nl80211_commands cmd, gfp_t gfp)
7478 struct sk_buff *msg;
7481 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7485 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7491 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7492 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7493 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
7494 goto nla_put_failure;
7496 genlmsg_end(msg, hdr);
7498 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7499 nl80211_mlme_mcgrp.id, gfp);
7503 genlmsg_cancel(msg, hdr);
7507 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
7508 struct net_device *netdev, const u8 *buf,
7509 size_t len, gfp_t gfp)
7511 nl80211_send_mlme_event(rdev, netdev, buf, len,
7512 NL80211_CMD_AUTHENTICATE, gfp);
7515 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
7516 struct net_device *netdev, const u8 *buf,
7517 size_t len, gfp_t gfp)
7519 nl80211_send_mlme_event(rdev, netdev, buf, len,
7520 NL80211_CMD_ASSOCIATE, gfp);
7523 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
7524 struct net_device *netdev, const u8 *buf,
7525 size_t len, gfp_t gfp)
7527 nl80211_send_mlme_event(rdev, netdev, buf, len,
7528 NL80211_CMD_DEAUTHENTICATE, gfp);
7531 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
7532 struct net_device *netdev, const u8 *buf,
7533 size_t len, gfp_t gfp)
7535 nl80211_send_mlme_event(rdev, netdev, buf, len,
7536 NL80211_CMD_DISASSOCIATE, gfp);
7539 void nl80211_send_unprot_deauth(struct cfg80211_registered_device *rdev,
7540 struct net_device *netdev, const u8 *buf,
7541 size_t len, gfp_t gfp)
7543 nl80211_send_mlme_event(rdev, netdev, buf, len,
7544 NL80211_CMD_UNPROT_DEAUTHENTICATE, gfp);
7547 void nl80211_send_unprot_disassoc(struct cfg80211_registered_device *rdev,
7548 struct net_device *netdev, const u8 *buf,
7549 size_t len, gfp_t gfp)
7551 nl80211_send_mlme_event(rdev, netdev, buf, len,
7552 NL80211_CMD_UNPROT_DISASSOCIATE, gfp);
7555 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
7556 struct net_device *netdev, int cmd,
7557 const u8 *addr, gfp_t gfp)
7559 struct sk_buff *msg;
7562 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7566 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7572 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7573 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7574 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
7575 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
7576 goto nla_put_failure;
7578 genlmsg_end(msg, hdr);
7580 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7581 nl80211_mlme_mcgrp.id, gfp);
7585 genlmsg_cancel(msg, hdr);
7589 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
7590 struct net_device *netdev, const u8 *addr,
7593 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
7597 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
7598 struct net_device *netdev, const u8 *addr,
7601 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
7605 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
7606 struct net_device *netdev, const u8 *bssid,
7607 const u8 *req_ie, size_t req_ie_len,
7608 const u8 *resp_ie, size_t resp_ie_len,
7609 u16 status, gfp_t gfp)
7611 struct sk_buff *msg;
7614 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7618 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
7624 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7625 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7626 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
7627 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
7629 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
7631 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
7632 goto nla_put_failure;
7634 genlmsg_end(msg, hdr);
7636 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7637 nl80211_mlme_mcgrp.id, gfp);
7641 genlmsg_cancel(msg, hdr);
7646 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
7647 struct net_device *netdev, const u8 *bssid,
7648 const u8 *req_ie, size_t req_ie_len,
7649 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
7651 struct sk_buff *msg;
7654 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7658 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
7664 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7665 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7666 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
7668 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
7670 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
7671 goto nla_put_failure;
7673 genlmsg_end(msg, hdr);
7675 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7676 nl80211_mlme_mcgrp.id, gfp);
7680 genlmsg_cancel(msg, hdr);
7685 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
7686 struct net_device *netdev, u16 reason,
7687 const u8 *ie, size_t ie_len, bool from_ap)
7689 struct sk_buff *msg;
7692 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
7696 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
7702 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7703 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7704 (from_ap && reason &&
7705 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
7707 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
7708 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
7709 goto nla_put_failure;
7711 genlmsg_end(msg, hdr);
7713 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7714 nl80211_mlme_mcgrp.id, GFP_KERNEL);
7718 genlmsg_cancel(msg, hdr);
7723 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
7724 struct net_device *netdev, const u8 *bssid,
7727 struct sk_buff *msg;
7730 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7734 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
7740 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7741 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7742 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
7743 goto nla_put_failure;
7745 genlmsg_end(msg, hdr);
7747 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7748 nl80211_mlme_mcgrp.id, gfp);
7752 genlmsg_cancel(msg, hdr);
7756 void nl80211_send_new_peer_candidate(struct cfg80211_registered_device *rdev,
7757 struct net_device *netdev,
7758 const u8 *macaddr, const u8* ie, u8 ie_len,
7761 struct sk_buff *msg;
7764 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7768 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
7774 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7775 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7776 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, macaddr) ||
7778 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
7779 goto nla_put_failure;
7781 genlmsg_end(msg, hdr);
7783 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7784 nl80211_mlme_mcgrp.id, gfp);
7788 genlmsg_cancel(msg, hdr);
7792 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
7793 struct net_device *netdev, const u8 *addr,
7794 enum nl80211_key_type key_type, int key_id,
7795 const u8 *tsc, gfp_t gfp)
7797 struct sk_buff *msg;
7800 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7804 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
7810 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7811 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7812 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
7813 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
7815 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
7816 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
7817 goto nla_put_failure;
7819 genlmsg_end(msg, hdr);
7821 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7822 nl80211_mlme_mcgrp.id, gfp);
7826 genlmsg_cancel(msg, hdr);
7830 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
7831 struct ieee80211_channel *channel_before,
7832 struct ieee80211_channel *channel_after)
7834 struct sk_buff *msg;
7836 struct nlattr *nl_freq;
7838 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
7842 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
7849 * Since we are applying the beacon hint to a wiphy we know its
7850 * wiphy_idx is valid
7852 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7853 goto nla_put_failure;
7856 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
7858 goto nla_put_failure;
7859 if (nl80211_msg_put_channel(msg, channel_before))
7860 goto nla_put_failure;
7861 nla_nest_end(msg, nl_freq);
7864 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
7866 goto nla_put_failure;
7867 if (nl80211_msg_put_channel(msg, channel_after))
7868 goto nla_put_failure;
7869 nla_nest_end(msg, nl_freq);
7871 genlmsg_end(msg, hdr);
7874 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
7881 genlmsg_cancel(msg, hdr);
7885 static void nl80211_send_remain_on_chan_event(
7886 int cmd, struct cfg80211_registered_device *rdev,
7887 struct net_device *netdev, u64 cookie,
7888 struct ieee80211_channel *chan,
7889 enum nl80211_channel_type channel_type,
7890 unsigned int duration, gfp_t gfp)
7892 struct sk_buff *msg;
7895 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
7899 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
7905 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
7906 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
7907 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
7908 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, channel_type) ||
7909 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7910 goto nla_put_failure;
7912 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
7913 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
7914 goto nla_put_failure;
7916 genlmsg_end(msg, hdr);
7918 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7919 nl80211_mlme_mcgrp.id, gfp);
7923 genlmsg_cancel(msg, hdr);
7927 void nl80211_send_remain_on_channel(struct cfg80211_registered_device *rdev,
7928 struct net_device *netdev, u64 cookie,
7929 struct ieee80211_channel *chan,
7930 enum nl80211_channel_type channel_type,
7931 unsigned int duration, gfp_t gfp)
7933 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
7934 rdev, netdev, cookie, chan,
7935 channel_type, duration, gfp);
7938 void nl80211_send_remain_on_channel_cancel(
7939 struct cfg80211_registered_device *rdev, struct net_device *netdev,
7940 u64 cookie, struct ieee80211_channel *chan,
7941 enum nl80211_channel_type channel_type, gfp_t gfp)
7943 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
7944 rdev, netdev, cookie, chan,
7945 channel_type, 0, gfp);
7948 void nl80211_send_sta_event(struct cfg80211_registered_device *rdev,
7949 struct net_device *dev, const u8 *mac_addr,
7950 struct station_info *sinfo, gfp_t gfp)
7952 struct sk_buff *msg;
7954 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7958 if (nl80211_send_station(msg, 0, 0, 0,
7959 rdev, dev, mac_addr, sinfo) < 0) {
7964 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7965 nl80211_mlme_mcgrp.id, gfp);
7968 void nl80211_send_sta_del_event(struct cfg80211_registered_device *rdev,
7969 struct net_device *dev, const u8 *mac_addr,
7972 struct sk_buff *msg;
7975 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
7979 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
7985 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
7986 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
7987 goto nla_put_failure;
7989 genlmsg_end(msg, hdr);
7991 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
7992 nl80211_mlme_mcgrp.id, gfp);
7996 genlmsg_cancel(msg, hdr);
8000 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
8001 const u8 *addr, gfp_t gfp)
8003 struct wireless_dev *wdev = dev->ieee80211_ptr;
8004 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
8005 struct sk_buff *msg;
8008 u32 nlpid = ACCESS_ONCE(wdev->ap_unexpected_nlpid);
8013 msg = nlmsg_new(100, gfp);
8017 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
8023 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8024 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
8025 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
8026 goto nla_put_failure;
8028 err = genlmsg_end(msg, hdr);
8034 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
8038 genlmsg_cancel(msg, hdr);
8043 bool nl80211_unexpected_frame(struct net_device *dev, const u8 *addr, gfp_t gfp)
8045 return __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
8049 bool nl80211_unexpected_4addr_frame(struct net_device *dev,
8050 const u8 *addr, gfp_t gfp)
8052 return __nl80211_unexpected_frame(dev,
8053 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
8057 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
8058 struct net_device *netdev, u32 nlpid,
8059 int freq, int sig_dbm,
8060 const u8 *buf, size_t len, gfp_t gfp)
8062 struct sk_buff *msg;
8065 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
8069 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
8075 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8076 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8077 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
8079 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
8080 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
8081 goto nla_put_failure;
8083 genlmsg_end(msg, hdr);
8085 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
8088 genlmsg_cancel(msg, hdr);
8093 void nl80211_send_mgmt_tx_status(struct cfg80211_registered_device *rdev,
8094 struct net_device *netdev, u64 cookie,
8095 const u8 *buf, size_t len, bool ack,
8098 struct sk_buff *msg;
8101 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
8105 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
8111 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8112 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8113 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
8114 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
8115 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
8116 goto nla_put_failure;
8118 genlmsg_end(msg, hdr);
8120 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
8124 genlmsg_cancel(msg, hdr);
8129 nl80211_send_cqm_rssi_notify(struct cfg80211_registered_device *rdev,
8130 struct net_device *netdev,
8131 enum nl80211_cqm_rssi_threshold_event rssi_event,
8134 struct sk_buff *msg;
8135 struct nlattr *pinfoattr;
8138 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8142 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
8148 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8149 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
8150 goto nla_put_failure;
8152 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
8154 goto nla_put_failure;
8156 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
8158 goto nla_put_failure;
8160 nla_nest_end(msg, pinfoattr);
8162 genlmsg_end(msg, hdr);
8164 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8165 nl80211_mlme_mcgrp.id, gfp);
8169 genlmsg_cancel(msg, hdr);
8173 void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
8174 struct net_device *netdev, const u8 *bssid,
8175 const u8 *replay_ctr, gfp_t gfp)
8177 struct sk_buff *msg;
8178 struct nlattr *rekey_attr;
8181 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8185 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
8191 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8192 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8193 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
8194 goto nla_put_failure;
8196 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
8198 goto nla_put_failure;
8200 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
8201 NL80211_REPLAY_CTR_LEN, replay_ctr))
8202 goto nla_put_failure;
8204 nla_nest_end(msg, rekey_attr);
8206 genlmsg_end(msg, hdr);
8208 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8209 nl80211_mlme_mcgrp.id, gfp);
8213 genlmsg_cancel(msg, hdr);
8217 void nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
8218 struct net_device *netdev, int index,
8219 const u8 *bssid, bool preauth, gfp_t gfp)
8221 struct sk_buff *msg;
8222 struct nlattr *attr;
8225 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8229 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
8235 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8236 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
8237 goto nla_put_failure;
8239 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
8241 goto nla_put_failure;
8243 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
8244 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
8246 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
8247 goto nla_put_failure;
8249 nla_nest_end(msg, attr);
8251 genlmsg_end(msg, hdr);
8253 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8254 nl80211_mlme_mcgrp.id, gfp);
8258 genlmsg_cancel(msg, hdr);
8262 void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
8263 struct net_device *netdev, int freq,
8264 enum nl80211_channel_type type, gfp_t gfp)
8266 struct sk_buff *msg;
8269 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8273 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY);
8279 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8280 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
8281 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, type))
8282 goto nla_put_failure;
8284 genlmsg_end(msg, hdr);
8286 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8287 nl80211_mlme_mcgrp.id, gfp);
8291 genlmsg_cancel(msg, hdr);
8296 nl80211_send_cqm_pktloss_notify(struct cfg80211_registered_device *rdev,
8297 struct net_device *netdev, const u8 *peer,
8298 u32 num_packets, gfp_t gfp)
8300 struct sk_buff *msg;
8301 struct nlattr *pinfoattr;
8304 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8308 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
8314 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8315 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
8316 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
8317 goto nla_put_failure;
8319 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
8321 goto nla_put_failure;
8323 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
8324 goto nla_put_failure;
8326 nla_nest_end(msg, pinfoattr);
8328 genlmsg_end(msg, hdr);
8330 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8331 nl80211_mlme_mcgrp.id, gfp);
8335 genlmsg_cancel(msg, hdr);
8339 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
8340 u64 cookie, bool acked, gfp_t gfp)
8342 struct wireless_dev *wdev = dev->ieee80211_ptr;
8343 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
8344 struct sk_buff *msg;
8348 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
8352 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
8358 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8359 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
8360 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
8361 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
8362 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
8363 goto nla_put_failure;
8365 err = genlmsg_end(msg, hdr);
8371 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8372 nl80211_mlme_mcgrp.id, gfp);
8376 genlmsg_cancel(msg, hdr);
8379 EXPORT_SYMBOL(cfg80211_probe_status);
8381 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
8382 const u8 *frame, size_t len,
8383 int freq, int sig_dbm, gfp_t gfp)
8385 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
8386 struct sk_buff *msg;
8388 u32 nlpid = ACCESS_ONCE(rdev->ap_beacons_nlpid);
8393 msg = nlmsg_new(len + 100, gfp);
8397 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
8403 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8405 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
8407 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
8408 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
8409 goto nla_put_failure;
8411 genlmsg_end(msg, hdr);
8413 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlpid);
8417 genlmsg_cancel(msg, hdr);
8420 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
8422 static int nl80211_netlink_notify(struct notifier_block * nb,
8423 unsigned long state,
8426 struct netlink_notify *notify = _notify;
8427 struct cfg80211_registered_device *rdev;
8428 struct wireless_dev *wdev;
8430 if (state != NETLINK_URELEASE)
8435 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
8436 list_for_each_entry_rcu(wdev, &rdev->netdev_list, list)
8437 cfg80211_mlme_unregister_socket(wdev, notify->pid);
8438 if (rdev->ap_beacons_nlpid == notify->pid)
8439 rdev->ap_beacons_nlpid = 0;
8447 static struct notifier_block nl80211_netlink_notifier = {
8448 .notifier_call = nl80211_netlink_notify,
8451 /* initialisation/exit functions */
8453 int nl80211_init(void)
8457 err = genl_register_family_with_ops(&nl80211_fam,
8458 nl80211_ops, ARRAY_SIZE(nl80211_ops));
8462 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
8466 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
8470 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
8474 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
8478 #ifdef CONFIG_NL80211_TESTMODE
8479 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
8484 err = netlink_register_notifier(&nl80211_netlink_notifier);
8490 genl_unregister_family(&nl80211_fam);
8494 void nl80211_exit(void)
8496 netlink_unregister_notifier(&nl80211_netlink_notifier);
8497 genl_unregister_family(&nl80211_fam);