1 // SPDX-License-Identifier: GPL-2.0-only
3 * This is the new netlink-based wireless configuration interface.
5 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2013-2014 Intel Mobile Communications GmbH
7 * Copyright 2015-2017 Intel Deutschland GmbH
8 * Copyright (C) 2018-2021 Intel Corporation
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/slab.h>
15 #include <linux/list.h>
16 #include <linux/if_ether.h>
17 #include <linux/ieee80211.h>
18 #include <linux/nl80211.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/netlink.h>
21 #include <linux/nospec.h>
22 #include <linux/etherdevice.h>
23 #include <linux/if_vlan.h>
24 #include <net/net_namespace.h>
25 #include <net/genetlink.h>
26 #include <net/cfg80211.h>
28 #include <net/inet_connection_sock.h>
34 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
35 struct genl_info *info,
36 struct cfg80211_crypto_settings *settings,
39 /* the netlink family */
40 static struct genl_family nl80211_fam;
42 /* multicast groups */
43 enum nl80211_multicast_groups {
46 NL80211_MCGRP_REGULATORY,
50 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
53 static const struct genl_multicast_group nl80211_mcgrps[] = {
54 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
55 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
56 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
57 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
58 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
59 [NL80211_MCGRP_NAN] = { .name = NL80211_MULTICAST_GROUP_NAN },
60 #ifdef CONFIG_NL80211_TESTMODE
61 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
65 /* returns ERR_PTR values */
66 static struct wireless_dev *
67 __cfg80211_wdev_from_attrs(struct cfg80211_registered_device *rdev,
68 struct net *netns, struct nlattr **attrs)
70 struct wireless_dev *result = NULL;
71 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
72 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
77 if (!have_ifidx && !have_wdev_id)
78 return ERR_PTR(-EINVAL);
81 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
83 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
84 wiphy_idx = wdev_id >> 32;
88 struct wireless_dev *wdev;
90 lockdep_assert_held(&rdev->wiphy.mtx);
92 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
93 if (have_ifidx && wdev->netdev &&
94 wdev->netdev->ifindex == ifidx) {
98 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
104 return result ?: ERR_PTR(-ENODEV);
109 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
110 struct wireless_dev *wdev;
112 if (wiphy_net(&rdev->wiphy) != netns)
115 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
118 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
119 if (have_ifidx && wdev->netdev &&
120 wdev->netdev->ifindex == ifidx) {
124 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
136 return ERR_PTR(-ENODEV);
139 static struct cfg80211_registered_device *
140 __cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
142 struct cfg80211_registered_device *rdev = NULL, *tmp;
143 struct net_device *netdev;
147 if (!attrs[NL80211_ATTR_WIPHY] &&
148 !attrs[NL80211_ATTR_IFINDEX] &&
149 !attrs[NL80211_ATTR_WDEV])
150 return ERR_PTR(-EINVAL);
152 if (attrs[NL80211_ATTR_WIPHY])
153 rdev = cfg80211_rdev_by_wiphy_idx(
154 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
156 if (attrs[NL80211_ATTR_WDEV]) {
157 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
158 struct wireless_dev *wdev;
161 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
163 /* make sure wdev exists */
164 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
165 if (wdev->identifier != (u32)wdev_id)
174 if (rdev && tmp != rdev)
175 return ERR_PTR(-EINVAL);
180 if (attrs[NL80211_ATTR_IFINDEX]) {
181 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
183 netdev = __dev_get_by_index(netns, ifindex);
185 if (netdev->ieee80211_ptr)
187 netdev->ieee80211_ptr->wiphy);
191 /* not wireless device -- return error */
193 return ERR_PTR(-EINVAL);
195 /* mismatch -- return error */
196 if (rdev && tmp != rdev)
197 return ERR_PTR(-EINVAL);
204 return ERR_PTR(-ENODEV);
206 if (netns != wiphy_net(&rdev->wiphy))
207 return ERR_PTR(-ENODEV);
213 * This function returns a pointer to the driver
214 * that the genl_info item that is passed refers to.
216 * The result of this can be a PTR_ERR and hence must
217 * be checked with IS_ERR() for errors.
219 static struct cfg80211_registered_device *
220 cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
222 return __cfg80211_rdev_from_attrs(netns, info->attrs);
225 static int validate_beacon_head(const struct nlattr *attr,
226 struct netlink_ext_ack *extack)
228 const u8 *data = nla_data(attr);
229 unsigned int len = nla_len(attr);
230 const struct element *elem;
231 const struct ieee80211_mgmt *mgmt = (void *)data;
232 unsigned int fixedlen, hdrlen;
235 if (len < offsetofend(typeof(*mgmt), frame_control))
238 s1g_bcn = ieee80211_is_s1g_beacon(mgmt->frame_control);
240 fixedlen = offsetof(struct ieee80211_ext,
241 u.s1g_beacon.variable);
242 hdrlen = offsetof(struct ieee80211_ext, u.s1g_beacon);
244 fixedlen = offsetof(struct ieee80211_mgmt,
246 hdrlen = offsetof(struct ieee80211_mgmt, u.beacon);
252 if (ieee80211_hdrlen(mgmt->frame_control) != hdrlen)
258 for_each_element(elem, data, len) {
262 if (for_each_element_completed(elem, data, len))
266 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed beacon head");
270 static int validate_ie_attr(const struct nlattr *attr,
271 struct netlink_ext_ack *extack)
273 const u8 *data = nla_data(attr);
274 unsigned int len = nla_len(attr);
275 const struct element *elem;
277 for_each_element(elem, data, len) {
281 if (for_each_element_completed(elem, data, len))
284 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed information elements");
288 /* policy for the attributes */
289 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR];
291 static const struct nla_policy
292 nl80211_ftm_responder_policy[NL80211_FTM_RESP_ATTR_MAX + 1] = {
293 [NL80211_FTM_RESP_ATTR_ENABLED] = { .type = NLA_FLAG, },
294 [NL80211_FTM_RESP_ATTR_LCI] = { .type = NLA_BINARY,
296 [NL80211_FTM_RESP_ATTR_CIVICLOC] = { .type = NLA_BINARY,
300 static const struct nla_policy
301 nl80211_pmsr_ftm_req_attr_policy[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1] = {
302 [NL80211_PMSR_FTM_REQ_ATTR_ASAP] = { .type = NLA_FLAG },
303 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE] = { .type = NLA_U32 },
304 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP] =
305 NLA_POLICY_MAX(NLA_U8, 15),
306 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD] = { .type = NLA_U16 },
307 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION] =
308 NLA_POLICY_MAX(NLA_U8, 15),
309 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST] =
310 NLA_POLICY_MAX(NLA_U8, 31),
311 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES] = { .type = NLA_U8 },
312 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI] = { .type = NLA_FLAG },
313 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC] = { .type = NLA_FLAG },
314 [NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED] = { .type = NLA_FLAG },
315 [NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED] = { .type = NLA_FLAG },
316 [NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK] = { .type = NLA_FLAG },
319 static const struct nla_policy
320 nl80211_pmsr_req_data_policy[NL80211_PMSR_TYPE_MAX + 1] = {
321 [NL80211_PMSR_TYPE_FTM] =
322 NLA_POLICY_NESTED(nl80211_pmsr_ftm_req_attr_policy),
325 static const struct nla_policy
326 nl80211_pmsr_req_attr_policy[NL80211_PMSR_REQ_ATTR_MAX + 1] = {
327 [NL80211_PMSR_REQ_ATTR_DATA] =
328 NLA_POLICY_NESTED(nl80211_pmsr_req_data_policy),
329 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF] = { .type = NLA_FLAG },
332 static const struct nla_policy
333 nl80211_pmsr_peer_attr_policy[NL80211_PMSR_PEER_ATTR_MAX + 1] = {
334 [NL80211_PMSR_PEER_ATTR_ADDR] = NLA_POLICY_ETH_ADDR,
335 [NL80211_PMSR_PEER_ATTR_CHAN] = NLA_POLICY_NESTED(nl80211_policy),
336 [NL80211_PMSR_PEER_ATTR_REQ] =
337 NLA_POLICY_NESTED(nl80211_pmsr_req_attr_policy),
338 [NL80211_PMSR_PEER_ATTR_RESP] = { .type = NLA_REJECT },
341 static const struct nla_policy
342 nl80211_pmsr_attr_policy[NL80211_PMSR_ATTR_MAX + 1] = {
343 [NL80211_PMSR_ATTR_MAX_PEERS] = { .type = NLA_REJECT },
344 [NL80211_PMSR_ATTR_REPORT_AP_TSF] = { .type = NLA_REJECT },
345 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR] = { .type = NLA_REJECT },
346 [NL80211_PMSR_ATTR_TYPE_CAPA] = { .type = NLA_REJECT },
347 [NL80211_PMSR_ATTR_PEERS] =
348 NLA_POLICY_NESTED_ARRAY(nl80211_pmsr_peer_attr_policy),
351 static const struct nla_policy
352 he_obss_pd_policy[NL80211_HE_OBSS_PD_ATTR_MAX + 1] = {
353 [NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] =
354 NLA_POLICY_RANGE(NLA_U8, 1, 20),
355 [NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET] =
356 NLA_POLICY_RANGE(NLA_U8, 1, 20),
357 [NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET] =
358 NLA_POLICY_RANGE(NLA_U8, 1, 20),
359 [NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP] =
360 NLA_POLICY_EXACT_LEN(8),
361 [NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP] =
362 NLA_POLICY_EXACT_LEN(8),
363 [NL80211_HE_OBSS_PD_ATTR_SR_CTRL] = { .type = NLA_U8 },
366 static const struct nla_policy
367 he_bss_color_policy[NL80211_HE_BSS_COLOR_ATTR_MAX + 1] = {
368 [NL80211_HE_BSS_COLOR_ATTR_COLOR] = NLA_POLICY_RANGE(NLA_U8, 1, 63),
369 [NL80211_HE_BSS_COLOR_ATTR_DISABLED] = { .type = NLA_FLAG },
370 [NL80211_HE_BSS_COLOR_ATTR_PARTIAL] = { .type = NLA_FLAG },
373 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
374 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
375 .len = NL80211_MAX_SUPP_RATES },
376 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
377 .len = NL80211_MAX_SUPP_HT_RATES },
378 [NL80211_TXRATE_VHT] = NLA_POLICY_EXACT_LEN_WARN(sizeof(struct nl80211_txrate_vht)),
379 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
380 [NL80211_TXRATE_HE] = NLA_POLICY_EXACT_LEN(sizeof(struct nl80211_txrate_he)),
381 [NL80211_TXRATE_HE_GI] = NLA_POLICY_RANGE(NLA_U8,
382 NL80211_RATE_INFO_HE_GI_0_8,
383 NL80211_RATE_INFO_HE_GI_3_2),
384 [NL80211_TXRATE_HE_LTF] = NLA_POLICY_RANGE(NLA_U8,
385 NL80211_RATE_INFO_HE_1XLTF,
386 NL80211_RATE_INFO_HE_4XLTF),
389 static const struct nla_policy
390 nl80211_tid_config_attr_policy[NL80211_TID_CONFIG_ATTR_MAX + 1] = {
391 [NL80211_TID_CONFIG_ATTR_VIF_SUPP] = { .type = NLA_U64 },
392 [NL80211_TID_CONFIG_ATTR_PEER_SUPP] = { .type = NLA_U64 },
393 [NL80211_TID_CONFIG_ATTR_OVERRIDE] = { .type = NLA_FLAG },
394 [NL80211_TID_CONFIG_ATTR_TIDS] = NLA_POLICY_RANGE(NLA_U16, 1, 0xff),
395 [NL80211_TID_CONFIG_ATTR_NOACK] =
396 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
397 [NL80211_TID_CONFIG_ATTR_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
398 [NL80211_TID_CONFIG_ATTR_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
399 [NL80211_TID_CONFIG_ATTR_AMPDU_CTRL] =
400 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
401 [NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL] =
402 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
403 [NL80211_TID_CONFIG_ATTR_AMSDU_CTRL] =
404 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
405 [NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE] =
406 NLA_POLICY_MAX(NLA_U8, NL80211_TX_RATE_FIXED),
407 [NL80211_TID_CONFIG_ATTR_TX_RATE] =
408 NLA_POLICY_NESTED(nl80211_txattr_policy),
411 static const struct nla_policy
412 nl80211_fils_discovery_policy[NL80211_FILS_DISCOVERY_ATTR_MAX + 1] = {
413 [NL80211_FILS_DISCOVERY_ATTR_INT_MIN] = NLA_POLICY_MAX(NLA_U32, 10000),
414 [NL80211_FILS_DISCOVERY_ATTR_INT_MAX] = NLA_POLICY_MAX(NLA_U32, 10000),
415 [NL80211_FILS_DISCOVERY_ATTR_TMPL] =
416 NLA_POLICY_RANGE(NLA_BINARY,
417 NL80211_FILS_DISCOVERY_TMPL_MIN_LEN,
418 IEEE80211_MAX_DATA_LEN),
421 static const struct nla_policy
422 nl80211_unsol_bcast_probe_resp_policy[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX + 1] = {
423 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT] = NLA_POLICY_MAX(NLA_U32, 20),
424 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL] = { .type = NLA_BINARY,
425 .len = IEEE80211_MAX_DATA_LEN }
428 static const struct nla_policy
429 sar_specs_policy[NL80211_SAR_ATTR_SPECS_MAX + 1] = {
430 [NL80211_SAR_ATTR_SPECS_POWER] = { .type = NLA_S32 },
431 [NL80211_SAR_ATTR_SPECS_RANGE_INDEX] = {.type = NLA_U32 },
434 static const struct nla_policy
435 sar_policy[NL80211_SAR_ATTR_MAX + 1] = {
436 [NL80211_SAR_ATTR_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_SAR_TYPE),
437 [NL80211_SAR_ATTR_SPECS] = NLA_POLICY_NESTED_ARRAY(sar_specs_policy),
440 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
441 [0] = { .strict_start_type = NL80211_ATTR_HE_OBSS_PD },
442 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
443 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
445 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
447 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
448 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
449 [NL80211_ATTR_WIPHY_EDMG_CHANNELS] = NLA_POLICY_RANGE(NLA_U8,
450 NL80211_EDMG_CHANNELS_MIN,
451 NL80211_EDMG_CHANNELS_MAX),
452 [NL80211_ATTR_WIPHY_EDMG_BW_CONFIG] = NLA_POLICY_RANGE(NLA_U8,
453 NL80211_EDMG_BW_CONFIG_MIN,
454 NL80211_EDMG_BW_CONFIG_MAX),
456 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
457 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
458 [NL80211_ATTR_CENTER_FREQ1_OFFSET] = NLA_POLICY_RANGE(NLA_U32, 0, 999),
459 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
461 [NL80211_ATTR_WIPHY_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
462 [NL80211_ATTR_WIPHY_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
463 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
464 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
465 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
466 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
468 [NL80211_ATTR_IFTYPE] = NLA_POLICY_MAX(NLA_U32, NL80211_IFTYPE_MAX),
469 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
470 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
472 [NL80211_ATTR_MAC] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
473 [NL80211_ATTR_PREV_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
475 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
476 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
477 .len = WLAN_MAX_KEY_LEN },
478 [NL80211_ATTR_KEY_IDX] = NLA_POLICY_MAX(NLA_U8, 7),
479 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
480 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
481 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
482 [NL80211_ATTR_KEY_TYPE] =
483 NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES),
485 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
486 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
487 [NL80211_ATTR_BEACON_HEAD] =
488 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_beacon_head,
489 IEEE80211_MAX_DATA_LEN),
490 [NL80211_ATTR_BEACON_TAIL] =
491 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
492 IEEE80211_MAX_DATA_LEN),
493 [NL80211_ATTR_STA_AID] =
494 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
495 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
496 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
497 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
498 .len = NL80211_MAX_SUPP_RATES },
499 [NL80211_ATTR_STA_PLINK_ACTION] =
500 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1),
501 [NL80211_ATTR_STA_TX_POWER_SETTING] =
502 NLA_POLICY_RANGE(NLA_U8,
503 NL80211_TX_POWER_AUTOMATIC,
504 NL80211_TX_POWER_FIXED),
505 [NL80211_ATTR_STA_TX_POWER] = { .type = NLA_S16 },
506 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
507 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
508 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
509 .len = IEEE80211_MAX_MESH_ID_LEN },
510 [NL80211_ATTR_MPATH_NEXT_HOP] = NLA_POLICY_ETH_ADDR_COMPAT,
512 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
513 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
515 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
516 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
517 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
518 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
519 .len = NL80211_MAX_SUPP_RATES },
520 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
522 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
523 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
525 [NL80211_ATTR_HT_CAPABILITY] = NLA_POLICY_EXACT_LEN_WARN(NL80211_HT_CAPABILITY_LEN),
527 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
528 [NL80211_ATTR_IE] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
530 IEEE80211_MAX_DATA_LEN),
531 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
532 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
534 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
535 .len = IEEE80211_MAX_SSID_LEN },
536 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
537 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
538 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
539 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
540 [NL80211_ATTR_USE_MFP] = NLA_POLICY_RANGE(NLA_U32,
542 NL80211_MFP_OPTIONAL),
543 [NL80211_ATTR_STA_FLAGS2] = {
544 .len = sizeof(struct nl80211_sta_flag_update),
546 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
547 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
548 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
549 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211] = { .type = NLA_FLAG },
550 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
551 [NL80211_ATTR_STATUS_CODE] = { .type = NLA_U16 },
552 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
553 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
554 [NL80211_ATTR_PID] = { .type = NLA_U32 },
555 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
556 [NL80211_ATTR_PMKID] = NLA_POLICY_EXACT_LEN_WARN(WLAN_PMKID_LEN),
557 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
558 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
559 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
560 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
561 .len = IEEE80211_MAX_DATA_LEN },
562 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
563 [NL80211_ATTR_PS_STATE] = NLA_POLICY_RANGE(NLA_U32,
566 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
567 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
568 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
569 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
570 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
571 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
572 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
573 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
574 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
575 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
576 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
577 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
578 [NL80211_ATTR_STA_PLINK_STATE] =
579 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
580 [NL80211_ATTR_MEASUREMENT_DURATION] = { .type = NLA_U16 },
581 [NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY] = { .type = NLA_FLAG },
582 [NL80211_ATTR_MESH_PEER_AID] =
583 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
584 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
585 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
586 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
587 [NL80211_ATTR_HIDDEN_SSID] =
588 NLA_POLICY_RANGE(NLA_U32,
589 NL80211_HIDDEN_SSID_NOT_IN_USE,
590 NL80211_HIDDEN_SSID_ZERO_CONTENTS),
591 [NL80211_ATTR_IE_PROBE_RESP] =
592 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
593 IEEE80211_MAX_DATA_LEN),
594 [NL80211_ATTR_IE_ASSOC_RESP] =
595 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
596 IEEE80211_MAX_DATA_LEN),
597 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
598 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
599 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
600 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
601 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
602 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
603 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
604 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
605 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
606 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
607 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
608 .len = IEEE80211_MAX_DATA_LEN },
609 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
610 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
611 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
612 .len = NL80211_HT_CAPABILITY_LEN
614 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
615 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
616 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
617 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
618 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
620 /* need to include at least Auth Transaction and Status Code */
621 [NL80211_ATTR_AUTH_DATA] = NLA_POLICY_MIN_LEN(4),
623 [NL80211_ATTR_VHT_CAPABILITY] = NLA_POLICY_EXACT_LEN_WARN(NL80211_VHT_CAPABILITY_LEN),
624 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
625 [NL80211_ATTR_P2P_CTWINDOW] = NLA_POLICY_MAX(NLA_U8, 127),
626 [NL80211_ATTR_P2P_OPPPS] = NLA_POLICY_MAX(NLA_U8, 1),
627 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] =
628 NLA_POLICY_RANGE(NLA_U32,
629 NL80211_MESH_POWER_UNKNOWN + 1,
630 NL80211_MESH_POWER_MAX),
631 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
632 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
633 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
634 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
635 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
636 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
637 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
638 .len = NL80211_VHT_CAPABILITY_LEN,
640 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
641 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
642 .len = IEEE80211_MAX_DATA_LEN },
643 [NL80211_ATTR_CRIT_PROT_ID] = { .type = NLA_U16 },
644 [NL80211_ATTR_MAX_CRIT_PROT_DURATION] =
645 NLA_POLICY_MAX(NLA_U16, NL80211_CRIT_PROTO_MAX_DURATION),
646 [NL80211_ATTR_PEER_AID] =
647 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
648 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
649 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
650 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
651 [NL80211_ATTR_CNTDWN_OFFS_BEACON] = { .type = NLA_BINARY },
652 [NL80211_ATTR_CNTDWN_OFFS_PRESP] = { .type = NLA_BINARY },
653 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = NLA_POLICY_MIN_LEN(2),
655 * The value of the Length field of the Supported Operating
656 * Classes element is between 2 and 253.
658 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] =
659 NLA_POLICY_RANGE(NLA_BINARY, 2, 253),
660 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
661 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
662 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
663 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
664 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
665 [NL80211_ATTR_QOS_MAP] = NLA_POLICY_RANGE(NLA_BINARY,
666 IEEE80211_QOS_MAP_LEN_MIN,
667 IEEE80211_QOS_MAP_LEN_MAX),
668 [NL80211_ATTR_MAC_HINT] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
669 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
670 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
671 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
672 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
673 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
674 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1),
675 [NL80211_ATTR_USER_PRIO] =
676 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
677 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
678 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
679 [NL80211_ATTR_OPER_CLASS] = { .type = NLA_U8 },
680 [NL80211_ATTR_MAC_MASK] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
681 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
682 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
683 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
684 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
685 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
686 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
687 [NL80211_ATTR_STA_SUPPORT_P2P_PS] =
688 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1),
689 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
690 .len = VHT_MUMIMO_GROUPS_DATA_LEN
692 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
693 [NL80211_ATTR_NAN_MASTER_PREF] = NLA_POLICY_MIN(NLA_U8, 1),
694 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
695 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
696 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
697 .len = FILS_MAX_KEK_LEN },
698 [NL80211_ATTR_FILS_NONCES] = NLA_POLICY_EXACT_LEN_WARN(2 * FILS_NONCE_LEN),
699 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
700 [NL80211_ATTR_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
701 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
702 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
703 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
705 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
706 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
707 .len = FILS_ERP_MAX_USERNAME_LEN },
708 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
709 .len = FILS_ERP_MAX_REALM_LEN },
710 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
711 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
712 .len = FILS_ERP_MAX_RRK_LEN },
713 [NL80211_ATTR_FILS_CACHE_ID] = NLA_POLICY_EXACT_LEN_WARN(2),
714 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
715 [NL80211_ATTR_PMKR0_NAME] = NLA_POLICY_EXACT_LEN(WLAN_PMK_NAME_LEN),
716 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
717 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT] = { .type = NLA_FLAG },
719 [NL80211_ATTR_TXQ_LIMIT] = { .type = NLA_U32 },
720 [NL80211_ATTR_TXQ_MEMORY_LIMIT] = { .type = NLA_U32 },
721 [NL80211_ATTR_TXQ_QUANTUM] = { .type = NLA_U32 },
722 [NL80211_ATTR_HE_CAPABILITY] =
723 NLA_POLICY_RANGE(NLA_BINARY,
724 NL80211_HE_MIN_CAPABILITY_LEN,
725 NL80211_HE_MAX_CAPABILITY_LEN),
726 [NL80211_ATTR_FTM_RESPONDER] =
727 NLA_POLICY_NESTED(nl80211_ftm_responder_policy),
728 [NL80211_ATTR_TIMEOUT] = NLA_POLICY_MIN(NLA_U32, 1),
729 [NL80211_ATTR_PEER_MEASUREMENTS] =
730 NLA_POLICY_NESTED(nl80211_pmsr_attr_policy),
731 [NL80211_ATTR_AIRTIME_WEIGHT] = NLA_POLICY_MIN(NLA_U16, 1),
732 [NL80211_ATTR_SAE_PASSWORD] = { .type = NLA_BINARY,
733 .len = SAE_PASSWORD_MAX_LEN },
734 [NL80211_ATTR_TWT_RESPONDER] = { .type = NLA_FLAG },
735 [NL80211_ATTR_HE_OBSS_PD] = NLA_POLICY_NESTED(he_obss_pd_policy),
736 [NL80211_ATTR_VLAN_ID] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
737 [NL80211_ATTR_HE_BSS_COLOR] = NLA_POLICY_NESTED(he_bss_color_policy),
738 [NL80211_ATTR_TID_CONFIG] =
739 NLA_POLICY_NESTED_ARRAY(nl80211_tid_config_attr_policy),
740 [NL80211_ATTR_CONTROL_PORT_NO_PREAUTH] = { .type = NLA_FLAG },
741 [NL80211_ATTR_PMK_LIFETIME] = NLA_POLICY_MIN(NLA_U32, 1),
742 [NL80211_ATTR_PMK_REAUTH_THRESHOLD] = NLA_POLICY_RANGE(NLA_U8, 1, 100),
743 [NL80211_ATTR_RECEIVE_MULTICAST] = { .type = NLA_FLAG },
744 [NL80211_ATTR_WIPHY_FREQ_OFFSET] = NLA_POLICY_RANGE(NLA_U32, 0, 999),
745 [NL80211_ATTR_SCAN_FREQ_KHZ] = { .type = NLA_NESTED },
746 [NL80211_ATTR_HE_6GHZ_CAPABILITY] =
747 NLA_POLICY_EXACT_LEN(sizeof(struct ieee80211_he_6ghz_capa)),
748 [NL80211_ATTR_FILS_DISCOVERY] =
749 NLA_POLICY_NESTED(nl80211_fils_discovery_policy),
750 [NL80211_ATTR_UNSOL_BCAST_PROBE_RESP] =
751 NLA_POLICY_NESTED(nl80211_unsol_bcast_probe_resp_policy),
752 [NL80211_ATTR_S1G_CAPABILITY] =
753 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN),
754 [NL80211_ATTR_S1G_CAPABILITY_MASK] =
755 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN),
756 [NL80211_ATTR_SAE_PWE] =
757 NLA_POLICY_RANGE(NLA_U8, NL80211_SAE_PWE_HUNT_AND_PECK,
758 NL80211_SAE_PWE_BOTH),
759 [NL80211_ATTR_RECONNECT_REQUESTED] = { .type = NLA_REJECT },
760 [NL80211_ATTR_SAR_SPEC] = NLA_POLICY_NESTED(sar_policy),
761 [NL80211_ATTR_DISABLE_HE] = { .type = NLA_FLAG },
764 /* policy for the key attributes */
765 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
766 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
767 [NL80211_KEY_IDX] = { .type = NLA_U8 },
768 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
769 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
770 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
771 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
772 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1),
773 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
774 [NL80211_KEY_MODE] = NLA_POLICY_RANGE(NLA_U8, 0, NL80211_KEY_SET_TX),
777 /* policy for the key default flags */
778 static const struct nla_policy
779 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
780 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
781 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
785 /* policy for WoWLAN attributes */
786 static const struct nla_policy
787 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
788 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
789 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
790 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
791 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
792 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
793 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
794 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
795 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
796 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
797 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
800 static const struct nla_policy
801 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
802 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
803 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
804 [NL80211_WOWLAN_TCP_DST_MAC] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
805 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
806 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
807 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = NLA_POLICY_MIN_LEN(1),
808 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
809 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
811 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
812 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
814 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
815 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = NLA_POLICY_MIN_LEN(1),
816 [NL80211_WOWLAN_TCP_WAKE_MASK] = NLA_POLICY_MIN_LEN(1),
818 #endif /* CONFIG_PM */
820 /* policy for coalesce rule attributes */
821 static const struct nla_policy
822 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
823 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
824 [NL80211_ATTR_COALESCE_RULE_CONDITION] =
825 NLA_POLICY_RANGE(NLA_U32,
826 NL80211_COALESCE_CONDITION_MATCH,
827 NL80211_COALESCE_CONDITION_NO_MATCH),
828 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
831 /* policy for GTK rekey offload attributes */
832 static const struct nla_policy
833 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
834 [NL80211_REKEY_DATA_KEK] = {
836 .len = NL80211_KEK_EXT_LEN
838 [NL80211_REKEY_DATA_KCK] = {
840 .len = NL80211_KCK_EXT_LEN
842 [NL80211_REKEY_DATA_REPLAY_CTR] = NLA_POLICY_EXACT_LEN(NL80211_REPLAY_CTR_LEN),
843 [NL80211_REKEY_DATA_AKM] = { .type = NLA_U32 },
846 static const struct nla_policy
847 nl80211_match_band_rssi_policy[NUM_NL80211_BANDS] = {
848 [NL80211_BAND_2GHZ] = { .type = NLA_S32 },
849 [NL80211_BAND_5GHZ] = { .type = NLA_S32 },
850 [NL80211_BAND_6GHZ] = { .type = NLA_S32 },
851 [NL80211_BAND_60GHZ] = { .type = NLA_S32 },
854 static const struct nla_policy
855 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
856 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
857 .len = IEEE80211_MAX_SSID_LEN },
858 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
859 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
860 [NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI] =
861 NLA_POLICY_NESTED(nl80211_match_band_rssi_policy),
864 static const struct nla_policy
865 nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
866 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
867 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
870 static const struct nla_policy
871 nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
872 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
873 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
874 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
875 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
879 /* policy for NAN function attributes */
880 static const struct nla_policy
881 nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
882 [NL80211_NAN_FUNC_TYPE] =
883 NLA_POLICY_MAX(NLA_U8, NL80211_NAN_FUNC_MAX_TYPE),
884 [NL80211_NAN_FUNC_SERVICE_ID] = {
885 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
886 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
887 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
888 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
889 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
890 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
891 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
892 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
893 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
894 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
895 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
896 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
897 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
898 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
899 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
900 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
903 /* policy for Service Response Filter attributes */
904 static const struct nla_policy
905 nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
906 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
907 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
908 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
909 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
910 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
913 /* policy for packet pattern attributes */
914 static const struct nla_policy
915 nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
916 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
917 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
918 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
921 int nl80211_prepare_wdev_dump(struct netlink_callback *cb,
922 struct cfg80211_registered_device **rdev,
923 struct wireless_dev **wdev)
928 struct nlattr **attrbuf;
930 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
935 err = nlmsg_parse_deprecated(cb->nlh,
936 GENL_HDRLEN + nl80211_fam.hdrsize,
937 attrbuf, nl80211_fam.maxattr,
938 nl80211_policy, NULL);
945 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(cb->skb->sk),
950 return PTR_ERR(*wdev);
952 *rdev = wiphy_to_rdev((*wdev)->wiphy);
953 mutex_lock(&(*rdev)->wiphy.mtx);
955 /* 0 is the first index - add 1 to parse only once */
956 cb->args[0] = (*rdev)->wiphy_idx + 1;
957 cb->args[1] = (*wdev)->identifier;
959 /* subtract the 1 again here */
961 struct wireless_dev *tmp;
964 wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
969 *rdev = wiphy_to_rdev(wiphy);
972 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
973 if (tmp->identifier == cb->args[1]) {
983 mutex_lock(&(*rdev)->wiphy.mtx);
990 /* message building helper */
991 void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
994 /* since there is no private header just add the generic one */
995 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
998 static int nl80211_msg_put_wmm_rules(struct sk_buff *msg,
999 const struct ieee80211_reg_rule *rule)
1002 struct nlattr *nl_wmm_rules =
1003 nla_nest_start_noflag(msg, NL80211_FREQUENCY_ATTR_WMM);
1006 goto nla_put_failure;
1008 for (j = 0; j < IEEE80211_NUM_ACS; j++) {
1009 struct nlattr *nl_wmm_rule = nla_nest_start_noflag(msg, j);
1012 goto nla_put_failure;
1014 if (nla_put_u16(msg, NL80211_WMMR_CW_MIN,
1015 rule->wmm_rule.client[j].cw_min) ||
1016 nla_put_u16(msg, NL80211_WMMR_CW_MAX,
1017 rule->wmm_rule.client[j].cw_max) ||
1018 nla_put_u8(msg, NL80211_WMMR_AIFSN,
1019 rule->wmm_rule.client[j].aifsn) ||
1020 nla_put_u16(msg, NL80211_WMMR_TXOP,
1021 rule->wmm_rule.client[j].cot))
1022 goto nla_put_failure;
1024 nla_nest_end(msg, nl_wmm_rule);
1026 nla_nest_end(msg, nl_wmm_rules);
1034 static int nl80211_msg_put_channel(struct sk_buff *msg, struct wiphy *wiphy,
1035 struct ieee80211_channel *chan,
1038 /* Some channels must be completely excluded from the
1039 * list to protect old user-space tools from breaking
1041 if (!large && chan->flags &
1042 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
1044 if (!large && chan->freq_offset)
1047 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
1049 goto nla_put_failure;
1051 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_OFFSET, chan->freq_offset))
1052 goto nla_put_failure;
1054 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
1055 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
1056 goto nla_put_failure;
1057 if (chan->flags & IEEE80211_CHAN_NO_IR) {
1058 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
1059 goto nla_put_failure;
1060 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
1061 goto nla_put_failure;
1063 if (chan->flags & IEEE80211_CHAN_RADAR) {
1064 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
1065 goto nla_put_failure;
1069 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
1071 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
1073 goto nla_put_failure;
1074 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
1076 goto nla_put_failure;
1077 if (nla_put_u32(msg,
1078 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
1080 goto nla_put_failure;
1085 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
1086 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
1087 goto nla_put_failure;
1088 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
1089 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
1090 goto nla_put_failure;
1091 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
1092 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
1093 goto nla_put_failure;
1094 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
1095 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
1096 goto nla_put_failure;
1097 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
1098 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
1099 goto nla_put_failure;
1100 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
1101 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
1102 goto nla_put_failure;
1103 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
1104 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
1105 goto nla_put_failure;
1106 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
1107 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
1108 goto nla_put_failure;
1109 if ((chan->flags & IEEE80211_CHAN_NO_HE) &&
1110 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HE))
1111 goto nla_put_failure;
1112 if ((chan->flags & IEEE80211_CHAN_1MHZ) &&
1113 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_1MHZ))
1114 goto nla_put_failure;
1115 if ((chan->flags & IEEE80211_CHAN_2MHZ) &&
1116 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_2MHZ))
1117 goto nla_put_failure;
1118 if ((chan->flags & IEEE80211_CHAN_4MHZ) &&
1119 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_4MHZ))
1120 goto nla_put_failure;
1121 if ((chan->flags & IEEE80211_CHAN_8MHZ) &&
1122 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_8MHZ))
1123 goto nla_put_failure;
1124 if ((chan->flags & IEEE80211_CHAN_16MHZ) &&
1125 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_16MHZ))
1126 goto nla_put_failure;
1129 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
1130 DBM_TO_MBM(chan->max_power)))
1131 goto nla_put_failure;
1134 const struct ieee80211_reg_rule *rule =
1135 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1137 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) {
1138 if (nl80211_msg_put_wmm_rules(msg, rule))
1139 goto nla_put_failure;
1149 static bool nl80211_put_txq_stats(struct sk_buff *msg,
1150 struct cfg80211_txq_stats *txqstats,
1153 struct nlattr *txqattr;
1155 #define PUT_TXQVAL_U32(attr, memb) do { \
1156 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
1157 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
1161 txqattr = nla_nest_start_noflag(msg, attrtype);
1165 PUT_TXQVAL_U32(BACKLOG_BYTES, backlog_bytes);
1166 PUT_TXQVAL_U32(BACKLOG_PACKETS, backlog_packets);
1167 PUT_TXQVAL_U32(FLOWS, flows);
1168 PUT_TXQVAL_U32(DROPS, drops);
1169 PUT_TXQVAL_U32(ECN_MARKS, ecn_marks);
1170 PUT_TXQVAL_U32(OVERLIMIT, overlimit);
1171 PUT_TXQVAL_U32(OVERMEMORY, overmemory);
1172 PUT_TXQVAL_U32(COLLISIONS, collisions);
1173 PUT_TXQVAL_U32(TX_BYTES, tx_bytes);
1174 PUT_TXQVAL_U32(TX_PACKETS, tx_packets);
1175 PUT_TXQVAL_U32(MAX_FLOWS, max_flows);
1176 nla_nest_end(msg, txqattr);
1178 #undef PUT_TXQVAL_U32
1182 /* netlink command implementations */
1185 struct key_params p;
1188 bool def, defmgmt, defbeacon;
1189 bool def_uni, def_multi;
1192 static int nl80211_parse_key_new(struct genl_info *info, struct nlattr *key,
1193 struct key_parse *k)
1195 struct nlattr *tb[NL80211_KEY_MAX + 1];
1196 int err = nla_parse_nested_deprecated(tb, NL80211_KEY_MAX, key,
1202 k->def = !!tb[NL80211_KEY_DEFAULT];
1203 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
1204 k->defbeacon = !!tb[NL80211_KEY_DEFAULT_BEACON];
1208 k->def_multi = true;
1210 if (k->defmgmt || k->defbeacon)
1211 k->def_multi = true;
1213 if (tb[NL80211_KEY_IDX])
1214 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
1216 if (tb[NL80211_KEY_DATA]) {
1217 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
1218 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
1221 if (tb[NL80211_KEY_SEQ]) {
1222 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
1223 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
1226 if (tb[NL80211_KEY_CIPHER])
1227 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
1229 if (tb[NL80211_KEY_TYPE])
1230 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
1232 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
1233 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1235 err = nla_parse_nested_deprecated(kdt,
1236 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1237 tb[NL80211_KEY_DEFAULT_TYPES],
1238 nl80211_key_default_policy,
1243 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1244 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1247 if (tb[NL80211_KEY_MODE])
1248 k->p.mode = nla_get_u8(tb[NL80211_KEY_MODE]);
1253 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
1255 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
1256 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
1257 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
1260 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
1261 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
1262 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
1265 if (info->attrs[NL80211_ATTR_KEY_IDX])
1266 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1268 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
1269 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
1271 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
1272 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
1276 k->def_multi = true;
1279 k->def_multi = true;
1281 if (info->attrs[NL80211_ATTR_KEY_TYPE])
1282 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1284 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
1285 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1286 int err = nla_parse_nested_deprecated(kdt,
1287 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1288 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
1289 nl80211_key_default_policy,
1294 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1295 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1301 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
1305 memset(k, 0, sizeof(*k));
1309 if (info->attrs[NL80211_ATTR_KEY])
1310 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k);
1312 err = nl80211_parse_key_old(info, k);
1317 if ((k->def ? 1 : 0) + (k->defmgmt ? 1 : 0) +
1318 (k->defbeacon ? 1 : 0) > 1) {
1319 GENL_SET_ERR_MSG(info,
1320 "key with multiple default flags is invalid");
1324 if (k->defmgmt || k->defbeacon) {
1325 if (k->def_uni || !k->def_multi) {
1326 GENL_SET_ERR_MSG(info,
1327 "defmgmt/defbeacon key must be mcast");
1334 if (k->idx < 4 || k->idx > 5) {
1335 GENL_SET_ERR_MSG(info,
1336 "defmgmt key idx not 4 or 5");
1339 } else if (k->defbeacon) {
1340 if (k->idx < 6 || k->idx > 7) {
1341 GENL_SET_ERR_MSG(info,
1342 "defbeacon key idx not 6 or 7");
1345 } else if (k->def) {
1346 if (k->idx < 0 || k->idx > 3) {
1347 GENL_SET_ERR_MSG(info, "def key idx not 0-3");
1351 if (k->idx < 0 || k->idx > 7) {
1352 GENL_SET_ERR_MSG(info, "key idx not 0-7");
1361 static struct cfg80211_cached_keys *
1362 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
1363 struct genl_info *info, bool *no_ht)
1365 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS];
1366 struct key_parse parse;
1368 struct cfg80211_cached_keys *result;
1369 int rem, err, def = 0;
1370 bool have_key = false;
1372 nla_for_each_nested(key, keys, rem) {
1380 result = kzalloc(sizeof(*result), GFP_KERNEL);
1382 return ERR_PTR(-ENOMEM);
1386 nla_for_each_nested(key, keys, rem) {
1387 memset(&parse, 0, sizeof(parse));
1390 err = nl80211_parse_key_new(info, key, &parse);
1396 if (parse.idx < 0 || parse.idx > 3) {
1397 GENL_SET_ERR_MSG(info, "key index out of range [0-3]");
1402 GENL_SET_ERR_MSG(info,
1403 "only one key can be default");
1407 result->def = parse.idx;
1408 if (!parse.def_uni || !parse.def_multi)
1410 } else if (parse.defmgmt)
1412 err = cfg80211_validate_key_settings(rdev, &parse.p,
1413 parse.idx, false, NULL);
1416 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1417 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
1418 GENL_SET_ERR_MSG(info, "connect key must be WEP");
1422 result->params[parse.idx].cipher = parse.p.cipher;
1423 result->params[parse.idx].key_len = parse.p.key_len;
1424 result->params[parse.idx].key = result->data[parse.idx];
1425 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
1427 /* must be WEP key if we got here */
1432 if (result->def < 0) {
1434 GENL_SET_ERR_MSG(info, "need a default/TX key");
1441 return ERR_PTR(err);
1444 static int nl80211_key_allowed(struct wireless_dev *wdev)
1446 ASSERT_WDEV_LOCK(wdev);
1448 switch (wdev->iftype) {
1449 case NL80211_IFTYPE_AP:
1450 case NL80211_IFTYPE_AP_VLAN:
1451 case NL80211_IFTYPE_P2P_GO:
1452 case NL80211_IFTYPE_MESH_POINT:
1454 case NL80211_IFTYPE_ADHOC:
1455 case NL80211_IFTYPE_STATION:
1456 case NL80211_IFTYPE_P2P_CLIENT:
1457 if (!wdev->current_bss)
1460 case NL80211_IFTYPE_UNSPECIFIED:
1461 case NL80211_IFTYPE_OCB:
1462 case NL80211_IFTYPE_MONITOR:
1463 case NL80211_IFTYPE_NAN:
1464 case NL80211_IFTYPE_P2P_DEVICE:
1465 case NL80211_IFTYPE_WDS:
1466 case NUM_NL80211_IFTYPES:
1473 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
1476 struct ieee80211_channel *chan;
1478 chan = ieee80211_get_channel_khz(wiphy, freq);
1479 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1484 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1486 struct nlattr *nl_modes = nla_nest_start_noflag(msg, attr);
1490 goto nla_put_failure;
1494 if ((ifmodes & 1) && nla_put_flag(msg, i))
1495 goto nla_put_failure;
1500 nla_nest_end(msg, nl_modes);
1507 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
1508 struct sk_buff *msg,
1511 struct nlattr *nl_combis;
1514 nl_combis = nla_nest_start_noflag(msg,
1515 NL80211_ATTR_INTERFACE_COMBINATIONS);
1517 goto nla_put_failure;
1519 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1520 const struct ieee80211_iface_combination *c;
1521 struct nlattr *nl_combi, *nl_limits;
1523 c = &wiphy->iface_combinations[i];
1525 nl_combi = nla_nest_start_noflag(msg, i + 1);
1527 goto nla_put_failure;
1529 nl_limits = nla_nest_start_noflag(msg,
1530 NL80211_IFACE_COMB_LIMITS);
1532 goto nla_put_failure;
1534 for (j = 0; j < c->n_limits; j++) {
1535 struct nlattr *nl_limit;
1537 nl_limit = nla_nest_start_noflag(msg, j + 1);
1539 goto nla_put_failure;
1540 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1542 goto nla_put_failure;
1543 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1544 c->limits[j].types))
1545 goto nla_put_failure;
1546 nla_nest_end(msg, nl_limit);
1549 nla_nest_end(msg, nl_limits);
1551 if (c->beacon_int_infra_match &&
1552 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1553 goto nla_put_failure;
1554 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1555 c->num_different_channels) ||
1556 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1558 goto nla_put_failure;
1560 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1561 c->radar_detect_widths) ||
1562 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1563 c->radar_detect_regions)))
1564 goto nla_put_failure;
1565 if (c->beacon_int_min_gcd &&
1566 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1567 c->beacon_int_min_gcd))
1568 goto nla_put_failure;
1570 nla_nest_end(msg, nl_combi);
1573 nla_nest_end(msg, nl_combis);
1581 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1582 struct sk_buff *msg)
1584 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1585 struct nlattr *nl_tcp;
1590 nl_tcp = nla_nest_start_noflag(msg,
1591 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1595 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1596 tcp->data_payload_max))
1599 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1600 tcp->data_payload_max))
1603 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1606 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1607 sizeof(*tcp->tok), tcp->tok))
1610 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1611 tcp->data_interval_max))
1614 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1615 tcp->wake_payload_max))
1618 nla_nest_end(msg, nl_tcp);
1622 static int nl80211_send_wowlan(struct sk_buff *msg,
1623 struct cfg80211_registered_device *rdev,
1626 struct nlattr *nl_wowlan;
1628 if (!rdev->wiphy.wowlan)
1631 nl_wowlan = nla_nest_start_noflag(msg,
1632 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1636 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1637 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1638 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1639 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1640 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1641 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1642 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1643 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1644 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1645 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1646 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1647 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1648 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1649 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1650 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1651 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1654 if (rdev->wiphy.wowlan->n_patterns) {
1655 struct nl80211_pattern_support pat = {
1656 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1657 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1658 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1659 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1662 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1667 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1668 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1669 rdev->wiphy.wowlan->max_nd_match_sets))
1672 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
1675 nla_nest_end(msg, nl_wowlan);
1681 static int nl80211_send_coalesce(struct sk_buff *msg,
1682 struct cfg80211_registered_device *rdev)
1684 struct nl80211_coalesce_rule_support rule;
1686 if (!rdev->wiphy.coalesce)
1689 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1690 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1691 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1692 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1693 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1694 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1696 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1703 nl80211_send_iftype_data(struct sk_buff *msg,
1704 const struct ieee80211_supported_band *sband,
1705 const struct ieee80211_sband_iftype_data *iftdata)
1707 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap;
1709 if (nl80211_put_iftypes(msg, NL80211_BAND_IFTYPE_ATTR_IFTYPES,
1710 iftdata->types_mask))
1713 if (he_cap->has_he) {
1714 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC,
1715 sizeof(he_cap->he_cap_elem.mac_cap_info),
1716 he_cap->he_cap_elem.mac_cap_info) ||
1717 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY,
1718 sizeof(he_cap->he_cap_elem.phy_cap_info),
1719 he_cap->he_cap_elem.phy_cap_info) ||
1720 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET,
1721 sizeof(he_cap->he_mcs_nss_supp),
1722 &he_cap->he_mcs_nss_supp) ||
1723 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE,
1724 sizeof(he_cap->ppe_thres), he_cap->ppe_thres))
1728 if (sband->band == NL80211_BAND_6GHZ &&
1729 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA,
1730 sizeof(iftdata->he_6ghz_capa),
1731 &iftdata->he_6ghz_capa))
1734 if (iftdata->vendor_elems.data && iftdata->vendor_elems.len &&
1735 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_VENDOR_ELEMS,
1736 iftdata->vendor_elems.len, iftdata->vendor_elems.data))
1742 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1743 struct ieee80211_supported_band *sband,
1746 struct nlattr *nl_rates, *nl_rate;
1747 struct ieee80211_rate *rate;
1751 if (sband->ht_cap.ht_supported &&
1752 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1753 sizeof(sband->ht_cap.mcs),
1754 &sband->ht_cap.mcs) ||
1755 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1756 sband->ht_cap.cap) ||
1757 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1758 sband->ht_cap.ampdu_factor) ||
1759 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1760 sband->ht_cap.ampdu_density)))
1764 if (sband->vht_cap.vht_supported &&
1765 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1766 sizeof(sband->vht_cap.vht_mcs),
1767 &sband->vht_cap.vht_mcs) ||
1768 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1769 sband->vht_cap.cap)))
1772 if (large && sband->n_iftype_data) {
1773 struct nlattr *nl_iftype_data =
1774 nla_nest_start_noflag(msg,
1775 NL80211_BAND_ATTR_IFTYPE_DATA);
1778 if (!nl_iftype_data)
1781 for (i = 0; i < sband->n_iftype_data; i++) {
1782 struct nlattr *iftdata;
1784 iftdata = nla_nest_start_noflag(msg, i + 1);
1788 err = nl80211_send_iftype_data(msg, sband,
1789 &sband->iftype_data[i]);
1793 nla_nest_end(msg, iftdata);
1796 nla_nest_end(msg, nl_iftype_data);
1800 if (large && sband->edmg_cap.channels &&
1801 (nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_CHANNELS,
1802 sband->edmg_cap.channels) ||
1803 nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_BW_CONFIG,
1804 sband->edmg_cap.bw_config)))
1809 nl_rates = nla_nest_start_noflag(msg, NL80211_BAND_ATTR_RATES);
1813 for (i = 0; i < sband->n_bitrates; i++) {
1814 nl_rate = nla_nest_start_noflag(msg, i);
1818 rate = &sband->bitrates[i];
1819 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1822 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1824 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1827 nla_nest_end(msg, nl_rate);
1830 nla_nest_end(msg, nl_rates);
1836 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1837 const struct ieee80211_txrx_stypes *mgmt_stypes)
1840 struct nlattr *nl_ftypes, *nl_ifs;
1841 enum nl80211_iftype ift;
1847 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_TX_FRAME_TYPES);
1851 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1852 nl_ftypes = nla_nest_start_noflag(msg, ift);
1856 stypes = mgmt_stypes[ift].tx;
1859 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1860 (i << 4) | IEEE80211_FTYPE_MGMT))
1865 nla_nest_end(msg, nl_ftypes);
1868 nla_nest_end(msg, nl_ifs);
1870 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_RX_FRAME_TYPES);
1874 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1875 nl_ftypes = nla_nest_start_noflag(msg, ift);
1879 stypes = mgmt_stypes[ift].rx;
1882 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1883 (i << 4) | IEEE80211_FTYPE_MGMT))
1888 nla_nest_end(msg, nl_ftypes);
1890 nla_nest_end(msg, nl_ifs);
1895 #define CMD(op, n) \
1897 if (rdev->ops->op) { \
1899 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1900 goto nla_put_failure; \
1904 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1905 struct sk_buff *msg)
1910 * do *NOT* add anything into this function, new things need to be
1911 * advertised only to new versions of userspace that can deal with
1912 * the split (and they can't possibly care about new features...
1914 CMD(add_virtual_intf, NEW_INTERFACE);
1915 CMD(change_virtual_intf, SET_INTERFACE);
1916 CMD(add_key, NEW_KEY);
1917 CMD(start_ap, START_AP);
1918 CMD(add_station, NEW_STATION);
1919 CMD(add_mpath, NEW_MPATH);
1920 CMD(update_mesh_config, SET_MESH_CONFIG);
1921 CMD(change_bss, SET_BSS);
1922 CMD(auth, AUTHENTICATE);
1923 CMD(assoc, ASSOCIATE);
1924 CMD(deauth, DEAUTHENTICATE);
1925 CMD(disassoc, DISASSOCIATE);
1926 CMD(join_ibss, JOIN_IBSS);
1927 CMD(join_mesh, JOIN_MESH);
1928 CMD(set_pmksa, SET_PMKSA);
1929 CMD(del_pmksa, DEL_PMKSA);
1930 CMD(flush_pmksa, FLUSH_PMKSA);
1931 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1932 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1933 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1934 CMD(mgmt_tx, FRAME);
1935 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1936 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1938 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1939 goto nla_put_failure;
1941 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1942 rdev->ops->join_mesh) {
1944 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1945 goto nla_put_failure;
1947 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1948 CMD(tdls_mgmt, TDLS_MGMT);
1949 CMD(tdls_oper, TDLS_OPER);
1951 if (rdev->wiphy.max_sched_scan_reqs)
1952 CMD(sched_scan_start, START_SCHED_SCAN);
1953 CMD(probe_client, PROBE_CLIENT);
1954 CMD(set_noack_map, SET_NOACK_MAP);
1955 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1957 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1958 goto nla_put_failure;
1960 CMD(start_p2p_device, START_P2P_DEVICE);
1961 CMD(set_mcast_rate, SET_MCAST_RATE);
1962 #ifdef CONFIG_NL80211_TESTMODE
1963 CMD(testmode_cmd, TESTMODE);
1966 if (rdev->ops->connect || rdev->ops->auth) {
1968 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1969 goto nla_put_failure;
1972 if (rdev->ops->disconnect || rdev->ops->deauth) {
1974 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1975 goto nla_put_failure;
1984 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities *cap,
1985 struct sk_buff *msg)
1989 if (!cap->ftm.supported)
1992 ftm = nla_nest_start_noflag(msg, NL80211_PMSR_TYPE_FTM);
1996 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP))
1998 if (cap->ftm.non_asap &&
1999 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP))
2001 if (cap->ftm.request_lci &&
2002 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI))
2004 if (cap->ftm.request_civicloc &&
2005 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC))
2007 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES,
2008 cap->ftm.preambles))
2010 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS,
2011 cap->ftm.bandwidths))
2013 if (cap->ftm.max_bursts_exponent >= 0 &&
2014 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT,
2015 cap->ftm.max_bursts_exponent))
2017 if (cap->ftm.max_ftms_per_burst &&
2018 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST,
2019 cap->ftm.max_ftms_per_burst))
2021 if (cap->ftm.trigger_based &&
2022 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_TRIGGER_BASED))
2024 if (cap->ftm.non_trigger_based &&
2025 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED))
2028 nla_nest_end(msg, ftm);
2032 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device *rdev,
2033 struct sk_buff *msg)
2035 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa;
2036 struct nlattr *pmsr, *caps;
2042 * we don't need to clean up anything here since the caller
2043 * will genlmsg_cancel() if we fail
2046 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS);
2050 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers))
2053 if (cap->report_ap_tsf &&
2054 nla_put_flag(msg, NL80211_PMSR_ATTR_REPORT_AP_TSF))
2057 if (cap->randomize_mac_addr &&
2058 nla_put_flag(msg, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR))
2061 caps = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_TYPE_CAPA);
2065 if (nl80211_send_pmsr_ftm_capa(cap, msg))
2068 nla_nest_end(msg, caps);
2069 nla_nest_end(msg, pmsr);
2075 nl80211_put_iftype_akm_suites(struct cfg80211_registered_device *rdev,
2076 struct sk_buff *msg)
2079 struct nlattr *nested, *nested_akms;
2080 const struct wiphy_iftype_akm_suites *iftype_akms;
2082 if (!rdev->wiphy.num_iftype_akm_suites ||
2083 !rdev->wiphy.iftype_akm_suites)
2086 nested = nla_nest_start(msg, NL80211_ATTR_IFTYPE_AKM_SUITES);
2090 for (i = 0; i < rdev->wiphy.num_iftype_akm_suites; i++) {
2091 nested_akms = nla_nest_start(msg, i + 1);
2095 iftype_akms = &rdev->wiphy.iftype_akm_suites[i];
2097 if (nl80211_put_iftypes(msg, NL80211_IFTYPE_AKM_ATTR_IFTYPES,
2098 iftype_akms->iftypes_mask))
2101 if (nla_put(msg, NL80211_IFTYPE_AKM_ATTR_SUITES,
2102 sizeof(u32) * iftype_akms->n_akm_suites,
2103 iftype_akms->akm_suites)) {
2106 nla_nest_end(msg, nested_akms);
2109 nla_nest_end(msg, nested);
2115 nl80211_put_tid_config_support(struct cfg80211_registered_device *rdev,
2116 struct sk_buff *msg)
2118 struct nlattr *supp;
2120 if (!rdev->wiphy.tid_config_support.vif &&
2121 !rdev->wiphy.tid_config_support.peer)
2124 supp = nla_nest_start(msg, NL80211_ATTR_TID_CONFIG);
2128 if (rdev->wiphy.tid_config_support.vif &&
2129 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_VIF_SUPP,
2130 rdev->wiphy.tid_config_support.vif,
2131 NL80211_TID_CONFIG_ATTR_PAD))
2134 if (rdev->wiphy.tid_config_support.peer &&
2135 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_PEER_SUPP,
2136 rdev->wiphy.tid_config_support.peer,
2137 NL80211_TID_CONFIG_ATTR_PAD))
2140 /* for now we just use the same value ... makes more sense */
2141 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_SHORT,
2142 rdev->wiphy.tid_config_support.max_retry))
2144 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_LONG,
2145 rdev->wiphy.tid_config_support.max_retry))
2148 nla_nest_end(msg, supp);
2152 nla_nest_cancel(msg, supp);
2157 nl80211_put_sar_specs(struct cfg80211_registered_device *rdev,
2158 struct sk_buff *msg)
2160 struct nlattr *sar_capa, *specs, *sub_freq_range;
2164 if (!rdev->wiphy.sar_capa)
2167 num_freq_ranges = rdev->wiphy.sar_capa->num_freq_ranges;
2169 sar_capa = nla_nest_start(msg, NL80211_ATTR_SAR_SPEC);
2173 if (nla_put_u32(msg, NL80211_SAR_ATTR_TYPE, rdev->wiphy.sar_capa->type))
2176 specs = nla_nest_start(msg, NL80211_SAR_ATTR_SPECS);
2180 /* report supported freq_ranges */
2181 for (i = 0; i < num_freq_ranges; i++) {
2182 sub_freq_range = nla_nest_start(msg, i + 1);
2183 if (!sub_freq_range)
2186 if (nla_put_u32(msg, NL80211_SAR_ATTR_SPECS_START_FREQ,
2187 rdev->wiphy.sar_capa->freq_ranges[i].start_freq))
2190 if (nla_put_u32(msg, NL80211_SAR_ATTR_SPECS_END_FREQ,
2191 rdev->wiphy.sar_capa->freq_ranges[i].end_freq))
2194 nla_nest_end(msg, sub_freq_range);
2197 nla_nest_end(msg, specs);
2198 nla_nest_end(msg, sar_capa);
2202 nla_nest_cancel(msg, sar_capa);
2206 struct nl80211_dump_wiphy_state {
2209 long split_start, band_start, chan_start, capa_start;
2213 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
2214 enum nl80211_commands cmd,
2215 struct sk_buff *msg, u32 portid, u32 seq,
2216 int flags, struct nl80211_dump_wiphy_state *state)
2219 struct nlattr *nl_bands, *nl_band;
2220 struct nlattr *nl_freqs, *nl_freq;
2221 struct nlattr *nl_cmds;
2222 enum nl80211_band band;
2223 struct ieee80211_channel *chan;
2225 const struct ieee80211_txrx_stypes *mgmt_stypes =
2226 rdev->wiphy.mgmt_stypes;
2229 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2233 if (WARN_ON(!state))
2236 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2237 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
2238 wiphy_name(&rdev->wiphy)) ||
2239 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2240 cfg80211_rdev_list_generation))
2241 goto nla_put_failure;
2243 if (cmd != NL80211_CMD_NEW_WIPHY)
2246 switch (state->split_start) {
2248 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
2249 rdev->wiphy.retry_short) ||
2250 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
2251 rdev->wiphy.retry_long) ||
2252 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
2253 rdev->wiphy.frag_threshold) ||
2254 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
2255 rdev->wiphy.rts_threshold) ||
2256 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
2257 rdev->wiphy.coverage_class) ||
2258 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
2259 rdev->wiphy.max_scan_ssids) ||
2260 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
2261 rdev->wiphy.max_sched_scan_ssids) ||
2262 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
2263 rdev->wiphy.max_scan_ie_len) ||
2264 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
2265 rdev->wiphy.max_sched_scan_ie_len) ||
2266 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
2267 rdev->wiphy.max_match_sets))
2268 goto nla_put_failure;
2270 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
2271 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
2272 goto nla_put_failure;
2273 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
2274 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
2275 goto nla_put_failure;
2276 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
2277 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
2278 goto nla_put_failure;
2279 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
2280 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
2281 goto nla_put_failure;
2282 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
2283 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
2284 goto nla_put_failure;
2285 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
2286 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
2287 goto nla_put_failure;
2288 state->split_start++;
2293 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
2294 sizeof(u32) * rdev->wiphy.n_cipher_suites,
2295 rdev->wiphy.cipher_suites))
2296 goto nla_put_failure;
2298 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
2299 rdev->wiphy.max_num_pmkids))
2300 goto nla_put_failure;
2302 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
2303 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
2304 goto nla_put_failure;
2306 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
2307 rdev->wiphy.available_antennas_tx) ||
2308 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
2309 rdev->wiphy.available_antennas_rx))
2310 goto nla_put_failure;
2312 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
2313 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
2314 rdev->wiphy.probe_resp_offload))
2315 goto nla_put_failure;
2317 if ((rdev->wiphy.available_antennas_tx ||
2318 rdev->wiphy.available_antennas_rx) &&
2319 rdev->ops->get_antenna) {
2320 u32 tx_ant = 0, rx_ant = 0;
2323 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
2325 if (nla_put_u32(msg,
2326 NL80211_ATTR_WIPHY_ANTENNA_TX,
2329 NL80211_ATTR_WIPHY_ANTENNA_RX,
2331 goto nla_put_failure;
2335 state->split_start++;
2340 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
2341 rdev->wiphy.interface_modes))
2342 goto nla_put_failure;
2343 state->split_start++;
2348 nl_bands = nla_nest_start_noflag(msg,
2349 NL80211_ATTR_WIPHY_BANDS);
2351 goto nla_put_failure;
2353 for (band = state->band_start;
2354 band < (state->split ?
2356 NL80211_BAND_60GHZ + 1);
2358 struct ieee80211_supported_band *sband;
2360 /* omit higher bands for ancient software */
2361 if (band > NL80211_BAND_5GHZ && !state->split)
2364 sband = rdev->wiphy.bands[band];
2369 nl_band = nla_nest_start_noflag(msg, band);
2371 goto nla_put_failure;
2373 switch (state->chan_start) {
2375 if (nl80211_send_band_rateinfo(msg, sband,
2377 goto nla_put_failure;
2378 state->chan_start++;
2383 /* add frequencies */
2384 nl_freqs = nla_nest_start_noflag(msg,
2385 NL80211_BAND_ATTR_FREQS);
2387 goto nla_put_failure;
2389 for (i = state->chan_start - 1;
2390 i < sband->n_channels;
2392 nl_freq = nla_nest_start_noflag(msg,
2395 goto nla_put_failure;
2397 chan = &sband->channels[i];
2399 if (nl80211_msg_put_channel(
2400 msg, &rdev->wiphy, chan,
2402 goto nla_put_failure;
2404 nla_nest_end(msg, nl_freq);
2408 if (i < sband->n_channels)
2409 state->chan_start = i + 2;
2411 state->chan_start = 0;
2412 nla_nest_end(msg, nl_freqs);
2415 nla_nest_end(msg, nl_band);
2418 /* start again here */
2419 if (state->chan_start)
2424 nla_nest_end(msg, nl_bands);
2426 if (band < NUM_NL80211_BANDS)
2427 state->band_start = band + 1;
2429 state->band_start = 0;
2431 /* if bands & channels are done, continue outside */
2432 if (state->band_start == 0 && state->chan_start == 0)
2433 state->split_start++;
2438 nl_cmds = nla_nest_start_noflag(msg,
2439 NL80211_ATTR_SUPPORTED_COMMANDS);
2441 goto nla_put_failure;
2443 i = nl80211_add_commands_unsplit(rdev, msg);
2445 goto nla_put_failure;
2447 CMD(crit_proto_start, CRIT_PROTOCOL_START);
2448 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
2449 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
2450 CMD(channel_switch, CHANNEL_SWITCH);
2451 CMD(set_qos_map, SET_QOS_MAP);
2452 if (rdev->wiphy.features &
2453 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
2454 CMD(add_tx_ts, ADD_TX_TS);
2455 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
2456 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
2457 CMD(update_ft_ies, UPDATE_FT_IES);
2458 if (rdev->wiphy.sar_capa)
2459 CMD(set_sar_specs, SET_SAR_SPECS);
2463 nla_nest_end(msg, nl_cmds);
2464 state->split_start++;
2469 if (rdev->ops->remain_on_channel &&
2470 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
2472 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
2473 rdev->wiphy.max_remain_on_channel_duration))
2474 goto nla_put_failure;
2476 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
2477 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
2478 goto nla_put_failure;
2480 state->split_start++;
2486 if (nl80211_send_wowlan(msg, rdev, state->split))
2487 goto nla_put_failure;
2488 state->split_start++;
2492 state->split_start++;
2496 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
2497 rdev->wiphy.software_iftypes))
2498 goto nla_put_failure;
2500 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
2502 goto nla_put_failure;
2504 state->split_start++;
2509 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
2510 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
2511 rdev->wiphy.ap_sme_capa))
2512 goto nla_put_failure;
2514 features = rdev->wiphy.features;
2516 * We can only add the per-channel limit information if the
2517 * dump is split, otherwise it makes it too big. Therefore
2518 * only advertise it in that case.
2521 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
2522 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
2523 goto nla_put_failure;
2525 if (rdev->wiphy.ht_capa_mod_mask &&
2526 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
2527 sizeof(*rdev->wiphy.ht_capa_mod_mask),
2528 rdev->wiphy.ht_capa_mod_mask))
2529 goto nla_put_failure;
2531 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
2532 rdev->wiphy.max_acl_mac_addrs &&
2533 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
2534 rdev->wiphy.max_acl_mac_addrs))
2535 goto nla_put_failure;
2538 * Any information below this point is only available to
2539 * applications that can deal with it being split. This
2540 * helps ensure that newly added capabilities don't break
2541 * older tools by overrunning their buffers.
2543 * We still increment split_start so that in the split
2544 * case we'll continue with more data in the next round,
2545 * but break unconditionally so unsplit data stops here.
2548 state->split_start++;
2550 state->split_start = 0;
2553 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
2554 goto nla_put_failure;
2556 if (nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
2557 rdev->wiphy.max_sched_scan_plans) ||
2558 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
2559 rdev->wiphy.max_sched_scan_plan_interval) ||
2560 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
2561 rdev->wiphy.max_sched_scan_plan_iterations))
2562 goto nla_put_failure;
2564 if (rdev->wiphy.extended_capabilities &&
2565 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
2566 rdev->wiphy.extended_capabilities_len,
2567 rdev->wiphy.extended_capabilities) ||
2568 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2569 rdev->wiphy.extended_capabilities_len,
2570 rdev->wiphy.extended_capabilities_mask)))
2571 goto nla_put_failure;
2573 if (rdev->wiphy.vht_capa_mod_mask &&
2574 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
2575 sizeof(*rdev->wiphy.vht_capa_mod_mask),
2576 rdev->wiphy.vht_capa_mod_mask))
2577 goto nla_put_failure;
2579 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
2580 rdev->wiphy.perm_addr))
2581 goto nla_put_failure;
2583 if (!is_zero_ether_addr(rdev->wiphy.addr_mask) &&
2584 nla_put(msg, NL80211_ATTR_MAC_MASK, ETH_ALEN,
2585 rdev->wiphy.addr_mask))
2586 goto nla_put_failure;
2588 if (rdev->wiphy.n_addresses > 1) {
2591 attr = nla_nest_start(msg, NL80211_ATTR_MAC_ADDRS);
2593 goto nla_put_failure;
2595 for (i = 0; i < rdev->wiphy.n_addresses; i++)
2596 if (nla_put(msg, i + 1, ETH_ALEN,
2597 rdev->wiphy.addresses[i].addr))
2598 goto nla_put_failure;
2600 nla_nest_end(msg, attr);
2603 state->split_start++;
2606 if (nl80211_send_coalesce(msg, rdev))
2607 goto nla_put_failure;
2609 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
2610 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
2611 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
2612 goto nla_put_failure;
2614 if (rdev->wiphy.max_ap_assoc_sta &&
2615 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
2616 rdev->wiphy.max_ap_assoc_sta))
2617 goto nla_put_failure;
2619 state->split_start++;
2622 if (rdev->wiphy.n_vendor_commands) {
2623 const struct nl80211_vendor_cmd_info *info;
2624 struct nlattr *nested;
2626 nested = nla_nest_start_noflag(msg,
2627 NL80211_ATTR_VENDOR_DATA);
2629 goto nla_put_failure;
2631 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
2632 info = &rdev->wiphy.vendor_commands[i].info;
2633 if (nla_put(msg, i + 1, sizeof(*info), info))
2634 goto nla_put_failure;
2636 nla_nest_end(msg, nested);
2639 if (rdev->wiphy.n_vendor_events) {
2640 const struct nl80211_vendor_cmd_info *info;
2641 struct nlattr *nested;
2643 nested = nla_nest_start_noflag(msg,
2644 NL80211_ATTR_VENDOR_EVENTS);
2646 goto nla_put_failure;
2648 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
2649 info = &rdev->wiphy.vendor_events[i];
2650 if (nla_put(msg, i + 1, sizeof(*info), info))
2651 goto nla_put_failure;
2653 nla_nest_end(msg, nested);
2655 state->split_start++;
2658 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
2659 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
2660 rdev->wiphy.max_num_csa_counters))
2661 goto nla_put_failure;
2663 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2664 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
2665 goto nla_put_failure;
2667 if (rdev->wiphy.max_sched_scan_reqs &&
2668 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
2669 rdev->wiphy.max_sched_scan_reqs))
2670 goto nla_put_failure;
2672 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
2673 sizeof(rdev->wiphy.ext_features),
2674 rdev->wiphy.ext_features))
2675 goto nla_put_failure;
2677 if (rdev->wiphy.bss_select_support) {
2678 struct nlattr *nested;
2679 u32 bss_select_support = rdev->wiphy.bss_select_support;
2681 nested = nla_nest_start_noflag(msg,
2682 NL80211_ATTR_BSS_SELECT);
2684 goto nla_put_failure;
2687 while (bss_select_support) {
2688 if ((bss_select_support & 1) &&
2689 nla_put_flag(msg, i))
2690 goto nla_put_failure;
2692 bss_select_support >>= 1;
2694 nla_nest_end(msg, nested);
2697 state->split_start++;
2700 if (rdev->wiphy.num_iftype_ext_capab &&
2701 rdev->wiphy.iftype_ext_capab) {
2702 struct nlattr *nested_ext_capab, *nested;
2704 nested = nla_nest_start_noflag(msg,
2705 NL80211_ATTR_IFTYPE_EXT_CAPA);
2707 goto nla_put_failure;
2709 for (i = state->capa_start;
2710 i < rdev->wiphy.num_iftype_ext_capab; i++) {
2711 const struct wiphy_iftype_ext_capab *capab;
2713 capab = &rdev->wiphy.iftype_ext_capab[i];
2715 nested_ext_capab = nla_nest_start_noflag(msg,
2717 if (!nested_ext_capab ||
2718 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
2720 nla_put(msg, NL80211_ATTR_EXT_CAPA,
2721 capab->extended_capabilities_len,
2722 capab->extended_capabilities) ||
2723 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2724 capab->extended_capabilities_len,
2725 capab->extended_capabilities_mask))
2726 goto nla_put_failure;
2728 nla_nest_end(msg, nested_ext_capab);
2732 nla_nest_end(msg, nested);
2733 if (i < rdev->wiphy.num_iftype_ext_capab) {
2734 state->capa_start = i + 1;
2739 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
2740 rdev->wiphy.nan_supported_bands))
2741 goto nla_put_failure;
2743 if (wiphy_ext_feature_isset(&rdev->wiphy,
2744 NL80211_EXT_FEATURE_TXQS)) {
2745 struct cfg80211_txq_stats txqstats = {};
2748 res = rdev_get_txq_stats(rdev, NULL, &txqstats);
2750 !nl80211_put_txq_stats(msg, &txqstats,
2751 NL80211_ATTR_TXQ_STATS))
2752 goto nla_put_failure;
2754 if (nla_put_u32(msg, NL80211_ATTR_TXQ_LIMIT,
2755 rdev->wiphy.txq_limit))
2756 goto nla_put_failure;
2757 if (nla_put_u32(msg, NL80211_ATTR_TXQ_MEMORY_LIMIT,
2758 rdev->wiphy.txq_memory_limit))
2759 goto nla_put_failure;
2760 if (nla_put_u32(msg, NL80211_ATTR_TXQ_QUANTUM,
2761 rdev->wiphy.txq_quantum))
2762 goto nla_put_failure;
2765 state->split_start++;
2768 if (nl80211_send_pmsr_capa(rdev, msg))
2769 goto nla_put_failure;
2771 state->split_start++;
2774 if (rdev->wiphy.akm_suites &&
2775 nla_put(msg, NL80211_ATTR_AKM_SUITES,
2776 sizeof(u32) * rdev->wiphy.n_akm_suites,
2777 rdev->wiphy.akm_suites))
2778 goto nla_put_failure;
2780 if (nl80211_put_iftype_akm_suites(rdev, msg))
2781 goto nla_put_failure;
2783 if (nl80211_put_tid_config_support(rdev, msg))
2784 goto nla_put_failure;
2785 state->split_start++;
2788 if (nl80211_put_sar_specs(rdev, msg))
2789 goto nla_put_failure;
2792 state->split_start = 0;
2796 genlmsg_end(msg, hdr);
2800 genlmsg_cancel(msg, hdr);
2804 static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
2805 struct netlink_callback *cb,
2806 struct nl80211_dump_wiphy_state *state)
2808 struct nlattr **tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
2814 ret = nlmsg_parse_deprecated(cb->nlh,
2815 GENL_HDRLEN + nl80211_fam.hdrsize,
2816 tb, nl80211_fam.maxattr,
2817 nl80211_policy, NULL);
2818 /* ignore parse errors for backward compatibility */
2824 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
2825 if (tb[NL80211_ATTR_WIPHY])
2826 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2827 if (tb[NL80211_ATTR_WDEV])
2828 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
2829 if (tb[NL80211_ATTR_IFINDEX]) {
2830 struct net_device *netdev;
2831 struct cfg80211_registered_device *rdev;
2832 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
2834 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
2839 if (netdev->ieee80211_ptr) {
2840 rdev = wiphy_to_rdev(
2841 netdev->ieee80211_ptr->wiphy);
2842 state->filter_wiphy = rdev->wiphy_idx;
2852 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
2855 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
2856 struct cfg80211_registered_device *rdev;
2860 state = kzalloc(sizeof(*state), GFP_KERNEL);
2865 state->filter_wiphy = -1;
2866 ret = nl80211_dump_wiphy_parse(skb, cb, state);
2872 cb->args[0] = (long)state;
2875 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2876 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2878 if (++idx <= state->start)
2880 if (state->filter_wiphy != -1 &&
2881 state->filter_wiphy != rdev->wiphy_idx)
2883 /* attempt to fit multiple wiphy data chunks into the skb */
2885 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
2887 NETLINK_CB(cb->skb).portid,
2889 NLM_F_MULTI, state);
2892 * If sending the wiphy data didn't fit (ENOBUFS
2893 * or EMSGSIZE returned), this SKB is still
2894 * empty (so it's not too big because another
2895 * wiphy dataset is already in the skb) and
2896 * we've not tried to adjust the dump allocation
2897 * yet ... then adjust the alloc size to be
2898 * bigger, and return 1 but with the empty skb.
2899 * This results in an empty message being RX'ed
2900 * in userspace, but that is ignored.
2902 * We can then retry with the larger buffer.
2904 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
2905 !skb->len && !state->split &&
2906 cb->min_dump_alloc < 4096) {
2907 cb->min_dump_alloc = 4096;
2908 state->split_start = 0;
2915 } while (state->split_start > 0);
2925 static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2927 kfree((void *)cb->args[0]);
2931 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2933 struct sk_buff *msg;
2934 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2935 struct nl80211_dump_wiphy_state state = {};
2937 msg = nlmsg_new(4096, GFP_KERNEL);
2941 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2942 info->snd_portid, info->snd_seq, 0,
2948 return genlmsg_reply(msg, info);
2951 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2952 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2953 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2954 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2955 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2956 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2959 static int parse_txq_params(struct nlattr *tb[],
2960 struct ieee80211_txq_params *txq_params)
2964 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
2965 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2966 !tb[NL80211_TXQ_ATTR_AIFS])
2969 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
2970 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2971 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2972 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2973 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2975 if (ac >= NL80211_NUM_ACS)
2977 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
2981 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2984 * You can only set the channel explicitly for some interfaces,
2985 * most have their channel managed via their respective
2986 * "establish a connection" command (connect, join, ...)
2988 * For AP/GO and mesh mode, the channel can be set with the
2989 * channel userspace API, but is only stored and passed to the
2990 * low-level driver when the AP starts or the mesh is joined.
2991 * This is for backward compatibility, userspace can also give
2992 * the channel in the start-ap or join-mesh commands instead.
2994 * Monitors are special as they are normally slaved to
2995 * whatever else is going on, so they have their own special
2996 * operation to set the monitor channel if possible.
2999 wdev->iftype == NL80211_IFTYPE_AP ||
3000 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
3001 wdev->iftype == NL80211_IFTYPE_MONITOR ||
3002 wdev->iftype == NL80211_IFTYPE_P2P_GO;
3005 int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
3006 struct genl_info *info,
3007 struct cfg80211_chan_def *chandef)
3009 struct netlink_ext_ack *extack = info->extack;
3010 struct nlattr **attrs = info->attrs;
3013 if (!attrs[NL80211_ATTR_WIPHY_FREQ])
3016 control_freq = MHZ_TO_KHZ(
3017 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3018 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
3020 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
3022 memset(chandef, 0, sizeof(*chandef));
3023 chandef->chan = ieee80211_get_channel_khz(&rdev->wiphy, control_freq);
3024 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
3025 chandef->center_freq1 = KHZ_TO_MHZ(control_freq);
3026 chandef->freq1_offset = control_freq % 1000;
3027 chandef->center_freq2 = 0;
3029 /* Primary channel not allowed */
3030 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED) {
3031 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ],
3032 "Channel is disabled");
3036 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
3037 enum nl80211_channel_type chantype;
3039 chantype = nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
3042 case NL80211_CHAN_NO_HT:
3043 case NL80211_CHAN_HT20:
3044 case NL80211_CHAN_HT40PLUS:
3045 case NL80211_CHAN_HT40MINUS:
3046 cfg80211_chandef_create(chandef, chandef->chan,
3048 /* user input for center_freq is incorrect */
3049 if (attrs[NL80211_ATTR_CENTER_FREQ1] &&
3050 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) {
3051 NL_SET_ERR_MSG_ATTR(extack,
3052 attrs[NL80211_ATTR_CENTER_FREQ1],
3053 "bad center frequency 1");
3056 /* center_freq2 must be zero */
3057 if (attrs[NL80211_ATTR_CENTER_FREQ2] &&
3058 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2])) {
3059 NL_SET_ERR_MSG_ATTR(extack,
3060 attrs[NL80211_ATTR_CENTER_FREQ2],
3061 "center frequency 2 can't be used");
3066 NL_SET_ERR_MSG_ATTR(extack,
3067 attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
3068 "invalid channel type");
3071 } else if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
3073 nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]);
3074 if (attrs[NL80211_ATTR_CENTER_FREQ1]) {
3075 chandef->center_freq1 =
3076 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]);
3077 if (attrs[NL80211_ATTR_CENTER_FREQ1_OFFSET])
3078 chandef->freq1_offset = nla_get_u32(
3079 attrs[NL80211_ATTR_CENTER_FREQ1_OFFSET]);
3081 chandef->freq1_offset = 0;
3083 if (attrs[NL80211_ATTR_CENTER_FREQ2])
3084 chandef->center_freq2 =
3085 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]);
3088 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
3089 chandef->edmg.channels =
3090 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
3092 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
3093 chandef->edmg.bw_config =
3094 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
3096 chandef->edmg.bw_config = 0;
3097 chandef->edmg.channels = 0;
3100 if (!cfg80211_chandef_valid(chandef)) {
3101 NL_SET_ERR_MSG(extack, "invalid channel definition");
3105 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
3106 IEEE80211_CHAN_DISABLED)) {
3107 NL_SET_ERR_MSG(extack, "(extension) channel is disabled");
3111 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
3112 chandef->width == NL80211_CHAN_WIDTH_10) &&
3113 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) {
3114 NL_SET_ERR_MSG(extack, "5/10 MHz not supported");
3121 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
3122 struct net_device *dev,
3123 struct genl_info *info)
3125 struct cfg80211_chan_def chandef;
3127 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
3128 struct wireless_dev *wdev = NULL;
3131 wdev = dev->ieee80211_ptr;
3132 if (!nl80211_can_set_dev_channel(wdev))
3135 iftype = wdev->iftype;
3137 result = nl80211_parse_chandef(rdev, info, &chandef);
3142 case NL80211_IFTYPE_AP:
3143 case NL80211_IFTYPE_P2P_GO:
3144 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
3149 if (wdev->beacon_interval) {
3150 if (!dev || !rdev->ops->set_ap_chanwidth ||
3151 !(rdev->wiphy.features &
3152 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
3157 /* Only allow dynamic channel width changes */
3158 if (chandef.chan != wdev->preset_chandef.chan) {
3162 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
3166 wdev->preset_chandef = chandef;
3169 case NL80211_IFTYPE_MESH_POINT:
3170 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
3172 case NL80211_IFTYPE_MONITOR:
3173 result = cfg80211_set_monitor_channel(rdev, &chandef);
3182 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
3184 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3185 struct net_device *netdev = info->user_ptr[1];
3187 return __nl80211_set_channel(rdev, netdev, info);
3190 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
3192 struct cfg80211_registered_device *rdev = NULL;
3193 struct net_device *netdev = NULL;
3194 struct wireless_dev *wdev;
3195 int result = 0, rem_txq_params = 0;
3196 struct nlattr *nl_txq_params;
3198 u8 retry_short = 0, retry_long = 0;
3199 u32 frag_threshold = 0, rts_threshold = 0;
3200 u8 coverage_class = 0;
3201 u32 txq_limit = 0, txq_memory_limit = 0, txq_quantum = 0;
3205 * Try to find the wiphy and netdev. Normally this
3206 * function shouldn't need the netdev, but this is
3207 * done for backward compatibility -- previously
3208 * setting the channel was done per wiphy, but now
3209 * it is per netdev. Previous userland like hostapd
3210 * also passed a netdev to set_wiphy, so that it is
3211 * possible to let that go to the right netdev!
3214 if (info->attrs[NL80211_ATTR_IFINDEX]) {
3215 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
3217 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
3218 if (netdev && netdev->ieee80211_ptr)
3219 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
3225 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
3229 return PTR_ERR(rdev);
3235 wdev = netdev->ieee80211_ptr;
3237 wiphy_lock(&rdev->wiphy);
3240 * end workaround code, by now the rdev is available
3241 * and locked, and wdev may or may not be NULL.
3244 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
3245 result = cfg80211_dev_rename(
3246 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
3252 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
3253 struct ieee80211_txq_params txq_params;
3254 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
3256 if (!rdev->ops->set_txq_params) {
3257 result = -EOPNOTSUPP;
3266 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3267 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
3272 if (!netif_running(netdev)) {
3277 nla_for_each_nested(nl_txq_params,
3278 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
3280 result = nla_parse_nested_deprecated(tb,
3281 NL80211_TXQ_ATTR_MAX,
3287 result = parse_txq_params(tb, &txq_params);
3291 result = rdev_set_txq_params(rdev, netdev,
3298 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3299 result = __nl80211_set_channel(
3301 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
3307 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
3308 struct wireless_dev *txp_wdev = wdev;
3309 enum nl80211_tx_power_setting type;
3312 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
3315 if (!rdev->ops->set_tx_power) {
3316 result = -EOPNOTSUPP;
3320 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
3321 type = nla_get_u32(info->attrs[idx]);
3323 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
3324 (type != NL80211_TX_POWER_AUTOMATIC)) {
3329 if (type != NL80211_TX_POWER_AUTOMATIC) {
3330 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
3331 mbm = nla_get_u32(info->attrs[idx]);
3334 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
3339 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
3340 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
3343 if ((!rdev->wiphy.available_antennas_tx &&
3344 !rdev->wiphy.available_antennas_rx) ||
3345 !rdev->ops->set_antenna) {
3346 result = -EOPNOTSUPP;
3350 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
3351 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
3353 /* reject antenna configurations which don't match the
3354 * available antenna masks, except for the "all" mask */
3355 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
3356 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) {
3361 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
3362 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
3364 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
3371 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
3372 retry_short = nla_get_u8(
3373 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
3375 changed |= WIPHY_PARAM_RETRY_SHORT;
3378 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
3379 retry_long = nla_get_u8(
3380 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
3382 changed |= WIPHY_PARAM_RETRY_LONG;
3385 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
3386 frag_threshold = nla_get_u32(
3387 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
3388 if (frag_threshold < 256) {
3393 if (frag_threshold != (u32) -1) {
3395 * Fragments (apart from the last one) are required to
3396 * have even length. Make the fragmentation code
3397 * simpler by stripping LSB should someone try to use
3398 * odd threshold value.
3400 frag_threshold &= ~0x1;
3402 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
3405 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
3406 rts_threshold = nla_get_u32(
3407 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
3408 changed |= WIPHY_PARAM_RTS_THRESHOLD;
3411 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3412 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
3417 coverage_class = nla_get_u8(
3418 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
3419 changed |= WIPHY_PARAM_COVERAGE_CLASS;
3422 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
3423 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION)) {
3424 result = -EOPNOTSUPP;
3428 changed |= WIPHY_PARAM_DYN_ACK;
3431 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) {
3432 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3433 NL80211_EXT_FEATURE_TXQS)) {
3434 result = -EOPNOTSUPP;
3437 txq_limit = nla_get_u32(
3438 info->attrs[NL80211_ATTR_TXQ_LIMIT]);
3439 changed |= WIPHY_PARAM_TXQ_LIMIT;
3442 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) {
3443 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3444 NL80211_EXT_FEATURE_TXQS)) {
3445 result = -EOPNOTSUPP;
3448 txq_memory_limit = nla_get_u32(
3449 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]);
3450 changed |= WIPHY_PARAM_TXQ_MEMORY_LIMIT;
3453 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) {
3454 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3455 NL80211_EXT_FEATURE_TXQS)) {
3456 result = -EOPNOTSUPP;
3459 txq_quantum = nla_get_u32(
3460 info->attrs[NL80211_ATTR_TXQ_QUANTUM]);
3461 changed |= WIPHY_PARAM_TXQ_QUANTUM;
3465 u8 old_retry_short, old_retry_long;
3466 u32 old_frag_threshold, old_rts_threshold;
3467 u8 old_coverage_class;
3468 u32 old_txq_limit, old_txq_memory_limit, old_txq_quantum;
3470 if (!rdev->ops->set_wiphy_params) {
3471 result = -EOPNOTSUPP;
3475 old_retry_short = rdev->wiphy.retry_short;
3476 old_retry_long = rdev->wiphy.retry_long;
3477 old_frag_threshold = rdev->wiphy.frag_threshold;
3478 old_rts_threshold = rdev->wiphy.rts_threshold;
3479 old_coverage_class = rdev->wiphy.coverage_class;
3480 old_txq_limit = rdev->wiphy.txq_limit;
3481 old_txq_memory_limit = rdev->wiphy.txq_memory_limit;
3482 old_txq_quantum = rdev->wiphy.txq_quantum;
3484 if (changed & WIPHY_PARAM_RETRY_SHORT)
3485 rdev->wiphy.retry_short = retry_short;
3486 if (changed & WIPHY_PARAM_RETRY_LONG)
3487 rdev->wiphy.retry_long = retry_long;
3488 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
3489 rdev->wiphy.frag_threshold = frag_threshold;
3490 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
3491 rdev->wiphy.rts_threshold = rts_threshold;
3492 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
3493 rdev->wiphy.coverage_class = coverage_class;
3494 if (changed & WIPHY_PARAM_TXQ_LIMIT)
3495 rdev->wiphy.txq_limit = txq_limit;
3496 if (changed & WIPHY_PARAM_TXQ_MEMORY_LIMIT)
3497 rdev->wiphy.txq_memory_limit = txq_memory_limit;
3498 if (changed & WIPHY_PARAM_TXQ_QUANTUM)
3499 rdev->wiphy.txq_quantum = txq_quantum;
3501 result = rdev_set_wiphy_params(rdev, changed);
3503 rdev->wiphy.retry_short = old_retry_short;
3504 rdev->wiphy.retry_long = old_retry_long;
3505 rdev->wiphy.frag_threshold = old_frag_threshold;
3506 rdev->wiphy.rts_threshold = old_rts_threshold;
3507 rdev->wiphy.coverage_class = old_coverage_class;
3508 rdev->wiphy.txq_limit = old_txq_limit;
3509 rdev->wiphy.txq_memory_limit = old_txq_memory_limit;
3510 rdev->wiphy.txq_quantum = old_txq_quantum;
3518 wiphy_unlock(&rdev->wiphy);
3522 static int nl80211_send_chandef(struct sk_buff *msg,
3523 const struct cfg80211_chan_def *chandef)
3525 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3528 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
3529 chandef->chan->center_freq))
3531 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET,
3532 chandef->chan->freq_offset))
3534 switch (chandef->width) {
3535 case NL80211_CHAN_WIDTH_20_NOHT:
3536 case NL80211_CHAN_WIDTH_20:
3537 case NL80211_CHAN_WIDTH_40:
3538 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
3539 cfg80211_get_chandef_type(chandef)))
3545 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
3547 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
3549 if (chandef->center_freq2 &&
3550 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
3555 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
3556 struct cfg80211_registered_device *rdev,
3557 struct wireless_dev *wdev,
3558 enum nl80211_commands cmd)
3560 struct net_device *dev = wdev->netdev;
3563 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
3564 cmd != NL80211_CMD_DEL_INTERFACE &&
3565 cmd != NL80211_CMD_SET_INTERFACE);
3567 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3572 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3573 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
3574 goto nla_put_failure;
3576 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3577 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
3578 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
3579 NL80211_ATTR_PAD) ||
3580 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
3581 nla_put_u32(msg, NL80211_ATTR_GENERATION,
3582 rdev->devlist_generation ^
3583 (cfg80211_rdev_list_generation << 2)) ||
3584 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr))
3585 goto nla_put_failure;
3587 if (rdev->ops->get_channel) {
3589 struct cfg80211_chan_def chandef = {};
3591 ret = rdev_get_channel(rdev, wdev, &chandef);
3593 if (nl80211_send_chandef(msg, &chandef))
3594 goto nla_put_failure;
3598 if (rdev->ops->get_tx_power) {
3601 ret = rdev_get_tx_power(rdev, wdev, &dbm);
3603 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
3605 goto nla_put_failure;
3609 switch (wdev->iftype) {
3610 case NL80211_IFTYPE_AP:
3611 if (wdev->ssid_len &&
3612 nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
3613 goto nla_put_failure_locked;
3615 case NL80211_IFTYPE_STATION:
3616 case NL80211_IFTYPE_P2P_CLIENT:
3617 case NL80211_IFTYPE_ADHOC: {
3619 if (!wdev->current_bss)
3622 ssid_ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
3625 nla_put(msg, NL80211_ATTR_SSID, ssid_ie[1], ssid_ie + 2))
3626 goto nla_put_failure_rcu_locked;
3636 if (rdev->ops->get_txq_stats) {
3637 struct cfg80211_txq_stats txqstats = {};
3638 int ret = rdev_get_txq_stats(rdev, wdev, &txqstats);
3641 !nl80211_put_txq_stats(msg, &txqstats,
3642 NL80211_ATTR_TXQ_STATS))
3643 goto nla_put_failure;
3646 genlmsg_end(msg, hdr);
3649 nla_put_failure_rcu_locked:
3651 nla_put_failure_locked:
3654 genlmsg_cancel(msg, hdr);
3658 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
3662 int wp_start = cb->args[0];
3663 int if_start = cb->args[1];
3664 int filter_wiphy = -1;
3665 struct cfg80211_registered_device *rdev;
3666 struct wireless_dev *wdev;
3671 struct nl80211_dump_wiphy_state state = {
3675 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
3679 filter_wiphy = state.filter_wiphy;
3682 * if filtering, set cb->args[2] to +1 since 0 is the default
3683 * value needed to determine that parsing is necessary.
3685 if (filter_wiphy >= 0)
3686 cb->args[2] = filter_wiphy + 1;
3689 } else if (cb->args[2] > 0) {
3690 filter_wiphy = cb->args[2] - 1;
3693 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3694 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3696 if (wp_idx < wp_start) {
3701 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
3706 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3707 if (if_idx < if_start) {
3711 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
3712 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3714 NL80211_CMD_NEW_INTERFACE) < 0) {
3723 cb->args[0] = wp_idx;
3724 cb->args[1] = if_idx;
3733 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
3735 struct sk_buff *msg;
3736 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3737 struct wireless_dev *wdev = info->user_ptr[1];
3739 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3743 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3744 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3749 return genlmsg_reply(msg, info);
3752 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
3753 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
3754 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
3755 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
3756 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
3757 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
3758 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
3761 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
3763 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
3771 if (nla_parse_nested_deprecated(flags, NL80211_MNTR_FLAG_MAX, nla, mntr_flags_policy, NULL))
3774 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
3776 *mntrflags |= (1<<flag);
3778 *mntrflags |= MONITOR_FLAG_CHANGED;
3783 static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
3784 enum nl80211_iftype type,
3785 struct genl_info *info,
3786 struct vif_params *params)
3788 bool change = false;
3791 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
3792 if (type != NL80211_IFTYPE_MONITOR)
3795 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
3803 if (params->flags & MONITOR_FLAG_ACTIVE &&
3804 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
3807 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
3808 const u8 *mumimo_groups;
3809 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3811 if (type != NL80211_IFTYPE_MONITOR)
3814 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3818 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
3820 /* bits 0 and 63 are reserved and must be zero */
3821 if ((mumimo_groups[0] & BIT(0)) ||
3822 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
3825 params->vht_mumimo_groups = mumimo_groups;
3829 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
3830 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3832 if (type != NL80211_IFTYPE_MONITOR)
3835 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3838 params->vht_mumimo_follow_addr =
3839 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
3843 return change ? 1 : 0;
3846 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
3847 struct net_device *netdev, u8 use_4addr,
3848 enum nl80211_iftype iftype)
3851 if (netdev && netif_is_bridge_port(netdev))
3857 case NL80211_IFTYPE_AP_VLAN:
3858 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
3861 case NL80211_IFTYPE_STATION:
3862 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
3872 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
3874 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3875 struct vif_params params;
3877 enum nl80211_iftype otype, ntype;
3878 struct net_device *dev = info->user_ptr[1];
3879 bool change = false;
3881 memset(¶ms, 0, sizeof(params));
3883 otype = ntype = dev->ieee80211_ptr->iftype;
3885 if (info->attrs[NL80211_ATTR_IFTYPE]) {
3886 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3891 if (info->attrs[NL80211_ATTR_MESH_ID]) {
3892 struct wireless_dev *wdev = dev->ieee80211_ptr;
3894 if (ntype != NL80211_IFTYPE_MESH_POINT)
3896 if (netif_running(dev))
3900 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3901 IEEE80211_MAX_MESH_ID_LEN);
3902 wdev->mesh_id_up_len =
3903 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3904 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3905 wdev->mesh_id_up_len);
3909 if (info->attrs[NL80211_ATTR_4ADDR]) {
3910 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3912 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
3916 params.use_4addr = -1;
3919 err = nl80211_parse_mon_options(rdev, ntype, info, ¶ms);
3926 err = cfg80211_change_iface(rdev, dev, ntype, ¶ms);
3930 if (!err && params.use_4addr != -1)
3931 dev->ieee80211_ptr->use_4addr = params.use_4addr;
3933 if (change && !err) {
3934 struct wireless_dev *wdev = dev->ieee80211_ptr;
3936 nl80211_notify_iface(rdev, wdev, NL80211_CMD_SET_INTERFACE);
3942 static int _nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
3944 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3945 struct vif_params params;
3946 struct wireless_dev *wdev;
3947 struct sk_buff *msg;
3949 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
3951 memset(¶ms, 0, sizeof(params));
3953 if (!info->attrs[NL80211_ATTR_IFNAME])
3956 if (info->attrs[NL80211_ATTR_IFTYPE])
3957 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3959 if (!rdev->ops->add_virtual_intf)
3962 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
3963 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
3964 info->attrs[NL80211_ATTR_MAC]) {
3965 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
3967 if (!is_valid_ether_addr(params.macaddr))
3968 return -EADDRNOTAVAIL;
3971 if (info->attrs[NL80211_ATTR_4ADDR]) {
3972 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3973 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
3978 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0))
3981 err = nl80211_parse_mon_options(rdev, type, info, ¶ms);
3985 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3989 wdev = rdev_add_virtual_intf(rdev,
3990 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
3991 NET_NAME_USER, type, ¶ms);
3992 if (WARN_ON(!wdev)) {
3995 } else if (IS_ERR(wdev)) {
3997 return PTR_ERR(wdev);
4000 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
4001 wdev->owner_nlportid = info->snd_portid;
4004 case NL80211_IFTYPE_MESH_POINT:
4005 if (!info->attrs[NL80211_ATTR_MESH_ID])
4008 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
4009 IEEE80211_MAX_MESH_ID_LEN);
4010 wdev->mesh_id_up_len =
4011 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
4012 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
4013 wdev->mesh_id_up_len);
4016 case NL80211_IFTYPE_NAN:
4017 case NL80211_IFTYPE_P2P_DEVICE:
4019 * P2P Device and NAN do not have a netdev, so don't go
4020 * through the netdev notifier and must be added here
4022 cfg80211_init_wdev(wdev);
4023 cfg80211_register_wdev(rdev, wdev);
4029 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
4030 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
4035 return genlmsg_reply(msg, info);
4038 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
4040 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4043 /* to avoid failing a new interface creation due to pending removal */
4044 cfg80211_destroy_ifaces(rdev);
4046 wiphy_lock(&rdev->wiphy);
4047 ret = _nl80211_new_interface(skb, info);
4048 wiphy_unlock(&rdev->wiphy);
4053 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
4055 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4056 struct wireless_dev *wdev = info->user_ptr[1];
4058 if (!rdev->ops->del_virtual_intf)
4062 * We hold RTNL, so this is safe, without RTNL opencount cannot
4063 * reach 0, and thus the rdev cannot be deleted.
4065 * We need to do it for the dev_close(), since that will call
4066 * the netdev notifiers, and we need to acquire the mutex there
4067 * but don't know if we get there from here or from some other
4068 * place (e.g. "ip link set ... down").
4070 mutex_unlock(&rdev->wiphy.mtx);
4073 * If we remove a wireless device without a netdev then clear
4074 * user_ptr[1] so that nl80211_post_doit won't dereference it
4075 * to check if it needs to do dev_put(). Otherwise it crashes
4076 * since the wdev has been freed, unlike with a netdev where
4077 * we need the dev_put() for the netdev to really be freed.
4080 info->user_ptr[1] = NULL;
4082 dev_close(wdev->netdev);
4084 mutex_lock(&rdev->wiphy.mtx);
4086 return rdev_del_virtual_intf(rdev, wdev);
4089 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
4091 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4092 struct net_device *dev = info->user_ptr[1];
4095 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
4098 if (!rdev->ops->set_noack_map)
4101 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
4103 return rdev_set_noack_map(rdev, dev, noack_map);
4106 struct get_key_cookie {
4107 struct sk_buff *msg;
4112 static void get_key_callback(void *c, struct key_params *params)
4115 struct get_key_cookie *cookie = c;
4118 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
4119 params->key_len, params->key)) ||
4121 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
4122 params->seq_len, params->seq)) ||
4124 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
4126 goto nla_put_failure;
4128 key = nla_nest_start_noflag(cookie->msg, NL80211_ATTR_KEY);
4130 goto nla_put_failure;
4133 nla_put(cookie->msg, NL80211_KEY_DATA,
4134 params->key_len, params->key)) ||
4136 nla_put(cookie->msg, NL80211_KEY_SEQ,
4137 params->seq_len, params->seq)) ||
4139 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
4141 goto nla_put_failure;
4143 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
4144 goto nla_put_failure;
4146 nla_nest_end(cookie->msg, key);
4153 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
4155 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4157 struct net_device *dev = info->user_ptr[1];
4159 const u8 *mac_addr = NULL;
4161 struct get_key_cookie cookie = {
4165 struct sk_buff *msg;
4166 bool bigtk_support = false;
4168 if (wiphy_ext_feature_isset(&rdev->wiphy,
4169 NL80211_EXT_FEATURE_BEACON_PROTECTION))
4170 bigtk_support = true;
4172 if ((dev->ieee80211_ptr->iftype == NL80211_IFTYPE_STATION ||
4173 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
4174 wiphy_ext_feature_isset(&rdev->wiphy,
4175 NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT))
4176 bigtk_support = true;
4178 if (info->attrs[NL80211_ATTR_KEY_IDX]) {
4179 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
4181 if (key_idx >= 6 && key_idx <= 7 && !bigtk_support) {
4182 GENL_SET_ERR_MSG(info, "BIGTK not supported");
4187 if (info->attrs[NL80211_ATTR_MAC])
4188 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4190 pairwise = !!mac_addr;
4191 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
4192 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
4194 if (kt != NL80211_KEYTYPE_GROUP &&
4195 kt != NL80211_KEYTYPE_PAIRWISE)
4197 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
4200 if (!rdev->ops->get_key)
4203 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
4206 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4210 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4211 NL80211_CMD_NEW_KEY);
4213 goto nla_put_failure;
4216 cookie.idx = key_idx;
4218 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4219 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
4220 goto nla_put_failure;
4222 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
4223 goto nla_put_failure;
4225 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
4232 goto nla_put_failure;
4234 genlmsg_end(msg, hdr);
4235 return genlmsg_reply(msg, info);
4244 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
4246 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4247 struct key_parse key;
4249 struct net_device *dev = info->user_ptr[1];
4251 err = nl80211_parse_key(info, &key);
4258 /* Only support setting default key and
4259 * Extended Key ID action NL80211_KEY_SET_TX.
4261 if (!key.def && !key.defmgmt && !key.defbeacon &&
4262 !(key.p.mode == NL80211_KEY_SET_TX))
4265 wdev_lock(dev->ieee80211_ptr);
4268 if (!rdev->ops->set_default_key) {
4273 err = nl80211_key_allowed(dev->ieee80211_ptr);
4277 err = rdev_set_default_key(rdev, dev, key.idx,
4278 key.def_uni, key.def_multi);
4283 #ifdef CONFIG_CFG80211_WEXT
4284 dev->ieee80211_ptr->wext.default_key = key.idx;
4286 } else if (key.defmgmt) {
4287 if (key.def_uni || !key.def_multi) {
4292 if (!rdev->ops->set_default_mgmt_key) {
4297 err = nl80211_key_allowed(dev->ieee80211_ptr);
4301 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
4305 #ifdef CONFIG_CFG80211_WEXT
4306 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
4308 } else if (key.defbeacon) {
4309 if (key.def_uni || !key.def_multi) {
4314 if (!rdev->ops->set_default_beacon_key) {
4319 err = nl80211_key_allowed(dev->ieee80211_ptr);
4323 err = rdev_set_default_beacon_key(rdev, dev, key.idx);
4326 } else if (key.p.mode == NL80211_KEY_SET_TX &&
4327 wiphy_ext_feature_isset(&rdev->wiphy,
4328 NL80211_EXT_FEATURE_EXT_KEY_ID)) {
4329 u8 *mac_addr = NULL;
4331 if (info->attrs[NL80211_ATTR_MAC])
4332 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4334 if (!mac_addr || key.idx < 0 || key.idx > 1) {
4339 err = rdev_add_key(rdev, dev, key.idx,
4340 NL80211_KEYTYPE_PAIRWISE,
4346 wdev_unlock(dev->ieee80211_ptr);
4351 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
4353 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4355 struct net_device *dev = info->user_ptr[1];
4356 struct key_parse key;
4357 const u8 *mac_addr = NULL;
4359 err = nl80211_parse_key(info, &key);
4364 GENL_SET_ERR_MSG(info, "no key");
4368 if (info->attrs[NL80211_ATTR_MAC])
4369 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4371 if (key.type == -1) {
4373 key.type = NL80211_KEYTYPE_PAIRWISE;
4375 key.type = NL80211_KEYTYPE_GROUP;
4379 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
4380 key.type != NL80211_KEYTYPE_GROUP) {
4381 GENL_SET_ERR_MSG(info, "key type not pairwise or group");
4385 if (key.type == NL80211_KEYTYPE_GROUP &&
4386 info->attrs[NL80211_ATTR_VLAN_ID])
4387 key.p.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
4389 if (!rdev->ops->add_key)
4392 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
4393 key.type == NL80211_KEYTYPE_PAIRWISE,
4395 GENL_SET_ERR_MSG(info, "key setting validation failed");
4399 wdev_lock(dev->ieee80211_ptr);
4400 err = nl80211_key_allowed(dev->ieee80211_ptr);
4402 GENL_SET_ERR_MSG(info, "key not allowed");
4404 err = rdev_add_key(rdev, dev, key.idx,
4405 key.type == NL80211_KEYTYPE_PAIRWISE,
4408 GENL_SET_ERR_MSG(info, "key addition failed");
4410 wdev_unlock(dev->ieee80211_ptr);
4415 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
4417 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4419 struct net_device *dev = info->user_ptr[1];
4420 u8 *mac_addr = NULL;
4421 struct key_parse key;
4423 err = nl80211_parse_key(info, &key);
4427 if (info->attrs[NL80211_ATTR_MAC])
4428 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4430 if (key.type == -1) {
4432 key.type = NL80211_KEYTYPE_PAIRWISE;
4434 key.type = NL80211_KEYTYPE_GROUP;
4438 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
4439 key.type != NL80211_KEYTYPE_GROUP)
4442 if (!cfg80211_valid_key_idx(rdev, key.idx,
4443 key.type == NL80211_KEYTYPE_PAIRWISE))
4446 if (!rdev->ops->del_key)
4449 wdev_lock(dev->ieee80211_ptr);
4450 err = nl80211_key_allowed(dev->ieee80211_ptr);
4452 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
4453 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
4457 err = rdev_del_key(rdev, dev, key.idx,
4458 key.type == NL80211_KEYTYPE_PAIRWISE,
4461 #ifdef CONFIG_CFG80211_WEXT
4463 if (key.idx == dev->ieee80211_ptr->wext.default_key)
4464 dev->ieee80211_ptr->wext.default_key = -1;
4465 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
4466 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
4469 wdev_unlock(dev->ieee80211_ptr);
4474 /* This function returns an error or the number of nested attributes */
4475 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
4477 struct nlattr *attr;
4478 int n_entries = 0, tmp;
4480 nla_for_each_nested(attr, nl_attr, tmp) {
4481 if (nla_len(attr) != ETH_ALEN)
4491 * This function parses ACL information and allocates memory for ACL data.
4492 * On successful return, the calling function is responsible to free the
4493 * ACL buffer returned by this function.
4495 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
4496 struct genl_info *info)
4498 enum nl80211_acl_policy acl_policy;
4499 struct nlattr *attr;
4500 struct cfg80211_acl_data *acl;
4501 int i = 0, n_entries, tmp;
4503 if (!wiphy->max_acl_mac_addrs)
4504 return ERR_PTR(-EOPNOTSUPP);
4506 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
4507 return ERR_PTR(-EINVAL);
4509 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
4510 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
4511 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
4512 return ERR_PTR(-EINVAL);
4514 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
4515 return ERR_PTR(-EINVAL);
4517 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
4519 return ERR_PTR(n_entries);
4521 if (n_entries > wiphy->max_acl_mac_addrs)
4522 return ERR_PTR(-ENOTSUPP);
4524 acl = kzalloc(struct_size(acl, mac_addrs, n_entries), GFP_KERNEL);
4526 return ERR_PTR(-ENOMEM);
4528 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
4529 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
4533 acl->n_acl_entries = n_entries;
4534 acl->acl_policy = acl_policy;
4539 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
4541 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4542 struct net_device *dev = info->user_ptr[1];
4543 struct cfg80211_acl_data *acl;
4546 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4547 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4550 if (!dev->ieee80211_ptr->beacon_interval)
4553 acl = parse_acl_data(&rdev->wiphy, info);
4555 return PTR_ERR(acl);
4557 err = rdev_set_mac_acl(rdev, dev, acl);
4564 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
4565 u8 *rates, u8 rates_len)
4570 for (i = 0; i < rates_len; i++) {
4571 int rate = (rates[i] & 0x7f) * 5;
4574 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
4575 struct ieee80211_rate *srate =
4576 &sband->bitrates[ridx];
4577 if (rate == srate->bitrate) {
4582 if (ridx == sband->n_bitrates)
4583 return 0; /* rate not found */
4589 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
4590 u8 *rates, u8 rates_len,
4591 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
4595 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
4597 for (i = 0; i < rates_len; i++) {
4600 ridx = rates[i] / 8;
4601 rbit = BIT(rates[i] % 8);
4603 /* check validity */
4604 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
4607 /* check availability */
4608 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN);
4609 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
4618 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
4622 switch (vht_mcs_map) {
4623 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
4625 case IEEE80211_VHT_MCS_SUPPORT_0_7:
4628 case IEEE80211_VHT_MCS_SUPPORT_0_8:
4631 case IEEE80211_VHT_MCS_SUPPORT_0_9:
4641 static void vht_build_mcs_mask(u16 vht_mcs_map,
4642 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
4646 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
4647 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
4652 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
4653 struct nl80211_txrate_vht *txrate,
4654 u16 mcs[NL80211_VHT_NSS_MAX])
4656 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4657 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
4660 if (!sband->vht_cap.vht_supported)
4663 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
4665 /* Build vht_mcs_mask from VHT capabilities */
4666 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
4668 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4669 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
4670 mcs[i] = txrate->mcs[i];
4678 static u16 he_mcs_map_to_mcs_mask(u8 he_mcs_map)
4680 switch (he_mcs_map) {
4681 case IEEE80211_HE_MCS_NOT_SUPPORTED:
4683 case IEEE80211_HE_MCS_SUPPORT_0_7:
4685 case IEEE80211_HE_MCS_SUPPORT_0_9:
4687 case IEEE80211_HE_MCS_SUPPORT_0_11:
4695 static void he_build_mcs_mask(u16 he_mcs_map,
4696 u16 he_mcs_mask[NL80211_HE_NSS_MAX])
4700 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) {
4701 he_mcs_mask[nss] = he_mcs_map_to_mcs_mask(he_mcs_map & 0x03);
4706 static u16 he_get_txmcsmap(struct genl_info *info,
4707 const struct ieee80211_sta_he_cap *he_cap)
4709 struct net_device *dev = info->user_ptr[1];
4710 struct wireless_dev *wdev = dev->ieee80211_ptr;
4713 switch (wdev->chandef.width) {
4714 case NL80211_CHAN_WIDTH_80P80:
4715 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80p80;
4717 case NL80211_CHAN_WIDTH_160:
4718 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_160;
4721 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80;
4724 return le16_to_cpu(tx_mcs);
4727 static bool he_set_mcs_mask(struct genl_info *info,
4728 struct wireless_dev *wdev,
4729 struct ieee80211_supported_band *sband,
4730 struct nl80211_txrate_he *txrate,
4731 u16 mcs[NL80211_HE_NSS_MAX])
4733 const struct ieee80211_sta_he_cap *he_cap;
4734 u16 tx_mcs_mask[NL80211_HE_NSS_MAX] = {};
4738 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
4742 memset(mcs, 0, sizeof(u16) * NL80211_HE_NSS_MAX);
4744 tx_mcs_map = he_get_txmcsmap(info, he_cap);
4746 /* Build he_mcs_mask from HE capabilities */
4747 he_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
4749 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
4750 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
4751 mcs[i] = txrate->mcs[i];
4759 static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
4760 struct nlattr *attrs[],
4761 enum nl80211_attrs attr,
4762 struct cfg80211_bitrate_mask *mask,
4763 struct net_device *dev,
4764 bool default_all_enabled)
4766 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
4767 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4768 struct wireless_dev *wdev = dev->ieee80211_ptr;
4770 struct nlattr *tx_rates;
4771 struct ieee80211_supported_band *sband;
4772 u16 vht_tx_mcs_map, he_tx_mcs_map;
4774 memset(mask, 0, sizeof(*mask));
4775 /* Default to all rates enabled */
4776 for (i = 0; i < NUM_NL80211_BANDS; i++) {
4777 const struct ieee80211_sta_he_cap *he_cap;
4779 if (!default_all_enabled)
4782 sband = rdev->wiphy.bands[i];
4787 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
4788 memcpy(mask->control[i].ht_mcs,
4789 sband->ht_cap.mcs.rx_mask,
4790 sizeof(mask->control[i].ht_mcs));
4792 if (sband->vht_cap.vht_supported) {
4793 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4794 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
4797 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
4801 he_tx_mcs_map = he_get_txmcsmap(info, he_cap);
4802 he_build_mcs_mask(he_tx_mcs_map, mask->control[i].he_mcs);
4804 mask->control[i].he_gi = 0xFF;
4805 mask->control[i].he_ltf = 0xFF;
4808 /* if no rates are given set it back to the defaults */
4812 /* The nested attribute uses enum nl80211_band as the index. This maps
4813 * directly to the enum nl80211_band values used in cfg80211.
4815 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
4816 nla_for_each_nested(tx_rates, attrs[attr], rem) {
4817 enum nl80211_band band = nla_type(tx_rates);
4820 if (band < 0 || band >= NUM_NL80211_BANDS)
4822 sband = rdev->wiphy.bands[band];
4825 err = nla_parse_nested_deprecated(tb, NL80211_TXRATE_MAX,
4827 nl80211_txattr_policy,
4831 if (tb[NL80211_TXRATE_LEGACY]) {
4832 mask->control[band].legacy = rateset_to_mask(
4834 nla_data(tb[NL80211_TXRATE_LEGACY]),
4835 nla_len(tb[NL80211_TXRATE_LEGACY]));
4836 if ((mask->control[band].legacy == 0) &&
4837 nla_len(tb[NL80211_TXRATE_LEGACY]))
4840 if (tb[NL80211_TXRATE_HT]) {
4841 if (!ht_rateset_to_mask(
4843 nla_data(tb[NL80211_TXRATE_HT]),
4844 nla_len(tb[NL80211_TXRATE_HT]),
4845 mask->control[band].ht_mcs))
4849 if (tb[NL80211_TXRATE_VHT]) {
4850 if (!vht_set_mcs_mask(
4852 nla_data(tb[NL80211_TXRATE_VHT]),
4853 mask->control[band].vht_mcs))
4857 if (tb[NL80211_TXRATE_GI]) {
4858 mask->control[band].gi =
4859 nla_get_u8(tb[NL80211_TXRATE_GI]);
4860 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
4863 if (tb[NL80211_TXRATE_HE] &&
4864 !he_set_mcs_mask(info, wdev, sband,
4865 nla_data(tb[NL80211_TXRATE_HE]),
4866 mask->control[band].he_mcs))
4869 if (tb[NL80211_TXRATE_HE_GI])
4870 mask->control[band].he_gi =
4871 nla_get_u8(tb[NL80211_TXRATE_HE_GI]);
4872 if (tb[NL80211_TXRATE_HE_LTF])
4873 mask->control[band].he_ltf =
4874 nla_get_u8(tb[NL80211_TXRATE_HE_LTF]);
4876 if (mask->control[band].legacy == 0) {
4877 /* don't allow empty legacy rates if HT, VHT or HE
4878 * are not even supported.
4880 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
4881 rdev->wiphy.bands[band]->vht_cap.vht_supported ||
4882 ieee80211_get_he_iftype_cap(sband, wdev->iftype)))
4885 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4886 if (mask->control[band].ht_mcs[i])
4889 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4890 if (mask->control[band].vht_mcs[i])
4893 for (i = 0; i < NL80211_HE_NSS_MAX; i++)
4894 if (mask->control[band].he_mcs[i])
4897 /* legacy and mcs rates may not be both empty */
4906 static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
4907 enum nl80211_band band,
4908 struct cfg80211_bitrate_mask *beacon_rate)
4910 u32 count_ht, count_vht, count_he, i;
4911 u32 rate = beacon_rate->control[band].legacy;
4913 /* Allow only one rate */
4914 if (hweight32(rate) > 1)
4918 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4919 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
4921 } else if (beacon_rate->control[band].ht_mcs[i]) {
4926 if (count_ht && rate)
4931 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4932 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
4934 } else if (beacon_rate->control[band].vht_mcs[i]) {
4939 if (count_vht && rate)
4944 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
4945 if (hweight16(beacon_rate->control[band].he_mcs[i]) > 1) {
4947 } else if (beacon_rate->control[band].he_mcs[i]) {
4952 if (count_he && rate)
4956 if ((count_ht && count_vht && count_he) ||
4957 (!rate && !count_ht && !count_vht && !count_he))
4961 !wiphy_ext_feature_isset(&rdev->wiphy,
4962 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
4965 !wiphy_ext_feature_isset(&rdev->wiphy,
4966 NL80211_EXT_FEATURE_BEACON_RATE_HT))
4969 !wiphy_ext_feature_isset(&rdev->wiphy,
4970 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
4973 !wiphy_ext_feature_isset(&rdev->wiphy,
4974 NL80211_EXT_FEATURE_BEACON_RATE_HE))
4980 static int nl80211_parse_beacon(struct cfg80211_registered_device *rdev,
4981 struct nlattr *attrs[],
4982 struct cfg80211_beacon_data *bcn)
4984 bool haveinfo = false;
4987 memset(bcn, 0, sizeof(*bcn));
4989 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
4990 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
4991 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
4997 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
4998 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
4999 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
5006 if (attrs[NL80211_ATTR_IE]) {
5007 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
5008 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
5011 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
5012 bcn->proberesp_ies =
5013 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
5014 bcn->proberesp_ies_len =
5015 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
5018 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
5019 bcn->assocresp_ies =
5020 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
5021 bcn->assocresp_ies_len =
5022 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
5025 if (attrs[NL80211_ATTR_PROBE_RESP]) {
5026 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
5027 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
5030 if (attrs[NL80211_ATTR_FTM_RESPONDER]) {
5031 struct nlattr *tb[NL80211_FTM_RESP_ATTR_MAX + 1];
5033 err = nla_parse_nested_deprecated(tb,
5034 NL80211_FTM_RESP_ATTR_MAX,
5035 attrs[NL80211_ATTR_FTM_RESPONDER],
5040 if (tb[NL80211_FTM_RESP_ATTR_ENABLED] &&
5041 wiphy_ext_feature_isset(&rdev->wiphy,
5042 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
5043 bcn->ftm_responder = 1;
5047 if (tb[NL80211_FTM_RESP_ATTR_LCI]) {
5048 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]);
5049 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]);
5052 if (tb[NL80211_FTM_RESP_ATTR_CIVICLOC]) {
5053 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
5054 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
5057 bcn->ftm_responder = -1;
5063 static int nl80211_parse_he_obss_pd(struct nlattr *attrs,
5064 struct ieee80211_he_obss_pd *he_obss_pd)
5066 struct nlattr *tb[NL80211_HE_OBSS_PD_ATTR_MAX + 1];
5069 err = nla_parse_nested(tb, NL80211_HE_OBSS_PD_ATTR_MAX, attrs,
5070 he_obss_pd_policy, NULL);
5074 if (!tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL])
5077 he_obss_pd->sr_ctrl = nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL]);
5079 if (tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET])
5080 he_obss_pd->min_offset =
5081 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET]);
5082 if (tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET])
5083 he_obss_pd->max_offset =
5084 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET]);
5085 if (tb[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET])
5086 he_obss_pd->non_srg_max_offset =
5087 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET]);
5089 if (he_obss_pd->min_offset > he_obss_pd->max_offset)
5092 if (tb[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP])
5093 memcpy(he_obss_pd->bss_color_bitmap,
5094 nla_data(tb[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP]),
5095 sizeof(he_obss_pd->bss_color_bitmap));
5097 if (tb[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP])
5098 memcpy(he_obss_pd->partial_bssid_bitmap,
5099 nla_data(tb[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP]),
5100 sizeof(he_obss_pd->partial_bssid_bitmap));
5102 he_obss_pd->enable = true;
5107 static int nl80211_parse_he_bss_color(struct nlattr *attrs,
5108 struct cfg80211_he_bss_color *he_bss_color)
5110 struct nlattr *tb[NL80211_HE_BSS_COLOR_ATTR_MAX + 1];
5113 err = nla_parse_nested(tb, NL80211_HE_BSS_COLOR_ATTR_MAX, attrs,
5114 he_bss_color_policy, NULL);
5118 if (!tb[NL80211_HE_BSS_COLOR_ATTR_COLOR])
5121 he_bss_color->color =
5122 nla_get_u8(tb[NL80211_HE_BSS_COLOR_ATTR_COLOR]);
5123 he_bss_color->enabled =
5124 !nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_DISABLED]);
5125 he_bss_color->partial =
5126 nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_PARTIAL]);
5131 static int nl80211_parse_fils_discovery(struct cfg80211_registered_device *rdev,
5132 struct nlattr *attrs,
5133 struct cfg80211_ap_settings *params)
5135 struct nlattr *tb[NL80211_FILS_DISCOVERY_ATTR_MAX + 1];
5137 struct cfg80211_fils_discovery *fd = ¶ms->fils_discovery;
5139 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5140 NL80211_EXT_FEATURE_FILS_DISCOVERY))
5143 ret = nla_parse_nested(tb, NL80211_FILS_DISCOVERY_ATTR_MAX, attrs,
5148 if (!tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN] ||
5149 !tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX] ||
5150 !tb[NL80211_FILS_DISCOVERY_ATTR_TMPL])
5153 fd->tmpl_len = nla_len(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]);
5154 fd->tmpl = nla_data(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]);
5155 fd->min_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN]);
5156 fd->max_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX]);
5162 nl80211_parse_unsol_bcast_probe_resp(struct cfg80211_registered_device *rdev,
5163 struct nlattr *attrs,
5164 struct cfg80211_ap_settings *params)
5166 struct nlattr *tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX + 1];
5168 struct cfg80211_unsol_bcast_probe_resp *presp =
5169 ¶ms->unsol_bcast_probe_resp;
5171 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5172 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP))
5175 ret = nla_parse_nested(tb, NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX,
5180 if (!tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT] ||
5181 !tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL])
5184 presp->tmpl = nla_data(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]);
5185 presp->tmpl_len = nla_len(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]);
5186 presp->interval = nla_get_u32(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT]);
5190 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
5198 for (i = 0; i < rates[1]; i++) {
5199 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
5200 params->ht_required = true;
5201 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
5202 params->vht_required = true;
5203 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HE_PHY)
5204 params->he_required = true;
5205 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_SAE_H2E)
5206 params->sae_h2e_required = true;
5211 * Since the nl80211 API didn't include, from the beginning, attributes about
5212 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
5213 * benefit of drivers that rebuild IEs in the firmware.
5215 static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
5217 const struct cfg80211_beacon_data *bcn = ¶ms->beacon;
5218 size_t ies_len = bcn->tail_len;
5219 const u8 *ies = bcn->tail;
5223 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
5224 nl80211_check_ap_rate_selectors(params, rates);
5226 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
5227 nl80211_check_ap_rate_selectors(params, rates);
5229 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
5230 if (cap && cap[1] >= sizeof(*params->ht_cap))
5231 params->ht_cap = (void *)(cap + 2);
5232 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
5233 if (cap && cap[1] >= sizeof(*params->vht_cap))
5234 params->vht_cap = (void *)(cap + 2);
5235 cap = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY, ies, ies_len);
5236 if (cap && cap[1] >= sizeof(*params->he_cap) + 1)
5237 params->he_cap = (void *)(cap + 3);
5238 cap = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_OPERATION, ies, ies_len);
5239 if (cap && cap[1] >= sizeof(*params->he_oper) + 1)
5240 params->he_oper = (void *)(cap + 3);
5243 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
5244 struct cfg80211_ap_settings *params)
5246 struct wireless_dev *wdev;
5249 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
5250 if (wdev->iftype != NL80211_IFTYPE_AP &&
5251 wdev->iftype != NL80211_IFTYPE_P2P_GO)
5254 if (!wdev->preset_chandef.chan)
5257 params->chandef = wdev->preset_chandef;
5265 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
5266 enum nl80211_auth_type auth_type,
5267 enum nl80211_commands cmd)
5269 if (auth_type > NL80211_AUTHTYPE_MAX)
5273 case NL80211_CMD_AUTHENTICATE:
5274 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
5275 auth_type == NL80211_AUTHTYPE_SAE)
5277 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5278 NL80211_EXT_FEATURE_FILS_STA) &&
5279 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
5280 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
5281 auth_type == NL80211_AUTHTYPE_FILS_PK))
5284 case NL80211_CMD_CONNECT:
5285 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
5286 !wiphy_ext_feature_isset(&rdev->wiphy,
5287 NL80211_EXT_FEATURE_SAE_OFFLOAD) &&
5288 auth_type == NL80211_AUTHTYPE_SAE)
5291 /* FILS with SK PFS or PK not supported yet */
5292 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
5293 auth_type == NL80211_AUTHTYPE_FILS_PK)
5295 if (!wiphy_ext_feature_isset(
5297 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
5298 auth_type == NL80211_AUTHTYPE_FILS_SK)
5301 case NL80211_CMD_START_AP:
5302 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5303 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP) &&
5304 auth_type == NL80211_AUTHTYPE_SAE)
5306 /* FILS not supported yet */
5307 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
5308 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
5309 auth_type == NL80211_AUTHTYPE_FILS_PK)
5317 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
5319 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5320 struct net_device *dev = info->user_ptr[1];
5321 struct wireless_dev *wdev = dev->ieee80211_ptr;
5322 struct cfg80211_ap_settings params;
5325 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5326 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5329 if (!rdev->ops->start_ap)
5332 if (wdev->beacon_interval)
5335 memset(¶ms, 0, sizeof(params));
5337 /* these are required for START_AP */
5338 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
5339 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
5340 !info->attrs[NL80211_ATTR_BEACON_HEAD])
5343 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon);
5347 params.beacon_interval =
5348 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
5349 params.dtim_period =
5350 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
5352 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
5353 params.beacon_interval);
5358 * In theory, some of these attributes should be required here
5359 * but since they were not used when the command was originally
5360 * added, keep them optional for old user space programs to let
5361 * them continue to work with drivers that do not need the
5362 * additional information -- drivers must check!
5364 if (info->attrs[NL80211_ATTR_SSID]) {
5365 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5367 nla_len(info->attrs[NL80211_ATTR_SSID]);
5368 if (params.ssid_len == 0)
5372 if (info->attrs[NL80211_ATTR_HIDDEN_SSID])
5373 params.hidden_ssid = nla_get_u32(
5374 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
5376 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
5378 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
5379 params.auth_type = nla_get_u32(
5380 info->attrs[NL80211_ATTR_AUTH_TYPE]);
5381 if (!nl80211_valid_auth_type(rdev, params.auth_type,
5382 NL80211_CMD_START_AP))
5385 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
5387 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
5388 NL80211_MAX_NR_CIPHER_SUITES);
5392 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
5393 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
5395 params.inactivity_timeout = nla_get_u16(
5396 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
5399 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
5400 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5402 params.p2p_ctwindow =
5403 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
5404 if (params.p2p_ctwindow != 0 &&
5405 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
5409 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
5412 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5414 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
5415 params.p2p_opp_ps = tmp;
5416 if (params.p2p_opp_ps != 0 &&
5417 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
5421 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
5422 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
5425 } else if (wdev->preset_chandef.chan) {
5426 params.chandef = wdev->preset_chandef;
5427 } else if (!nl80211_get_ap_channel(rdev, ¶ms))
5430 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
5434 if (info->attrs[NL80211_ATTR_TX_RATES]) {
5435 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
5436 NL80211_ATTR_TX_RATES,
5437 ¶ms.beacon_rate,
5442 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
5443 ¶ms.beacon_rate);
5448 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
5450 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
5451 switch (params.smps_mode) {
5452 case NL80211_SMPS_OFF:
5454 case NL80211_SMPS_STATIC:
5455 if (!(rdev->wiphy.features &
5456 NL80211_FEATURE_STATIC_SMPS))
5459 case NL80211_SMPS_DYNAMIC:
5460 if (!(rdev->wiphy.features &
5461 NL80211_FEATURE_DYNAMIC_SMPS))
5468 params.smps_mode = NL80211_SMPS_OFF;
5471 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
5472 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
5475 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
5476 params.acl = parse_acl_data(&rdev->wiphy, info);
5477 if (IS_ERR(params.acl))
5478 return PTR_ERR(params.acl);
5481 params.twt_responder =
5482 nla_get_flag(info->attrs[NL80211_ATTR_TWT_RESPONDER]);
5484 if (info->attrs[NL80211_ATTR_HE_OBSS_PD]) {
5485 err = nl80211_parse_he_obss_pd(
5486 info->attrs[NL80211_ATTR_HE_OBSS_PD],
5487 ¶ms.he_obss_pd);
5492 if (info->attrs[NL80211_ATTR_HE_BSS_COLOR]) {
5493 err = nl80211_parse_he_bss_color(
5494 info->attrs[NL80211_ATTR_HE_BSS_COLOR],
5495 ¶ms.he_bss_color);
5500 if (info->attrs[NL80211_ATTR_FILS_DISCOVERY]) {
5501 err = nl80211_parse_fils_discovery(rdev,
5502 info->attrs[NL80211_ATTR_FILS_DISCOVERY],
5508 if (info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP]) {
5509 err = nl80211_parse_unsol_bcast_probe_resp(
5510 rdev, info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP],
5516 nl80211_calculate_ap_params(¶ms);
5518 if (info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])
5519 params.flags |= AP_SETTINGS_EXTERNAL_AUTH_SUPPORT;
5522 err = rdev_start_ap(rdev, dev, ¶ms);
5524 wdev->preset_chandef = params.chandef;
5525 wdev->beacon_interval = params.beacon_interval;
5526 wdev->chandef = params.chandef;
5527 wdev->ssid_len = params.ssid_len;
5528 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
5530 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
5531 wdev->conn_owner_nlportid = info->snd_portid;
5541 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
5543 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5544 struct net_device *dev = info->user_ptr[1];
5545 struct wireless_dev *wdev = dev->ieee80211_ptr;
5546 struct cfg80211_beacon_data params;
5549 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5550 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5553 if (!rdev->ops->change_beacon)
5556 if (!wdev->beacon_interval)
5559 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms);
5564 err = rdev_change_beacon(rdev, dev, ¶ms);
5570 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
5572 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5573 struct net_device *dev = info->user_ptr[1];
5575 return cfg80211_stop_ap(rdev, dev, false);
5578 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
5579 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
5580 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
5581 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
5582 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
5583 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
5584 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5587 static int parse_station_flags(struct genl_info *info,
5588 enum nl80211_iftype iftype,
5589 struct station_parameters *params)
5591 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
5596 * Try parsing the new attribute first so userspace
5597 * can specify both for older kernels.
5599 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
5601 struct nl80211_sta_flag_update *sta_flags;
5603 sta_flags = nla_data(nla);
5604 params->sta_flags_mask = sta_flags->mask;
5605 params->sta_flags_set = sta_flags->set;
5606 params->sta_flags_set &= params->sta_flags_mask;
5607 if ((params->sta_flags_mask |
5608 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
5613 /* if present, parse the old attribute */
5615 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5619 if (nla_parse_nested_deprecated(flags, NL80211_STA_FLAG_MAX, nla, sta_flags_policy, info->extack))
5623 * Only allow certain flags for interface types so that
5624 * other attributes are silently ignored. Remember that
5625 * this is backward compatibility code with old userspace
5626 * and shouldn't be hit in other cases anyway.
5629 case NL80211_IFTYPE_AP:
5630 case NL80211_IFTYPE_AP_VLAN:
5631 case NL80211_IFTYPE_P2P_GO:
5632 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
5633 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
5634 BIT(NL80211_STA_FLAG_WME) |
5635 BIT(NL80211_STA_FLAG_MFP);
5637 case NL80211_IFTYPE_P2P_CLIENT:
5638 case NL80211_IFTYPE_STATION:
5639 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
5640 BIT(NL80211_STA_FLAG_TDLS_PEER);
5642 case NL80211_IFTYPE_MESH_POINT:
5643 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5644 BIT(NL80211_STA_FLAG_MFP) |
5645 BIT(NL80211_STA_FLAG_AUTHORIZED);
5651 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
5653 params->sta_flags_set |= (1<<flag);
5655 /* no longer support new API additions in old API */
5656 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
5664 bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info, int attr)
5666 struct nlattr *rate;
5669 enum nl80211_rate_info rate_flg;
5671 rate = nla_nest_start_noflag(msg, attr);
5675 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
5676 bitrate = cfg80211_calculate_bitrate(info);
5677 /* report 16-bit bitrate only if we can */
5678 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
5680 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
5682 if (bitrate_compat > 0 &&
5683 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
5687 case RATE_INFO_BW_5:
5688 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
5690 case RATE_INFO_BW_10:
5691 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
5696 case RATE_INFO_BW_20:
5699 case RATE_INFO_BW_40:
5700 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
5702 case RATE_INFO_BW_80:
5703 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
5705 case RATE_INFO_BW_160:
5706 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
5708 case RATE_INFO_BW_HE_RU:
5710 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS));
5713 if (rate_flg && nla_put_flag(msg, rate_flg))
5716 if (info->flags & RATE_INFO_FLAGS_MCS) {
5717 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
5719 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
5720 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
5722 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
5723 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
5725 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
5727 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
5728 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
5730 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) {
5731 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs))
5733 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss))
5735 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi))
5737 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm))
5739 if (info->bw == RATE_INFO_BW_HE_RU &&
5740 nla_put_u8(msg, NL80211_RATE_INFO_HE_RU_ALLOC,
5745 nla_nest_end(msg, rate);
5749 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
5758 attr = nla_nest_start_noflag(msg, id);
5762 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
5763 if (!(mask & BIT(i)))
5766 if (nla_put_u8(msg, i, signal[i]))
5770 nla_nest_end(msg, attr);
5775 static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
5777 struct cfg80211_registered_device *rdev,
5778 struct net_device *dev,
5779 const u8 *mac_addr, struct station_info *sinfo)
5782 struct nlattr *sinfoattr, *bss_param;
5784 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
5786 cfg80211_sinfo_release_content(sinfo);
5790 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5791 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
5792 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
5793 goto nla_put_failure;
5795 sinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_STA_INFO);
5797 goto nla_put_failure;
5799 #define PUT_SINFO(attr, memb, type) do { \
5800 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
5801 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5802 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
5804 goto nla_put_failure; \
5806 #define PUT_SINFO_U64(attr, memb) do { \
5807 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5808 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
5809 sinfo->memb, NL80211_STA_INFO_PAD)) \
5810 goto nla_put_failure; \
5813 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
5814 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
5815 PUT_SINFO_U64(ASSOC_AT_BOOTTIME, assoc_at);
5817 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
5818 BIT_ULL(NL80211_STA_INFO_RX_BYTES64)) &&
5819 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
5820 (u32)sinfo->rx_bytes))
5821 goto nla_put_failure;
5823 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
5824 BIT_ULL(NL80211_STA_INFO_TX_BYTES64)) &&
5825 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
5826 (u32)sinfo->tx_bytes))
5827 goto nla_put_failure;
5829 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
5830 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
5831 PUT_SINFO(LLID, llid, u16);
5832 PUT_SINFO(PLID, plid, u16);
5833 PUT_SINFO(PLINK_STATE, plink_state, u8);
5834 PUT_SINFO_U64(RX_DURATION, rx_duration);
5835 PUT_SINFO_U64(TX_DURATION, tx_duration);
5837 if (wiphy_ext_feature_isset(&rdev->wiphy,
5838 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
5839 PUT_SINFO(AIRTIME_WEIGHT, airtime_weight, u16);
5841 switch (rdev->wiphy.signal_type) {
5842 case CFG80211_SIGNAL_TYPE_MBM:
5843 PUT_SINFO(SIGNAL, signal, u8);
5844 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
5849 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
5850 if (!nl80211_put_signal(msg, sinfo->chains,
5851 sinfo->chain_signal,
5852 NL80211_STA_INFO_CHAIN_SIGNAL))
5853 goto nla_put_failure;
5855 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
5856 if (!nl80211_put_signal(msg, sinfo->chains,
5857 sinfo->chain_signal_avg,
5858 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
5859 goto nla_put_failure;
5861 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
5862 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
5863 NL80211_STA_INFO_TX_BITRATE))
5864 goto nla_put_failure;
5866 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
5867 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
5868 NL80211_STA_INFO_RX_BITRATE))
5869 goto nla_put_failure;
5872 PUT_SINFO(RX_PACKETS, rx_packets, u32);
5873 PUT_SINFO(TX_PACKETS, tx_packets, u32);
5874 PUT_SINFO(TX_RETRIES, tx_retries, u32);
5875 PUT_SINFO(TX_FAILED, tx_failed, u32);
5876 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
5877 PUT_SINFO(AIRTIME_LINK_METRIC, airtime_link_metric, u32);
5878 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
5879 PUT_SINFO(LOCAL_PM, local_pm, u32);
5880 PUT_SINFO(PEER_PM, peer_pm, u32);
5881 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
5882 PUT_SINFO(CONNECTED_TO_GATE, connected_to_gate, u8);
5883 PUT_SINFO(CONNECTED_TO_AS, connected_to_as, u8);
5885 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
5886 bss_param = nla_nest_start_noflag(msg,
5887 NL80211_STA_INFO_BSS_PARAM);
5889 goto nla_put_failure;
5891 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
5892 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
5893 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
5894 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
5895 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
5896 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
5897 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
5898 sinfo->bss_param.dtim_period) ||
5899 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
5900 sinfo->bss_param.beacon_interval))
5901 goto nla_put_failure;
5903 nla_nest_end(msg, bss_param);
5905 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) &&
5906 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
5907 sizeof(struct nl80211_sta_flag_update),
5909 goto nla_put_failure;
5911 PUT_SINFO_U64(T_OFFSET, t_offset);
5912 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
5913 PUT_SINFO_U64(BEACON_RX, rx_beacon);
5914 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
5915 PUT_SINFO(RX_MPDUS, rx_mpdu_count, u32);
5916 PUT_SINFO(FCS_ERROR_COUNT, fcs_err_count, u32);
5917 if (wiphy_ext_feature_isset(&rdev->wiphy,
5918 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT)) {
5919 PUT_SINFO(ACK_SIGNAL, ack_signal, u8);
5920 PUT_SINFO(ACK_SIGNAL_AVG, avg_ack_signal, s8);
5924 #undef PUT_SINFO_U64
5926 if (sinfo->pertid) {
5927 struct nlattr *tidsattr;
5930 tidsattr = nla_nest_start_noflag(msg,
5931 NL80211_STA_INFO_TID_STATS);
5933 goto nla_put_failure;
5935 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
5936 struct cfg80211_tid_stats *tidstats;
5937 struct nlattr *tidattr;
5939 tidstats = &sinfo->pertid[tid];
5941 if (!tidstats->filled)
5944 tidattr = nla_nest_start_noflag(msg, tid + 1);
5946 goto nla_put_failure;
5948 #define PUT_TIDVAL_U64(attr, memb) do { \
5949 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
5950 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
5951 tidstats->memb, NL80211_TID_STATS_PAD)) \
5952 goto nla_put_failure; \
5955 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
5956 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
5957 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
5958 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
5960 #undef PUT_TIDVAL_U64
5961 if ((tidstats->filled &
5962 BIT(NL80211_TID_STATS_TXQ_STATS)) &&
5963 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
5964 NL80211_TID_STATS_TXQ_STATS))
5965 goto nla_put_failure;
5967 nla_nest_end(msg, tidattr);
5970 nla_nest_end(msg, tidsattr);
5973 nla_nest_end(msg, sinfoattr);
5975 if (sinfo->assoc_req_ies_len &&
5976 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
5977 sinfo->assoc_req_ies))
5978 goto nla_put_failure;
5980 cfg80211_sinfo_release_content(sinfo);
5981 genlmsg_end(msg, hdr);
5985 cfg80211_sinfo_release_content(sinfo);
5986 genlmsg_cancel(msg, hdr);
5990 static int nl80211_dump_station(struct sk_buff *skb,
5991 struct netlink_callback *cb)
5993 struct station_info sinfo;
5994 struct cfg80211_registered_device *rdev;
5995 struct wireless_dev *wdev;
5996 u8 mac_addr[ETH_ALEN];
5997 int sta_idx = cb->args[2];
6000 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6003 /* nl80211_prepare_wdev_dump acquired it in the successful case */
6004 __acquire(&rdev->wiphy.mtx);
6006 if (!wdev->netdev) {
6011 if (!rdev->ops->dump_station) {
6017 memset(&sinfo, 0, sizeof(sinfo));
6018 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
6025 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
6026 NETLINK_CB(cb->skb).portid,
6027 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6028 rdev, wdev->netdev, mac_addr,
6036 cb->args[2] = sta_idx;
6039 wiphy_unlock(&rdev->wiphy);
6044 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
6046 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6047 struct net_device *dev = info->user_ptr[1];
6048 struct station_info sinfo;
6049 struct sk_buff *msg;
6050 u8 *mac_addr = NULL;
6053 memset(&sinfo, 0, sizeof(sinfo));
6055 if (!info->attrs[NL80211_ATTR_MAC])
6058 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6060 if (!rdev->ops->get_station)
6063 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
6067 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6069 cfg80211_sinfo_release_content(&sinfo);
6073 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
6074 info->snd_portid, info->snd_seq, 0,
6075 rdev, dev, mac_addr, &sinfo) < 0) {
6080 return genlmsg_reply(msg, info);
6083 int cfg80211_check_station_change(struct wiphy *wiphy,
6084 struct station_parameters *params,
6085 enum cfg80211_station_type statype)
6087 if (params->listen_interval != -1 &&
6088 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
6091 if (params->support_p2p_ps != -1 &&
6092 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
6096 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
6097 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
6100 /* When you run into this, adjust the code below for the new flag */
6101 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
6104 case CFG80211_STA_MESH_PEER_KERNEL:
6105 case CFG80211_STA_MESH_PEER_USER:
6107 * No ignoring the TDLS flag here -- the userspace mesh
6108 * code doesn't have the bug of including TDLS in the
6111 if (params->sta_flags_mask &
6112 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6113 BIT(NL80211_STA_FLAG_MFP) |
6114 BIT(NL80211_STA_FLAG_AUTHORIZED)))
6117 case CFG80211_STA_TDLS_PEER_SETUP:
6118 case CFG80211_STA_TDLS_PEER_ACTIVE:
6119 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
6121 /* ignore since it can't change */
6122 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
6125 /* disallow mesh-specific things */
6126 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
6128 if (params->local_pm)
6130 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
6134 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
6135 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
6136 /* TDLS can't be set, ... */
6137 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
6140 * ... but don't bother the driver with it. This works around
6141 * a hostapd/wpa_supplicant issue -- it always includes the
6142 * TLDS_PEER flag in the mask even for AP mode.
6144 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
6147 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
6148 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
6149 /* reject other things that can't change */
6150 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
6152 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
6154 if (params->supported_rates)
6156 if (params->ext_capab || params->ht_capa || params->vht_capa ||
6161 if (statype != CFG80211_STA_AP_CLIENT &&
6162 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
6168 case CFG80211_STA_AP_MLME_CLIENT:
6169 /* Use this only for authorizing/unauthorizing a station */
6170 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
6173 case CFG80211_STA_AP_CLIENT:
6174 case CFG80211_STA_AP_CLIENT_UNASSOC:
6175 /* accept only the listed bits */
6176 if (params->sta_flags_mask &
6177 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
6178 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6179 BIT(NL80211_STA_FLAG_ASSOCIATED) |
6180 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
6181 BIT(NL80211_STA_FLAG_WME) |
6182 BIT(NL80211_STA_FLAG_MFP)))
6185 /* but authenticated/associated only if driver handles it */
6186 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
6187 params->sta_flags_mask &
6188 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6189 BIT(NL80211_STA_FLAG_ASSOCIATED)))
6192 case CFG80211_STA_IBSS:
6193 case CFG80211_STA_AP_STA:
6194 /* reject any changes other than AUTHORIZED */
6195 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
6198 case CFG80211_STA_TDLS_PEER_SETUP:
6199 /* reject any changes other than AUTHORIZED or WME */
6200 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
6201 BIT(NL80211_STA_FLAG_WME)))
6203 /* force (at least) rates when authorizing */
6204 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
6205 !params->supported_rates)
6208 case CFG80211_STA_TDLS_PEER_ACTIVE:
6209 /* reject any changes */
6211 case CFG80211_STA_MESH_PEER_KERNEL:
6212 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
6215 case CFG80211_STA_MESH_PEER_USER:
6216 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
6217 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
6223 * Older kernel versions ignored this attribute entirely, so don't
6224 * reject attempts to update it but mark it as unused instead so the
6225 * driver won't look at the data.
6227 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
6228 statype != CFG80211_STA_TDLS_PEER_SETUP)
6229 params->opmode_notif_used = false;
6233 EXPORT_SYMBOL(cfg80211_check_station_change);
6236 * Get vlan interface making sure it is running and on the right wiphy.
6238 static struct net_device *get_vlan(struct genl_info *info,
6239 struct cfg80211_registered_device *rdev)
6241 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
6242 struct net_device *v;
6248 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
6250 return ERR_PTR(-ENODEV);
6252 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
6257 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
6258 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6259 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
6264 if (!netif_running(v)) {
6272 return ERR_PTR(ret);
6275 static const struct nla_policy
6276 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
6277 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
6278 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
6281 static int nl80211_parse_sta_wme(struct genl_info *info,
6282 struct station_parameters *params)
6284 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
6288 /* parse WME attributes if present */
6289 if (!info->attrs[NL80211_ATTR_STA_WME])
6292 nla = info->attrs[NL80211_ATTR_STA_WME];
6293 err = nla_parse_nested_deprecated(tb, NL80211_STA_WME_MAX, nla,
6294 nl80211_sta_wme_policy,
6299 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
6300 params->uapsd_queues = nla_get_u8(
6301 tb[NL80211_STA_WME_UAPSD_QUEUES]);
6302 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
6305 if (tb[NL80211_STA_WME_MAX_SP])
6306 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
6308 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
6311 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
6316 static int nl80211_parse_sta_channel_info(struct genl_info *info,
6317 struct station_parameters *params)
6319 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
6320 params->supported_channels =
6321 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
6322 params->supported_channels_len =
6323 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
6325 * Need to include at least one (first channel, number of
6326 * channels) tuple for each subband (checked in policy),
6327 * and must have proper tuples for the rest of the data as well.
6329 if (params->supported_channels_len % 2)
6333 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
6334 params->supported_oper_classes =
6335 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
6336 params->supported_oper_classes_len =
6337 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
6342 static int nl80211_set_station_tdls(struct genl_info *info,
6343 struct station_parameters *params)
6346 /* Dummy STA entry gets updated once the peer capabilities are known */
6347 if (info->attrs[NL80211_ATTR_PEER_AID])
6348 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
6349 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
6351 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
6352 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
6354 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
6355 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
6357 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
6358 params->he_capa_len =
6359 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
6362 err = nl80211_parse_sta_channel_info(info, params);
6366 return nl80211_parse_sta_wme(info, params);
6369 static int nl80211_parse_sta_txpower_setting(struct genl_info *info,
6370 struct station_parameters *params)
6372 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6375 if (info->attrs[NL80211_ATTR_STA_TX_POWER_SETTING]) {
6376 if (!rdev->ops->set_tx_power ||
6377 !wiphy_ext_feature_isset(&rdev->wiphy,
6378 NL80211_EXT_FEATURE_STA_TX_PWR))
6381 idx = NL80211_ATTR_STA_TX_POWER_SETTING;
6382 params->txpwr.type = nla_get_u8(info->attrs[idx]);
6384 if (params->txpwr.type == NL80211_TX_POWER_LIMITED) {
6385 idx = NL80211_ATTR_STA_TX_POWER;
6387 if (info->attrs[idx])
6388 params->txpwr.power =
6389 nla_get_s16(info->attrs[idx]);
6393 params->sta_modify_mask |= STATION_PARAM_APPLY_STA_TXPOWER;
6399 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
6401 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6402 struct net_device *dev = info->user_ptr[1];
6403 struct station_parameters params;
6407 memset(¶ms, 0, sizeof(params));
6409 if (!rdev->ops->change_station)
6413 * AID and listen_interval properties can be set only for unassociated
6414 * station. Include these parameters here and will check them in
6415 * cfg80211_check_station_change().
6417 if (info->attrs[NL80211_ATTR_STA_AID])
6418 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
6420 if (info->attrs[NL80211_ATTR_VLAN_ID])
6421 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
6423 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
6424 params.listen_interval =
6425 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
6427 params.listen_interval = -1;
6429 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS])
6430 params.support_p2p_ps =
6431 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
6433 params.support_p2p_ps = -1;
6435 if (!info->attrs[NL80211_ATTR_MAC])
6438 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6440 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
6441 params.supported_rates =
6442 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
6443 params.supported_rates_len =
6444 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
6447 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
6449 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
6450 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
6453 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
6455 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
6456 params.ext_capab_len =
6457 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
6460 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
6463 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
6464 params.plink_action =
6465 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
6467 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
6468 params.plink_state =
6469 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
6470 if (info->attrs[NL80211_ATTR_MESH_PEER_AID])
6471 params.peer_aid = nla_get_u16(
6472 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
6473 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
6476 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE])
6477 params.local_pm = nla_get_u32(
6478 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
6480 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
6481 params.opmode_notif_used = true;
6482 params.opmode_notif =
6483 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
6486 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
6487 params.he_6ghz_capa =
6488 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
6490 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
6491 params.airtime_weight =
6492 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
6494 if (params.airtime_weight &&
6495 !wiphy_ext_feature_isset(&rdev->wiphy,
6496 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
6499 err = nl80211_parse_sta_txpower_setting(info, ¶ms);
6503 /* Include parameters for TDLS peer (will check later) */
6504 err = nl80211_set_station_tdls(info, ¶ms);
6508 params.vlan = get_vlan(info, rdev);
6509 if (IS_ERR(params.vlan))
6510 return PTR_ERR(params.vlan);
6512 switch (dev->ieee80211_ptr->iftype) {
6513 case NL80211_IFTYPE_AP:
6514 case NL80211_IFTYPE_AP_VLAN:
6515 case NL80211_IFTYPE_P2P_GO:
6516 case NL80211_IFTYPE_P2P_CLIENT:
6517 case NL80211_IFTYPE_STATION:
6518 case NL80211_IFTYPE_ADHOC:
6519 case NL80211_IFTYPE_MESH_POINT:
6526 /* driver will call cfg80211_check_station_change() */
6527 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
6531 dev_put(params.vlan);
6536 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
6538 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6540 struct net_device *dev = info->user_ptr[1];
6541 struct station_parameters params;
6542 u8 *mac_addr = NULL;
6543 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6544 BIT(NL80211_STA_FLAG_ASSOCIATED);
6546 memset(¶ms, 0, sizeof(params));
6548 if (!rdev->ops->add_station)
6551 if (!info->attrs[NL80211_ATTR_MAC])
6554 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
6557 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
6560 if (!info->attrs[NL80211_ATTR_STA_AID] &&
6561 !info->attrs[NL80211_ATTR_PEER_AID])
6564 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6565 params.supported_rates =
6566 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
6567 params.supported_rates_len =
6568 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
6569 params.listen_interval =
6570 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
6572 if (info->attrs[NL80211_ATTR_VLAN_ID])
6573 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
6575 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
6576 params.support_p2p_ps =
6577 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
6580 * if not specified, assume it's supported for P2P GO interface,
6581 * and is NOT supported for AP interface
6583 params.support_p2p_ps =
6584 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
6587 if (info->attrs[NL80211_ATTR_PEER_AID])
6588 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
6590 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
6592 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
6594 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
6595 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
6598 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
6600 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
6601 params.ext_capab_len =
6602 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
6605 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
6607 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
6609 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
6611 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
6613 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
6615 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
6616 params.he_capa_len =
6617 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
6620 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
6621 params.he_6ghz_capa =
6622 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
6624 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
6625 params.opmode_notif_used = true;
6626 params.opmode_notif =
6627 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
6630 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
6631 params.plink_action =
6632 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
6634 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
6635 params.airtime_weight =
6636 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
6638 if (params.airtime_weight &&
6639 !wiphy_ext_feature_isset(&rdev->wiphy,
6640 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
6643 err = nl80211_parse_sta_txpower_setting(info, ¶ms);
6647 err = nl80211_parse_sta_channel_info(info, ¶ms);
6651 err = nl80211_parse_sta_wme(info, ¶ms);
6655 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
6658 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
6659 * as userspace might just pass through the capabilities from the IEs
6660 * directly, rather than enforcing this restriction and returning an
6661 * error in this case.
6663 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
6664 params.ht_capa = NULL;
6665 params.vht_capa = NULL;
6667 /* HE requires WME */
6668 if (params.he_capa_len || params.he_6ghz_capa)
6672 /* Ensure that HT/VHT capabilities are not set for 6 GHz HE STA */
6673 if (params.he_6ghz_capa && (params.ht_capa || params.vht_capa))
6676 /* When you run into this, adjust the code below for the new flag */
6677 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
6679 switch (dev->ieee80211_ptr->iftype) {
6680 case NL80211_IFTYPE_AP:
6681 case NL80211_IFTYPE_AP_VLAN:
6682 case NL80211_IFTYPE_P2P_GO:
6683 /* ignore WME attributes if iface/sta is not capable */
6684 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
6685 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
6686 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
6688 /* TDLS peers cannot be added */
6689 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
6690 info->attrs[NL80211_ATTR_PEER_AID])
6692 /* but don't bother the driver with it */
6693 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
6695 /* allow authenticated/associated only if driver handles it */
6696 if (!(rdev->wiphy.features &
6697 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
6698 params.sta_flags_mask & auth_assoc)
6701 /* Older userspace, or userspace wanting to be compatible with
6702 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
6703 * and assoc flags in the mask, but assumes the station will be
6704 * added as associated anyway since this was the required driver
6705 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
6707 * In order to not bother drivers with this quirk in the API
6708 * set the flags in both the mask and set for new stations in
6711 if (!(params.sta_flags_mask & auth_assoc)) {
6712 params.sta_flags_mask |= auth_assoc;
6713 params.sta_flags_set |= auth_assoc;
6716 /* must be last in here for error handling */
6717 params.vlan = get_vlan(info, rdev);
6718 if (IS_ERR(params.vlan))
6719 return PTR_ERR(params.vlan);
6721 case NL80211_IFTYPE_MESH_POINT:
6722 /* ignore uAPSD data */
6723 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
6725 /* associated is disallowed */
6726 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
6728 /* TDLS peers cannot be added */
6729 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
6730 info->attrs[NL80211_ATTR_PEER_AID])
6733 case NL80211_IFTYPE_STATION:
6734 case NL80211_IFTYPE_P2P_CLIENT:
6735 /* ignore uAPSD data */
6736 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
6738 /* these are disallowed */
6739 if (params.sta_flags_mask &
6740 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
6741 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
6743 /* Only TDLS peers can be added */
6744 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
6746 /* Can only add if TDLS ... */
6747 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
6749 /* ... with external setup is supported */
6750 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
6753 * Older wpa_supplicant versions always mark the TDLS peer
6754 * as authorized, but it shouldn't yet be.
6756 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
6762 /* be aware of params.vlan when changing code here */
6764 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
6767 dev_put(params.vlan);
6771 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
6773 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6774 struct net_device *dev = info->user_ptr[1];
6775 struct station_del_parameters params;
6777 memset(¶ms, 0, sizeof(params));
6779 if (info->attrs[NL80211_ATTR_MAC])
6780 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
6782 switch (dev->ieee80211_ptr->iftype) {
6783 case NL80211_IFTYPE_AP:
6784 case NL80211_IFTYPE_AP_VLAN:
6785 case NL80211_IFTYPE_MESH_POINT:
6786 case NL80211_IFTYPE_P2P_GO:
6787 /* always accept these */
6789 case NL80211_IFTYPE_ADHOC:
6790 /* conditionally accept */
6791 if (wiphy_ext_feature_isset(&rdev->wiphy,
6792 NL80211_EXT_FEATURE_DEL_IBSS_STA))
6799 if (!rdev->ops->del_station)
6802 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
6804 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
6805 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
6806 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
6809 /* Default to Deauthentication frame */
6810 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
6813 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
6814 params.reason_code =
6815 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6816 if (params.reason_code == 0)
6817 return -EINVAL; /* 0 is reserved */
6819 /* Default to reason code 2 */
6820 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
6823 return rdev_del_station(rdev, dev, ¶ms);
6826 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
6827 int flags, struct net_device *dev,
6828 u8 *dst, u8 *next_hop,
6829 struct mpath_info *pinfo)
6832 struct nlattr *pinfoattr;
6834 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
6838 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6839 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
6840 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
6841 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
6842 goto nla_put_failure;
6844 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MPATH_INFO);
6846 goto nla_put_failure;
6847 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
6848 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
6850 goto nla_put_failure;
6851 if (((pinfo->filled & MPATH_INFO_SN) &&
6852 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
6853 ((pinfo->filled & MPATH_INFO_METRIC) &&
6854 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
6856 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
6857 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
6859 ((pinfo->filled & MPATH_INFO_FLAGS) &&
6860 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
6862 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
6863 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
6864 pinfo->discovery_timeout)) ||
6865 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
6866 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
6867 pinfo->discovery_retries)) ||
6868 ((pinfo->filled & MPATH_INFO_HOP_COUNT) &&
6869 nla_put_u8(msg, NL80211_MPATH_INFO_HOP_COUNT,
6870 pinfo->hop_count)) ||
6871 ((pinfo->filled & MPATH_INFO_PATH_CHANGE) &&
6872 nla_put_u32(msg, NL80211_MPATH_INFO_PATH_CHANGE,
6873 pinfo->path_change_count)))
6874 goto nla_put_failure;
6876 nla_nest_end(msg, pinfoattr);
6878 genlmsg_end(msg, hdr);
6882 genlmsg_cancel(msg, hdr);
6886 static int nl80211_dump_mpath(struct sk_buff *skb,
6887 struct netlink_callback *cb)
6889 struct mpath_info pinfo;
6890 struct cfg80211_registered_device *rdev;
6891 struct wireless_dev *wdev;
6893 u8 next_hop[ETH_ALEN];
6894 int path_idx = cb->args[2];
6897 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6900 /* nl80211_prepare_wdev_dump acquired it in the successful case */
6901 __acquire(&rdev->wiphy.mtx);
6903 if (!rdev->ops->dump_mpath) {
6908 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
6914 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
6921 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
6922 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6923 wdev->netdev, dst, next_hop,
6931 cb->args[2] = path_idx;
6934 wiphy_unlock(&rdev->wiphy);
6938 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
6940 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6942 struct net_device *dev = info->user_ptr[1];
6943 struct mpath_info pinfo;
6944 struct sk_buff *msg;
6946 u8 next_hop[ETH_ALEN];
6948 memset(&pinfo, 0, sizeof(pinfo));
6950 if (!info->attrs[NL80211_ATTR_MAC])
6953 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6955 if (!rdev->ops->get_mpath)
6958 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6961 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
6965 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6969 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
6970 dev, dst, next_hop, &pinfo) < 0) {
6975 return genlmsg_reply(msg, info);
6978 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
6980 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6981 struct net_device *dev = info->user_ptr[1];
6983 u8 *next_hop = NULL;
6985 if (!info->attrs[NL80211_ATTR_MAC])
6988 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
6991 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6992 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
6994 if (!rdev->ops->change_mpath)
6997 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7000 return rdev_change_mpath(rdev, dev, dst, next_hop);
7003 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
7005 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7006 struct net_device *dev = info->user_ptr[1];
7008 u8 *next_hop = NULL;
7010 if (!info->attrs[NL80211_ATTR_MAC])
7013 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
7016 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7017 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
7019 if (!rdev->ops->add_mpath)
7022 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7025 return rdev_add_mpath(rdev, dev, dst, next_hop);
7028 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
7030 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7031 struct net_device *dev = info->user_ptr[1];
7034 if (info->attrs[NL80211_ATTR_MAC])
7035 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7037 if (!rdev->ops->del_mpath)
7040 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7043 return rdev_del_mpath(rdev, dev, dst);
7046 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
7048 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7050 struct net_device *dev = info->user_ptr[1];
7051 struct mpath_info pinfo;
7052 struct sk_buff *msg;
7056 memset(&pinfo, 0, sizeof(pinfo));
7058 if (!info->attrs[NL80211_ATTR_MAC])
7061 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7063 if (!rdev->ops->get_mpp)
7066 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7069 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
7073 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7077 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
7078 dev, dst, mpp, &pinfo) < 0) {
7083 return genlmsg_reply(msg, info);
7086 static int nl80211_dump_mpp(struct sk_buff *skb,
7087 struct netlink_callback *cb)
7089 struct mpath_info pinfo;
7090 struct cfg80211_registered_device *rdev;
7091 struct wireless_dev *wdev;
7094 int path_idx = cb->args[2];
7097 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
7100 /* nl80211_prepare_wdev_dump acquired it in the successful case */
7101 __acquire(&rdev->wiphy.mtx);
7103 if (!rdev->ops->dump_mpp) {
7108 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
7114 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
7121 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
7122 cb->nlh->nlmsg_seq, NLM_F_MULTI,
7123 wdev->netdev, dst, mpp,
7131 cb->args[2] = path_idx;
7134 wiphy_unlock(&rdev->wiphy);
7138 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
7140 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7141 struct net_device *dev = info->user_ptr[1];
7142 struct wireless_dev *wdev = dev->ieee80211_ptr;
7143 struct bss_parameters params;
7146 memset(¶ms, 0, sizeof(params));
7147 /* default to not changing parameters */
7148 params.use_cts_prot = -1;
7149 params.use_short_preamble = -1;
7150 params.use_short_slot_time = -1;
7151 params.ap_isolate = -1;
7152 params.ht_opmode = -1;
7153 params.p2p_ctwindow = -1;
7154 params.p2p_opp_ps = -1;
7156 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
7157 params.use_cts_prot =
7158 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
7159 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
7160 params.use_short_preamble =
7161 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
7162 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
7163 params.use_short_slot_time =
7164 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
7165 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
7166 params.basic_rates =
7167 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
7168 params.basic_rates_len =
7169 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
7171 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
7172 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
7173 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
7175 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
7177 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
7178 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
7180 params.p2p_ctwindow =
7181 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
7182 if (params.p2p_ctwindow != 0 &&
7183 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
7187 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
7190 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
7192 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
7193 params.p2p_opp_ps = tmp;
7194 if (params.p2p_opp_ps &&
7195 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
7199 if (!rdev->ops->change_bss)
7202 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
7203 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
7207 err = rdev_change_bss(rdev, dev, ¶ms);
7213 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
7217 enum nl80211_user_reg_hint_type user_reg_hint_type;
7221 * You should only get this when cfg80211 hasn't yet initialized
7222 * completely when built-in to the kernel right between the time
7223 * window between nl80211_init() and regulatory_init(), if that is
7226 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
7227 return -EINPROGRESS;
7229 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
7230 user_reg_hint_type =
7231 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
7233 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
7235 switch (user_reg_hint_type) {
7236 case NL80211_USER_REG_HINT_USER:
7237 case NL80211_USER_REG_HINT_CELL_BASE:
7238 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
7241 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
7242 return regulatory_hint_user(data, user_reg_hint_type);
7243 case NL80211_USER_REG_HINT_INDOOR:
7244 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
7245 owner_nlportid = info->snd_portid;
7246 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
7252 return regulatory_hint_indoor(is_indoor, owner_nlportid);
7258 static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info)
7260 return reg_reload_regdb();
7263 static int nl80211_get_mesh_config(struct sk_buff *skb,
7264 struct genl_info *info)
7266 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7267 struct net_device *dev = info->user_ptr[1];
7268 struct wireless_dev *wdev = dev->ieee80211_ptr;
7269 struct mesh_config cur_params;
7272 struct nlattr *pinfoattr;
7273 struct sk_buff *msg;
7275 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
7278 if (!rdev->ops->get_mesh_config)
7282 /* If not connected, get default parameters */
7283 if (!wdev->mesh_id_len)
7284 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
7286 err = rdev_get_mesh_config(rdev, dev, &cur_params);
7292 /* Draw up a netlink message to send back */
7293 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7296 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7297 NL80211_CMD_GET_MESH_CONFIG);
7300 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MESH_CONFIG);
7302 goto nla_put_failure;
7303 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
7304 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
7305 cur_params.dot11MeshRetryTimeout) ||
7306 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
7307 cur_params.dot11MeshConfirmTimeout) ||
7308 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
7309 cur_params.dot11MeshHoldingTimeout) ||
7310 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
7311 cur_params.dot11MeshMaxPeerLinks) ||
7312 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
7313 cur_params.dot11MeshMaxRetries) ||
7314 nla_put_u8(msg, NL80211_MESHCONF_TTL,
7315 cur_params.dot11MeshTTL) ||
7316 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
7317 cur_params.element_ttl) ||
7318 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
7319 cur_params.auto_open_plinks) ||
7320 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
7321 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
7322 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
7323 cur_params.dot11MeshHWMPmaxPREQretries) ||
7324 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
7325 cur_params.path_refresh_time) ||
7326 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
7327 cur_params.min_discovery_timeout) ||
7328 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
7329 cur_params.dot11MeshHWMPactivePathTimeout) ||
7330 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
7331 cur_params.dot11MeshHWMPpreqMinInterval) ||
7332 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
7333 cur_params.dot11MeshHWMPperrMinInterval) ||
7334 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
7335 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
7336 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
7337 cur_params.dot11MeshHWMPRootMode) ||
7338 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
7339 cur_params.dot11MeshHWMPRannInterval) ||
7340 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
7341 cur_params.dot11MeshGateAnnouncementProtocol) ||
7342 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
7343 cur_params.dot11MeshForwarding) ||
7344 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
7345 cur_params.rssi_threshold) ||
7346 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
7347 cur_params.ht_opmode) ||
7348 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
7349 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
7350 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
7351 cur_params.dot11MeshHWMProotInterval) ||
7352 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
7353 cur_params.dot11MeshHWMPconfirmationInterval) ||
7354 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
7355 cur_params.power_mode) ||
7356 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
7357 cur_params.dot11MeshAwakeWindowDuration) ||
7358 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
7359 cur_params.plink_timeout) ||
7360 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_GATE,
7361 cur_params.dot11MeshConnectedToMeshGate) ||
7362 nla_put_u8(msg, NL80211_MESHCONF_NOLEARN,
7363 cur_params.dot11MeshNolearn) ||
7364 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_AS,
7365 cur_params.dot11MeshConnectedToAuthServer))
7366 goto nla_put_failure;
7367 nla_nest_end(msg, pinfoattr);
7368 genlmsg_end(msg, hdr);
7369 return genlmsg_reply(msg, info);
7377 static const struct nla_policy
7378 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
7379 [NL80211_MESHCONF_RETRY_TIMEOUT] =
7380 NLA_POLICY_RANGE(NLA_U16, 1, 255),
7381 [NL80211_MESHCONF_CONFIRM_TIMEOUT] =
7382 NLA_POLICY_RANGE(NLA_U16, 1, 255),
7383 [NL80211_MESHCONF_HOLDING_TIMEOUT] =
7384 NLA_POLICY_RANGE(NLA_U16, 1, 255),
7385 [NL80211_MESHCONF_MAX_PEER_LINKS] =
7386 NLA_POLICY_RANGE(NLA_U16, 0, 255),
7387 [NL80211_MESHCONF_MAX_RETRIES] = NLA_POLICY_MAX(NLA_U8, 16),
7388 [NL80211_MESHCONF_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
7389 [NL80211_MESHCONF_ELEMENT_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
7390 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = NLA_POLICY_MAX(NLA_U8, 1),
7391 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] =
7392 NLA_POLICY_RANGE(NLA_U32, 1, 255),
7393 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
7394 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
7395 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = NLA_POLICY_MIN(NLA_U16, 1),
7396 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
7397 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] =
7398 NLA_POLICY_MIN(NLA_U16, 1),
7399 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] =
7400 NLA_POLICY_MIN(NLA_U16, 1),
7401 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] =
7402 NLA_POLICY_MIN(NLA_U16, 1),
7403 [NL80211_MESHCONF_HWMP_ROOTMODE] = NLA_POLICY_MAX(NLA_U8, 4),
7404 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] =
7405 NLA_POLICY_MIN(NLA_U16, 1),
7406 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = NLA_POLICY_MAX(NLA_U8, 1),
7407 [NL80211_MESHCONF_FORWARDING] = NLA_POLICY_MAX(NLA_U8, 1),
7408 [NL80211_MESHCONF_RSSI_THRESHOLD] =
7409 NLA_POLICY_RANGE(NLA_S32, -255, 0),
7410 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
7411 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
7412 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] =
7413 NLA_POLICY_MIN(NLA_U16, 1),
7414 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] =
7415 NLA_POLICY_MIN(NLA_U16, 1),
7416 [NL80211_MESHCONF_POWER_MODE] =
7417 NLA_POLICY_RANGE(NLA_U32,
7418 NL80211_MESH_POWER_ACTIVE,
7419 NL80211_MESH_POWER_MAX),
7420 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
7421 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
7422 [NL80211_MESHCONF_CONNECTED_TO_GATE] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
7423 [NL80211_MESHCONF_NOLEARN] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
7424 [NL80211_MESHCONF_CONNECTED_TO_AS] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
7427 static const struct nla_policy
7428 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
7429 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
7430 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
7431 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
7432 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
7433 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
7434 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
7435 [NL80211_MESH_SETUP_IE] =
7436 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
7437 IEEE80211_MAX_DATA_LEN),
7438 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
7441 static int nl80211_parse_mesh_config(struct genl_info *info,
7442 struct mesh_config *cfg,
7445 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
7449 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \
7452 cfg->param = fn(tb[attr]); \
7453 mask |= BIT((attr) - 1); \
7457 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
7459 if (nla_parse_nested_deprecated(tb, NL80211_MESHCONF_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_CONFIG], nl80211_meshconf_params_policy, info->extack))
7462 /* This makes sure that there aren't more than 32 mesh config
7463 * parameters (otherwise our bitfield scheme would not work.) */
7464 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
7466 /* Fill in the params struct */
7467 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, mask,
7468 NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
7469 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, mask,
7470 NL80211_MESHCONF_CONFIRM_TIMEOUT,
7472 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, mask,
7473 NL80211_MESHCONF_HOLDING_TIMEOUT,
7475 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, mask,
7476 NL80211_MESHCONF_MAX_PEER_LINKS,
7478 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, mask,
7479 NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
7480 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, mask,
7481 NL80211_MESHCONF_TTL, nla_get_u8);
7482 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, mask,
7483 NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
7484 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, mask,
7485 NL80211_MESHCONF_AUTO_OPEN_PLINKS,
7487 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
7489 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
7491 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, mask,
7492 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
7494 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, mask,
7495 NL80211_MESHCONF_PATH_REFRESH_TIME,
7497 if (mask & BIT(NL80211_MESHCONF_PATH_REFRESH_TIME) &&
7498 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535))
7500 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, mask,
7501 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
7503 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
7505 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
7507 if (mask & BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT) &&
7508 (cfg->dot11MeshHWMPactivePathTimeout < 1 ||
7509 cfg->dot11MeshHWMPactivePathTimeout > 65535))
7511 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, mask,
7512 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
7514 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval, mask,
7515 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
7517 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
7518 dot11MeshHWMPnetDiameterTraversalTime, mask,
7519 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
7521 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask,
7522 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8);
7523 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask,
7524 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
7526 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshGateAnnouncementProtocol,
7527 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
7529 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, mask,
7530 NL80211_MESHCONF_FORWARDING, nla_get_u8);
7531 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, mask,
7532 NL80211_MESHCONF_RSSI_THRESHOLD,
7534 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToMeshGate, mask,
7535 NL80211_MESHCONF_CONNECTED_TO_GATE,
7537 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToAuthServer, mask,
7538 NL80211_MESHCONF_CONNECTED_TO_AS,
7541 * Check HT operation mode based on
7542 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
7544 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
7545 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
7547 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
7548 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
7549 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
7552 /* NON_HT_STA bit is reserved, but some programs set it */
7553 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
7555 cfg->ht_opmode = ht_opmode;
7556 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
7558 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
7559 dot11MeshHWMPactivePathToRootTimeout, mask,
7560 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
7562 if (mask & BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT) &&
7563 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 ||
7564 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535))
7566 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, mask,
7567 NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
7569 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPconfirmationInterval,
7571 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
7573 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode, mask,
7574 NL80211_MESHCONF_POWER_MODE, nla_get_u32);
7575 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration, mask,
7576 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
7577 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, mask,
7578 NL80211_MESHCONF_PLINK_TIMEOUT, nla_get_u32);
7579 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNolearn, mask,
7580 NL80211_MESHCONF_NOLEARN, nla_get_u8);
7586 #undef FILL_IN_MESH_PARAM_IF_SET
7589 static int nl80211_parse_mesh_setup(struct genl_info *info,
7590 struct mesh_setup *setup)
7592 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7593 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
7595 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
7597 if (nla_parse_nested_deprecated(tb, NL80211_MESH_SETUP_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_SETUP], nl80211_mesh_setup_params_policy, info->extack))
7600 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
7601 setup->sync_method =
7602 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
7603 IEEE80211_SYNC_METHOD_VENDOR :
7604 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
7606 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
7607 setup->path_sel_proto =
7608 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
7609 IEEE80211_PATH_PROTOCOL_VENDOR :
7610 IEEE80211_PATH_PROTOCOL_HWMP;
7612 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
7613 setup->path_metric =
7614 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
7615 IEEE80211_PATH_METRIC_VENDOR :
7616 IEEE80211_PATH_METRIC_AIRTIME;
7618 if (tb[NL80211_MESH_SETUP_IE]) {
7619 struct nlattr *ieattr =
7620 tb[NL80211_MESH_SETUP_IE];
7621 setup->ie = nla_data(ieattr);
7622 setup->ie_len = nla_len(ieattr);
7624 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
7625 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
7627 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
7628 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
7629 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
7630 if (setup->is_secure)
7631 setup->user_mpm = true;
7633 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
7634 if (!setup->user_mpm)
7637 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
7643 static int nl80211_update_mesh_config(struct sk_buff *skb,
7644 struct genl_info *info)
7646 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7647 struct net_device *dev = info->user_ptr[1];
7648 struct wireless_dev *wdev = dev->ieee80211_ptr;
7649 struct mesh_config cfg;
7653 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
7656 if (!rdev->ops->update_mesh_config)
7659 err = nl80211_parse_mesh_config(info, &cfg, &mask);
7664 if (!wdev->mesh_id_len)
7668 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
7675 static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
7676 struct sk_buff *msg)
7678 struct nlattr *nl_reg_rules;
7681 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
7682 (regdom->dfs_region &&
7683 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
7684 goto nla_put_failure;
7686 nl_reg_rules = nla_nest_start_noflag(msg, NL80211_ATTR_REG_RULES);
7688 goto nla_put_failure;
7690 for (i = 0; i < regdom->n_reg_rules; i++) {
7691 struct nlattr *nl_reg_rule;
7692 const struct ieee80211_reg_rule *reg_rule;
7693 const struct ieee80211_freq_range *freq_range;
7694 const struct ieee80211_power_rule *power_rule;
7695 unsigned int max_bandwidth_khz;
7697 reg_rule = ®dom->reg_rules[i];
7698 freq_range = ®_rule->freq_range;
7699 power_rule = ®_rule->power_rule;
7701 nl_reg_rule = nla_nest_start_noflag(msg, i);
7703 goto nla_put_failure;
7705 max_bandwidth_khz = freq_range->max_bandwidth_khz;
7706 if (!max_bandwidth_khz)
7707 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
7710 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
7712 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
7713 freq_range->start_freq_khz) ||
7714 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
7715 freq_range->end_freq_khz) ||
7716 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
7717 max_bandwidth_khz) ||
7718 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
7719 power_rule->max_antenna_gain) ||
7720 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
7721 power_rule->max_eirp) ||
7722 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
7723 reg_rule->dfs_cac_ms))
7724 goto nla_put_failure;
7726 nla_nest_end(msg, nl_reg_rule);
7729 nla_nest_end(msg, nl_reg_rules);
7736 static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
7738 const struct ieee80211_regdomain *regdom = NULL;
7739 struct cfg80211_registered_device *rdev;
7740 struct wiphy *wiphy = NULL;
7741 struct sk_buff *msg;
7744 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7748 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7749 NL80211_CMD_GET_REG);
7755 if (info->attrs[NL80211_ATTR_WIPHY]) {
7758 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
7762 return PTR_ERR(rdev);
7765 wiphy = &rdev->wiphy;
7766 self_managed = wiphy->regulatory_flags &
7767 REGULATORY_WIPHY_SELF_MANAGED;
7768 regdom = get_wiphy_regdom(wiphy);
7770 /* a self-managed-reg device must have a private regdom */
7771 if (WARN_ON(!regdom && self_managed)) {
7778 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7779 goto nla_put_failure;
7782 if (!wiphy && reg_last_request_cell_base() &&
7783 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
7784 NL80211_USER_REG_HINT_CELL_BASE))
7785 goto nla_put_failure;
7790 regdom = rcu_dereference(cfg80211_regdomain);
7792 if (nl80211_put_regdom(regdom, msg))
7793 goto nla_put_failure_rcu;
7797 genlmsg_end(msg, hdr);
7799 return genlmsg_reply(msg, info);
7801 nla_put_failure_rcu:
7810 static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
7811 u32 seq, int flags, struct wiphy *wiphy,
7812 const struct ieee80211_regdomain *regdom)
7814 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
7815 NL80211_CMD_GET_REG);
7820 genl_dump_check_consistent(cb, hdr);
7822 if (nl80211_put_regdom(regdom, msg))
7823 goto nla_put_failure;
7825 if (!wiphy && reg_last_request_cell_base() &&
7826 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
7827 NL80211_USER_REG_HINT_CELL_BASE))
7828 goto nla_put_failure;
7831 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7832 goto nla_put_failure;
7834 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
7835 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
7836 goto nla_put_failure;
7838 genlmsg_end(msg, hdr);
7842 genlmsg_cancel(msg, hdr);
7846 static int nl80211_get_reg_dump(struct sk_buff *skb,
7847 struct netlink_callback *cb)
7849 const struct ieee80211_regdomain *regdom = NULL;
7850 struct cfg80211_registered_device *rdev;
7851 int err, reg_idx, start = cb->args[2];
7855 if (cfg80211_regdomain && start == 0) {
7856 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
7858 rtnl_dereference(cfg80211_regdomain));
7863 /* the global regdom is idx 0 */
7865 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
7866 regdom = get_wiphy_regdom(&rdev->wiphy);
7870 if (++reg_idx <= start)
7873 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
7874 NLM_F_MULTI, &rdev->wiphy, regdom);
7881 cb->args[2] = reg_idx;
7888 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
7889 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
7890 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
7891 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
7892 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
7893 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
7894 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
7895 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
7896 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
7899 static int parse_reg_rule(struct nlattr *tb[],
7900 struct ieee80211_reg_rule *reg_rule)
7902 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
7903 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
7905 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
7907 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
7909 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
7911 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
7913 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
7916 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
7918 freq_range->start_freq_khz =
7919 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
7920 freq_range->end_freq_khz =
7921 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
7922 freq_range->max_bandwidth_khz =
7923 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
7925 power_rule->max_eirp =
7926 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
7928 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
7929 power_rule->max_antenna_gain =
7930 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
7932 if (tb[NL80211_ATTR_DFS_CAC_TIME])
7933 reg_rule->dfs_cac_ms =
7934 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
7939 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
7941 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
7942 struct nlattr *nl_reg_rule;
7944 int rem_reg_rules, r;
7945 u32 num_rules = 0, rule_idx = 0;
7946 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
7947 struct ieee80211_regdomain *rd;
7949 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
7952 if (!info->attrs[NL80211_ATTR_REG_RULES])
7955 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
7957 if (info->attrs[NL80211_ATTR_DFS_REGION])
7958 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
7960 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
7963 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
7968 if (!reg_is_valid_request(alpha2)) {
7973 rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL);
7979 rd->n_reg_rules = num_rules;
7980 rd->alpha2[0] = alpha2[0];
7981 rd->alpha2[1] = alpha2[1];
7984 * Disable DFS master mode if the DFS region was
7985 * not supported or known on this kernel.
7987 if (reg_supported_dfs_region(dfs_region))
7988 rd->dfs_region = dfs_region;
7990 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
7992 r = nla_parse_nested_deprecated(tb, NL80211_REG_RULE_ATTR_MAX,
7993 nl_reg_rule, reg_rule_policy,
7997 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
8003 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
8009 r = set_regdom(rd, REGD_SOURCE_CRDA);
8010 /* set_regdom takes ownership of rd */
8018 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
8020 static int validate_scan_freqs(struct nlattr *freqs)
8022 struct nlattr *attr1, *attr2;
8023 int n_channels = 0, tmp1, tmp2;
8025 nla_for_each_nested(attr1, freqs, tmp1)
8026 if (nla_len(attr1) != sizeof(u32))
8029 nla_for_each_nested(attr1, freqs, tmp1) {
8032 * Some hardware has a limited channel list for
8033 * scanning, and it is pretty much nonsensical
8034 * to scan for a channel twice, so disallow that
8035 * and don't require drivers to check that the
8036 * channel list they get isn't longer than what
8037 * they can scan, as long as they can scan all
8038 * the channels they registered at once.
8040 nla_for_each_nested(attr2, freqs, tmp2)
8041 if (attr1 != attr2 &&
8042 nla_get_u32(attr1) == nla_get_u32(attr2))
8049 static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
8051 return b < NUM_NL80211_BANDS && wiphy->bands[b];
8054 static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
8055 struct cfg80211_bss_selection *bss_select)
8057 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
8058 struct nlattr *nest;
8063 /* only process one nested attribute */
8064 nest = nla_data(nla);
8065 if (!nla_ok(nest, nla_len(nest)))
8068 err = nla_parse_nested_deprecated(attr, NL80211_BSS_SELECT_ATTR_MAX,
8069 nest, nl80211_bss_select_policy,
8074 /* only one attribute may be given */
8075 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
8083 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
8085 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
8086 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
8088 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
8089 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
8090 bss_select->param.band_pref =
8091 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
8092 if (!is_band_valid(wiphy, bss_select->param.band_pref))
8096 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
8097 struct nl80211_bss_select_rssi_adjust *adj_param;
8099 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
8100 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
8101 bss_select->param.adjust.band = adj_param->band;
8102 bss_select->param.adjust.delta = adj_param->delta;
8103 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
8107 /* user-space did not provide behaviour attribute */
8108 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
8111 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
8117 int nl80211_parse_random_mac(struct nlattr **attrs,
8118 u8 *mac_addr, u8 *mac_addr_mask)
8122 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
8123 eth_zero_addr(mac_addr);
8124 eth_zero_addr(mac_addr_mask);
8126 mac_addr_mask[0] = 0x3;
8131 /* need both or none */
8132 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
8135 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
8136 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
8138 /* don't allow or configure an mcast address */
8139 if (!is_multicast_ether_addr(mac_addr_mask) ||
8140 is_multicast_ether_addr(mac_addr))
8144 * allow users to pass a MAC address that has bits set outside
8145 * of the mask, but don't bother drivers with having to deal
8148 for (i = 0; i < ETH_ALEN; i++)
8149 mac_addr[i] &= mac_addr_mask[i];
8154 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
8156 ASSERT_WDEV_LOCK(wdev);
8158 if (!cfg80211_beaconing_iface_active(wdev))
8161 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
8164 return regulatory_pre_cac_allowed(wdev->wiphy);
8167 static bool nl80211_check_scan_feat(struct wiphy *wiphy, u32 flags, u32 flag,
8168 enum nl80211_ext_feature_index feat)
8170 if (!(flags & flag))
8172 if (wiphy_ext_feature_isset(wiphy, feat))
8178 nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
8179 void *request, struct nlattr **attrs,
8182 u8 *mac_addr, *mac_addr_mask;
8184 enum nl80211_feature_flags randomness_flag;
8186 if (!attrs[NL80211_ATTR_SCAN_FLAGS])
8189 if (is_sched_scan) {
8190 struct cfg80211_sched_scan_request *req = request;
8192 randomness_flag = wdev ?
8193 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR :
8194 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
8195 flags = &req->flags;
8196 mac_addr = req->mac_addr;
8197 mac_addr_mask = req->mac_addr_mask;
8199 struct cfg80211_scan_request *req = request;
8201 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
8202 flags = &req->flags;
8203 mac_addr = req->mac_addr;
8204 mac_addr_mask = req->mac_addr_mask;
8207 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
8209 if (((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
8210 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
8211 !nl80211_check_scan_feat(wiphy, *flags,
8212 NL80211_SCAN_FLAG_LOW_SPAN,
8213 NL80211_EXT_FEATURE_LOW_SPAN_SCAN) ||
8214 !nl80211_check_scan_feat(wiphy, *flags,
8215 NL80211_SCAN_FLAG_LOW_POWER,
8216 NL80211_EXT_FEATURE_LOW_POWER_SCAN) ||
8217 !nl80211_check_scan_feat(wiphy, *flags,
8218 NL80211_SCAN_FLAG_HIGH_ACCURACY,
8219 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN) ||
8220 !nl80211_check_scan_feat(wiphy, *flags,
8221 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME,
8222 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) ||
8223 !nl80211_check_scan_feat(wiphy, *flags,
8224 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP,
8225 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) ||
8226 !nl80211_check_scan_feat(wiphy, *flags,
8227 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION,
8228 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) ||
8229 !nl80211_check_scan_feat(wiphy, *flags,
8230 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE,
8231 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) ||
8232 !nl80211_check_scan_feat(wiphy, *flags,
8233 NL80211_SCAN_FLAG_RANDOM_SN,
8234 NL80211_EXT_FEATURE_SCAN_RANDOM_SN) ||
8235 !nl80211_check_scan_feat(wiphy, *flags,
8236 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT,
8237 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
8240 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
8243 if (!(wiphy->features & randomness_flag) ||
8244 (wdev && wdev->current_bss))
8247 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask);
8255 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
8257 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8258 struct wireless_dev *wdev = info->user_ptr[1];
8259 struct cfg80211_scan_request *request;
8260 struct nlattr *scan_freqs = NULL;
8261 bool scan_freqs_khz = false;
8262 struct nlattr *attr;
8263 struct wiphy *wiphy;
8264 int err, tmp, n_ssids = 0, n_channels, i;
8267 wiphy = &rdev->wiphy;
8269 if (wdev->iftype == NL80211_IFTYPE_NAN)
8272 if (!rdev->ops->scan)
8275 if (rdev->scan_req || rdev->scan_msg)
8278 if (info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ]) {
8279 if (!wiphy_ext_feature_isset(wiphy,
8280 NL80211_EXT_FEATURE_SCAN_FREQ_KHZ))
8282 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ];
8283 scan_freqs_khz = true;
8284 } else if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES])
8285 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQUENCIES];
8288 n_channels = validate_scan_freqs(scan_freqs);
8292 n_channels = ieee80211_get_num_supported_channels(wiphy);
8295 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
8296 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
8299 if (n_ssids > wiphy->max_scan_ssids)
8302 if (info->attrs[NL80211_ATTR_IE])
8303 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8307 if (ie_len > wiphy->max_scan_ie_len)
8310 request = kzalloc(sizeof(*request)
8311 + sizeof(*request->ssids) * n_ssids
8312 + sizeof(*request->channels) * n_channels
8313 + ie_len, GFP_KERNEL);
8318 request->ssids = (void *)&request->channels[n_channels];
8319 request->n_ssids = n_ssids;
8322 request->ie = (void *)(request->ssids + n_ssids);
8324 request->ie = (void *)(request->channels + n_channels);
8329 /* user specified, bail out if channel not found */
8330 nla_for_each_nested(attr, scan_freqs, tmp) {
8331 struct ieee80211_channel *chan;
8332 int freq = nla_get_u32(attr);
8334 if (!scan_freqs_khz)
8335 freq = MHZ_TO_KHZ(freq);
8337 chan = ieee80211_get_channel_khz(wiphy, freq);
8343 /* ignore disabled channels */
8344 if (chan->flags & IEEE80211_CHAN_DISABLED)
8347 request->channels[i] = chan;
8351 enum nl80211_band band;
8354 for (band = 0; band < NUM_NL80211_BANDS; band++) {
8357 if (!wiphy->bands[band])
8359 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
8360 struct ieee80211_channel *chan;
8362 chan = &wiphy->bands[band]->channels[j];
8364 if (chan->flags & IEEE80211_CHAN_DISABLED)
8367 request->channels[i] = chan;
8378 request->n_channels = i;
8381 if (!cfg80211_off_channel_oper_allowed(wdev)) {
8382 struct ieee80211_channel *chan;
8384 if (request->n_channels != 1) {
8390 chan = request->channels[0];
8391 if (chan->center_freq != wdev->chandef.chan->center_freq) {
8401 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
8402 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
8406 request->ssids[i].ssid_len = nla_len(attr);
8407 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
8412 if (info->attrs[NL80211_ATTR_IE]) {
8413 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8414 memcpy((void *)request->ie,
8415 nla_data(info->attrs[NL80211_ATTR_IE]),
8419 for (i = 0; i < NUM_NL80211_BANDS; i++)
8420 if (wiphy->bands[i])
8422 (1 << wiphy->bands[i]->n_bitrates) - 1;
8424 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
8425 nla_for_each_nested(attr,
8426 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
8428 enum nl80211_band band = nla_type(attr);
8430 if (band < 0 || band >= NUM_NL80211_BANDS) {
8435 if (!wiphy->bands[band])
8438 err = ieee80211_get_ratemask(wiphy->bands[band],
8441 &request->rates[band]);
8447 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
8449 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
8450 request->duration_mandatory =
8451 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
8454 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
8460 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
8462 /* Initial implementation used NL80211_ATTR_MAC to set the specific
8463 * BSSID to scan for. This was problematic because that same attribute
8464 * was already used for another purpose (local random MAC address). The
8465 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
8466 * compatibility with older userspace components, also use the
8467 * NL80211_ATTR_MAC value here if it can be determined to be used for
8468 * the specific BSSID use case instead of the random MAC address
8469 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
8471 if (info->attrs[NL80211_ATTR_BSSID])
8472 memcpy(request->bssid,
8473 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
8474 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
8475 info->attrs[NL80211_ATTR_MAC])
8476 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
8479 eth_broadcast_addr(request->bssid);
8481 request->wdev = wdev;
8482 request->wiphy = &rdev->wiphy;
8483 request->scan_start = jiffies;
8485 rdev->scan_req = request;
8486 err = cfg80211_scan(rdev);
8491 nl80211_send_scan_start(rdev, wdev);
8493 dev_hold(wdev->netdev);
8498 rdev->scan_req = NULL;
8504 static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
8506 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8507 struct wireless_dev *wdev = info->user_ptr[1];
8509 if (!rdev->ops->abort_scan)
8515 if (!rdev->scan_req)
8518 rdev_abort_scan(rdev, wdev);
8523 nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
8524 struct cfg80211_sched_scan_request *request,
8525 struct nlattr **attrs)
8527 int tmp, err, i = 0;
8528 struct nlattr *attr;
8530 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
8534 * If scan plans are not specified,
8535 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
8536 * case one scan plan will be set with the specified scan
8537 * interval and infinite number of iterations.
8539 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
8543 request->scan_plans[0].interval =
8544 DIV_ROUND_UP(interval, MSEC_PER_SEC);
8545 if (!request->scan_plans[0].interval)
8548 if (request->scan_plans[0].interval >
8549 wiphy->max_sched_scan_plan_interval)
8550 request->scan_plans[0].interval =
8551 wiphy->max_sched_scan_plan_interval;
8556 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
8557 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
8559 if (WARN_ON(i >= n_plans))
8562 err = nla_parse_nested_deprecated(plan,
8563 NL80211_SCHED_SCAN_PLAN_MAX,
8564 attr, nl80211_plan_policy,
8569 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
8572 request->scan_plans[i].interval =
8573 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
8574 if (!request->scan_plans[i].interval ||
8575 request->scan_plans[i].interval >
8576 wiphy->max_sched_scan_plan_interval)
8579 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
8580 request->scan_plans[i].iterations =
8581 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
8582 if (!request->scan_plans[i].iterations ||
8583 (request->scan_plans[i].iterations >
8584 wiphy->max_sched_scan_plan_iterations))
8586 } else if (i < n_plans - 1) {
8588 * All scan plans but the last one must specify
8589 * a finite number of iterations
8598 * The last scan plan must not specify the number of
8599 * iterations, it is supposed to run infinitely
8601 if (request->scan_plans[n_plans - 1].iterations)
8608 nl80211_parse_sched_scan_per_band_rssi(struct wiphy *wiphy,
8609 struct cfg80211_match_set *match_sets,
8610 struct nlattr *tb_band_rssi,
8613 struct nlattr *attr;
8614 int i, tmp, ret = 0;
8616 if (!wiphy_ext_feature_isset(wiphy,
8617 NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD)) {
8621 for (i = 0; i < NUM_NL80211_BANDS; i++)
8622 match_sets->per_band_rssi_thold[i] =
8623 NL80211_SCAN_RSSI_THOLD_OFF;
8627 for (i = 0; i < NUM_NL80211_BANDS; i++)
8628 match_sets->per_band_rssi_thold[i] = rssi_thold;
8630 nla_for_each_nested(attr, tb_band_rssi, tmp) {
8631 enum nl80211_band band = nla_type(attr);
8633 if (band < 0 || band >= NUM_NL80211_BANDS)
8636 match_sets->per_band_rssi_thold[band] = nla_get_s32(attr);
8642 static struct cfg80211_sched_scan_request *
8643 nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
8644 struct nlattr **attrs, int max_match_sets)
8646 struct cfg80211_sched_scan_request *request;
8647 struct nlattr *attr;
8648 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
8649 enum nl80211_band band;
8651 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
8652 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
8654 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
8655 n_channels = validate_scan_freqs(
8656 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
8658 return ERR_PTR(-EINVAL);
8660 n_channels = ieee80211_get_num_supported_channels(wiphy);
8663 if (attrs[NL80211_ATTR_SCAN_SSIDS])
8664 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
8668 if (n_ssids > wiphy->max_sched_scan_ssids)
8669 return ERR_PTR(-EINVAL);
8672 * First, count the number of 'real' matchsets. Due to an issue with
8673 * the old implementation, matchsets containing only the RSSI attribute
8674 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
8675 * RSSI for all matchsets, rather than their own matchset for reporting
8676 * all APs with a strong RSSI. This is needed to be compatible with
8677 * older userspace that treated a matchset with only the RSSI as the
8678 * global RSSI for all other matchsets - if there are other matchsets.
8680 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
8681 nla_for_each_nested(attr,
8682 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
8684 struct nlattr *rssi;
8686 err = nla_parse_nested_deprecated(tb,
8687 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
8689 nl80211_match_policy,
8692 return ERR_PTR(err);
8694 /* SSID and BSSID are mutually exclusive */
8695 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
8696 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
8697 return ERR_PTR(-EINVAL);
8699 /* add other standalone attributes here */
8700 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
8701 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
8705 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
8707 default_match_rssi = nla_get_s32(rssi);
8711 /* However, if there's no other matchset, add the RSSI one */
8712 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
8715 if (n_match_sets > max_match_sets)
8716 return ERR_PTR(-EINVAL);
8718 if (attrs[NL80211_ATTR_IE])
8719 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
8723 if (ie_len > wiphy->max_sched_scan_ie_len)
8724 return ERR_PTR(-EINVAL);
8726 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
8728 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
8729 * each scan plan already specifies its own interval
8731 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
8732 return ERR_PTR(-EINVAL);
8734 nla_for_each_nested(attr,
8735 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
8739 * The scan interval attribute is kept for backward
8740 * compatibility. If no scan plans are specified and sched scan
8741 * interval is specified, one scan plan will be set with this
8742 * scan interval and infinite number of iterations.
8744 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
8745 return ERR_PTR(-EINVAL);
8750 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
8751 return ERR_PTR(-EINVAL);
8753 if (!wiphy_ext_feature_isset(
8754 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
8755 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
8756 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
8757 return ERR_PTR(-EINVAL);
8759 request = kzalloc(sizeof(*request)
8760 + sizeof(*request->ssids) * n_ssids
8761 + sizeof(*request->match_sets) * n_match_sets
8762 + sizeof(*request->scan_plans) * n_plans
8763 + sizeof(*request->channels) * n_channels
8764 + ie_len, GFP_KERNEL);
8766 return ERR_PTR(-ENOMEM);
8769 request->ssids = (void *)&request->channels[n_channels];
8770 request->n_ssids = n_ssids;
8773 request->ie = (void *)(request->ssids + n_ssids);
8775 request->ie = (void *)(request->channels + n_channels);
8780 request->match_sets = (void *)(request->ie + ie_len);
8782 request->match_sets =
8783 (void *)(request->ssids + n_ssids);
8785 request->match_sets =
8786 (void *)(request->channels + n_channels);
8788 request->n_match_sets = n_match_sets;
8791 request->scan_plans = (void *)(request->match_sets +
8793 else if (request->ie)
8794 request->scan_plans = (void *)(request->ie + ie_len);
8796 request->scan_plans = (void *)(request->ssids + n_ssids);
8798 request->scan_plans = (void *)(request->channels + n_channels);
8800 request->n_scan_plans = n_plans;
8803 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
8804 /* user specified, bail out if channel not found */
8805 nla_for_each_nested(attr,
8806 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
8808 struct ieee80211_channel *chan;
8810 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
8817 /* ignore disabled channels */
8818 if (chan->flags & IEEE80211_CHAN_DISABLED)
8821 request->channels[i] = chan;
8826 for (band = 0; band < NUM_NL80211_BANDS; band++) {
8829 if (!wiphy->bands[band])
8831 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
8832 struct ieee80211_channel *chan;
8834 chan = &wiphy->bands[band]->channels[j];
8836 if (chan->flags & IEEE80211_CHAN_DISABLED)
8839 request->channels[i] = chan;
8850 request->n_channels = i;
8854 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
8856 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
8860 request->ssids[i].ssid_len = nla_len(attr);
8861 memcpy(request->ssids[i].ssid, nla_data(attr),
8868 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
8869 nla_for_each_nested(attr,
8870 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
8872 struct nlattr *ssid, *bssid, *rssi;
8874 err = nla_parse_nested_deprecated(tb,
8875 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
8877 nl80211_match_policy,
8881 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
8882 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
8884 if (!ssid && !bssid) {
8889 if (WARN_ON(i >= n_match_sets)) {
8890 /* this indicates a programming error,
8891 * the loop above should have verified
8899 memcpy(request->match_sets[i].ssid.ssid,
8900 nla_data(ssid), nla_len(ssid));
8901 request->match_sets[i].ssid.ssid_len =
8905 memcpy(request->match_sets[i].bssid,
8906 nla_data(bssid), ETH_ALEN);
8908 /* special attribute - old implementation w/a */
8909 request->match_sets[i].rssi_thold = default_match_rssi;
8910 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
8912 request->match_sets[i].rssi_thold =
8915 /* Parse per band RSSI attribute */
8916 err = nl80211_parse_sched_scan_per_band_rssi(wiphy,
8917 &request->match_sets[i],
8918 tb[NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI],
8919 request->match_sets[i].rssi_thold);
8926 /* there was no other matchset, so the RSSI one is alone */
8927 if (i == 0 && n_match_sets)
8928 request->match_sets[0].rssi_thold = default_match_rssi;
8930 request->min_rssi_thold = INT_MAX;
8931 for (i = 0; i < n_match_sets; i++)
8932 request->min_rssi_thold =
8933 min(request->match_sets[i].rssi_thold,
8934 request->min_rssi_thold);
8936 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
8940 request->ie_len = ie_len;
8941 memcpy((void *)request->ie,
8942 nla_data(attrs[NL80211_ATTR_IE]),
8946 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true);
8950 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
8952 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
8954 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
8955 request->relative_rssi = nla_get_s8(
8956 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
8957 request->relative_rssi_set = true;
8960 if (request->relative_rssi_set &&
8961 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
8962 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
8964 rssi_adjust = nla_data(
8965 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
8966 request->rssi_adjust.band = rssi_adjust->band;
8967 request->rssi_adjust.delta = rssi_adjust->delta;
8968 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
8974 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
8978 request->scan_start = jiffies;
8984 return ERR_PTR(err);
8987 static int nl80211_start_sched_scan(struct sk_buff *skb,
8988 struct genl_info *info)
8990 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8991 struct net_device *dev = info->user_ptr[1];
8992 struct wireless_dev *wdev = dev->ieee80211_ptr;
8993 struct cfg80211_sched_scan_request *sched_scan_req;
8997 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
9000 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
9001 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
9005 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
9007 rdev->wiphy.max_match_sets);
9009 err = PTR_ERR_OR_ZERO(sched_scan_req);
9013 /* leave request id zero for legacy request
9014 * or if driver does not support multi-scheduled scan
9016 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1)
9017 sched_scan_req->reqid = cfg80211_assign_cookie(rdev);
9019 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
9023 sched_scan_req->dev = dev;
9024 sched_scan_req->wiphy = &rdev->wiphy;
9026 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
9027 sched_scan_req->owner_nlportid = info->snd_portid;
9029 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
9031 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
9035 kfree(sched_scan_req);
9040 static int nl80211_stop_sched_scan(struct sk_buff *skb,
9041 struct genl_info *info)
9043 struct cfg80211_sched_scan_request *req;
9044 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9047 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
9050 if (info->attrs[NL80211_ATTR_COOKIE]) {
9051 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9052 return __cfg80211_stop_sched_scan(rdev, cookie, false);
9055 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
9056 struct cfg80211_sched_scan_request,
9058 if (!req || req->reqid ||
9059 (req->owner_nlportid &&
9060 req->owner_nlportid != info->snd_portid))
9063 return cfg80211_stop_sched_scan_req(rdev, req, false);
9066 static int nl80211_start_radar_detection(struct sk_buff *skb,
9067 struct genl_info *info)
9069 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9070 struct net_device *dev = info->user_ptr[1];
9071 struct wireless_dev *wdev = dev->ieee80211_ptr;
9072 struct wiphy *wiphy = wdev->wiphy;
9073 struct cfg80211_chan_def chandef;
9074 enum nl80211_dfs_regions dfs_region;
9075 unsigned int cac_time_ms;
9078 dfs_region = reg_get_dfs_region(wiphy);
9079 if (dfs_region == NL80211_DFS_UNSET)
9082 err = nl80211_parse_chandef(rdev, info, &chandef);
9086 if (netif_carrier_ok(dev))
9089 if (wdev->cac_started)
9092 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
9099 if (!cfg80211_chandef_dfs_usable(wiphy, &chandef))
9102 /* CAC start is offloaded to HW and can't be started manually */
9103 if (wiphy_ext_feature_isset(wiphy, NL80211_EXT_FEATURE_DFS_OFFLOAD))
9106 if (!rdev->ops->start_radar_detection)
9109 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
9110 if (WARN_ON(!cac_time_ms))
9111 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
9113 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
9115 wdev->chandef = chandef;
9116 wdev->cac_started = true;
9117 wdev->cac_start_time = jiffies;
9118 wdev->cac_time_ms = cac_time_ms;
9123 static int nl80211_notify_radar_detection(struct sk_buff *skb,
9124 struct genl_info *info)
9126 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9127 struct net_device *dev = info->user_ptr[1];
9128 struct wireless_dev *wdev = dev->ieee80211_ptr;
9129 struct wiphy *wiphy = wdev->wiphy;
9130 struct cfg80211_chan_def chandef;
9131 enum nl80211_dfs_regions dfs_region;
9134 dfs_region = reg_get_dfs_region(wiphy);
9135 if (dfs_region == NL80211_DFS_UNSET) {
9136 GENL_SET_ERR_MSG(info,
9137 "DFS Region is not set. Unexpected Radar indication");
9141 err = nl80211_parse_chandef(rdev, info, &chandef);
9143 GENL_SET_ERR_MSG(info, "Unable to extract chandef info");
9147 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
9149 GENL_SET_ERR_MSG(info, "chandef is invalid");
9154 GENL_SET_ERR_MSG(info,
9155 "Unexpected Radar indication for chandef/iftype");
9159 /* Do not process this notification if radar is already detected
9160 * by kernel on this channel, and return success.
9162 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE)
9165 cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_UNAVAILABLE);
9167 cfg80211_sched_dfs_chan_update(rdev);
9169 rdev->radar_chandef = chandef;
9171 /* Propagate this notification to other radios as well */
9172 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
9177 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
9179 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9180 struct net_device *dev = info->user_ptr[1];
9181 struct wireless_dev *wdev = dev->ieee80211_ptr;
9182 struct cfg80211_csa_settings params;
9183 struct nlattr **csa_attrs = NULL;
9185 bool need_new_beacon = false;
9186 bool need_handle_dfs_flag = true;
9190 if (!rdev->ops->channel_switch ||
9191 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
9194 switch (dev->ieee80211_ptr->iftype) {
9195 case NL80211_IFTYPE_AP:
9196 case NL80211_IFTYPE_P2P_GO:
9197 need_new_beacon = true;
9198 /* For all modes except AP the handle_dfs flag needs to be
9199 * supplied to tell the kernel that userspace will handle radar
9200 * events when they happen. Otherwise a switch to a channel
9201 * requiring DFS will be rejected.
9203 need_handle_dfs_flag = false;
9205 /* useless if AP is not running */
9206 if (!wdev->beacon_interval)
9209 case NL80211_IFTYPE_ADHOC:
9210 if (!wdev->ssid_len)
9213 case NL80211_IFTYPE_MESH_POINT:
9214 if (!wdev->mesh_id_len)
9221 memset(¶ms, 0, sizeof(params));
9222 params.beacon_csa.ftm_responder = -1;
9224 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
9225 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
9228 /* only important for AP, IBSS and mesh create IEs internally */
9229 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
9232 /* Even though the attribute is u32, the specification says
9233 * u8, so let's make sure we don't overflow.
9235 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
9239 params.count = cs_count;
9241 if (!need_new_beacon)
9244 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after);
9248 csa_attrs = kcalloc(NL80211_ATTR_MAX + 1, sizeof(*csa_attrs),
9253 err = nla_parse_nested_deprecated(csa_attrs, NL80211_ATTR_MAX,
9254 info->attrs[NL80211_ATTR_CSA_IES],
9255 nl80211_policy, info->extack);
9259 err = nl80211_parse_beacon(rdev, csa_attrs, ¶ms.beacon_csa);
9263 if (!csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]) {
9268 len = nla_len(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]);
9269 if (!len || (len % sizeof(u16))) {
9274 params.n_counter_offsets_beacon = len / sizeof(u16);
9275 if (rdev->wiphy.max_num_csa_counters &&
9276 (params.n_counter_offsets_beacon >
9277 rdev->wiphy.max_num_csa_counters)) {
9282 params.counter_offsets_beacon =
9283 nla_data(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]);
9285 /* sanity checks - counters should fit and be the same */
9286 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
9287 u16 offset = params.counter_offsets_beacon[i];
9289 if (offset >= params.beacon_csa.tail_len) {
9294 if (params.beacon_csa.tail[offset] != params.count) {
9300 if (csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]) {
9301 len = nla_len(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]);
9302 if (!len || (len % sizeof(u16))) {
9307 params.n_counter_offsets_presp = len / sizeof(u16);
9308 if (rdev->wiphy.max_num_csa_counters &&
9309 (params.n_counter_offsets_presp >
9310 rdev->wiphy.max_num_csa_counters)) {
9315 params.counter_offsets_presp =
9316 nla_data(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]);
9318 /* sanity checks - counters should fit and be the same */
9319 for (i = 0; i < params.n_counter_offsets_presp; i++) {
9320 u16 offset = params.counter_offsets_presp[i];
9322 if (offset >= params.beacon_csa.probe_resp_len) {
9327 if (params.beacon_csa.probe_resp[offset] !=
9336 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
9340 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
9346 err = cfg80211_chandef_dfs_required(wdev->wiphy,
9353 params.radar_required = true;
9354 if (need_handle_dfs_flag &&
9355 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
9361 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
9362 params.block_tx = true;
9365 err = rdev_channel_switch(rdev, dev, ¶ms);
9373 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
9375 struct cfg80211_registered_device *rdev,
9376 struct wireless_dev *wdev,
9377 struct cfg80211_internal_bss *intbss)
9379 struct cfg80211_bss *res = &intbss->pub;
9380 const struct cfg80211_bss_ies *ies;
9384 ASSERT_WDEV_LOCK(wdev);
9386 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
9387 NL80211_CMD_NEW_SCAN_RESULTS);
9391 genl_dump_check_consistent(cb, hdr);
9393 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
9394 goto nla_put_failure;
9396 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
9397 goto nla_put_failure;
9398 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
9400 goto nla_put_failure;
9402 bss = nla_nest_start_noflag(msg, NL80211_ATTR_BSS);
9404 goto nla_put_failure;
9405 if ((!is_zero_ether_addr(res->bssid) &&
9406 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
9407 goto nla_put_failure;
9410 /* indicate whether we have probe response data or not */
9411 if (rcu_access_pointer(res->proberesp_ies) &&
9412 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
9413 goto fail_unlock_rcu;
9415 /* this pointer prefers to be pointed to probe response data
9416 * but is always valid
9418 ies = rcu_dereference(res->ies);
9420 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
9422 goto fail_unlock_rcu;
9423 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
9424 ies->len, ies->data))
9425 goto fail_unlock_rcu;
9428 /* and this pointer is always (unless driver didn't know) beacon data */
9429 ies = rcu_dereference(res->beacon_ies);
9430 if (ies && ies->from_beacon) {
9431 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
9433 goto fail_unlock_rcu;
9434 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
9435 ies->len, ies->data))
9436 goto fail_unlock_rcu;
9440 if (res->beacon_interval &&
9441 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
9442 goto nla_put_failure;
9443 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
9444 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
9445 nla_put_u32(msg, NL80211_BSS_FREQUENCY_OFFSET,
9446 res->channel->freq_offset) ||
9447 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
9448 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
9449 jiffies_to_msecs(jiffies - intbss->ts)))
9450 goto nla_put_failure;
9452 if (intbss->parent_tsf &&
9453 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
9454 intbss->parent_tsf, NL80211_BSS_PAD) ||
9455 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
9456 intbss->parent_bssid)))
9457 goto nla_put_failure;
9459 if (intbss->ts_boottime &&
9460 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
9461 intbss->ts_boottime, NL80211_BSS_PAD))
9462 goto nla_put_failure;
9464 if (!nl80211_put_signal(msg, intbss->pub.chains,
9465 intbss->pub.chain_signal,
9466 NL80211_BSS_CHAIN_SIGNAL))
9467 goto nla_put_failure;
9469 switch (rdev->wiphy.signal_type) {
9470 case CFG80211_SIGNAL_TYPE_MBM:
9471 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
9472 goto nla_put_failure;
9474 case CFG80211_SIGNAL_TYPE_UNSPEC:
9475 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
9476 goto nla_put_failure;
9482 switch (wdev->iftype) {
9483 case NL80211_IFTYPE_P2P_CLIENT:
9484 case NL80211_IFTYPE_STATION:
9485 if (intbss == wdev->current_bss &&
9486 nla_put_u32(msg, NL80211_BSS_STATUS,
9487 NL80211_BSS_STATUS_ASSOCIATED))
9488 goto nla_put_failure;
9490 case NL80211_IFTYPE_ADHOC:
9491 if (intbss == wdev->current_bss &&
9492 nla_put_u32(msg, NL80211_BSS_STATUS,
9493 NL80211_BSS_STATUS_IBSS_JOINED))
9494 goto nla_put_failure;
9500 nla_nest_end(msg, bss);
9502 genlmsg_end(msg, hdr);
9508 genlmsg_cancel(msg, hdr);
9512 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
9514 struct cfg80211_registered_device *rdev;
9515 struct cfg80211_internal_bss *scan;
9516 struct wireless_dev *wdev;
9517 int start = cb->args[2], idx = 0;
9520 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
9523 /* nl80211_prepare_wdev_dump acquired it in the successful case */
9524 __acquire(&rdev->wiphy.mtx);
9527 spin_lock_bh(&rdev->bss_lock);
9530 * dump_scan will be called multiple times to break up the scan results
9531 * into multiple messages. It is unlikely that any more bss-es will be
9532 * expired after the first call, so only call only call this on the
9533 * first dump_scan invocation.
9536 cfg80211_bss_expire(rdev);
9538 cb->seq = rdev->bss_generation;
9540 list_for_each_entry(scan, &rdev->bss_list, list) {
9543 if (nl80211_send_bss(skb, cb,
9544 cb->nlh->nlmsg_seq, NLM_F_MULTI,
9545 rdev, wdev, scan) < 0) {
9551 spin_unlock_bh(&rdev->bss_lock);
9555 wiphy_unlock(&rdev->wiphy);
9560 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
9561 int flags, struct net_device *dev,
9562 bool allow_radio_stats,
9563 struct survey_info *survey)
9566 struct nlattr *infoattr;
9568 /* skip radio stats if userspace didn't request them */
9569 if (!survey->channel && !allow_radio_stats)
9572 hdr = nl80211hdr_put(msg, portid, seq, flags,
9573 NL80211_CMD_NEW_SURVEY_RESULTS);
9577 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9578 goto nla_put_failure;
9580 infoattr = nla_nest_start_noflag(msg, NL80211_ATTR_SURVEY_INFO);
9582 goto nla_put_failure;
9584 if (survey->channel &&
9585 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9586 survey->channel->center_freq))
9587 goto nla_put_failure;
9589 if (survey->channel && survey->channel->freq_offset &&
9590 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY_OFFSET,
9591 survey->channel->freq_offset))
9592 goto nla_put_failure;
9594 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
9595 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
9596 goto nla_put_failure;
9597 if ((survey->filled & SURVEY_INFO_IN_USE) &&
9598 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
9599 goto nla_put_failure;
9600 if ((survey->filled & SURVEY_INFO_TIME) &&
9601 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
9602 survey->time, NL80211_SURVEY_INFO_PAD))
9603 goto nla_put_failure;
9604 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
9605 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
9606 survey->time_busy, NL80211_SURVEY_INFO_PAD))
9607 goto nla_put_failure;
9608 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
9609 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
9610 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
9611 goto nla_put_failure;
9612 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
9613 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
9614 survey->time_rx, NL80211_SURVEY_INFO_PAD))
9615 goto nla_put_failure;
9616 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
9617 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
9618 survey->time_tx, NL80211_SURVEY_INFO_PAD))
9619 goto nla_put_failure;
9620 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
9621 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
9622 survey->time_scan, NL80211_SURVEY_INFO_PAD))
9623 goto nla_put_failure;
9624 if ((survey->filled & SURVEY_INFO_TIME_BSS_RX) &&
9625 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BSS_RX,
9626 survey->time_bss_rx, NL80211_SURVEY_INFO_PAD))
9627 goto nla_put_failure;
9629 nla_nest_end(msg, infoattr);
9631 genlmsg_end(msg, hdr);
9635 genlmsg_cancel(msg, hdr);
9639 static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
9641 struct nlattr **attrbuf;
9642 struct survey_info survey;
9643 struct cfg80211_registered_device *rdev;
9644 struct wireless_dev *wdev;
9645 int survey_idx = cb->args[2];
9649 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
9653 res = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
9658 /* nl80211_prepare_wdev_dump acquired it in the successful case */
9659 __acquire(&rdev->wiphy.mtx);
9661 /* prepare_wdev_dump parsed the attributes */
9662 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
9664 if (!wdev->netdev) {
9669 if (!rdev->ops->dump_survey) {
9675 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
9681 /* don't send disabled channels, but do send non-channel data */
9682 if (survey.channel &&
9683 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
9688 if (nl80211_send_survey(skb,
9689 NETLINK_CB(cb->skb).portid,
9690 cb->nlh->nlmsg_seq, NLM_F_MULTI,
9691 wdev->netdev, radio_stats, &survey) < 0)
9697 cb->args[2] = survey_idx;
9701 wiphy_unlock(&rdev->wiphy);
9705 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
9707 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
9708 NL80211_WPA_VERSION_2 |
9709 NL80211_WPA_VERSION_3));
9712 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
9714 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9715 struct net_device *dev = info->user_ptr[1];
9716 struct ieee80211_channel *chan;
9717 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
9718 int err, ssid_len, ie_len = 0, auth_data_len = 0;
9719 enum nl80211_auth_type auth_type;
9720 struct key_parse key;
9721 bool local_state_change;
9724 if (!info->attrs[NL80211_ATTR_MAC])
9727 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
9730 if (!info->attrs[NL80211_ATTR_SSID])
9733 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
9736 err = nl80211_parse_key(info, &key);
9741 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
9743 if (!key.p.key || !key.p.key_len)
9745 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
9746 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
9747 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
9748 key.p.key_len != WLAN_KEY_LEN_WEP104))
9761 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
9762 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
9771 if (!rdev->ops->auth)
9774 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9775 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9778 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9779 freq = MHZ_TO_KHZ(nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
9780 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
9782 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
9784 chan = nl80211_get_valid_chan(&rdev->wiphy, freq);
9788 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9789 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9791 if (info->attrs[NL80211_ATTR_IE]) {
9792 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9793 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9796 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
9797 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
9800 if ((auth_type == NL80211_AUTHTYPE_SAE ||
9801 auth_type == NL80211_AUTHTYPE_FILS_SK ||
9802 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
9803 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
9804 !info->attrs[NL80211_ATTR_AUTH_DATA])
9807 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
9808 if (auth_type != NL80211_AUTHTYPE_SAE &&
9809 auth_type != NL80211_AUTHTYPE_FILS_SK &&
9810 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
9811 auth_type != NL80211_AUTHTYPE_FILS_PK)
9813 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
9814 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
9817 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
9820 * Since we no longer track auth state, ignore
9821 * requests to only change local state.
9823 if (local_state_change)
9826 wdev_lock(dev->ieee80211_ptr);
9827 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
9828 ssid, ssid_len, ie, ie_len,
9829 key.p.key, key.p.key_len, key.idx,
9830 auth_data, auth_data_len);
9831 wdev_unlock(dev->ieee80211_ptr);
9835 static int validate_pae_over_nl80211(struct cfg80211_registered_device *rdev,
9836 struct genl_info *info)
9838 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9839 GENL_SET_ERR_MSG(info, "SOCKET_OWNER not set");
9843 if (!rdev->ops->tx_control_port ||
9844 !wiphy_ext_feature_isset(&rdev->wiphy,
9845 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
9851 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
9852 struct genl_info *info,
9853 struct cfg80211_crypto_settings *settings,
9856 memset(settings, 0, sizeof(*settings));
9858 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
9860 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
9863 proto = nla_get_u16(
9864 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
9865 settings->control_port_ethertype = cpu_to_be16(proto);
9866 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
9869 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
9870 settings->control_port_no_encrypt = true;
9872 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
9874 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
9875 int r = validate_pae_over_nl80211(rdev, info);
9880 settings->control_port_over_nl80211 = true;
9882 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_PREAUTH])
9883 settings->control_port_no_preauth = true;
9886 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
9890 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
9891 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
9892 settings->n_ciphers_pairwise = len / sizeof(u32);
9894 if (len % sizeof(u32))
9897 if (settings->n_ciphers_pairwise > cipher_limit)
9900 memcpy(settings->ciphers_pairwise, data, len);
9902 for (i = 0; i < settings->n_ciphers_pairwise; i++)
9903 if (!cfg80211_supported_cipher_suite(
9905 settings->ciphers_pairwise[i]))
9909 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
9910 settings->cipher_group =
9911 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
9912 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
9913 settings->cipher_group))
9917 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
9918 settings->wpa_versions =
9919 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
9920 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
9924 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
9928 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
9929 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
9930 settings->n_akm_suites = len / sizeof(u32);
9932 if (len % sizeof(u32))
9935 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
9938 memcpy(settings->akm_suites, data, len);
9941 if (info->attrs[NL80211_ATTR_PMK]) {
9942 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
9944 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9945 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK) &&
9946 !wiphy_ext_feature_isset(&rdev->wiphy,
9947 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK))
9949 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9952 if (info->attrs[NL80211_ATTR_SAE_PASSWORD]) {
9953 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9954 NL80211_EXT_FEATURE_SAE_OFFLOAD) &&
9955 !wiphy_ext_feature_isset(&rdev->wiphy,
9956 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP))
9959 nla_data(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
9960 settings->sae_pwd_len =
9961 nla_len(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
9964 if (info->attrs[NL80211_ATTR_SAE_PWE])
9966 nla_get_u8(info->attrs[NL80211_ATTR_SAE_PWE]);
9968 settings->sae_pwe = NL80211_SAE_PWE_UNSPECIFIED;
9973 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
9975 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9976 struct net_device *dev = info->user_ptr[1];
9977 struct ieee80211_channel *chan;
9978 struct cfg80211_assoc_request req = {};
9979 const u8 *bssid, *ssid;
9980 int err, ssid_len = 0;
9983 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9984 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9987 if (!info->attrs[NL80211_ATTR_MAC] ||
9988 !info->attrs[NL80211_ATTR_SSID] ||
9989 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
9992 if (!rdev->ops->assoc)
9995 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9996 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9999 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10001 freq = MHZ_TO_KHZ(nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
10002 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
10004 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
10005 chan = nl80211_get_valid_chan(&rdev->wiphy, freq);
10009 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10010 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10012 if (info->attrs[NL80211_ATTR_IE]) {
10013 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10014 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10017 if (info->attrs[NL80211_ATTR_USE_MFP]) {
10018 enum nl80211_mfp mfp =
10019 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
10020 if (mfp == NL80211_MFP_REQUIRED)
10021 req.use_mfp = true;
10022 else if (mfp != NL80211_MFP_NO)
10026 if (info->attrs[NL80211_ATTR_PREV_BSSID])
10027 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
10029 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
10030 req.flags |= ASSOC_REQ_DISABLE_HT;
10032 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10033 memcpy(&req.ht_capa_mask,
10034 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
10035 sizeof(req.ht_capa_mask));
10037 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
10038 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10040 memcpy(&req.ht_capa,
10041 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
10042 sizeof(req.ht_capa));
10045 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
10046 req.flags |= ASSOC_REQ_DISABLE_VHT;
10048 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE]))
10049 req.flags |= ASSOC_REQ_DISABLE_HE;
10051 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
10052 memcpy(&req.vht_capa_mask,
10053 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
10054 sizeof(req.vht_capa_mask));
10056 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
10057 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
10059 memcpy(&req.vht_capa,
10060 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
10061 sizeof(req.vht_capa));
10064 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
10065 if (!((rdev->wiphy.features &
10066 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
10067 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
10068 !wiphy_ext_feature_isset(&rdev->wiphy,
10069 NL80211_EXT_FEATURE_RRM))
10071 req.flags |= ASSOC_REQ_USE_RRM;
10074 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
10075 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
10076 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
10077 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
10080 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
10083 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]) {
10084 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY])
10086 memcpy(&req.s1g_capa_mask,
10087 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]),
10088 sizeof(req.s1g_capa_mask));
10091 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY]) {
10092 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK])
10094 memcpy(&req.s1g_capa,
10095 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY]),
10096 sizeof(req.s1g_capa));
10099 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
10101 wdev_lock(dev->ieee80211_ptr);
10103 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
10104 ssid, ssid_len, &req);
10106 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10107 dev->ieee80211_ptr->conn_owner_nlportid =
10109 memcpy(dev->ieee80211_ptr->disconnect_bssid,
10113 wdev_unlock(dev->ieee80211_ptr);
10119 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
10121 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10122 struct net_device *dev = info->user_ptr[1];
10123 const u8 *ie = NULL, *bssid;
10124 int ie_len = 0, err;
10126 bool local_state_change;
10128 if (dev->ieee80211_ptr->conn_owner_nlportid &&
10129 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
10132 if (!info->attrs[NL80211_ATTR_MAC])
10135 if (!info->attrs[NL80211_ATTR_REASON_CODE])
10138 if (!rdev->ops->deauth)
10139 return -EOPNOTSUPP;
10141 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10142 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10143 return -EOPNOTSUPP;
10145 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10147 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
10148 if (reason_code == 0) {
10149 /* Reason Code 0 is reserved */
10153 if (info->attrs[NL80211_ATTR_IE]) {
10154 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10155 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10158 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
10160 wdev_lock(dev->ieee80211_ptr);
10161 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
10162 local_state_change);
10163 wdev_unlock(dev->ieee80211_ptr);
10167 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
10169 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10170 struct net_device *dev = info->user_ptr[1];
10171 const u8 *ie = NULL, *bssid;
10172 int ie_len = 0, err;
10174 bool local_state_change;
10176 if (dev->ieee80211_ptr->conn_owner_nlportid &&
10177 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
10180 if (!info->attrs[NL80211_ATTR_MAC])
10183 if (!info->attrs[NL80211_ATTR_REASON_CODE])
10186 if (!rdev->ops->disassoc)
10187 return -EOPNOTSUPP;
10189 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10190 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10191 return -EOPNOTSUPP;
10193 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10195 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
10196 if (reason_code == 0) {
10197 /* Reason Code 0 is reserved */
10201 if (info->attrs[NL80211_ATTR_IE]) {
10202 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10203 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10206 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
10208 wdev_lock(dev->ieee80211_ptr);
10209 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
10210 local_state_change);
10211 wdev_unlock(dev->ieee80211_ptr);
10216 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
10217 int mcast_rate[NUM_NL80211_BANDS],
10220 struct wiphy *wiphy = &rdev->wiphy;
10221 bool found = false;
10224 for (band = 0; band < NUM_NL80211_BANDS; band++) {
10225 struct ieee80211_supported_band *sband;
10227 sband = wiphy->bands[band];
10231 for (i = 0; i < sband->n_bitrates; i++) {
10232 if (sband->bitrates[i].bitrate == rateval) {
10233 mcast_rate[band] = i + 1;
10243 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
10245 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10246 struct net_device *dev = info->user_ptr[1];
10247 struct cfg80211_ibss_params ibss;
10248 struct wiphy *wiphy;
10249 struct cfg80211_cached_keys *connkeys = NULL;
10252 memset(&ibss, 0, sizeof(ibss));
10254 if (!info->attrs[NL80211_ATTR_SSID] ||
10255 !nla_len(info->attrs[NL80211_ATTR_SSID]))
10258 ibss.beacon_interval = 100;
10260 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
10261 ibss.beacon_interval =
10262 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
10264 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
10265 ibss.beacon_interval);
10269 if (!rdev->ops->join_ibss)
10270 return -EOPNOTSUPP;
10272 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
10273 return -EOPNOTSUPP;
10275 wiphy = &rdev->wiphy;
10277 if (info->attrs[NL80211_ATTR_MAC]) {
10278 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10280 if (!is_valid_ether_addr(ibss.bssid))
10283 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10284 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10286 if (info->attrs[NL80211_ATTR_IE]) {
10287 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10288 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10291 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
10295 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
10296 NL80211_IFTYPE_ADHOC))
10299 switch (ibss.chandef.width) {
10300 case NL80211_CHAN_WIDTH_5:
10301 case NL80211_CHAN_WIDTH_10:
10302 case NL80211_CHAN_WIDTH_20_NOHT:
10304 case NL80211_CHAN_WIDTH_20:
10305 case NL80211_CHAN_WIDTH_40:
10306 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
10309 case NL80211_CHAN_WIDTH_80:
10310 case NL80211_CHAN_WIDTH_80P80:
10311 case NL80211_CHAN_WIDTH_160:
10312 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
10314 if (!wiphy_ext_feature_isset(&rdev->wiphy,
10315 NL80211_EXT_FEATURE_VHT_IBSS))
10322 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
10323 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
10325 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
10327 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10329 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10330 struct ieee80211_supported_band *sband =
10331 wiphy->bands[ibss.chandef.chan->band];
10333 err = ieee80211_get_ratemask(sband, rates, n_rates,
10334 &ibss.basic_rates);
10339 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10340 memcpy(&ibss.ht_capa_mask,
10341 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
10342 sizeof(ibss.ht_capa_mask));
10344 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
10345 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10347 memcpy(&ibss.ht_capa,
10348 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
10349 sizeof(ibss.ht_capa));
10352 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
10353 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
10354 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
10357 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
10358 bool no_ht = false;
10360 connkeys = nl80211_parse_connkeys(rdev, info, &no_ht);
10361 if (IS_ERR(connkeys))
10362 return PTR_ERR(connkeys);
10364 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
10366 kfree_sensitive(connkeys);
10371 ibss.control_port =
10372 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
10374 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
10375 int r = validate_pae_over_nl80211(rdev, info);
10378 kfree_sensitive(connkeys);
10382 ibss.control_port_over_nl80211 = true;
10385 ibss.userspace_handles_dfs =
10386 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
10388 wdev_lock(dev->ieee80211_ptr);
10389 err = __cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
10391 kfree_sensitive(connkeys);
10392 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
10393 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
10394 wdev_unlock(dev->ieee80211_ptr);
10399 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
10401 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10402 struct net_device *dev = info->user_ptr[1];
10404 if (!rdev->ops->leave_ibss)
10405 return -EOPNOTSUPP;
10407 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
10408 return -EOPNOTSUPP;
10410 return cfg80211_leave_ibss(rdev, dev, false);
10413 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
10415 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10416 struct net_device *dev = info->user_ptr[1];
10417 int mcast_rate[NUM_NL80211_BANDS];
10421 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
10422 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
10423 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
10424 return -EOPNOTSUPP;
10426 if (!rdev->ops->set_mcast_rate)
10427 return -EOPNOTSUPP;
10429 memset(mcast_rate, 0, sizeof(mcast_rate));
10431 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
10434 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
10435 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
10438 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
10443 static struct sk_buff *
10444 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
10445 struct wireless_dev *wdev, int approxlen,
10446 u32 portid, u32 seq, enum nl80211_commands cmd,
10447 enum nl80211_attrs attr,
10448 const struct nl80211_vendor_cmd_info *info,
10451 struct sk_buff *skb;
10453 struct nlattr *data;
10455 skb = nlmsg_new(approxlen + 100, gfp);
10459 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
10465 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
10466 goto nla_put_failure;
10469 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
10471 goto nla_put_failure;
10472 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
10474 goto nla_put_failure;
10478 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
10479 wdev_id(wdev), NL80211_ATTR_PAD))
10480 goto nla_put_failure;
10481 if (wdev->netdev &&
10482 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
10483 wdev->netdev->ifindex))
10484 goto nla_put_failure;
10487 data = nla_nest_start_noflag(skb, attr);
10489 goto nla_put_failure;
10491 ((void **)skb->cb)[0] = rdev;
10492 ((void **)skb->cb)[1] = hdr;
10493 ((void **)skb->cb)[2] = data;
10502 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
10503 struct wireless_dev *wdev,
10504 enum nl80211_commands cmd,
10505 enum nl80211_attrs attr,
10506 unsigned int portid,
10507 int vendor_event_idx,
10508 int approxlen, gfp_t gfp)
10510 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
10511 const struct nl80211_vendor_cmd_info *info;
10514 case NL80211_CMD_TESTMODE:
10515 if (WARN_ON(vendor_event_idx != -1))
10519 case NL80211_CMD_VENDOR:
10520 if (WARN_ON(vendor_event_idx < 0 ||
10521 vendor_event_idx >= wiphy->n_vendor_events))
10523 info = &wiphy->vendor_events[vendor_event_idx];
10530 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, portid, 0,
10531 cmd, attr, info, gfp);
10533 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
10535 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
10537 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
10538 void *hdr = ((void **)skb->cb)[1];
10539 struct nlmsghdr *nlhdr = nlmsg_hdr(skb);
10540 struct nlattr *data = ((void **)skb->cb)[2];
10541 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
10543 /* clear CB data for netlink core to own from now on */
10544 memset(skb->cb, 0, sizeof(skb->cb));
10546 nla_nest_end(skb, data);
10547 genlmsg_end(skb, hdr);
10549 if (nlhdr->nlmsg_pid) {
10550 genlmsg_unicast(wiphy_net(&rdev->wiphy), skb,
10553 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
10554 mcgrp = NL80211_MCGRP_VENDOR;
10556 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
10557 skb, 0, mcgrp, gfp);
10560 EXPORT_SYMBOL(__cfg80211_send_event_skb);
10562 #ifdef CONFIG_NL80211_TESTMODE
10563 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
10565 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10566 struct wireless_dev *wdev;
10569 lockdep_assert_held(&rdev->wiphy.mtx);
10571 wdev = __cfg80211_wdev_from_attrs(rdev, genl_info_net(info),
10574 if (!rdev->ops->testmode_cmd)
10575 return -EOPNOTSUPP;
10577 if (IS_ERR(wdev)) {
10578 err = PTR_ERR(wdev);
10579 if (err != -EINVAL)
10582 } else if (wdev->wiphy != &rdev->wiphy) {
10586 if (!info->attrs[NL80211_ATTR_TESTDATA])
10589 rdev->cur_cmd_info = info;
10590 err = rdev_testmode_cmd(rdev, wdev,
10591 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
10592 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
10593 rdev->cur_cmd_info = NULL;
10598 static int nl80211_testmode_dump(struct sk_buff *skb,
10599 struct netlink_callback *cb)
10601 struct cfg80211_registered_device *rdev;
10602 struct nlattr **attrbuf = NULL;
10612 * 0 is a valid index, but not valid for args[0],
10613 * so we need to offset by 1.
10615 phy_idx = cb->args[0] - 1;
10617 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
10623 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
10630 err = nlmsg_parse_deprecated(cb->nlh,
10631 GENL_HDRLEN + nl80211_fam.hdrsize,
10632 attrbuf, nl80211_fam.maxattr,
10633 nl80211_policy, NULL);
10637 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
10638 if (IS_ERR(rdev)) {
10639 err = PTR_ERR(rdev);
10642 phy_idx = rdev->wiphy_idx;
10644 if (attrbuf[NL80211_ATTR_TESTDATA])
10645 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
10649 data = nla_data((void *)cb->args[1]);
10650 data_len = nla_len((void *)cb->args[1]);
10653 if (!rdev->ops->testmode_dump) {
10659 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
10660 cb->nlh->nlmsg_seq, NLM_F_MULTI,
10661 NL80211_CMD_TESTMODE);
10662 struct nlattr *tmdata;
10667 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
10668 genlmsg_cancel(skb, hdr);
10672 tmdata = nla_nest_start_noflag(skb, NL80211_ATTR_TESTDATA);
10674 genlmsg_cancel(skb, hdr);
10677 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
10678 nla_nest_end(skb, tmdata);
10680 if (err == -ENOBUFS || err == -ENOENT) {
10681 genlmsg_cancel(skb, hdr);
10684 genlmsg_cancel(skb, hdr);
10688 genlmsg_end(skb, hdr);
10693 cb->args[0] = phy_idx + 1;
10701 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
10703 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10704 struct net_device *dev = info->user_ptr[1];
10705 struct cfg80211_connect_params connect;
10706 struct wiphy *wiphy;
10707 struct cfg80211_cached_keys *connkeys = NULL;
10711 memset(&connect, 0, sizeof(connect));
10713 if (!info->attrs[NL80211_ATTR_SSID] ||
10714 !nla_len(info->attrs[NL80211_ATTR_SSID]))
10717 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
10718 connect.auth_type =
10719 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
10720 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
10721 NL80211_CMD_CONNECT))
10724 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
10726 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
10728 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
10729 !wiphy_ext_feature_isset(&rdev->wiphy,
10730 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
10732 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
10734 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
10735 NL80211_MAX_NR_CIPHER_SUITES);
10739 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10740 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10741 return -EOPNOTSUPP;
10743 wiphy = &rdev->wiphy;
10745 connect.bg_scan_period = -1;
10746 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
10747 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
10748 connect.bg_scan_period =
10749 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
10752 if (info->attrs[NL80211_ATTR_MAC])
10753 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10754 else if (info->attrs[NL80211_ATTR_MAC_HINT])
10755 connect.bssid_hint =
10756 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
10757 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10758 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10760 if (info->attrs[NL80211_ATTR_IE]) {
10761 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10762 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10765 if (info->attrs[NL80211_ATTR_USE_MFP]) {
10766 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
10767 if (connect.mfp == NL80211_MFP_OPTIONAL &&
10768 !wiphy_ext_feature_isset(&rdev->wiphy,
10769 NL80211_EXT_FEATURE_MFP_OPTIONAL))
10770 return -EOPNOTSUPP;
10772 connect.mfp = NL80211_MFP_NO;
10775 if (info->attrs[NL80211_ATTR_PREV_BSSID])
10776 connect.prev_bssid =
10777 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
10779 if (info->attrs[NL80211_ATTR_WIPHY_FREQ])
10780 freq = MHZ_TO_KHZ(nla_get_u32(
10781 info->attrs[NL80211_ATTR_WIPHY_FREQ]));
10782 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
10784 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
10787 connect.channel = nl80211_get_valid_chan(wiphy, freq);
10788 if (!connect.channel)
10790 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
10791 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
10792 freq = MHZ_TO_KHZ(freq);
10793 connect.channel_hint = nl80211_get_valid_chan(wiphy, freq);
10794 if (!connect.channel_hint)
10798 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
10799 connect.edmg.channels =
10800 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
10802 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
10803 connect.edmg.bw_config =
10804 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
10807 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
10808 connkeys = nl80211_parse_connkeys(rdev, info, NULL);
10809 if (IS_ERR(connkeys))
10810 return PTR_ERR(connkeys);
10813 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
10814 connect.flags |= ASSOC_REQ_DISABLE_HT;
10816 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10817 memcpy(&connect.ht_capa_mask,
10818 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
10819 sizeof(connect.ht_capa_mask));
10821 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
10822 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
10823 kfree_sensitive(connkeys);
10826 memcpy(&connect.ht_capa,
10827 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
10828 sizeof(connect.ht_capa));
10831 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
10832 connect.flags |= ASSOC_REQ_DISABLE_VHT;
10834 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE]))
10835 connect.flags |= ASSOC_REQ_DISABLE_HE;
10837 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
10838 memcpy(&connect.vht_capa_mask,
10839 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
10840 sizeof(connect.vht_capa_mask));
10842 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
10843 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
10844 kfree_sensitive(connkeys);
10847 memcpy(&connect.vht_capa,
10848 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
10849 sizeof(connect.vht_capa));
10852 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
10853 if (!((rdev->wiphy.features &
10854 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
10855 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
10856 !wiphy_ext_feature_isset(&rdev->wiphy,
10857 NL80211_EXT_FEATURE_RRM)) {
10858 kfree_sensitive(connkeys);
10861 connect.flags |= ASSOC_REQ_USE_RRM;
10864 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
10865 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
10866 kfree_sensitive(connkeys);
10867 return -EOPNOTSUPP;
10870 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
10871 /* bss selection makes no sense if bssid is set */
10872 if (connect.bssid) {
10873 kfree_sensitive(connkeys);
10877 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
10878 wiphy, &connect.bss_select);
10880 kfree_sensitive(connkeys);
10885 if (wiphy_ext_feature_isset(&rdev->wiphy,
10886 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
10887 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
10888 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
10889 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
10890 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10891 connect.fils_erp_username =
10892 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10893 connect.fils_erp_username_len =
10894 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10895 connect.fils_erp_realm =
10896 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10897 connect.fils_erp_realm_len =
10898 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10899 connect.fils_erp_next_seq_num =
10901 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
10902 connect.fils_erp_rrk =
10903 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10904 connect.fils_erp_rrk_len =
10905 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10906 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
10907 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
10908 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
10909 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10910 kfree_sensitive(connkeys);
10914 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
10915 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10916 kfree_sensitive(connkeys);
10917 GENL_SET_ERR_MSG(info,
10918 "external auth requires connection ownership");
10921 connect.flags |= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT;
10924 wdev_lock(dev->ieee80211_ptr);
10926 err = cfg80211_connect(rdev, dev, &connect, connkeys,
10927 connect.prev_bssid);
10929 kfree_sensitive(connkeys);
10931 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10932 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
10934 memcpy(dev->ieee80211_ptr->disconnect_bssid,
10935 connect.bssid, ETH_ALEN);
10937 eth_zero_addr(dev->ieee80211_ptr->disconnect_bssid);
10940 wdev_unlock(dev->ieee80211_ptr);
10945 static int nl80211_update_connect_params(struct sk_buff *skb,
10946 struct genl_info *info)
10948 struct cfg80211_connect_params connect = {};
10949 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10950 struct net_device *dev = info->user_ptr[1];
10951 struct wireless_dev *wdev = dev->ieee80211_ptr;
10952 bool fils_sk_offload;
10957 if (!rdev->ops->update_connect_params)
10958 return -EOPNOTSUPP;
10960 if (info->attrs[NL80211_ATTR_IE]) {
10961 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10962 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10963 changed |= UPDATE_ASSOC_IES;
10966 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy,
10967 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD);
10970 * when driver supports fils-sk offload all attributes must be
10971 * provided. So the else covers "fils-sk-not-all" and
10972 * "no-fils-sk-any".
10974 if (fils_sk_offload &&
10975 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
10976 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
10977 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
10978 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10979 connect.fils_erp_username =
10980 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10981 connect.fils_erp_username_len =
10982 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10983 connect.fils_erp_realm =
10984 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10985 connect.fils_erp_realm_len =
10986 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10987 connect.fils_erp_next_seq_num =
10989 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
10990 connect.fils_erp_rrk =
10991 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10992 connect.fils_erp_rrk_len =
10993 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10994 changed |= UPDATE_FILS_ERP_INFO;
10995 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
10996 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
10997 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
10998 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
11002 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
11003 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
11004 if (!nl80211_valid_auth_type(rdev, auth_type,
11005 NL80211_CMD_CONNECT))
11008 if (auth_type == NL80211_AUTHTYPE_FILS_SK &&
11009 fils_sk_offload && !(changed & UPDATE_FILS_ERP_INFO))
11012 connect.auth_type = auth_type;
11013 changed |= UPDATE_AUTH_TYPE;
11016 wdev_lock(dev->ieee80211_ptr);
11017 if (!wdev->current_bss)
11020 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
11021 wdev_unlock(dev->ieee80211_ptr);
11026 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
11028 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11029 struct net_device *dev = info->user_ptr[1];
11033 if (dev->ieee80211_ptr->conn_owner_nlportid &&
11034 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
11037 if (!info->attrs[NL80211_ATTR_REASON_CODE])
11038 reason = WLAN_REASON_DEAUTH_LEAVING;
11040 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
11045 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11046 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
11047 return -EOPNOTSUPP;
11049 wdev_lock(dev->ieee80211_ptr);
11050 ret = cfg80211_disconnect(rdev, dev, reason, true);
11051 wdev_unlock(dev->ieee80211_ptr);
11055 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
11057 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11061 if (info->attrs[NL80211_ATTR_PID]) {
11062 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
11064 net = get_net_ns_by_pid(pid);
11065 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
11066 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
11068 net = get_net_ns_by_fd(fd);
11074 return PTR_ERR(net);
11078 /* check if anything to do */
11079 if (!net_eq(wiphy_net(&rdev->wiphy), net))
11080 err = cfg80211_switch_netns(rdev, net);
11086 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
11088 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11089 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
11090 struct cfg80211_pmksa *pmksa) = NULL;
11091 struct net_device *dev = info->user_ptr[1];
11092 struct cfg80211_pmksa pmksa;
11094 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
11096 if (!info->attrs[NL80211_ATTR_PMKID])
11099 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
11101 if (info->attrs[NL80211_ATTR_MAC]) {
11102 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
11103 } else if (info->attrs[NL80211_ATTR_SSID] &&
11104 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
11105 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
11106 info->attrs[NL80211_ATTR_PMK])) {
11107 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
11108 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
11110 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
11114 if (info->attrs[NL80211_ATTR_PMK]) {
11115 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
11116 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
11119 if (info->attrs[NL80211_ATTR_PMK_LIFETIME])
11120 pmksa.pmk_lifetime =
11121 nla_get_u32(info->attrs[NL80211_ATTR_PMK_LIFETIME]);
11123 if (info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD])
11124 pmksa.pmk_reauth_threshold =
11126 info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD]);
11128 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11129 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
11130 !(dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP &&
11131 wiphy_ext_feature_isset(&rdev->wiphy,
11132 NL80211_EXT_FEATURE_AP_PMKSA_CACHING)))
11133 return -EOPNOTSUPP;
11135 switch (info->genlhdr->cmd) {
11136 case NL80211_CMD_SET_PMKSA:
11137 rdev_ops = rdev->ops->set_pmksa;
11139 case NL80211_CMD_DEL_PMKSA:
11140 rdev_ops = rdev->ops->del_pmksa;
11148 return -EOPNOTSUPP;
11150 return rdev_ops(&rdev->wiphy, dev, &pmksa);
11153 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
11155 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11156 struct net_device *dev = info->user_ptr[1];
11158 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11159 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
11160 return -EOPNOTSUPP;
11162 if (!rdev->ops->flush_pmksa)
11163 return -EOPNOTSUPP;
11165 return rdev_flush_pmksa(rdev, dev);
11168 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
11170 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11171 struct net_device *dev = info->user_ptr[1];
11172 u8 action_code, dialog_token;
11173 u32 peer_capability = 0;
11178 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
11179 !rdev->ops->tdls_mgmt)
11180 return -EOPNOTSUPP;
11182 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
11183 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
11184 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
11185 !info->attrs[NL80211_ATTR_IE] ||
11186 !info->attrs[NL80211_ATTR_MAC])
11189 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
11190 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
11191 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
11192 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
11193 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
11194 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
11196 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
11198 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
11199 dialog_token, status_code, peer_capability,
11201 nla_data(info->attrs[NL80211_ATTR_IE]),
11202 nla_len(info->attrs[NL80211_ATTR_IE]));
11205 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
11207 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11208 struct net_device *dev = info->user_ptr[1];
11209 enum nl80211_tdls_operation operation;
11212 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
11213 !rdev->ops->tdls_oper)
11214 return -EOPNOTSUPP;
11216 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
11217 !info->attrs[NL80211_ATTR_MAC])
11220 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
11221 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
11223 return rdev_tdls_oper(rdev, dev, peer, operation);
11226 static int nl80211_remain_on_channel(struct sk_buff *skb,
11227 struct genl_info *info)
11229 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11230 struct wireless_dev *wdev = info->user_ptr[1];
11231 struct cfg80211_chan_def chandef;
11232 const struct cfg80211_chan_def *compat_chandef;
11233 struct sk_buff *msg;
11239 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
11240 !info->attrs[NL80211_ATTR_DURATION])
11243 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
11245 if (!rdev->ops->remain_on_channel ||
11246 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
11247 return -EOPNOTSUPP;
11250 * We should be on that channel for at least a minimum amount of
11251 * time (10ms) but no longer than the driver supports.
11253 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
11254 duration > rdev->wiphy.max_remain_on_channel_duration)
11257 err = nl80211_parse_chandef(rdev, info, &chandef);
11262 if (!cfg80211_off_channel_oper_allowed(wdev) &&
11263 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
11264 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
11266 if (compat_chandef != &chandef) {
11273 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11277 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11278 NL80211_CMD_REMAIN_ON_CHANNEL);
11284 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
11285 duration, &cookie);
11290 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11292 goto nla_put_failure;
11294 genlmsg_end(msg, hdr);
11296 return genlmsg_reply(msg, info);
11305 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
11306 struct genl_info *info)
11308 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11309 struct wireless_dev *wdev = info->user_ptr[1];
11312 if (!info->attrs[NL80211_ATTR_COOKIE])
11315 if (!rdev->ops->cancel_remain_on_channel)
11316 return -EOPNOTSUPP;
11318 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11320 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
11323 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
11324 struct genl_info *info)
11326 struct cfg80211_bitrate_mask mask;
11327 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11328 struct net_device *dev = info->user_ptr[1];
11331 if (!rdev->ops->set_bitrate_mask)
11332 return -EOPNOTSUPP;
11334 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
11335 NL80211_ATTR_TX_RATES, &mask,
11340 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
11343 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
11345 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11346 struct wireless_dev *wdev = info->user_ptr[1];
11347 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
11349 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
11352 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
11353 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
11355 switch (wdev->iftype) {
11356 case NL80211_IFTYPE_STATION:
11357 case NL80211_IFTYPE_ADHOC:
11358 case NL80211_IFTYPE_P2P_CLIENT:
11359 case NL80211_IFTYPE_AP:
11360 case NL80211_IFTYPE_AP_VLAN:
11361 case NL80211_IFTYPE_MESH_POINT:
11362 case NL80211_IFTYPE_P2P_GO:
11363 case NL80211_IFTYPE_P2P_DEVICE:
11365 case NL80211_IFTYPE_NAN:
11367 return -EOPNOTSUPP;
11370 /* not much point in registering if we can't reply */
11371 if (!rdev->ops->mgmt_tx)
11372 return -EOPNOTSUPP;
11374 if (info->attrs[NL80211_ATTR_RECEIVE_MULTICAST] &&
11375 !wiphy_ext_feature_isset(&rdev->wiphy,
11376 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS)) {
11377 GENL_SET_ERR_MSG(info,
11378 "multicast RX registrations are not supported");
11379 return -EOPNOTSUPP;
11382 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
11383 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
11384 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]),
11385 info->attrs[NL80211_ATTR_RECEIVE_MULTICAST],
11389 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
11391 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11392 struct wireless_dev *wdev = info->user_ptr[1];
11393 struct cfg80211_chan_def chandef;
11397 struct sk_buff *msg = NULL;
11398 struct cfg80211_mgmt_tx_params params = {
11399 .dont_wait_for_ack =
11400 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
11403 if (!info->attrs[NL80211_ATTR_FRAME])
11406 if (!rdev->ops->mgmt_tx)
11407 return -EOPNOTSUPP;
11409 switch (wdev->iftype) {
11410 case NL80211_IFTYPE_P2P_DEVICE:
11411 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
11414 case NL80211_IFTYPE_STATION:
11415 case NL80211_IFTYPE_ADHOC:
11416 case NL80211_IFTYPE_P2P_CLIENT:
11417 case NL80211_IFTYPE_AP:
11418 case NL80211_IFTYPE_AP_VLAN:
11419 case NL80211_IFTYPE_MESH_POINT:
11420 case NL80211_IFTYPE_P2P_GO:
11422 case NL80211_IFTYPE_NAN:
11424 return -EOPNOTSUPP;
11427 if (info->attrs[NL80211_ATTR_DURATION]) {
11428 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
11430 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
11433 * We should wait on the channel for at least a minimum amount
11434 * of time (10ms) but no longer than the driver supports.
11436 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
11437 params.wait > rdev->wiphy.max_remain_on_channel_duration)
11441 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
11443 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
11446 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
11448 /* get the channel if any has been specified, otherwise pass NULL to
11449 * the driver. The latter will use the current one
11451 chandef.chan = NULL;
11452 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
11453 err = nl80211_parse_chandef(rdev, info, &chandef);
11458 if (!chandef.chan && params.offchan)
11462 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
11468 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
11469 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
11471 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
11472 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
11475 if (len % sizeof(u16))
11478 params.n_csa_offsets = len / sizeof(u16);
11479 params.csa_offsets =
11480 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
11482 /* check that all the offsets fit the frame */
11483 for (i = 0; i < params.n_csa_offsets; i++) {
11484 if (params.csa_offsets[i] >= params.len)
11489 if (!params.dont_wait_for_ack) {
11490 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11494 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11495 NL80211_CMD_FRAME);
11502 params.chan = chandef.chan;
11503 err = cfg80211_mlme_mgmt_tx(rdev, wdev, ¶ms, &cookie);
11508 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11510 goto nla_put_failure;
11512 genlmsg_end(msg, hdr);
11513 return genlmsg_reply(msg, info);
11525 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
11527 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11528 struct wireless_dev *wdev = info->user_ptr[1];
11531 if (!info->attrs[NL80211_ATTR_COOKIE])
11534 if (!rdev->ops->mgmt_tx_cancel_wait)
11535 return -EOPNOTSUPP;
11537 switch (wdev->iftype) {
11538 case NL80211_IFTYPE_STATION:
11539 case NL80211_IFTYPE_ADHOC:
11540 case NL80211_IFTYPE_P2P_CLIENT:
11541 case NL80211_IFTYPE_AP:
11542 case NL80211_IFTYPE_AP_VLAN:
11543 case NL80211_IFTYPE_P2P_GO:
11544 case NL80211_IFTYPE_P2P_DEVICE:
11546 case NL80211_IFTYPE_NAN:
11548 return -EOPNOTSUPP;
11551 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11553 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
11556 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
11558 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11559 struct wireless_dev *wdev;
11560 struct net_device *dev = info->user_ptr[1];
11565 if (!info->attrs[NL80211_ATTR_PS_STATE])
11568 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
11570 wdev = dev->ieee80211_ptr;
11572 if (!rdev->ops->set_power_mgmt)
11573 return -EOPNOTSUPP;
11575 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
11577 if (state == wdev->ps)
11580 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
11586 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
11588 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11589 enum nl80211_ps_state ps_state;
11590 struct wireless_dev *wdev;
11591 struct net_device *dev = info->user_ptr[1];
11592 struct sk_buff *msg;
11596 wdev = dev->ieee80211_ptr;
11598 if (!rdev->ops->set_power_mgmt)
11599 return -EOPNOTSUPP;
11601 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11605 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11606 NL80211_CMD_GET_POWER_SAVE);
11613 ps_state = NL80211_PS_ENABLED;
11615 ps_state = NL80211_PS_DISABLED;
11617 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
11618 goto nla_put_failure;
11620 genlmsg_end(msg, hdr);
11621 return genlmsg_reply(msg, info);
11630 static const struct nla_policy
11631 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
11632 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
11633 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
11634 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
11635 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
11636 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
11637 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
11638 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
11641 static int nl80211_set_cqm_txe(struct genl_info *info,
11642 u32 rate, u32 pkts, u32 intvl)
11644 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11645 struct net_device *dev = info->user_ptr[1];
11646 struct wireless_dev *wdev = dev->ieee80211_ptr;
11648 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
11651 if (!rdev->ops->set_cqm_txe_config)
11652 return -EOPNOTSUPP;
11654 if (wdev->iftype != NL80211_IFTYPE_STATION &&
11655 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
11656 return -EOPNOTSUPP;
11658 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
11661 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
11662 struct net_device *dev)
11664 struct wireless_dev *wdev = dev->ieee80211_ptr;
11665 s32 last, low, high;
11667 int i, n, low_index;
11670 /* RSSI reporting disabled? */
11671 if (!wdev->cqm_config)
11672 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
11675 * Obtain current RSSI value if possible, if not and no RSSI threshold
11676 * event has been received yet, we should receive an event after a
11677 * connection is established and enough beacons received to calculate
11680 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
11681 rdev->ops->get_station) {
11682 struct station_info sinfo = {};
11685 mac_addr = wdev->current_bss->pub.bssid;
11687 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
11691 cfg80211_sinfo_release_content(&sinfo);
11692 if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
11693 wdev->cqm_config->last_rssi_event_value =
11694 (s8) sinfo.rx_beacon_signal_avg;
11697 last = wdev->cqm_config->last_rssi_event_value;
11698 hyst = wdev->cqm_config->rssi_hyst;
11699 n = wdev->cqm_config->n_rssi_thresholds;
11701 for (i = 0; i < n; i++) {
11702 i = array_index_nospec(i, n);
11703 if (last < wdev->cqm_config->rssi_thresholds[i])
11708 if (low_index >= 0) {
11709 low_index = array_index_nospec(low_index, n);
11710 low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;
11715 i = array_index_nospec(i, n);
11716 high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;
11721 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
11724 static int nl80211_set_cqm_rssi(struct genl_info *info,
11725 const s32 *thresholds, int n_thresholds,
11728 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11729 struct net_device *dev = info->user_ptr[1];
11730 struct wireless_dev *wdev = dev->ieee80211_ptr;
11732 s32 prev = S32_MIN;
11734 /* Check all values negative and sorted */
11735 for (i = 0; i < n_thresholds; i++) {
11736 if (thresholds[i] > 0 || thresholds[i] <= prev)
11739 prev = thresholds[i];
11742 if (wdev->iftype != NL80211_IFTYPE_STATION &&
11743 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
11744 return -EOPNOTSUPP;
11747 cfg80211_cqm_config_free(wdev);
11750 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
11751 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
11752 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
11754 return rdev_set_cqm_rssi_config(rdev, dev,
11755 thresholds[0], hysteresis);
11758 if (!wiphy_ext_feature_isset(&rdev->wiphy,
11759 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
11760 return -EOPNOTSUPP;
11762 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
11766 if (n_thresholds) {
11767 struct cfg80211_cqm_config *cqm_config;
11769 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
11770 n_thresholds * sizeof(s32), GFP_KERNEL);
11776 cqm_config->rssi_hyst = hysteresis;
11777 cqm_config->n_rssi_thresholds = n_thresholds;
11778 memcpy(cqm_config->rssi_thresholds, thresholds,
11779 n_thresholds * sizeof(s32));
11781 wdev->cqm_config = cqm_config;
11784 err = cfg80211_cqm_rssi_update(rdev, dev);
11792 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
11794 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
11795 struct nlattr *cqm;
11798 cqm = info->attrs[NL80211_ATTR_CQM];
11802 err = nla_parse_nested_deprecated(attrs, NL80211_ATTR_CQM_MAX, cqm,
11803 nl80211_attr_cqm_policy,
11808 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
11809 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
11810 const s32 *thresholds =
11811 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
11812 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
11813 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
11818 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
11822 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
11823 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
11824 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
11825 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
11826 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
11827 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
11829 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
11835 static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
11837 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11838 struct net_device *dev = info->user_ptr[1];
11839 struct ocb_setup setup = {};
11842 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
11846 return cfg80211_join_ocb(rdev, dev, &setup);
11849 static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
11851 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11852 struct net_device *dev = info->user_ptr[1];
11854 return cfg80211_leave_ocb(rdev, dev);
11857 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
11859 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11860 struct net_device *dev = info->user_ptr[1];
11861 struct mesh_config cfg;
11862 struct mesh_setup setup;
11865 /* start with default */
11866 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
11867 memcpy(&setup, &default_mesh_setup, sizeof(setup));
11869 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
11870 /* and parse parameters if given */
11871 err = nl80211_parse_mesh_config(info, &cfg, NULL);
11876 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
11877 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
11880 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
11881 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
11883 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
11884 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
11885 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
11888 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
11889 setup.beacon_interval =
11890 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
11892 err = cfg80211_validate_beacon_int(rdev,
11893 NL80211_IFTYPE_MESH_POINT,
11894 setup.beacon_interval);
11899 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
11900 setup.dtim_period =
11901 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
11902 if (setup.dtim_period < 1 || setup.dtim_period > 100)
11906 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
11907 /* parse additional setup parameters if given */
11908 err = nl80211_parse_mesh_setup(info, &setup);
11913 if (setup.user_mpm)
11914 cfg.auto_open_plinks = false;
11916 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
11917 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
11921 /* __cfg80211_join_mesh() will sort it out */
11922 setup.chandef.chan = NULL;
11925 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
11926 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
11928 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
11929 struct ieee80211_supported_band *sband;
11931 if (!setup.chandef.chan)
11934 sband = rdev->wiphy.bands[setup.chandef.chan->band];
11936 err = ieee80211_get_ratemask(sband, rates, n_rates,
11937 &setup.basic_rates);
11942 if (info->attrs[NL80211_ATTR_TX_RATES]) {
11943 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
11944 NL80211_ATTR_TX_RATES,
11945 &setup.beacon_rate,
11950 if (!setup.chandef.chan)
11953 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
11954 &setup.beacon_rate);
11959 setup.userspace_handles_dfs =
11960 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
11962 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
11963 int r = validate_pae_over_nl80211(rdev, info);
11968 setup.control_port_over_nl80211 = true;
11971 wdev_lock(dev->ieee80211_ptr);
11972 err = __cfg80211_join_mesh(rdev, dev, &setup, &cfg);
11973 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER])
11974 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
11975 wdev_unlock(dev->ieee80211_ptr);
11980 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
11982 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11983 struct net_device *dev = info->user_ptr[1];
11985 return cfg80211_leave_mesh(rdev, dev);
11989 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
11990 struct cfg80211_registered_device *rdev)
11992 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
11993 struct nlattr *nl_pats, *nl_pat;
11996 if (!wowlan->n_patterns)
11999 nl_pats = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
12003 for (i = 0; i < wowlan->n_patterns; i++) {
12004 nl_pat = nla_nest_start_noflag(msg, i + 1);
12007 pat_len = wowlan->patterns[i].pattern_len;
12008 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
12009 wowlan->patterns[i].mask) ||
12010 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
12011 wowlan->patterns[i].pattern) ||
12012 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
12013 wowlan->patterns[i].pkt_offset))
12015 nla_nest_end(msg, nl_pat);
12017 nla_nest_end(msg, nl_pats);
12022 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
12023 struct cfg80211_wowlan_tcp *tcp)
12025 struct nlattr *nl_tcp;
12030 nl_tcp = nla_nest_start_noflag(msg,
12031 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
12035 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
12036 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
12037 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
12038 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
12039 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
12040 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
12041 tcp->payload_len, tcp->payload) ||
12042 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
12043 tcp->data_interval) ||
12044 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
12045 tcp->wake_len, tcp->wake_data) ||
12046 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
12047 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
12050 if (tcp->payload_seq.len &&
12051 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
12052 sizeof(tcp->payload_seq), &tcp->payload_seq))
12055 if (tcp->payload_tok.len &&
12056 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
12057 sizeof(tcp->payload_tok) + tcp->tokens_size,
12058 &tcp->payload_tok))
12061 nla_nest_end(msg, nl_tcp);
12066 static int nl80211_send_wowlan_nd(struct sk_buff *msg,
12067 struct cfg80211_sched_scan_request *req)
12069 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
12075 nd = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
12079 if (req->n_scan_plans == 1 &&
12080 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
12081 req->scan_plans[0].interval * 1000))
12084 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
12087 if (req->relative_rssi_set) {
12088 struct nl80211_bss_select_rssi_adjust rssi_adjust;
12090 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
12091 req->relative_rssi))
12094 rssi_adjust.band = req->rssi_adjust.band;
12095 rssi_adjust.delta = req->rssi_adjust.delta;
12096 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
12097 sizeof(rssi_adjust), &rssi_adjust))
12101 freqs = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES);
12105 for (i = 0; i < req->n_channels; i++) {
12106 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
12110 nla_nest_end(msg, freqs);
12112 if (req->n_match_sets) {
12113 matches = nla_nest_start_noflag(msg,
12114 NL80211_ATTR_SCHED_SCAN_MATCH);
12118 for (i = 0; i < req->n_match_sets; i++) {
12119 match = nla_nest_start_noflag(msg, i);
12123 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
12124 req->match_sets[i].ssid.ssid_len,
12125 req->match_sets[i].ssid.ssid))
12127 nla_nest_end(msg, match);
12129 nla_nest_end(msg, matches);
12132 scan_plans = nla_nest_start_noflag(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
12136 for (i = 0; i < req->n_scan_plans; i++) {
12137 scan_plan = nla_nest_start_noflag(msg, i + 1);
12141 if (nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
12142 req->scan_plans[i].interval) ||
12143 (req->scan_plans[i].iterations &&
12144 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
12145 req->scan_plans[i].iterations)))
12147 nla_nest_end(msg, scan_plan);
12149 nla_nest_end(msg, scan_plans);
12151 nla_nest_end(msg, nd);
12156 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
12158 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12159 struct sk_buff *msg;
12161 u32 size = NLMSG_DEFAULT_SIZE;
12163 if (!rdev->wiphy.wowlan)
12164 return -EOPNOTSUPP;
12166 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
12167 /* adjust size to have room for all the data */
12168 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
12169 rdev->wiphy.wowlan_config->tcp->payload_len +
12170 rdev->wiphy.wowlan_config->tcp->wake_len +
12171 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
12174 msg = nlmsg_new(size, GFP_KERNEL);
12178 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12179 NL80211_CMD_GET_WOWLAN);
12181 goto nla_put_failure;
12183 if (rdev->wiphy.wowlan_config) {
12184 struct nlattr *nl_wowlan;
12186 nl_wowlan = nla_nest_start_noflag(msg,
12187 NL80211_ATTR_WOWLAN_TRIGGERS);
12189 goto nla_put_failure;
12191 if ((rdev->wiphy.wowlan_config->any &&
12192 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
12193 (rdev->wiphy.wowlan_config->disconnect &&
12194 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
12195 (rdev->wiphy.wowlan_config->magic_pkt &&
12196 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
12197 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
12198 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
12199 (rdev->wiphy.wowlan_config->eap_identity_req &&
12200 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
12201 (rdev->wiphy.wowlan_config->four_way_handshake &&
12202 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
12203 (rdev->wiphy.wowlan_config->rfkill_release &&
12204 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
12205 goto nla_put_failure;
12207 if (nl80211_send_wowlan_patterns(msg, rdev))
12208 goto nla_put_failure;
12210 if (nl80211_send_wowlan_tcp(msg,
12211 rdev->wiphy.wowlan_config->tcp))
12212 goto nla_put_failure;
12214 if (nl80211_send_wowlan_nd(
12216 rdev->wiphy.wowlan_config->nd_config))
12217 goto nla_put_failure;
12219 nla_nest_end(msg, nl_wowlan);
12222 genlmsg_end(msg, hdr);
12223 return genlmsg_reply(msg, info);
12230 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
12231 struct nlattr *attr,
12232 struct cfg80211_wowlan *trig)
12234 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
12235 struct cfg80211_wowlan_tcp *cfg;
12236 struct nl80211_wowlan_tcp_data_token *tok = NULL;
12237 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
12239 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
12242 if (!rdev->wiphy.wowlan->tcp)
12245 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TCP, attr,
12246 nl80211_wowlan_tcp_policy, NULL);
12250 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
12251 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
12252 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
12253 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
12254 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
12255 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
12256 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
12257 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
12260 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
12261 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
12264 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
12265 rdev->wiphy.wowlan->tcp->data_interval_max ||
12266 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
12269 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
12270 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
12273 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
12274 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
12277 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
12278 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
12280 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
12281 tokens_size = tokln - sizeof(*tok);
12283 if (!tok->len || tokens_size % tok->len)
12285 if (!rdev->wiphy.wowlan->tcp->tok)
12287 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
12289 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
12291 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
12293 if (tok->offset + tok->len > data_size)
12297 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
12298 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
12299 if (!rdev->wiphy.wowlan->tcp->seq)
12301 if (seq->len == 0 || seq->len > 4)
12303 if (seq->len + seq->offset > data_size)
12307 size = sizeof(*cfg);
12309 size += wake_size + wake_mask_size;
12310 size += tokens_size;
12312 cfg = kzalloc(size, GFP_KERNEL);
12315 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
12316 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
12317 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
12319 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
12320 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
12324 /* allocate a socket and port for it and use it */
12325 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
12326 IPPROTO_TCP, &cfg->sock, 1);
12331 if (inet_csk_get_port(cfg->sock->sk, port)) {
12332 sock_release(cfg->sock);
12334 return -EADDRINUSE;
12336 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
12342 cfg->src_port = port;
12345 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
12346 cfg->payload_len = data_size;
12347 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
12348 memcpy((void *)cfg->payload,
12349 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
12352 cfg->payload_seq = *seq;
12353 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
12354 cfg->wake_len = wake_size;
12355 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
12356 memcpy((void *)cfg->wake_data,
12357 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
12359 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
12360 data_size + wake_size;
12361 memcpy((void *)cfg->wake_mask,
12362 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
12365 cfg->tokens_size = tokens_size;
12366 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
12374 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
12375 const struct wiphy_wowlan_support *wowlan,
12376 struct nlattr *attr,
12377 struct cfg80211_wowlan *trig)
12379 struct nlattr **tb;
12382 tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
12386 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
12391 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_MAX, attr,
12392 nl80211_policy, NULL);
12396 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
12397 wowlan->max_nd_match_sets);
12398 err = PTR_ERR_OR_ZERO(trig->nd_config);
12400 trig->nd_config = NULL;
12407 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
12409 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12410 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
12411 struct cfg80211_wowlan new_triggers = {};
12412 struct cfg80211_wowlan *ntrig;
12413 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
12415 bool prev_enabled = rdev->wiphy.wowlan_config;
12416 bool regular = false;
12419 return -EOPNOTSUPP;
12421 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
12422 cfg80211_rdev_free_wowlan(rdev);
12423 rdev->wiphy.wowlan_config = NULL;
12427 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TRIG,
12428 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
12429 nl80211_wowlan_policy, info->extack);
12433 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
12434 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
12436 new_triggers.any = true;
12439 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
12440 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
12442 new_triggers.disconnect = true;
12446 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
12447 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
12449 new_triggers.magic_pkt = true;
12453 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
12456 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
12457 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
12459 new_triggers.gtk_rekey_failure = true;
12463 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
12464 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
12466 new_triggers.eap_identity_req = true;
12470 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
12471 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
12473 new_triggers.four_way_handshake = true;
12477 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
12478 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
12480 new_triggers.rfkill_release = true;
12484 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
12485 struct nlattr *pat;
12486 int n_patterns = 0;
12487 int rem, pat_len, mask_len, pkt_offset;
12488 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
12492 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
12495 if (n_patterns > wowlan->n_patterns)
12498 new_triggers.patterns = kcalloc(n_patterns,
12499 sizeof(new_triggers.patterns[0]),
12501 if (!new_triggers.patterns)
12504 new_triggers.n_patterns = n_patterns;
12507 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
12511 err = nla_parse_nested_deprecated(pat_tb,
12512 MAX_NL80211_PKTPAT,
12514 nl80211_packet_pattern_policy,
12520 if (!pat_tb[NL80211_PKTPAT_MASK] ||
12521 !pat_tb[NL80211_PKTPAT_PATTERN])
12523 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
12524 mask_len = DIV_ROUND_UP(pat_len, 8);
12525 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
12527 if (pat_len > wowlan->pattern_max_len ||
12528 pat_len < wowlan->pattern_min_len)
12531 if (!pat_tb[NL80211_PKTPAT_OFFSET])
12534 pkt_offset = nla_get_u32(
12535 pat_tb[NL80211_PKTPAT_OFFSET]);
12536 if (pkt_offset > wowlan->max_pkt_offset)
12538 new_triggers.patterns[i].pkt_offset = pkt_offset;
12540 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
12545 new_triggers.patterns[i].mask = mask_pat;
12546 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
12548 mask_pat += mask_len;
12549 new_triggers.patterns[i].pattern = mask_pat;
12550 new_triggers.patterns[i].pattern_len = pat_len;
12552 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
12558 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
12560 err = nl80211_parse_wowlan_tcp(
12561 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
12567 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
12569 err = nl80211_parse_wowlan_nd(
12570 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
12576 /* The 'any' trigger means the device continues operating more or less
12577 * as in its normal operation mode and wakes up the host on most of the
12578 * normal interrupts (like packet RX, ...)
12579 * It therefore makes little sense to combine with the more constrained
12580 * wakeup trigger modes.
12582 if (new_triggers.any && regular) {
12587 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
12592 cfg80211_rdev_free_wowlan(rdev);
12593 rdev->wiphy.wowlan_config = ntrig;
12596 if (rdev->ops->set_wakeup &&
12597 prev_enabled != !!rdev->wiphy.wowlan_config)
12598 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
12602 for (i = 0; i < new_triggers.n_patterns; i++)
12603 kfree(new_triggers.patterns[i].mask);
12604 kfree(new_triggers.patterns);
12605 if (new_triggers.tcp && new_triggers.tcp->sock)
12606 sock_release(new_triggers.tcp->sock);
12607 kfree(new_triggers.tcp);
12608 kfree(new_triggers.nd_config);
12613 static int nl80211_send_coalesce_rules(struct sk_buff *msg,
12614 struct cfg80211_registered_device *rdev)
12616 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
12618 struct cfg80211_coalesce_rules *rule;
12620 if (!rdev->coalesce->n_rules)
12623 nl_rules = nla_nest_start_noflag(msg, NL80211_ATTR_COALESCE_RULE);
12627 for (i = 0; i < rdev->coalesce->n_rules; i++) {
12628 nl_rule = nla_nest_start_noflag(msg, i + 1);
12632 rule = &rdev->coalesce->rules[i];
12633 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
12637 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
12641 nl_pats = nla_nest_start_noflag(msg,
12642 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
12646 for (j = 0; j < rule->n_patterns; j++) {
12647 nl_pat = nla_nest_start_noflag(msg, j + 1);
12650 pat_len = rule->patterns[j].pattern_len;
12651 if (nla_put(msg, NL80211_PKTPAT_MASK,
12652 DIV_ROUND_UP(pat_len, 8),
12653 rule->patterns[j].mask) ||
12654 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
12655 rule->patterns[j].pattern) ||
12656 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
12657 rule->patterns[j].pkt_offset))
12659 nla_nest_end(msg, nl_pat);
12661 nla_nest_end(msg, nl_pats);
12662 nla_nest_end(msg, nl_rule);
12664 nla_nest_end(msg, nl_rules);
12669 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
12671 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12672 struct sk_buff *msg;
12675 if (!rdev->wiphy.coalesce)
12676 return -EOPNOTSUPP;
12678 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12682 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12683 NL80211_CMD_GET_COALESCE);
12685 goto nla_put_failure;
12687 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
12688 goto nla_put_failure;
12690 genlmsg_end(msg, hdr);
12691 return genlmsg_reply(msg, info);
12698 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
12700 struct cfg80211_coalesce *coalesce = rdev->coalesce;
12702 struct cfg80211_coalesce_rules *rule;
12707 for (i = 0; i < coalesce->n_rules; i++) {
12708 rule = &coalesce->rules[i];
12709 for (j = 0; j < rule->n_patterns; j++)
12710 kfree(rule->patterns[j].mask);
12711 kfree(rule->patterns);
12713 kfree(coalesce->rules);
12715 rdev->coalesce = NULL;
12718 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
12719 struct nlattr *rule,
12720 struct cfg80211_coalesce_rules *new_rule)
12723 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
12724 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
12725 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
12726 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
12728 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_COALESCE_RULE_MAX,
12729 rule, nl80211_coalesce_policy, NULL);
12733 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
12735 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
12736 if (new_rule->delay > coalesce->max_delay)
12739 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
12740 new_rule->condition =
12741 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
12743 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
12746 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
12749 if (n_patterns > coalesce->n_patterns)
12752 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
12754 if (!new_rule->patterns)
12757 new_rule->n_patterns = n_patterns;
12760 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
12764 err = nla_parse_nested_deprecated(pat_tb, MAX_NL80211_PKTPAT,
12766 nl80211_packet_pattern_policy,
12771 if (!pat_tb[NL80211_PKTPAT_MASK] ||
12772 !pat_tb[NL80211_PKTPAT_PATTERN])
12774 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
12775 mask_len = DIV_ROUND_UP(pat_len, 8);
12776 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
12778 if (pat_len > coalesce->pattern_max_len ||
12779 pat_len < coalesce->pattern_min_len)
12782 if (!pat_tb[NL80211_PKTPAT_OFFSET])
12785 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
12786 if (pkt_offset > coalesce->max_pkt_offset)
12788 new_rule->patterns[i].pkt_offset = pkt_offset;
12790 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
12794 new_rule->patterns[i].mask = mask_pat;
12795 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
12798 mask_pat += mask_len;
12799 new_rule->patterns[i].pattern = mask_pat;
12800 new_rule->patterns[i].pattern_len = pat_len;
12801 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
12809 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
12811 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12812 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
12813 struct cfg80211_coalesce new_coalesce = {};
12814 struct cfg80211_coalesce *n_coalesce;
12815 int err, rem_rule, n_rules = 0, i, j;
12816 struct nlattr *rule;
12817 struct cfg80211_coalesce_rules *tmp_rule;
12819 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
12820 return -EOPNOTSUPP;
12822 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
12823 cfg80211_rdev_free_coalesce(rdev);
12824 rdev_set_coalesce(rdev, NULL);
12828 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
12831 if (n_rules > coalesce->n_rules)
12834 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
12836 if (!new_coalesce.rules)
12839 new_coalesce.n_rules = n_rules;
12842 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
12844 err = nl80211_parse_coalesce_rule(rdev, rule,
12845 &new_coalesce.rules[i]);
12852 err = rdev_set_coalesce(rdev, &new_coalesce);
12856 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
12861 cfg80211_rdev_free_coalesce(rdev);
12862 rdev->coalesce = n_coalesce;
12866 for (i = 0; i < new_coalesce.n_rules; i++) {
12867 tmp_rule = &new_coalesce.rules[i];
12868 for (j = 0; j < tmp_rule->n_patterns; j++)
12869 kfree(tmp_rule->patterns[j].mask);
12870 kfree(tmp_rule->patterns);
12872 kfree(new_coalesce.rules);
12877 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
12879 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12880 struct net_device *dev = info->user_ptr[1];
12881 struct wireless_dev *wdev = dev->ieee80211_ptr;
12882 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
12883 struct cfg80211_gtk_rekey_data rekey_data = {};
12886 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
12889 err = nla_parse_nested_deprecated(tb, MAX_NL80211_REKEY_DATA,
12890 info->attrs[NL80211_ATTR_REKEY_DATA],
12891 nl80211_rekey_policy, info->extack);
12895 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
12896 !tb[NL80211_REKEY_DATA_KCK])
12898 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN &&
12899 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK &&
12900 nla_len(tb[NL80211_REKEY_DATA_KEK]) == NL80211_KEK_EXT_LEN))
12902 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN &&
12903 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK &&
12904 nla_len(tb[NL80211_REKEY_DATA_KEK]) == NL80211_KCK_EXT_LEN))
12907 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
12908 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
12909 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
12910 rekey_data.kek_len = nla_len(tb[NL80211_REKEY_DATA_KEK]);
12911 rekey_data.kck_len = nla_len(tb[NL80211_REKEY_DATA_KCK]);
12912 if (tb[NL80211_REKEY_DATA_AKM])
12913 rekey_data.akm = nla_get_u32(tb[NL80211_REKEY_DATA_AKM]);
12916 if (!wdev->current_bss) {
12921 if (!rdev->ops->set_rekey_data) {
12926 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
12932 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
12933 struct genl_info *info)
12935 struct net_device *dev = info->user_ptr[1];
12936 struct wireless_dev *wdev = dev->ieee80211_ptr;
12938 if (wdev->iftype != NL80211_IFTYPE_AP &&
12939 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12942 if (wdev->ap_unexpected_nlportid)
12945 wdev->ap_unexpected_nlportid = info->snd_portid;
12949 static int nl80211_probe_client(struct sk_buff *skb,
12950 struct genl_info *info)
12952 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12953 struct net_device *dev = info->user_ptr[1];
12954 struct wireless_dev *wdev = dev->ieee80211_ptr;
12955 struct sk_buff *msg;
12961 if (wdev->iftype != NL80211_IFTYPE_AP &&
12962 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12963 return -EOPNOTSUPP;
12965 if (!info->attrs[NL80211_ATTR_MAC])
12968 if (!rdev->ops->probe_client)
12969 return -EOPNOTSUPP;
12971 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12975 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12976 NL80211_CMD_PROBE_CLIENT);
12982 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12984 err = rdev_probe_client(rdev, dev, addr, &cookie);
12988 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12990 goto nla_put_failure;
12992 genlmsg_end(msg, hdr);
12994 return genlmsg_reply(msg, info);
13003 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
13005 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13006 struct cfg80211_beacon_registration *reg, *nreg;
13009 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
13010 return -EOPNOTSUPP;
13012 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
13016 /* First, check if already registered. */
13017 spin_lock_bh(&rdev->beacon_registrations_lock);
13018 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
13019 if (reg->nlportid == info->snd_portid) {
13024 /* Add it to the list */
13025 nreg->nlportid = info->snd_portid;
13026 list_add(&nreg->list, &rdev->beacon_registrations);
13028 spin_unlock_bh(&rdev->beacon_registrations_lock);
13032 spin_unlock_bh(&rdev->beacon_registrations_lock);
13037 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
13039 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13040 struct wireless_dev *wdev = info->user_ptr[1];
13043 if (!rdev->ops->start_p2p_device)
13044 return -EOPNOTSUPP;
13046 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
13047 return -EOPNOTSUPP;
13049 if (wdev_running(wdev))
13052 if (rfkill_blocked(rdev->wiphy.rfkill))
13055 err = rdev_start_p2p_device(rdev, wdev);
13059 wdev->is_running = true;
13065 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
13067 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13068 struct wireless_dev *wdev = info->user_ptr[1];
13070 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
13071 return -EOPNOTSUPP;
13073 if (!rdev->ops->stop_p2p_device)
13074 return -EOPNOTSUPP;
13076 cfg80211_stop_p2p_device(rdev, wdev);
13081 static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
13083 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13084 struct wireless_dev *wdev = info->user_ptr[1];
13085 struct cfg80211_nan_conf conf = {};
13088 if (wdev->iftype != NL80211_IFTYPE_NAN)
13089 return -EOPNOTSUPP;
13091 if (wdev_running(wdev))
13094 if (rfkill_blocked(rdev->wiphy.rfkill))
13097 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
13101 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
13103 if (info->attrs[NL80211_ATTR_BANDS]) {
13104 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
13106 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
13107 return -EOPNOTSUPP;
13109 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
13112 conf.bands = bands;
13115 err = rdev_start_nan(rdev, wdev, &conf);
13119 wdev->is_running = true;
13125 static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
13127 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13128 struct wireless_dev *wdev = info->user_ptr[1];
13130 if (wdev->iftype != NL80211_IFTYPE_NAN)
13131 return -EOPNOTSUPP;
13133 cfg80211_stop_nan(rdev, wdev);
13138 static int validate_nan_filter(struct nlattr *filter_attr)
13140 struct nlattr *attr;
13141 int len = 0, n_entries = 0, rem;
13143 nla_for_each_nested(attr, filter_attr, rem) {
13144 len += nla_len(attr);
13154 static int handle_nan_filter(struct nlattr *attr_filter,
13155 struct cfg80211_nan_func *func,
13158 struct nlattr *attr;
13159 int n_entries, rem, i;
13160 struct cfg80211_nan_func_filter *filter;
13162 n_entries = validate_nan_filter(attr_filter);
13166 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
13168 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
13173 nla_for_each_nested(attr, attr_filter, rem) {
13174 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
13175 filter[i].len = nla_len(attr);
13179 func->num_tx_filters = n_entries;
13180 func->tx_filters = filter;
13182 func->num_rx_filters = n_entries;
13183 func->rx_filters = filter;
13189 static int nl80211_nan_add_func(struct sk_buff *skb,
13190 struct genl_info *info)
13192 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13193 struct wireless_dev *wdev = info->user_ptr[1];
13194 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
13195 struct cfg80211_nan_func *func;
13196 struct sk_buff *msg = NULL;
13200 if (wdev->iftype != NL80211_IFTYPE_NAN)
13201 return -EOPNOTSUPP;
13203 if (!wdev_running(wdev))
13206 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
13209 err = nla_parse_nested_deprecated(tb, NL80211_NAN_FUNC_ATTR_MAX,
13210 info->attrs[NL80211_ATTR_NAN_FUNC],
13211 nl80211_nan_func_policy,
13216 func = kzalloc(sizeof(*func), GFP_KERNEL);
13220 func->cookie = cfg80211_assign_cookie(rdev);
13222 if (!tb[NL80211_NAN_FUNC_TYPE]) {
13228 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
13230 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
13235 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
13236 sizeof(func->service_id));
13238 func->close_range =
13239 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
13241 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
13242 func->serv_spec_info_len =
13243 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
13244 func->serv_spec_info =
13245 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
13246 func->serv_spec_info_len,
13248 if (!func->serv_spec_info) {
13254 if (tb[NL80211_NAN_FUNC_TTL])
13255 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
13257 switch (func->type) {
13258 case NL80211_NAN_FUNC_PUBLISH:
13259 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
13264 func->publish_type =
13265 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
13266 func->publish_bcast =
13267 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
13269 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
13270 func->publish_bcast) {
13275 case NL80211_NAN_FUNC_SUBSCRIBE:
13276 func->subscribe_active =
13277 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
13279 case NL80211_NAN_FUNC_FOLLOW_UP:
13280 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
13281 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] ||
13282 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) {
13287 func->followup_id =
13288 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
13289 func->followup_reqid =
13290 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
13291 memcpy(func->followup_dest.addr,
13292 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
13293 sizeof(func->followup_dest.addr));
13304 if (tb[NL80211_NAN_FUNC_SRF]) {
13305 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
13307 err = nla_parse_nested_deprecated(srf_tb,
13308 NL80211_NAN_SRF_ATTR_MAX,
13309 tb[NL80211_NAN_FUNC_SRF],
13310 nl80211_nan_srf_policy,
13315 func->srf_include =
13316 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
13318 if (srf_tb[NL80211_NAN_SRF_BF]) {
13319 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
13320 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
13326 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
13328 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
13329 func->srf_bf_len, GFP_KERNEL);
13330 if (!func->srf_bf) {
13336 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
13338 struct nlattr *attr, *mac_attr =
13339 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
13340 int n_entries, rem, i = 0;
13347 n_entries = validate_acl_mac_addrs(mac_attr);
13348 if (n_entries <= 0) {
13353 func->srf_num_macs = n_entries;
13355 kcalloc(n_entries, sizeof(*func->srf_macs),
13357 if (!func->srf_macs) {
13362 nla_for_each_nested(attr, mac_attr, rem)
13363 memcpy(func->srf_macs[i++].addr, nla_data(attr),
13364 sizeof(*func->srf_macs));
13368 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
13369 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
13375 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
13376 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
13382 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13388 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13389 NL80211_CMD_ADD_NAN_FUNCTION);
13390 /* This can't really happen - we just allocated 4KB */
13391 if (WARN_ON(!hdr)) {
13396 err = rdev_add_nan_func(rdev, wdev, func);
13399 cfg80211_free_nan_func(func);
13404 /* propagate the instance id and cookie to userspace */
13405 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
13407 goto nla_put_failure;
13409 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
13411 goto nla_put_failure;
13413 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
13414 func->instance_id))
13415 goto nla_put_failure;
13417 nla_nest_end(msg, func_attr);
13419 genlmsg_end(msg, hdr);
13420 return genlmsg_reply(msg, info);
13427 static int nl80211_nan_del_func(struct sk_buff *skb,
13428 struct genl_info *info)
13430 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13431 struct wireless_dev *wdev = info->user_ptr[1];
13434 if (wdev->iftype != NL80211_IFTYPE_NAN)
13435 return -EOPNOTSUPP;
13437 if (!wdev_running(wdev))
13440 if (!info->attrs[NL80211_ATTR_COOKIE])
13443 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
13445 rdev_del_nan_func(rdev, wdev, cookie);
13450 static int nl80211_nan_change_config(struct sk_buff *skb,
13451 struct genl_info *info)
13453 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13454 struct wireless_dev *wdev = info->user_ptr[1];
13455 struct cfg80211_nan_conf conf = {};
13458 if (wdev->iftype != NL80211_IFTYPE_NAN)
13459 return -EOPNOTSUPP;
13461 if (!wdev_running(wdev))
13464 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
13466 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
13467 if (conf.master_pref <= 1 || conf.master_pref == 255)
13470 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
13473 if (info->attrs[NL80211_ATTR_BANDS]) {
13474 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
13476 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
13477 return -EOPNOTSUPP;
13479 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
13482 conf.bands = bands;
13483 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
13489 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
13492 void cfg80211_nan_match(struct wireless_dev *wdev,
13493 struct cfg80211_nan_match_params *match, gfp_t gfp)
13495 struct wiphy *wiphy = wdev->wiphy;
13496 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
13497 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
13498 struct sk_buff *msg;
13501 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
13504 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
13508 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
13514 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13515 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13516 wdev->netdev->ifindex)) ||
13517 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13519 goto nla_put_failure;
13521 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
13522 NL80211_ATTR_PAD) ||
13523 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
13524 goto nla_put_failure;
13526 match_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_MATCH);
13528 goto nla_put_failure;
13530 local_func_attr = nla_nest_start_noflag(msg,
13531 NL80211_NAN_MATCH_FUNC_LOCAL);
13532 if (!local_func_attr)
13533 goto nla_put_failure;
13535 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
13536 goto nla_put_failure;
13538 nla_nest_end(msg, local_func_attr);
13540 peer_func_attr = nla_nest_start_noflag(msg,
13541 NL80211_NAN_MATCH_FUNC_PEER);
13542 if (!peer_func_attr)
13543 goto nla_put_failure;
13545 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
13546 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
13547 goto nla_put_failure;
13549 if (match->info && match->info_len &&
13550 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
13552 goto nla_put_failure;
13554 nla_nest_end(msg, peer_func_attr);
13555 nla_nest_end(msg, match_attr);
13556 genlmsg_end(msg, hdr);
13558 if (!wdev->owner_nlportid)
13559 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
13560 msg, 0, NL80211_MCGRP_NAN, gfp);
13562 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
13563 wdev->owner_nlportid);
13570 EXPORT_SYMBOL(cfg80211_nan_match);
13572 void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
13574 enum nl80211_nan_func_term_reason reason,
13575 u64 cookie, gfp_t gfp)
13577 struct wiphy *wiphy = wdev->wiphy;
13578 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
13579 struct sk_buff *msg;
13580 struct nlattr *func_attr;
13583 if (WARN_ON(!inst_id))
13586 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
13590 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
13596 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13597 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
13598 wdev->netdev->ifindex)) ||
13599 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
13601 goto nla_put_failure;
13603 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
13605 goto nla_put_failure;
13607 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
13609 goto nla_put_failure;
13611 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
13612 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
13613 goto nla_put_failure;
13615 nla_nest_end(msg, func_attr);
13616 genlmsg_end(msg, hdr);
13618 if (!wdev->owner_nlportid)
13619 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
13620 msg, 0, NL80211_MCGRP_NAN, gfp);
13622 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
13623 wdev->owner_nlportid);
13630 EXPORT_SYMBOL(cfg80211_nan_func_terminated);
13632 static int nl80211_get_protocol_features(struct sk_buff *skb,
13633 struct genl_info *info)
13636 struct sk_buff *msg;
13638 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13642 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13643 NL80211_CMD_GET_PROTOCOL_FEATURES);
13645 goto nla_put_failure;
13647 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
13648 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
13649 goto nla_put_failure;
13651 genlmsg_end(msg, hdr);
13652 return genlmsg_reply(msg, info);
13659 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
13661 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13662 struct cfg80211_update_ft_ies_params ft_params;
13663 struct net_device *dev = info->user_ptr[1];
13665 if (!rdev->ops->update_ft_ies)
13666 return -EOPNOTSUPP;
13668 if (!info->attrs[NL80211_ATTR_MDID] ||
13669 !info->attrs[NL80211_ATTR_IE])
13672 memset(&ft_params, 0, sizeof(ft_params));
13673 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
13674 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
13675 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
13677 return rdev_update_ft_ies(rdev, dev, &ft_params);
13680 static int nl80211_crit_protocol_start(struct sk_buff *skb,
13681 struct genl_info *info)
13683 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13684 struct wireless_dev *wdev = info->user_ptr[1];
13685 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
13689 if (!rdev->ops->crit_proto_start)
13690 return -EOPNOTSUPP;
13692 if (WARN_ON(!rdev->ops->crit_proto_stop))
13695 if (rdev->crit_proto_nlportid)
13698 /* determine protocol if provided */
13699 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
13700 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
13702 if (proto >= NUM_NL80211_CRIT_PROTO)
13705 /* timeout must be provided */
13706 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
13710 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
13712 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
13714 rdev->crit_proto_nlportid = info->snd_portid;
13719 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
13720 struct genl_info *info)
13722 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13723 struct wireless_dev *wdev = info->user_ptr[1];
13725 if (!rdev->ops->crit_proto_stop)
13726 return -EOPNOTSUPP;
13728 if (rdev->crit_proto_nlportid) {
13729 rdev->crit_proto_nlportid = 0;
13730 rdev_crit_proto_stop(rdev, wdev);
13735 static int nl80211_vendor_check_policy(const struct wiphy_vendor_command *vcmd,
13736 struct nlattr *attr,
13737 struct netlink_ext_ack *extack)
13739 if (vcmd->policy == VENDOR_CMD_RAW_DATA) {
13740 if (attr->nla_type & NLA_F_NESTED) {
13741 NL_SET_ERR_MSG_ATTR(extack, attr,
13742 "unexpected nested data");
13749 if (!(attr->nla_type & NLA_F_NESTED)) {
13750 NL_SET_ERR_MSG_ATTR(extack, attr, "expected nested data");
13754 return nla_validate_nested(attr, vcmd->maxattr, vcmd->policy, extack);
13757 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
13759 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13760 struct wireless_dev *wdev =
13761 __cfg80211_wdev_from_attrs(rdev, genl_info_net(info),
13766 if (!rdev->wiphy.vendor_commands)
13767 return -EOPNOTSUPP;
13769 if (IS_ERR(wdev)) {
13770 err = PTR_ERR(wdev);
13771 if (err != -EINVAL)
13774 } else if (wdev->wiphy != &rdev->wiphy) {
13778 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
13779 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
13782 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
13783 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
13784 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
13785 const struct wiphy_vendor_command *vcmd;
13789 vcmd = &rdev->wiphy.vendor_commands[i];
13791 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
13794 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
13795 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
13798 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
13802 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
13803 if (!wdev_running(wdev))
13811 return -EOPNOTSUPP;
13813 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
13814 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
13815 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
13817 err = nl80211_vendor_check_policy(vcmd,
13818 info->attrs[NL80211_ATTR_VENDOR_DATA],
13824 rdev->cur_cmd_info = info;
13825 err = vcmd->doit(&rdev->wiphy, wdev, data, len);
13826 rdev->cur_cmd_info = NULL;
13830 return -EOPNOTSUPP;
13833 static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
13834 struct netlink_callback *cb,
13835 struct cfg80211_registered_device **rdev,
13836 struct wireless_dev **wdev)
13838 struct nlattr **attrbuf;
13844 unsigned int data_len = 0;
13847 /* subtract the 1 again here */
13848 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
13849 struct wireless_dev *tmp;
13853 *rdev = wiphy_to_rdev(wiphy);
13857 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
13858 if (tmp->identifier == cb->args[1] - 1) {
13865 /* keep rtnl locked in successful case */
13869 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
13873 err = nlmsg_parse_deprecated(cb->nlh,
13874 GENL_HDRLEN + nl80211_fam.hdrsize,
13875 attrbuf, nl80211_fam.maxattr,
13876 nl80211_policy, NULL);
13880 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
13881 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) {
13886 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(skb->sk), attrbuf);
13890 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
13891 if (IS_ERR(*rdev)) {
13892 err = PTR_ERR(*rdev);
13896 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
13897 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
13899 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
13900 const struct wiphy_vendor_command *vcmd;
13902 vcmd = &(*rdev)->wiphy.vendor_commands[i];
13904 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
13907 if (!vcmd->dumpit) {
13916 if (vcmd_idx < 0) {
13921 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
13922 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
13923 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
13925 err = nl80211_vendor_check_policy(
13926 &(*rdev)->wiphy.vendor_commands[vcmd_idx],
13927 attrbuf[NL80211_ATTR_VENDOR_DATA],
13933 /* 0 is the first index - add 1 to parse only once */
13934 cb->args[0] = (*rdev)->wiphy_idx + 1;
13935 /* add 1 to know if it was NULL */
13936 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
13937 cb->args[2] = vcmd_idx;
13938 cb->args[3] = (unsigned long)data;
13939 cb->args[4] = data_len;
13941 /* keep rtnl locked in successful case */
13948 static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
13949 struct netlink_callback *cb)
13951 struct cfg80211_registered_device *rdev;
13952 struct wireless_dev *wdev;
13953 unsigned int vcmd_idx;
13954 const struct wiphy_vendor_command *vcmd;
13958 struct nlattr *vendor_data;
13961 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
13965 vcmd_idx = cb->args[2];
13966 data = (void *)cb->args[3];
13967 data_len = cb->args[4];
13968 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
13970 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
13971 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
13976 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
13982 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
13983 if (!wdev_running(wdev)) {
13991 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
13992 cb->nlh->nlmsg_seq, NLM_F_MULTI,
13993 NL80211_CMD_VENDOR);
13997 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13998 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
14000 NL80211_ATTR_PAD))) {
14001 genlmsg_cancel(skb, hdr);
14005 vendor_data = nla_nest_start_noflag(skb,
14006 NL80211_ATTR_VENDOR_DATA);
14007 if (!vendor_data) {
14008 genlmsg_cancel(skb, hdr);
14012 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
14013 (unsigned long *)&cb->args[5]);
14014 nla_nest_end(skb, vendor_data);
14016 if (err == -ENOBUFS || err == -ENOENT) {
14017 genlmsg_cancel(skb, hdr);
14019 } else if (err <= 0) {
14020 genlmsg_cancel(skb, hdr);
14024 genlmsg_end(skb, hdr);
14033 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
14034 enum nl80211_commands cmd,
14035 enum nl80211_attrs attr,
14038 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14040 if (WARN_ON(!rdev->cur_cmd_info))
14043 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
14044 rdev->cur_cmd_info->snd_portid,
14045 rdev->cur_cmd_info->snd_seq,
14046 cmd, attr, NULL, GFP_KERNEL);
14048 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
14050 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
14052 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
14053 void *hdr = ((void **)skb->cb)[1];
14054 struct nlattr *data = ((void **)skb->cb)[2];
14056 /* clear CB data for netlink core to own from now on */
14057 memset(skb->cb, 0, sizeof(skb->cb));
14059 if (WARN_ON(!rdev->cur_cmd_info)) {
14064 nla_nest_end(skb, data);
14065 genlmsg_end(skb, hdr);
14066 return genlmsg_reply(skb, rdev->cur_cmd_info);
14068 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
14070 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy *wiphy)
14072 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14074 if (WARN_ON(!rdev->cur_cmd_info))
14077 return rdev->cur_cmd_info->snd_portid;
14079 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_get_sender);
14081 static int nl80211_set_qos_map(struct sk_buff *skb,
14082 struct genl_info *info)
14084 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14085 struct cfg80211_qos_map *qos_map = NULL;
14086 struct net_device *dev = info->user_ptr[1];
14087 u8 *pos, len, num_des, des_len, des;
14090 if (!rdev->ops->set_qos_map)
14091 return -EOPNOTSUPP;
14093 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
14094 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
14095 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
14100 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
14104 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
14106 des_len = num_des *
14107 sizeof(struct cfg80211_dscp_exception);
14108 memcpy(qos_map->dscp_exception, pos, des_len);
14109 qos_map->num_des = num_des;
14110 for (des = 0; des < num_des; des++) {
14111 if (qos_map->dscp_exception[des].up > 7) {
14118 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
14121 wdev_lock(dev->ieee80211_ptr);
14122 ret = nl80211_key_allowed(dev->ieee80211_ptr);
14124 ret = rdev_set_qos_map(rdev, dev, qos_map);
14125 wdev_unlock(dev->ieee80211_ptr);
14131 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
14133 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14134 struct net_device *dev = info->user_ptr[1];
14135 struct wireless_dev *wdev = dev->ieee80211_ptr;
14138 u16 admitted_time = 0;
14141 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
14142 return -EOPNOTSUPP;
14144 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
14145 !info->attrs[NL80211_ATTR_USER_PRIO])
14148 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
14149 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
14151 /* WMM uses TIDs 0-7 even for TSPEC */
14152 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
14153 /* TODO: handle 802.11 TSPEC/admission control
14154 * need more attributes for that (e.g. BA session requirement);
14155 * change the WMM adminssion test above to allow both then
14160 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
14162 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
14164 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
14165 if (!admitted_time)
14170 switch (wdev->iftype) {
14171 case NL80211_IFTYPE_STATION:
14172 case NL80211_IFTYPE_P2P_CLIENT:
14173 if (wdev->current_bss)
14182 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
14189 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
14191 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14192 struct net_device *dev = info->user_ptr[1];
14193 struct wireless_dev *wdev = dev->ieee80211_ptr;
14198 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
14201 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
14202 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
14205 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
14211 static int nl80211_tdls_channel_switch(struct sk_buff *skb,
14212 struct genl_info *info)
14214 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14215 struct net_device *dev = info->user_ptr[1];
14216 struct wireless_dev *wdev = dev->ieee80211_ptr;
14217 struct cfg80211_chan_def chandef = {};
14222 if (!rdev->ops->tdls_channel_switch ||
14223 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
14224 return -EOPNOTSUPP;
14226 switch (dev->ieee80211_ptr->iftype) {
14227 case NL80211_IFTYPE_STATION:
14228 case NL80211_IFTYPE_P2P_CLIENT:
14231 return -EOPNOTSUPP;
14234 if (!info->attrs[NL80211_ATTR_MAC] ||
14235 !info->attrs[NL80211_ATTR_OPER_CLASS])
14238 err = nl80211_parse_chandef(rdev, info, &chandef);
14243 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
14244 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
14245 * specification is not defined for them.
14247 if (chandef.chan->band == NL80211_BAND_2GHZ &&
14248 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
14249 chandef.width != NL80211_CHAN_WIDTH_20)
14252 /* we will be active on the TDLS link */
14253 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
14257 /* don't allow switching to DFS channels */
14258 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
14261 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
14262 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
14265 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
14271 static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
14272 struct genl_info *info)
14274 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14275 struct net_device *dev = info->user_ptr[1];
14276 struct wireless_dev *wdev = dev->ieee80211_ptr;
14279 if (!rdev->ops->tdls_channel_switch ||
14280 !rdev->ops->tdls_cancel_channel_switch ||
14281 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
14282 return -EOPNOTSUPP;
14284 switch (dev->ieee80211_ptr->iftype) {
14285 case NL80211_IFTYPE_STATION:
14286 case NL80211_IFTYPE_P2P_CLIENT:
14289 return -EOPNOTSUPP;
14292 if (!info->attrs[NL80211_ATTR_MAC])
14295 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
14298 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
14304 static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
14305 struct genl_info *info)
14307 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14308 struct net_device *dev = info->user_ptr[1];
14309 struct wireless_dev *wdev = dev->ieee80211_ptr;
14310 const struct nlattr *nla;
14313 if (!rdev->ops->set_multicast_to_unicast)
14314 return -EOPNOTSUPP;
14316 if (wdev->iftype != NL80211_IFTYPE_AP &&
14317 wdev->iftype != NL80211_IFTYPE_P2P_GO)
14318 return -EOPNOTSUPP;
14320 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
14321 enabled = nla_get_flag(nla);
14323 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
14326 static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
14328 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14329 struct net_device *dev = info->user_ptr[1];
14330 struct wireless_dev *wdev = dev->ieee80211_ptr;
14331 struct cfg80211_pmk_conf pmk_conf = {};
14334 if (wdev->iftype != NL80211_IFTYPE_STATION &&
14335 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
14336 return -EOPNOTSUPP;
14338 if (!wiphy_ext_feature_isset(&rdev->wiphy,
14339 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
14340 return -EOPNOTSUPP;
14342 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
14346 if (!wdev->current_bss) {
14351 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
14352 if (memcmp(pmk_conf.aa, wdev->current_bss->pub.bssid, ETH_ALEN)) {
14357 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
14358 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
14359 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
14360 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
14365 if (info->attrs[NL80211_ATTR_PMKR0_NAME])
14366 pmk_conf.pmk_r0_name =
14367 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
14369 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
14375 static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
14377 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14378 struct net_device *dev = info->user_ptr[1];
14379 struct wireless_dev *wdev = dev->ieee80211_ptr;
14383 if (wdev->iftype != NL80211_IFTYPE_STATION &&
14384 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
14385 return -EOPNOTSUPP;
14387 if (!wiphy_ext_feature_isset(&rdev->wiphy,
14388 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
14389 return -EOPNOTSUPP;
14391 if (!info->attrs[NL80211_ATTR_MAC])
14395 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
14396 ret = rdev_del_pmk(rdev, dev, aa);
14402 static int nl80211_external_auth(struct sk_buff *skb, struct genl_info *info)
14404 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14405 struct net_device *dev = info->user_ptr[1];
14406 struct cfg80211_external_auth_params params;
14408 if (!rdev->ops->external_auth)
14409 return -EOPNOTSUPP;
14411 if (!info->attrs[NL80211_ATTR_SSID] &&
14412 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
14413 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
14416 if (!info->attrs[NL80211_ATTR_BSSID])
14419 if (!info->attrs[NL80211_ATTR_STATUS_CODE])
14422 memset(¶ms, 0, sizeof(params));
14424 if (info->attrs[NL80211_ATTR_SSID]) {
14425 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
14426 if (params.ssid.ssid_len == 0)
14428 memcpy(params.ssid.ssid,
14429 nla_data(info->attrs[NL80211_ATTR_SSID]),
14430 params.ssid.ssid_len);
14433 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]),
14436 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
14438 if (info->attrs[NL80211_ATTR_PMKID])
14439 params.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
14441 return rdev_external_auth(rdev, dev, ¶ms);
14444 static int nl80211_tx_control_port(struct sk_buff *skb, struct genl_info *info)
14446 bool dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
14447 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14448 struct net_device *dev = info->user_ptr[1];
14449 struct wireless_dev *wdev = dev->ieee80211_ptr;
14458 if (!wiphy_ext_feature_isset(&rdev->wiphy,
14459 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
14460 return -EOPNOTSUPP;
14462 if (!rdev->ops->tx_control_port)
14463 return -EOPNOTSUPP;
14465 if (!info->attrs[NL80211_ATTR_FRAME] ||
14466 !info->attrs[NL80211_ATTR_MAC] ||
14467 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
14468 GENL_SET_ERR_MSG(info, "Frame, MAC or ethertype missing");
14474 switch (wdev->iftype) {
14475 case NL80211_IFTYPE_AP:
14476 case NL80211_IFTYPE_P2P_GO:
14477 case NL80211_IFTYPE_MESH_POINT:
14479 case NL80211_IFTYPE_ADHOC:
14480 case NL80211_IFTYPE_STATION:
14481 case NL80211_IFTYPE_P2P_CLIENT:
14482 if (wdev->current_bss)
14493 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
14494 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
14495 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
14496 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
14498 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
14500 err = rdev_tx_control_port(rdev, dev, buf, len,
14501 dest, cpu_to_be16(proto), noencrypt,
14502 dont_wait_for_ack ? NULL : &cookie);
14503 if (!err && !dont_wait_for_ack)
14504 nl_set_extack_cookie_u64(info->extack, cookie);
14511 static int nl80211_get_ftm_responder_stats(struct sk_buff *skb,
14512 struct genl_info *info)
14514 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14515 struct net_device *dev = info->user_ptr[1];
14516 struct wireless_dev *wdev = dev->ieee80211_ptr;
14517 struct cfg80211_ftm_responder_stats ftm_stats = {};
14518 struct sk_buff *msg;
14520 struct nlattr *ftm_stats_attr;
14523 if (wdev->iftype != NL80211_IFTYPE_AP || !wdev->beacon_interval)
14524 return -EOPNOTSUPP;
14526 err = rdev_get_ftm_responder_stats(rdev, dev, &ftm_stats);
14530 if (!ftm_stats.filled)
14533 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14537 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
14538 NL80211_CMD_GET_FTM_RESPONDER_STATS);
14540 goto nla_put_failure;
14542 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
14543 goto nla_put_failure;
14545 ftm_stats_attr = nla_nest_start_noflag(msg,
14546 NL80211_ATTR_FTM_RESPONDER_STATS);
14547 if (!ftm_stats_attr)
14548 goto nla_put_failure;
14550 #define SET_FTM(field, name, type) \
14551 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
14552 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \
14553 ftm_stats.field)) \
14554 goto nla_put_failure; } while (0)
14555 #define SET_FTM_U64(field, name) \
14556 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
14557 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \
14558 ftm_stats.field, NL80211_FTM_STATS_PAD)) \
14559 goto nla_put_failure; } while (0)
14561 SET_FTM(success_num, SUCCESS_NUM, u32);
14562 SET_FTM(partial_num, PARTIAL_NUM, u32);
14563 SET_FTM(failed_num, FAILED_NUM, u32);
14564 SET_FTM(asap_num, ASAP_NUM, u32);
14565 SET_FTM(non_asap_num, NON_ASAP_NUM, u32);
14566 SET_FTM_U64(total_duration_ms, TOTAL_DURATION_MSEC);
14567 SET_FTM(unknown_triggers_num, UNKNOWN_TRIGGERS_NUM, u32);
14568 SET_FTM(reschedule_requests_num, RESCHEDULE_REQUESTS_NUM, u32);
14569 SET_FTM(out_of_window_triggers_num, OUT_OF_WINDOW_TRIGGERS_NUM, u32);
14572 nla_nest_end(msg, ftm_stats_attr);
14574 genlmsg_end(msg, hdr);
14575 return genlmsg_reply(msg, info);
14582 static int nl80211_update_owe_info(struct sk_buff *skb, struct genl_info *info)
14584 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14585 struct cfg80211_update_owe_info owe_info;
14586 struct net_device *dev = info->user_ptr[1];
14588 if (!rdev->ops->update_owe_info)
14589 return -EOPNOTSUPP;
14591 if (!info->attrs[NL80211_ATTR_STATUS_CODE] ||
14592 !info->attrs[NL80211_ATTR_MAC])
14595 memset(&owe_info, 0, sizeof(owe_info));
14596 owe_info.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
14597 nla_memcpy(owe_info.peer, info->attrs[NL80211_ATTR_MAC], ETH_ALEN);
14599 if (info->attrs[NL80211_ATTR_IE]) {
14600 owe_info.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
14601 owe_info.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
14604 return rdev_update_owe_info(rdev, dev, &owe_info);
14607 static int nl80211_probe_mesh_link(struct sk_buff *skb, struct genl_info *info)
14609 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14610 struct net_device *dev = info->user_ptr[1];
14611 struct wireless_dev *wdev = dev->ieee80211_ptr;
14612 struct station_info sinfo = {};
14618 if (!rdev->ops->probe_mesh_link || !rdev->ops->get_station)
14619 return -EOPNOTSUPP;
14621 if (!info->attrs[NL80211_ATTR_MAC] ||
14622 !info->attrs[NL80211_ATTR_FRAME]) {
14623 GENL_SET_ERR_MSG(info, "Frame or MAC missing");
14627 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
14628 return -EOPNOTSUPP;
14630 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
14631 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
14632 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
14634 if (len < sizeof(struct ethhdr))
14637 if (!ether_addr_equal(buf, dest) || is_multicast_ether_addr(buf) ||
14638 !ether_addr_equal(buf + ETH_ALEN, dev->dev_addr))
14641 err = rdev_get_station(rdev, dev, dest, &sinfo);
14645 cfg80211_sinfo_release_content(&sinfo);
14647 return rdev_probe_mesh_link(rdev, dev, dest, buf, len);
14650 static int parse_tid_conf(struct cfg80211_registered_device *rdev,
14651 struct nlattr *attrs[], struct net_device *dev,
14652 struct cfg80211_tid_cfg *tid_conf,
14653 struct genl_info *info, const u8 *peer)
14655 struct netlink_ext_ack *extack = info->extack;
14659 if (!attrs[NL80211_TID_CONFIG_ATTR_TIDS])
14662 tid_conf->config_override =
14663 nla_get_flag(attrs[NL80211_TID_CONFIG_ATTR_OVERRIDE]);
14664 tid_conf->tids = nla_get_u16(attrs[NL80211_TID_CONFIG_ATTR_TIDS]);
14666 if (tid_conf->config_override) {
14667 if (rdev->ops->reset_tid_config) {
14668 err = rdev_reset_tid_config(rdev, dev, peer,
14677 if (attrs[NL80211_TID_CONFIG_ATTR_NOACK]) {
14678 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_NOACK);
14680 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_NOACK]);
14683 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]) {
14684 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT);
14685 tid_conf->retry_short =
14686 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]);
14688 if (tid_conf->retry_short > rdev->wiphy.max_data_retry_count)
14692 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]) {
14693 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
14694 tid_conf->retry_long =
14695 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]);
14697 if (tid_conf->retry_long > rdev->wiphy.max_data_retry_count)
14701 if (attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]) {
14702 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);
14704 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]);
14707 if (attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]) {
14708 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);
14710 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]);
14713 if (attrs[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL]) {
14714 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMSDU_CTRL);
14716 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL]);
14719 if (attrs[NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE]) {
14720 u32 idx = NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE, attr;
14722 tid_conf->txrate_type = nla_get_u8(attrs[idx]);
14724 if (tid_conf->txrate_type != NL80211_TX_RATE_AUTOMATIC) {
14725 attr = NL80211_TID_CONFIG_ATTR_TX_RATE;
14726 err = nl80211_parse_tx_bitrate_mask(info, attrs, attr,
14727 &tid_conf->txrate_mask, dev,
14732 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE);
14734 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE);
14738 mask = rdev->wiphy.tid_config_support.peer;
14740 mask = rdev->wiphy.tid_config_support.vif;
14742 if (tid_conf->mask & ~mask) {
14743 NL_SET_ERR_MSG(extack, "unsupported TID configuration");
14750 static int nl80211_set_tid_config(struct sk_buff *skb,
14751 struct genl_info *info)
14753 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14754 struct nlattr *attrs[NL80211_TID_CONFIG_ATTR_MAX + 1];
14755 struct net_device *dev = info->user_ptr[1];
14756 struct cfg80211_tid_config *tid_config;
14757 struct nlattr *tid;
14758 int conf_idx = 0, rem_conf;
14762 if (!info->attrs[NL80211_ATTR_TID_CONFIG])
14765 if (!rdev->ops->set_tid_config)
14766 return -EOPNOTSUPP;
14768 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
14772 tid_config = kzalloc(struct_size(tid_config, tid_conf, num_conf),
14777 tid_config->n_tid_conf = num_conf;
14779 if (info->attrs[NL80211_ATTR_MAC])
14780 tid_config->peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
14782 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
14784 ret = nla_parse_nested(attrs, NL80211_TID_CONFIG_ATTR_MAX,
14790 ret = parse_tid_conf(rdev, attrs, dev,
14791 &tid_config->tid_conf[conf_idx],
14792 info, tid_config->peer);
14799 ret = rdev_set_tid_config(rdev, dev, tid_config);
14806 #define NL80211_FLAG_NEED_WIPHY 0x01
14807 #define NL80211_FLAG_NEED_NETDEV 0x02
14808 #define NL80211_FLAG_NEED_RTNL 0x04
14809 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
14810 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
14811 NL80211_FLAG_CHECK_NETDEV_UP)
14812 #define NL80211_FLAG_NEED_WDEV 0x10
14813 /* If a netdev is associated, it must be UP, P2P must be started */
14814 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
14815 NL80211_FLAG_CHECK_NETDEV_UP)
14816 #define NL80211_FLAG_CLEAR_SKB 0x20
14817 #define NL80211_FLAG_NO_WIPHY_MTX 0x40
14819 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
14820 struct genl_info *info)
14822 struct cfg80211_registered_device *rdev = NULL;
14823 struct wireless_dev *wdev;
14824 struct net_device *dev;
14827 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
14828 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
14829 if (IS_ERR(rdev)) {
14831 return PTR_ERR(rdev);
14833 info->user_ptr[0] = rdev;
14834 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
14835 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
14836 wdev = __cfg80211_wdev_from_attrs(NULL, genl_info_net(info),
14838 if (IS_ERR(wdev)) {
14840 return PTR_ERR(wdev);
14843 dev = wdev->netdev;
14844 rdev = wiphy_to_rdev(wdev->wiphy);
14846 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
14852 info->user_ptr[1] = dev;
14854 info->user_ptr[1] = wdev;
14857 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
14858 !wdev_running(wdev)) {
14866 info->user_ptr[0] = rdev;
14869 if (rdev && !(ops->internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) {
14870 wiphy_lock(&rdev->wiphy);
14871 /* we keep the mutex locked until post_doit */
14872 __release(&rdev->wiphy.mtx);
14874 if (!(ops->internal_flags & NL80211_FLAG_NEED_RTNL))
14880 static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
14881 struct genl_info *info)
14883 if (info->user_ptr[1]) {
14884 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
14885 struct wireless_dev *wdev = info->user_ptr[1];
14888 dev_put(wdev->netdev);
14890 dev_put(info->user_ptr[1]);
14894 if (info->user_ptr[0] &&
14895 !(ops->internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) {
14896 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14898 /* we kept the mutex locked since pre_doit */
14899 __acquire(&rdev->wiphy.mtx);
14900 wiphy_unlock(&rdev->wiphy);
14903 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
14906 /* If needed, clear the netlink message payload from the SKB
14907 * as it might contain key data that shouldn't stick around on
14908 * the heap after the SKB is freed. The netlink message header
14909 * is still needed for further processing, so leave it intact.
14911 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
14912 struct nlmsghdr *nlh = nlmsg_hdr(skb);
14914 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
14918 static int nl80211_set_sar_sub_specs(struct cfg80211_registered_device *rdev,
14919 struct cfg80211_sar_specs *sar_specs,
14920 struct nlattr *spec[], int index)
14922 u32 range_index, i;
14924 if (!sar_specs || !spec)
14927 if (!spec[NL80211_SAR_ATTR_SPECS_POWER] ||
14928 !spec[NL80211_SAR_ATTR_SPECS_RANGE_INDEX])
14931 range_index = nla_get_u32(spec[NL80211_SAR_ATTR_SPECS_RANGE_INDEX]);
14933 /* check if range_index exceeds num_freq_ranges */
14934 if (range_index >= rdev->wiphy.sar_capa->num_freq_ranges)
14937 /* check if range_index duplicates */
14938 for (i = 0; i < index; i++) {
14939 if (sar_specs->sub_specs[i].freq_range_index == range_index)
14943 sar_specs->sub_specs[index].power =
14944 nla_get_s32(spec[NL80211_SAR_ATTR_SPECS_POWER]);
14946 sar_specs->sub_specs[index].freq_range_index = range_index;
14951 static int nl80211_set_sar_specs(struct sk_buff *skb, struct genl_info *info)
14953 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14954 struct nlattr *spec[NL80211_SAR_ATTR_SPECS_MAX + 1];
14955 struct nlattr *tb[NL80211_SAR_ATTR_MAX + 1];
14956 struct cfg80211_sar_specs *sar_spec;
14957 enum nl80211_sar_type type;
14958 struct nlattr *spec_list;
14962 if (!rdev->wiphy.sar_capa || !rdev->ops->set_sar_specs)
14963 return -EOPNOTSUPP;
14965 if (!info->attrs[NL80211_ATTR_SAR_SPEC])
14968 nla_parse_nested(tb, NL80211_SAR_ATTR_MAX,
14969 info->attrs[NL80211_ATTR_SAR_SPEC],
14972 if (!tb[NL80211_SAR_ATTR_TYPE] || !tb[NL80211_SAR_ATTR_SPECS])
14975 type = nla_get_u32(tb[NL80211_SAR_ATTR_TYPE]);
14976 if (type != rdev->wiphy.sar_capa->type)
14980 nla_for_each_nested(spec_list, tb[NL80211_SAR_ATTR_SPECS], rem)
14983 if (specs > rdev->wiphy.sar_capa->num_freq_ranges)
14986 sar_spec = kzalloc(sizeof(*sar_spec) +
14987 specs * sizeof(struct cfg80211_sar_sub_specs),
14992 sar_spec->type = type;
14994 nla_for_each_nested(spec_list, tb[NL80211_SAR_ATTR_SPECS], rem) {
14995 nla_parse_nested(spec, NL80211_SAR_ATTR_SPECS_MAX,
14996 spec_list, NULL, NULL);
14999 case NL80211_SAR_TYPE_POWER:
15000 if (nl80211_set_sar_sub_specs(rdev, sar_spec,
15013 sar_spec->num_sub_specs = specs;
15015 rdev->cur_cmd_info = info;
15016 err = rdev_set_sar_specs(rdev, sar_spec);
15017 rdev->cur_cmd_info = NULL;
15023 static const struct genl_ops nl80211_ops[] = {
15025 .cmd = NL80211_CMD_GET_WIPHY,
15026 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15027 .doit = nl80211_get_wiphy,
15028 .dumpit = nl80211_dump_wiphy,
15029 .done = nl80211_dump_wiphy_done,
15030 /* can be retrieved by unprivileged users */
15031 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15035 static const struct genl_small_ops nl80211_small_ops[] = {
15037 .cmd = NL80211_CMD_SET_WIPHY,
15038 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15039 .doit = nl80211_set_wiphy,
15040 .flags = GENL_UNS_ADMIN_PERM,
15043 .cmd = NL80211_CMD_GET_INTERFACE,
15044 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15045 .doit = nl80211_get_interface,
15046 .dumpit = nl80211_dump_interface,
15047 /* can be retrieved by unprivileged users */
15048 .internal_flags = NL80211_FLAG_NEED_WDEV,
15051 .cmd = NL80211_CMD_SET_INTERFACE,
15052 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15053 .doit = nl80211_set_interface,
15054 .flags = GENL_UNS_ADMIN_PERM,
15055 .internal_flags = NL80211_FLAG_NEED_NETDEV |
15056 NL80211_FLAG_NEED_RTNL,
15059 .cmd = NL80211_CMD_NEW_INTERFACE,
15060 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15061 .doit = nl80211_new_interface,
15062 .flags = GENL_UNS_ADMIN_PERM,
15063 .internal_flags = NL80211_FLAG_NEED_WIPHY |
15064 NL80211_FLAG_NEED_RTNL |
15065 /* we take the wiphy mutex later ourselves */
15066 NL80211_FLAG_NO_WIPHY_MTX,
15069 .cmd = NL80211_CMD_DEL_INTERFACE,
15070 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15071 .doit = nl80211_del_interface,
15072 .flags = GENL_UNS_ADMIN_PERM,
15073 .internal_flags = NL80211_FLAG_NEED_WDEV |
15074 NL80211_FLAG_NEED_RTNL,
15077 .cmd = NL80211_CMD_GET_KEY,
15078 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15079 .doit = nl80211_get_key,
15080 .flags = GENL_UNS_ADMIN_PERM,
15081 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15084 .cmd = NL80211_CMD_SET_KEY,
15085 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15086 .doit = nl80211_set_key,
15087 .flags = GENL_UNS_ADMIN_PERM,
15088 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15089 NL80211_FLAG_CLEAR_SKB,
15092 .cmd = NL80211_CMD_NEW_KEY,
15093 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15094 .doit = nl80211_new_key,
15095 .flags = GENL_UNS_ADMIN_PERM,
15096 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15097 NL80211_FLAG_CLEAR_SKB,
15100 .cmd = NL80211_CMD_DEL_KEY,
15101 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15102 .doit = nl80211_del_key,
15103 .flags = GENL_UNS_ADMIN_PERM,
15104 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15107 .cmd = NL80211_CMD_SET_BEACON,
15108 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15109 .flags = GENL_UNS_ADMIN_PERM,
15110 .doit = nl80211_set_beacon,
15111 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15114 .cmd = NL80211_CMD_START_AP,
15115 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15116 .flags = GENL_UNS_ADMIN_PERM,
15117 .doit = nl80211_start_ap,
15118 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15121 .cmd = NL80211_CMD_STOP_AP,
15122 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15123 .flags = GENL_UNS_ADMIN_PERM,
15124 .doit = nl80211_stop_ap,
15125 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15128 .cmd = NL80211_CMD_GET_STATION,
15129 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15130 .doit = nl80211_get_station,
15131 .dumpit = nl80211_dump_station,
15132 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15135 .cmd = NL80211_CMD_SET_STATION,
15136 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15137 .doit = nl80211_set_station,
15138 .flags = GENL_UNS_ADMIN_PERM,
15139 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15142 .cmd = NL80211_CMD_NEW_STATION,
15143 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15144 .doit = nl80211_new_station,
15145 .flags = GENL_UNS_ADMIN_PERM,
15146 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15149 .cmd = NL80211_CMD_DEL_STATION,
15150 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15151 .doit = nl80211_del_station,
15152 .flags = GENL_UNS_ADMIN_PERM,
15153 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15156 .cmd = NL80211_CMD_GET_MPATH,
15157 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15158 .doit = nl80211_get_mpath,
15159 .dumpit = nl80211_dump_mpath,
15160 .flags = GENL_UNS_ADMIN_PERM,
15161 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15164 .cmd = NL80211_CMD_GET_MPP,
15165 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15166 .doit = nl80211_get_mpp,
15167 .dumpit = nl80211_dump_mpp,
15168 .flags = GENL_UNS_ADMIN_PERM,
15169 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15172 .cmd = NL80211_CMD_SET_MPATH,
15173 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15174 .doit = nl80211_set_mpath,
15175 .flags = GENL_UNS_ADMIN_PERM,
15176 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15179 .cmd = NL80211_CMD_NEW_MPATH,
15180 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15181 .doit = nl80211_new_mpath,
15182 .flags = GENL_UNS_ADMIN_PERM,
15183 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15186 .cmd = NL80211_CMD_DEL_MPATH,
15187 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15188 .doit = nl80211_del_mpath,
15189 .flags = GENL_UNS_ADMIN_PERM,
15190 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15193 .cmd = NL80211_CMD_SET_BSS,
15194 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15195 .doit = nl80211_set_bss,
15196 .flags = GENL_UNS_ADMIN_PERM,
15197 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15200 .cmd = NL80211_CMD_GET_REG,
15201 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15202 .doit = nl80211_get_reg_do,
15203 .dumpit = nl80211_get_reg_dump,
15204 .internal_flags = 0,
15205 /* can be retrieved by unprivileged users */
15207 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
15209 .cmd = NL80211_CMD_SET_REG,
15210 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15211 .doit = nl80211_set_reg,
15212 .flags = GENL_ADMIN_PERM,
15213 .internal_flags = 0,
15217 .cmd = NL80211_CMD_REQ_SET_REG,
15218 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15219 .doit = nl80211_req_set_reg,
15220 .flags = GENL_ADMIN_PERM,
15223 .cmd = NL80211_CMD_RELOAD_REGDB,
15224 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15225 .doit = nl80211_reload_regdb,
15226 .flags = GENL_ADMIN_PERM,
15229 .cmd = NL80211_CMD_GET_MESH_CONFIG,
15230 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15231 .doit = nl80211_get_mesh_config,
15232 /* can be retrieved by unprivileged users */
15233 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15236 .cmd = NL80211_CMD_SET_MESH_CONFIG,
15237 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15238 .doit = nl80211_update_mesh_config,
15239 .flags = GENL_UNS_ADMIN_PERM,
15240 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15243 .cmd = NL80211_CMD_TRIGGER_SCAN,
15244 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15245 .doit = nl80211_trigger_scan,
15246 .flags = GENL_UNS_ADMIN_PERM,
15247 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15250 .cmd = NL80211_CMD_ABORT_SCAN,
15251 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15252 .doit = nl80211_abort_scan,
15253 .flags = GENL_UNS_ADMIN_PERM,
15254 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15257 .cmd = NL80211_CMD_GET_SCAN,
15258 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15259 .dumpit = nl80211_dump_scan,
15262 .cmd = NL80211_CMD_START_SCHED_SCAN,
15263 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15264 .doit = nl80211_start_sched_scan,
15265 .flags = GENL_UNS_ADMIN_PERM,
15266 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15269 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
15270 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15271 .doit = nl80211_stop_sched_scan,
15272 .flags = GENL_UNS_ADMIN_PERM,
15273 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15276 .cmd = NL80211_CMD_AUTHENTICATE,
15277 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15278 .doit = nl80211_authenticate,
15279 .flags = GENL_UNS_ADMIN_PERM,
15280 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15282 NL80211_FLAG_CLEAR_SKB,
15285 .cmd = NL80211_CMD_ASSOCIATE,
15286 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15287 .doit = nl80211_associate,
15288 .flags = GENL_UNS_ADMIN_PERM,
15289 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15291 NL80211_FLAG_CLEAR_SKB,
15294 .cmd = NL80211_CMD_DEAUTHENTICATE,
15295 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15296 .doit = nl80211_deauthenticate,
15297 .flags = GENL_UNS_ADMIN_PERM,
15298 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15301 .cmd = NL80211_CMD_DISASSOCIATE,
15302 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15303 .doit = nl80211_disassociate,
15304 .flags = GENL_UNS_ADMIN_PERM,
15305 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15308 .cmd = NL80211_CMD_JOIN_IBSS,
15309 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15310 .doit = nl80211_join_ibss,
15311 .flags = GENL_UNS_ADMIN_PERM,
15312 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15315 .cmd = NL80211_CMD_LEAVE_IBSS,
15316 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15317 .doit = nl80211_leave_ibss,
15318 .flags = GENL_UNS_ADMIN_PERM,
15319 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15321 #ifdef CONFIG_NL80211_TESTMODE
15323 .cmd = NL80211_CMD_TESTMODE,
15324 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15325 .doit = nl80211_testmode_do,
15326 .dumpit = nl80211_testmode_dump,
15327 .flags = GENL_UNS_ADMIN_PERM,
15328 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15332 .cmd = NL80211_CMD_CONNECT,
15333 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15334 .doit = nl80211_connect,
15335 .flags = GENL_UNS_ADMIN_PERM,
15336 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15338 NL80211_FLAG_CLEAR_SKB,
15341 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
15342 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15343 .doit = nl80211_update_connect_params,
15344 .flags = GENL_ADMIN_PERM,
15345 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15347 NL80211_FLAG_CLEAR_SKB,
15350 .cmd = NL80211_CMD_DISCONNECT,
15351 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15352 .doit = nl80211_disconnect,
15353 .flags = GENL_UNS_ADMIN_PERM,
15354 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15357 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
15358 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15359 .doit = nl80211_wiphy_netns,
15360 .flags = GENL_UNS_ADMIN_PERM,
15361 .internal_flags = NL80211_FLAG_NEED_WIPHY |
15362 NL80211_FLAG_NEED_RTNL |
15363 NL80211_FLAG_NO_WIPHY_MTX,
15366 .cmd = NL80211_CMD_GET_SURVEY,
15367 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15368 .dumpit = nl80211_dump_survey,
15371 .cmd = NL80211_CMD_SET_PMKSA,
15372 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15373 .doit = nl80211_setdel_pmksa,
15374 .flags = GENL_UNS_ADMIN_PERM,
15375 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15377 NL80211_FLAG_CLEAR_SKB,
15380 .cmd = NL80211_CMD_DEL_PMKSA,
15381 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15382 .doit = nl80211_setdel_pmksa,
15383 .flags = GENL_UNS_ADMIN_PERM,
15384 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15387 .cmd = NL80211_CMD_FLUSH_PMKSA,
15388 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15389 .doit = nl80211_flush_pmksa,
15390 .flags = GENL_UNS_ADMIN_PERM,
15391 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15394 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
15395 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15396 .doit = nl80211_remain_on_channel,
15397 .flags = GENL_UNS_ADMIN_PERM,
15398 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15401 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
15402 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15403 .doit = nl80211_cancel_remain_on_channel,
15404 .flags = GENL_UNS_ADMIN_PERM,
15405 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15408 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
15409 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15410 .doit = nl80211_set_tx_bitrate_mask,
15411 .flags = GENL_UNS_ADMIN_PERM,
15412 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15415 .cmd = NL80211_CMD_REGISTER_FRAME,
15416 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15417 .doit = nl80211_register_mgmt,
15418 .flags = GENL_UNS_ADMIN_PERM,
15419 .internal_flags = NL80211_FLAG_NEED_WDEV,
15422 .cmd = NL80211_CMD_FRAME,
15423 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15424 .doit = nl80211_tx_mgmt,
15425 .flags = GENL_UNS_ADMIN_PERM,
15426 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15429 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
15430 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15431 .doit = nl80211_tx_mgmt_cancel_wait,
15432 .flags = GENL_UNS_ADMIN_PERM,
15433 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15436 .cmd = NL80211_CMD_SET_POWER_SAVE,
15437 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15438 .doit = nl80211_set_power_save,
15439 .flags = GENL_UNS_ADMIN_PERM,
15440 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15443 .cmd = NL80211_CMD_GET_POWER_SAVE,
15444 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15445 .doit = nl80211_get_power_save,
15446 /* can be retrieved by unprivileged users */
15447 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15450 .cmd = NL80211_CMD_SET_CQM,
15451 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15452 .doit = nl80211_set_cqm,
15453 .flags = GENL_UNS_ADMIN_PERM,
15454 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15457 .cmd = NL80211_CMD_SET_CHANNEL,
15458 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15459 .doit = nl80211_set_channel,
15460 .flags = GENL_UNS_ADMIN_PERM,
15461 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15464 .cmd = NL80211_CMD_JOIN_MESH,
15465 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15466 .doit = nl80211_join_mesh,
15467 .flags = GENL_UNS_ADMIN_PERM,
15468 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15471 .cmd = NL80211_CMD_LEAVE_MESH,
15472 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15473 .doit = nl80211_leave_mesh,
15474 .flags = GENL_UNS_ADMIN_PERM,
15475 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15478 .cmd = NL80211_CMD_JOIN_OCB,
15479 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15480 .doit = nl80211_join_ocb,
15481 .flags = GENL_UNS_ADMIN_PERM,
15482 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15485 .cmd = NL80211_CMD_LEAVE_OCB,
15486 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15487 .doit = nl80211_leave_ocb,
15488 .flags = GENL_UNS_ADMIN_PERM,
15489 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15493 .cmd = NL80211_CMD_GET_WOWLAN,
15494 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15495 .doit = nl80211_get_wowlan,
15496 /* can be retrieved by unprivileged users */
15497 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15500 .cmd = NL80211_CMD_SET_WOWLAN,
15501 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15502 .doit = nl80211_set_wowlan,
15503 .flags = GENL_UNS_ADMIN_PERM,
15504 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15508 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
15509 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15510 .doit = nl80211_set_rekey_data,
15511 .flags = GENL_UNS_ADMIN_PERM,
15512 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15514 NL80211_FLAG_CLEAR_SKB,
15517 .cmd = NL80211_CMD_TDLS_MGMT,
15518 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15519 .doit = nl80211_tdls_mgmt,
15520 .flags = GENL_UNS_ADMIN_PERM,
15521 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15524 .cmd = NL80211_CMD_TDLS_OPER,
15525 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15526 .doit = nl80211_tdls_oper,
15527 .flags = GENL_UNS_ADMIN_PERM,
15528 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15531 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
15532 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15533 .doit = nl80211_register_unexpected_frame,
15534 .flags = GENL_UNS_ADMIN_PERM,
15535 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15538 .cmd = NL80211_CMD_PROBE_CLIENT,
15539 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15540 .doit = nl80211_probe_client,
15541 .flags = GENL_UNS_ADMIN_PERM,
15542 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15545 .cmd = NL80211_CMD_REGISTER_BEACONS,
15546 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15547 .doit = nl80211_register_beacons,
15548 .flags = GENL_UNS_ADMIN_PERM,
15549 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15552 .cmd = NL80211_CMD_SET_NOACK_MAP,
15553 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15554 .doit = nl80211_set_noack_map,
15555 .flags = GENL_UNS_ADMIN_PERM,
15556 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15559 .cmd = NL80211_CMD_START_P2P_DEVICE,
15560 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15561 .doit = nl80211_start_p2p_device,
15562 .flags = GENL_UNS_ADMIN_PERM,
15563 .internal_flags = NL80211_FLAG_NEED_WDEV |
15564 NL80211_FLAG_NEED_RTNL,
15567 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
15568 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15569 .doit = nl80211_stop_p2p_device,
15570 .flags = GENL_UNS_ADMIN_PERM,
15571 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
15572 NL80211_FLAG_NEED_RTNL,
15575 .cmd = NL80211_CMD_START_NAN,
15576 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15577 .doit = nl80211_start_nan,
15578 .flags = GENL_ADMIN_PERM,
15579 .internal_flags = NL80211_FLAG_NEED_WDEV |
15580 NL80211_FLAG_NEED_RTNL,
15583 .cmd = NL80211_CMD_STOP_NAN,
15584 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15585 .doit = nl80211_stop_nan,
15586 .flags = GENL_ADMIN_PERM,
15587 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
15588 NL80211_FLAG_NEED_RTNL,
15591 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
15592 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15593 .doit = nl80211_nan_add_func,
15594 .flags = GENL_ADMIN_PERM,
15595 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15598 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
15599 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15600 .doit = nl80211_nan_del_func,
15601 .flags = GENL_ADMIN_PERM,
15602 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15605 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
15606 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15607 .doit = nl80211_nan_change_config,
15608 .flags = GENL_ADMIN_PERM,
15609 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15612 .cmd = NL80211_CMD_SET_MCAST_RATE,
15613 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15614 .doit = nl80211_set_mcast_rate,
15615 .flags = GENL_UNS_ADMIN_PERM,
15616 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15619 .cmd = NL80211_CMD_SET_MAC_ACL,
15620 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15621 .doit = nl80211_set_mac_acl,
15622 .flags = GENL_UNS_ADMIN_PERM,
15623 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15626 .cmd = NL80211_CMD_RADAR_DETECT,
15627 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15628 .doit = nl80211_start_radar_detection,
15629 .flags = GENL_UNS_ADMIN_PERM,
15630 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15633 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
15634 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15635 .doit = nl80211_get_protocol_features,
15638 .cmd = NL80211_CMD_UPDATE_FT_IES,
15639 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15640 .doit = nl80211_update_ft_ies,
15641 .flags = GENL_UNS_ADMIN_PERM,
15642 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15645 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
15646 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15647 .doit = nl80211_crit_protocol_start,
15648 .flags = GENL_UNS_ADMIN_PERM,
15649 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15652 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
15653 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15654 .doit = nl80211_crit_protocol_stop,
15655 .flags = GENL_UNS_ADMIN_PERM,
15656 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15659 .cmd = NL80211_CMD_GET_COALESCE,
15660 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15661 .doit = nl80211_get_coalesce,
15662 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15665 .cmd = NL80211_CMD_SET_COALESCE,
15666 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15667 .doit = nl80211_set_coalesce,
15668 .flags = GENL_UNS_ADMIN_PERM,
15669 .internal_flags = NL80211_FLAG_NEED_WIPHY,
15672 .cmd = NL80211_CMD_CHANNEL_SWITCH,
15673 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15674 .doit = nl80211_channel_switch,
15675 .flags = GENL_UNS_ADMIN_PERM,
15676 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15679 .cmd = NL80211_CMD_VENDOR,
15680 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15681 .doit = nl80211_vendor_cmd,
15682 .dumpit = nl80211_vendor_cmd_dump,
15683 .flags = GENL_UNS_ADMIN_PERM,
15684 .internal_flags = NL80211_FLAG_NEED_WIPHY |
15686 NL80211_FLAG_CLEAR_SKB,
15689 .cmd = NL80211_CMD_SET_QOS_MAP,
15690 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15691 .doit = nl80211_set_qos_map,
15692 .flags = GENL_UNS_ADMIN_PERM,
15693 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15696 .cmd = NL80211_CMD_ADD_TX_TS,
15697 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15698 .doit = nl80211_add_tx_ts,
15699 .flags = GENL_UNS_ADMIN_PERM,
15700 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15703 .cmd = NL80211_CMD_DEL_TX_TS,
15704 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15705 .doit = nl80211_del_tx_ts,
15706 .flags = GENL_UNS_ADMIN_PERM,
15707 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15710 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
15711 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15712 .doit = nl80211_tdls_channel_switch,
15713 .flags = GENL_UNS_ADMIN_PERM,
15714 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15717 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
15718 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15719 .doit = nl80211_tdls_cancel_channel_switch,
15720 .flags = GENL_UNS_ADMIN_PERM,
15721 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15724 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
15725 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15726 .doit = nl80211_set_multicast_to_unicast,
15727 .flags = GENL_UNS_ADMIN_PERM,
15728 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15731 .cmd = NL80211_CMD_SET_PMK,
15732 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15733 .doit = nl80211_set_pmk,
15734 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15736 NL80211_FLAG_CLEAR_SKB,
15739 .cmd = NL80211_CMD_DEL_PMK,
15740 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15741 .doit = nl80211_del_pmk,
15742 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15745 .cmd = NL80211_CMD_EXTERNAL_AUTH,
15746 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15747 .doit = nl80211_external_auth,
15748 .flags = GENL_ADMIN_PERM,
15749 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15752 .cmd = NL80211_CMD_CONTROL_PORT_FRAME,
15753 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15754 .doit = nl80211_tx_control_port,
15755 .flags = GENL_UNS_ADMIN_PERM,
15756 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15759 .cmd = NL80211_CMD_GET_FTM_RESPONDER_STATS,
15760 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15761 .doit = nl80211_get_ftm_responder_stats,
15762 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15765 .cmd = NL80211_CMD_PEER_MEASUREMENT_START,
15766 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15767 .doit = nl80211_pmsr_start,
15768 .flags = GENL_UNS_ADMIN_PERM,
15769 .internal_flags = NL80211_FLAG_NEED_WDEV_UP,
15772 .cmd = NL80211_CMD_NOTIFY_RADAR,
15773 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15774 .doit = nl80211_notify_radar_detection,
15775 .flags = GENL_UNS_ADMIN_PERM,
15776 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15779 .cmd = NL80211_CMD_UPDATE_OWE_INFO,
15780 .doit = nl80211_update_owe_info,
15781 .flags = GENL_ADMIN_PERM,
15782 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15785 .cmd = NL80211_CMD_PROBE_MESH_LINK,
15786 .doit = nl80211_probe_mesh_link,
15787 .flags = GENL_UNS_ADMIN_PERM,
15788 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP,
15791 .cmd = NL80211_CMD_SET_TID_CONFIG,
15792 .doit = nl80211_set_tid_config,
15793 .flags = GENL_UNS_ADMIN_PERM,
15794 .internal_flags = NL80211_FLAG_NEED_NETDEV,
15797 .cmd = NL80211_CMD_SET_SAR_SPECS,
15798 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15799 .doit = nl80211_set_sar_specs,
15800 .flags = GENL_UNS_ADMIN_PERM,
15801 .internal_flags = NL80211_FLAG_NEED_WIPHY |
15802 NL80211_FLAG_NEED_RTNL,
15806 static struct genl_family nl80211_fam __ro_after_init = {
15807 .name = NL80211_GENL_NAME, /* have users key off the name instead */
15808 .hdrsize = 0, /* no private header */
15809 .version = 1, /* no particular meaning now */
15810 .maxattr = NL80211_ATTR_MAX,
15811 .policy = nl80211_policy,
15813 .pre_doit = nl80211_pre_doit,
15814 .post_doit = nl80211_post_doit,
15815 .module = THIS_MODULE,
15816 .ops = nl80211_ops,
15817 .n_ops = ARRAY_SIZE(nl80211_ops),
15818 .small_ops = nl80211_small_ops,
15819 .n_small_ops = ARRAY_SIZE(nl80211_small_ops),
15820 .mcgrps = nl80211_mcgrps,
15821 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
15822 .parallel_ops = true,
15825 /* notification functions */
15827 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
15828 enum nl80211_commands cmd)
15830 struct sk_buff *msg;
15831 struct nl80211_dump_wiphy_state state = {};
15833 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
15834 cmd != NL80211_CMD_DEL_WIPHY);
15836 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15840 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
15845 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15846 NL80211_MCGRP_CONFIG, GFP_KERNEL);
15849 void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
15850 struct wireless_dev *wdev,
15851 enum nl80211_commands cmd)
15853 struct sk_buff *msg;
15855 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15859 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, cmd) < 0) {
15864 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15865 NL80211_MCGRP_CONFIG, GFP_KERNEL);
15868 static int nl80211_add_scan_req(struct sk_buff *msg,
15869 struct cfg80211_registered_device *rdev)
15871 struct cfg80211_scan_request *req = rdev->scan_req;
15872 struct nlattr *nest;
15874 struct cfg80211_scan_info *info;
15879 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_SSIDS);
15881 goto nla_put_failure;
15882 for (i = 0; i < req->n_ssids; i++) {
15883 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
15884 goto nla_put_failure;
15886 nla_nest_end(msg, nest);
15888 if (req->flags & NL80211_SCAN_FLAG_FREQ_KHZ) {
15889 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQ_KHZ);
15891 goto nla_put_failure;
15892 for (i = 0; i < req->n_channels; i++) {
15893 if (nla_put_u32(msg, i,
15894 ieee80211_channel_to_khz(req->channels[i])))
15895 goto nla_put_failure;
15897 nla_nest_end(msg, nest);
15899 nest = nla_nest_start_noflag(msg,
15900 NL80211_ATTR_SCAN_FREQUENCIES);
15902 goto nla_put_failure;
15903 for (i = 0; i < req->n_channels; i++) {
15904 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
15905 goto nla_put_failure;
15907 nla_nest_end(msg, nest);
15911 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
15912 goto nla_put_failure;
15915 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
15916 goto nla_put_failure;
15918 info = rdev->int_scan_req ? &rdev->int_scan_req->info :
15919 &rdev->scan_req->info;
15920 if (info->scan_start_tsf &&
15921 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
15922 info->scan_start_tsf, NL80211_BSS_PAD) ||
15923 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
15925 goto nla_put_failure;
15932 static int nl80211_prep_scan_msg(struct sk_buff *msg,
15933 struct cfg80211_registered_device *rdev,
15934 struct wireless_dev *wdev,
15935 u32 portid, u32 seq, int flags,
15940 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
15944 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15945 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15946 wdev->netdev->ifindex)) ||
15947 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15949 goto nla_put_failure;
15951 /* ignore errors and send incomplete event anyway */
15952 nl80211_add_scan_req(msg, rdev);
15954 genlmsg_end(msg, hdr);
15958 genlmsg_cancel(msg, hdr);
15963 nl80211_prep_sched_scan_msg(struct sk_buff *msg,
15964 struct cfg80211_sched_scan_request *req, u32 cmd)
15968 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15972 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
15973 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
15974 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
15975 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
15977 goto nla_put_failure;
15979 genlmsg_end(msg, hdr);
15983 genlmsg_cancel(msg, hdr);
15987 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
15988 struct wireless_dev *wdev)
15990 struct sk_buff *msg;
15992 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15996 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
15997 NL80211_CMD_TRIGGER_SCAN) < 0) {
16002 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16003 NL80211_MCGRP_SCAN, GFP_KERNEL);
16006 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
16007 struct wireless_dev *wdev, bool aborted)
16009 struct sk_buff *msg;
16011 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
16015 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
16016 aborted ? NL80211_CMD_SCAN_ABORTED :
16017 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
16025 /* send message created by nl80211_build_scan_msg() */
16026 void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
16027 struct sk_buff *msg)
16032 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16033 NL80211_MCGRP_SCAN, GFP_KERNEL);
16036 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
16038 struct sk_buff *msg;
16040 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
16044 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
16049 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
16050 NL80211_MCGRP_SCAN, GFP_KERNEL);
16053 static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
16054 struct regulatory_request *request)
16056 /* Userspace can always count this one always being set */
16057 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
16058 goto nla_put_failure;
16060 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
16061 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
16062 NL80211_REGDOM_TYPE_WORLD))
16063 goto nla_put_failure;
16064 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
16065 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
16066 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
16067 goto nla_put_failure;
16068 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
16069 request->intersect) {
16070 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
16071 NL80211_REGDOM_TYPE_INTERSECTION))
16072 goto nla_put_failure;
16074 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
16075 NL80211_REGDOM_TYPE_COUNTRY) ||
16076 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
16078 goto nla_put_failure;
16081 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
16082 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
16085 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
16086 goto nla_put_failure;
16089 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
16090 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
16091 goto nla_put_failure;
16101 * This can happen on global regulatory changes or device specific settings
16102 * based on custom regulatory domains.
16104 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
16105 struct regulatory_request *request)
16107 struct sk_buff *msg;
16110 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
16114 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
16116 goto nla_put_failure;
16118 if (!nl80211_reg_change_event_fill(msg, request))
16119 goto nla_put_failure;
16121 genlmsg_end(msg, hdr);
16124 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
16125 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
16134 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
16135 struct net_device *netdev,
16136 const u8 *buf, size_t len,
16137 enum nl80211_commands cmd, gfp_t gfp,
16138 int uapsd_queues, const u8 *req_ies,
16139 size_t req_ies_len, bool reconnect)
16141 struct sk_buff *msg;
16144 msg = nlmsg_new(100 + len + req_ies_len, gfp);
16148 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
16154 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16155 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16156 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
16158 nla_put(msg, NL80211_ATTR_REQ_IE, req_ies_len, req_ies)))
16159 goto nla_put_failure;
16161 if (reconnect && nla_put_flag(msg, NL80211_ATTR_RECONNECT_REQUESTED))
16162 goto nla_put_failure;
16164 if (uapsd_queues >= 0) {
16165 struct nlattr *nla_wmm =
16166 nla_nest_start_noflag(msg, NL80211_ATTR_STA_WME);
16168 goto nla_put_failure;
16170 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
16172 goto nla_put_failure;
16174 nla_nest_end(msg, nla_wmm);
16177 genlmsg_end(msg, hdr);
16179 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16180 NL80211_MCGRP_MLME, gfp);
16187 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
16188 struct net_device *netdev, const u8 *buf,
16189 size_t len, gfp_t gfp)
16191 nl80211_send_mlme_event(rdev, netdev, buf, len,
16192 NL80211_CMD_AUTHENTICATE, gfp, -1, NULL, 0,
16196 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
16197 struct net_device *netdev, const u8 *buf,
16198 size_t len, gfp_t gfp, int uapsd_queues,
16199 const u8 *req_ies, size_t req_ies_len)
16201 nl80211_send_mlme_event(rdev, netdev, buf, len,
16202 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues,
16203 req_ies, req_ies_len, false);
16206 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
16207 struct net_device *netdev, const u8 *buf,
16208 size_t len, bool reconnect, gfp_t gfp)
16210 nl80211_send_mlme_event(rdev, netdev, buf, len,
16211 NL80211_CMD_DEAUTHENTICATE, gfp, -1, NULL, 0,
16215 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
16216 struct net_device *netdev, const u8 *buf,
16217 size_t len, bool reconnect, gfp_t gfp)
16219 nl80211_send_mlme_event(rdev, netdev, buf, len,
16220 NL80211_CMD_DISASSOCIATE, gfp, -1, NULL, 0,
16224 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
16227 struct wireless_dev *wdev = dev->ieee80211_ptr;
16228 struct wiphy *wiphy = wdev->wiphy;
16229 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16230 const struct ieee80211_mgmt *mgmt = (void *)buf;
16233 if (WARN_ON(len < 2))
16236 if (ieee80211_is_deauth(mgmt->frame_control)) {
16237 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
16238 } else if (ieee80211_is_disassoc(mgmt->frame_control)) {
16239 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
16240 } else if (ieee80211_is_beacon(mgmt->frame_control)) {
16241 if (wdev->unprot_beacon_reported &&
16242 elapsed_jiffies_msecs(wdev->unprot_beacon_reported) < 10000)
16244 cmd = NL80211_CMD_UNPROT_BEACON;
16245 wdev->unprot_beacon_reported = jiffies;
16250 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
16251 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1,
16254 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
16256 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
16257 struct net_device *netdev, int cmd,
16258 const u8 *addr, gfp_t gfp)
16260 struct sk_buff *msg;
16263 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16267 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
16273 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16274 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16275 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
16276 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
16277 goto nla_put_failure;
16279 genlmsg_end(msg, hdr);
16281 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16282 NL80211_MCGRP_MLME, gfp);
16289 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
16290 struct net_device *netdev, const u8 *addr,
16293 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
16297 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
16298 struct net_device *netdev, const u8 *addr,
16301 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
16305 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
16306 struct net_device *netdev,
16307 struct cfg80211_connect_resp_params *cr,
16310 struct sk_buff *msg;
16313 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
16314 cr->fils.kek_len + cr->fils.pmk_len +
16315 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
16319 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
16325 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16326 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16328 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
16329 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
16330 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
16333 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
16334 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
16335 cr->timeout_reason))) ||
16337 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
16339 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
16341 (cr->fils.update_erp_next_seq_num &&
16342 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
16343 cr->fils.erp_next_seq_num)) ||
16344 (cr->status == WLAN_STATUS_SUCCESS &&
16346 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len,
16349 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) ||
16351 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid)))))
16352 goto nla_put_failure;
16354 genlmsg_end(msg, hdr);
16356 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16357 NL80211_MCGRP_MLME, gfp);
16364 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
16365 struct net_device *netdev,
16366 struct cfg80211_roam_info *info, gfp_t gfp)
16368 struct sk_buff *msg;
16370 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
16372 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len +
16373 info->fils.kek_len + info->fils.pmk_len +
16374 (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
16378 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
16384 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16385 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16386 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
16388 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
16391 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
16393 (info->fils.update_erp_next_seq_num &&
16394 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
16395 info->fils.erp_next_seq_num)) ||
16397 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len,
16398 info->fils.kek)) ||
16400 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) ||
16401 (info->fils.pmkid &&
16402 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid)))
16403 goto nla_put_failure;
16405 genlmsg_end(msg, hdr);
16407 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16408 NL80211_MCGRP_MLME, gfp);
16415 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
16416 struct net_device *netdev, const u8 *bssid)
16418 struct sk_buff *msg;
16421 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
16425 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED);
16431 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16432 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16433 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
16434 goto nla_put_failure;
16436 genlmsg_end(msg, hdr);
16438 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16439 NL80211_MCGRP_MLME, GFP_KERNEL);
16446 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
16447 struct net_device *netdev, u16 reason,
16448 const u8 *ie, size_t ie_len, bool from_ap)
16450 struct sk_buff *msg;
16453 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
16457 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
16463 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16464 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16466 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
16468 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
16469 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
16470 goto nla_put_failure;
16472 genlmsg_end(msg, hdr);
16474 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16475 NL80211_MCGRP_MLME, GFP_KERNEL);
16482 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
16483 struct net_device *netdev, const u8 *bssid,
16486 struct sk_buff *msg;
16489 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16493 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
16499 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16500 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16501 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
16502 goto nla_put_failure;
16504 genlmsg_end(msg, hdr);
16506 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16507 NL80211_MCGRP_MLME, gfp);
16514 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
16515 const u8 *ie, u8 ie_len,
16516 int sig_dbm, gfp_t gfp)
16518 struct wireless_dev *wdev = dev->ieee80211_ptr;
16519 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16520 struct sk_buff *msg;
16523 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
16526 trace_cfg80211_notify_new_peer_candidate(dev, addr);
16528 msg = nlmsg_new(100 + ie_len, gfp);
16532 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
16538 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16539 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16540 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
16542 nla_put(msg, NL80211_ATTR_IE, ie_len, ie)) ||
16544 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)))
16545 goto nla_put_failure;
16547 genlmsg_end(msg, hdr);
16549 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16550 NL80211_MCGRP_MLME, gfp);
16556 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
16558 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
16559 struct net_device *netdev, const u8 *addr,
16560 enum nl80211_key_type key_type, int key_id,
16561 const u8 *tsc, gfp_t gfp)
16563 struct sk_buff *msg;
16566 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16570 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
16576 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16577 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16578 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
16579 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
16581 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
16582 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
16583 goto nla_put_failure;
16585 genlmsg_end(msg, hdr);
16587 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16588 NL80211_MCGRP_MLME, gfp);
16595 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
16596 struct ieee80211_channel *channel_before,
16597 struct ieee80211_channel *channel_after)
16599 struct sk_buff *msg;
16601 struct nlattr *nl_freq;
16603 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
16607 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
16614 * Since we are applying the beacon hint to a wiphy we know its
16615 * wiphy_idx is valid
16617 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
16618 goto nla_put_failure;
16621 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_BEFORE);
16623 goto nla_put_failure;
16625 if (nl80211_msg_put_channel(msg, wiphy, channel_before, false))
16626 goto nla_put_failure;
16627 nla_nest_end(msg, nl_freq);
16630 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_AFTER);
16632 goto nla_put_failure;
16634 if (nl80211_msg_put_channel(msg, wiphy, channel_after, false))
16635 goto nla_put_failure;
16636 nla_nest_end(msg, nl_freq);
16638 genlmsg_end(msg, hdr);
16641 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
16642 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
16651 static void nl80211_send_remain_on_chan_event(
16652 int cmd, struct cfg80211_registered_device *rdev,
16653 struct wireless_dev *wdev, u64 cookie,
16654 struct ieee80211_channel *chan,
16655 unsigned int duration, gfp_t gfp)
16657 struct sk_buff *msg;
16660 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16664 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
16670 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16671 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16672 wdev->netdev->ifindex)) ||
16673 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16674 NL80211_ATTR_PAD) ||
16675 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
16676 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
16677 NL80211_CHAN_NO_HT) ||
16678 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
16680 goto nla_put_failure;
16682 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
16683 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
16684 goto nla_put_failure;
16686 genlmsg_end(msg, hdr);
16688 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16689 NL80211_MCGRP_MLME, gfp);
16696 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
16697 struct ieee80211_channel *chan,
16698 unsigned int duration, gfp_t gfp)
16700 struct wiphy *wiphy = wdev->wiphy;
16701 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16703 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
16704 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
16705 rdev, wdev, cookie, chan,
16708 EXPORT_SYMBOL(cfg80211_ready_on_channel);
16710 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
16711 struct ieee80211_channel *chan,
16714 struct wiphy *wiphy = wdev->wiphy;
16715 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16717 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
16718 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
16719 rdev, wdev, cookie, chan, 0, gfp);
16721 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
16723 void cfg80211_tx_mgmt_expired(struct wireless_dev *wdev, u64 cookie,
16724 struct ieee80211_channel *chan,
16727 struct wiphy *wiphy = wdev->wiphy;
16728 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16730 trace_cfg80211_tx_mgmt_expired(wdev, cookie, chan);
16731 nl80211_send_remain_on_chan_event(NL80211_CMD_FRAME_WAIT_CANCEL,
16732 rdev, wdev, cookie, chan, 0, gfp);
16734 EXPORT_SYMBOL(cfg80211_tx_mgmt_expired);
16736 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
16737 struct station_info *sinfo, gfp_t gfp)
16739 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
16740 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16741 struct sk_buff *msg;
16743 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
16745 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16749 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
16750 rdev, dev, mac_addr, sinfo) < 0) {
16755 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16756 NL80211_MCGRP_MLME, gfp);
16758 EXPORT_SYMBOL(cfg80211_new_sta);
16760 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
16761 struct station_info *sinfo, gfp_t gfp)
16763 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
16764 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16765 struct sk_buff *msg;
16766 struct station_info empty_sinfo = {};
16769 sinfo = &empty_sinfo;
16771 trace_cfg80211_del_sta(dev, mac_addr);
16773 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16775 cfg80211_sinfo_release_content(sinfo);
16779 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
16780 rdev, dev, mac_addr, sinfo) < 0) {
16785 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16786 NL80211_MCGRP_MLME, gfp);
16788 EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
16790 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
16791 enum nl80211_connect_failed_reason reason,
16794 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
16795 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16796 struct sk_buff *msg;
16799 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
16803 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
16809 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16810 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
16811 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
16812 goto nla_put_failure;
16814 genlmsg_end(msg, hdr);
16816 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16817 NL80211_MCGRP_MLME, gfp);
16823 EXPORT_SYMBOL(cfg80211_conn_failed);
16825 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
16826 const u8 *addr, gfp_t gfp)
16828 struct wireless_dev *wdev = dev->ieee80211_ptr;
16829 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16830 struct sk_buff *msg;
16832 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
16837 msg = nlmsg_new(100, gfp);
16841 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
16847 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16848 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16849 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
16850 goto nla_put_failure;
16852 genlmsg_end(msg, hdr);
16853 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16861 bool cfg80211_rx_spurious_frame(struct net_device *dev,
16862 const u8 *addr, gfp_t gfp)
16864 struct wireless_dev *wdev = dev->ieee80211_ptr;
16867 trace_cfg80211_rx_spurious_frame(dev, addr);
16869 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
16870 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
16871 trace_cfg80211_return_bool(false);
16874 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
16876 trace_cfg80211_return_bool(ret);
16879 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
16881 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
16882 const u8 *addr, gfp_t gfp)
16884 struct wireless_dev *wdev = dev->ieee80211_ptr;
16887 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
16889 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
16890 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
16891 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
16892 trace_cfg80211_return_bool(false);
16895 ret = __nl80211_unexpected_frame(dev,
16896 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
16898 trace_cfg80211_return_bool(ret);
16901 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
16903 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
16904 struct wireless_dev *wdev, u32 nlportid,
16905 int freq, int sig_dbm,
16906 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
16908 struct net_device *netdev = wdev->netdev;
16909 struct sk_buff *msg;
16912 msg = nlmsg_new(100 + len, gfp);
16916 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
16922 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16923 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16924 netdev->ifindex)) ||
16925 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16926 NL80211_ATTR_PAD) ||
16927 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, KHZ_TO_MHZ(freq)) ||
16928 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET, freq % 1000) ||
16930 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
16931 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
16933 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
16934 goto nla_put_failure;
16936 genlmsg_end(msg, hdr);
16938 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16945 static void nl80211_frame_tx_status(struct wireless_dev *wdev, u64 cookie,
16946 const u8 *buf, size_t len, bool ack,
16947 gfp_t gfp, enum nl80211_commands command)
16949 struct wiphy *wiphy = wdev->wiphy;
16950 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16951 struct net_device *netdev = wdev->netdev;
16952 struct sk_buff *msg;
16955 if (command == NL80211_CMD_FRAME_TX_STATUS)
16956 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
16958 trace_cfg80211_control_port_tx_status(wdev, cookie, ack);
16960 msg = nlmsg_new(100 + len, gfp);
16964 hdr = nl80211hdr_put(msg, 0, 0, 0, command);
16970 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16971 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16972 netdev->ifindex)) ||
16973 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16974 NL80211_ATTR_PAD) ||
16975 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
16976 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
16977 NL80211_ATTR_PAD) ||
16978 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
16979 goto nla_put_failure;
16981 genlmsg_end(msg, hdr);
16983 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16984 NL80211_MCGRP_MLME, gfp);
16991 void cfg80211_control_port_tx_status(struct wireless_dev *wdev, u64 cookie,
16992 const u8 *buf, size_t len, bool ack,
16995 nl80211_frame_tx_status(wdev, cookie, buf, len, ack, gfp,
16996 NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS);
16998 EXPORT_SYMBOL(cfg80211_control_port_tx_status);
17000 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
17001 const u8 *buf, size_t len, bool ack, gfp_t gfp)
17003 nl80211_frame_tx_status(wdev, cookie, buf, len, ack, gfp,
17004 NL80211_CMD_FRAME_TX_STATUS);
17006 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
17008 static int __nl80211_rx_control_port(struct net_device *dev,
17009 struct sk_buff *skb,
17010 bool unencrypted, gfp_t gfp)
17012 struct wireless_dev *wdev = dev->ieee80211_ptr;
17013 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17014 struct ethhdr *ehdr = eth_hdr(skb);
17015 const u8 *addr = ehdr->h_source;
17016 u16 proto = be16_to_cpu(skb->protocol);
17017 struct sk_buff *msg;
17019 struct nlattr *frame;
17021 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid);
17026 msg = nlmsg_new(100 + skb->len, gfp);
17030 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME);
17036 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17037 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
17038 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17039 NL80211_ATTR_PAD) ||
17040 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
17041 nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) ||
17042 (unencrypted && nla_put_flag(msg,
17043 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
17044 goto nla_put_failure;
17046 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len);
17048 goto nla_put_failure;
17050 skb_copy_bits(skb, 0, nla_data(frame), skb->len);
17051 genlmsg_end(msg, hdr);
17053 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
17060 bool cfg80211_rx_control_port(struct net_device *dev,
17061 struct sk_buff *skb, bool unencrypted)
17065 trace_cfg80211_rx_control_port(dev, skb, unencrypted);
17066 ret = __nl80211_rx_control_port(dev, skb, unencrypted, GFP_ATOMIC);
17067 trace_cfg80211_return_bool(ret == 0);
17070 EXPORT_SYMBOL(cfg80211_rx_control_port);
17072 static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
17073 const char *mac, gfp_t gfp)
17075 struct wireless_dev *wdev = dev->ieee80211_ptr;
17076 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17077 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17083 cb = (void **)msg->cb;
17085 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
17091 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17092 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
17093 goto nla_put_failure;
17095 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
17096 goto nla_put_failure;
17098 cb[1] = nla_nest_start_noflag(msg, NL80211_ATTR_CQM);
17100 goto nla_put_failure;
17110 static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
17112 void **cb = (void **)msg->cb;
17113 struct cfg80211_registered_device *rdev = cb[2];
17115 nla_nest_end(msg, cb[1]);
17116 genlmsg_end(msg, cb[0]);
17118 memset(msg->cb, 0, sizeof(msg->cb));
17120 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17121 NL80211_MCGRP_MLME, gfp);
17124 void cfg80211_cqm_rssi_notify(struct net_device *dev,
17125 enum nl80211_cqm_rssi_threshold_event rssi_event,
17126 s32 rssi_level, gfp_t gfp)
17128 struct sk_buff *msg;
17129 struct wireless_dev *wdev = dev->ieee80211_ptr;
17130 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17132 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
17134 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
17135 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
17138 if (wdev->cqm_config) {
17139 wdev->cqm_config->last_rssi_event_value = rssi_level;
17141 cfg80211_cqm_rssi_update(rdev, dev);
17143 if (rssi_level == 0)
17144 rssi_level = wdev->cqm_config->last_rssi_event_value;
17147 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
17151 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
17153 goto nla_put_failure;
17155 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
17157 goto nla_put_failure;
17159 cfg80211_send_cqm(msg, gfp);
17166 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
17168 void cfg80211_cqm_txe_notify(struct net_device *dev,
17169 const u8 *peer, u32 num_packets,
17170 u32 rate, u32 intvl, gfp_t gfp)
17172 struct sk_buff *msg;
17174 msg = cfg80211_prepare_cqm(dev, peer, gfp);
17178 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
17179 goto nla_put_failure;
17181 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
17182 goto nla_put_failure;
17184 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
17185 goto nla_put_failure;
17187 cfg80211_send_cqm(msg, gfp);
17193 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
17195 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
17196 const u8 *peer, u32 num_packets, gfp_t gfp)
17198 struct sk_buff *msg;
17200 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
17202 msg = cfg80211_prepare_cqm(dev, peer, gfp);
17206 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
17207 goto nla_put_failure;
17209 cfg80211_send_cqm(msg, gfp);
17215 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
17217 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
17219 struct sk_buff *msg;
17221 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
17225 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
17226 goto nla_put_failure;
17228 cfg80211_send_cqm(msg, gfp);
17234 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
17236 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
17237 struct net_device *netdev, const u8 *bssid,
17238 const u8 *replay_ctr, gfp_t gfp)
17240 struct sk_buff *msg;
17241 struct nlattr *rekey_attr;
17244 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17248 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
17254 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17255 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17256 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
17257 goto nla_put_failure;
17259 rekey_attr = nla_nest_start_noflag(msg, NL80211_ATTR_REKEY_DATA);
17261 goto nla_put_failure;
17263 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
17264 NL80211_REPLAY_CTR_LEN, replay_ctr))
17265 goto nla_put_failure;
17267 nla_nest_end(msg, rekey_attr);
17269 genlmsg_end(msg, hdr);
17271 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17272 NL80211_MCGRP_MLME, gfp);
17279 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
17280 const u8 *replay_ctr, gfp_t gfp)
17282 struct wireless_dev *wdev = dev->ieee80211_ptr;
17283 struct wiphy *wiphy = wdev->wiphy;
17284 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17286 trace_cfg80211_gtk_rekey_notify(dev, bssid);
17287 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
17289 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
17292 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
17293 struct net_device *netdev, int index,
17294 const u8 *bssid, bool preauth, gfp_t gfp)
17296 struct sk_buff *msg;
17297 struct nlattr *attr;
17300 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17304 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
17310 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17311 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
17312 goto nla_put_failure;
17314 attr = nla_nest_start_noflag(msg, NL80211_ATTR_PMKSA_CANDIDATE);
17316 goto nla_put_failure;
17318 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
17319 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
17321 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
17322 goto nla_put_failure;
17324 nla_nest_end(msg, attr);
17326 genlmsg_end(msg, hdr);
17328 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17329 NL80211_MCGRP_MLME, gfp);
17336 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
17337 const u8 *bssid, bool preauth, gfp_t gfp)
17339 struct wireless_dev *wdev = dev->ieee80211_ptr;
17340 struct wiphy *wiphy = wdev->wiphy;
17341 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17343 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
17344 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
17346 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
17348 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
17349 struct net_device *netdev,
17350 struct cfg80211_chan_def *chandef,
17352 enum nl80211_commands notif,
17353 u8 count, bool quiet)
17355 struct sk_buff *msg;
17358 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17362 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
17368 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
17369 goto nla_put_failure;
17371 if (nl80211_send_chandef(msg, chandef))
17372 goto nla_put_failure;
17374 if (notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) {
17375 if (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count))
17376 goto nla_put_failure;
17378 nla_put_flag(msg, NL80211_ATTR_CH_SWITCH_BLOCK_TX))
17379 goto nla_put_failure;
17382 genlmsg_end(msg, hdr);
17384 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17385 NL80211_MCGRP_MLME, gfp);
17392 void cfg80211_ch_switch_notify(struct net_device *dev,
17393 struct cfg80211_chan_def *chandef)
17395 struct wireless_dev *wdev = dev->ieee80211_ptr;
17396 struct wiphy *wiphy = wdev->wiphy;
17397 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17399 ASSERT_WDEV_LOCK(wdev);
17401 trace_cfg80211_ch_switch_notify(dev, chandef);
17403 wdev->chandef = *chandef;
17404 wdev->preset_chandef = *chandef;
17406 if (wdev->iftype == NL80211_IFTYPE_STATION &&
17407 !WARN_ON(!wdev->current_bss))
17408 cfg80211_update_assoc_bss_entry(wdev, chandef->chan);
17410 cfg80211_sched_dfs_chan_update(rdev);
17412 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
17413 NL80211_CMD_CH_SWITCH_NOTIFY, 0, false);
17415 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
17417 void cfg80211_ch_switch_started_notify(struct net_device *dev,
17418 struct cfg80211_chan_def *chandef,
17419 u8 count, bool quiet)
17421 struct wireless_dev *wdev = dev->ieee80211_ptr;
17422 struct wiphy *wiphy = wdev->wiphy;
17423 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17425 trace_cfg80211_ch_switch_started_notify(dev, chandef);
17427 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
17428 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY,
17431 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
17434 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
17435 const struct cfg80211_chan_def *chandef,
17436 enum nl80211_radar_event event,
17437 struct net_device *netdev, gfp_t gfp)
17439 struct sk_buff *msg;
17442 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17446 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
17452 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
17453 goto nla_put_failure;
17455 /* NOP and radar events don't need a netdev parameter */
17457 struct wireless_dev *wdev = netdev->ieee80211_ptr;
17459 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17460 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17462 goto nla_put_failure;
17465 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
17466 goto nla_put_failure;
17468 if (nl80211_send_chandef(msg, chandef))
17469 goto nla_put_failure;
17471 genlmsg_end(msg, hdr);
17473 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17474 NL80211_MCGRP_MLME, gfp);
17481 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac,
17482 struct sta_opmode_info *sta_opmode,
17485 struct sk_buff *msg;
17486 struct wireless_dev *wdev = dev->ieee80211_ptr;
17487 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17493 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17497 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED);
17503 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
17504 goto nla_put_failure;
17506 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
17507 goto nla_put_failure;
17509 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
17510 goto nla_put_failure;
17512 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) &&
17513 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode))
17514 goto nla_put_failure;
17516 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) &&
17517 nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw))
17518 goto nla_put_failure;
17520 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) &&
17521 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss))
17522 goto nla_put_failure;
17524 genlmsg_end(msg, hdr);
17526 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17527 NL80211_MCGRP_MLME, gfp);
17534 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify);
17536 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
17537 u64 cookie, bool acked, s32 ack_signal,
17538 bool is_valid_ack_signal, gfp_t gfp)
17540 struct wireless_dev *wdev = dev->ieee80211_ptr;
17541 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17542 struct sk_buff *msg;
17545 trace_cfg80211_probe_status(dev, addr, cookie, acked);
17547 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17552 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
17558 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17559 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
17560 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
17561 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
17562 NL80211_ATTR_PAD) ||
17563 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
17564 (is_valid_ack_signal && nla_put_s32(msg, NL80211_ATTR_ACK_SIGNAL,
17566 goto nla_put_failure;
17568 genlmsg_end(msg, hdr);
17570 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17571 NL80211_MCGRP_MLME, gfp);
17577 EXPORT_SYMBOL(cfg80211_probe_status);
17579 void cfg80211_report_obss_beacon_khz(struct wiphy *wiphy, const u8 *frame,
17580 size_t len, int freq, int sig_dbm)
17582 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17583 struct sk_buff *msg;
17585 struct cfg80211_beacon_registration *reg;
17587 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
17589 spin_lock_bh(&rdev->beacon_registrations_lock);
17590 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
17591 msg = nlmsg_new(len + 100, GFP_ATOMIC);
17593 spin_unlock_bh(&rdev->beacon_registrations_lock);
17597 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
17599 goto nla_put_failure;
17601 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17603 (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
17604 KHZ_TO_MHZ(freq)) ||
17605 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET,
17608 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
17609 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
17610 goto nla_put_failure;
17612 genlmsg_end(msg, hdr);
17614 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
17616 spin_unlock_bh(&rdev->beacon_registrations_lock);
17620 spin_unlock_bh(&rdev->beacon_registrations_lock);
17623 EXPORT_SYMBOL(cfg80211_report_obss_beacon_khz);
17626 static int cfg80211_net_detect_results(struct sk_buff *msg,
17627 struct cfg80211_wowlan_wakeup *wakeup)
17629 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
17630 struct nlattr *nl_results, *nl_match, *nl_freqs;
17633 nl_results = nla_nest_start_noflag(msg,
17634 NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
17638 for (i = 0; i < nd->n_matches; i++) {
17639 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
17641 nl_match = nla_nest_start_noflag(msg, i);
17645 /* The SSID attribute is optional in nl80211, but for
17646 * simplicity reasons it's always present in the
17647 * cfg80211 structure. If a driver can't pass the
17648 * SSID, that needs to be changed. A zero length SSID
17649 * is still a valid SSID (wildcard), so it cannot be
17650 * used for this purpose.
17652 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
17653 match->ssid.ssid)) {
17654 nla_nest_cancel(msg, nl_match);
17658 if (match->n_channels) {
17659 nl_freqs = nla_nest_start_noflag(msg,
17660 NL80211_ATTR_SCAN_FREQUENCIES);
17662 nla_nest_cancel(msg, nl_match);
17666 for (j = 0; j < match->n_channels; j++) {
17667 if (nla_put_u32(msg, j, match->channels[j])) {
17668 nla_nest_cancel(msg, nl_freqs);
17669 nla_nest_cancel(msg, nl_match);
17674 nla_nest_end(msg, nl_freqs);
17677 nla_nest_end(msg, nl_match);
17681 nla_nest_end(msg, nl_results);
17685 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
17686 struct cfg80211_wowlan_wakeup *wakeup,
17689 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17690 struct sk_buff *msg;
17694 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
17697 size += wakeup->packet_present_len;
17699 msg = nlmsg_new(size, gfp);
17703 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
17707 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17708 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17712 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
17713 wdev->netdev->ifindex))
17717 struct nlattr *reasons;
17719 reasons = nla_nest_start_noflag(msg,
17720 NL80211_ATTR_WOWLAN_TRIGGERS);
17724 if (wakeup->disconnect &&
17725 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
17727 if (wakeup->magic_pkt &&
17728 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
17730 if (wakeup->gtk_rekey_failure &&
17731 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
17733 if (wakeup->eap_identity_req &&
17734 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
17736 if (wakeup->four_way_handshake &&
17737 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
17739 if (wakeup->rfkill_release &&
17740 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
17743 if (wakeup->pattern_idx >= 0 &&
17744 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
17745 wakeup->pattern_idx))
17748 if (wakeup->tcp_match &&
17749 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
17752 if (wakeup->tcp_connlost &&
17753 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
17756 if (wakeup->tcp_nomoretokens &&
17758 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
17761 if (wakeup->packet) {
17762 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
17763 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
17765 if (!wakeup->packet_80211) {
17767 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
17769 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
17772 if (wakeup->packet_len &&
17773 nla_put_u32(msg, len_attr, wakeup->packet_len))
17776 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
17781 if (wakeup->net_detect &&
17782 cfg80211_net_detect_results(msg, wakeup))
17785 nla_nest_end(msg, reasons);
17788 genlmsg_end(msg, hdr);
17790 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17791 NL80211_MCGRP_MLME, gfp);
17797 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
17800 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
17801 enum nl80211_tdls_operation oper,
17802 u16 reason_code, gfp_t gfp)
17804 struct wireless_dev *wdev = dev->ieee80211_ptr;
17805 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17806 struct sk_buff *msg;
17809 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
17812 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17816 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
17822 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17823 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
17824 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
17825 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
17826 (reason_code > 0 &&
17827 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
17828 goto nla_put_failure;
17830 genlmsg_end(msg, hdr);
17832 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17833 NL80211_MCGRP_MLME, gfp);
17839 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
17841 static int nl80211_netlink_notify(struct notifier_block * nb,
17842 unsigned long state,
17845 struct netlink_notify *notify = _notify;
17846 struct cfg80211_registered_device *rdev;
17847 struct wireless_dev *wdev;
17848 struct cfg80211_beacon_registration *reg, *tmp;
17850 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
17851 return NOTIFY_DONE;
17855 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
17856 struct cfg80211_sched_scan_request *sched_scan_req;
17858 list_for_each_entry_rcu(sched_scan_req,
17859 &rdev->sched_scan_req_list,
17861 if (sched_scan_req->owner_nlportid == notify->portid) {
17862 sched_scan_req->nl_owner_dead = true;
17863 schedule_work(&rdev->sched_scan_stop_wk);
17867 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
17868 cfg80211_mlme_unregister_socket(wdev, notify->portid);
17870 if (wdev->owner_nlportid == notify->portid) {
17871 wdev->nl_owner_dead = true;
17872 schedule_work(&rdev->destroy_work);
17873 } else if (wdev->conn_owner_nlportid == notify->portid) {
17874 schedule_work(&wdev->disconnect_wk);
17877 cfg80211_release_pmsr(wdev, notify->portid);
17880 spin_lock_bh(&rdev->beacon_registrations_lock);
17881 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
17883 if (reg->nlportid == notify->portid) {
17884 list_del(®->list);
17889 spin_unlock_bh(&rdev->beacon_registrations_lock);
17895 * It is possible that the user space process that is controlling the
17896 * indoor setting disappeared, so notify the regulatory core.
17898 regulatory_netlink_notify(notify->portid);
17902 static struct notifier_block nl80211_netlink_notifier = {
17903 .notifier_call = nl80211_netlink_notify,
17906 void cfg80211_ft_event(struct net_device *netdev,
17907 struct cfg80211_ft_event_params *ft_event)
17909 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
17910 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17911 struct sk_buff *msg;
17914 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
17916 if (!ft_event->target_ap)
17919 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len,
17924 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
17928 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17929 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17930 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
17933 if (ft_event->ies &&
17934 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
17936 if (ft_event->ric_ies &&
17937 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
17938 ft_event->ric_ies))
17941 genlmsg_end(msg, hdr);
17943 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17944 NL80211_MCGRP_MLME, GFP_KERNEL);
17949 EXPORT_SYMBOL(cfg80211_ft_event);
17951 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
17953 struct cfg80211_registered_device *rdev;
17954 struct sk_buff *msg;
17958 rdev = wiphy_to_rdev(wdev->wiphy);
17959 if (!rdev->crit_proto_nlportid)
17962 nlportid = rdev->crit_proto_nlportid;
17963 rdev->crit_proto_nlportid = 0;
17965 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17969 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
17971 goto nla_put_failure;
17973 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17974 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17976 goto nla_put_failure;
17978 genlmsg_end(msg, hdr);
17980 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
17986 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
17988 void nl80211_send_ap_stopped(struct wireless_dev *wdev)
17990 struct wiphy *wiphy = wdev->wiphy;
17991 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17992 struct sk_buff *msg;
17995 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17999 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
18003 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18004 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
18005 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
18009 genlmsg_end(msg, hdr);
18011 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
18012 NL80211_MCGRP_MLME, GFP_KERNEL);
18018 int cfg80211_external_auth_request(struct net_device *dev,
18019 struct cfg80211_external_auth_params *params,
18022 struct wireless_dev *wdev = dev->ieee80211_ptr;
18023 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
18024 struct sk_buff *msg;
18027 if (!wdev->conn_owner_nlportid)
18030 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18034 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH);
18036 goto nla_put_failure;
18038 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18039 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
18040 nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, params->key_mgmt_suite) ||
18041 nla_put_u32(msg, NL80211_ATTR_EXTERNAL_AUTH_ACTION,
18043 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) ||
18044 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len,
18045 params->ssid.ssid))
18046 goto nla_put_failure;
18048 genlmsg_end(msg, hdr);
18049 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
18050 wdev->conn_owner_nlportid);
18057 EXPORT_SYMBOL(cfg80211_external_auth_request);
18059 void cfg80211_update_owe_info_event(struct net_device *netdev,
18060 struct cfg80211_update_owe_info *owe_info,
18063 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
18064 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18065 struct sk_buff *msg;
18068 trace_cfg80211_update_owe_info_event(wiphy, netdev, owe_info);
18070 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18074 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_UPDATE_OWE_INFO);
18076 goto nla_put_failure;
18078 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18079 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18080 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, owe_info->peer))
18081 goto nla_put_failure;
18083 if (!owe_info->ie_len ||
18084 nla_put(msg, NL80211_ATTR_IE, owe_info->ie_len, owe_info->ie))
18085 goto nla_put_failure;
18087 genlmsg_end(msg, hdr);
18089 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18090 NL80211_MCGRP_MLME, gfp);
18094 genlmsg_cancel(msg, hdr);
18097 EXPORT_SYMBOL(cfg80211_update_owe_info_event);
18099 /* initialisation/exit functions */
18101 int __init nl80211_init(void)
18105 err = genl_register_family(&nl80211_fam);
18109 err = netlink_register_notifier(&nl80211_netlink_notifier);
18115 genl_unregister_family(&nl80211_fam);
18119 void nl80211_exit(void)
18121 netlink_unregister_notifier(&nl80211_netlink_notifier);
18122 genl_unregister_family(&nl80211_fam);