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-2023 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 static int validate_he_capa(const struct nlattr *attr,
289 struct netlink_ext_ack *extack)
291 if (!ieee80211_he_capa_size_ok(nla_data(attr), nla_len(attr)))
297 /* policy for the attributes */
298 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR];
300 static const struct nla_policy
301 nl80211_ftm_responder_policy[NL80211_FTM_RESP_ATTR_MAX + 1] = {
302 [NL80211_FTM_RESP_ATTR_ENABLED] = { .type = NLA_FLAG, },
303 [NL80211_FTM_RESP_ATTR_LCI] = { .type = NLA_BINARY,
305 [NL80211_FTM_RESP_ATTR_CIVICLOC] = { .type = NLA_BINARY,
309 static const struct nla_policy
310 nl80211_pmsr_ftm_req_attr_policy[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1] = {
311 [NL80211_PMSR_FTM_REQ_ATTR_ASAP] = { .type = NLA_FLAG },
312 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE] = { .type = NLA_U32 },
313 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP] =
314 NLA_POLICY_MAX(NLA_U8, 15),
315 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD] = { .type = NLA_U16 },
316 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION] =
317 NLA_POLICY_MAX(NLA_U8, 15),
318 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST] =
319 NLA_POLICY_MAX(NLA_U8, 31),
320 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES] = { .type = NLA_U8 },
321 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI] = { .type = NLA_FLAG },
322 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC] = { .type = NLA_FLAG },
323 [NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED] = { .type = NLA_FLAG },
324 [NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED] = { .type = NLA_FLAG },
325 [NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK] = { .type = NLA_FLAG },
328 static const struct nla_policy
329 nl80211_pmsr_req_data_policy[NL80211_PMSR_TYPE_MAX + 1] = {
330 [NL80211_PMSR_TYPE_FTM] =
331 NLA_POLICY_NESTED(nl80211_pmsr_ftm_req_attr_policy),
334 static const struct nla_policy
335 nl80211_pmsr_req_attr_policy[NL80211_PMSR_REQ_ATTR_MAX + 1] = {
336 [NL80211_PMSR_REQ_ATTR_DATA] =
337 NLA_POLICY_NESTED(nl80211_pmsr_req_data_policy),
338 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF] = { .type = NLA_FLAG },
341 static const struct nla_policy
342 nl80211_pmsr_peer_attr_policy[NL80211_PMSR_PEER_ATTR_MAX + 1] = {
343 [NL80211_PMSR_PEER_ATTR_ADDR] = NLA_POLICY_ETH_ADDR,
344 [NL80211_PMSR_PEER_ATTR_CHAN] = NLA_POLICY_NESTED(nl80211_policy),
345 [NL80211_PMSR_PEER_ATTR_REQ] =
346 NLA_POLICY_NESTED(nl80211_pmsr_req_attr_policy),
347 [NL80211_PMSR_PEER_ATTR_RESP] = { .type = NLA_REJECT },
350 static const struct nla_policy
351 nl80211_pmsr_attr_policy[NL80211_PMSR_ATTR_MAX + 1] = {
352 [NL80211_PMSR_ATTR_MAX_PEERS] = { .type = NLA_REJECT },
353 [NL80211_PMSR_ATTR_REPORT_AP_TSF] = { .type = NLA_REJECT },
354 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR] = { .type = NLA_REJECT },
355 [NL80211_PMSR_ATTR_TYPE_CAPA] = { .type = NLA_REJECT },
356 [NL80211_PMSR_ATTR_PEERS] =
357 NLA_POLICY_NESTED_ARRAY(nl80211_pmsr_peer_attr_policy),
360 static const struct nla_policy
361 he_obss_pd_policy[NL80211_HE_OBSS_PD_ATTR_MAX + 1] = {
362 [NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] =
363 NLA_POLICY_RANGE(NLA_U8, 1, 20),
364 [NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET] =
365 NLA_POLICY_RANGE(NLA_U8, 1, 20),
366 [NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET] =
367 NLA_POLICY_RANGE(NLA_U8, 1, 20),
368 [NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP] =
369 NLA_POLICY_EXACT_LEN(8),
370 [NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP] =
371 NLA_POLICY_EXACT_LEN(8),
372 [NL80211_HE_OBSS_PD_ATTR_SR_CTRL] = { .type = NLA_U8 },
375 static const struct nla_policy
376 he_bss_color_policy[NL80211_HE_BSS_COLOR_ATTR_MAX + 1] = {
377 [NL80211_HE_BSS_COLOR_ATTR_COLOR] = NLA_POLICY_RANGE(NLA_U8, 1, 63),
378 [NL80211_HE_BSS_COLOR_ATTR_DISABLED] = { .type = NLA_FLAG },
379 [NL80211_HE_BSS_COLOR_ATTR_PARTIAL] = { .type = NLA_FLAG },
382 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
383 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
384 .len = NL80211_MAX_SUPP_RATES },
385 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
386 .len = NL80211_MAX_SUPP_HT_RATES },
387 [NL80211_TXRATE_VHT] = NLA_POLICY_EXACT_LEN_WARN(sizeof(struct nl80211_txrate_vht)),
388 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
389 [NL80211_TXRATE_HE] = NLA_POLICY_EXACT_LEN(sizeof(struct nl80211_txrate_he)),
390 [NL80211_TXRATE_HE_GI] = NLA_POLICY_RANGE(NLA_U8,
391 NL80211_RATE_INFO_HE_GI_0_8,
392 NL80211_RATE_INFO_HE_GI_3_2),
393 [NL80211_TXRATE_HE_LTF] = NLA_POLICY_RANGE(NLA_U8,
394 NL80211_RATE_INFO_HE_1XLTF,
395 NL80211_RATE_INFO_HE_4XLTF),
398 static const struct nla_policy
399 nl80211_tid_config_attr_policy[NL80211_TID_CONFIG_ATTR_MAX + 1] = {
400 [NL80211_TID_CONFIG_ATTR_VIF_SUPP] = { .type = NLA_U64 },
401 [NL80211_TID_CONFIG_ATTR_PEER_SUPP] = { .type = NLA_U64 },
402 [NL80211_TID_CONFIG_ATTR_OVERRIDE] = { .type = NLA_FLAG },
403 [NL80211_TID_CONFIG_ATTR_TIDS] = NLA_POLICY_RANGE(NLA_U16, 1, 0xff),
404 [NL80211_TID_CONFIG_ATTR_NOACK] =
405 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
406 [NL80211_TID_CONFIG_ATTR_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
407 [NL80211_TID_CONFIG_ATTR_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
408 [NL80211_TID_CONFIG_ATTR_AMPDU_CTRL] =
409 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
410 [NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL] =
411 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
412 [NL80211_TID_CONFIG_ATTR_AMSDU_CTRL] =
413 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
414 [NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE] =
415 NLA_POLICY_MAX(NLA_U8, NL80211_TX_RATE_FIXED),
416 [NL80211_TID_CONFIG_ATTR_TX_RATE] =
417 NLA_POLICY_NESTED(nl80211_txattr_policy),
420 static const struct nla_policy
421 nl80211_fils_discovery_policy[NL80211_FILS_DISCOVERY_ATTR_MAX + 1] = {
422 [NL80211_FILS_DISCOVERY_ATTR_INT_MIN] = NLA_POLICY_MAX(NLA_U32, 10000),
423 [NL80211_FILS_DISCOVERY_ATTR_INT_MAX] = NLA_POLICY_MAX(NLA_U32, 10000),
424 [NL80211_FILS_DISCOVERY_ATTR_TMPL] =
425 NLA_POLICY_RANGE(NLA_BINARY,
426 NL80211_FILS_DISCOVERY_TMPL_MIN_LEN,
427 IEEE80211_MAX_DATA_LEN),
430 static const struct nla_policy
431 nl80211_unsol_bcast_probe_resp_policy[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX + 1] = {
432 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT] = NLA_POLICY_MAX(NLA_U32, 20),
433 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL] = { .type = NLA_BINARY,
434 .len = IEEE80211_MAX_DATA_LEN }
437 static const struct nla_policy
438 sar_specs_policy[NL80211_SAR_ATTR_SPECS_MAX + 1] = {
439 [NL80211_SAR_ATTR_SPECS_POWER] = { .type = NLA_S32 },
440 [NL80211_SAR_ATTR_SPECS_RANGE_INDEX] = {.type = NLA_U32 },
443 static const struct nla_policy
444 sar_policy[NL80211_SAR_ATTR_MAX + 1] = {
445 [NL80211_SAR_ATTR_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_SAR_TYPE),
446 [NL80211_SAR_ATTR_SPECS] = NLA_POLICY_NESTED_ARRAY(sar_specs_policy),
449 static const struct nla_policy
450 nl80211_mbssid_config_policy[NL80211_MBSSID_CONFIG_ATTR_MAX + 1] = {
451 [NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES] = NLA_POLICY_MIN(NLA_U8, 2),
452 [NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY] =
453 NLA_POLICY_MIN(NLA_U8, 1),
454 [NL80211_MBSSID_CONFIG_ATTR_INDEX] = { .type = NLA_U8 },
455 [NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX] = { .type = NLA_U32 },
456 [NL80211_MBSSID_CONFIG_ATTR_EMA] = { .type = NLA_FLAG },
459 static const struct nla_policy
460 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
461 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
462 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
465 static struct netlink_range_validation nl80211_punct_bitmap_range = {
470 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
471 [0] = { .strict_start_type = NL80211_ATTR_HE_OBSS_PD },
472 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
473 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
475 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
477 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
478 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
479 [NL80211_ATTR_WIPHY_EDMG_CHANNELS] = NLA_POLICY_RANGE(NLA_U8,
480 NL80211_EDMG_CHANNELS_MIN,
481 NL80211_EDMG_CHANNELS_MAX),
482 [NL80211_ATTR_WIPHY_EDMG_BW_CONFIG] = NLA_POLICY_RANGE(NLA_U8,
483 NL80211_EDMG_BW_CONFIG_MIN,
484 NL80211_EDMG_BW_CONFIG_MAX),
486 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
487 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
488 [NL80211_ATTR_CENTER_FREQ1_OFFSET] = NLA_POLICY_RANGE(NLA_U32, 0, 999),
489 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
491 [NL80211_ATTR_WIPHY_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
492 [NL80211_ATTR_WIPHY_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
493 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
494 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
495 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
496 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
498 [NL80211_ATTR_IFTYPE] = NLA_POLICY_MAX(NLA_U32, NL80211_IFTYPE_MAX),
499 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
500 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
502 [NL80211_ATTR_MAC] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
503 [NL80211_ATTR_PREV_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
505 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
506 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
507 .len = WLAN_MAX_KEY_LEN },
508 [NL80211_ATTR_KEY_IDX] = NLA_POLICY_MAX(NLA_U8, 7),
509 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
510 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
511 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
512 [NL80211_ATTR_KEY_TYPE] =
513 NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES),
515 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
516 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
517 [NL80211_ATTR_BEACON_HEAD] =
518 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_beacon_head,
519 IEEE80211_MAX_DATA_LEN),
520 [NL80211_ATTR_BEACON_TAIL] =
521 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
522 IEEE80211_MAX_DATA_LEN),
523 [NL80211_ATTR_STA_AID] =
524 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
525 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
526 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
527 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
528 .len = NL80211_MAX_SUPP_RATES },
529 [NL80211_ATTR_STA_PLINK_ACTION] =
530 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1),
531 [NL80211_ATTR_STA_TX_POWER_SETTING] =
532 NLA_POLICY_RANGE(NLA_U8,
533 NL80211_TX_POWER_AUTOMATIC,
534 NL80211_TX_POWER_FIXED),
535 [NL80211_ATTR_STA_TX_POWER] = { .type = NLA_S16 },
536 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
537 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
538 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
539 .len = IEEE80211_MAX_MESH_ID_LEN },
540 [NL80211_ATTR_MPATH_NEXT_HOP] = NLA_POLICY_ETH_ADDR_COMPAT,
542 /* allow 3 for NUL-termination, we used to declare this NLA_STRING */
543 [NL80211_ATTR_REG_ALPHA2] = NLA_POLICY_RANGE(NLA_BINARY, 2, 3),
544 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
546 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
547 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
548 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
549 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
550 .len = NL80211_MAX_SUPP_RATES },
551 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
553 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
554 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
556 [NL80211_ATTR_HT_CAPABILITY] = NLA_POLICY_EXACT_LEN_WARN(NL80211_HT_CAPABILITY_LEN),
558 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
559 [NL80211_ATTR_IE] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
561 IEEE80211_MAX_DATA_LEN),
562 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
563 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
565 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
566 .len = IEEE80211_MAX_SSID_LEN },
567 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
568 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
569 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
570 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
571 [NL80211_ATTR_USE_MFP] = NLA_POLICY_RANGE(NLA_U32,
573 NL80211_MFP_OPTIONAL),
574 [NL80211_ATTR_STA_FLAGS2] =
575 NLA_POLICY_EXACT_LEN_WARN(sizeof(struct nl80211_sta_flag_update)),
576 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
577 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
578 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
579 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211] = { .type = NLA_FLAG },
580 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
581 [NL80211_ATTR_STATUS_CODE] = { .type = NLA_U16 },
582 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
583 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
584 [NL80211_ATTR_PID] = { .type = NLA_U32 },
585 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
586 [NL80211_ATTR_PMKID] = NLA_POLICY_EXACT_LEN_WARN(WLAN_PMKID_LEN),
587 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
588 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
589 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
590 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
591 .len = IEEE80211_MAX_DATA_LEN },
592 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
593 [NL80211_ATTR_PS_STATE] = NLA_POLICY_RANGE(NLA_U32,
596 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
597 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
598 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
599 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
600 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
601 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
602 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
603 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
604 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
605 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
606 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
607 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
608 [NL80211_ATTR_STA_PLINK_STATE] =
609 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
610 [NL80211_ATTR_MEASUREMENT_DURATION] = { .type = NLA_U16 },
611 [NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY] = { .type = NLA_FLAG },
612 [NL80211_ATTR_MESH_PEER_AID] =
613 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
614 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
615 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
616 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
617 [NL80211_ATTR_HIDDEN_SSID] =
618 NLA_POLICY_RANGE(NLA_U32,
619 NL80211_HIDDEN_SSID_NOT_IN_USE,
620 NL80211_HIDDEN_SSID_ZERO_CONTENTS),
621 [NL80211_ATTR_IE_PROBE_RESP] =
622 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
623 IEEE80211_MAX_DATA_LEN),
624 [NL80211_ATTR_IE_ASSOC_RESP] =
625 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
626 IEEE80211_MAX_DATA_LEN),
627 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
628 [NL80211_ATTR_STA_WME] = NLA_POLICY_NESTED(nl80211_sta_wme_policy),
629 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
630 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
631 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
632 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
633 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
634 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
635 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
636 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
637 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
638 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
639 .len = IEEE80211_MAX_DATA_LEN },
640 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
641 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
642 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
643 .len = NL80211_HT_CAPABILITY_LEN
645 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
646 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
647 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
648 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
649 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
651 /* need to include at least Auth Transaction and Status Code */
652 [NL80211_ATTR_AUTH_DATA] = NLA_POLICY_MIN_LEN(4),
654 [NL80211_ATTR_VHT_CAPABILITY] = NLA_POLICY_EXACT_LEN_WARN(NL80211_VHT_CAPABILITY_LEN),
655 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
656 [NL80211_ATTR_P2P_CTWINDOW] = NLA_POLICY_MAX(NLA_U8, 127),
657 [NL80211_ATTR_P2P_OPPPS] = NLA_POLICY_MAX(NLA_U8, 1),
658 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] =
659 NLA_POLICY_RANGE(NLA_U32,
660 NL80211_MESH_POWER_UNKNOWN + 1,
661 NL80211_MESH_POWER_MAX),
662 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
663 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
664 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
665 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
666 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
667 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
668 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
669 .len = NL80211_VHT_CAPABILITY_LEN,
671 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
672 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
673 .len = IEEE80211_MAX_DATA_LEN },
674 [NL80211_ATTR_CRIT_PROT_ID] = { .type = NLA_U16 },
675 [NL80211_ATTR_MAX_CRIT_PROT_DURATION] =
676 NLA_POLICY_MAX(NLA_U16, NL80211_CRIT_PROTO_MAX_DURATION),
677 [NL80211_ATTR_PEER_AID] =
678 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
679 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
680 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
681 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
682 [NL80211_ATTR_CNTDWN_OFFS_BEACON] = { .type = NLA_BINARY },
683 [NL80211_ATTR_CNTDWN_OFFS_PRESP] = { .type = NLA_BINARY },
684 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = NLA_POLICY_MIN_LEN(2),
686 * The value of the Length field of the Supported Operating
687 * Classes element is between 2 and 253.
689 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] =
690 NLA_POLICY_RANGE(NLA_BINARY, 2, 253),
691 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
692 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
693 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
694 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
695 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
696 [NL80211_ATTR_QOS_MAP] = NLA_POLICY_RANGE(NLA_BINARY,
697 IEEE80211_QOS_MAP_LEN_MIN,
698 IEEE80211_QOS_MAP_LEN_MAX),
699 [NL80211_ATTR_MAC_HINT] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
700 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
701 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
702 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
703 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
704 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
705 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1),
706 [NL80211_ATTR_USER_PRIO] =
707 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
708 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
709 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
710 [NL80211_ATTR_OPER_CLASS] = { .type = NLA_U8 },
711 [NL80211_ATTR_MAC_MASK] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
712 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
713 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
714 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
715 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
716 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
717 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
718 [NL80211_ATTR_STA_SUPPORT_P2P_PS] =
719 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1),
720 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
721 .len = VHT_MUMIMO_GROUPS_DATA_LEN
723 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
724 [NL80211_ATTR_NAN_MASTER_PREF] = NLA_POLICY_MIN(NLA_U8, 1),
725 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
726 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
727 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
728 .len = FILS_MAX_KEK_LEN },
729 [NL80211_ATTR_FILS_NONCES] = NLA_POLICY_EXACT_LEN_WARN(2 * FILS_NONCE_LEN),
730 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
731 [NL80211_ATTR_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
732 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
733 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
734 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
736 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
737 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
738 .len = FILS_ERP_MAX_USERNAME_LEN },
739 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
740 .len = FILS_ERP_MAX_REALM_LEN },
741 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
742 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
743 .len = FILS_ERP_MAX_RRK_LEN },
744 [NL80211_ATTR_FILS_CACHE_ID] = NLA_POLICY_EXACT_LEN_WARN(2),
745 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
746 [NL80211_ATTR_PMKR0_NAME] = NLA_POLICY_EXACT_LEN(WLAN_PMK_NAME_LEN),
747 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
748 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT] = { .type = NLA_FLAG },
750 [NL80211_ATTR_TXQ_LIMIT] = { .type = NLA_U32 },
751 [NL80211_ATTR_TXQ_MEMORY_LIMIT] = { .type = NLA_U32 },
752 [NL80211_ATTR_TXQ_QUANTUM] = { .type = NLA_U32 },
753 [NL80211_ATTR_HE_CAPABILITY] =
754 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_he_capa,
755 NL80211_HE_MAX_CAPABILITY_LEN),
756 [NL80211_ATTR_FTM_RESPONDER] =
757 NLA_POLICY_NESTED(nl80211_ftm_responder_policy),
758 [NL80211_ATTR_TIMEOUT] = NLA_POLICY_MIN(NLA_U32, 1),
759 [NL80211_ATTR_PEER_MEASUREMENTS] =
760 NLA_POLICY_NESTED(nl80211_pmsr_attr_policy),
761 [NL80211_ATTR_AIRTIME_WEIGHT] = NLA_POLICY_MIN(NLA_U16, 1),
762 [NL80211_ATTR_SAE_PASSWORD] = { .type = NLA_BINARY,
763 .len = SAE_PASSWORD_MAX_LEN },
764 [NL80211_ATTR_TWT_RESPONDER] = { .type = NLA_FLAG },
765 [NL80211_ATTR_HE_OBSS_PD] = NLA_POLICY_NESTED(he_obss_pd_policy),
766 [NL80211_ATTR_VLAN_ID] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
767 [NL80211_ATTR_HE_BSS_COLOR] = NLA_POLICY_NESTED(he_bss_color_policy),
768 [NL80211_ATTR_TID_CONFIG] =
769 NLA_POLICY_NESTED_ARRAY(nl80211_tid_config_attr_policy),
770 [NL80211_ATTR_CONTROL_PORT_NO_PREAUTH] = { .type = NLA_FLAG },
771 [NL80211_ATTR_PMK_LIFETIME] = NLA_POLICY_MIN(NLA_U32, 1),
772 [NL80211_ATTR_PMK_REAUTH_THRESHOLD] = NLA_POLICY_RANGE(NLA_U8, 1, 100),
773 [NL80211_ATTR_RECEIVE_MULTICAST] = { .type = NLA_FLAG },
774 [NL80211_ATTR_WIPHY_FREQ_OFFSET] = NLA_POLICY_RANGE(NLA_U32, 0, 999),
775 [NL80211_ATTR_SCAN_FREQ_KHZ] = { .type = NLA_NESTED },
776 [NL80211_ATTR_HE_6GHZ_CAPABILITY] =
777 NLA_POLICY_EXACT_LEN(sizeof(struct ieee80211_he_6ghz_capa)),
778 [NL80211_ATTR_FILS_DISCOVERY] =
779 NLA_POLICY_NESTED(nl80211_fils_discovery_policy),
780 [NL80211_ATTR_UNSOL_BCAST_PROBE_RESP] =
781 NLA_POLICY_NESTED(nl80211_unsol_bcast_probe_resp_policy),
782 [NL80211_ATTR_S1G_CAPABILITY] =
783 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN),
784 [NL80211_ATTR_S1G_CAPABILITY_MASK] =
785 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN),
786 [NL80211_ATTR_SAE_PWE] =
787 NLA_POLICY_RANGE(NLA_U8, NL80211_SAE_PWE_HUNT_AND_PECK,
788 NL80211_SAE_PWE_BOTH),
789 [NL80211_ATTR_RECONNECT_REQUESTED] = { .type = NLA_REJECT },
790 [NL80211_ATTR_SAR_SPEC] = NLA_POLICY_NESTED(sar_policy),
791 [NL80211_ATTR_DISABLE_HE] = { .type = NLA_FLAG },
792 [NL80211_ATTR_OBSS_COLOR_BITMAP] = { .type = NLA_U64 },
793 [NL80211_ATTR_COLOR_CHANGE_COUNT] = { .type = NLA_U8 },
794 [NL80211_ATTR_COLOR_CHANGE_COLOR] = { .type = NLA_U8 },
795 [NL80211_ATTR_COLOR_CHANGE_ELEMS] = NLA_POLICY_NESTED(nl80211_policy),
796 [NL80211_ATTR_MBSSID_CONFIG] =
797 NLA_POLICY_NESTED(nl80211_mbssid_config_policy),
798 [NL80211_ATTR_MBSSID_ELEMS] = { .type = NLA_NESTED },
799 [NL80211_ATTR_RADAR_BACKGROUND] = { .type = NLA_FLAG },
800 [NL80211_ATTR_AP_SETTINGS_FLAGS] = { .type = NLA_U32 },
801 [NL80211_ATTR_EHT_CAPABILITY] =
802 NLA_POLICY_RANGE(NLA_BINARY,
803 NL80211_EHT_MIN_CAPABILITY_LEN,
804 NL80211_EHT_MAX_CAPABILITY_LEN),
805 [NL80211_ATTR_DISABLE_EHT] = { .type = NLA_FLAG },
806 [NL80211_ATTR_MLO_LINKS] =
807 NLA_POLICY_NESTED_ARRAY(nl80211_policy),
808 [NL80211_ATTR_MLO_LINK_ID] =
809 NLA_POLICY_RANGE(NLA_U8, 0, IEEE80211_MLD_MAX_NUM_LINKS),
810 [NL80211_ATTR_MLD_ADDR] = NLA_POLICY_EXACT_LEN(ETH_ALEN),
811 [NL80211_ATTR_MLO_SUPPORT] = { .type = NLA_FLAG },
812 [NL80211_ATTR_MAX_NUM_AKM_SUITES] = { .type = NLA_REJECT },
813 [NL80211_ATTR_PUNCT_BITMAP] =
814 NLA_POLICY_FULL_RANGE(NLA_U32, &nl80211_punct_bitmap_range),
816 [NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS] = { .type = NLA_U16 },
817 [NL80211_ATTR_HW_TIMESTAMP_ENABLED] = { .type = NLA_FLAG },
818 [NL80211_ATTR_EMA_RNR_ELEMS] = { .type = NLA_NESTED },
819 [NL80211_ATTR_MLO_LINK_DISABLED] = { .type = NLA_FLAG },
822 /* policy for the key attributes */
823 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
824 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
825 [NL80211_KEY_IDX] = { .type = NLA_U8 },
826 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
827 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
828 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
829 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
830 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1),
831 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
832 [NL80211_KEY_MODE] = NLA_POLICY_RANGE(NLA_U8, 0, NL80211_KEY_SET_TX),
835 /* policy for the key default flags */
836 static const struct nla_policy
837 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
838 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
839 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
843 /* policy for WoWLAN attributes */
844 static const struct nla_policy
845 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
846 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
847 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
848 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
849 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
850 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
851 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
852 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
853 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
854 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
855 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
858 static const struct nla_policy
859 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
860 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
861 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
862 [NL80211_WOWLAN_TCP_DST_MAC] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
863 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
864 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
865 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = NLA_POLICY_MIN_LEN(1),
866 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
867 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
869 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
870 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
872 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
873 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = NLA_POLICY_MIN_LEN(1),
874 [NL80211_WOWLAN_TCP_WAKE_MASK] = NLA_POLICY_MIN_LEN(1),
876 #endif /* CONFIG_PM */
878 /* policy for coalesce rule attributes */
879 static const struct nla_policy
880 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
881 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
882 [NL80211_ATTR_COALESCE_RULE_CONDITION] =
883 NLA_POLICY_RANGE(NLA_U32,
884 NL80211_COALESCE_CONDITION_MATCH,
885 NL80211_COALESCE_CONDITION_NO_MATCH),
886 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
889 /* policy for GTK rekey offload attributes */
890 static const struct nla_policy
891 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
892 [NL80211_REKEY_DATA_KEK] = {
894 .len = NL80211_KEK_EXT_LEN
896 [NL80211_REKEY_DATA_KCK] = {
898 .len = NL80211_KCK_EXT_LEN_32
900 [NL80211_REKEY_DATA_REPLAY_CTR] = NLA_POLICY_EXACT_LEN(NL80211_REPLAY_CTR_LEN),
901 [NL80211_REKEY_DATA_AKM] = { .type = NLA_U32 },
904 static const struct nla_policy
905 nl80211_match_band_rssi_policy[NUM_NL80211_BANDS] = {
906 [NL80211_BAND_2GHZ] = { .type = NLA_S32 },
907 [NL80211_BAND_5GHZ] = { .type = NLA_S32 },
908 [NL80211_BAND_6GHZ] = { .type = NLA_S32 },
909 [NL80211_BAND_60GHZ] = { .type = NLA_S32 },
910 [NL80211_BAND_LC] = { .type = NLA_S32 },
913 static const struct nla_policy
914 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
915 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
916 .len = IEEE80211_MAX_SSID_LEN },
917 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
918 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
919 [NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI] =
920 NLA_POLICY_NESTED(nl80211_match_band_rssi_policy),
923 static const struct nla_policy
924 nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
925 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
926 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
929 static const struct nla_policy
930 nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
931 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
932 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
933 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
934 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
938 /* policy for NAN function attributes */
939 static const struct nla_policy
940 nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
941 [NL80211_NAN_FUNC_TYPE] =
942 NLA_POLICY_MAX(NLA_U8, NL80211_NAN_FUNC_MAX_TYPE),
943 [NL80211_NAN_FUNC_SERVICE_ID] = {
944 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
945 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
946 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
947 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
948 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
949 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
950 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN),
951 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
952 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
953 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
954 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
955 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
956 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
957 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
958 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
959 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
962 /* policy for Service Response Filter attributes */
963 static const struct nla_policy
964 nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
965 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
966 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
967 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
968 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
969 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
972 /* policy for packet pattern attributes */
973 static const struct nla_policy
974 nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
975 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
976 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
977 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
980 static int nl80211_prepare_wdev_dump(struct netlink_callback *cb,
981 struct cfg80211_registered_device **rdev,
982 struct wireless_dev **wdev,
983 struct nlattr **attrbuf)
988 struct nlattr **attrbuf_free = NULL;
991 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
995 attrbuf_free = attrbuf;
998 err = nlmsg_parse_deprecated(cb->nlh,
999 GENL_HDRLEN + nl80211_fam.hdrsize,
1000 attrbuf, nl80211_fam.maxattr,
1001 nl80211_policy, NULL);
1003 kfree(attrbuf_free);
1008 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(cb->skb->sk),
1010 kfree(attrbuf_free);
1011 if (IS_ERR(*wdev)) {
1013 return PTR_ERR(*wdev);
1015 *rdev = wiphy_to_rdev((*wdev)->wiphy);
1016 mutex_lock(&(*rdev)->wiphy.mtx);
1018 /* 0 is the first index - add 1 to parse only once */
1019 cb->args[0] = (*rdev)->wiphy_idx + 1;
1020 cb->args[1] = (*wdev)->identifier;
1022 /* subtract the 1 again here */
1023 struct wiphy *wiphy;
1024 struct wireless_dev *tmp;
1027 wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
1032 *rdev = wiphy_to_rdev(wiphy);
1035 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
1036 if (tmp->identifier == cb->args[1]) {
1046 mutex_lock(&(*rdev)->wiphy.mtx);
1053 /* message building helper */
1054 void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
1057 /* since there is no private header just add the generic one */
1058 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
1061 static int nl80211_msg_put_wmm_rules(struct sk_buff *msg,
1062 const struct ieee80211_reg_rule *rule)
1065 struct nlattr *nl_wmm_rules =
1066 nla_nest_start_noflag(msg, NL80211_FREQUENCY_ATTR_WMM);
1069 goto nla_put_failure;
1071 for (j = 0; j < IEEE80211_NUM_ACS; j++) {
1072 struct nlattr *nl_wmm_rule = nla_nest_start_noflag(msg, j);
1075 goto nla_put_failure;
1077 if (nla_put_u16(msg, NL80211_WMMR_CW_MIN,
1078 rule->wmm_rule.client[j].cw_min) ||
1079 nla_put_u16(msg, NL80211_WMMR_CW_MAX,
1080 rule->wmm_rule.client[j].cw_max) ||
1081 nla_put_u8(msg, NL80211_WMMR_AIFSN,
1082 rule->wmm_rule.client[j].aifsn) ||
1083 nla_put_u16(msg, NL80211_WMMR_TXOP,
1084 rule->wmm_rule.client[j].cot))
1085 goto nla_put_failure;
1087 nla_nest_end(msg, nl_wmm_rule);
1089 nla_nest_end(msg, nl_wmm_rules);
1097 static int nl80211_msg_put_channel(struct sk_buff *msg, struct wiphy *wiphy,
1098 struct ieee80211_channel *chan,
1101 /* Some channels must be completely excluded from the
1102 * list to protect old user-space tools from breaking
1104 if (!large && chan->flags &
1105 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
1107 if (!large && chan->freq_offset)
1110 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
1112 goto nla_put_failure;
1114 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_OFFSET, chan->freq_offset))
1115 goto nla_put_failure;
1117 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
1118 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
1119 goto nla_put_failure;
1120 if (chan->flags & IEEE80211_CHAN_NO_IR) {
1121 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
1122 goto nla_put_failure;
1123 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
1124 goto nla_put_failure;
1126 if (chan->flags & IEEE80211_CHAN_RADAR) {
1127 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
1128 goto nla_put_failure;
1132 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
1134 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
1136 goto nla_put_failure;
1137 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
1139 goto nla_put_failure;
1140 if (nla_put_u32(msg,
1141 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
1143 goto nla_put_failure;
1148 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
1149 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
1150 goto nla_put_failure;
1151 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
1152 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
1153 goto nla_put_failure;
1154 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
1155 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
1156 goto nla_put_failure;
1157 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
1158 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
1159 goto nla_put_failure;
1160 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
1161 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
1162 goto nla_put_failure;
1163 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
1164 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
1165 goto nla_put_failure;
1166 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
1167 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
1168 goto nla_put_failure;
1169 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
1170 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
1171 goto nla_put_failure;
1172 if ((chan->flags & IEEE80211_CHAN_NO_HE) &&
1173 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HE))
1174 goto nla_put_failure;
1175 if ((chan->flags & IEEE80211_CHAN_1MHZ) &&
1176 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_1MHZ))
1177 goto nla_put_failure;
1178 if ((chan->flags & IEEE80211_CHAN_2MHZ) &&
1179 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_2MHZ))
1180 goto nla_put_failure;
1181 if ((chan->flags & IEEE80211_CHAN_4MHZ) &&
1182 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_4MHZ))
1183 goto nla_put_failure;
1184 if ((chan->flags & IEEE80211_CHAN_8MHZ) &&
1185 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_8MHZ))
1186 goto nla_put_failure;
1187 if ((chan->flags & IEEE80211_CHAN_16MHZ) &&
1188 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_16MHZ))
1189 goto nla_put_failure;
1190 if ((chan->flags & IEEE80211_CHAN_NO_320MHZ) &&
1191 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_320MHZ))
1192 goto nla_put_failure;
1193 if ((chan->flags & IEEE80211_CHAN_NO_EHT) &&
1194 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_EHT))
1195 goto nla_put_failure;
1198 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
1199 DBM_TO_MBM(chan->max_power)))
1200 goto nla_put_failure;
1203 const struct ieee80211_reg_rule *rule =
1204 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1206 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) {
1207 if (nl80211_msg_put_wmm_rules(msg, rule))
1208 goto nla_put_failure;
1218 static bool nl80211_put_txq_stats(struct sk_buff *msg,
1219 struct cfg80211_txq_stats *txqstats,
1222 struct nlattr *txqattr;
1224 #define PUT_TXQVAL_U32(attr, memb) do { \
1225 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
1226 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
1230 txqattr = nla_nest_start_noflag(msg, attrtype);
1234 PUT_TXQVAL_U32(BACKLOG_BYTES, backlog_bytes);
1235 PUT_TXQVAL_U32(BACKLOG_PACKETS, backlog_packets);
1236 PUT_TXQVAL_U32(FLOWS, flows);
1237 PUT_TXQVAL_U32(DROPS, drops);
1238 PUT_TXQVAL_U32(ECN_MARKS, ecn_marks);
1239 PUT_TXQVAL_U32(OVERLIMIT, overlimit);
1240 PUT_TXQVAL_U32(OVERMEMORY, overmemory);
1241 PUT_TXQVAL_U32(COLLISIONS, collisions);
1242 PUT_TXQVAL_U32(TX_BYTES, tx_bytes);
1243 PUT_TXQVAL_U32(TX_PACKETS, tx_packets);
1244 PUT_TXQVAL_U32(MAX_FLOWS, max_flows);
1245 nla_nest_end(msg, txqattr);
1247 #undef PUT_TXQVAL_U32
1251 /* netlink command implementations */
1254 * nl80211_link_id - return link ID
1255 * @attrs: attributes to look at
1257 * Returns: the link ID or 0 if not given
1259 * Note this function doesn't do any validation of the link
1260 * ID validity wrt. links that were actually added, so it must
1261 * be called only from ops with %NL80211_FLAG_MLO_VALID_LINK_ID
1262 * or if additional validation is done.
1264 static unsigned int nl80211_link_id(struct nlattr **attrs)
1266 struct nlattr *linkid = attrs[NL80211_ATTR_MLO_LINK_ID];
1271 return nla_get_u8(linkid);
1274 static int nl80211_link_id_or_invalid(struct nlattr **attrs)
1276 struct nlattr *linkid = attrs[NL80211_ATTR_MLO_LINK_ID];
1281 return nla_get_u8(linkid);
1285 struct key_params p;
1288 bool def, defmgmt, defbeacon;
1289 bool def_uni, def_multi;
1292 static int nl80211_parse_key_new(struct genl_info *info, struct nlattr *key,
1293 struct key_parse *k)
1295 struct nlattr *tb[NL80211_KEY_MAX + 1];
1296 int err = nla_parse_nested_deprecated(tb, NL80211_KEY_MAX, key,
1302 k->def = !!tb[NL80211_KEY_DEFAULT];
1303 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
1304 k->defbeacon = !!tb[NL80211_KEY_DEFAULT_BEACON];
1308 k->def_multi = true;
1310 if (k->defmgmt || k->defbeacon)
1311 k->def_multi = true;
1313 if (tb[NL80211_KEY_IDX])
1314 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
1316 if (tb[NL80211_KEY_DATA]) {
1317 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
1318 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
1321 if (tb[NL80211_KEY_SEQ]) {
1322 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
1323 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
1326 if (tb[NL80211_KEY_CIPHER])
1327 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
1329 if (tb[NL80211_KEY_TYPE])
1330 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
1332 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
1333 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1335 err = nla_parse_nested_deprecated(kdt,
1336 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1337 tb[NL80211_KEY_DEFAULT_TYPES],
1338 nl80211_key_default_policy,
1343 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1344 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1347 if (tb[NL80211_KEY_MODE])
1348 k->p.mode = nla_get_u8(tb[NL80211_KEY_MODE]);
1353 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
1355 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
1356 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
1357 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
1360 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
1361 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
1362 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
1365 if (info->attrs[NL80211_ATTR_KEY_IDX])
1366 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1368 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
1369 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
1371 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
1372 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
1376 k->def_multi = true;
1379 k->def_multi = true;
1381 if (info->attrs[NL80211_ATTR_KEY_TYPE])
1382 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1384 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
1385 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1386 int err = nla_parse_nested_deprecated(kdt,
1387 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1388 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
1389 nl80211_key_default_policy,
1394 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1395 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1401 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
1405 memset(k, 0, sizeof(*k));
1409 if (info->attrs[NL80211_ATTR_KEY])
1410 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k);
1412 err = nl80211_parse_key_old(info, k);
1417 if ((k->def ? 1 : 0) + (k->defmgmt ? 1 : 0) +
1418 (k->defbeacon ? 1 : 0) > 1) {
1419 GENL_SET_ERR_MSG(info,
1420 "key with multiple default flags is invalid");
1424 if (k->defmgmt || k->defbeacon) {
1425 if (k->def_uni || !k->def_multi) {
1426 GENL_SET_ERR_MSG(info,
1427 "defmgmt/defbeacon key must be mcast");
1434 if (k->idx < 4 || k->idx > 5) {
1435 GENL_SET_ERR_MSG(info,
1436 "defmgmt key idx not 4 or 5");
1439 } else if (k->defbeacon) {
1440 if (k->idx < 6 || k->idx > 7) {
1441 GENL_SET_ERR_MSG(info,
1442 "defbeacon key idx not 6 or 7");
1445 } else if (k->def) {
1446 if (k->idx < 0 || k->idx > 3) {
1447 GENL_SET_ERR_MSG(info, "def key idx not 0-3");
1451 if (k->idx < 0 || k->idx > 7) {
1452 GENL_SET_ERR_MSG(info, "key idx not 0-7");
1461 static struct cfg80211_cached_keys *
1462 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
1463 struct genl_info *info, bool *no_ht)
1465 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS];
1466 struct key_parse parse;
1468 struct cfg80211_cached_keys *result;
1469 int rem, err, def = 0;
1470 bool have_key = false;
1472 nla_for_each_nested(key, keys, rem) {
1480 result = kzalloc(sizeof(*result), GFP_KERNEL);
1482 return ERR_PTR(-ENOMEM);
1486 nla_for_each_nested(key, keys, rem) {
1487 memset(&parse, 0, sizeof(parse));
1490 err = nl80211_parse_key_new(info, key, &parse);
1496 if (parse.idx < 0 || parse.idx > 3) {
1497 GENL_SET_ERR_MSG(info, "key index out of range [0-3]");
1502 GENL_SET_ERR_MSG(info,
1503 "only one key can be default");
1507 result->def = parse.idx;
1508 if (!parse.def_uni || !parse.def_multi)
1510 } else if (parse.defmgmt)
1512 err = cfg80211_validate_key_settings(rdev, &parse.p,
1513 parse.idx, false, NULL);
1516 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1517 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
1518 GENL_SET_ERR_MSG(info, "connect key must be WEP");
1522 result->params[parse.idx].cipher = parse.p.cipher;
1523 result->params[parse.idx].key_len = parse.p.key_len;
1524 result->params[parse.idx].key = result->data[parse.idx];
1525 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
1527 /* must be WEP key if we got here */
1532 if (result->def < 0) {
1534 GENL_SET_ERR_MSG(info, "need a default/TX key");
1541 return ERR_PTR(err);
1544 static int nl80211_key_allowed(struct wireless_dev *wdev)
1546 ASSERT_WDEV_LOCK(wdev);
1548 switch (wdev->iftype) {
1549 case NL80211_IFTYPE_AP:
1550 case NL80211_IFTYPE_AP_VLAN:
1551 case NL80211_IFTYPE_P2P_GO:
1552 case NL80211_IFTYPE_MESH_POINT:
1554 case NL80211_IFTYPE_ADHOC:
1555 if (wdev->u.ibss.current_bss)
1558 case NL80211_IFTYPE_STATION:
1559 case NL80211_IFTYPE_P2P_CLIENT:
1560 if (wdev->connected)
1563 case NL80211_IFTYPE_NAN:
1564 if (wiphy_ext_feature_isset(wdev->wiphy,
1565 NL80211_EXT_FEATURE_SECURE_NAN))
1568 case NL80211_IFTYPE_UNSPECIFIED:
1569 case NL80211_IFTYPE_OCB:
1570 case NL80211_IFTYPE_MONITOR:
1571 case NL80211_IFTYPE_P2P_DEVICE:
1572 case NL80211_IFTYPE_WDS:
1573 case NUM_NL80211_IFTYPES:
1580 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
1583 struct ieee80211_channel *chan;
1585 chan = ieee80211_get_channel_khz(wiphy, freq);
1586 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1591 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1593 struct nlattr *nl_modes = nla_nest_start_noflag(msg, attr);
1597 goto nla_put_failure;
1601 if ((ifmodes & 1) && nla_put_flag(msg, i))
1602 goto nla_put_failure;
1607 nla_nest_end(msg, nl_modes);
1614 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
1615 struct sk_buff *msg,
1618 struct nlattr *nl_combis;
1621 nl_combis = nla_nest_start_noflag(msg,
1622 NL80211_ATTR_INTERFACE_COMBINATIONS);
1624 goto nla_put_failure;
1626 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1627 const struct ieee80211_iface_combination *c;
1628 struct nlattr *nl_combi, *nl_limits;
1630 c = &wiphy->iface_combinations[i];
1632 nl_combi = nla_nest_start_noflag(msg, i + 1);
1634 goto nla_put_failure;
1636 nl_limits = nla_nest_start_noflag(msg,
1637 NL80211_IFACE_COMB_LIMITS);
1639 goto nla_put_failure;
1641 for (j = 0; j < c->n_limits; j++) {
1642 struct nlattr *nl_limit;
1644 nl_limit = nla_nest_start_noflag(msg, j + 1);
1646 goto nla_put_failure;
1647 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1649 goto nla_put_failure;
1650 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1651 c->limits[j].types))
1652 goto nla_put_failure;
1653 nla_nest_end(msg, nl_limit);
1656 nla_nest_end(msg, nl_limits);
1658 if (c->beacon_int_infra_match &&
1659 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1660 goto nla_put_failure;
1661 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1662 c->num_different_channels) ||
1663 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1665 goto nla_put_failure;
1667 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1668 c->radar_detect_widths) ||
1669 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1670 c->radar_detect_regions)))
1671 goto nla_put_failure;
1672 if (c->beacon_int_min_gcd &&
1673 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1674 c->beacon_int_min_gcd))
1675 goto nla_put_failure;
1677 nla_nest_end(msg, nl_combi);
1680 nla_nest_end(msg, nl_combis);
1688 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1689 struct sk_buff *msg)
1691 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1692 struct nlattr *nl_tcp;
1697 nl_tcp = nla_nest_start_noflag(msg,
1698 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1702 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1703 tcp->data_payload_max))
1706 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1707 tcp->data_payload_max))
1710 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1713 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1714 sizeof(*tcp->tok), tcp->tok))
1717 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1718 tcp->data_interval_max))
1721 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1722 tcp->wake_payload_max))
1725 nla_nest_end(msg, nl_tcp);
1729 static int nl80211_send_wowlan(struct sk_buff *msg,
1730 struct cfg80211_registered_device *rdev,
1733 struct nlattr *nl_wowlan;
1735 if (!rdev->wiphy.wowlan)
1738 nl_wowlan = nla_nest_start_noflag(msg,
1739 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1743 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1744 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1745 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1746 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1747 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1748 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1749 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1750 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1751 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1752 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1753 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1754 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1755 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1756 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1757 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1758 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1761 if (rdev->wiphy.wowlan->n_patterns) {
1762 struct nl80211_pattern_support pat = {
1763 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1764 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1765 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1766 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1769 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1774 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1775 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1776 rdev->wiphy.wowlan->max_nd_match_sets))
1779 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
1782 nla_nest_end(msg, nl_wowlan);
1788 static int nl80211_send_coalesce(struct sk_buff *msg,
1789 struct cfg80211_registered_device *rdev)
1791 struct nl80211_coalesce_rule_support rule;
1793 if (!rdev->wiphy.coalesce)
1796 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1797 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1798 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1799 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1800 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1801 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1803 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1810 nl80211_send_iftype_data(struct sk_buff *msg,
1811 const struct ieee80211_supported_band *sband,
1812 const struct ieee80211_sband_iftype_data *iftdata)
1814 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap;
1815 const struct ieee80211_sta_eht_cap *eht_cap = &iftdata->eht_cap;
1817 if (nl80211_put_iftypes(msg, NL80211_BAND_IFTYPE_ATTR_IFTYPES,
1818 iftdata->types_mask))
1821 if (he_cap->has_he) {
1822 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC,
1823 sizeof(he_cap->he_cap_elem.mac_cap_info),
1824 he_cap->he_cap_elem.mac_cap_info) ||
1825 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY,
1826 sizeof(he_cap->he_cap_elem.phy_cap_info),
1827 he_cap->he_cap_elem.phy_cap_info) ||
1828 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET,
1829 sizeof(he_cap->he_mcs_nss_supp),
1830 &he_cap->he_mcs_nss_supp) ||
1831 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE,
1832 sizeof(he_cap->ppe_thres), he_cap->ppe_thres))
1836 if (eht_cap->has_eht && he_cap->has_he) {
1837 u8 mcs_nss_size, ppe_thresh_size;
1841 is_ap = iftdata->types_mask & BIT(NL80211_IFTYPE_AP) ||
1842 iftdata->types_mask & BIT(NL80211_IFTYPE_P2P_GO);
1845 ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
1846 &eht_cap->eht_cap_elem,
1849 ppe_thres_hdr = get_unaligned_le16(&eht_cap->eht_ppe_thres[0]);
1851 ieee80211_eht_ppe_size(ppe_thres_hdr,
1852 eht_cap->eht_cap_elem.phy_cap_info);
1854 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC,
1855 sizeof(eht_cap->eht_cap_elem.mac_cap_info),
1856 eht_cap->eht_cap_elem.mac_cap_info) ||
1857 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY,
1858 sizeof(eht_cap->eht_cap_elem.phy_cap_info),
1859 eht_cap->eht_cap_elem.phy_cap_info) ||
1860 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET,
1861 mcs_nss_size, &eht_cap->eht_mcs_nss_supp) ||
1862 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE,
1863 ppe_thresh_size, eht_cap->eht_ppe_thres))
1867 if (sband->band == NL80211_BAND_6GHZ &&
1868 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA,
1869 sizeof(iftdata->he_6ghz_capa),
1870 &iftdata->he_6ghz_capa))
1873 if (iftdata->vendor_elems.data && iftdata->vendor_elems.len &&
1874 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_VENDOR_ELEMS,
1875 iftdata->vendor_elems.len, iftdata->vendor_elems.data))
1881 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1882 struct ieee80211_supported_band *sband,
1885 struct nlattr *nl_rates, *nl_rate;
1886 struct ieee80211_rate *rate;
1890 if (sband->ht_cap.ht_supported &&
1891 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1892 sizeof(sband->ht_cap.mcs),
1893 &sband->ht_cap.mcs) ||
1894 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1895 sband->ht_cap.cap) ||
1896 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1897 sband->ht_cap.ampdu_factor) ||
1898 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1899 sband->ht_cap.ampdu_density)))
1903 if (sband->vht_cap.vht_supported &&
1904 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1905 sizeof(sband->vht_cap.vht_mcs),
1906 &sband->vht_cap.vht_mcs) ||
1907 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1908 sband->vht_cap.cap)))
1911 if (large && sband->n_iftype_data) {
1912 struct nlattr *nl_iftype_data =
1913 nla_nest_start_noflag(msg,
1914 NL80211_BAND_ATTR_IFTYPE_DATA);
1917 if (!nl_iftype_data)
1920 for (i = 0; i < sband->n_iftype_data; i++) {
1921 struct nlattr *iftdata;
1923 iftdata = nla_nest_start_noflag(msg, i + 1);
1927 err = nl80211_send_iftype_data(msg, sband,
1928 &sband->iftype_data[i]);
1932 nla_nest_end(msg, iftdata);
1935 nla_nest_end(msg, nl_iftype_data);
1939 if (large && sband->edmg_cap.channels &&
1940 (nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_CHANNELS,
1941 sband->edmg_cap.channels) ||
1942 nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_BW_CONFIG,
1943 sband->edmg_cap.bw_config)))
1948 nl_rates = nla_nest_start_noflag(msg, NL80211_BAND_ATTR_RATES);
1952 for (i = 0; i < sband->n_bitrates; i++) {
1953 nl_rate = nla_nest_start_noflag(msg, i);
1957 rate = &sband->bitrates[i];
1958 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1961 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1963 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1966 nla_nest_end(msg, nl_rate);
1969 nla_nest_end(msg, nl_rates);
1971 /* S1G capabilities */
1972 if (sband->band == NL80211_BAND_S1GHZ && sband->s1g_cap.s1g &&
1973 (nla_put(msg, NL80211_BAND_ATTR_S1G_CAPA,
1974 sizeof(sband->s1g_cap.cap),
1975 sband->s1g_cap.cap) ||
1976 nla_put(msg, NL80211_BAND_ATTR_S1G_MCS_NSS_SET,
1977 sizeof(sband->s1g_cap.nss_mcs),
1978 sband->s1g_cap.nss_mcs)))
1985 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1986 const struct ieee80211_txrx_stypes *mgmt_stypes)
1989 struct nlattr *nl_ftypes, *nl_ifs;
1990 enum nl80211_iftype ift;
1996 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_TX_FRAME_TYPES);
2000 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
2001 nl_ftypes = nla_nest_start_noflag(msg, ift);
2005 stypes = mgmt_stypes[ift].tx;
2008 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
2009 (i << 4) | IEEE80211_FTYPE_MGMT))
2014 nla_nest_end(msg, nl_ftypes);
2017 nla_nest_end(msg, nl_ifs);
2019 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_RX_FRAME_TYPES);
2023 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
2024 nl_ftypes = nla_nest_start_noflag(msg, ift);
2028 stypes = mgmt_stypes[ift].rx;
2031 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
2032 (i << 4) | IEEE80211_FTYPE_MGMT))
2037 nla_nest_end(msg, nl_ftypes);
2039 nla_nest_end(msg, nl_ifs);
2044 #define CMD(op, n) \
2046 if (rdev->ops->op) { \
2048 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
2049 goto nla_put_failure; \
2053 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
2054 struct sk_buff *msg)
2059 * do *NOT* add anything into this function, new things need to be
2060 * advertised only to new versions of userspace that can deal with
2061 * the split (and they can't possibly care about new features...
2063 CMD(add_virtual_intf, NEW_INTERFACE);
2064 CMD(change_virtual_intf, SET_INTERFACE);
2065 CMD(add_key, NEW_KEY);
2066 CMD(start_ap, START_AP);
2067 CMD(add_station, NEW_STATION);
2068 CMD(add_mpath, NEW_MPATH);
2069 CMD(update_mesh_config, SET_MESH_CONFIG);
2070 CMD(change_bss, SET_BSS);
2071 CMD(auth, AUTHENTICATE);
2072 CMD(assoc, ASSOCIATE);
2073 CMD(deauth, DEAUTHENTICATE);
2074 CMD(disassoc, DISASSOCIATE);
2075 CMD(join_ibss, JOIN_IBSS);
2076 CMD(join_mesh, JOIN_MESH);
2077 CMD(set_pmksa, SET_PMKSA);
2078 CMD(del_pmksa, DEL_PMKSA);
2079 CMD(flush_pmksa, FLUSH_PMKSA);
2080 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
2081 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
2082 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
2083 CMD(mgmt_tx, FRAME);
2084 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
2085 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
2087 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
2088 goto nla_put_failure;
2090 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
2091 rdev->ops->join_mesh) {
2093 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
2094 goto nla_put_failure;
2096 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
2097 CMD(tdls_mgmt, TDLS_MGMT);
2098 CMD(tdls_oper, TDLS_OPER);
2100 if (rdev->wiphy.max_sched_scan_reqs)
2101 CMD(sched_scan_start, START_SCHED_SCAN);
2102 CMD(probe_client, PROBE_CLIENT);
2103 CMD(set_noack_map, SET_NOACK_MAP);
2104 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
2106 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
2107 goto nla_put_failure;
2109 CMD(start_p2p_device, START_P2P_DEVICE);
2110 CMD(set_mcast_rate, SET_MCAST_RATE);
2111 #ifdef CONFIG_NL80211_TESTMODE
2112 CMD(testmode_cmd, TESTMODE);
2115 if (rdev->ops->connect || rdev->ops->auth) {
2117 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
2118 goto nla_put_failure;
2121 if (rdev->ops->disconnect || rdev->ops->deauth) {
2123 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
2124 goto nla_put_failure;
2133 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities *cap,
2134 struct sk_buff *msg)
2138 if (!cap->ftm.supported)
2141 ftm = nla_nest_start_noflag(msg, NL80211_PMSR_TYPE_FTM);
2145 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP))
2147 if (cap->ftm.non_asap &&
2148 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP))
2150 if (cap->ftm.request_lci &&
2151 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI))
2153 if (cap->ftm.request_civicloc &&
2154 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC))
2156 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES,
2157 cap->ftm.preambles))
2159 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS,
2160 cap->ftm.bandwidths))
2162 if (cap->ftm.max_bursts_exponent >= 0 &&
2163 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT,
2164 cap->ftm.max_bursts_exponent))
2166 if (cap->ftm.max_ftms_per_burst &&
2167 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST,
2168 cap->ftm.max_ftms_per_burst))
2170 if (cap->ftm.trigger_based &&
2171 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_TRIGGER_BASED))
2173 if (cap->ftm.non_trigger_based &&
2174 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED))
2177 nla_nest_end(msg, ftm);
2181 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device *rdev,
2182 struct sk_buff *msg)
2184 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa;
2185 struct nlattr *pmsr, *caps;
2191 * we don't need to clean up anything here since the caller
2192 * will genlmsg_cancel() if we fail
2195 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS);
2199 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers))
2202 if (cap->report_ap_tsf &&
2203 nla_put_flag(msg, NL80211_PMSR_ATTR_REPORT_AP_TSF))
2206 if (cap->randomize_mac_addr &&
2207 nla_put_flag(msg, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR))
2210 caps = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_TYPE_CAPA);
2214 if (nl80211_send_pmsr_ftm_capa(cap, msg))
2217 nla_nest_end(msg, caps);
2218 nla_nest_end(msg, pmsr);
2224 nl80211_put_iftype_akm_suites(struct cfg80211_registered_device *rdev,
2225 struct sk_buff *msg)
2228 struct nlattr *nested, *nested_akms;
2229 const struct wiphy_iftype_akm_suites *iftype_akms;
2231 if (!rdev->wiphy.num_iftype_akm_suites ||
2232 !rdev->wiphy.iftype_akm_suites)
2235 nested = nla_nest_start(msg, NL80211_ATTR_IFTYPE_AKM_SUITES);
2239 for (i = 0; i < rdev->wiphy.num_iftype_akm_suites; i++) {
2240 nested_akms = nla_nest_start(msg, i + 1);
2244 iftype_akms = &rdev->wiphy.iftype_akm_suites[i];
2246 if (nl80211_put_iftypes(msg, NL80211_IFTYPE_AKM_ATTR_IFTYPES,
2247 iftype_akms->iftypes_mask))
2250 if (nla_put(msg, NL80211_IFTYPE_AKM_ATTR_SUITES,
2251 sizeof(u32) * iftype_akms->n_akm_suites,
2252 iftype_akms->akm_suites)) {
2255 nla_nest_end(msg, nested_akms);
2258 nla_nest_end(msg, nested);
2264 nl80211_put_tid_config_support(struct cfg80211_registered_device *rdev,
2265 struct sk_buff *msg)
2267 struct nlattr *supp;
2269 if (!rdev->wiphy.tid_config_support.vif &&
2270 !rdev->wiphy.tid_config_support.peer)
2273 supp = nla_nest_start(msg, NL80211_ATTR_TID_CONFIG);
2277 if (rdev->wiphy.tid_config_support.vif &&
2278 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_VIF_SUPP,
2279 rdev->wiphy.tid_config_support.vif,
2280 NL80211_TID_CONFIG_ATTR_PAD))
2283 if (rdev->wiphy.tid_config_support.peer &&
2284 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_PEER_SUPP,
2285 rdev->wiphy.tid_config_support.peer,
2286 NL80211_TID_CONFIG_ATTR_PAD))
2289 /* for now we just use the same value ... makes more sense */
2290 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_SHORT,
2291 rdev->wiphy.tid_config_support.max_retry))
2293 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_LONG,
2294 rdev->wiphy.tid_config_support.max_retry))
2297 nla_nest_end(msg, supp);
2301 nla_nest_cancel(msg, supp);
2306 nl80211_put_sar_specs(struct cfg80211_registered_device *rdev,
2307 struct sk_buff *msg)
2309 struct nlattr *sar_capa, *specs, *sub_freq_range;
2313 if (!rdev->wiphy.sar_capa)
2316 num_freq_ranges = rdev->wiphy.sar_capa->num_freq_ranges;
2318 sar_capa = nla_nest_start(msg, NL80211_ATTR_SAR_SPEC);
2322 if (nla_put_u32(msg, NL80211_SAR_ATTR_TYPE, rdev->wiphy.sar_capa->type))
2325 specs = nla_nest_start(msg, NL80211_SAR_ATTR_SPECS);
2329 /* report supported freq_ranges */
2330 for (i = 0; i < num_freq_ranges; i++) {
2331 sub_freq_range = nla_nest_start(msg, i + 1);
2332 if (!sub_freq_range)
2335 if (nla_put_u32(msg, NL80211_SAR_ATTR_SPECS_START_FREQ,
2336 rdev->wiphy.sar_capa->freq_ranges[i].start_freq))
2339 if (nla_put_u32(msg, NL80211_SAR_ATTR_SPECS_END_FREQ,
2340 rdev->wiphy.sar_capa->freq_ranges[i].end_freq))
2343 nla_nest_end(msg, sub_freq_range);
2346 nla_nest_end(msg, specs);
2347 nla_nest_end(msg, sar_capa);
2351 nla_nest_cancel(msg, sar_capa);
2355 static int nl80211_put_mbssid_support(struct wiphy *wiphy, struct sk_buff *msg)
2357 struct nlattr *config;
2359 if (!wiphy->mbssid_max_interfaces)
2362 config = nla_nest_start(msg, NL80211_ATTR_MBSSID_CONFIG);
2366 if (nla_put_u8(msg, NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES,
2367 wiphy->mbssid_max_interfaces))
2370 if (wiphy->ema_max_profile_periodicity &&
2372 NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY,
2373 wiphy->ema_max_profile_periodicity))
2376 nla_nest_end(msg, config);
2380 nla_nest_cancel(msg, config);
2384 struct nl80211_dump_wiphy_state {
2387 long split_start, band_start, chan_start, capa_start;
2391 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
2392 enum nl80211_commands cmd,
2393 struct sk_buff *msg, u32 portid, u32 seq,
2394 int flags, struct nl80211_dump_wiphy_state *state)
2397 struct nlattr *nl_bands, *nl_band;
2398 struct nlattr *nl_freqs, *nl_freq;
2399 struct nlattr *nl_cmds;
2400 enum nl80211_band band;
2401 struct ieee80211_channel *chan;
2403 const struct ieee80211_txrx_stypes *mgmt_stypes =
2404 rdev->wiphy.mgmt_stypes;
2407 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2411 if (WARN_ON(!state))
2414 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2415 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
2416 wiphy_name(&rdev->wiphy)) ||
2417 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2418 cfg80211_rdev_list_generation))
2419 goto nla_put_failure;
2421 if (cmd != NL80211_CMD_NEW_WIPHY)
2424 switch (state->split_start) {
2426 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
2427 rdev->wiphy.retry_short) ||
2428 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
2429 rdev->wiphy.retry_long) ||
2430 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
2431 rdev->wiphy.frag_threshold) ||
2432 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
2433 rdev->wiphy.rts_threshold) ||
2434 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
2435 rdev->wiphy.coverage_class) ||
2436 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
2437 rdev->wiphy.max_scan_ssids) ||
2438 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
2439 rdev->wiphy.max_sched_scan_ssids) ||
2440 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
2441 rdev->wiphy.max_scan_ie_len) ||
2442 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
2443 rdev->wiphy.max_sched_scan_ie_len) ||
2444 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
2445 rdev->wiphy.max_match_sets))
2446 goto nla_put_failure;
2448 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
2449 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
2450 goto nla_put_failure;
2451 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
2452 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
2453 goto nla_put_failure;
2454 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
2455 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
2456 goto nla_put_failure;
2457 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
2458 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
2459 goto nla_put_failure;
2460 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
2461 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
2462 goto nla_put_failure;
2463 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
2464 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
2465 goto nla_put_failure;
2466 state->split_start++;
2471 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
2472 sizeof(u32) * rdev->wiphy.n_cipher_suites,
2473 rdev->wiphy.cipher_suites))
2474 goto nla_put_failure;
2476 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
2477 rdev->wiphy.max_num_pmkids))
2478 goto nla_put_failure;
2480 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
2481 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
2482 goto nla_put_failure;
2484 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
2485 rdev->wiphy.available_antennas_tx) ||
2486 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
2487 rdev->wiphy.available_antennas_rx))
2488 goto nla_put_failure;
2490 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
2491 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
2492 rdev->wiphy.probe_resp_offload))
2493 goto nla_put_failure;
2495 if ((rdev->wiphy.available_antennas_tx ||
2496 rdev->wiphy.available_antennas_rx) &&
2497 rdev->ops->get_antenna) {
2498 u32 tx_ant = 0, rx_ant = 0;
2501 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
2503 if (nla_put_u32(msg,
2504 NL80211_ATTR_WIPHY_ANTENNA_TX,
2507 NL80211_ATTR_WIPHY_ANTENNA_RX,
2509 goto nla_put_failure;
2513 state->split_start++;
2518 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
2519 rdev->wiphy.interface_modes))
2520 goto nla_put_failure;
2521 state->split_start++;
2526 nl_bands = nla_nest_start_noflag(msg,
2527 NL80211_ATTR_WIPHY_BANDS);
2529 goto nla_put_failure;
2531 for (band = state->band_start;
2532 band < (state->split ?
2534 NL80211_BAND_60GHZ + 1);
2536 struct ieee80211_supported_band *sband;
2538 /* omit higher bands for ancient software */
2539 if (band > NL80211_BAND_5GHZ && !state->split)
2542 sband = rdev->wiphy.bands[band];
2547 nl_band = nla_nest_start_noflag(msg, band);
2549 goto nla_put_failure;
2551 switch (state->chan_start) {
2553 if (nl80211_send_band_rateinfo(msg, sband,
2555 goto nla_put_failure;
2556 state->chan_start++;
2561 /* add frequencies */
2562 nl_freqs = nla_nest_start_noflag(msg,
2563 NL80211_BAND_ATTR_FREQS);
2565 goto nla_put_failure;
2567 for (i = state->chan_start - 1;
2568 i < sband->n_channels;
2570 nl_freq = nla_nest_start_noflag(msg,
2573 goto nla_put_failure;
2575 chan = &sband->channels[i];
2577 if (nl80211_msg_put_channel(
2578 msg, &rdev->wiphy, chan,
2580 goto nla_put_failure;
2582 nla_nest_end(msg, nl_freq);
2586 if (i < sband->n_channels)
2587 state->chan_start = i + 2;
2589 state->chan_start = 0;
2590 nla_nest_end(msg, nl_freqs);
2593 nla_nest_end(msg, nl_band);
2596 /* start again here */
2597 if (state->chan_start)
2602 nla_nest_end(msg, nl_bands);
2604 if (band < NUM_NL80211_BANDS)
2605 state->band_start = band + 1;
2607 state->band_start = 0;
2609 /* if bands & channels are done, continue outside */
2610 if (state->band_start == 0 && state->chan_start == 0)
2611 state->split_start++;
2616 nl_cmds = nla_nest_start_noflag(msg,
2617 NL80211_ATTR_SUPPORTED_COMMANDS);
2619 goto nla_put_failure;
2621 i = nl80211_add_commands_unsplit(rdev, msg);
2623 goto nla_put_failure;
2625 CMD(crit_proto_start, CRIT_PROTOCOL_START);
2626 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
2627 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
2628 CMD(channel_switch, CHANNEL_SWITCH);
2629 CMD(set_qos_map, SET_QOS_MAP);
2630 if (rdev->wiphy.features &
2631 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
2632 CMD(add_tx_ts, ADD_TX_TS);
2633 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
2634 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
2635 CMD(update_ft_ies, UPDATE_FT_IES);
2636 if (rdev->wiphy.sar_capa)
2637 CMD(set_sar_specs, SET_SAR_SPECS);
2641 nla_nest_end(msg, nl_cmds);
2642 state->split_start++;
2647 if (rdev->ops->remain_on_channel &&
2648 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
2650 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
2651 rdev->wiphy.max_remain_on_channel_duration))
2652 goto nla_put_failure;
2654 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
2655 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
2656 goto nla_put_failure;
2658 state->split_start++;
2664 if (nl80211_send_wowlan(msg, rdev, state->split))
2665 goto nla_put_failure;
2666 state->split_start++;
2670 state->split_start++;
2674 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
2675 rdev->wiphy.software_iftypes))
2676 goto nla_put_failure;
2678 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
2680 goto nla_put_failure;
2682 state->split_start++;
2687 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
2688 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
2689 rdev->wiphy.ap_sme_capa))
2690 goto nla_put_failure;
2692 features = rdev->wiphy.features;
2694 * We can only add the per-channel limit information if the
2695 * dump is split, otherwise it makes it too big. Therefore
2696 * only advertise it in that case.
2699 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
2700 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
2701 goto nla_put_failure;
2703 if (rdev->wiphy.ht_capa_mod_mask &&
2704 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
2705 sizeof(*rdev->wiphy.ht_capa_mod_mask),
2706 rdev->wiphy.ht_capa_mod_mask))
2707 goto nla_put_failure;
2709 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
2710 rdev->wiphy.max_acl_mac_addrs &&
2711 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
2712 rdev->wiphy.max_acl_mac_addrs))
2713 goto nla_put_failure;
2716 * Any information below this point is only available to
2717 * applications that can deal with it being split. This
2718 * helps ensure that newly added capabilities don't break
2719 * older tools by overrunning their buffers.
2721 * We still increment split_start so that in the split
2722 * case we'll continue with more data in the next round,
2723 * but break unconditionally so unsplit data stops here.
2726 state->split_start++;
2728 state->split_start = 0;
2731 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
2732 goto nla_put_failure;
2734 if (nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
2735 rdev->wiphy.max_sched_scan_plans) ||
2736 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
2737 rdev->wiphy.max_sched_scan_plan_interval) ||
2738 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
2739 rdev->wiphy.max_sched_scan_plan_iterations))
2740 goto nla_put_failure;
2742 if (rdev->wiphy.extended_capabilities &&
2743 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
2744 rdev->wiphy.extended_capabilities_len,
2745 rdev->wiphy.extended_capabilities) ||
2746 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2747 rdev->wiphy.extended_capabilities_len,
2748 rdev->wiphy.extended_capabilities_mask)))
2749 goto nla_put_failure;
2751 if (rdev->wiphy.vht_capa_mod_mask &&
2752 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
2753 sizeof(*rdev->wiphy.vht_capa_mod_mask),
2754 rdev->wiphy.vht_capa_mod_mask))
2755 goto nla_put_failure;
2757 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
2758 rdev->wiphy.perm_addr))
2759 goto nla_put_failure;
2761 if (!is_zero_ether_addr(rdev->wiphy.addr_mask) &&
2762 nla_put(msg, NL80211_ATTR_MAC_MASK, ETH_ALEN,
2763 rdev->wiphy.addr_mask))
2764 goto nla_put_failure;
2766 if (rdev->wiphy.n_addresses > 1) {
2769 attr = nla_nest_start(msg, NL80211_ATTR_MAC_ADDRS);
2771 goto nla_put_failure;
2773 for (i = 0; i < rdev->wiphy.n_addresses; i++)
2774 if (nla_put(msg, i + 1, ETH_ALEN,
2775 rdev->wiphy.addresses[i].addr))
2776 goto nla_put_failure;
2778 nla_nest_end(msg, attr);
2781 state->split_start++;
2784 if (nl80211_send_coalesce(msg, rdev))
2785 goto nla_put_failure;
2787 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
2788 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
2789 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
2790 goto nla_put_failure;
2792 if (rdev->wiphy.max_ap_assoc_sta &&
2793 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
2794 rdev->wiphy.max_ap_assoc_sta))
2795 goto nla_put_failure;
2797 state->split_start++;
2800 if (rdev->wiphy.n_vendor_commands) {
2801 const struct nl80211_vendor_cmd_info *info;
2802 struct nlattr *nested;
2804 nested = nla_nest_start_noflag(msg,
2805 NL80211_ATTR_VENDOR_DATA);
2807 goto nla_put_failure;
2809 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
2810 info = &rdev->wiphy.vendor_commands[i].info;
2811 if (nla_put(msg, i + 1, sizeof(*info), info))
2812 goto nla_put_failure;
2814 nla_nest_end(msg, nested);
2817 if (rdev->wiphy.n_vendor_events) {
2818 const struct nl80211_vendor_cmd_info *info;
2819 struct nlattr *nested;
2821 nested = nla_nest_start_noflag(msg,
2822 NL80211_ATTR_VENDOR_EVENTS);
2824 goto nla_put_failure;
2826 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
2827 info = &rdev->wiphy.vendor_events[i];
2828 if (nla_put(msg, i + 1, sizeof(*info), info))
2829 goto nla_put_failure;
2831 nla_nest_end(msg, nested);
2833 state->split_start++;
2836 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
2837 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
2838 rdev->wiphy.max_num_csa_counters))
2839 goto nla_put_failure;
2841 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2842 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
2843 goto nla_put_failure;
2845 if (rdev->wiphy.max_sched_scan_reqs &&
2846 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
2847 rdev->wiphy.max_sched_scan_reqs))
2848 goto nla_put_failure;
2850 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
2851 sizeof(rdev->wiphy.ext_features),
2852 rdev->wiphy.ext_features))
2853 goto nla_put_failure;
2855 if (rdev->wiphy.bss_select_support) {
2856 struct nlattr *nested;
2857 u32 bss_select_support = rdev->wiphy.bss_select_support;
2859 nested = nla_nest_start_noflag(msg,
2860 NL80211_ATTR_BSS_SELECT);
2862 goto nla_put_failure;
2865 while (bss_select_support) {
2866 if ((bss_select_support & 1) &&
2867 nla_put_flag(msg, i))
2868 goto nla_put_failure;
2870 bss_select_support >>= 1;
2872 nla_nest_end(msg, nested);
2875 state->split_start++;
2878 if (rdev->wiphy.num_iftype_ext_capab &&
2879 rdev->wiphy.iftype_ext_capab) {
2880 struct nlattr *nested_ext_capab, *nested;
2882 nested = nla_nest_start_noflag(msg,
2883 NL80211_ATTR_IFTYPE_EXT_CAPA);
2885 goto nla_put_failure;
2887 for (i = state->capa_start;
2888 i < rdev->wiphy.num_iftype_ext_capab; i++) {
2889 const struct wiphy_iftype_ext_capab *capab;
2891 capab = &rdev->wiphy.iftype_ext_capab[i];
2893 nested_ext_capab = nla_nest_start_noflag(msg,
2895 if (!nested_ext_capab ||
2896 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
2898 nla_put(msg, NL80211_ATTR_EXT_CAPA,
2899 capab->extended_capabilities_len,
2900 capab->extended_capabilities) ||
2901 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2902 capab->extended_capabilities_len,
2903 capab->extended_capabilities_mask))
2904 goto nla_put_failure;
2906 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO &&
2908 NL80211_ATTR_EML_CAPABILITY,
2909 capab->eml_capabilities) ||
2911 NL80211_ATTR_MLD_CAPA_AND_OPS,
2912 capab->mld_capa_and_ops)))
2913 goto nla_put_failure;
2915 nla_nest_end(msg, nested_ext_capab);
2919 nla_nest_end(msg, nested);
2920 if (i < rdev->wiphy.num_iftype_ext_capab) {
2921 state->capa_start = i + 1;
2926 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
2927 rdev->wiphy.nan_supported_bands))
2928 goto nla_put_failure;
2930 if (wiphy_ext_feature_isset(&rdev->wiphy,
2931 NL80211_EXT_FEATURE_TXQS)) {
2932 struct cfg80211_txq_stats txqstats = {};
2935 res = rdev_get_txq_stats(rdev, NULL, &txqstats);
2937 !nl80211_put_txq_stats(msg, &txqstats,
2938 NL80211_ATTR_TXQ_STATS))
2939 goto nla_put_failure;
2941 if (nla_put_u32(msg, NL80211_ATTR_TXQ_LIMIT,
2942 rdev->wiphy.txq_limit))
2943 goto nla_put_failure;
2944 if (nla_put_u32(msg, NL80211_ATTR_TXQ_MEMORY_LIMIT,
2945 rdev->wiphy.txq_memory_limit))
2946 goto nla_put_failure;
2947 if (nla_put_u32(msg, NL80211_ATTR_TXQ_QUANTUM,
2948 rdev->wiphy.txq_quantum))
2949 goto nla_put_failure;
2952 state->split_start++;
2955 if (nl80211_send_pmsr_capa(rdev, msg))
2956 goto nla_put_failure;
2958 state->split_start++;
2961 if (rdev->wiphy.akm_suites &&
2962 nla_put(msg, NL80211_ATTR_AKM_SUITES,
2963 sizeof(u32) * rdev->wiphy.n_akm_suites,
2964 rdev->wiphy.akm_suites))
2965 goto nla_put_failure;
2967 if (nl80211_put_iftype_akm_suites(rdev, msg))
2968 goto nla_put_failure;
2970 if (nl80211_put_tid_config_support(rdev, msg))
2971 goto nla_put_failure;
2972 state->split_start++;
2975 if (nl80211_put_sar_specs(rdev, msg))
2976 goto nla_put_failure;
2978 if (nl80211_put_mbssid_support(&rdev->wiphy, msg))
2979 goto nla_put_failure;
2981 if (nla_put_u16(msg, NL80211_ATTR_MAX_NUM_AKM_SUITES,
2982 rdev->wiphy.max_num_akm_suites))
2983 goto nla_put_failure;
2985 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO)
2986 nla_put_flag(msg, NL80211_ATTR_MLO_SUPPORT);
2988 if (rdev->wiphy.hw_timestamp_max_peers &&
2989 nla_put_u16(msg, NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS,
2990 rdev->wiphy.hw_timestamp_max_peers))
2991 goto nla_put_failure;
2994 state->split_start = 0;
2998 genlmsg_end(msg, hdr);
3002 genlmsg_cancel(msg, hdr);
3006 static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
3007 struct netlink_callback *cb,
3008 struct nl80211_dump_wiphy_state *state)
3010 struct nlattr **tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
3016 ret = nlmsg_parse_deprecated(cb->nlh,
3017 GENL_HDRLEN + nl80211_fam.hdrsize,
3018 tb, nl80211_fam.maxattr,
3019 nl80211_policy, NULL);
3020 /* ignore parse errors for backward compatibility */
3026 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
3027 if (tb[NL80211_ATTR_WIPHY])
3028 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
3029 if (tb[NL80211_ATTR_WDEV])
3030 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
3031 if (tb[NL80211_ATTR_IFINDEX]) {
3032 struct net_device *netdev;
3033 struct cfg80211_registered_device *rdev;
3034 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
3036 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
3041 if (netdev->ieee80211_ptr) {
3042 rdev = wiphy_to_rdev(
3043 netdev->ieee80211_ptr->wiphy);
3044 state->filter_wiphy = rdev->wiphy_idx;
3054 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
3057 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
3058 struct cfg80211_registered_device *rdev;
3062 state = kzalloc(sizeof(*state), GFP_KERNEL);
3067 state->filter_wiphy = -1;
3068 ret = nl80211_dump_wiphy_parse(skb, cb, state);
3074 cb->args[0] = (long)state;
3077 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3078 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3080 if (++idx <= state->start)
3082 if (state->filter_wiphy != -1 &&
3083 state->filter_wiphy != rdev->wiphy_idx)
3085 wiphy_lock(&rdev->wiphy);
3086 /* attempt to fit multiple wiphy data chunks into the skb */
3088 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
3090 NETLINK_CB(cb->skb).portid,
3092 NLM_F_MULTI, state);
3095 * If sending the wiphy data didn't fit (ENOBUFS
3096 * or EMSGSIZE returned), this SKB is still
3097 * empty (so it's not too big because another
3098 * wiphy dataset is already in the skb) and
3099 * we've not tried to adjust the dump allocation
3100 * yet ... then adjust the alloc size to be
3101 * bigger, and return 1 but with the empty skb.
3102 * This results in an empty message being RX'ed
3103 * in userspace, but that is ignored.
3105 * We can then retry with the larger buffer.
3107 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
3108 !skb->len && !state->split &&
3109 cb->min_dump_alloc < 4096) {
3110 cb->min_dump_alloc = 4096;
3111 state->split_start = 0;
3112 wiphy_unlock(&rdev->wiphy);
3119 } while (state->split_start > 0);
3120 wiphy_unlock(&rdev->wiphy);
3130 static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
3132 kfree((void *)cb->args[0]);
3136 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
3138 struct sk_buff *msg;
3139 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3140 struct nl80211_dump_wiphy_state state = {};
3142 msg = nlmsg_new(4096, GFP_KERNEL);
3146 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
3147 info->snd_portid, info->snd_seq, 0,
3153 return genlmsg_reply(msg, info);
3156 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
3157 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
3158 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
3159 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
3160 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
3161 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
3164 static int parse_txq_params(struct nlattr *tb[],
3165 struct ieee80211_txq_params *txq_params)
3169 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
3170 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
3171 !tb[NL80211_TXQ_ATTR_AIFS])
3174 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
3175 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
3176 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
3177 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
3178 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
3180 if (ac >= NL80211_NUM_ACS)
3182 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
3186 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
3189 * You can only set the channel explicitly for some interfaces,
3190 * most have their channel managed via their respective
3191 * "establish a connection" command (connect, join, ...)
3193 * For AP/GO and mesh mode, the channel can be set with the
3194 * channel userspace API, but is only stored and passed to the
3195 * low-level driver when the AP starts or the mesh is joined.
3196 * This is for backward compatibility, userspace can also give
3197 * the channel in the start-ap or join-mesh commands instead.
3199 * Monitors are special as they are normally slaved to
3200 * whatever else is going on, so they have their own special
3201 * operation to set the monitor channel if possible.
3204 wdev->iftype == NL80211_IFTYPE_AP ||
3205 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
3206 wdev->iftype == NL80211_IFTYPE_MONITOR ||
3207 wdev->iftype == NL80211_IFTYPE_P2P_GO;
3210 static int nl80211_parse_punct_bitmap(struct cfg80211_registered_device *rdev,
3211 struct genl_info *info,
3212 const struct cfg80211_chan_def *chandef,
3215 if (!wiphy_ext_feature_isset(&rdev->wiphy, NL80211_EXT_FEATURE_PUNCT))
3218 *punct_bitmap = nla_get_u32(info->attrs[NL80211_ATTR_PUNCT_BITMAP]);
3219 if (!cfg80211_valid_disable_subchannel_bitmap(punct_bitmap, chandef))
3225 int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
3226 struct genl_info *info,
3227 struct cfg80211_chan_def *chandef)
3229 struct netlink_ext_ack *extack = info->extack;
3230 struct nlattr **attrs = info->attrs;
3233 if (!attrs[NL80211_ATTR_WIPHY_FREQ]) {
3234 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ],
3235 "Frequency is missing");
3239 control_freq = MHZ_TO_KHZ(
3240 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3241 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
3243 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
3245 memset(chandef, 0, sizeof(*chandef));
3246 chandef->chan = ieee80211_get_channel_khz(&rdev->wiphy, control_freq);
3247 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
3248 chandef->center_freq1 = KHZ_TO_MHZ(control_freq);
3249 chandef->freq1_offset = control_freq % 1000;
3250 chandef->center_freq2 = 0;
3252 /* Primary channel not allowed */
3253 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED) {
3254 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ],
3255 "Channel is disabled");
3259 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
3260 enum nl80211_channel_type chantype;
3262 chantype = nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
3265 case NL80211_CHAN_NO_HT:
3266 case NL80211_CHAN_HT20:
3267 case NL80211_CHAN_HT40PLUS:
3268 case NL80211_CHAN_HT40MINUS:
3269 cfg80211_chandef_create(chandef, chandef->chan,
3271 /* user input for center_freq is incorrect */
3272 if (attrs[NL80211_ATTR_CENTER_FREQ1] &&
3273 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) {
3274 NL_SET_ERR_MSG_ATTR(extack,
3275 attrs[NL80211_ATTR_CENTER_FREQ1],
3276 "bad center frequency 1");
3279 /* center_freq2 must be zero */
3280 if (attrs[NL80211_ATTR_CENTER_FREQ2] &&
3281 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2])) {
3282 NL_SET_ERR_MSG_ATTR(extack,
3283 attrs[NL80211_ATTR_CENTER_FREQ2],
3284 "center frequency 2 can't be used");
3289 NL_SET_ERR_MSG_ATTR(extack,
3290 attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
3291 "invalid channel type");
3294 } else if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
3296 nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]);
3297 if (chandef->chan->band == NL80211_BAND_S1GHZ) {
3298 /* User input error for channel width doesn't match channel */
3299 if (chandef->width != ieee80211_s1g_channel_width(chandef->chan)) {
3300 NL_SET_ERR_MSG_ATTR(extack,
3301 attrs[NL80211_ATTR_CHANNEL_WIDTH],
3302 "bad channel width");
3306 if (attrs[NL80211_ATTR_CENTER_FREQ1]) {
3307 chandef->center_freq1 =
3308 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]);
3309 if (attrs[NL80211_ATTR_CENTER_FREQ1_OFFSET])
3310 chandef->freq1_offset = nla_get_u32(
3311 attrs[NL80211_ATTR_CENTER_FREQ1_OFFSET]);
3313 chandef->freq1_offset = 0;
3315 if (attrs[NL80211_ATTR_CENTER_FREQ2])
3316 chandef->center_freq2 =
3317 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]);
3320 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
3321 chandef->edmg.channels =
3322 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
3324 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
3325 chandef->edmg.bw_config =
3326 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
3328 chandef->edmg.bw_config = 0;
3329 chandef->edmg.channels = 0;
3332 if (!cfg80211_chandef_valid(chandef)) {
3333 NL_SET_ERR_MSG(extack, "invalid channel definition");
3337 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
3338 IEEE80211_CHAN_DISABLED)) {
3339 NL_SET_ERR_MSG(extack, "(extension) channel is disabled");
3343 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
3344 chandef->width == NL80211_CHAN_WIDTH_10) &&
3345 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) {
3346 NL_SET_ERR_MSG(extack, "5/10 MHz not supported");
3353 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
3354 struct net_device *dev,
3355 struct genl_info *info,
3358 struct cfg80211_chan_def chandef;
3360 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
3361 struct wireless_dev *wdev = NULL;
3362 int link_id = _link_id;
3365 wdev = dev->ieee80211_ptr;
3366 if (!nl80211_can_set_dev_channel(wdev))
3369 iftype = wdev->iftype;
3372 if (wdev && wdev->valid_links)
3377 result = nl80211_parse_chandef(rdev, info, &chandef);
3382 case NL80211_IFTYPE_AP:
3383 case NL80211_IFTYPE_P2P_GO:
3384 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
3387 if (wdev->links[link_id].ap.beacon_interval) {
3388 struct ieee80211_channel *cur_chan;
3390 if (!dev || !rdev->ops->set_ap_chanwidth ||
3391 !(rdev->wiphy.features &
3392 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE))
3395 /* Only allow dynamic channel width changes */
3396 cur_chan = wdev->links[link_id].ap.chandef.chan;
3397 if (chandef.chan != cur_chan)
3400 result = rdev_set_ap_chanwidth(rdev, dev, link_id,
3404 wdev->links[link_id].ap.chandef = chandef;
3406 wdev->u.ap.preset_chandef = chandef;
3409 case NL80211_IFTYPE_MESH_POINT:
3410 return cfg80211_set_mesh_channel(rdev, wdev, &chandef);
3411 case NL80211_IFTYPE_MONITOR:
3412 return cfg80211_set_monitor_channel(rdev, &chandef);
3420 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
3422 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3423 int link_id = nl80211_link_id_or_invalid(info->attrs);
3424 struct net_device *netdev = info->user_ptr[1];
3427 wdev_lock(netdev->ieee80211_ptr);
3428 ret = __nl80211_set_channel(rdev, netdev, info, link_id);
3429 wdev_unlock(netdev->ieee80211_ptr);
3434 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
3436 struct cfg80211_registered_device *rdev = NULL;
3437 struct net_device *netdev = NULL;
3438 struct wireless_dev *wdev;
3439 int result = 0, rem_txq_params = 0;
3440 struct nlattr *nl_txq_params;
3442 u8 retry_short = 0, retry_long = 0;
3443 u32 frag_threshold = 0, rts_threshold = 0;
3444 u8 coverage_class = 0;
3445 u32 txq_limit = 0, txq_memory_limit = 0, txq_quantum = 0;
3449 * Try to find the wiphy and netdev. Normally this
3450 * function shouldn't need the netdev, but this is
3451 * done for backward compatibility -- previously
3452 * setting the channel was done per wiphy, but now
3453 * it is per netdev. Previous userland like hostapd
3454 * also passed a netdev to set_wiphy, so that it is
3455 * possible to let that go to the right netdev!
3458 if (info->attrs[NL80211_ATTR_IFINDEX]) {
3459 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
3461 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
3462 if (netdev && netdev->ieee80211_ptr)
3463 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
3469 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
3473 return PTR_ERR(rdev);
3479 wdev = netdev->ieee80211_ptr;
3481 wiphy_lock(&rdev->wiphy);
3484 * end workaround code, by now the rdev is available
3485 * and locked, and wdev may or may not be NULL.
3488 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
3489 result = cfg80211_dev_rename(
3490 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
3496 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
3497 struct ieee80211_txq_params txq_params;
3498 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
3500 if (!rdev->ops->set_txq_params) {
3501 result = -EOPNOTSUPP;
3510 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3511 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
3516 if (!netif_running(netdev)) {
3521 nla_for_each_nested(nl_txq_params,
3522 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
3524 result = nla_parse_nested_deprecated(tb,
3525 NL80211_TXQ_ATTR_MAX,
3531 result = parse_txq_params(tb, &txq_params);
3535 txq_params.link_id =
3536 nl80211_link_id_or_invalid(info->attrs);
3538 wdev_lock(netdev->ieee80211_ptr);
3539 if (txq_params.link_id >= 0 &&
3540 !(netdev->ieee80211_ptr->valid_links &
3541 BIT(txq_params.link_id)))
3543 else if (txq_params.link_id >= 0 &&
3544 !netdev->ieee80211_ptr->valid_links)
3547 result = rdev_set_txq_params(rdev, netdev,
3549 wdev_unlock(netdev->ieee80211_ptr);
3555 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3556 int link_id = nl80211_link_id_or_invalid(info->attrs);
3560 result = __nl80211_set_channel(
3562 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
3566 result = __nl80211_set_channel(rdev, netdev, info, link_id);
3573 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
3574 struct wireless_dev *txp_wdev = wdev;
3575 enum nl80211_tx_power_setting type;
3578 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
3581 if (!rdev->ops->set_tx_power) {
3582 result = -EOPNOTSUPP;
3586 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
3587 type = nla_get_u32(info->attrs[idx]);
3589 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
3590 (type != NL80211_TX_POWER_AUTOMATIC)) {
3595 if (type != NL80211_TX_POWER_AUTOMATIC) {
3596 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
3597 mbm = nla_get_u32(info->attrs[idx]);
3600 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
3605 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
3606 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
3609 if ((!rdev->wiphy.available_antennas_tx &&
3610 !rdev->wiphy.available_antennas_rx) ||
3611 !rdev->ops->set_antenna) {
3612 result = -EOPNOTSUPP;
3616 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
3617 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
3619 /* reject antenna configurations which don't match the
3620 * available antenna masks, except for the "all" mask */
3621 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
3622 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) {
3627 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
3628 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
3630 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
3637 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
3638 retry_short = nla_get_u8(
3639 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
3641 changed |= WIPHY_PARAM_RETRY_SHORT;
3644 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
3645 retry_long = nla_get_u8(
3646 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
3648 changed |= WIPHY_PARAM_RETRY_LONG;
3651 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
3652 frag_threshold = nla_get_u32(
3653 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
3654 if (frag_threshold < 256) {
3659 if (frag_threshold != (u32) -1) {
3661 * Fragments (apart from the last one) are required to
3662 * have even length. Make the fragmentation code
3663 * simpler by stripping LSB should someone try to use
3664 * odd threshold value.
3666 frag_threshold &= ~0x1;
3668 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
3671 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
3672 rts_threshold = nla_get_u32(
3673 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
3674 changed |= WIPHY_PARAM_RTS_THRESHOLD;
3677 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3678 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
3683 coverage_class = nla_get_u8(
3684 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
3685 changed |= WIPHY_PARAM_COVERAGE_CLASS;
3688 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
3689 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION)) {
3690 result = -EOPNOTSUPP;
3694 changed |= WIPHY_PARAM_DYN_ACK;
3697 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) {
3698 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3699 NL80211_EXT_FEATURE_TXQS)) {
3700 result = -EOPNOTSUPP;
3703 txq_limit = nla_get_u32(
3704 info->attrs[NL80211_ATTR_TXQ_LIMIT]);
3705 changed |= WIPHY_PARAM_TXQ_LIMIT;
3708 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) {
3709 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3710 NL80211_EXT_FEATURE_TXQS)) {
3711 result = -EOPNOTSUPP;
3714 txq_memory_limit = nla_get_u32(
3715 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]);
3716 changed |= WIPHY_PARAM_TXQ_MEMORY_LIMIT;
3719 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) {
3720 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3721 NL80211_EXT_FEATURE_TXQS)) {
3722 result = -EOPNOTSUPP;
3725 txq_quantum = nla_get_u32(
3726 info->attrs[NL80211_ATTR_TXQ_QUANTUM]);
3727 changed |= WIPHY_PARAM_TXQ_QUANTUM;
3731 u8 old_retry_short, old_retry_long;
3732 u32 old_frag_threshold, old_rts_threshold;
3733 u8 old_coverage_class;
3734 u32 old_txq_limit, old_txq_memory_limit, old_txq_quantum;
3736 if (!rdev->ops->set_wiphy_params) {
3737 result = -EOPNOTSUPP;
3741 old_retry_short = rdev->wiphy.retry_short;
3742 old_retry_long = rdev->wiphy.retry_long;
3743 old_frag_threshold = rdev->wiphy.frag_threshold;
3744 old_rts_threshold = rdev->wiphy.rts_threshold;
3745 old_coverage_class = rdev->wiphy.coverage_class;
3746 old_txq_limit = rdev->wiphy.txq_limit;
3747 old_txq_memory_limit = rdev->wiphy.txq_memory_limit;
3748 old_txq_quantum = rdev->wiphy.txq_quantum;
3750 if (changed & WIPHY_PARAM_RETRY_SHORT)
3751 rdev->wiphy.retry_short = retry_short;
3752 if (changed & WIPHY_PARAM_RETRY_LONG)
3753 rdev->wiphy.retry_long = retry_long;
3754 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
3755 rdev->wiphy.frag_threshold = frag_threshold;
3756 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
3757 rdev->wiphy.rts_threshold = rts_threshold;
3758 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
3759 rdev->wiphy.coverage_class = coverage_class;
3760 if (changed & WIPHY_PARAM_TXQ_LIMIT)
3761 rdev->wiphy.txq_limit = txq_limit;
3762 if (changed & WIPHY_PARAM_TXQ_MEMORY_LIMIT)
3763 rdev->wiphy.txq_memory_limit = txq_memory_limit;
3764 if (changed & WIPHY_PARAM_TXQ_QUANTUM)
3765 rdev->wiphy.txq_quantum = txq_quantum;
3767 result = rdev_set_wiphy_params(rdev, changed);
3769 rdev->wiphy.retry_short = old_retry_short;
3770 rdev->wiphy.retry_long = old_retry_long;
3771 rdev->wiphy.frag_threshold = old_frag_threshold;
3772 rdev->wiphy.rts_threshold = old_rts_threshold;
3773 rdev->wiphy.coverage_class = old_coverage_class;
3774 rdev->wiphy.txq_limit = old_txq_limit;
3775 rdev->wiphy.txq_memory_limit = old_txq_memory_limit;
3776 rdev->wiphy.txq_quantum = old_txq_quantum;
3784 wiphy_unlock(&rdev->wiphy);
3788 int nl80211_send_chandef(struct sk_buff *msg, const struct cfg80211_chan_def *chandef)
3790 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3793 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
3794 chandef->chan->center_freq))
3796 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET,
3797 chandef->chan->freq_offset))
3799 switch (chandef->width) {
3800 case NL80211_CHAN_WIDTH_20_NOHT:
3801 case NL80211_CHAN_WIDTH_20:
3802 case NL80211_CHAN_WIDTH_40:
3803 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
3804 cfg80211_get_chandef_type(chandef)))
3810 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
3812 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
3814 if (chandef->center_freq2 &&
3815 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
3819 EXPORT_SYMBOL(nl80211_send_chandef);
3821 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
3822 struct cfg80211_registered_device *rdev,
3823 struct wireless_dev *wdev,
3824 enum nl80211_commands cmd)
3826 struct net_device *dev = wdev->netdev;
3829 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
3830 cmd != NL80211_CMD_DEL_INTERFACE &&
3831 cmd != NL80211_CMD_SET_INTERFACE);
3833 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3838 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3839 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
3840 goto nla_put_failure;
3842 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3843 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
3844 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
3845 NL80211_ATTR_PAD) ||
3846 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
3847 nla_put_u32(msg, NL80211_ATTR_GENERATION,
3848 rdev->devlist_generation ^
3849 (cfg80211_rdev_list_generation << 2)) ||
3850 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr))
3851 goto nla_put_failure;
3853 if (rdev->ops->get_channel && !wdev->valid_links) {
3854 struct cfg80211_chan_def chandef = {};
3857 ret = rdev_get_channel(rdev, wdev, 0, &chandef);
3858 if (ret == 0 && nl80211_send_chandef(msg, &chandef))
3859 goto nla_put_failure;
3862 if (rdev->ops->get_tx_power) {
3865 ret = rdev_get_tx_power(rdev, wdev, &dbm);
3867 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
3869 goto nla_put_failure;
3873 switch (wdev->iftype) {
3874 case NL80211_IFTYPE_AP:
3875 case NL80211_IFTYPE_P2P_GO:
3876 if (wdev->u.ap.ssid_len &&
3877 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ap.ssid_len,
3879 goto nla_put_failure_locked;
3881 case NL80211_IFTYPE_STATION:
3882 case NL80211_IFTYPE_P2P_CLIENT:
3883 if (wdev->u.client.ssid_len &&
3884 nla_put(msg, NL80211_ATTR_SSID, wdev->u.client.ssid_len,
3885 wdev->u.client.ssid))
3886 goto nla_put_failure_locked;
3888 case NL80211_IFTYPE_ADHOC:
3889 if (wdev->u.ibss.ssid_len &&
3890 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ibss.ssid_len,
3892 goto nla_put_failure_locked;
3900 if (rdev->ops->get_txq_stats) {
3901 struct cfg80211_txq_stats txqstats = {};
3902 int ret = rdev_get_txq_stats(rdev, wdev, &txqstats);
3905 !nl80211_put_txq_stats(msg, &txqstats,
3906 NL80211_ATTR_TXQ_STATS))
3907 goto nla_put_failure;
3910 if (wdev->valid_links) {
3911 unsigned int link_id;
3912 struct nlattr *links = nla_nest_start(msg,
3913 NL80211_ATTR_MLO_LINKS);
3916 goto nla_put_failure;
3918 for_each_valid_link(wdev, link_id) {
3919 struct nlattr *link = nla_nest_start(msg, link_id + 1);
3920 struct cfg80211_chan_def chandef = {};
3924 goto nla_put_failure;
3926 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id))
3927 goto nla_put_failure;
3928 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
3929 wdev->links[link_id].addr))
3930 goto nla_put_failure;
3932 ret = rdev_get_channel(rdev, wdev, link_id, &chandef);
3933 if (ret == 0 && nl80211_send_chandef(msg, &chandef))
3934 goto nla_put_failure;
3936 nla_nest_end(msg, link);
3939 nla_nest_end(msg, links);
3942 genlmsg_end(msg, hdr);
3945 nla_put_failure_locked:
3948 genlmsg_cancel(msg, hdr);
3952 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
3956 int wp_start = cb->args[0];
3957 int if_start = cb->args[1];
3958 int filter_wiphy = -1;
3959 struct cfg80211_registered_device *rdev;
3960 struct wireless_dev *wdev;
3965 struct nl80211_dump_wiphy_state state = {
3969 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
3973 filter_wiphy = state.filter_wiphy;
3976 * if filtering, set cb->args[2] to +1 since 0 is the default
3977 * value needed to determine that parsing is necessary.
3979 if (filter_wiphy >= 0)
3980 cb->args[2] = filter_wiphy + 1;
3983 } else if (cb->args[2] > 0) {
3984 filter_wiphy = cb->args[2] - 1;
3987 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3988 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3990 if (wp_idx < wp_start) {
3995 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
4000 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4001 if (if_idx < if_start) {
4005 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
4006 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4008 NL80211_CMD_NEW_INTERFACE) < 0) {
4017 cb->args[0] = wp_idx;
4018 cb->args[1] = if_idx;
4027 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
4029 struct sk_buff *msg;
4030 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4031 struct wireless_dev *wdev = info->user_ptr[1];
4033 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4037 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
4038 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
4043 return genlmsg_reply(msg, info);
4046 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
4047 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
4048 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
4049 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
4050 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
4051 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
4052 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
4055 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
4057 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
4065 if (nla_parse_nested_deprecated(flags, NL80211_MNTR_FLAG_MAX, nla, mntr_flags_policy, NULL))
4068 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
4070 *mntrflags |= (1<<flag);
4072 *mntrflags |= MONITOR_FLAG_CHANGED;
4077 static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
4078 enum nl80211_iftype type,
4079 struct genl_info *info,
4080 struct vif_params *params)
4082 bool change = false;
4085 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
4086 if (type != NL80211_IFTYPE_MONITOR)
4089 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
4097 if (params->flags & MONITOR_FLAG_ACTIVE &&
4098 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
4101 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
4102 const u8 *mumimo_groups;
4103 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
4105 if (type != NL80211_IFTYPE_MONITOR)
4108 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
4112 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
4114 /* bits 0 and 63 are reserved and must be zero */
4115 if ((mumimo_groups[0] & BIT(0)) ||
4116 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
4119 params->vht_mumimo_groups = mumimo_groups;
4123 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
4124 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
4126 if (type != NL80211_IFTYPE_MONITOR)
4129 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
4132 params->vht_mumimo_follow_addr =
4133 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
4137 return change ? 1 : 0;
4140 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
4141 struct net_device *netdev, u8 use_4addr,
4142 enum nl80211_iftype iftype)
4145 if (netdev && netif_is_bridge_port(netdev))
4151 case NL80211_IFTYPE_AP_VLAN:
4152 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
4155 case NL80211_IFTYPE_STATION:
4156 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
4166 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
4168 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4169 struct vif_params params;
4171 enum nl80211_iftype otype, ntype;
4172 struct net_device *dev = info->user_ptr[1];
4173 bool change = false;
4175 memset(¶ms, 0, sizeof(params));
4177 otype = ntype = dev->ieee80211_ptr->iftype;
4179 if (info->attrs[NL80211_ATTR_IFTYPE]) {
4180 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
4185 if (info->attrs[NL80211_ATTR_MESH_ID]) {
4186 struct wireless_dev *wdev = dev->ieee80211_ptr;
4188 if (ntype != NL80211_IFTYPE_MESH_POINT)
4190 if (netif_running(dev))
4194 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
4195 IEEE80211_MAX_MESH_ID_LEN);
4196 wdev->u.mesh.id_up_len =
4197 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
4198 memcpy(wdev->u.mesh.id,
4199 nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
4200 wdev->u.mesh.id_up_len);
4204 if (info->attrs[NL80211_ATTR_4ADDR]) {
4205 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
4207 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
4211 params.use_4addr = -1;
4214 err = nl80211_parse_mon_options(rdev, ntype, info, ¶ms);
4221 err = cfg80211_change_iface(rdev, dev, ntype, ¶ms);
4225 if (!err && params.use_4addr != -1)
4226 dev->ieee80211_ptr->use_4addr = params.use_4addr;
4228 if (change && !err) {
4229 struct wireless_dev *wdev = dev->ieee80211_ptr;
4231 nl80211_notify_iface(rdev, wdev, NL80211_CMD_SET_INTERFACE);
4237 static int _nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
4239 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4240 struct vif_params params;
4241 struct wireless_dev *wdev;
4242 struct sk_buff *msg;
4244 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
4246 memset(¶ms, 0, sizeof(params));
4248 if (!info->attrs[NL80211_ATTR_IFNAME])
4251 if (info->attrs[NL80211_ATTR_IFTYPE])
4252 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
4254 if (!rdev->ops->add_virtual_intf)
4257 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
4258 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
4259 info->attrs[NL80211_ATTR_MAC]) {
4260 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
4262 if (!is_valid_ether_addr(params.macaddr))
4263 return -EADDRNOTAVAIL;
4266 if (info->attrs[NL80211_ATTR_4ADDR]) {
4267 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
4268 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
4273 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0))
4276 err = nl80211_parse_mon_options(rdev, type, info, ¶ms);
4280 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4284 wdev = rdev_add_virtual_intf(rdev,
4285 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
4286 NET_NAME_USER, type, ¶ms);
4287 if (WARN_ON(!wdev)) {
4290 } else if (IS_ERR(wdev)) {
4292 return PTR_ERR(wdev);
4295 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
4296 wdev->owner_nlportid = info->snd_portid;
4299 case NL80211_IFTYPE_MESH_POINT:
4300 if (!info->attrs[NL80211_ATTR_MESH_ID])
4303 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
4304 IEEE80211_MAX_MESH_ID_LEN);
4305 wdev->u.mesh.id_up_len =
4306 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
4307 memcpy(wdev->u.mesh.id,
4308 nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
4309 wdev->u.mesh.id_up_len);
4312 case NL80211_IFTYPE_NAN:
4313 case NL80211_IFTYPE_P2P_DEVICE:
4315 * P2P Device and NAN do not have a netdev, so don't go
4316 * through the netdev notifier and must be added here
4318 cfg80211_init_wdev(wdev);
4319 cfg80211_register_wdev(rdev, wdev);
4325 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
4326 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
4331 return genlmsg_reply(msg, info);
4334 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
4336 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4339 /* to avoid failing a new interface creation due to pending removal */
4340 cfg80211_destroy_ifaces(rdev);
4342 wiphy_lock(&rdev->wiphy);
4343 ret = _nl80211_new_interface(skb, info);
4344 wiphy_unlock(&rdev->wiphy);
4349 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
4351 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4352 struct wireless_dev *wdev = info->user_ptr[1];
4354 if (!rdev->ops->del_virtual_intf)
4358 * We hold RTNL, so this is safe, without RTNL opencount cannot
4359 * reach 0, and thus the rdev cannot be deleted.
4361 * We need to do it for the dev_close(), since that will call
4362 * the netdev notifiers, and we need to acquire the mutex there
4363 * but don't know if we get there from here or from some other
4364 * place (e.g. "ip link set ... down").
4366 mutex_unlock(&rdev->wiphy.mtx);
4369 * If we remove a wireless device without a netdev then clear
4370 * user_ptr[1] so that nl80211_post_doit won't dereference it
4371 * to check if it needs to do dev_put(). Otherwise it crashes
4372 * since the wdev has been freed, unlike with a netdev where
4373 * we need the dev_put() for the netdev to really be freed.
4376 info->user_ptr[1] = NULL;
4378 dev_close(wdev->netdev);
4380 mutex_lock(&rdev->wiphy.mtx);
4382 return cfg80211_remove_virtual_intf(rdev, wdev);
4385 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
4387 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4388 struct net_device *dev = info->user_ptr[1];
4391 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
4394 if (!rdev->ops->set_noack_map)
4397 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
4399 return rdev_set_noack_map(rdev, dev, noack_map);
4402 static int nl80211_validate_key_link_id(struct genl_info *info,
4403 struct wireless_dev *wdev,
4404 int link_id, bool pairwise)
4407 if (link_id != -1) {
4408 GENL_SET_ERR_MSG(info,
4409 "link ID not allowed for pairwise key");
4416 if (wdev->valid_links) {
4417 if (link_id == -1) {
4418 GENL_SET_ERR_MSG(info,
4419 "link ID must for MLO group key");
4422 if (!(wdev->valid_links & BIT(link_id))) {
4423 GENL_SET_ERR_MSG(info, "invalid link ID for MLO group key");
4426 } else if (link_id != -1) {
4427 GENL_SET_ERR_MSG(info, "link ID not allowed for non-MLO group key");
4434 struct get_key_cookie {
4435 struct sk_buff *msg;
4440 static void get_key_callback(void *c, struct key_params *params)
4443 struct get_key_cookie *cookie = c;
4446 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
4447 params->key_len, params->key)) ||
4449 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
4450 params->seq_len, params->seq)) ||
4452 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
4454 goto nla_put_failure;
4456 key = nla_nest_start_noflag(cookie->msg, NL80211_ATTR_KEY);
4458 goto nla_put_failure;
4461 nla_put(cookie->msg, NL80211_KEY_DATA,
4462 params->key_len, params->key)) ||
4464 nla_put(cookie->msg, NL80211_KEY_SEQ,
4465 params->seq_len, params->seq)) ||
4467 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
4469 goto nla_put_failure;
4471 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
4472 goto nla_put_failure;
4474 nla_nest_end(cookie->msg, key);
4481 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
4483 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4485 struct net_device *dev = info->user_ptr[1];
4487 const u8 *mac_addr = NULL;
4489 struct get_key_cookie cookie = {
4493 struct sk_buff *msg;
4494 bool bigtk_support = false;
4495 int link_id = nl80211_link_id_or_invalid(info->attrs);
4496 struct wireless_dev *wdev = dev->ieee80211_ptr;
4498 if (wiphy_ext_feature_isset(&rdev->wiphy,
4499 NL80211_EXT_FEATURE_BEACON_PROTECTION))
4500 bigtk_support = true;
4502 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
4503 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
4504 wiphy_ext_feature_isset(&rdev->wiphy,
4505 NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT))
4506 bigtk_support = true;
4508 if (info->attrs[NL80211_ATTR_KEY_IDX]) {
4509 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
4511 if (key_idx >= 6 && key_idx <= 7 && !bigtk_support) {
4512 GENL_SET_ERR_MSG(info, "BIGTK not supported");
4517 if (info->attrs[NL80211_ATTR_MAC])
4518 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4520 pairwise = !!mac_addr;
4521 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
4522 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
4524 if (kt != NL80211_KEYTYPE_GROUP &&
4525 kt != NL80211_KEYTYPE_PAIRWISE)
4527 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
4530 if (!rdev->ops->get_key)
4533 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
4536 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4540 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4541 NL80211_CMD_NEW_KEY);
4543 goto nla_put_failure;
4546 cookie.idx = key_idx;
4548 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4549 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
4550 goto nla_put_failure;
4552 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
4553 goto nla_put_failure;
4555 err = nl80211_validate_key_link_id(info, wdev, link_id, pairwise);
4559 err = rdev_get_key(rdev, dev, link_id, key_idx, pairwise, mac_addr,
4560 &cookie, get_key_callback);
4566 goto nla_put_failure;
4568 genlmsg_end(msg, hdr);
4569 return genlmsg_reply(msg, info);
4578 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
4580 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4581 struct key_parse key;
4583 struct net_device *dev = info->user_ptr[1];
4584 int link_id = nl80211_link_id_or_invalid(info->attrs);
4585 struct wireless_dev *wdev = dev->ieee80211_ptr;
4587 err = nl80211_parse_key(info, &key);
4594 /* Only support setting default key and
4595 * Extended Key ID action NL80211_KEY_SET_TX.
4597 if (!key.def && !key.defmgmt && !key.defbeacon &&
4598 !(key.p.mode == NL80211_KEY_SET_TX))
4604 if (!rdev->ops->set_default_key) {
4609 err = nl80211_key_allowed(wdev);
4613 err = nl80211_validate_key_link_id(info, wdev, link_id, false);
4617 err = rdev_set_default_key(rdev, dev, link_id, key.idx,
4618 key.def_uni, key.def_multi);
4623 #ifdef CONFIG_CFG80211_WEXT
4624 wdev->wext.default_key = key.idx;
4626 } else if (key.defmgmt) {
4627 if (key.def_uni || !key.def_multi) {
4632 if (!rdev->ops->set_default_mgmt_key) {
4637 err = nl80211_key_allowed(wdev);
4641 err = nl80211_validate_key_link_id(info, wdev, link_id, false);
4645 err = rdev_set_default_mgmt_key(rdev, dev, link_id, key.idx);
4649 #ifdef CONFIG_CFG80211_WEXT
4650 wdev->wext.default_mgmt_key = key.idx;
4652 } else if (key.defbeacon) {
4653 if (key.def_uni || !key.def_multi) {
4658 if (!rdev->ops->set_default_beacon_key) {
4663 err = nl80211_key_allowed(wdev);
4667 err = nl80211_validate_key_link_id(info, wdev, link_id, false);
4671 err = rdev_set_default_beacon_key(rdev, dev, link_id, key.idx);
4674 } else if (key.p.mode == NL80211_KEY_SET_TX &&
4675 wiphy_ext_feature_isset(&rdev->wiphy,
4676 NL80211_EXT_FEATURE_EXT_KEY_ID)) {
4677 u8 *mac_addr = NULL;
4679 if (info->attrs[NL80211_ATTR_MAC])
4680 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4682 if (!mac_addr || key.idx < 0 || key.idx > 1) {
4687 err = nl80211_validate_key_link_id(info, wdev, link_id, true);
4691 err = rdev_add_key(rdev, dev, link_id, key.idx,
4692 NL80211_KEYTYPE_PAIRWISE,
4703 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
4705 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4707 struct net_device *dev = info->user_ptr[1];
4708 struct key_parse key;
4709 const u8 *mac_addr = NULL;
4710 int link_id = nl80211_link_id_or_invalid(info->attrs);
4711 struct wireless_dev *wdev = dev->ieee80211_ptr;
4713 err = nl80211_parse_key(info, &key);
4718 GENL_SET_ERR_MSG(info, "no key");
4722 if (info->attrs[NL80211_ATTR_MAC])
4723 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4725 if (key.type == -1) {
4727 key.type = NL80211_KEYTYPE_PAIRWISE;
4729 key.type = NL80211_KEYTYPE_GROUP;
4733 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
4734 key.type != NL80211_KEYTYPE_GROUP) {
4735 GENL_SET_ERR_MSG(info, "key type not pairwise or group");
4739 if (key.type == NL80211_KEYTYPE_GROUP &&
4740 info->attrs[NL80211_ATTR_VLAN_ID])
4741 key.p.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
4743 if (!rdev->ops->add_key)
4746 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
4747 key.type == NL80211_KEYTYPE_PAIRWISE,
4749 GENL_SET_ERR_MSG(info, "key setting validation failed");
4754 err = nl80211_key_allowed(wdev);
4756 GENL_SET_ERR_MSG(info, "key not allowed");
4759 err = nl80211_validate_key_link_id(info, wdev, link_id,
4760 key.type == NL80211_KEYTYPE_PAIRWISE);
4763 err = rdev_add_key(rdev, dev, link_id, key.idx,
4764 key.type == NL80211_KEYTYPE_PAIRWISE,
4767 GENL_SET_ERR_MSG(info, "key addition failed");
4774 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
4776 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4778 struct net_device *dev = info->user_ptr[1];
4779 u8 *mac_addr = NULL;
4780 struct key_parse key;
4781 int link_id = nl80211_link_id_or_invalid(info->attrs);
4782 struct wireless_dev *wdev = dev->ieee80211_ptr;
4784 err = nl80211_parse_key(info, &key);
4788 if (info->attrs[NL80211_ATTR_MAC])
4789 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4791 if (key.type == -1) {
4793 key.type = NL80211_KEYTYPE_PAIRWISE;
4795 key.type = NL80211_KEYTYPE_GROUP;
4799 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
4800 key.type != NL80211_KEYTYPE_GROUP)
4803 if (!cfg80211_valid_key_idx(rdev, key.idx,
4804 key.type == NL80211_KEYTYPE_PAIRWISE))
4807 if (!rdev->ops->del_key)
4811 err = nl80211_key_allowed(wdev);
4813 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
4814 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
4818 err = nl80211_validate_key_link_id(info, wdev, link_id,
4819 key.type == NL80211_KEYTYPE_PAIRWISE);
4822 err = rdev_del_key(rdev, dev, link_id, key.idx,
4823 key.type == NL80211_KEYTYPE_PAIRWISE,
4826 #ifdef CONFIG_CFG80211_WEXT
4828 if (key.idx == wdev->wext.default_key)
4829 wdev->wext.default_key = -1;
4830 else if (key.idx == wdev->wext.default_mgmt_key)
4831 wdev->wext.default_mgmt_key = -1;
4839 /* This function returns an error or the number of nested attributes */
4840 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
4842 struct nlattr *attr;
4843 int n_entries = 0, tmp;
4845 nla_for_each_nested(attr, nl_attr, tmp) {
4846 if (nla_len(attr) != ETH_ALEN)
4856 * This function parses ACL information and allocates memory for ACL data.
4857 * On successful return, the calling function is responsible to free the
4858 * ACL buffer returned by this function.
4860 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
4861 struct genl_info *info)
4863 enum nl80211_acl_policy acl_policy;
4864 struct nlattr *attr;
4865 struct cfg80211_acl_data *acl;
4866 int i = 0, n_entries, tmp;
4868 if (!wiphy->max_acl_mac_addrs)
4869 return ERR_PTR(-EOPNOTSUPP);
4871 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
4872 return ERR_PTR(-EINVAL);
4874 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
4875 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
4876 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
4877 return ERR_PTR(-EINVAL);
4879 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
4880 return ERR_PTR(-EINVAL);
4882 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
4884 return ERR_PTR(n_entries);
4886 if (n_entries > wiphy->max_acl_mac_addrs)
4887 return ERR_PTR(-ENOTSUPP);
4889 acl = kzalloc(struct_size(acl, mac_addrs, n_entries), GFP_KERNEL);
4891 return ERR_PTR(-ENOMEM);
4893 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
4894 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
4898 acl->n_acl_entries = n_entries;
4899 acl->acl_policy = acl_policy;
4904 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
4906 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4907 struct net_device *dev = info->user_ptr[1];
4908 struct cfg80211_acl_data *acl;
4911 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4912 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4915 if (!dev->ieee80211_ptr->links[0].ap.beacon_interval)
4918 acl = parse_acl_data(&rdev->wiphy, info);
4920 return PTR_ERR(acl);
4922 err = rdev_set_mac_acl(rdev, dev, acl);
4929 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
4930 u8 *rates, u8 rates_len)
4935 for (i = 0; i < rates_len; i++) {
4936 int rate = (rates[i] & 0x7f) * 5;
4939 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
4940 struct ieee80211_rate *srate =
4941 &sband->bitrates[ridx];
4942 if (rate == srate->bitrate) {
4947 if (ridx == sband->n_bitrates)
4948 return 0; /* rate not found */
4954 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
4955 u8 *rates, u8 rates_len,
4956 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
4960 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
4962 for (i = 0; i < rates_len; i++) {
4965 ridx = rates[i] / 8;
4966 rbit = BIT(rates[i] % 8);
4968 /* check validity */
4969 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
4972 /* check availability */
4973 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN);
4974 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
4983 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
4987 switch (vht_mcs_map) {
4988 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
4990 case IEEE80211_VHT_MCS_SUPPORT_0_7:
4993 case IEEE80211_VHT_MCS_SUPPORT_0_8:
4996 case IEEE80211_VHT_MCS_SUPPORT_0_9:
5006 static void vht_build_mcs_mask(u16 vht_mcs_map,
5007 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
5011 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
5012 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
5017 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
5018 struct nl80211_txrate_vht *txrate,
5019 u16 mcs[NL80211_VHT_NSS_MAX])
5021 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5022 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
5025 if (!sband->vht_cap.vht_supported)
5028 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
5030 /* Build vht_mcs_mask from VHT capabilities */
5031 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
5033 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
5034 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
5035 mcs[i] = txrate->mcs[i];
5043 static u16 he_mcs_map_to_mcs_mask(u8 he_mcs_map)
5045 switch (he_mcs_map) {
5046 case IEEE80211_HE_MCS_NOT_SUPPORTED:
5048 case IEEE80211_HE_MCS_SUPPORT_0_7:
5050 case IEEE80211_HE_MCS_SUPPORT_0_9:
5052 case IEEE80211_HE_MCS_SUPPORT_0_11:
5060 static void he_build_mcs_mask(u16 he_mcs_map,
5061 u16 he_mcs_mask[NL80211_HE_NSS_MAX])
5065 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) {
5066 he_mcs_mask[nss] = he_mcs_map_to_mcs_mask(he_mcs_map & 0x03);
5071 static u16 he_get_txmcsmap(struct genl_info *info, unsigned int link_id,
5072 const struct ieee80211_sta_he_cap *he_cap)
5074 struct net_device *dev = info->user_ptr[1];
5075 struct wireless_dev *wdev = dev->ieee80211_ptr;
5076 struct cfg80211_chan_def *chandef;
5079 chandef = wdev_chandef(wdev, link_id);
5082 * This is probably broken, but we never maintained
5083 * a chandef in these cases, so it always was.
5085 return le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
5088 switch (chandef->width) {
5089 case NL80211_CHAN_WIDTH_80P80:
5090 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80p80;
5092 case NL80211_CHAN_WIDTH_160:
5093 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_160;
5096 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80;
5100 return le16_to_cpu(tx_mcs);
5103 static bool he_set_mcs_mask(struct genl_info *info,
5104 struct wireless_dev *wdev,
5105 struct ieee80211_supported_band *sband,
5106 struct nl80211_txrate_he *txrate,
5107 u16 mcs[NL80211_HE_NSS_MAX],
5108 unsigned int link_id)
5110 const struct ieee80211_sta_he_cap *he_cap;
5111 u16 tx_mcs_mask[NL80211_HE_NSS_MAX] = {};
5115 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
5119 memset(mcs, 0, sizeof(u16) * NL80211_HE_NSS_MAX);
5121 tx_mcs_map = he_get_txmcsmap(info, link_id, he_cap);
5123 /* Build he_mcs_mask from HE capabilities */
5124 he_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
5126 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
5127 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
5128 mcs[i] = txrate->mcs[i];
5136 static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
5137 struct nlattr *attrs[],
5138 enum nl80211_attrs attr,
5139 struct cfg80211_bitrate_mask *mask,
5140 struct net_device *dev,
5141 bool default_all_enabled,
5142 unsigned int link_id)
5144 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
5145 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5146 struct wireless_dev *wdev = dev->ieee80211_ptr;
5148 struct nlattr *tx_rates;
5149 struct ieee80211_supported_band *sband;
5150 u16 vht_tx_mcs_map, he_tx_mcs_map;
5152 memset(mask, 0, sizeof(*mask));
5153 /* Default to all rates enabled */
5154 for (i = 0; i < NUM_NL80211_BANDS; i++) {
5155 const struct ieee80211_sta_he_cap *he_cap;
5157 if (!default_all_enabled)
5160 sband = rdev->wiphy.bands[i];
5165 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
5166 memcpy(mask->control[i].ht_mcs,
5167 sband->ht_cap.mcs.rx_mask,
5168 sizeof(mask->control[i].ht_mcs));
5170 if (sband->vht_cap.vht_supported) {
5171 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5172 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
5175 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
5179 he_tx_mcs_map = he_get_txmcsmap(info, link_id, he_cap);
5180 he_build_mcs_mask(he_tx_mcs_map, mask->control[i].he_mcs);
5182 mask->control[i].he_gi = 0xFF;
5183 mask->control[i].he_ltf = 0xFF;
5186 /* if no rates are given set it back to the defaults */
5190 /* The nested attribute uses enum nl80211_band as the index. This maps
5191 * directly to the enum nl80211_band values used in cfg80211.
5193 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
5194 nla_for_each_nested(tx_rates, attrs[attr], rem) {
5195 enum nl80211_band band = nla_type(tx_rates);
5198 if (band < 0 || band >= NUM_NL80211_BANDS)
5200 sband = rdev->wiphy.bands[band];
5203 err = nla_parse_nested_deprecated(tb, NL80211_TXRATE_MAX,
5205 nl80211_txattr_policy,
5209 if (tb[NL80211_TXRATE_LEGACY]) {
5210 mask->control[band].legacy = rateset_to_mask(
5212 nla_data(tb[NL80211_TXRATE_LEGACY]),
5213 nla_len(tb[NL80211_TXRATE_LEGACY]));
5214 if ((mask->control[band].legacy == 0) &&
5215 nla_len(tb[NL80211_TXRATE_LEGACY]))
5218 if (tb[NL80211_TXRATE_HT]) {
5219 if (!ht_rateset_to_mask(
5221 nla_data(tb[NL80211_TXRATE_HT]),
5222 nla_len(tb[NL80211_TXRATE_HT]),
5223 mask->control[band].ht_mcs))
5227 if (tb[NL80211_TXRATE_VHT]) {
5228 if (!vht_set_mcs_mask(
5230 nla_data(tb[NL80211_TXRATE_VHT]),
5231 mask->control[band].vht_mcs))
5235 if (tb[NL80211_TXRATE_GI]) {
5236 mask->control[band].gi =
5237 nla_get_u8(tb[NL80211_TXRATE_GI]);
5238 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
5241 if (tb[NL80211_TXRATE_HE] &&
5242 !he_set_mcs_mask(info, wdev, sband,
5243 nla_data(tb[NL80211_TXRATE_HE]),
5244 mask->control[band].he_mcs,
5248 if (tb[NL80211_TXRATE_HE_GI])
5249 mask->control[band].he_gi =
5250 nla_get_u8(tb[NL80211_TXRATE_HE_GI]);
5251 if (tb[NL80211_TXRATE_HE_LTF])
5252 mask->control[band].he_ltf =
5253 nla_get_u8(tb[NL80211_TXRATE_HE_LTF]);
5255 if (mask->control[band].legacy == 0) {
5256 /* don't allow empty legacy rates if HT, VHT or HE
5257 * are not even supported.
5259 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
5260 rdev->wiphy.bands[band]->vht_cap.vht_supported ||
5261 ieee80211_get_he_iftype_cap(sband, wdev->iftype)))
5264 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
5265 if (mask->control[band].ht_mcs[i])
5268 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
5269 if (mask->control[band].vht_mcs[i])
5272 for (i = 0; i < NL80211_HE_NSS_MAX; i++)
5273 if (mask->control[band].he_mcs[i])
5276 /* legacy and mcs rates may not be both empty */
5285 static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
5286 enum nl80211_band band,
5287 struct cfg80211_bitrate_mask *beacon_rate)
5289 u32 count_ht, count_vht, count_he, i;
5290 u32 rate = beacon_rate->control[band].legacy;
5292 /* Allow only one rate */
5293 if (hweight32(rate) > 1)
5297 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
5298 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
5300 } else if (beacon_rate->control[band].ht_mcs[i]) {
5305 if (count_ht && rate)
5310 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
5311 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
5313 } else if (beacon_rate->control[band].vht_mcs[i]) {
5318 if (count_vht && rate)
5323 for (i = 0; i < NL80211_HE_NSS_MAX; i++) {
5324 if (hweight16(beacon_rate->control[band].he_mcs[i]) > 1) {
5326 } else if (beacon_rate->control[band].he_mcs[i]) {
5331 if (count_he && rate)
5335 if ((count_ht && count_vht && count_he) ||
5336 (!rate && !count_ht && !count_vht && !count_he))
5340 !wiphy_ext_feature_isset(&rdev->wiphy,
5341 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
5344 !wiphy_ext_feature_isset(&rdev->wiphy,
5345 NL80211_EXT_FEATURE_BEACON_RATE_HT))
5348 !wiphy_ext_feature_isset(&rdev->wiphy,
5349 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
5352 !wiphy_ext_feature_isset(&rdev->wiphy,
5353 NL80211_EXT_FEATURE_BEACON_RATE_HE))
5359 static int nl80211_parse_mbssid_config(struct wiphy *wiphy,
5360 struct net_device *dev,
5361 struct nlattr *attrs,
5362 struct cfg80211_mbssid_config *config,
5365 struct nlattr *tb[NL80211_MBSSID_CONFIG_ATTR_MAX + 1];
5367 if (!wiphy->mbssid_max_interfaces)
5370 if (nla_parse_nested(tb, NL80211_MBSSID_CONFIG_ATTR_MAX, attrs, NULL,
5372 !tb[NL80211_MBSSID_CONFIG_ATTR_INDEX])
5375 config->ema = nla_get_flag(tb[NL80211_MBSSID_CONFIG_ATTR_EMA]);
5377 if (!wiphy->ema_max_profile_periodicity)
5380 if (num_elems > wiphy->ema_max_profile_periodicity)
5384 config->index = nla_get_u8(tb[NL80211_MBSSID_CONFIG_ATTR_INDEX]);
5385 if (config->index >= wiphy->mbssid_max_interfaces ||
5386 (!config->index && !num_elems))
5389 if (tb[NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX]) {
5391 nla_get_u32(tb[NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX]);
5393 if ((!config->index && tx_ifindex != dev->ifindex) ||
5394 (config->index && tx_ifindex == dev->ifindex))
5397 if (tx_ifindex != dev->ifindex) {
5398 struct net_device *tx_netdev =
5399 dev_get_by_index(wiphy_net(wiphy), tx_ifindex);
5401 if (!tx_netdev || !tx_netdev->ieee80211_ptr ||
5402 tx_netdev->ieee80211_ptr->wiphy != wiphy ||
5403 tx_netdev->ieee80211_ptr->iftype !=
5404 NL80211_IFTYPE_AP) {
5409 config->tx_wdev = tx_netdev->ieee80211_ptr;
5411 config->tx_wdev = dev->ieee80211_ptr;
5413 } else if (!config->index) {
5414 config->tx_wdev = dev->ieee80211_ptr;
5422 static struct cfg80211_mbssid_elems *
5423 nl80211_parse_mbssid_elems(struct wiphy *wiphy, struct nlattr *attrs)
5425 struct nlattr *nl_elems;
5426 struct cfg80211_mbssid_elems *elems;
5428 u8 i = 0, num_elems = 0;
5430 if (!wiphy->mbssid_max_interfaces)
5431 return ERR_PTR(-EINVAL);
5433 nla_for_each_nested(nl_elems, attrs, rem_elems)
5436 elems = kzalloc(struct_size(elems, elem, num_elems), GFP_KERNEL);
5438 return ERR_PTR(-ENOMEM);
5440 nla_for_each_nested(nl_elems, attrs, rem_elems) {
5441 elems->elem[i].data = nla_data(nl_elems);
5442 elems->elem[i].len = nla_len(nl_elems);
5445 elems->cnt = num_elems;
5449 static struct cfg80211_rnr_elems *
5450 nl80211_parse_rnr_elems(struct wiphy *wiphy, struct nlattr *attrs,
5451 struct netlink_ext_ack *extack)
5453 struct nlattr *nl_elems;
5454 struct cfg80211_rnr_elems *elems;
5456 u8 i = 0, num_elems = 0;
5458 nla_for_each_nested(nl_elems, attrs, rem_elems) {
5461 ret = validate_ie_attr(nl_elems, extack);
5463 return ERR_PTR(ret);
5468 elems = kzalloc(struct_size(elems, elem, num_elems), GFP_KERNEL);
5470 return ERR_PTR(-ENOMEM);
5472 nla_for_each_nested(nl_elems, attrs, rem_elems) {
5473 elems->elem[i].data = nla_data(nl_elems);
5474 elems->elem[i].len = nla_len(nl_elems);
5477 elems->cnt = num_elems;
5481 static int nl80211_parse_he_bss_color(struct nlattr *attrs,
5482 struct cfg80211_he_bss_color *he_bss_color)
5484 struct nlattr *tb[NL80211_HE_BSS_COLOR_ATTR_MAX + 1];
5487 err = nla_parse_nested(tb, NL80211_HE_BSS_COLOR_ATTR_MAX, attrs,
5488 he_bss_color_policy, NULL);
5492 if (!tb[NL80211_HE_BSS_COLOR_ATTR_COLOR])
5495 he_bss_color->color =
5496 nla_get_u8(tb[NL80211_HE_BSS_COLOR_ATTR_COLOR]);
5497 he_bss_color->enabled =
5498 !nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_DISABLED]);
5499 he_bss_color->partial =
5500 nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_PARTIAL]);
5505 static int nl80211_parse_beacon(struct cfg80211_registered_device *rdev,
5506 struct nlattr *attrs[],
5507 struct cfg80211_beacon_data *bcn,
5508 struct netlink_ext_ack *extack)
5510 bool haveinfo = false;
5513 memset(bcn, 0, sizeof(*bcn));
5515 bcn->link_id = nl80211_link_id(attrs);
5517 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
5518 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
5519 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
5525 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
5526 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
5527 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
5534 if (attrs[NL80211_ATTR_IE]) {
5535 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
5536 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
5539 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
5540 bcn->proberesp_ies =
5541 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
5542 bcn->proberesp_ies_len =
5543 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
5546 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
5547 bcn->assocresp_ies =
5548 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
5549 bcn->assocresp_ies_len =
5550 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
5553 if (attrs[NL80211_ATTR_PROBE_RESP]) {
5554 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
5555 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
5558 if (attrs[NL80211_ATTR_FTM_RESPONDER]) {
5559 struct nlattr *tb[NL80211_FTM_RESP_ATTR_MAX + 1];
5561 err = nla_parse_nested_deprecated(tb,
5562 NL80211_FTM_RESP_ATTR_MAX,
5563 attrs[NL80211_ATTR_FTM_RESPONDER],
5568 if (tb[NL80211_FTM_RESP_ATTR_ENABLED] &&
5569 wiphy_ext_feature_isset(&rdev->wiphy,
5570 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
5571 bcn->ftm_responder = 1;
5575 if (tb[NL80211_FTM_RESP_ATTR_LCI]) {
5576 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]);
5577 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]);
5580 if (tb[NL80211_FTM_RESP_ATTR_CIVICLOC]) {
5581 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
5582 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
5585 bcn->ftm_responder = -1;
5588 if (attrs[NL80211_ATTR_HE_BSS_COLOR]) {
5589 err = nl80211_parse_he_bss_color(attrs[NL80211_ATTR_HE_BSS_COLOR],
5590 &bcn->he_bss_color);
5593 bcn->he_bss_color_valid = true;
5596 if (attrs[NL80211_ATTR_MBSSID_ELEMS]) {
5597 struct cfg80211_mbssid_elems *mbssid =
5598 nl80211_parse_mbssid_elems(&rdev->wiphy,
5599 attrs[NL80211_ATTR_MBSSID_ELEMS]);
5602 return PTR_ERR(mbssid);
5604 bcn->mbssid_ies = mbssid;
5606 if (bcn->mbssid_ies && attrs[NL80211_ATTR_EMA_RNR_ELEMS]) {
5607 struct cfg80211_rnr_elems *rnr =
5608 nl80211_parse_rnr_elems(&rdev->wiphy,
5609 attrs[NL80211_ATTR_EMA_RNR_ELEMS],
5613 return PTR_ERR(rnr);
5615 if (rnr && rnr->cnt < bcn->mbssid_ies->cnt)
5625 static int nl80211_parse_he_obss_pd(struct nlattr *attrs,
5626 struct ieee80211_he_obss_pd *he_obss_pd)
5628 struct nlattr *tb[NL80211_HE_OBSS_PD_ATTR_MAX + 1];
5631 err = nla_parse_nested(tb, NL80211_HE_OBSS_PD_ATTR_MAX, attrs,
5632 he_obss_pd_policy, NULL);
5636 if (!tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL])
5639 he_obss_pd->sr_ctrl = nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL]);
5641 if (tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET])
5642 he_obss_pd->min_offset =
5643 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET]);
5644 if (tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET])
5645 he_obss_pd->max_offset =
5646 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET]);
5647 if (tb[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET])
5648 he_obss_pd->non_srg_max_offset =
5649 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET]);
5651 if (he_obss_pd->min_offset > he_obss_pd->max_offset)
5654 if (tb[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP])
5655 memcpy(he_obss_pd->bss_color_bitmap,
5656 nla_data(tb[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP]),
5657 sizeof(he_obss_pd->bss_color_bitmap));
5659 if (tb[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP])
5660 memcpy(he_obss_pd->partial_bssid_bitmap,
5661 nla_data(tb[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP]),
5662 sizeof(he_obss_pd->partial_bssid_bitmap));
5664 he_obss_pd->enable = true;
5669 static int nl80211_parse_fils_discovery(struct cfg80211_registered_device *rdev,
5670 struct nlattr *attrs,
5671 struct cfg80211_ap_settings *params)
5673 struct nlattr *tb[NL80211_FILS_DISCOVERY_ATTR_MAX + 1];
5675 struct cfg80211_fils_discovery *fd = ¶ms->fils_discovery;
5677 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5678 NL80211_EXT_FEATURE_FILS_DISCOVERY))
5681 ret = nla_parse_nested(tb, NL80211_FILS_DISCOVERY_ATTR_MAX, attrs,
5686 if (!tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN] ||
5687 !tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX] ||
5688 !tb[NL80211_FILS_DISCOVERY_ATTR_TMPL])
5691 fd->tmpl_len = nla_len(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]);
5692 fd->tmpl = nla_data(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]);
5693 fd->min_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN]);
5694 fd->max_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX]);
5700 nl80211_parse_unsol_bcast_probe_resp(struct cfg80211_registered_device *rdev,
5701 struct nlattr *attrs,
5702 struct cfg80211_ap_settings *params)
5704 struct nlattr *tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX + 1];
5706 struct cfg80211_unsol_bcast_probe_resp *presp =
5707 ¶ms->unsol_bcast_probe_resp;
5709 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5710 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP))
5713 ret = nla_parse_nested(tb, NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX,
5718 if (!tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT] ||
5719 !tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL])
5722 presp->tmpl = nla_data(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]);
5723 presp->tmpl_len = nla_len(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]);
5724 presp->interval = nla_get_u32(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT]);
5728 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
5729 const struct element *rates)
5736 for (i = 0; i < rates->datalen; i++) {
5737 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
5738 params->ht_required = true;
5739 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
5740 params->vht_required = true;
5741 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_HE_PHY)
5742 params->he_required = true;
5743 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_SAE_H2E)
5744 params->sae_h2e_required = true;
5749 * Since the nl80211 API didn't include, from the beginning, attributes about
5750 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
5751 * benefit of drivers that rebuild IEs in the firmware.
5753 static int nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
5755 const struct cfg80211_beacon_data *bcn = ¶ms->beacon;
5756 size_t ies_len = bcn->tail_len;
5757 const u8 *ies = bcn->tail;
5758 const struct element *rates;
5759 const struct element *cap;
5761 rates = cfg80211_find_elem(WLAN_EID_SUPP_RATES, ies, ies_len);
5762 nl80211_check_ap_rate_selectors(params, rates);
5764 rates = cfg80211_find_elem(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
5765 nl80211_check_ap_rate_selectors(params, rates);
5767 cap = cfg80211_find_elem(WLAN_EID_HT_CAPABILITY, ies, ies_len);
5768 if (cap && cap->datalen >= sizeof(*params->ht_cap))
5769 params->ht_cap = (void *)cap->data;
5770 cap = cfg80211_find_elem(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
5771 if (cap && cap->datalen >= sizeof(*params->vht_cap))
5772 params->vht_cap = (void *)cap->data;
5773 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_HE_CAPABILITY, ies, ies_len);
5774 if (cap && cap->datalen >= sizeof(*params->he_cap) + 1)
5775 params->he_cap = (void *)(cap->data + 1);
5776 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_HE_OPERATION, ies, ies_len);
5777 if (cap && cap->datalen >= sizeof(*params->he_oper) + 1)
5778 params->he_oper = (void *)(cap->data + 1);
5779 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_EHT_CAPABILITY, ies, ies_len);
5783 params->eht_cap = (void *)(cap->data + 1);
5784 if (!ieee80211_eht_capa_size_ok((const u8 *)params->he_cap,
5785 (const u8 *)params->eht_cap,
5786 cap->datalen - 1, true))
5789 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_EHT_OPERATION, ies, ies_len);
5793 params->eht_oper = (void *)(cap->data + 1);
5794 if (!ieee80211_eht_oper_size_ok((const u8 *)params->eht_oper,
5801 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
5802 struct cfg80211_ap_settings *params)
5804 struct wireless_dev *wdev;
5806 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
5807 if (wdev->iftype != NL80211_IFTYPE_AP &&
5808 wdev->iftype != NL80211_IFTYPE_P2P_GO)
5811 if (!wdev->u.ap.preset_chandef.chan)
5814 params->chandef = wdev->u.ap.preset_chandef;
5821 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
5822 enum nl80211_auth_type auth_type,
5823 enum nl80211_commands cmd)
5825 if (auth_type > NL80211_AUTHTYPE_MAX)
5829 case NL80211_CMD_AUTHENTICATE:
5830 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
5831 auth_type == NL80211_AUTHTYPE_SAE)
5833 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5834 NL80211_EXT_FEATURE_FILS_STA) &&
5835 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
5836 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
5837 auth_type == NL80211_AUTHTYPE_FILS_PK))
5840 case NL80211_CMD_CONNECT:
5841 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
5842 !wiphy_ext_feature_isset(&rdev->wiphy,
5843 NL80211_EXT_FEATURE_SAE_OFFLOAD) &&
5844 auth_type == NL80211_AUTHTYPE_SAE)
5847 /* FILS with SK PFS or PK not supported yet */
5848 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
5849 auth_type == NL80211_AUTHTYPE_FILS_PK)
5851 if (!wiphy_ext_feature_isset(
5853 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
5854 auth_type == NL80211_AUTHTYPE_FILS_SK)
5857 case NL80211_CMD_START_AP:
5858 if (!wiphy_ext_feature_isset(&rdev->wiphy,
5859 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP) &&
5860 auth_type == NL80211_AUTHTYPE_SAE)
5862 /* FILS not supported yet */
5863 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
5864 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
5865 auth_type == NL80211_AUTHTYPE_FILS_PK)
5873 static void nl80211_send_ap_started(struct wireless_dev *wdev,
5874 unsigned int link_id)
5876 struct wiphy *wiphy = wdev->wiphy;
5877 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
5878 struct sk_buff *msg;
5881 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5885 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_START_AP);
5889 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
5890 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
5891 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
5892 NL80211_ATTR_PAD) ||
5893 (wdev->u.ap.ssid_len &&
5894 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ap.ssid_len,
5895 wdev->u.ap.ssid)) ||
5896 (wdev->valid_links &&
5897 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)))
5900 genlmsg_end(msg, hdr);
5902 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
5903 NL80211_MCGRP_MLME, GFP_KERNEL);
5909 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
5911 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5912 unsigned int link_id = nl80211_link_id(info->attrs);
5913 struct net_device *dev = info->user_ptr[1];
5914 struct wireless_dev *wdev = dev->ieee80211_ptr;
5915 struct cfg80211_ap_settings *params;
5918 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5919 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5922 if (!rdev->ops->start_ap)
5925 if (wdev->links[link_id].ap.beacon_interval)
5928 /* these are required for START_AP */
5929 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
5930 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
5931 !info->attrs[NL80211_ATTR_BEACON_HEAD])
5934 params = kzalloc(sizeof(*params), GFP_KERNEL);
5938 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms->beacon,
5943 params->beacon_interval =
5944 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
5945 params->dtim_period =
5946 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
5948 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
5949 params->beacon_interval);
5954 * In theory, some of these attributes should be required here
5955 * but since they were not used when the command was originally
5956 * added, keep them optional for old user space programs to let
5957 * them continue to work with drivers that do not need the
5958 * additional information -- drivers must check!
5960 if (info->attrs[NL80211_ATTR_SSID]) {
5961 params->ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5963 nla_len(info->attrs[NL80211_ATTR_SSID]);
5964 if (params->ssid_len == 0) {
5969 if (wdev->u.ap.ssid_len &&
5970 (wdev->u.ap.ssid_len != params->ssid_len ||
5971 memcmp(wdev->u.ap.ssid, params->ssid, params->ssid_len))) {
5972 /* require identical SSID for MLO */
5976 } else if (wdev->valid_links) {
5977 /* require SSID for MLO */
5982 if (info->attrs[NL80211_ATTR_HIDDEN_SSID])
5983 params->hidden_ssid = nla_get_u32(
5984 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
5986 params->privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
5988 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
5989 params->auth_type = nla_get_u32(
5990 info->attrs[NL80211_ATTR_AUTH_TYPE]);
5991 if (!nl80211_valid_auth_type(rdev, params->auth_type,
5992 NL80211_CMD_START_AP)) {
5997 params->auth_type = NL80211_AUTHTYPE_AUTOMATIC;
5999 err = nl80211_crypto_settings(rdev, info, ¶ms->crypto,
6000 NL80211_MAX_NR_CIPHER_SUITES);
6004 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
6005 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER)) {
6009 params->inactivity_timeout = nla_get_u16(
6010 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
6013 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
6014 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
6018 params->p2p_ctwindow =
6019 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
6020 if (params->p2p_ctwindow != 0 &&
6021 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN)) {
6027 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
6030 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
6034 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
6035 params->p2p_opp_ps = tmp;
6036 if (params->p2p_opp_ps != 0 &&
6037 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS)) {
6043 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6044 err = nl80211_parse_chandef(rdev, info, ¶ms->chandef);
6047 } else if (wdev->valid_links) {
6048 /* with MLD need to specify the channel configuration */
6051 } else if (wdev->u.ap.preset_chandef.chan) {
6052 params->chandef = wdev->u.ap.preset_chandef;
6053 } else if (!nl80211_get_ap_channel(rdev, params)) {
6058 if (info->attrs[NL80211_ATTR_PUNCT_BITMAP]) {
6059 err = nl80211_parse_punct_bitmap(rdev, info,
6061 ¶ms->punct_bitmap);
6066 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms->chandef,
6074 if (info->attrs[NL80211_ATTR_TX_RATES]) {
6075 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
6076 NL80211_ATTR_TX_RATES,
6077 ¶ms->beacon_rate,
6078 dev, false, link_id);
6082 err = validate_beacon_tx_rate(rdev, params->chandef.chan->band,
6083 ¶ms->beacon_rate);
6088 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
6090 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
6091 switch (params->smps_mode) {
6092 case NL80211_SMPS_OFF:
6094 case NL80211_SMPS_STATIC:
6095 if (!(rdev->wiphy.features &
6096 NL80211_FEATURE_STATIC_SMPS)) {
6101 case NL80211_SMPS_DYNAMIC:
6102 if (!(rdev->wiphy.features &
6103 NL80211_FEATURE_DYNAMIC_SMPS)) {
6113 params->smps_mode = NL80211_SMPS_OFF;
6116 params->pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
6117 if (params->pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
6122 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
6123 params->acl = parse_acl_data(&rdev->wiphy, info);
6124 if (IS_ERR(params->acl)) {
6125 err = PTR_ERR(params->acl);
6131 params->twt_responder =
6132 nla_get_flag(info->attrs[NL80211_ATTR_TWT_RESPONDER]);
6134 if (info->attrs[NL80211_ATTR_HE_OBSS_PD]) {
6135 err = nl80211_parse_he_obss_pd(
6136 info->attrs[NL80211_ATTR_HE_OBSS_PD],
6137 ¶ms->he_obss_pd);
6142 if (info->attrs[NL80211_ATTR_FILS_DISCOVERY]) {
6143 err = nl80211_parse_fils_discovery(rdev,
6144 info->attrs[NL80211_ATTR_FILS_DISCOVERY],
6150 if (info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP]) {
6151 err = nl80211_parse_unsol_bcast_probe_resp(
6152 rdev, info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP],
6158 if (info->attrs[NL80211_ATTR_MBSSID_CONFIG]) {
6159 err = nl80211_parse_mbssid_config(&rdev->wiphy, dev,
6160 info->attrs[NL80211_ATTR_MBSSID_CONFIG],
6161 ¶ms->mbssid_config,
6162 params->beacon.mbssid_ies ?
6163 params->beacon.mbssid_ies->cnt :
6169 if (!params->mbssid_config.ema && params->beacon.rnr_ies) {
6174 err = nl80211_calculate_ap_params(params);
6178 if (info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS])
6179 params->flags = nla_get_u32(
6180 info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS]);
6181 else if (info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])
6182 params->flags |= NL80211_AP_SETTINGS_EXTERNAL_AUTH_SUPPORT;
6184 if (wdev->conn_owner_nlportid &&
6185 info->attrs[NL80211_ATTR_SOCKET_OWNER] &&
6186 wdev->conn_owner_nlportid != info->snd_portid) {
6191 /* FIXME: validate MLO/link-id against driver capabilities */
6193 err = rdev_start_ap(rdev, dev, params);
6195 wdev->links[link_id].ap.beacon_interval = params->beacon_interval;
6196 wdev->links[link_id].ap.chandef = params->chandef;
6197 wdev->u.ap.ssid_len = params->ssid_len;
6198 memcpy(wdev->u.ap.ssid, params->ssid,
6201 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
6202 wdev->conn_owner_nlportid = info->snd_portid;
6204 nl80211_send_ap_started(wdev, link_id);
6210 kfree(params->beacon.mbssid_ies);
6211 if (params->mbssid_config.tx_wdev &&
6212 params->mbssid_config.tx_wdev->netdev &&
6213 params->mbssid_config.tx_wdev->netdev != dev)
6214 dev_put(params->mbssid_config.tx_wdev->netdev);
6215 kfree(params->beacon.rnr_ies);
6221 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
6223 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6224 unsigned int link_id = nl80211_link_id(info->attrs);
6225 struct net_device *dev = info->user_ptr[1];
6226 struct wireless_dev *wdev = dev->ieee80211_ptr;
6227 struct cfg80211_beacon_data params;
6230 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6231 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6234 if (!rdev->ops->change_beacon)
6237 if (!wdev->links[link_id].ap.beacon_interval)
6240 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms, info->extack);
6245 err = rdev_change_beacon(rdev, dev, ¶ms);
6249 kfree(params.mbssid_ies);
6250 kfree(params.rnr_ies);
6254 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
6256 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6257 unsigned int link_id = nl80211_link_id(info->attrs);
6258 struct net_device *dev = info->user_ptr[1];
6260 return cfg80211_stop_ap(rdev, dev, link_id, false);
6263 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
6264 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
6265 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
6266 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
6267 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
6268 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
6269 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
6272 static int parse_station_flags(struct genl_info *info,
6273 enum nl80211_iftype iftype,
6274 struct station_parameters *params)
6276 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
6281 * Try parsing the new attribute first so userspace
6282 * can specify both for older kernels.
6284 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
6286 struct nl80211_sta_flag_update *sta_flags;
6288 sta_flags = nla_data(nla);
6289 params->sta_flags_mask = sta_flags->mask;
6290 params->sta_flags_set = sta_flags->set;
6291 params->sta_flags_set &= params->sta_flags_mask;
6292 if ((params->sta_flags_mask |
6293 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
6298 /* if present, parse the old attribute */
6300 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
6304 if (nla_parse_nested_deprecated(flags, NL80211_STA_FLAG_MAX, nla, sta_flags_policy, info->extack))
6308 * Only allow certain flags for interface types so that
6309 * other attributes are silently ignored. Remember that
6310 * this is backward compatibility code with old userspace
6311 * and shouldn't be hit in other cases anyway.
6314 case NL80211_IFTYPE_AP:
6315 case NL80211_IFTYPE_AP_VLAN:
6316 case NL80211_IFTYPE_P2P_GO:
6317 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
6318 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
6319 BIT(NL80211_STA_FLAG_WME) |
6320 BIT(NL80211_STA_FLAG_MFP);
6322 case NL80211_IFTYPE_P2P_CLIENT:
6323 case NL80211_IFTYPE_STATION:
6324 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
6325 BIT(NL80211_STA_FLAG_TDLS_PEER);
6327 case NL80211_IFTYPE_MESH_POINT:
6328 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6329 BIT(NL80211_STA_FLAG_MFP) |
6330 BIT(NL80211_STA_FLAG_AUTHORIZED);
6336 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
6338 params->sta_flags_set |= (1<<flag);
6340 /* no longer support new API additions in old API */
6341 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
6349 bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info, int attr)
6351 struct nlattr *rate;
6354 enum nl80211_rate_info rate_flg;
6356 rate = nla_nest_start_noflag(msg, attr);
6360 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
6361 bitrate = cfg80211_calculate_bitrate(info);
6362 /* report 16-bit bitrate only if we can */
6363 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
6365 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
6367 if (bitrate_compat > 0 &&
6368 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
6372 case RATE_INFO_BW_1:
6373 rate_flg = NL80211_RATE_INFO_1_MHZ_WIDTH;
6375 case RATE_INFO_BW_2:
6376 rate_flg = NL80211_RATE_INFO_2_MHZ_WIDTH;
6378 case RATE_INFO_BW_4:
6379 rate_flg = NL80211_RATE_INFO_4_MHZ_WIDTH;
6381 case RATE_INFO_BW_5:
6382 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
6384 case RATE_INFO_BW_8:
6385 rate_flg = NL80211_RATE_INFO_8_MHZ_WIDTH;
6387 case RATE_INFO_BW_10:
6388 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
6390 case RATE_INFO_BW_16:
6391 rate_flg = NL80211_RATE_INFO_16_MHZ_WIDTH;
6396 case RATE_INFO_BW_20:
6399 case RATE_INFO_BW_40:
6400 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
6402 case RATE_INFO_BW_80:
6403 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
6405 case RATE_INFO_BW_160:
6406 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
6408 case RATE_INFO_BW_HE_RU:
6410 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS));
6412 case RATE_INFO_BW_320:
6413 rate_flg = NL80211_RATE_INFO_320_MHZ_WIDTH;
6415 case RATE_INFO_BW_EHT_RU:
6417 WARN_ON(!(info->flags & RATE_INFO_FLAGS_EHT_MCS));
6421 if (rate_flg && nla_put_flag(msg, rate_flg))
6424 if (info->flags & RATE_INFO_FLAGS_MCS) {
6425 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
6427 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
6428 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
6430 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
6431 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
6433 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
6435 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
6436 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
6438 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) {
6439 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs))
6441 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss))
6443 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi))
6445 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm))
6447 if (info->bw == RATE_INFO_BW_HE_RU &&
6448 nla_put_u8(msg, NL80211_RATE_INFO_HE_RU_ALLOC,
6451 } else if (info->flags & RATE_INFO_FLAGS_S1G_MCS) {
6452 if (nla_put_u8(msg, NL80211_RATE_INFO_S1G_MCS, info->mcs))
6454 if (nla_put_u8(msg, NL80211_RATE_INFO_S1G_NSS, info->nss))
6456 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
6457 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
6459 } else if (info->flags & RATE_INFO_FLAGS_EHT_MCS) {
6460 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_MCS, info->mcs))
6462 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_NSS, info->nss))
6464 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_GI, info->eht_gi))
6466 if (info->bw == RATE_INFO_BW_EHT_RU &&
6467 nla_put_u8(msg, NL80211_RATE_INFO_EHT_RU_ALLOC,
6468 info->eht_ru_alloc))
6472 nla_nest_end(msg, rate);
6476 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
6485 attr = nla_nest_start_noflag(msg, id);
6489 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
6490 if (!(mask & BIT(i)))
6493 if (nla_put_u8(msg, i, signal[i]))
6497 nla_nest_end(msg, attr);
6502 static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
6504 struct cfg80211_registered_device *rdev,
6505 struct net_device *dev,
6506 const u8 *mac_addr, struct station_info *sinfo)
6509 struct nlattr *sinfoattr, *bss_param;
6511 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
6513 cfg80211_sinfo_release_content(sinfo);
6517 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6518 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
6519 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
6520 goto nla_put_failure;
6522 sinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_STA_INFO);
6524 goto nla_put_failure;
6526 #define PUT_SINFO(attr, memb, type) do { \
6527 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
6528 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
6529 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
6531 goto nla_put_failure; \
6533 #define PUT_SINFO_U64(attr, memb) do { \
6534 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
6535 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
6536 sinfo->memb, NL80211_STA_INFO_PAD)) \
6537 goto nla_put_failure; \
6540 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
6541 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
6542 PUT_SINFO_U64(ASSOC_AT_BOOTTIME, assoc_at);
6544 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
6545 BIT_ULL(NL80211_STA_INFO_RX_BYTES64)) &&
6546 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
6547 (u32)sinfo->rx_bytes))
6548 goto nla_put_failure;
6550 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
6551 BIT_ULL(NL80211_STA_INFO_TX_BYTES64)) &&
6552 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
6553 (u32)sinfo->tx_bytes))
6554 goto nla_put_failure;
6556 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
6557 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
6558 PUT_SINFO(LLID, llid, u16);
6559 PUT_SINFO(PLID, plid, u16);
6560 PUT_SINFO(PLINK_STATE, plink_state, u8);
6561 PUT_SINFO_U64(RX_DURATION, rx_duration);
6562 PUT_SINFO_U64(TX_DURATION, tx_duration);
6564 if (wiphy_ext_feature_isset(&rdev->wiphy,
6565 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
6566 PUT_SINFO(AIRTIME_WEIGHT, airtime_weight, u16);
6568 switch (rdev->wiphy.signal_type) {
6569 case CFG80211_SIGNAL_TYPE_MBM:
6570 PUT_SINFO(SIGNAL, signal, u8);
6571 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
6576 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
6577 if (!nl80211_put_signal(msg, sinfo->chains,
6578 sinfo->chain_signal,
6579 NL80211_STA_INFO_CHAIN_SIGNAL))
6580 goto nla_put_failure;
6582 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
6583 if (!nl80211_put_signal(msg, sinfo->chains,
6584 sinfo->chain_signal_avg,
6585 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
6586 goto nla_put_failure;
6588 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
6589 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
6590 NL80211_STA_INFO_TX_BITRATE))
6591 goto nla_put_failure;
6593 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
6594 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
6595 NL80211_STA_INFO_RX_BITRATE))
6596 goto nla_put_failure;
6599 PUT_SINFO(RX_PACKETS, rx_packets, u32);
6600 PUT_SINFO(TX_PACKETS, tx_packets, u32);
6601 PUT_SINFO(TX_RETRIES, tx_retries, u32);
6602 PUT_SINFO(TX_FAILED, tx_failed, u32);
6603 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
6604 PUT_SINFO(AIRTIME_LINK_METRIC, airtime_link_metric, u32);
6605 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
6606 PUT_SINFO(LOCAL_PM, local_pm, u32);
6607 PUT_SINFO(PEER_PM, peer_pm, u32);
6608 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
6609 PUT_SINFO(CONNECTED_TO_GATE, connected_to_gate, u8);
6610 PUT_SINFO(CONNECTED_TO_AS, connected_to_as, u8);
6612 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
6613 bss_param = nla_nest_start_noflag(msg,
6614 NL80211_STA_INFO_BSS_PARAM);
6616 goto nla_put_failure;
6618 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
6619 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
6620 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
6621 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
6622 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
6623 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
6624 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
6625 sinfo->bss_param.dtim_period) ||
6626 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
6627 sinfo->bss_param.beacon_interval))
6628 goto nla_put_failure;
6630 nla_nest_end(msg, bss_param);
6632 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) &&
6633 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
6634 sizeof(struct nl80211_sta_flag_update),
6636 goto nla_put_failure;
6638 PUT_SINFO_U64(T_OFFSET, t_offset);
6639 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
6640 PUT_SINFO_U64(BEACON_RX, rx_beacon);
6641 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
6642 PUT_SINFO(RX_MPDUS, rx_mpdu_count, u32);
6643 PUT_SINFO(FCS_ERROR_COUNT, fcs_err_count, u32);
6644 if (wiphy_ext_feature_isset(&rdev->wiphy,
6645 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT)) {
6646 PUT_SINFO(ACK_SIGNAL, ack_signal, u8);
6647 PUT_SINFO(ACK_SIGNAL_AVG, avg_ack_signal, s8);
6651 #undef PUT_SINFO_U64
6653 if (sinfo->pertid) {
6654 struct nlattr *tidsattr;
6657 tidsattr = nla_nest_start_noflag(msg,
6658 NL80211_STA_INFO_TID_STATS);
6660 goto nla_put_failure;
6662 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
6663 struct cfg80211_tid_stats *tidstats;
6664 struct nlattr *tidattr;
6666 tidstats = &sinfo->pertid[tid];
6668 if (!tidstats->filled)
6671 tidattr = nla_nest_start_noflag(msg, tid + 1);
6673 goto nla_put_failure;
6675 #define PUT_TIDVAL_U64(attr, memb) do { \
6676 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
6677 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
6678 tidstats->memb, NL80211_TID_STATS_PAD)) \
6679 goto nla_put_failure; \
6682 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
6683 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
6684 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
6685 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
6687 #undef PUT_TIDVAL_U64
6688 if ((tidstats->filled &
6689 BIT(NL80211_TID_STATS_TXQ_STATS)) &&
6690 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
6691 NL80211_TID_STATS_TXQ_STATS))
6692 goto nla_put_failure;
6694 nla_nest_end(msg, tidattr);
6697 nla_nest_end(msg, tidsattr);
6700 nla_nest_end(msg, sinfoattr);
6702 if (sinfo->assoc_req_ies_len &&
6703 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
6704 sinfo->assoc_req_ies))
6705 goto nla_put_failure;
6707 if (sinfo->assoc_resp_ies_len &&
6708 nla_put(msg, NL80211_ATTR_RESP_IE, sinfo->assoc_resp_ies_len,
6709 sinfo->assoc_resp_ies))
6710 goto nla_put_failure;
6712 if (sinfo->mlo_params_valid) {
6713 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID,
6714 sinfo->assoc_link_id))
6715 goto nla_put_failure;
6717 if (!is_zero_ether_addr(sinfo->mld_addr) &&
6718 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN,
6720 goto nla_put_failure;
6723 cfg80211_sinfo_release_content(sinfo);
6724 genlmsg_end(msg, hdr);
6728 cfg80211_sinfo_release_content(sinfo);
6729 genlmsg_cancel(msg, hdr);
6733 static int nl80211_dump_station(struct sk_buff *skb,
6734 struct netlink_callback *cb)
6736 struct station_info sinfo;
6737 struct cfg80211_registered_device *rdev;
6738 struct wireless_dev *wdev;
6739 u8 mac_addr[ETH_ALEN];
6740 int sta_idx = cb->args[2];
6743 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL);
6746 /* nl80211_prepare_wdev_dump acquired it in the successful case */
6747 __acquire(&rdev->wiphy.mtx);
6749 if (!wdev->netdev) {
6754 if (!rdev->ops->dump_station) {
6760 memset(&sinfo, 0, sizeof(sinfo));
6761 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
6768 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
6769 NETLINK_CB(cb->skb).portid,
6770 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6771 rdev, wdev->netdev, mac_addr,
6779 cb->args[2] = sta_idx;
6782 wiphy_unlock(&rdev->wiphy);
6787 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
6789 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6790 struct net_device *dev = info->user_ptr[1];
6791 struct station_info sinfo;
6792 struct sk_buff *msg;
6793 u8 *mac_addr = NULL;
6796 memset(&sinfo, 0, sizeof(sinfo));
6798 if (!info->attrs[NL80211_ATTR_MAC])
6801 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6803 if (!rdev->ops->get_station)
6806 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
6810 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6812 cfg80211_sinfo_release_content(&sinfo);
6816 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
6817 info->snd_portid, info->snd_seq, 0,
6818 rdev, dev, mac_addr, &sinfo) < 0) {
6823 return genlmsg_reply(msg, info);
6826 int cfg80211_check_station_change(struct wiphy *wiphy,
6827 struct station_parameters *params,
6828 enum cfg80211_station_type statype)
6830 if (params->listen_interval != -1 &&
6831 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
6834 if (params->support_p2p_ps != -1 &&
6835 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
6839 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
6840 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
6843 /* When you run into this, adjust the code below for the new flag */
6844 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
6847 case CFG80211_STA_MESH_PEER_KERNEL:
6848 case CFG80211_STA_MESH_PEER_USER:
6850 * No ignoring the TDLS flag here -- the userspace mesh
6851 * code doesn't have the bug of including TDLS in the
6854 if (params->sta_flags_mask &
6855 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6856 BIT(NL80211_STA_FLAG_MFP) |
6857 BIT(NL80211_STA_FLAG_AUTHORIZED)))
6860 case CFG80211_STA_TDLS_PEER_SETUP:
6861 case CFG80211_STA_TDLS_PEER_ACTIVE:
6862 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
6864 /* ignore since it can't change */
6865 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
6868 /* disallow mesh-specific things */
6869 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
6871 if (params->local_pm)
6873 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
6877 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
6878 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
6879 /* TDLS can't be set, ... */
6880 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
6883 * ... but don't bother the driver with it. This works around
6884 * a hostapd/wpa_supplicant issue -- it always includes the
6885 * TLDS_PEER flag in the mask even for AP mode.
6887 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
6890 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
6891 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
6892 /* reject other things that can't change */
6893 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
6895 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
6897 if (params->link_sta_params.supported_rates)
6899 if (params->ext_capab || params->link_sta_params.ht_capa ||
6900 params->link_sta_params.vht_capa ||
6901 params->link_sta_params.he_capa ||
6902 params->link_sta_params.eht_capa)
6906 if (statype != CFG80211_STA_AP_CLIENT &&
6907 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
6913 case CFG80211_STA_AP_MLME_CLIENT:
6914 /* Use this only for authorizing/unauthorizing a station */
6915 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
6918 case CFG80211_STA_AP_CLIENT:
6919 case CFG80211_STA_AP_CLIENT_UNASSOC:
6920 /* accept only the listed bits */
6921 if (params->sta_flags_mask &
6922 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
6923 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6924 BIT(NL80211_STA_FLAG_ASSOCIATED) |
6925 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
6926 BIT(NL80211_STA_FLAG_WME) |
6927 BIT(NL80211_STA_FLAG_MFP)))
6930 /* but authenticated/associated only if driver handles it */
6931 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
6932 params->sta_flags_mask &
6933 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6934 BIT(NL80211_STA_FLAG_ASSOCIATED)))
6937 case CFG80211_STA_IBSS:
6938 case CFG80211_STA_AP_STA:
6939 /* reject any changes other than AUTHORIZED */
6940 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
6943 case CFG80211_STA_TDLS_PEER_SETUP:
6944 /* reject any changes other than AUTHORIZED or WME */
6945 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
6946 BIT(NL80211_STA_FLAG_WME)))
6948 /* force (at least) rates when authorizing */
6949 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
6950 !params->link_sta_params.supported_rates)
6953 case CFG80211_STA_TDLS_PEER_ACTIVE:
6954 /* reject any changes */
6956 case CFG80211_STA_MESH_PEER_KERNEL:
6957 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
6960 case CFG80211_STA_MESH_PEER_USER:
6961 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
6962 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
6968 * Older kernel versions ignored this attribute entirely, so don't
6969 * reject attempts to update it but mark it as unused instead so the
6970 * driver won't look at the data.
6972 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
6973 statype != CFG80211_STA_TDLS_PEER_SETUP)
6974 params->link_sta_params.opmode_notif_used = false;
6978 EXPORT_SYMBOL(cfg80211_check_station_change);
6981 * Get vlan interface making sure it is running and on the right wiphy.
6983 static struct net_device *get_vlan(struct genl_info *info,
6984 struct cfg80211_registered_device *rdev)
6986 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
6987 struct net_device *v;
6993 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
6995 return ERR_PTR(-ENODEV);
6997 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
7002 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
7003 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
7004 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
7009 if (!netif_running(v)) {
7017 return ERR_PTR(ret);
7020 static int nl80211_parse_sta_wme(struct genl_info *info,
7021 struct station_parameters *params)
7023 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
7027 /* parse WME attributes if present */
7028 if (!info->attrs[NL80211_ATTR_STA_WME])
7031 nla = info->attrs[NL80211_ATTR_STA_WME];
7032 err = nla_parse_nested_deprecated(tb, NL80211_STA_WME_MAX, nla,
7033 nl80211_sta_wme_policy,
7038 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
7039 params->uapsd_queues = nla_get_u8(
7040 tb[NL80211_STA_WME_UAPSD_QUEUES]);
7041 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
7044 if (tb[NL80211_STA_WME_MAX_SP])
7045 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
7047 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
7050 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
7055 static int nl80211_parse_sta_channel_info(struct genl_info *info,
7056 struct station_parameters *params)
7058 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
7059 params->supported_channels =
7060 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
7061 params->supported_channels_len =
7062 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
7064 * Need to include at least one (first channel, number of
7065 * channels) tuple for each subband (checked in policy),
7066 * and must have proper tuples for the rest of the data as well.
7068 if (params->supported_channels_len % 2)
7072 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
7073 params->supported_oper_classes =
7074 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
7075 params->supported_oper_classes_len =
7076 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
7081 static int nl80211_set_station_tdls(struct genl_info *info,
7082 struct station_parameters *params)
7085 /* Dummy STA entry gets updated once the peer capabilities are known */
7086 if (info->attrs[NL80211_ATTR_PEER_AID])
7087 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
7088 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
7089 params->link_sta_params.ht_capa =
7090 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
7091 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
7092 params->link_sta_params.vht_capa =
7093 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
7094 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
7095 params->link_sta_params.he_capa =
7096 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
7097 params->link_sta_params.he_capa_len =
7098 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
7100 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) {
7101 params->link_sta_params.eht_capa =
7102 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
7103 params->link_sta_params.eht_capa_len =
7104 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
7106 if (!ieee80211_eht_capa_size_ok((const u8 *)params->link_sta_params.he_capa,
7107 (const u8 *)params->link_sta_params.eht_capa,
7108 params->link_sta_params.eht_capa_len,
7114 err = nl80211_parse_sta_channel_info(info, params);
7118 return nl80211_parse_sta_wme(info, params);
7121 static int nl80211_parse_sta_txpower_setting(struct genl_info *info,
7122 struct sta_txpwr *txpwr,
7125 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7128 if (info->attrs[NL80211_ATTR_STA_TX_POWER_SETTING]) {
7129 if (!rdev->ops->set_tx_power ||
7130 !wiphy_ext_feature_isset(&rdev->wiphy,
7131 NL80211_EXT_FEATURE_STA_TX_PWR))
7134 idx = NL80211_ATTR_STA_TX_POWER_SETTING;
7135 txpwr->type = nla_get_u8(info->attrs[idx]);
7137 if (txpwr->type == NL80211_TX_POWER_LIMITED) {
7138 idx = NL80211_ATTR_STA_TX_POWER;
7140 if (info->attrs[idx])
7141 txpwr->power = nla_get_s16(info->attrs[idx]);
7154 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
7156 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7157 struct net_device *dev = info->user_ptr[1];
7158 struct station_parameters params;
7162 memset(¶ms, 0, sizeof(params));
7164 if (!rdev->ops->change_station)
7168 * AID and listen_interval properties can be set only for unassociated
7169 * station. Include these parameters here and will check them in
7170 * cfg80211_check_station_change().
7172 if (info->attrs[NL80211_ATTR_STA_AID])
7173 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
7175 if (info->attrs[NL80211_ATTR_VLAN_ID])
7176 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
7178 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
7179 params.listen_interval =
7180 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
7182 params.listen_interval = -1;
7184 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS])
7185 params.support_p2p_ps =
7186 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
7188 params.support_p2p_ps = -1;
7190 if (!info->attrs[NL80211_ATTR_MAC])
7193 params.link_sta_params.link_id =
7194 nl80211_link_id_or_invalid(info->attrs);
7196 if (info->attrs[NL80211_ATTR_MLD_ADDR]) {
7197 /* If MLD_ADDR attribute is set then this is an MLD station
7198 * and the MLD_ADDR attribute holds the MLD address and the
7199 * MAC attribute holds for the LINK address.
7200 * In that case, the link_id is also expected to be valid.
7202 if (params.link_sta_params.link_id < 0)
7205 mac_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
7206 params.link_sta_params.mld_mac = mac_addr;
7207 params.link_sta_params.link_mac =
7208 nla_data(info->attrs[NL80211_ATTR_MAC]);
7209 if (!is_valid_ether_addr(params.link_sta_params.link_mac))
7212 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
7216 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
7217 params.link_sta_params.supported_rates =
7218 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
7219 params.link_sta_params.supported_rates_len =
7220 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
7223 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
7225 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
7226 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
7229 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
7231 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
7232 params.ext_capab_len =
7233 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
7236 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
7239 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
7240 params.plink_action =
7241 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
7243 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
7244 params.plink_state =
7245 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
7246 if (info->attrs[NL80211_ATTR_MESH_PEER_AID])
7247 params.peer_aid = nla_get_u16(
7248 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
7249 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
7252 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE])
7253 params.local_pm = nla_get_u32(
7254 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
7256 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
7257 params.link_sta_params.opmode_notif_used = true;
7258 params.link_sta_params.opmode_notif =
7259 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
7262 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
7263 params.link_sta_params.he_6ghz_capa =
7264 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
7266 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
7267 params.airtime_weight =
7268 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
7270 if (params.airtime_weight &&
7271 !wiphy_ext_feature_isset(&rdev->wiphy,
7272 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
7275 err = nl80211_parse_sta_txpower_setting(info,
7276 ¶ms.link_sta_params.txpwr,
7277 ¶ms.link_sta_params.txpwr_set);
7281 /* Include parameters for TDLS peer (will check later) */
7282 err = nl80211_set_station_tdls(info, ¶ms);
7286 params.vlan = get_vlan(info, rdev);
7287 if (IS_ERR(params.vlan))
7288 return PTR_ERR(params.vlan);
7290 switch (dev->ieee80211_ptr->iftype) {
7291 case NL80211_IFTYPE_AP:
7292 case NL80211_IFTYPE_AP_VLAN:
7293 case NL80211_IFTYPE_P2P_GO:
7294 case NL80211_IFTYPE_P2P_CLIENT:
7295 case NL80211_IFTYPE_STATION:
7296 case NL80211_IFTYPE_ADHOC:
7297 case NL80211_IFTYPE_MESH_POINT:
7304 /* driver will call cfg80211_check_station_change() */
7305 wdev_lock(dev->ieee80211_ptr);
7306 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
7307 wdev_unlock(dev->ieee80211_ptr);
7310 dev_put(params.vlan);
7315 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
7317 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7319 struct net_device *dev = info->user_ptr[1];
7320 struct wireless_dev *wdev = dev->ieee80211_ptr;
7321 struct station_parameters params;
7322 u8 *mac_addr = NULL;
7323 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
7324 BIT(NL80211_STA_FLAG_ASSOCIATED);
7326 memset(¶ms, 0, sizeof(params));
7328 if (!rdev->ops->add_station)
7331 if (!info->attrs[NL80211_ATTR_MAC])
7334 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
7337 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
7340 if (!info->attrs[NL80211_ATTR_STA_AID] &&
7341 !info->attrs[NL80211_ATTR_PEER_AID])
7344 params.link_sta_params.link_id =
7345 nl80211_link_id_or_invalid(info->attrs);
7347 if (info->attrs[NL80211_ATTR_MLD_ADDR]) {
7348 mac_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
7349 params.link_sta_params.mld_mac = mac_addr;
7350 params.link_sta_params.link_mac =
7351 nla_data(info->attrs[NL80211_ATTR_MAC]);
7352 if (!is_valid_ether_addr(params.link_sta_params.link_mac))
7355 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
7358 params.link_sta_params.supported_rates =
7359 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
7360 params.link_sta_params.supported_rates_len =
7361 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
7362 params.listen_interval =
7363 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
7365 if (info->attrs[NL80211_ATTR_VLAN_ID])
7366 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
7368 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
7369 params.support_p2p_ps =
7370 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
7373 * if not specified, assume it's supported for P2P GO interface,
7374 * and is NOT supported for AP interface
7376 params.support_p2p_ps =
7377 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
7380 if (info->attrs[NL80211_ATTR_PEER_AID])
7381 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
7383 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
7385 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
7387 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
7388 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
7391 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
7393 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
7394 params.ext_capab_len =
7395 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
7398 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
7399 params.link_sta_params.ht_capa =
7400 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
7402 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
7403 params.link_sta_params.vht_capa =
7404 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
7406 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
7407 params.link_sta_params.he_capa =
7408 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
7409 params.link_sta_params.he_capa_len =
7410 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
7412 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) {
7413 params.link_sta_params.eht_capa =
7414 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
7415 params.link_sta_params.eht_capa_len =
7416 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
7418 if (!ieee80211_eht_capa_size_ok((const u8 *)params.link_sta_params.he_capa,
7419 (const u8 *)params.link_sta_params.eht_capa,
7420 params.link_sta_params.eht_capa_len,
7426 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
7427 params.link_sta_params.he_6ghz_capa =
7428 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
7430 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
7431 params.link_sta_params.opmode_notif_used = true;
7432 params.link_sta_params.opmode_notif =
7433 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
7436 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
7437 params.plink_action =
7438 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
7440 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
7441 params.airtime_weight =
7442 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
7444 if (params.airtime_weight &&
7445 !wiphy_ext_feature_isset(&rdev->wiphy,
7446 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
7449 err = nl80211_parse_sta_txpower_setting(info,
7450 ¶ms.link_sta_params.txpwr,
7451 ¶ms.link_sta_params.txpwr_set);
7455 err = nl80211_parse_sta_channel_info(info, ¶ms);
7459 err = nl80211_parse_sta_wme(info, ¶ms);
7463 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
7466 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
7467 * as userspace might just pass through the capabilities from the IEs
7468 * directly, rather than enforcing this restriction and returning an
7469 * error in this case.
7471 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
7472 params.link_sta_params.ht_capa = NULL;
7473 params.link_sta_params.vht_capa = NULL;
7475 /* HE and EHT require WME */
7476 if (params.link_sta_params.he_capa_len ||
7477 params.link_sta_params.he_6ghz_capa ||
7478 params.link_sta_params.eht_capa_len)
7482 /* Ensure that HT/VHT capabilities are not set for 6 GHz HE STA */
7483 if (params.link_sta_params.he_6ghz_capa &&
7484 (params.link_sta_params.ht_capa || params.link_sta_params.vht_capa))
7487 /* When you run into this, adjust the code below for the new flag */
7488 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
7490 switch (dev->ieee80211_ptr->iftype) {
7491 case NL80211_IFTYPE_AP:
7492 case NL80211_IFTYPE_AP_VLAN:
7493 case NL80211_IFTYPE_P2P_GO:
7494 /* ignore WME attributes if iface/sta is not capable */
7495 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
7496 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
7497 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
7499 /* TDLS peers cannot be added */
7500 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
7501 info->attrs[NL80211_ATTR_PEER_AID])
7503 /* but don't bother the driver with it */
7504 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
7506 /* allow authenticated/associated only if driver handles it */
7507 if (!(rdev->wiphy.features &
7508 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
7509 params.sta_flags_mask & auth_assoc)
7512 /* Older userspace, or userspace wanting to be compatible with
7513 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
7514 * and assoc flags in the mask, but assumes the station will be
7515 * added as associated anyway since this was the required driver
7516 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
7518 * In order to not bother drivers with this quirk in the API
7519 * set the flags in both the mask and set for new stations in
7522 if (!(params.sta_flags_mask & auth_assoc)) {
7523 params.sta_flags_mask |= auth_assoc;
7524 params.sta_flags_set |= auth_assoc;
7527 /* must be last in here for error handling */
7528 params.vlan = get_vlan(info, rdev);
7529 if (IS_ERR(params.vlan))
7530 return PTR_ERR(params.vlan);
7532 case NL80211_IFTYPE_MESH_POINT:
7533 /* ignore uAPSD data */
7534 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
7536 /* associated is disallowed */
7537 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
7539 /* TDLS peers cannot be added */
7540 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
7541 info->attrs[NL80211_ATTR_PEER_AID])
7544 case NL80211_IFTYPE_STATION:
7545 case NL80211_IFTYPE_P2P_CLIENT:
7546 /* ignore uAPSD data */
7547 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
7549 /* these are disallowed */
7550 if (params.sta_flags_mask &
7551 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
7552 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
7554 /* Only TDLS peers can be added */
7555 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
7557 /* Can only add if TDLS ... */
7558 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
7560 /* ... with external setup is supported */
7561 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
7564 * Older wpa_supplicant versions always mark the TDLS peer
7565 * as authorized, but it shouldn't yet be.
7567 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
7573 /* be aware of params.vlan when changing code here */
7575 wdev_lock(dev->ieee80211_ptr);
7576 if (wdev->valid_links) {
7577 if (params.link_sta_params.link_id < 0) {
7581 if (!(wdev->valid_links & BIT(params.link_sta_params.link_id))) {
7586 if (params.link_sta_params.link_id >= 0) {
7591 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
7593 wdev_unlock(dev->ieee80211_ptr);
7594 dev_put(params.vlan);
7598 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
7600 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7601 struct net_device *dev = info->user_ptr[1];
7602 struct station_del_parameters params;
7605 memset(¶ms, 0, sizeof(params));
7607 if (info->attrs[NL80211_ATTR_MAC])
7608 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
7610 switch (dev->ieee80211_ptr->iftype) {
7611 case NL80211_IFTYPE_AP:
7612 case NL80211_IFTYPE_AP_VLAN:
7613 case NL80211_IFTYPE_MESH_POINT:
7614 case NL80211_IFTYPE_P2P_GO:
7615 /* always accept these */
7617 case NL80211_IFTYPE_ADHOC:
7618 /* conditionally accept */
7619 if (wiphy_ext_feature_isset(&rdev->wiphy,
7620 NL80211_EXT_FEATURE_DEL_IBSS_STA))
7627 if (!rdev->ops->del_station)
7630 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
7632 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
7633 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
7634 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
7637 /* Default to Deauthentication frame */
7638 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
7641 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
7642 params.reason_code =
7643 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
7644 if (params.reason_code == 0)
7645 return -EINVAL; /* 0 is reserved */
7647 /* Default to reason code 2 */
7648 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
7651 wdev_lock(dev->ieee80211_ptr);
7652 ret = rdev_del_station(rdev, dev, ¶ms);
7653 wdev_unlock(dev->ieee80211_ptr);
7658 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
7659 int flags, struct net_device *dev,
7660 u8 *dst, u8 *next_hop,
7661 struct mpath_info *pinfo)
7664 struct nlattr *pinfoattr;
7666 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
7670 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
7671 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
7672 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
7673 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
7674 goto nla_put_failure;
7676 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MPATH_INFO);
7678 goto nla_put_failure;
7679 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
7680 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
7682 goto nla_put_failure;
7683 if (((pinfo->filled & MPATH_INFO_SN) &&
7684 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
7685 ((pinfo->filled & MPATH_INFO_METRIC) &&
7686 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
7688 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
7689 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
7691 ((pinfo->filled & MPATH_INFO_FLAGS) &&
7692 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
7694 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
7695 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
7696 pinfo->discovery_timeout)) ||
7697 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
7698 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
7699 pinfo->discovery_retries)) ||
7700 ((pinfo->filled & MPATH_INFO_HOP_COUNT) &&
7701 nla_put_u8(msg, NL80211_MPATH_INFO_HOP_COUNT,
7702 pinfo->hop_count)) ||
7703 ((pinfo->filled & MPATH_INFO_PATH_CHANGE) &&
7704 nla_put_u32(msg, NL80211_MPATH_INFO_PATH_CHANGE,
7705 pinfo->path_change_count)))
7706 goto nla_put_failure;
7708 nla_nest_end(msg, pinfoattr);
7710 genlmsg_end(msg, hdr);
7714 genlmsg_cancel(msg, hdr);
7718 static int nl80211_dump_mpath(struct sk_buff *skb,
7719 struct netlink_callback *cb)
7721 struct mpath_info pinfo;
7722 struct cfg80211_registered_device *rdev;
7723 struct wireless_dev *wdev;
7725 u8 next_hop[ETH_ALEN];
7726 int path_idx = cb->args[2];
7729 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL);
7732 /* nl80211_prepare_wdev_dump acquired it in the successful case */
7733 __acquire(&rdev->wiphy.mtx);
7735 if (!rdev->ops->dump_mpath) {
7740 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
7746 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
7753 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
7754 cb->nlh->nlmsg_seq, NLM_F_MULTI,
7755 wdev->netdev, dst, next_hop,
7763 cb->args[2] = path_idx;
7766 wiphy_unlock(&rdev->wiphy);
7770 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
7772 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7774 struct net_device *dev = info->user_ptr[1];
7775 struct mpath_info pinfo;
7776 struct sk_buff *msg;
7778 u8 next_hop[ETH_ALEN];
7780 memset(&pinfo, 0, sizeof(pinfo));
7782 if (!info->attrs[NL80211_ATTR_MAC])
7785 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7787 if (!rdev->ops->get_mpath)
7790 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7793 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
7797 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7801 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
7802 dev, dst, next_hop, &pinfo) < 0) {
7807 return genlmsg_reply(msg, info);
7810 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
7812 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7813 struct net_device *dev = info->user_ptr[1];
7815 u8 *next_hop = NULL;
7817 if (!info->attrs[NL80211_ATTR_MAC])
7820 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
7823 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7824 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
7826 if (!rdev->ops->change_mpath)
7829 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7832 return rdev_change_mpath(rdev, dev, dst, next_hop);
7835 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
7837 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7838 struct net_device *dev = info->user_ptr[1];
7840 u8 *next_hop = NULL;
7842 if (!info->attrs[NL80211_ATTR_MAC])
7845 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
7848 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7849 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
7851 if (!rdev->ops->add_mpath)
7854 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7857 return rdev_add_mpath(rdev, dev, dst, next_hop);
7860 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
7862 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7863 struct net_device *dev = info->user_ptr[1];
7866 if (info->attrs[NL80211_ATTR_MAC])
7867 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7869 if (!rdev->ops->del_mpath)
7872 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7875 return rdev_del_mpath(rdev, dev, dst);
7878 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
7880 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7882 struct net_device *dev = info->user_ptr[1];
7883 struct mpath_info pinfo;
7884 struct sk_buff *msg;
7888 memset(&pinfo, 0, sizeof(pinfo));
7890 if (!info->attrs[NL80211_ATTR_MAC])
7893 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
7895 if (!rdev->ops->get_mpp)
7898 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7901 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
7905 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7909 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
7910 dev, dst, mpp, &pinfo) < 0) {
7915 return genlmsg_reply(msg, info);
7918 static int nl80211_dump_mpp(struct sk_buff *skb,
7919 struct netlink_callback *cb)
7921 struct mpath_info pinfo;
7922 struct cfg80211_registered_device *rdev;
7923 struct wireless_dev *wdev;
7926 int path_idx = cb->args[2];
7929 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL);
7932 /* nl80211_prepare_wdev_dump acquired it in the successful case */
7933 __acquire(&rdev->wiphy.mtx);
7935 if (!rdev->ops->dump_mpp) {
7940 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
7946 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
7953 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
7954 cb->nlh->nlmsg_seq, NLM_F_MULTI,
7955 wdev->netdev, dst, mpp,
7963 cb->args[2] = path_idx;
7966 wiphy_unlock(&rdev->wiphy);
7970 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
7972 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7973 struct net_device *dev = info->user_ptr[1];
7974 struct wireless_dev *wdev = dev->ieee80211_ptr;
7975 struct bss_parameters params;
7978 memset(¶ms, 0, sizeof(params));
7979 params.link_id = nl80211_link_id_or_invalid(info->attrs);
7980 /* default to not changing parameters */
7981 params.use_cts_prot = -1;
7982 params.use_short_preamble = -1;
7983 params.use_short_slot_time = -1;
7984 params.ap_isolate = -1;
7985 params.ht_opmode = -1;
7986 params.p2p_ctwindow = -1;
7987 params.p2p_opp_ps = -1;
7989 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
7990 params.use_cts_prot =
7991 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
7992 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
7993 params.use_short_preamble =
7994 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
7995 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
7996 params.use_short_slot_time =
7997 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
7998 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
7999 params.basic_rates =
8000 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8001 params.basic_rates_len =
8002 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8004 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
8005 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
8006 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
8008 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
8010 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
8011 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
8013 params.p2p_ctwindow =
8014 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
8015 if (params.p2p_ctwindow != 0 &&
8016 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
8020 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
8023 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
8025 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
8026 params.p2p_opp_ps = tmp;
8027 if (params.p2p_opp_ps &&
8028 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
8032 if (!rdev->ops->change_bss)
8035 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
8036 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
8040 err = rdev_change_bss(rdev, dev, ¶ms);
8046 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
8050 enum nl80211_user_reg_hint_type user_reg_hint_type;
8054 * You should only get this when cfg80211 hasn't yet initialized
8055 * completely when built-in to the kernel right between the time
8056 * window between nl80211_init() and regulatory_init(), if that is
8059 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
8060 return -EINPROGRESS;
8062 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
8063 user_reg_hint_type =
8064 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
8066 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
8068 switch (user_reg_hint_type) {
8069 case NL80211_USER_REG_HINT_USER:
8070 case NL80211_USER_REG_HINT_CELL_BASE:
8071 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
8074 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
8075 return regulatory_hint_user(data, user_reg_hint_type);
8076 case NL80211_USER_REG_HINT_INDOOR:
8077 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8078 owner_nlportid = info->snd_portid;
8079 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
8085 return regulatory_hint_indoor(is_indoor, owner_nlportid);
8091 static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info)
8093 return reg_reload_regdb();
8096 static int nl80211_get_mesh_config(struct sk_buff *skb,
8097 struct genl_info *info)
8099 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8100 struct net_device *dev = info->user_ptr[1];
8101 struct wireless_dev *wdev = dev->ieee80211_ptr;
8102 struct mesh_config cur_params;
8105 struct nlattr *pinfoattr;
8106 struct sk_buff *msg;
8108 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
8111 if (!rdev->ops->get_mesh_config)
8115 /* If not connected, get default parameters */
8116 if (!wdev->u.mesh.id_len)
8117 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
8119 err = rdev_get_mesh_config(rdev, dev, &cur_params);
8125 /* Draw up a netlink message to send back */
8126 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8129 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8130 NL80211_CMD_GET_MESH_CONFIG);
8133 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MESH_CONFIG);
8135 goto nla_put_failure;
8136 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
8137 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
8138 cur_params.dot11MeshRetryTimeout) ||
8139 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
8140 cur_params.dot11MeshConfirmTimeout) ||
8141 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
8142 cur_params.dot11MeshHoldingTimeout) ||
8143 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
8144 cur_params.dot11MeshMaxPeerLinks) ||
8145 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
8146 cur_params.dot11MeshMaxRetries) ||
8147 nla_put_u8(msg, NL80211_MESHCONF_TTL,
8148 cur_params.dot11MeshTTL) ||
8149 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
8150 cur_params.element_ttl) ||
8151 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
8152 cur_params.auto_open_plinks) ||
8153 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
8154 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
8155 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
8156 cur_params.dot11MeshHWMPmaxPREQretries) ||
8157 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
8158 cur_params.path_refresh_time) ||
8159 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
8160 cur_params.min_discovery_timeout) ||
8161 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
8162 cur_params.dot11MeshHWMPactivePathTimeout) ||
8163 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
8164 cur_params.dot11MeshHWMPpreqMinInterval) ||
8165 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
8166 cur_params.dot11MeshHWMPperrMinInterval) ||
8167 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
8168 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
8169 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
8170 cur_params.dot11MeshHWMPRootMode) ||
8171 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
8172 cur_params.dot11MeshHWMPRannInterval) ||
8173 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
8174 cur_params.dot11MeshGateAnnouncementProtocol) ||
8175 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
8176 cur_params.dot11MeshForwarding) ||
8177 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
8178 cur_params.rssi_threshold) ||
8179 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
8180 cur_params.ht_opmode) ||
8181 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
8182 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
8183 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
8184 cur_params.dot11MeshHWMProotInterval) ||
8185 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
8186 cur_params.dot11MeshHWMPconfirmationInterval) ||
8187 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
8188 cur_params.power_mode) ||
8189 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
8190 cur_params.dot11MeshAwakeWindowDuration) ||
8191 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
8192 cur_params.plink_timeout) ||
8193 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_GATE,
8194 cur_params.dot11MeshConnectedToMeshGate) ||
8195 nla_put_u8(msg, NL80211_MESHCONF_NOLEARN,
8196 cur_params.dot11MeshNolearn) ||
8197 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_AS,
8198 cur_params.dot11MeshConnectedToAuthServer))
8199 goto nla_put_failure;
8200 nla_nest_end(msg, pinfoattr);
8201 genlmsg_end(msg, hdr);
8202 return genlmsg_reply(msg, info);
8210 static const struct nla_policy
8211 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
8212 [NL80211_MESHCONF_RETRY_TIMEOUT] =
8213 NLA_POLICY_RANGE(NLA_U16, 1, 255),
8214 [NL80211_MESHCONF_CONFIRM_TIMEOUT] =
8215 NLA_POLICY_RANGE(NLA_U16, 1, 255),
8216 [NL80211_MESHCONF_HOLDING_TIMEOUT] =
8217 NLA_POLICY_RANGE(NLA_U16, 1, 255),
8218 [NL80211_MESHCONF_MAX_PEER_LINKS] =
8219 NLA_POLICY_RANGE(NLA_U16, 0, 255),
8220 [NL80211_MESHCONF_MAX_RETRIES] = NLA_POLICY_MAX(NLA_U8, 16),
8221 [NL80211_MESHCONF_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
8222 [NL80211_MESHCONF_ELEMENT_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
8223 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = NLA_POLICY_MAX(NLA_U8, 1),
8224 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] =
8225 NLA_POLICY_RANGE(NLA_U32, 1, 255),
8226 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
8227 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
8228 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = NLA_POLICY_MIN(NLA_U16, 1),
8229 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
8230 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] =
8231 NLA_POLICY_MIN(NLA_U16, 1),
8232 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] =
8233 NLA_POLICY_MIN(NLA_U16, 1),
8234 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] =
8235 NLA_POLICY_MIN(NLA_U16, 1),
8236 [NL80211_MESHCONF_HWMP_ROOTMODE] = NLA_POLICY_MAX(NLA_U8, 4),
8237 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] =
8238 NLA_POLICY_MIN(NLA_U16, 1),
8239 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = NLA_POLICY_MAX(NLA_U8, 1),
8240 [NL80211_MESHCONF_FORWARDING] = NLA_POLICY_MAX(NLA_U8, 1),
8241 [NL80211_MESHCONF_RSSI_THRESHOLD] =
8242 NLA_POLICY_RANGE(NLA_S32, -255, 0),
8243 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
8244 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
8245 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] =
8246 NLA_POLICY_MIN(NLA_U16, 1),
8247 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] =
8248 NLA_POLICY_MIN(NLA_U16, 1),
8249 [NL80211_MESHCONF_POWER_MODE] =
8250 NLA_POLICY_RANGE(NLA_U32,
8251 NL80211_MESH_POWER_ACTIVE,
8252 NL80211_MESH_POWER_MAX),
8253 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
8254 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
8255 [NL80211_MESHCONF_CONNECTED_TO_GATE] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
8256 [NL80211_MESHCONF_NOLEARN] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
8257 [NL80211_MESHCONF_CONNECTED_TO_AS] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
8260 static const struct nla_policy
8261 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
8262 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
8263 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
8264 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
8265 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
8266 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
8267 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
8268 [NL80211_MESH_SETUP_IE] =
8269 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
8270 IEEE80211_MAX_DATA_LEN),
8271 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
8274 static int nl80211_parse_mesh_config(struct genl_info *info,
8275 struct mesh_config *cfg,
8278 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
8282 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \
8285 cfg->param = fn(tb[attr]); \
8286 mask |= BIT((attr) - 1); \
8290 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
8292 if (nla_parse_nested_deprecated(tb, NL80211_MESHCONF_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_CONFIG], nl80211_meshconf_params_policy, info->extack))
8295 /* This makes sure that there aren't more than 32 mesh config
8296 * parameters (otherwise our bitfield scheme would not work.) */
8297 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
8299 /* Fill in the params struct */
8300 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, mask,
8301 NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
8302 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, mask,
8303 NL80211_MESHCONF_CONFIRM_TIMEOUT,
8305 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, mask,
8306 NL80211_MESHCONF_HOLDING_TIMEOUT,
8308 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, mask,
8309 NL80211_MESHCONF_MAX_PEER_LINKS,
8311 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, mask,
8312 NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
8313 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, mask,
8314 NL80211_MESHCONF_TTL, nla_get_u8);
8315 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, mask,
8316 NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
8317 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, mask,
8318 NL80211_MESHCONF_AUTO_OPEN_PLINKS,
8320 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
8322 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
8324 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, mask,
8325 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
8327 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, mask,
8328 NL80211_MESHCONF_PATH_REFRESH_TIME,
8330 if (mask & BIT(NL80211_MESHCONF_PATH_REFRESH_TIME) &&
8331 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535))
8333 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, mask,
8334 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
8336 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
8338 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
8340 if (mask & BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT) &&
8341 (cfg->dot11MeshHWMPactivePathTimeout < 1 ||
8342 cfg->dot11MeshHWMPactivePathTimeout > 65535))
8344 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, mask,
8345 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
8347 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval, mask,
8348 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
8350 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
8351 dot11MeshHWMPnetDiameterTraversalTime, mask,
8352 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
8354 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask,
8355 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8);
8356 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask,
8357 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
8359 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshGateAnnouncementProtocol,
8360 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
8362 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, mask,
8363 NL80211_MESHCONF_FORWARDING, nla_get_u8);
8364 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, mask,
8365 NL80211_MESHCONF_RSSI_THRESHOLD,
8367 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToMeshGate, mask,
8368 NL80211_MESHCONF_CONNECTED_TO_GATE,
8370 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToAuthServer, mask,
8371 NL80211_MESHCONF_CONNECTED_TO_AS,
8374 * Check HT operation mode based on
8375 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
8377 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
8378 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
8380 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
8381 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
8382 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
8385 /* NON_HT_STA bit is reserved, but some programs set it */
8386 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
8388 cfg->ht_opmode = ht_opmode;
8389 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
8391 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
8392 dot11MeshHWMPactivePathToRootTimeout, mask,
8393 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
8395 if (mask & BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT) &&
8396 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 ||
8397 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535))
8399 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, mask,
8400 NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
8402 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPconfirmationInterval,
8404 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
8406 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode, mask,
8407 NL80211_MESHCONF_POWER_MODE, nla_get_u32);
8408 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration, mask,
8409 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
8410 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, mask,
8411 NL80211_MESHCONF_PLINK_TIMEOUT, nla_get_u32);
8412 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNolearn, mask,
8413 NL80211_MESHCONF_NOLEARN, nla_get_u8);
8419 #undef FILL_IN_MESH_PARAM_IF_SET
8422 static int nl80211_parse_mesh_setup(struct genl_info *info,
8423 struct mesh_setup *setup)
8425 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8426 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
8428 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
8430 if (nla_parse_nested_deprecated(tb, NL80211_MESH_SETUP_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_SETUP], nl80211_mesh_setup_params_policy, info->extack))
8433 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
8434 setup->sync_method =
8435 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
8436 IEEE80211_SYNC_METHOD_VENDOR :
8437 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
8439 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
8440 setup->path_sel_proto =
8441 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
8442 IEEE80211_PATH_PROTOCOL_VENDOR :
8443 IEEE80211_PATH_PROTOCOL_HWMP;
8445 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
8446 setup->path_metric =
8447 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
8448 IEEE80211_PATH_METRIC_VENDOR :
8449 IEEE80211_PATH_METRIC_AIRTIME;
8451 if (tb[NL80211_MESH_SETUP_IE]) {
8452 struct nlattr *ieattr =
8453 tb[NL80211_MESH_SETUP_IE];
8454 setup->ie = nla_data(ieattr);
8455 setup->ie_len = nla_len(ieattr);
8457 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
8458 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
8460 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
8461 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
8462 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
8463 if (setup->is_secure)
8464 setup->user_mpm = true;
8466 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
8467 if (!setup->user_mpm)
8470 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
8476 static int nl80211_update_mesh_config(struct sk_buff *skb,
8477 struct genl_info *info)
8479 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8480 struct net_device *dev = info->user_ptr[1];
8481 struct wireless_dev *wdev = dev->ieee80211_ptr;
8482 struct mesh_config cfg;
8486 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
8489 if (!rdev->ops->update_mesh_config)
8492 err = nl80211_parse_mesh_config(info, &cfg, &mask);
8497 if (!wdev->u.mesh.id_len)
8501 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
8508 static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
8509 struct sk_buff *msg)
8511 struct nlattr *nl_reg_rules;
8514 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
8515 (regdom->dfs_region &&
8516 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
8517 goto nla_put_failure;
8519 nl_reg_rules = nla_nest_start_noflag(msg, NL80211_ATTR_REG_RULES);
8521 goto nla_put_failure;
8523 for (i = 0; i < regdom->n_reg_rules; i++) {
8524 struct nlattr *nl_reg_rule;
8525 const struct ieee80211_reg_rule *reg_rule;
8526 const struct ieee80211_freq_range *freq_range;
8527 const struct ieee80211_power_rule *power_rule;
8528 unsigned int max_bandwidth_khz;
8530 reg_rule = ®dom->reg_rules[i];
8531 freq_range = ®_rule->freq_range;
8532 power_rule = ®_rule->power_rule;
8534 nl_reg_rule = nla_nest_start_noflag(msg, i);
8536 goto nla_put_failure;
8538 max_bandwidth_khz = freq_range->max_bandwidth_khz;
8539 if (!max_bandwidth_khz)
8540 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
8543 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
8545 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
8546 freq_range->start_freq_khz) ||
8547 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
8548 freq_range->end_freq_khz) ||
8549 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
8550 max_bandwidth_khz) ||
8551 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
8552 power_rule->max_antenna_gain) ||
8553 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
8554 power_rule->max_eirp) ||
8555 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
8556 reg_rule->dfs_cac_ms))
8557 goto nla_put_failure;
8559 nla_nest_end(msg, nl_reg_rule);
8562 nla_nest_end(msg, nl_reg_rules);
8569 static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
8571 const struct ieee80211_regdomain *regdom = NULL;
8572 struct cfg80211_registered_device *rdev;
8573 struct wiphy *wiphy = NULL;
8574 struct sk_buff *msg;
8575 int err = -EMSGSIZE;
8578 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8582 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8583 NL80211_CMD_GET_REG);
8589 if (info->attrs[NL80211_ATTR_WIPHY]) {
8592 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
8594 err = PTR_ERR(rdev);
8595 goto nla_put_failure;
8598 wiphy = &rdev->wiphy;
8599 self_managed = wiphy->regulatory_flags &
8600 REGULATORY_WIPHY_SELF_MANAGED;
8604 regdom = get_wiphy_regdom(wiphy);
8606 /* a self-managed-reg device must have a private regdom */
8607 if (WARN_ON(!regdom && self_managed)) {
8609 goto nla_put_failure_rcu;
8613 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
8614 goto nla_put_failure_rcu;
8619 if (!wiphy && reg_last_request_cell_base() &&
8620 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
8621 NL80211_USER_REG_HINT_CELL_BASE))
8622 goto nla_put_failure_rcu;
8625 regdom = rcu_dereference(cfg80211_regdomain);
8627 if (nl80211_put_regdom(regdom, msg))
8628 goto nla_put_failure_rcu;
8632 genlmsg_end(msg, hdr);
8634 return genlmsg_reply(msg, info);
8636 nla_put_failure_rcu:
8645 static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
8646 u32 seq, int flags, struct wiphy *wiphy,
8647 const struct ieee80211_regdomain *regdom)
8649 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
8650 NL80211_CMD_GET_REG);
8655 genl_dump_check_consistent(cb, hdr);
8657 if (nl80211_put_regdom(regdom, msg))
8658 goto nla_put_failure;
8660 if (!wiphy && reg_last_request_cell_base() &&
8661 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
8662 NL80211_USER_REG_HINT_CELL_BASE))
8663 goto nla_put_failure;
8666 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
8667 goto nla_put_failure;
8669 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
8670 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
8671 goto nla_put_failure;
8673 genlmsg_end(msg, hdr);
8677 genlmsg_cancel(msg, hdr);
8681 static int nl80211_get_reg_dump(struct sk_buff *skb,
8682 struct netlink_callback *cb)
8684 const struct ieee80211_regdomain *regdom = NULL;
8685 struct cfg80211_registered_device *rdev;
8686 int err, reg_idx, start = cb->args[2];
8690 if (cfg80211_regdomain && start == 0) {
8691 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
8693 rcu_dereference(cfg80211_regdomain));
8698 /* the global regdom is idx 0 */
8700 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
8701 regdom = get_wiphy_regdom(&rdev->wiphy);
8705 if (++reg_idx <= start)
8708 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
8709 NLM_F_MULTI, &rdev->wiphy, regdom);
8716 cb->args[2] = reg_idx;
8723 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
8724 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
8725 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
8726 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
8727 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
8728 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
8729 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
8730 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
8731 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
8734 static int parse_reg_rule(struct nlattr *tb[],
8735 struct ieee80211_reg_rule *reg_rule)
8737 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
8738 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
8740 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
8742 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
8744 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
8746 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
8748 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
8751 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
8753 freq_range->start_freq_khz =
8754 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
8755 freq_range->end_freq_khz =
8756 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
8757 freq_range->max_bandwidth_khz =
8758 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
8760 power_rule->max_eirp =
8761 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
8763 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
8764 power_rule->max_antenna_gain =
8765 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
8767 if (tb[NL80211_ATTR_DFS_CAC_TIME])
8768 reg_rule->dfs_cac_ms =
8769 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
8774 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
8776 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
8777 struct nlattr *nl_reg_rule;
8779 int rem_reg_rules, r;
8780 u32 num_rules = 0, rule_idx = 0;
8781 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
8782 struct ieee80211_regdomain *rd;
8784 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
8787 if (!info->attrs[NL80211_ATTR_REG_RULES])
8790 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
8792 if (info->attrs[NL80211_ATTR_DFS_REGION])
8793 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
8795 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
8798 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
8803 if (!reg_is_valid_request(alpha2)) {
8808 rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL);
8814 rd->n_reg_rules = num_rules;
8815 rd->alpha2[0] = alpha2[0];
8816 rd->alpha2[1] = alpha2[1];
8819 * Disable DFS master mode if the DFS region was
8820 * not supported or known on this kernel.
8822 if (reg_supported_dfs_region(dfs_region))
8823 rd->dfs_region = dfs_region;
8825 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
8827 r = nla_parse_nested_deprecated(tb, NL80211_REG_RULE_ATTR_MAX,
8828 nl_reg_rule, reg_rule_policy,
8832 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
8838 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
8844 r = set_regdom(rd, REGD_SOURCE_CRDA);
8845 /* set_regdom takes ownership of rd */
8853 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
8855 static int validate_scan_freqs(struct nlattr *freqs)
8857 struct nlattr *attr1, *attr2;
8858 int n_channels = 0, tmp1, tmp2;
8860 nla_for_each_nested(attr1, freqs, tmp1)
8861 if (nla_len(attr1) != sizeof(u32))
8864 nla_for_each_nested(attr1, freqs, tmp1) {
8867 * Some hardware has a limited channel list for
8868 * scanning, and it is pretty much nonsensical
8869 * to scan for a channel twice, so disallow that
8870 * and don't require drivers to check that the
8871 * channel list they get isn't longer than what
8872 * they can scan, as long as they can scan all
8873 * the channels they registered at once.
8875 nla_for_each_nested(attr2, freqs, tmp2)
8876 if (attr1 != attr2 &&
8877 nla_get_u32(attr1) == nla_get_u32(attr2))
8884 static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
8886 return b < NUM_NL80211_BANDS && wiphy->bands[b];
8889 static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
8890 struct cfg80211_bss_selection *bss_select)
8892 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
8893 struct nlattr *nest;
8898 /* only process one nested attribute */
8899 nest = nla_data(nla);
8900 if (!nla_ok(nest, nla_len(nest)))
8903 err = nla_parse_nested_deprecated(attr, NL80211_BSS_SELECT_ATTR_MAX,
8904 nest, nl80211_bss_select_policy,
8909 /* only one attribute may be given */
8910 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
8918 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
8920 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
8921 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
8923 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
8924 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
8925 bss_select->param.band_pref =
8926 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
8927 if (!is_band_valid(wiphy, bss_select->param.band_pref))
8931 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
8932 struct nl80211_bss_select_rssi_adjust *adj_param;
8934 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
8935 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
8936 bss_select->param.adjust.band = adj_param->band;
8937 bss_select->param.adjust.delta = adj_param->delta;
8938 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
8942 /* user-space did not provide behaviour attribute */
8943 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
8946 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
8952 int nl80211_parse_random_mac(struct nlattr **attrs,
8953 u8 *mac_addr, u8 *mac_addr_mask)
8957 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
8958 eth_zero_addr(mac_addr);
8959 eth_zero_addr(mac_addr_mask);
8961 mac_addr_mask[0] = 0x3;
8966 /* need both or none */
8967 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
8970 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
8971 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
8973 /* don't allow or configure an mcast address */
8974 if (!is_multicast_ether_addr(mac_addr_mask) ||
8975 is_multicast_ether_addr(mac_addr))
8979 * allow users to pass a MAC address that has bits set outside
8980 * of the mask, but don't bother drivers with having to deal
8983 for (i = 0; i < ETH_ALEN; i++)
8984 mac_addr[i] &= mac_addr_mask[i];
8989 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev,
8990 struct ieee80211_channel *chan)
8992 unsigned int link_id;
8995 ASSERT_WDEV_LOCK(wdev);
8997 if (!cfg80211_beaconing_iface_active(wdev))
9001 * FIXME: check if we have a free HW resource/link for chan
9003 * This, as well as the FIXME below, requires knowing the link
9004 * capabilities of the hardware.
9007 /* we cannot leave radar channels */
9008 for_each_valid_link(wdev, link_id) {
9009 struct cfg80211_chan_def *chandef;
9011 chandef = wdev_chandef(wdev, link_id);
9012 if (!chandef || !chandef->chan)
9016 * FIXME: don't require all_ok, but rather check only the
9017 * correct HW resource/link onto which 'chan' falls,
9018 * as only that link leaves the channel for doing
9019 * the off-channel operation.
9022 if (chandef->chan->flags & IEEE80211_CHAN_RADAR)
9029 return regulatory_pre_cac_allowed(wdev->wiphy);
9032 static bool nl80211_check_scan_feat(struct wiphy *wiphy, u32 flags, u32 flag,
9033 enum nl80211_ext_feature_index feat)
9035 if (!(flags & flag))
9037 if (wiphy_ext_feature_isset(wiphy, feat))
9043 nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
9044 void *request, struct nlattr **attrs,
9047 u8 *mac_addr, *mac_addr_mask;
9049 enum nl80211_feature_flags randomness_flag;
9051 if (!attrs[NL80211_ATTR_SCAN_FLAGS])
9054 if (is_sched_scan) {
9055 struct cfg80211_sched_scan_request *req = request;
9057 randomness_flag = wdev ?
9058 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR :
9059 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
9060 flags = &req->flags;
9061 mac_addr = req->mac_addr;
9062 mac_addr_mask = req->mac_addr_mask;
9064 struct cfg80211_scan_request *req = request;
9066 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
9067 flags = &req->flags;
9068 mac_addr = req->mac_addr;
9069 mac_addr_mask = req->mac_addr_mask;
9072 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
9074 if (((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
9075 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
9076 !nl80211_check_scan_feat(wiphy, *flags,
9077 NL80211_SCAN_FLAG_LOW_SPAN,
9078 NL80211_EXT_FEATURE_LOW_SPAN_SCAN) ||
9079 !nl80211_check_scan_feat(wiphy, *flags,
9080 NL80211_SCAN_FLAG_LOW_POWER,
9081 NL80211_EXT_FEATURE_LOW_POWER_SCAN) ||
9082 !nl80211_check_scan_feat(wiphy, *flags,
9083 NL80211_SCAN_FLAG_HIGH_ACCURACY,
9084 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN) ||
9085 !nl80211_check_scan_feat(wiphy, *flags,
9086 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME,
9087 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) ||
9088 !nl80211_check_scan_feat(wiphy, *flags,
9089 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP,
9090 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) ||
9091 !nl80211_check_scan_feat(wiphy, *flags,
9092 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION,
9093 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) ||
9094 !nl80211_check_scan_feat(wiphy, *flags,
9095 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE,
9096 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) ||
9097 !nl80211_check_scan_feat(wiphy, *flags,
9098 NL80211_SCAN_FLAG_RANDOM_SN,
9099 NL80211_EXT_FEATURE_SCAN_RANDOM_SN) ||
9100 !nl80211_check_scan_feat(wiphy, *flags,
9101 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT,
9102 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
9105 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
9108 if (!(wiphy->features & randomness_flag) ||
9109 (wdev && wdev->connected))
9112 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask);
9120 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
9122 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9123 struct wireless_dev *wdev = info->user_ptr[1];
9124 struct cfg80211_scan_request *request;
9125 struct nlattr *scan_freqs = NULL;
9126 bool scan_freqs_khz = false;
9127 struct nlattr *attr;
9128 struct wiphy *wiphy;
9129 int err, tmp, n_ssids = 0, n_channels, i;
9130 size_t ie_len, size;
9132 wiphy = &rdev->wiphy;
9134 if (wdev->iftype == NL80211_IFTYPE_NAN)
9137 if (!rdev->ops->scan)
9140 if (rdev->scan_req || rdev->scan_msg)
9143 if (info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ]) {
9144 if (!wiphy_ext_feature_isset(wiphy,
9145 NL80211_EXT_FEATURE_SCAN_FREQ_KHZ))
9147 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ];
9148 scan_freqs_khz = true;
9149 } else if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES])
9150 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQUENCIES];
9153 n_channels = validate_scan_freqs(scan_freqs);
9157 n_channels = ieee80211_get_num_supported_channels(wiphy);
9160 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
9161 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
9164 if (n_ssids > wiphy->max_scan_ssids)
9167 if (info->attrs[NL80211_ATTR_IE])
9168 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9172 if (ie_len > wiphy->max_scan_ie_len)
9175 size = struct_size(request, channels, n_channels);
9176 size = size_add(size, array_size(sizeof(*request->ssids), n_ssids));
9177 size = size_add(size, ie_len);
9178 request = kzalloc(size, GFP_KERNEL);
9183 request->ssids = (void *)&request->channels[n_channels];
9184 request->n_ssids = n_ssids;
9187 request->ie = (void *)(request->ssids + n_ssids);
9189 request->ie = (void *)(request->channels + n_channels);
9194 /* user specified, bail out if channel not found */
9195 nla_for_each_nested(attr, scan_freqs, tmp) {
9196 struct ieee80211_channel *chan;
9197 int freq = nla_get_u32(attr);
9199 if (!scan_freqs_khz)
9200 freq = MHZ_TO_KHZ(freq);
9202 chan = ieee80211_get_channel_khz(wiphy, freq);
9208 /* ignore disabled channels */
9209 if (chan->flags & IEEE80211_CHAN_DISABLED)
9212 request->channels[i] = chan;
9216 enum nl80211_band band;
9219 for (band = 0; band < NUM_NL80211_BANDS; band++) {
9222 if (!wiphy->bands[band])
9224 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
9225 struct ieee80211_channel *chan;
9227 chan = &wiphy->bands[band]->channels[j];
9229 if (chan->flags & IEEE80211_CHAN_DISABLED)
9232 request->channels[i] = chan;
9243 request->n_channels = i;
9246 for (i = 0; i < request->n_channels; i++) {
9247 struct ieee80211_channel *chan = request->channels[i];
9249 /* if we can go off-channel to the target channel we're good */
9250 if (cfg80211_off_channel_oper_allowed(wdev, chan))
9253 if (!cfg80211_wdev_on_sub_chan(wdev, chan, true)) {
9263 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
9264 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
9268 request->ssids[i].ssid_len = nla_len(attr);
9269 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
9274 if (info->attrs[NL80211_ATTR_IE]) {
9275 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9276 memcpy((void *)request->ie,
9277 nla_data(info->attrs[NL80211_ATTR_IE]),
9281 for (i = 0; i < NUM_NL80211_BANDS; i++)
9282 if (wiphy->bands[i])
9284 (1 << wiphy->bands[i]->n_bitrates) - 1;
9286 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
9287 nla_for_each_nested(attr,
9288 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
9290 enum nl80211_band band = nla_type(attr);
9292 if (band < 0 || band >= NUM_NL80211_BANDS) {
9297 if (!wiphy->bands[band])
9300 err = ieee80211_get_ratemask(wiphy->bands[band],
9303 &request->rates[band]);
9309 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
9311 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
9312 request->duration_mandatory =
9313 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
9316 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
9322 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
9324 /* Initial implementation used NL80211_ATTR_MAC to set the specific
9325 * BSSID to scan for. This was problematic because that same attribute
9326 * was already used for another purpose (local random MAC address). The
9327 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
9328 * compatibility with older userspace components, also use the
9329 * NL80211_ATTR_MAC value here if it can be determined to be used for
9330 * the specific BSSID use case instead of the random MAC address
9331 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
9333 if (info->attrs[NL80211_ATTR_BSSID])
9334 memcpy(request->bssid,
9335 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
9336 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
9337 info->attrs[NL80211_ATTR_MAC])
9338 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
9341 eth_broadcast_addr(request->bssid);
9343 request->wdev = wdev;
9344 request->wiphy = &rdev->wiphy;
9345 request->scan_start = jiffies;
9347 rdev->scan_req = request;
9348 err = cfg80211_scan(rdev);
9353 nl80211_send_scan_start(rdev, wdev);
9354 dev_hold(wdev->netdev);
9359 rdev->scan_req = NULL;
9365 static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
9367 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9368 struct wireless_dev *wdev = info->user_ptr[1];
9370 if (!rdev->ops->abort_scan)
9376 if (!rdev->scan_req)
9379 rdev_abort_scan(rdev, wdev);
9384 nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
9385 struct cfg80211_sched_scan_request *request,
9386 struct nlattr **attrs)
9388 int tmp, err, i = 0;
9389 struct nlattr *attr;
9391 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
9395 * If scan plans are not specified,
9396 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
9397 * case one scan plan will be set with the specified scan
9398 * interval and infinite number of iterations.
9400 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
9404 request->scan_plans[0].interval =
9405 DIV_ROUND_UP(interval, MSEC_PER_SEC);
9406 if (!request->scan_plans[0].interval)
9409 if (request->scan_plans[0].interval >
9410 wiphy->max_sched_scan_plan_interval)
9411 request->scan_plans[0].interval =
9412 wiphy->max_sched_scan_plan_interval;
9417 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
9418 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
9420 if (WARN_ON(i >= n_plans))
9423 err = nla_parse_nested_deprecated(plan,
9424 NL80211_SCHED_SCAN_PLAN_MAX,
9425 attr, nl80211_plan_policy,
9430 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
9433 request->scan_plans[i].interval =
9434 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
9435 if (!request->scan_plans[i].interval ||
9436 request->scan_plans[i].interval >
9437 wiphy->max_sched_scan_plan_interval)
9440 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
9441 request->scan_plans[i].iterations =
9442 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
9443 if (!request->scan_plans[i].iterations ||
9444 (request->scan_plans[i].iterations >
9445 wiphy->max_sched_scan_plan_iterations))
9447 } else if (i < n_plans - 1) {
9449 * All scan plans but the last one must specify
9450 * a finite number of iterations
9459 * The last scan plan must not specify the number of
9460 * iterations, it is supposed to run infinitely
9462 if (request->scan_plans[n_plans - 1].iterations)
9469 nl80211_parse_sched_scan_per_band_rssi(struct wiphy *wiphy,
9470 struct cfg80211_match_set *match_sets,
9471 struct nlattr *tb_band_rssi,
9474 struct nlattr *attr;
9475 int i, tmp, ret = 0;
9477 if (!wiphy_ext_feature_isset(wiphy,
9478 NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD)) {
9482 for (i = 0; i < NUM_NL80211_BANDS; i++)
9483 match_sets->per_band_rssi_thold[i] =
9484 NL80211_SCAN_RSSI_THOLD_OFF;
9488 for (i = 0; i < NUM_NL80211_BANDS; i++)
9489 match_sets->per_band_rssi_thold[i] = rssi_thold;
9491 nla_for_each_nested(attr, tb_band_rssi, tmp) {
9492 enum nl80211_band band = nla_type(attr);
9494 if (band < 0 || band >= NUM_NL80211_BANDS)
9497 match_sets->per_band_rssi_thold[band] = nla_get_s32(attr);
9503 static struct cfg80211_sched_scan_request *
9504 nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
9505 struct nlattr **attrs, int max_match_sets)
9507 struct cfg80211_sched_scan_request *request;
9508 struct nlattr *attr;
9509 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
9510 enum nl80211_band band;
9511 size_t ie_len, size;
9512 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
9513 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
9515 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
9516 n_channels = validate_scan_freqs(
9517 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
9519 return ERR_PTR(-EINVAL);
9521 n_channels = ieee80211_get_num_supported_channels(wiphy);
9524 if (attrs[NL80211_ATTR_SCAN_SSIDS])
9525 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
9529 if (n_ssids > wiphy->max_sched_scan_ssids)
9530 return ERR_PTR(-EINVAL);
9533 * First, count the number of 'real' matchsets. Due to an issue with
9534 * the old implementation, matchsets containing only the RSSI attribute
9535 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
9536 * RSSI for all matchsets, rather than their own matchset for reporting
9537 * all APs with a strong RSSI. This is needed to be compatible with
9538 * older userspace that treated a matchset with only the RSSI as the
9539 * global RSSI for all other matchsets - if there are other matchsets.
9541 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
9542 nla_for_each_nested(attr,
9543 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
9545 struct nlattr *rssi;
9547 err = nla_parse_nested_deprecated(tb,
9548 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
9550 nl80211_match_policy,
9553 return ERR_PTR(err);
9555 /* SSID and BSSID are mutually exclusive */
9556 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
9557 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
9558 return ERR_PTR(-EINVAL);
9560 /* add other standalone attributes here */
9561 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
9562 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
9566 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
9568 default_match_rssi = nla_get_s32(rssi);
9572 /* However, if there's no other matchset, add the RSSI one */
9573 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
9576 if (n_match_sets > max_match_sets)
9577 return ERR_PTR(-EINVAL);
9579 if (attrs[NL80211_ATTR_IE])
9580 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
9584 if (ie_len > wiphy->max_sched_scan_ie_len)
9585 return ERR_PTR(-EINVAL);
9587 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
9589 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
9590 * each scan plan already specifies its own interval
9592 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
9593 return ERR_PTR(-EINVAL);
9595 nla_for_each_nested(attr,
9596 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
9600 * The scan interval attribute is kept for backward
9601 * compatibility. If no scan plans are specified and sched scan
9602 * interval is specified, one scan plan will be set with this
9603 * scan interval and infinite number of iterations.
9605 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
9606 return ERR_PTR(-EINVAL);
9611 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
9612 return ERR_PTR(-EINVAL);
9614 if (!wiphy_ext_feature_isset(
9615 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
9616 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
9617 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
9618 return ERR_PTR(-EINVAL);
9620 size = struct_size(request, channels, n_channels);
9621 size = size_add(size, array_size(sizeof(*request->ssids), n_ssids));
9622 size = size_add(size, array_size(sizeof(*request->match_sets),
9624 size = size_add(size, array_size(sizeof(*request->scan_plans),
9626 size = size_add(size, ie_len);
9627 request = kzalloc(size, GFP_KERNEL);
9629 return ERR_PTR(-ENOMEM);
9632 request->ssids = (void *)&request->channels[n_channels];
9633 request->n_ssids = n_ssids;
9636 request->ie = (void *)(request->ssids + n_ssids);
9638 request->ie = (void *)(request->channels + n_channels);
9643 request->match_sets = (void *)(request->ie + ie_len);
9645 request->match_sets =
9646 (void *)(request->ssids + n_ssids);
9648 request->match_sets =
9649 (void *)(request->channels + n_channels);
9651 request->n_match_sets = n_match_sets;
9654 request->scan_plans = (void *)(request->match_sets +
9656 else if (request->ie)
9657 request->scan_plans = (void *)(request->ie + ie_len);
9659 request->scan_plans = (void *)(request->ssids + n_ssids);
9661 request->scan_plans = (void *)(request->channels + n_channels);
9663 request->n_scan_plans = n_plans;
9666 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
9667 /* user specified, bail out if channel not found */
9668 nla_for_each_nested(attr,
9669 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
9671 struct ieee80211_channel *chan;
9673 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
9680 /* ignore disabled channels */
9681 if (chan->flags & IEEE80211_CHAN_DISABLED)
9684 request->channels[i] = chan;
9689 for (band = 0; band < NUM_NL80211_BANDS; band++) {
9692 if (!wiphy->bands[band])
9694 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
9695 struct ieee80211_channel *chan;
9697 chan = &wiphy->bands[band]->channels[j];
9699 if (chan->flags & IEEE80211_CHAN_DISABLED)
9702 request->channels[i] = chan;
9713 request->n_channels = i;
9717 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
9719 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
9723 request->ssids[i].ssid_len = nla_len(attr);
9724 memcpy(request->ssids[i].ssid, nla_data(attr),
9731 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
9732 nla_for_each_nested(attr,
9733 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
9735 struct nlattr *ssid, *bssid, *rssi;
9737 err = nla_parse_nested_deprecated(tb,
9738 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
9740 nl80211_match_policy,
9744 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
9745 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
9747 if (!ssid && !bssid) {
9752 if (WARN_ON(i >= n_match_sets)) {
9753 /* this indicates a programming error,
9754 * the loop above should have verified
9762 memcpy(request->match_sets[i].ssid.ssid,
9763 nla_data(ssid), nla_len(ssid));
9764 request->match_sets[i].ssid.ssid_len =
9768 memcpy(request->match_sets[i].bssid,
9769 nla_data(bssid), ETH_ALEN);
9771 /* special attribute - old implementation w/a */
9772 request->match_sets[i].rssi_thold = default_match_rssi;
9773 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
9775 request->match_sets[i].rssi_thold =
9778 /* Parse per band RSSI attribute */
9779 err = nl80211_parse_sched_scan_per_band_rssi(wiphy,
9780 &request->match_sets[i],
9781 tb[NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI],
9782 request->match_sets[i].rssi_thold);
9789 /* there was no other matchset, so the RSSI one is alone */
9790 if (i == 0 && n_match_sets)
9791 request->match_sets[0].rssi_thold = default_match_rssi;
9793 request->min_rssi_thold = INT_MAX;
9794 for (i = 0; i < n_match_sets; i++)
9795 request->min_rssi_thold =
9796 min(request->match_sets[i].rssi_thold,
9797 request->min_rssi_thold);
9799 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
9803 request->ie_len = ie_len;
9804 memcpy((void *)request->ie,
9805 nla_data(attrs[NL80211_ATTR_IE]),
9809 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true);
9813 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
9815 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
9817 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
9818 request->relative_rssi = nla_get_s8(
9819 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
9820 request->relative_rssi_set = true;
9823 if (request->relative_rssi_set &&
9824 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
9825 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
9827 rssi_adjust = nla_data(
9828 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
9829 request->rssi_adjust.band = rssi_adjust->band;
9830 request->rssi_adjust.delta = rssi_adjust->delta;
9831 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
9837 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
9841 request->scan_start = jiffies;
9847 return ERR_PTR(err);
9850 static int nl80211_start_sched_scan(struct sk_buff *skb,
9851 struct genl_info *info)
9853 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9854 struct net_device *dev = info->user_ptr[1];
9855 struct wireless_dev *wdev = dev->ieee80211_ptr;
9856 struct cfg80211_sched_scan_request *sched_scan_req;
9860 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
9863 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
9864 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
9868 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
9870 rdev->wiphy.max_match_sets);
9872 err = PTR_ERR_OR_ZERO(sched_scan_req);
9876 /* leave request id zero for legacy request
9877 * or if driver does not support multi-scheduled scan
9879 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1)
9880 sched_scan_req->reqid = cfg80211_assign_cookie(rdev);
9882 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
9886 sched_scan_req->dev = dev;
9887 sched_scan_req->wiphy = &rdev->wiphy;
9889 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
9890 sched_scan_req->owner_nlportid = info->snd_portid;
9892 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
9894 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
9898 kfree(sched_scan_req);
9903 static int nl80211_stop_sched_scan(struct sk_buff *skb,
9904 struct genl_info *info)
9906 struct cfg80211_sched_scan_request *req;
9907 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9910 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
9913 if (info->attrs[NL80211_ATTR_COOKIE]) {
9914 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
9915 return __cfg80211_stop_sched_scan(rdev, cookie, false);
9918 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
9919 struct cfg80211_sched_scan_request,
9921 if (!req || req->reqid ||
9922 (req->owner_nlportid &&
9923 req->owner_nlportid != info->snd_portid))
9926 return cfg80211_stop_sched_scan_req(rdev, req, false);
9929 static int nl80211_start_radar_detection(struct sk_buff *skb,
9930 struct genl_info *info)
9932 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9933 struct net_device *dev = info->user_ptr[1];
9934 struct wireless_dev *wdev = dev->ieee80211_ptr;
9935 struct wiphy *wiphy = wdev->wiphy;
9936 struct cfg80211_chan_def chandef;
9937 enum nl80211_dfs_regions dfs_region;
9938 unsigned int cac_time_ms;
9941 flush_delayed_work(&rdev->dfs_update_channels_wk);
9945 dfs_region = reg_get_dfs_region(wiphy);
9946 if (dfs_region == NL80211_DFS_UNSET)
9949 err = nl80211_parse_chandef(rdev, info, &chandef);
9953 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
9962 if (!cfg80211_chandef_dfs_usable(wiphy, &chandef)) {
9967 if (nla_get_flag(info->attrs[NL80211_ATTR_RADAR_BACKGROUND])) {
9968 err = cfg80211_start_background_radar_detection(rdev, wdev,
9973 if (netif_carrier_ok(dev)) {
9978 if (wdev->cac_started) {
9983 /* CAC start is offloaded to HW and can't be started manually */
9984 if (wiphy_ext_feature_isset(wiphy, NL80211_EXT_FEATURE_DFS_OFFLOAD)) {
9989 if (!rdev->ops->start_radar_detection) {
9994 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
9995 if (WARN_ON(!cac_time_ms))
9996 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
9998 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
10000 wdev->links[0].ap.chandef = chandef;
10001 wdev->cac_started = true;
10002 wdev->cac_start_time = jiffies;
10003 wdev->cac_time_ms = cac_time_ms;
10006 wiphy_unlock(wiphy);
10011 static int nl80211_notify_radar_detection(struct sk_buff *skb,
10012 struct genl_info *info)
10014 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10015 struct net_device *dev = info->user_ptr[1];
10016 struct wireless_dev *wdev = dev->ieee80211_ptr;
10017 struct wiphy *wiphy = wdev->wiphy;
10018 struct cfg80211_chan_def chandef;
10019 enum nl80211_dfs_regions dfs_region;
10022 dfs_region = reg_get_dfs_region(wiphy);
10023 if (dfs_region == NL80211_DFS_UNSET) {
10024 GENL_SET_ERR_MSG(info,
10025 "DFS Region is not set. Unexpected Radar indication");
10029 err = nl80211_parse_chandef(rdev, info, &chandef);
10031 GENL_SET_ERR_MSG(info, "Unable to extract chandef info");
10035 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
10037 GENL_SET_ERR_MSG(info, "chandef is invalid");
10042 GENL_SET_ERR_MSG(info,
10043 "Unexpected Radar indication for chandef/iftype");
10047 /* Do not process this notification if radar is already detected
10048 * by kernel on this channel, and return success.
10050 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE)
10053 cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_UNAVAILABLE);
10055 cfg80211_sched_dfs_chan_update(rdev);
10057 rdev->radar_chandef = chandef;
10059 /* Propagate this notification to other radios as well */
10060 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
10065 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
10067 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10068 unsigned int link_id = nl80211_link_id(info->attrs);
10069 struct net_device *dev = info->user_ptr[1];
10070 struct wireless_dev *wdev = dev->ieee80211_ptr;
10071 struct cfg80211_csa_settings params;
10072 struct nlattr **csa_attrs = NULL;
10074 bool need_new_beacon = false;
10075 bool need_handle_dfs_flag = true;
10079 if (!rdev->ops->channel_switch ||
10080 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
10081 return -EOPNOTSUPP;
10083 switch (dev->ieee80211_ptr->iftype) {
10084 case NL80211_IFTYPE_AP:
10085 case NL80211_IFTYPE_P2P_GO:
10086 need_new_beacon = true;
10087 /* For all modes except AP the handle_dfs flag needs to be
10088 * supplied to tell the kernel that userspace will handle radar
10089 * events when they happen. Otherwise a switch to a channel
10090 * requiring DFS will be rejected.
10092 need_handle_dfs_flag = false;
10094 /* useless if AP is not running */
10095 if (!wdev->links[link_id].ap.beacon_interval)
10098 case NL80211_IFTYPE_ADHOC:
10099 if (!wdev->u.ibss.ssid_len)
10102 case NL80211_IFTYPE_MESH_POINT:
10103 if (!wdev->u.mesh.id_len)
10107 return -EOPNOTSUPP;
10110 memset(¶ms, 0, sizeof(params));
10111 params.beacon_csa.ftm_responder = -1;
10113 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
10114 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
10117 /* only important for AP, IBSS and mesh create IEs internally */
10118 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
10121 /* Even though the attribute is u32, the specification says
10122 * u8, so let's make sure we don't overflow.
10124 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
10125 if (cs_count > 255)
10128 params.count = cs_count;
10130 if (!need_new_beacon)
10133 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after,
10138 csa_attrs = kcalloc(NL80211_ATTR_MAX + 1, sizeof(*csa_attrs),
10145 err = nla_parse_nested_deprecated(csa_attrs, NL80211_ATTR_MAX,
10146 info->attrs[NL80211_ATTR_CSA_IES],
10147 nl80211_policy, info->extack);
10151 err = nl80211_parse_beacon(rdev, csa_attrs, ¶ms.beacon_csa,
10156 if (!csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]) {
10161 len = nla_len(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]);
10162 if (!len || (len % sizeof(u16))) {
10167 params.n_counter_offsets_beacon = len / sizeof(u16);
10168 if (rdev->wiphy.max_num_csa_counters &&
10169 (params.n_counter_offsets_beacon >
10170 rdev->wiphy.max_num_csa_counters)) {
10175 params.counter_offsets_beacon =
10176 nla_data(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]);
10178 /* sanity checks - counters should fit and be the same */
10179 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
10180 u16 offset = params.counter_offsets_beacon[i];
10182 if (offset >= params.beacon_csa.tail_len) {
10187 if (params.beacon_csa.tail[offset] != params.count) {
10193 if (csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]) {
10194 len = nla_len(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]);
10195 if (!len || (len % sizeof(u16))) {
10200 params.n_counter_offsets_presp = len / sizeof(u16);
10201 if (rdev->wiphy.max_num_csa_counters &&
10202 (params.n_counter_offsets_presp >
10203 rdev->wiphy.max_num_csa_counters)) {
10208 params.counter_offsets_presp =
10209 nla_data(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]);
10211 /* sanity checks - counters should fit and be the same */
10212 for (i = 0; i < params.n_counter_offsets_presp; i++) {
10213 u16 offset = params.counter_offsets_presp[i];
10215 if (offset >= params.beacon_csa.probe_resp_len) {
10220 if (params.beacon_csa.probe_resp[offset] !=
10229 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
10233 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
10239 err = cfg80211_chandef_dfs_required(wdev->wiphy,
10246 params.radar_required = true;
10247 if (need_handle_dfs_flag &&
10248 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
10254 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
10255 params.block_tx = true;
10257 if (info->attrs[NL80211_ATTR_PUNCT_BITMAP]) {
10258 err = nl80211_parse_punct_bitmap(rdev, info,
10260 ¶ms.punct_bitmap);
10266 err = rdev_channel_switch(rdev, dev, ¶ms);
10270 kfree(params.beacon_after.mbssid_ies);
10271 kfree(params.beacon_csa.mbssid_ies);
10272 kfree(params.beacon_after.rnr_ies);
10273 kfree(params.beacon_csa.rnr_ies);
10278 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
10279 u32 seq, int flags,
10280 struct cfg80211_registered_device *rdev,
10281 struct wireless_dev *wdev,
10282 struct cfg80211_internal_bss *intbss)
10284 struct cfg80211_bss *res = &intbss->pub;
10285 const struct cfg80211_bss_ies *ies;
10286 unsigned int link_id;
10288 struct nlattr *bss;
10290 ASSERT_WDEV_LOCK(wdev);
10292 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
10293 NL80211_CMD_NEW_SCAN_RESULTS);
10297 genl_dump_check_consistent(cb, hdr);
10299 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
10300 goto nla_put_failure;
10301 if (wdev->netdev &&
10302 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
10303 goto nla_put_failure;
10304 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
10306 goto nla_put_failure;
10308 bss = nla_nest_start_noflag(msg, NL80211_ATTR_BSS);
10310 goto nla_put_failure;
10311 if ((!is_zero_ether_addr(res->bssid) &&
10312 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
10313 goto nla_put_failure;
10316 /* indicate whether we have probe response data or not */
10317 if (rcu_access_pointer(res->proberesp_ies) &&
10318 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
10319 goto fail_unlock_rcu;
10321 /* this pointer prefers to be pointed to probe response data
10322 * but is always valid
10324 ies = rcu_dereference(res->ies);
10326 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
10328 goto fail_unlock_rcu;
10329 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
10330 ies->len, ies->data))
10331 goto fail_unlock_rcu;
10334 /* and this pointer is always (unless driver didn't know) beacon data */
10335 ies = rcu_dereference(res->beacon_ies);
10336 if (ies && ies->from_beacon) {
10337 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
10339 goto fail_unlock_rcu;
10340 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
10341 ies->len, ies->data))
10342 goto fail_unlock_rcu;
10346 if (res->beacon_interval &&
10347 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
10348 goto nla_put_failure;
10349 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
10350 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
10351 nla_put_u32(msg, NL80211_BSS_FREQUENCY_OFFSET,
10352 res->channel->freq_offset) ||
10353 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
10354 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
10355 jiffies_to_msecs(jiffies - intbss->ts)))
10356 goto nla_put_failure;
10358 if (intbss->parent_tsf &&
10359 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
10360 intbss->parent_tsf, NL80211_BSS_PAD) ||
10361 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
10362 intbss->parent_bssid)))
10363 goto nla_put_failure;
10365 if (intbss->ts_boottime &&
10366 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
10367 intbss->ts_boottime, NL80211_BSS_PAD))
10368 goto nla_put_failure;
10370 if (!nl80211_put_signal(msg, intbss->pub.chains,
10371 intbss->pub.chain_signal,
10372 NL80211_BSS_CHAIN_SIGNAL))
10373 goto nla_put_failure;
10375 switch (rdev->wiphy.signal_type) {
10376 case CFG80211_SIGNAL_TYPE_MBM:
10377 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
10378 goto nla_put_failure;
10380 case CFG80211_SIGNAL_TYPE_UNSPEC:
10381 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
10382 goto nla_put_failure;
10388 switch (wdev->iftype) {
10389 case NL80211_IFTYPE_P2P_CLIENT:
10390 case NL80211_IFTYPE_STATION:
10391 for_each_valid_link(wdev, link_id) {
10392 if (intbss == wdev->links[link_id].client.current_bss &&
10393 (nla_put_u32(msg, NL80211_BSS_STATUS,
10394 NL80211_BSS_STATUS_ASSOCIATED) ||
10395 (wdev->valid_links &&
10396 (nla_put_u8(msg, NL80211_BSS_MLO_LINK_ID,
10398 nla_put(msg, NL80211_BSS_MLD_ADDR, ETH_ALEN,
10399 wdev->u.client.connected_addr)))))
10400 goto nla_put_failure;
10403 case NL80211_IFTYPE_ADHOC:
10404 if (intbss == wdev->u.ibss.current_bss &&
10405 nla_put_u32(msg, NL80211_BSS_STATUS,
10406 NL80211_BSS_STATUS_IBSS_JOINED))
10407 goto nla_put_failure;
10413 nla_nest_end(msg, bss);
10415 genlmsg_end(msg, hdr);
10421 genlmsg_cancel(msg, hdr);
10425 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
10427 struct cfg80211_registered_device *rdev;
10428 struct cfg80211_internal_bss *scan;
10429 struct wireless_dev *wdev;
10430 int start = cb->args[2], idx = 0;
10433 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL);
10436 /* nl80211_prepare_wdev_dump acquired it in the successful case */
10437 __acquire(&rdev->wiphy.mtx);
10440 spin_lock_bh(&rdev->bss_lock);
10443 * dump_scan will be called multiple times to break up the scan results
10444 * into multiple messages. It is unlikely that any more bss-es will be
10445 * expired after the first call, so only call only call this on the
10446 * first dump_scan invocation.
10449 cfg80211_bss_expire(rdev);
10451 cb->seq = rdev->bss_generation;
10453 list_for_each_entry(scan, &rdev->bss_list, list) {
10454 if (++idx <= start)
10456 if (nl80211_send_bss(skb, cb,
10457 cb->nlh->nlmsg_seq, NLM_F_MULTI,
10458 rdev, wdev, scan) < 0) {
10464 spin_unlock_bh(&rdev->bss_lock);
10468 wiphy_unlock(&rdev->wiphy);
10473 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
10474 int flags, struct net_device *dev,
10475 bool allow_radio_stats,
10476 struct survey_info *survey)
10479 struct nlattr *infoattr;
10481 /* skip radio stats if userspace didn't request them */
10482 if (!survey->channel && !allow_radio_stats)
10485 hdr = nl80211hdr_put(msg, portid, seq, flags,
10486 NL80211_CMD_NEW_SURVEY_RESULTS);
10490 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
10491 goto nla_put_failure;
10493 infoattr = nla_nest_start_noflag(msg, NL80211_ATTR_SURVEY_INFO);
10495 goto nla_put_failure;
10497 if (survey->channel &&
10498 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
10499 survey->channel->center_freq))
10500 goto nla_put_failure;
10502 if (survey->channel && survey->channel->freq_offset &&
10503 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY_OFFSET,
10504 survey->channel->freq_offset))
10505 goto nla_put_failure;
10507 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
10508 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
10509 goto nla_put_failure;
10510 if ((survey->filled & SURVEY_INFO_IN_USE) &&
10511 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
10512 goto nla_put_failure;
10513 if ((survey->filled & SURVEY_INFO_TIME) &&
10514 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
10515 survey->time, NL80211_SURVEY_INFO_PAD))
10516 goto nla_put_failure;
10517 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
10518 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
10519 survey->time_busy, NL80211_SURVEY_INFO_PAD))
10520 goto nla_put_failure;
10521 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
10522 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
10523 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
10524 goto nla_put_failure;
10525 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
10526 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
10527 survey->time_rx, NL80211_SURVEY_INFO_PAD))
10528 goto nla_put_failure;
10529 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
10530 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
10531 survey->time_tx, NL80211_SURVEY_INFO_PAD))
10532 goto nla_put_failure;
10533 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
10534 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
10535 survey->time_scan, NL80211_SURVEY_INFO_PAD))
10536 goto nla_put_failure;
10537 if ((survey->filled & SURVEY_INFO_TIME_BSS_RX) &&
10538 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BSS_RX,
10539 survey->time_bss_rx, NL80211_SURVEY_INFO_PAD))
10540 goto nla_put_failure;
10542 nla_nest_end(msg, infoattr);
10544 genlmsg_end(msg, hdr);
10548 genlmsg_cancel(msg, hdr);
10552 static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
10554 struct nlattr **attrbuf;
10555 struct survey_info survey;
10556 struct cfg80211_registered_device *rdev;
10557 struct wireless_dev *wdev;
10558 int survey_idx = cb->args[2];
10562 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
10566 res = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, attrbuf);
10571 /* nl80211_prepare_wdev_dump acquired it in the successful case */
10572 __acquire(&rdev->wiphy.mtx);
10574 /* prepare_wdev_dump parsed the attributes */
10575 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
10577 if (!wdev->netdev) {
10582 if (!rdev->ops->dump_survey) {
10589 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
10591 if (res == -ENOENT)
10596 /* don't send disabled channels, but do send non-channel data */
10597 if (survey.channel &&
10598 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
10603 if (nl80211_send_survey(skb,
10604 NETLINK_CB(cb->skb).portid,
10605 cb->nlh->nlmsg_seq, NLM_F_MULTI,
10606 wdev->netdev, radio_stats, &survey) < 0)
10612 cb->args[2] = survey_idx;
10616 wiphy_unlock(&rdev->wiphy);
10620 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
10622 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
10623 NL80211_WPA_VERSION_2 |
10624 NL80211_WPA_VERSION_3));
10627 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
10629 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10630 struct net_device *dev = info->user_ptr[1];
10631 struct ieee80211_channel *chan;
10632 const u8 *bssid, *ssid;
10634 enum nl80211_auth_type auth_type;
10635 struct key_parse key;
10636 bool local_state_change;
10637 struct cfg80211_auth_request req = {};
10640 if (!info->attrs[NL80211_ATTR_MAC])
10643 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
10646 if (!info->attrs[NL80211_ATTR_SSID])
10649 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
10652 err = nl80211_parse_key(info, &key);
10656 if (key.idx >= 0) {
10657 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
10659 if (!key.p.key || !key.p.key_len)
10661 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
10662 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
10663 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
10664 key.p.key_len != WLAN_KEY_LEN_WEP104))
10673 if (key.idx >= 0) {
10677 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
10678 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
10687 if (!rdev->ops->auth)
10688 return -EOPNOTSUPP;
10690 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10691 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10692 return -EOPNOTSUPP;
10694 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10695 freq = MHZ_TO_KHZ(nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
10696 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
10698 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
10700 chan = nl80211_get_valid_chan(&rdev->wiphy, freq);
10704 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10705 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10707 if (info->attrs[NL80211_ATTR_IE]) {
10708 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10709 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10712 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
10713 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
10716 if ((auth_type == NL80211_AUTHTYPE_SAE ||
10717 auth_type == NL80211_AUTHTYPE_FILS_SK ||
10718 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
10719 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
10720 !info->attrs[NL80211_ATTR_AUTH_DATA])
10723 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
10724 if (auth_type != NL80211_AUTHTYPE_SAE &&
10725 auth_type != NL80211_AUTHTYPE_FILS_SK &&
10726 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
10727 auth_type != NL80211_AUTHTYPE_FILS_PK)
10729 req.auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
10730 req.auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
10733 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
10736 * Since we no longer track auth state, ignore
10737 * requests to only change local state.
10739 if (local_state_change)
10742 req.auth_type = auth_type;
10743 req.key = key.p.key;
10744 req.key_len = key.p.key_len;
10745 req.key_idx = key.idx;
10746 req.link_id = nl80211_link_id_or_invalid(info->attrs);
10747 if (req.link_id >= 0) {
10748 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO))
10750 if (!info->attrs[NL80211_ATTR_MLD_ADDR])
10752 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
10753 if (!is_valid_ether_addr(req.ap_mld_addr))
10757 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
10758 IEEE80211_BSS_TYPE_ESS,
10759 IEEE80211_PRIVACY_ANY);
10763 wdev_lock(dev->ieee80211_ptr);
10764 err = cfg80211_mlme_auth(rdev, dev, &req);
10765 wdev_unlock(dev->ieee80211_ptr);
10767 cfg80211_put_bss(&rdev->wiphy, req.bss);
10772 static int validate_pae_over_nl80211(struct cfg80211_registered_device *rdev,
10773 struct genl_info *info)
10775 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10776 GENL_SET_ERR_MSG(info, "SOCKET_OWNER not set");
10780 if (!rdev->ops->tx_control_port ||
10781 !wiphy_ext_feature_isset(&rdev->wiphy,
10782 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
10783 return -EOPNOTSUPP;
10788 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
10789 struct genl_info *info,
10790 struct cfg80211_crypto_settings *settings,
10793 memset(settings, 0, sizeof(*settings));
10795 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
10797 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
10800 proto = nla_get_u16(
10801 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
10802 settings->control_port_ethertype = cpu_to_be16(proto);
10803 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
10804 proto != ETH_P_PAE)
10806 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
10807 settings->control_port_no_encrypt = true;
10809 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
10811 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
10812 int r = validate_pae_over_nl80211(rdev, info);
10817 settings->control_port_over_nl80211 = true;
10819 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_PREAUTH])
10820 settings->control_port_no_preauth = true;
10823 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
10827 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
10828 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
10829 settings->n_ciphers_pairwise = len / sizeof(u32);
10831 if (len % sizeof(u32))
10834 if (settings->n_ciphers_pairwise > cipher_limit)
10837 memcpy(settings->ciphers_pairwise, data, len);
10839 for (i = 0; i < settings->n_ciphers_pairwise; i++)
10840 if (!cfg80211_supported_cipher_suite(
10842 settings->ciphers_pairwise[i]))
10846 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
10847 settings->cipher_group =
10848 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
10849 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
10850 settings->cipher_group))
10854 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
10855 settings->wpa_versions =
10856 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
10857 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
10861 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
10865 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
10866 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
10867 settings->n_akm_suites = len / sizeof(u32);
10869 if (len % sizeof(u32))
10872 if (settings->n_akm_suites > rdev->wiphy.max_num_akm_suites)
10875 memcpy(settings->akm_suites, data, len);
10878 if (info->attrs[NL80211_ATTR_PMK]) {
10879 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
10881 if (!wiphy_ext_feature_isset(&rdev->wiphy,
10882 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK) &&
10883 !wiphy_ext_feature_isset(&rdev->wiphy,
10884 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK))
10886 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
10889 if (info->attrs[NL80211_ATTR_SAE_PASSWORD]) {
10890 if (!wiphy_ext_feature_isset(&rdev->wiphy,
10891 NL80211_EXT_FEATURE_SAE_OFFLOAD) &&
10892 !wiphy_ext_feature_isset(&rdev->wiphy,
10893 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP))
10895 settings->sae_pwd =
10896 nla_data(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
10897 settings->sae_pwd_len =
10898 nla_len(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
10901 if (info->attrs[NL80211_ATTR_SAE_PWE])
10902 settings->sae_pwe =
10903 nla_get_u8(info->attrs[NL80211_ATTR_SAE_PWE]);
10905 settings->sae_pwe = NL80211_SAE_PWE_UNSPECIFIED;
10910 static struct cfg80211_bss *nl80211_assoc_bss(struct cfg80211_registered_device *rdev,
10911 const u8 *ssid, int ssid_len,
10912 struct nlattr **attrs)
10914 struct ieee80211_channel *chan;
10915 struct cfg80211_bss *bss;
10919 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_WIPHY_FREQ])
10920 return ERR_PTR(-EINVAL);
10922 bssid = nla_data(attrs[NL80211_ATTR_MAC]);
10924 freq = MHZ_TO_KHZ(nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]));
10925 if (attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
10926 freq += nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
10928 chan = nl80211_get_valid_chan(&rdev->wiphy, freq);
10930 return ERR_PTR(-EINVAL);
10932 bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid,
10934 IEEE80211_BSS_TYPE_ESS,
10935 IEEE80211_PRIVACY_ANY);
10937 return ERR_PTR(-ENOENT);
10942 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
10944 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10945 struct net_device *dev = info->user_ptr[1];
10946 struct cfg80211_assoc_request req = {};
10947 struct nlattr **attrs = NULL;
10948 const u8 *ap_addr, *ssid;
10949 unsigned int link_id;
10952 if (dev->ieee80211_ptr->conn_owner_nlportid &&
10953 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
10956 if (!info->attrs[NL80211_ATTR_SSID])
10959 if (!rdev->ops->assoc)
10960 return -EOPNOTSUPP;
10962 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10963 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10964 return -EOPNOTSUPP;
10966 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10967 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10969 if (info->attrs[NL80211_ATTR_IE]) {
10970 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10971 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10973 if (cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE,
10974 req.ie, req.ie_len)) {
10975 GENL_SET_ERR_MSG(info,
10976 "non-inheritance makes no sense");
10981 if (info->attrs[NL80211_ATTR_USE_MFP]) {
10982 enum nl80211_mfp mfp =
10983 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
10984 if (mfp == NL80211_MFP_REQUIRED)
10985 req.use_mfp = true;
10986 else if (mfp != NL80211_MFP_NO)
10990 if (info->attrs[NL80211_ATTR_PREV_BSSID])
10991 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
10993 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
10994 req.flags |= ASSOC_REQ_DISABLE_HT;
10996 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10997 memcpy(&req.ht_capa_mask,
10998 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
10999 sizeof(req.ht_capa_mask));
11001 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
11002 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
11004 memcpy(&req.ht_capa,
11005 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
11006 sizeof(req.ht_capa));
11009 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
11010 req.flags |= ASSOC_REQ_DISABLE_VHT;
11012 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE]))
11013 req.flags |= ASSOC_REQ_DISABLE_HE;
11015 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_EHT]))
11016 req.flags |= ASSOC_REQ_DISABLE_EHT;
11018 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
11019 memcpy(&req.vht_capa_mask,
11020 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
11021 sizeof(req.vht_capa_mask));
11023 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
11024 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
11026 memcpy(&req.vht_capa,
11027 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
11028 sizeof(req.vht_capa));
11031 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
11032 if (!((rdev->wiphy.features &
11033 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
11034 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
11035 !wiphy_ext_feature_isset(&rdev->wiphy,
11036 NL80211_EXT_FEATURE_RRM))
11038 req.flags |= ASSOC_REQ_USE_RRM;
11041 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
11042 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
11043 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
11044 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
11047 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
11050 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]) {
11051 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY])
11053 memcpy(&req.s1g_capa_mask,
11054 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]),
11055 sizeof(req.s1g_capa_mask));
11058 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY]) {
11059 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK])
11061 memcpy(&req.s1g_capa,
11062 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY]),
11063 sizeof(req.s1g_capa));
11066 req.link_id = nl80211_link_id_or_invalid(info->attrs);
11068 if (info->attrs[NL80211_ATTR_MLO_LINKS]) {
11069 unsigned int attrsize = NUM_NL80211_ATTR * sizeof(*attrs);
11070 struct nlattr *link;
11073 if (req.link_id < 0)
11076 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO))
11079 if (info->attrs[NL80211_ATTR_MAC] ||
11080 info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
11081 !info->attrs[NL80211_ATTR_MLD_ADDR])
11084 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
11085 ap_addr = req.ap_mld_addr;
11087 attrs = kzalloc(attrsize, GFP_KERNEL);
11091 nla_for_each_nested(link,
11092 info->attrs[NL80211_ATTR_MLO_LINKS],
11094 memset(attrs, 0, attrsize);
11096 nla_parse_nested(attrs, NL80211_ATTR_MAX,
11099 if (!attrs[NL80211_ATTR_MLO_LINK_ID]) {
11104 link_id = nla_get_u8(attrs[NL80211_ATTR_MLO_LINK_ID]);
11105 /* cannot use the same link ID again */
11106 if (req.links[link_id].bss) {
11110 req.links[link_id].bss =
11111 nl80211_assoc_bss(rdev, ssid, ssid_len, attrs);
11112 if (IS_ERR(req.links[link_id].bss)) {
11113 err = PTR_ERR(req.links[link_id].bss);
11114 req.links[link_id].bss = NULL;
11118 if (attrs[NL80211_ATTR_IE]) {
11119 req.links[link_id].elems =
11120 nla_data(attrs[NL80211_ATTR_IE]);
11121 req.links[link_id].elems_len =
11122 nla_len(attrs[NL80211_ATTR_IE]);
11124 if (cfg80211_find_elem(WLAN_EID_FRAGMENT,
11125 req.links[link_id].elems,
11126 req.links[link_id].elems_len)) {
11127 GENL_SET_ERR_MSG(info,
11128 "cannot deal with fragmentation");
11133 if (cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE,
11134 req.links[link_id].elems,
11135 req.links[link_id].elems_len)) {
11136 GENL_SET_ERR_MSG(info,
11137 "cannot deal with non-inheritance");
11143 req.links[link_id].disabled =
11144 nla_get_flag(attrs[NL80211_ATTR_MLO_LINK_DISABLED]);
11147 if (!req.links[req.link_id].bss) {
11152 if (req.links[req.link_id].elems_len) {
11153 GENL_SET_ERR_MSG(info,
11154 "cannot have per-link elems on assoc link");
11159 if (req.links[req.link_id].disabled) {
11160 GENL_SET_ERR_MSG(info,
11161 "cannot have assoc link disabled");
11169 if (req.link_id >= 0)
11172 req.bss = nl80211_assoc_bss(rdev, ssid, ssid_len, info->attrs);
11173 if (IS_ERR(req.bss))
11174 return PTR_ERR(req.bss);
11175 ap_addr = req.bss->bssid;
11178 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
11180 wdev_lock(dev->ieee80211_ptr);
11182 err = cfg80211_mlme_assoc(rdev, dev, &req);
11184 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
11185 dev->ieee80211_ptr->conn_owner_nlportid =
11187 memcpy(dev->ieee80211_ptr->disconnect_bssid,
11188 ap_addr, ETH_ALEN);
11191 wdev_unlock(dev->ieee80211_ptr);
11195 for (link_id = 0; link_id < ARRAY_SIZE(req.links); link_id++)
11196 cfg80211_put_bss(&rdev->wiphy, req.links[link_id].bss);
11197 cfg80211_put_bss(&rdev->wiphy, req.bss);
11203 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
11205 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11206 struct net_device *dev = info->user_ptr[1];
11207 const u8 *ie = NULL, *bssid;
11208 int ie_len = 0, err;
11210 bool local_state_change;
11212 if (dev->ieee80211_ptr->conn_owner_nlportid &&
11213 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
11216 if (!info->attrs[NL80211_ATTR_MAC])
11219 if (!info->attrs[NL80211_ATTR_REASON_CODE])
11222 if (!rdev->ops->deauth)
11223 return -EOPNOTSUPP;
11225 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11226 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
11227 return -EOPNOTSUPP;
11229 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
11231 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
11232 if (reason_code == 0) {
11233 /* Reason Code 0 is reserved */
11237 if (info->attrs[NL80211_ATTR_IE]) {
11238 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11239 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11242 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
11244 wdev_lock(dev->ieee80211_ptr);
11245 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
11246 local_state_change);
11247 wdev_unlock(dev->ieee80211_ptr);
11251 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
11253 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11254 struct net_device *dev = info->user_ptr[1];
11255 const u8 *ie = NULL, *bssid;
11256 int ie_len = 0, err;
11258 bool local_state_change;
11260 if (dev->ieee80211_ptr->conn_owner_nlportid &&
11261 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
11264 if (!info->attrs[NL80211_ATTR_MAC])
11267 if (!info->attrs[NL80211_ATTR_REASON_CODE])
11270 if (!rdev->ops->disassoc)
11271 return -EOPNOTSUPP;
11273 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11274 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
11275 return -EOPNOTSUPP;
11277 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
11279 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
11280 if (reason_code == 0) {
11281 /* Reason Code 0 is reserved */
11285 if (info->attrs[NL80211_ATTR_IE]) {
11286 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11287 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11290 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
11292 wdev_lock(dev->ieee80211_ptr);
11293 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
11294 local_state_change);
11295 wdev_unlock(dev->ieee80211_ptr);
11300 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
11301 int mcast_rate[NUM_NL80211_BANDS],
11304 struct wiphy *wiphy = &rdev->wiphy;
11305 bool found = false;
11308 for (band = 0; band < NUM_NL80211_BANDS; band++) {
11309 struct ieee80211_supported_band *sband;
11311 sband = wiphy->bands[band];
11315 for (i = 0; i < sband->n_bitrates; i++) {
11316 if (sband->bitrates[i].bitrate == rateval) {
11317 mcast_rate[band] = i + 1;
11327 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
11329 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11330 struct net_device *dev = info->user_ptr[1];
11331 struct cfg80211_ibss_params ibss;
11332 struct wiphy *wiphy;
11333 struct cfg80211_cached_keys *connkeys = NULL;
11336 memset(&ibss, 0, sizeof(ibss));
11338 if (!info->attrs[NL80211_ATTR_SSID] ||
11339 !nla_len(info->attrs[NL80211_ATTR_SSID]))
11342 ibss.beacon_interval = 100;
11344 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
11345 ibss.beacon_interval =
11346 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
11348 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
11349 ibss.beacon_interval);
11353 if (!rdev->ops->join_ibss)
11354 return -EOPNOTSUPP;
11356 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
11357 return -EOPNOTSUPP;
11359 wiphy = &rdev->wiphy;
11361 if (info->attrs[NL80211_ATTR_MAC]) {
11362 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
11364 if (!is_valid_ether_addr(ibss.bssid))
11367 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
11368 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
11370 if (info->attrs[NL80211_ATTR_IE]) {
11371 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11372 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11375 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
11379 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
11380 NL80211_IFTYPE_ADHOC))
11383 switch (ibss.chandef.width) {
11384 case NL80211_CHAN_WIDTH_5:
11385 case NL80211_CHAN_WIDTH_10:
11386 case NL80211_CHAN_WIDTH_20_NOHT:
11388 case NL80211_CHAN_WIDTH_20:
11389 case NL80211_CHAN_WIDTH_40:
11390 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
11393 case NL80211_CHAN_WIDTH_80:
11394 case NL80211_CHAN_WIDTH_80P80:
11395 case NL80211_CHAN_WIDTH_160:
11396 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
11398 if (!wiphy_ext_feature_isset(&rdev->wiphy,
11399 NL80211_EXT_FEATURE_VHT_IBSS))
11402 case NL80211_CHAN_WIDTH_320:
11408 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
11409 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
11411 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
11413 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
11415 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
11416 struct ieee80211_supported_band *sband =
11417 wiphy->bands[ibss.chandef.chan->band];
11419 err = ieee80211_get_ratemask(sband, rates, n_rates,
11420 &ibss.basic_rates);
11425 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
11426 memcpy(&ibss.ht_capa_mask,
11427 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
11428 sizeof(ibss.ht_capa_mask));
11430 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
11431 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
11433 memcpy(&ibss.ht_capa,
11434 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
11435 sizeof(ibss.ht_capa));
11438 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
11439 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
11440 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
11443 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
11444 bool no_ht = false;
11446 connkeys = nl80211_parse_connkeys(rdev, info, &no_ht);
11447 if (IS_ERR(connkeys))
11448 return PTR_ERR(connkeys);
11450 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
11452 kfree_sensitive(connkeys);
11457 ibss.control_port =
11458 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
11460 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
11461 int r = validate_pae_over_nl80211(rdev, info);
11464 kfree_sensitive(connkeys);
11468 ibss.control_port_over_nl80211 = true;
11471 ibss.userspace_handles_dfs =
11472 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
11474 wdev_lock(dev->ieee80211_ptr);
11475 err = __cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
11477 kfree_sensitive(connkeys);
11478 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
11479 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
11480 wdev_unlock(dev->ieee80211_ptr);
11485 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
11487 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11488 struct net_device *dev = info->user_ptr[1];
11490 if (!rdev->ops->leave_ibss)
11491 return -EOPNOTSUPP;
11493 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
11494 return -EOPNOTSUPP;
11496 return cfg80211_leave_ibss(rdev, dev, false);
11499 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
11501 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11502 struct net_device *dev = info->user_ptr[1];
11503 int mcast_rate[NUM_NL80211_BANDS];
11506 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
11507 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
11508 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
11509 return -EOPNOTSUPP;
11511 if (!rdev->ops->set_mcast_rate)
11512 return -EOPNOTSUPP;
11514 memset(mcast_rate, 0, sizeof(mcast_rate));
11516 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
11519 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
11520 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
11523 return rdev_set_mcast_rate(rdev, dev, mcast_rate);
11526 static struct sk_buff *
11527 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
11528 struct wireless_dev *wdev, int approxlen,
11529 u32 portid, u32 seq, enum nl80211_commands cmd,
11530 enum nl80211_attrs attr,
11531 const struct nl80211_vendor_cmd_info *info,
11534 struct sk_buff *skb;
11536 struct nlattr *data;
11538 skb = nlmsg_new(approxlen + 100, gfp);
11542 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
11548 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
11549 goto nla_put_failure;
11552 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
11554 goto nla_put_failure;
11555 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
11557 goto nla_put_failure;
11561 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
11562 wdev_id(wdev), NL80211_ATTR_PAD))
11563 goto nla_put_failure;
11564 if (wdev->netdev &&
11565 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
11566 wdev->netdev->ifindex))
11567 goto nla_put_failure;
11570 data = nla_nest_start_noflag(skb, attr);
11572 goto nla_put_failure;
11574 ((void **)skb->cb)[0] = rdev;
11575 ((void **)skb->cb)[1] = hdr;
11576 ((void **)skb->cb)[2] = data;
11585 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
11586 struct wireless_dev *wdev,
11587 enum nl80211_commands cmd,
11588 enum nl80211_attrs attr,
11589 unsigned int portid,
11590 int vendor_event_idx,
11591 int approxlen, gfp_t gfp)
11593 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11594 const struct nl80211_vendor_cmd_info *info;
11597 case NL80211_CMD_TESTMODE:
11598 if (WARN_ON(vendor_event_idx != -1))
11602 case NL80211_CMD_VENDOR:
11603 if (WARN_ON(vendor_event_idx < 0 ||
11604 vendor_event_idx >= wiphy->n_vendor_events))
11606 info = &wiphy->vendor_events[vendor_event_idx];
11613 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, portid, 0,
11614 cmd, attr, info, gfp);
11616 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
11618 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
11620 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
11621 void *hdr = ((void **)skb->cb)[1];
11622 struct nlmsghdr *nlhdr = nlmsg_hdr(skb);
11623 struct nlattr *data = ((void **)skb->cb)[2];
11624 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
11626 /* clear CB data for netlink core to own from now on */
11627 memset(skb->cb, 0, sizeof(skb->cb));
11629 nla_nest_end(skb, data);
11630 genlmsg_end(skb, hdr);
11632 if (nlhdr->nlmsg_pid) {
11633 genlmsg_unicast(wiphy_net(&rdev->wiphy), skb,
11636 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
11637 mcgrp = NL80211_MCGRP_VENDOR;
11639 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
11640 skb, 0, mcgrp, gfp);
11643 EXPORT_SYMBOL(__cfg80211_send_event_skb);
11645 #ifdef CONFIG_NL80211_TESTMODE
11646 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
11648 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11649 struct wireless_dev *wdev;
11652 lockdep_assert_held(&rdev->wiphy.mtx);
11654 wdev = __cfg80211_wdev_from_attrs(rdev, genl_info_net(info),
11657 if (!rdev->ops->testmode_cmd)
11658 return -EOPNOTSUPP;
11660 if (IS_ERR(wdev)) {
11661 err = PTR_ERR(wdev);
11662 if (err != -EINVAL)
11665 } else if (wdev->wiphy != &rdev->wiphy) {
11669 if (!info->attrs[NL80211_ATTR_TESTDATA])
11672 rdev->cur_cmd_info = info;
11673 err = rdev_testmode_cmd(rdev, wdev,
11674 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
11675 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
11676 rdev->cur_cmd_info = NULL;
11681 static int nl80211_testmode_dump(struct sk_buff *skb,
11682 struct netlink_callback *cb)
11684 struct cfg80211_registered_device *rdev;
11685 struct nlattr **attrbuf = NULL;
11695 * 0 is a valid index, but not valid for args[0],
11696 * so we need to offset by 1.
11698 phy_idx = cb->args[0] - 1;
11700 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
11706 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
11713 err = nlmsg_parse_deprecated(cb->nlh,
11714 GENL_HDRLEN + nl80211_fam.hdrsize,
11715 attrbuf, nl80211_fam.maxattr,
11716 nl80211_policy, NULL);
11720 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
11721 if (IS_ERR(rdev)) {
11722 err = PTR_ERR(rdev);
11725 phy_idx = rdev->wiphy_idx;
11727 if (attrbuf[NL80211_ATTR_TESTDATA])
11728 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
11732 data = nla_data((void *)cb->args[1]);
11733 data_len = nla_len((void *)cb->args[1]);
11736 if (!rdev->ops->testmode_dump) {
11742 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
11743 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11744 NL80211_CMD_TESTMODE);
11745 struct nlattr *tmdata;
11750 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
11751 genlmsg_cancel(skb, hdr);
11755 tmdata = nla_nest_start_noflag(skb, NL80211_ATTR_TESTDATA);
11757 genlmsg_cancel(skb, hdr);
11760 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
11761 nla_nest_end(skb, tmdata);
11763 if (err == -ENOBUFS || err == -ENOENT) {
11764 genlmsg_cancel(skb, hdr);
11767 genlmsg_cancel(skb, hdr);
11771 genlmsg_end(skb, hdr);
11776 cb->args[0] = phy_idx + 1;
11784 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
11786 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11787 struct net_device *dev = info->user_ptr[1];
11788 struct cfg80211_connect_params connect;
11789 struct wiphy *wiphy;
11790 struct cfg80211_cached_keys *connkeys = NULL;
11794 memset(&connect, 0, sizeof(connect));
11796 if (!info->attrs[NL80211_ATTR_SSID] ||
11797 !nla_len(info->attrs[NL80211_ATTR_SSID]))
11800 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
11801 connect.auth_type =
11802 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
11803 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
11804 NL80211_CMD_CONNECT))
11807 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
11809 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
11811 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
11812 !wiphy_ext_feature_isset(&rdev->wiphy,
11813 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
11815 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
11817 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
11818 NL80211_MAX_NR_CIPHER_SUITES);
11822 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11823 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
11824 return -EOPNOTSUPP;
11826 wiphy = &rdev->wiphy;
11828 connect.bg_scan_period = -1;
11829 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
11830 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
11831 connect.bg_scan_period =
11832 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
11835 if (info->attrs[NL80211_ATTR_MAC])
11836 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
11837 else if (info->attrs[NL80211_ATTR_MAC_HINT])
11838 connect.bssid_hint =
11839 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
11840 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
11841 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
11843 if (info->attrs[NL80211_ATTR_IE]) {
11844 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11845 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11848 if (info->attrs[NL80211_ATTR_USE_MFP]) {
11849 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
11850 if (connect.mfp == NL80211_MFP_OPTIONAL &&
11851 !wiphy_ext_feature_isset(&rdev->wiphy,
11852 NL80211_EXT_FEATURE_MFP_OPTIONAL))
11853 return -EOPNOTSUPP;
11855 connect.mfp = NL80211_MFP_NO;
11858 if (info->attrs[NL80211_ATTR_PREV_BSSID])
11859 connect.prev_bssid =
11860 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
11862 if (info->attrs[NL80211_ATTR_WIPHY_FREQ])
11863 freq = MHZ_TO_KHZ(nla_get_u32(
11864 info->attrs[NL80211_ATTR_WIPHY_FREQ]));
11865 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
11867 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
11870 connect.channel = nl80211_get_valid_chan(wiphy, freq);
11871 if (!connect.channel)
11873 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
11874 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
11875 freq = MHZ_TO_KHZ(freq);
11876 connect.channel_hint = nl80211_get_valid_chan(wiphy, freq);
11877 if (!connect.channel_hint)
11881 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
11882 connect.edmg.channels =
11883 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
11885 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
11886 connect.edmg.bw_config =
11887 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
11890 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
11891 connkeys = nl80211_parse_connkeys(rdev, info, NULL);
11892 if (IS_ERR(connkeys))
11893 return PTR_ERR(connkeys);
11896 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
11897 connect.flags |= ASSOC_REQ_DISABLE_HT;
11899 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
11900 memcpy(&connect.ht_capa_mask,
11901 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
11902 sizeof(connect.ht_capa_mask));
11904 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
11905 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
11906 kfree_sensitive(connkeys);
11909 memcpy(&connect.ht_capa,
11910 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
11911 sizeof(connect.ht_capa));
11914 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
11915 connect.flags |= ASSOC_REQ_DISABLE_VHT;
11917 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE]))
11918 connect.flags |= ASSOC_REQ_DISABLE_HE;
11920 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_EHT]))
11921 connect.flags |= ASSOC_REQ_DISABLE_EHT;
11923 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
11924 memcpy(&connect.vht_capa_mask,
11925 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
11926 sizeof(connect.vht_capa_mask));
11928 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
11929 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
11930 kfree_sensitive(connkeys);
11933 memcpy(&connect.vht_capa,
11934 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
11935 sizeof(connect.vht_capa));
11938 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
11939 if (!((rdev->wiphy.features &
11940 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
11941 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
11942 !wiphy_ext_feature_isset(&rdev->wiphy,
11943 NL80211_EXT_FEATURE_RRM)) {
11944 kfree_sensitive(connkeys);
11947 connect.flags |= ASSOC_REQ_USE_RRM;
11950 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
11951 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
11952 kfree_sensitive(connkeys);
11953 return -EOPNOTSUPP;
11956 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
11957 /* bss selection makes no sense if bssid is set */
11958 if (connect.bssid) {
11959 kfree_sensitive(connkeys);
11963 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
11964 wiphy, &connect.bss_select);
11966 kfree_sensitive(connkeys);
11971 if (wiphy_ext_feature_isset(&rdev->wiphy,
11972 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
11973 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
11974 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
11975 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
11976 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
11977 connect.fils_erp_username =
11978 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
11979 connect.fils_erp_username_len =
11980 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
11981 connect.fils_erp_realm =
11982 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
11983 connect.fils_erp_realm_len =
11984 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
11985 connect.fils_erp_next_seq_num =
11987 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
11988 connect.fils_erp_rrk =
11989 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
11990 connect.fils_erp_rrk_len =
11991 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
11992 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
11993 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
11994 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
11995 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
11996 kfree_sensitive(connkeys);
12000 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
12001 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
12002 kfree_sensitive(connkeys);
12003 GENL_SET_ERR_MSG(info,
12004 "external auth requires connection ownership");
12007 connect.flags |= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT;
12010 if (nla_get_flag(info->attrs[NL80211_ATTR_MLO_SUPPORT]))
12011 connect.flags |= CONNECT_REQ_MLO_SUPPORT;
12013 wdev_lock(dev->ieee80211_ptr);
12015 err = cfg80211_connect(rdev, dev, &connect, connkeys,
12016 connect.prev_bssid);
12018 kfree_sensitive(connkeys);
12020 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
12021 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
12023 memcpy(dev->ieee80211_ptr->disconnect_bssid,
12024 connect.bssid, ETH_ALEN);
12026 eth_zero_addr(dev->ieee80211_ptr->disconnect_bssid);
12029 wdev_unlock(dev->ieee80211_ptr);
12034 static int nl80211_update_connect_params(struct sk_buff *skb,
12035 struct genl_info *info)
12037 struct cfg80211_connect_params connect = {};
12038 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12039 struct net_device *dev = info->user_ptr[1];
12040 struct wireless_dev *wdev = dev->ieee80211_ptr;
12041 bool fils_sk_offload;
12046 if (!rdev->ops->update_connect_params)
12047 return -EOPNOTSUPP;
12049 if (info->attrs[NL80211_ATTR_IE]) {
12050 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12051 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12052 changed |= UPDATE_ASSOC_IES;
12055 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy,
12056 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD);
12059 * when driver supports fils-sk offload all attributes must be
12060 * provided. So the else covers "fils-sk-not-all" and
12061 * "no-fils-sk-any".
12063 if (fils_sk_offload &&
12064 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
12065 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
12066 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
12067 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
12068 connect.fils_erp_username =
12069 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
12070 connect.fils_erp_username_len =
12071 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
12072 connect.fils_erp_realm =
12073 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
12074 connect.fils_erp_realm_len =
12075 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
12076 connect.fils_erp_next_seq_num =
12078 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
12079 connect.fils_erp_rrk =
12080 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
12081 connect.fils_erp_rrk_len =
12082 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
12083 changed |= UPDATE_FILS_ERP_INFO;
12084 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
12085 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
12086 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
12087 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
12091 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
12092 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
12093 if (!nl80211_valid_auth_type(rdev, auth_type,
12094 NL80211_CMD_CONNECT))
12097 if (auth_type == NL80211_AUTHTYPE_FILS_SK &&
12098 fils_sk_offload && !(changed & UPDATE_FILS_ERP_INFO))
12101 connect.auth_type = auth_type;
12102 changed |= UPDATE_AUTH_TYPE;
12105 wdev_lock(dev->ieee80211_ptr);
12106 if (!wdev->connected)
12109 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
12110 wdev_unlock(dev->ieee80211_ptr);
12115 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
12117 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12118 struct net_device *dev = info->user_ptr[1];
12122 if (dev->ieee80211_ptr->conn_owner_nlportid &&
12123 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
12126 if (!info->attrs[NL80211_ATTR_REASON_CODE])
12127 reason = WLAN_REASON_DEAUTH_LEAVING;
12129 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
12134 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
12135 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
12136 return -EOPNOTSUPP;
12138 wdev_lock(dev->ieee80211_ptr);
12139 ret = cfg80211_disconnect(rdev, dev, reason, true);
12140 wdev_unlock(dev->ieee80211_ptr);
12144 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
12146 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12150 if (info->attrs[NL80211_ATTR_PID]) {
12151 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
12153 net = get_net_ns_by_pid(pid);
12154 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
12155 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
12157 net = get_net_ns_by_fd(fd);
12163 return PTR_ERR(net);
12167 /* check if anything to do */
12168 if (!net_eq(wiphy_net(&rdev->wiphy), net))
12169 err = cfg80211_switch_netns(rdev, net);
12175 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
12177 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12178 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
12179 struct cfg80211_pmksa *pmksa) = NULL;
12180 struct net_device *dev = info->user_ptr[1];
12181 struct cfg80211_pmksa pmksa;
12183 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
12185 if (!info->attrs[NL80211_ATTR_PMKID])
12188 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
12190 if (info->attrs[NL80211_ATTR_MAC]) {
12191 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
12192 } else if (info->attrs[NL80211_ATTR_SSID] &&
12193 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
12194 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
12195 info->attrs[NL80211_ATTR_PMK])) {
12196 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
12197 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
12199 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
12203 if (info->attrs[NL80211_ATTR_PMK]) {
12204 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
12205 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
12208 if (info->attrs[NL80211_ATTR_PMK_LIFETIME])
12209 pmksa.pmk_lifetime =
12210 nla_get_u32(info->attrs[NL80211_ATTR_PMK_LIFETIME]);
12212 if (info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD])
12213 pmksa.pmk_reauth_threshold =
12215 info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD]);
12217 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
12218 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
12219 !(dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP &&
12220 wiphy_ext_feature_isset(&rdev->wiphy,
12221 NL80211_EXT_FEATURE_AP_PMKSA_CACHING)))
12222 return -EOPNOTSUPP;
12224 switch (info->genlhdr->cmd) {
12225 case NL80211_CMD_SET_PMKSA:
12226 rdev_ops = rdev->ops->set_pmksa;
12228 case NL80211_CMD_DEL_PMKSA:
12229 rdev_ops = rdev->ops->del_pmksa;
12237 return -EOPNOTSUPP;
12239 return rdev_ops(&rdev->wiphy, dev, &pmksa);
12242 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
12244 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12245 struct net_device *dev = info->user_ptr[1];
12247 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
12248 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
12249 return -EOPNOTSUPP;
12251 if (!rdev->ops->flush_pmksa)
12252 return -EOPNOTSUPP;
12254 return rdev_flush_pmksa(rdev, dev);
12257 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
12259 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12260 struct net_device *dev = info->user_ptr[1];
12261 u8 action_code, dialog_token;
12262 u32 peer_capability = 0;
12268 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
12269 !rdev->ops->tdls_mgmt)
12270 return -EOPNOTSUPP;
12272 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
12273 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
12274 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
12275 !info->attrs[NL80211_ATTR_IE] ||
12276 !info->attrs[NL80211_ATTR_MAC])
12279 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12280 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
12281 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
12282 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
12283 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
12284 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
12286 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
12287 link_id = nl80211_link_id_or_invalid(info->attrs);
12289 return rdev_tdls_mgmt(rdev, dev, peer, link_id, action_code,
12290 dialog_token, status_code, peer_capability,
12292 nla_data(info->attrs[NL80211_ATTR_IE]),
12293 nla_len(info->attrs[NL80211_ATTR_IE]));
12296 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
12298 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12299 struct net_device *dev = info->user_ptr[1];
12300 enum nl80211_tdls_operation operation;
12303 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
12304 !rdev->ops->tdls_oper)
12305 return -EOPNOTSUPP;
12307 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
12308 !info->attrs[NL80211_ATTR_MAC])
12311 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
12312 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12314 return rdev_tdls_oper(rdev, dev, peer, operation);
12317 static int nl80211_remain_on_channel(struct sk_buff *skb,
12318 struct genl_info *info)
12320 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12321 unsigned int link_id = nl80211_link_id(info->attrs);
12322 struct wireless_dev *wdev = info->user_ptr[1];
12323 struct cfg80211_chan_def chandef;
12324 struct sk_buff *msg;
12330 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
12331 !info->attrs[NL80211_ATTR_DURATION])
12334 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
12336 if (!rdev->ops->remain_on_channel ||
12337 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
12338 return -EOPNOTSUPP;
12341 * We should be on that channel for at least a minimum amount of
12342 * time (10ms) but no longer than the driver supports.
12344 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
12345 duration > rdev->wiphy.max_remain_on_channel_duration)
12348 err = nl80211_parse_chandef(rdev, info, &chandef);
12353 if (!cfg80211_off_channel_oper_allowed(wdev, chandef.chan)) {
12354 const struct cfg80211_chan_def *oper_chandef, *compat_chandef;
12356 oper_chandef = wdev_chandef(wdev, link_id);
12358 if (WARN_ON(!oper_chandef)) {
12359 /* cannot happen since we must beacon to get here */
12365 /* note: returns first one if identical chandefs */
12366 compat_chandef = cfg80211_chandef_compatible(&chandef,
12369 if (compat_chandef != &chandef) {
12376 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12380 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12381 NL80211_CMD_REMAIN_ON_CHANNEL);
12387 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
12388 duration, &cookie);
12393 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12395 goto nla_put_failure;
12397 genlmsg_end(msg, hdr);
12399 return genlmsg_reply(msg, info);
12408 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
12409 struct genl_info *info)
12411 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12412 struct wireless_dev *wdev = info->user_ptr[1];
12415 if (!info->attrs[NL80211_ATTR_COOKIE])
12418 if (!rdev->ops->cancel_remain_on_channel)
12419 return -EOPNOTSUPP;
12421 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
12423 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
12426 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
12427 struct genl_info *info)
12429 struct cfg80211_bitrate_mask mask;
12430 unsigned int link_id = nl80211_link_id(info->attrs);
12431 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12432 struct net_device *dev = info->user_ptr[1];
12433 struct wireless_dev *wdev = dev->ieee80211_ptr;
12436 if (!rdev->ops->set_bitrate_mask)
12437 return -EOPNOTSUPP;
12440 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
12441 NL80211_ATTR_TX_RATES, &mask,
12442 dev, true, link_id);
12446 err = rdev_set_bitrate_mask(rdev, dev, link_id, NULL, &mask);
12452 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
12454 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12455 struct wireless_dev *wdev = info->user_ptr[1];
12456 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
12458 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
12461 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
12462 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
12464 switch (wdev->iftype) {
12465 case NL80211_IFTYPE_STATION:
12466 case NL80211_IFTYPE_ADHOC:
12467 case NL80211_IFTYPE_P2P_CLIENT:
12468 case NL80211_IFTYPE_AP:
12469 case NL80211_IFTYPE_AP_VLAN:
12470 case NL80211_IFTYPE_MESH_POINT:
12471 case NL80211_IFTYPE_P2P_GO:
12472 case NL80211_IFTYPE_P2P_DEVICE:
12474 case NL80211_IFTYPE_NAN:
12475 if (!wiphy_ext_feature_isset(wdev->wiphy,
12476 NL80211_EXT_FEATURE_SECURE_NAN))
12477 return -EOPNOTSUPP;
12480 return -EOPNOTSUPP;
12483 /* not much point in registering if we can't reply */
12484 if (!rdev->ops->mgmt_tx)
12485 return -EOPNOTSUPP;
12487 if (info->attrs[NL80211_ATTR_RECEIVE_MULTICAST] &&
12488 !wiphy_ext_feature_isset(&rdev->wiphy,
12489 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS)) {
12490 GENL_SET_ERR_MSG(info,
12491 "multicast RX registrations are not supported");
12492 return -EOPNOTSUPP;
12495 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
12496 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
12497 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]),
12498 info->attrs[NL80211_ATTR_RECEIVE_MULTICAST],
12502 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
12504 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12505 struct wireless_dev *wdev = info->user_ptr[1];
12506 struct cfg80211_chan_def chandef;
12510 struct sk_buff *msg = NULL;
12511 struct cfg80211_mgmt_tx_params params = {
12512 .dont_wait_for_ack =
12513 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
12516 if (!info->attrs[NL80211_ATTR_FRAME])
12519 if (!rdev->ops->mgmt_tx)
12520 return -EOPNOTSUPP;
12522 switch (wdev->iftype) {
12523 case NL80211_IFTYPE_P2P_DEVICE:
12524 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
12527 case NL80211_IFTYPE_STATION:
12528 case NL80211_IFTYPE_ADHOC:
12529 case NL80211_IFTYPE_P2P_CLIENT:
12530 case NL80211_IFTYPE_AP:
12531 case NL80211_IFTYPE_AP_VLAN:
12532 case NL80211_IFTYPE_MESH_POINT:
12533 case NL80211_IFTYPE_P2P_GO:
12535 case NL80211_IFTYPE_NAN:
12536 if (!wiphy_ext_feature_isset(wdev->wiphy,
12537 NL80211_EXT_FEATURE_SECURE_NAN))
12538 return -EOPNOTSUPP;
12541 return -EOPNOTSUPP;
12544 if (info->attrs[NL80211_ATTR_DURATION]) {
12545 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
12547 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
12550 * We should wait on the channel for at least a minimum amount
12551 * of time (10ms) but no longer than the driver supports.
12553 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
12554 params.wait > rdev->wiphy.max_remain_on_channel_duration)
12558 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
12560 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
12563 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
12565 /* get the channel if any has been specified, otherwise pass NULL to
12566 * the driver. The latter will use the current one
12568 chandef.chan = NULL;
12569 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
12570 err = nl80211_parse_chandef(rdev, info, &chandef);
12575 if (!chandef.chan && params.offchan)
12579 if (params.offchan &&
12580 !cfg80211_off_channel_oper_allowed(wdev, chandef.chan)) {
12585 params.link_id = nl80211_link_id_or_invalid(info->attrs);
12587 * This now races due to the unlock, but we cannot check
12588 * the valid links for the _station_ anyway, so that's up
12591 if (params.link_id >= 0 &&
12592 !(wdev->valid_links & BIT(params.link_id))) {
12598 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
12599 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
12601 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
12602 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
12605 if (len % sizeof(u16))
12608 params.n_csa_offsets = len / sizeof(u16);
12609 params.csa_offsets =
12610 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
12612 /* check that all the offsets fit the frame */
12613 for (i = 0; i < params.n_csa_offsets; i++) {
12614 if (params.csa_offsets[i] >= params.len)
12619 if (!params.dont_wait_for_ack) {
12620 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12624 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12625 NL80211_CMD_FRAME);
12632 params.chan = chandef.chan;
12633 err = cfg80211_mlme_mgmt_tx(rdev, wdev, ¶ms, &cookie);
12638 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12640 goto nla_put_failure;
12642 genlmsg_end(msg, hdr);
12643 return genlmsg_reply(msg, info);
12655 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
12657 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12658 struct wireless_dev *wdev = info->user_ptr[1];
12661 if (!info->attrs[NL80211_ATTR_COOKIE])
12664 if (!rdev->ops->mgmt_tx_cancel_wait)
12665 return -EOPNOTSUPP;
12667 switch (wdev->iftype) {
12668 case NL80211_IFTYPE_STATION:
12669 case NL80211_IFTYPE_ADHOC:
12670 case NL80211_IFTYPE_P2P_CLIENT:
12671 case NL80211_IFTYPE_AP:
12672 case NL80211_IFTYPE_AP_VLAN:
12673 case NL80211_IFTYPE_P2P_GO:
12674 case NL80211_IFTYPE_P2P_DEVICE:
12676 case NL80211_IFTYPE_NAN:
12677 if (!wiphy_ext_feature_isset(wdev->wiphy,
12678 NL80211_EXT_FEATURE_SECURE_NAN))
12679 return -EOPNOTSUPP;
12682 return -EOPNOTSUPP;
12685 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
12687 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
12690 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
12692 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12693 struct wireless_dev *wdev;
12694 struct net_device *dev = info->user_ptr[1];
12699 if (!info->attrs[NL80211_ATTR_PS_STATE])
12702 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
12704 wdev = dev->ieee80211_ptr;
12706 if (!rdev->ops->set_power_mgmt)
12707 return -EOPNOTSUPP;
12709 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
12711 if (state == wdev->ps)
12714 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
12720 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
12722 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12723 enum nl80211_ps_state ps_state;
12724 struct wireless_dev *wdev;
12725 struct net_device *dev = info->user_ptr[1];
12726 struct sk_buff *msg;
12730 wdev = dev->ieee80211_ptr;
12732 if (!rdev->ops->set_power_mgmt)
12733 return -EOPNOTSUPP;
12735 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12739 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12740 NL80211_CMD_GET_POWER_SAVE);
12747 ps_state = NL80211_PS_ENABLED;
12749 ps_state = NL80211_PS_DISABLED;
12751 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
12752 goto nla_put_failure;
12754 genlmsg_end(msg, hdr);
12755 return genlmsg_reply(msg, info);
12764 static const struct nla_policy
12765 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
12766 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
12767 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
12768 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
12769 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
12770 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
12771 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
12772 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
12775 static int nl80211_set_cqm_txe(struct genl_info *info,
12776 u32 rate, u32 pkts, u32 intvl)
12778 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12779 struct net_device *dev = info->user_ptr[1];
12780 struct wireless_dev *wdev = dev->ieee80211_ptr;
12782 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
12785 if (!rdev->ops->set_cqm_txe_config)
12786 return -EOPNOTSUPP;
12788 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12789 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12790 return -EOPNOTSUPP;
12792 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
12795 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
12796 struct net_device *dev)
12798 struct wireless_dev *wdev = dev->ieee80211_ptr;
12799 s32 last, low, high;
12801 int i, n, low_index;
12804 /* RSSI reporting disabled? */
12805 if (!wdev->cqm_config)
12806 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
12809 * Obtain current RSSI value if possible, if not and no RSSI threshold
12810 * event has been received yet, we should receive an event after a
12811 * connection is established and enough beacons received to calculate
12814 if (!wdev->cqm_config->last_rssi_event_value &&
12815 wdev->links[0].client.current_bss &&
12816 rdev->ops->get_station) {
12817 struct station_info sinfo = {};
12820 mac_addr = wdev->links[0].client.current_bss->pub.bssid;
12822 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
12826 cfg80211_sinfo_release_content(&sinfo);
12827 if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
12828 wdev->cqm_config->last_rssi_event_value =
12829 (s8) sinfo.rx_beacon_signal_avg;
12832 last = wdev->cqm_config->last_rssi_event_value;
12833 hyst = wdev->cqm_config->rssi_hyst;
12834 n = wdev->cqm_config->n_rssi_thresholds;
12836 for (i = 0; i < n; i++) {
12837 i = array_index_nospec(i, n);
12838 if (last < wdev->cqm_config->rssi_thresholds[i])
12843 if (low_index >= 0) {
12844 low_index = array_index_nospec(low_index, n);
12845 low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;
12850 i = array_index_nospec(i, n);
12851 high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;
12856 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
12859 static int nl80211_set_cqm_rssi(struct genl_info *info,
12860 const s32 *thresholds, int n_thresholds,
12863 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12864 struct net_device *dev = info->user_ptr[1];
12865 struct wireless_dev *wdev = dev->ieee80211_ptr;
12867 s32 prev = S32_MIN;
12869 /* Check all values negative and sorted */
12870 for (i = 0; i < n_thresholds; i++) {
12871 if (thresholds[i] > 0 || thresholds[i] <= prev)
12874 prev = thresholds[i];
12877 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12878 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12879 return -EOPNOTSUPP;
12882 cfg80211_cqm_config_free(wdev);
12885 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
12886 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
12887 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
12889 return rdev_set_cqm_rssi_config(rdev, dev,
12890 thresholds[0], hysteresis);
12893 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12894 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
12895 return -EOPNOTSUPP;
12897 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
12901 if (n_thresholds) {
12902 struct cfg80211_cqm_config *cqm_config;
12904 cqm_config = kzalloc(struct_size(cqm_config, rssi_thresholds,
12912 cqm_config->rssi_hyst = hysteresis;
12913 cqm_config->n_rssi_thresholds = n_thresholds;
12914 memcpy(cqm_config->rssi_thresholds, thresholds,
12915 flex_array_size(cqm_config, rssi_thresholds,
12918 wdev->cqm_config = cqm_config;
12921 err = cfg80211_cqm_rssi_update(rdev, dev);
12929 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
12931 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
12932 struct nlattr *cqm;
12935 cqm = info->attrs[NL80211_ATTR_CQM];
12939 err = nla_parse_nested_deprecated(attrs, NL80211_ATTR_CQM_MAX, cqm,
12940 nl80211_attr_cqm_policy,
12945 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
12946 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
12947 const s32 *thresholds =
12948 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
12949 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
12950 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
12955 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
12959 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
12960 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
12961 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
12962 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
12963 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
12964 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
12966 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
12972 static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
12974 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12975 struct net_device *dev = info->user_ptr[1];
12976 struct ocb_setup setup = {};
12979 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
12983 return cfg80211_join_ocb(rdev, dev, &setup);
12986 static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
12988 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12989 struct net_device *dev = info->user_ptr[1];
12991 return cfg80211_leave_ocb(rdev, dev);
12994 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
12996 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12997 struct net_device *dev = info->user_ptr[1];
12998 struct mesh_config cfg;
12999 struct mesh_setup setup;
13002 /* start with default */
13003 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
13004 memcpy(&setup, &default_mesh_setup, sizeof(setup));
13006 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
13007 /* and parse parameters if given */
13008 err = nl80211_parse_mesh_config(info, &cfg, NULL);
13013 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
13014 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
13017 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
13018 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
13020 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
13021 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
13022 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
13025 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
13026 setup.beacon_interval =
13027 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
13029 err = cfg80211_validate_beacon_int(rdev,
13030 NL80211_IFTYPE_MESH_POINT,
13031 setup.beacon_interval);
13036 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
13037 setup.dtim_period =
13038 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
13039 if (setup.dtim_period < 1 || setup.dtim_period > 100)
13043 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
13044 /* parse additional setup parameters if given */
13045 err = nl80211_parse_mesh_setup(info, &setup);
13050 if (setup.user_mpm)
13051 cfg.auto_open_plinks = false;
13053 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
13054 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
13058 /* __cfg80211_join_mesh() will sort it out */
13059 setup.chandef.chan = NULL;
13062 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
13063 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
13065 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
13066 struct ieee80211_supported_band *sband;
13068 if (!setup.chandef.chan)
13071 sband = rdev->wiphy.bands[setup.chandef.chan->band];
13073 err = ieee80211_get_ratemask(sband, rates, n_rates,
13074 &setup.basic_rates);
13079 if (info->attrs[NL80211_ATTR_TX_RATES]) {
13080 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
13081 NL80211_ATTR_TX_RATES,
13082 &setup.beacon_rate,
13087 if (!setup.chandef.chan)
13090 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
13091 &setup.beacon_rate);
13096 setup.userspace_handles_dfs =
13097 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
13099 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
13100 int r = validate_pae_over_nl80211(rdev, info);
13105 setup.control_port_over_nl80211 = true;
13108 wdev_lock(dev->ieee80211_ptr);
13109 err = __cfg80211_join_mesh(rdev, dev, &setup, &cfg);
13110 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER])
13111 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
13112 wdev_unlock(dev->ieee80211_ptr);
13117 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
13119 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13120 struct net_device *dev = info->user_ptr[1];
13122 return cfg80211_leave_mesh(rdev, dev);
13126 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
13127 struct cfg80211_registered_device *rdev)
13129 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
13130 struct nlattr *nl_pats, *nl_pat;
13133 if (!wowlan->n_patterns)
13136 nl_pats = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
13140 for (i = 0; i < wowlan->n_patterns; i++) {
13141 nl_pat = nla_nest_start_noflag(msg, i + 1);
13144 pat_len = wowlan->patterns[i].pattern_len;
13145 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
13146 wowlan->patterns[i].mask) ||
13147 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
13148 wowlan->patterns[i].pattern) ||
13149 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
13150 wowlan->patterns[i].pkt_offset))
13152 nla_nest_end(msg, nl_pat);
13154 nla_nest_end(msg, nl_pats);
13159 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
13160 struct cfg80211_wowlan_tcp *tcp)
13162 struct nlattr *nl_tcp;
13167 nl_tcp = nla_nest_start_noflag(msg,
13168 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
13172 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
13173 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
13174 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
13175 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
13176 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
13177 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
13178 tcp->payload_len, tcp->payload) ||
13179 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
13180 tcp->data_interval) ||
13181 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
13182 tcp->wake_len, tcp->wake_data) ||
13183 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
13184 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
13187 if (tcp->payload_seq.len &&
13188 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
13189 sizeof(tcp->payload_seq), &tcp->payload_seq))
13192 if (tcp->payload_tok.len &&
13193 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
13194 sizeof(tcp->payload_tok) + tcp->tokens_size,
13195 &tcp->payload_tok))
13198 nla_nest_end(msg, nl_tcp);
13203 static int nl80211_send_wowlan_nd(struct sk_buff *msg,
13204 struct cfg80211_sched_scan_request *req)
13206 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
13212 nd = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
13216 if (req->n_scan_plans == 1 &&
13217 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
13218 req->scan_plans[0].interval * 1000))
13221 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
13224 if (req->relative_rssi_set) {
13225 struct nl80211_bss_select_rssi_adjust rssi_adjust;
13227 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
13228 req->relative_rssi))
13231 rssi_adjust.band = req->rssi_adjust.band;
13232 rssi_adjust.delta = req->rssi_adjust.delta;
13233 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
13234 sizeof(rssi_adjust), &rssi_adjust))
13238 freqs = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES);
13242 for (i = 0; i < req->n_channels; i++) {
13243 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
13247 nla_nest_end(msg, freqs);
13249 if (req->n_match_sets) {
13250 matches = nla_nest_start_noflag(msg,
13251 NL80211_ATTR_SCHED_SCAN_MATCH);
13255 for (i = 0; i < req->n_match_sets; i++) {
13256 match = nla_nest_start_noflag(msg, i);
13260 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
13261 req->match_sets[i].ssid.ssid_len,
13262 req->match_sets[i].ssid.ssid))
13264 nla_nest_end(msg, match);
13266 nla_nest_end(msg, matches);
13269 scan_plans = nla_nest_start_noflag(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
13273 for (i = 0; i < req->n_scan_plans; i++) {
13274 scan_plan = nla_nest_start_noflag(msg, i + 1);
13278 if (nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
13279 req->scan_plans[i].interval) ||
13280 (req->scan_plans[i].iterations &&
13281 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
13282 req->scan_plans[i].iterations)))
13284 nla_nest_end(msg, scan_plan);
13286 nla_nest_end(msg, scan_plans);
13288 nla_nest_end(msg, nd);
13293 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
13295 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13296 struct sk_buff *msg;
13298 u32 size = NLMSG_DEFAULT_SIZE;
13300 if (!rdev->wiphy.wowlan)
13301 return -EOPNOTSUPP;
13303 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
13304 /* adjust size to have room for all the data */
13305 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
13306 rdev->wiphy.wowlan_config->tcp->payload_len +
13307 rdev->wiphy.wowlan_config->tcp->wake_len +
13308 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
13311 msg = nlmsg_new(size, GFP_KERNEL);
13315 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13316 NL80211_CMD_GET_WOWLAN);
13318 goto nla_put_failure;
13320 if (rdev->wiphy.wowlan_config) {
13321 struct nlattr *nl_wowlan;
13323 nl_wowlan = nla_nest_start_noflag(msg,
13324 NL80211_ATTR_WOWLAN_TRIGGERS);
13326 goto nla_put_failure;
13328 if ((rdev->wiphy.wowlan_config->any &&
13329 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
13330 (rdev->wiphy.wowlan_config->disconnect &&
13331 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
13332 (rdev->wiphy.wowlan_config->magic_pkt &&
13333 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
13334 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
13335 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
13336 (rdev->wiphy.wowlan_config->eap_identity_req &&
13337 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
13338 (rdev->wiphy.wowlan_config->four_way_handshake &&
13339 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
13340 (rdev->wiphy.wowlan_config->rfkill_release &&
13341 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
13342 goto nla_put_failure;
13344 if (nl80211_send_wowlan_patterns(msg, rdev))
13345 goto nla_put_failure;
13347 if (nl80211_send_wowlan_tcp(msg,
13348 rdev->wiphy.wowlan_config->tcp))
13349 goto nla_put_failure;
13351 if (nl80211_send_wowlan_nd(
13353 rdev->wiphy.wowlan_config->nd_config))
13354 goto nla_put_failure;
13356 nla_nest_end(msg, nl_wowlan);
13359 genlmsg_end(msg, hdr);
13360 return genlmsg_reply(msg, info);
13367 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
13368 struct nlattr *attr,
13369 struct cfg80211_wowlan *trig)
13371 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
13372 struct cfg80211_wowlan_tcp *cfg;
13373 struct nl80211_wowlan_tcp_data_token *tok = NULL;
13374 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
13376 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
13379 if (!rdev->wiphy.wowlan->tcp)
13382 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TCP, attr,
13383 nl80211_wowlan_tcp_policy, NULL);
13387 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
13388 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
13389 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
13390 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
13391 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
13392 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
13393 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
13394 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
13397 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
13398 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
13401 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
13402 rdev->wiphy.wowlan->tcp->data_interval_max ||
13403 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
13406 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
13407 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
13410 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
13411 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
13414 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
13415 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
13417 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
13418 tokens_size = tokln - sizeof(*tok);
13420 if (!tok->len || tokens_size % tok->len)
13422 if (!rdev->wiphy.wowlan->tcp->tok)
13424 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
13426 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
13428 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
13430 if (tok->offset + tok->len > data_size)
13434 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
13435 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
13436 if (!rdev->wiphy.wowlan->tcp->seq)
13438 if (seq->len == 0 || seq->len > 4)
13440 if (seq->len + seq->offset > data_size)
13444 size = sizeof(*cfg);
13446 size += wake_size + wake_mask_size;
13447 size += tokens_size;
13449 cfg = kzalloc(size, GFP_KERNEL);
13452 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
13453 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
13454 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
13456 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
13457 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
13461 /* allocate a socket and port for it and use it */
13462 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
13463 IPPROTO_TCP, &cfg->sock, 1);
13468 if (inet_csk_get_port(cfg->sock->sk, port)) {
13469 sock_release(cfg->sock);
13471 return -EADDRINUSE;
13473 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
13479 cfg->src_port = port;
13482 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
13483 cfg->payload_len = data_size;
13484 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
13485 memcpy((void *)cfg->payload,
13486 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
13489 cfg->payload_seq = *seq;
13490 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
13491 cfg->wake_len = wake_size;
13492 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
13493 memcpy((void *)cfg->wake_data,
13494 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
13496 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
13497 data_size + wake_size;
13498 memcpy((void *)cfg->wake_mask,
13499 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
13502 cfg->tokens_size = tokens_size;
13503 cfg->payload_tok = *tok;
13504 memcpy(cfg->payload_tok.token_stream, tok->token_stream,
13513 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
13514 const struct wiphy_wowlan_support *wowlan,
13515 struct nlattr *attr,
13516 struct cfg80211_wowlan *trig)
13518 struct nlattr **tb;
13521 tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
13525 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
13530 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_MAX, attr,
13531 nl80211_policy, NULL);
13535 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
13536 wowlan->max_nd_match_sets);
13537 err = PTR_ERR_OR_ZERO(trig->nd_config);
13539 trig->nd_config = NULL;
13546 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
13548 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13549 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
13550 struct cfg80211_wowlan new_triggers = {};
13551 struct cfg80211_wowlan *ntrig;
13552 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
13554 bool prev_enabled = rdev->wiphy.wowlan_config;
13555 bool regular = false;
13558 return -EOPNOTSUPP;
13560 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
13561 cfg80211_rdev_free_wowlan(rdev);
13562 rdev->wiphy.wowlan_config = NULL;
13566 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TRIG,
13567 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
13568 nl80211_wowlan_policy, info->extack);
13572 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
13573 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
13575 new_triggers.any = true;
13578 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
13579 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
13581 new_triggers.disconnect = true;
13585 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
13586 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
13588 new_triggers.magic_pkt = true;
13592 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
13595 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
13596 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
13598 new_triggers.gtk_rekey_failure = true;
13602 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
13603 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
13605 new_triggers.eap_identity_req = true;
13609 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
13610 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
13612 new_triggers.four_way_handshake = true;
13616 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
13617 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
13619 new_triggers.rfkill_release = true;
13623 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
13624 struct nlattr *pat;
13625 int n_patterns = 0;
13626 int rem, pat_len, mask_len, pkt_offset;
13627 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
13631 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
13634 if (n_patterns > wowlan->n_patterns)
13637 new_triggers.patterns = kcalloc(n_patterns,
13638 sizeof(new_triggers.patterns[0]),
13640 if (!new_triggers.patterns)
13643 new_triggers.n_patterns = n_patterns;
13646 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
13650 err = nla_parse_nested_deprecated(pat_tb,
13651 MAX_NL80211_PKTPAT,
13653 nl80211_packet_pattern_policy,
13659 if (!pat_tb[NL80211_PKTPAT_MASK] ||
13660 !pat_tb[NL80211_PKTPAT_PATTERN])
13662 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
13663 mask_len = DIV_ROUND_UP(pat_len, 8);
13664 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
13666 if (pat_len > wowlan->pattern_max_len ||
13667 pat_len < wowlan->pattern_min_len)
13670 if (!pat_tb[NL80211_PKTPAT_OFFSET])
13673 pkt_offset = nla_get_u32(
13674 pat_tb[NL80211_PKTPAT_OFFSET]);
13675 if (pkt_offset > wowlan->max_pkt_offset)
13677 new_triggers.patterns[i].pkt_offset = pkt_offset;
13679 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
13684 new_triggers.patterns[i].mask = mask_pat;
13685 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
13687 mask_pat += mask_len;
13688 new_triggers.patterns[i].pattern = mask_pat;
13689 new_triggers.patterns[i].pattern_len = pat_len;
13691 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
13697 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
13699 err = nl80211_parse_wowlan_tcp(
13700 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
13706 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
13708 err = nl80211_parse_wowlan_nd(
13709 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
13715 /* The 'any' trigger means the device continues operating more or less
13716 * as in its normal operation mode and wakes up the host on most of the
13717 * normal interrupts (like packet RX, ...)
13718 * It therefore makes little sense to combine with the more constrained
13719 * wakeup trigger modes.
13721 if (new_triggers.any && regular) {
13726 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
13731 cfg80211_rdev_free_wowlan(rdev);
13732 rdev->wiphy.wowlan_config = ntrig;
13735 if (rdev->ops->set_wakeup &&
13736 prev_enabled != !!rdev->wiphy.wowlan_config)
13737 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
13741 for (i = 0; i < new_triggers.n_patterns; i++)
13742 kfree(new_triggers.patterns[i].mask);
13743 kfree(new_triggers.patterns);
13744 if (new_triggers.tcp && new_triggers.tcp->sock)
13745 sock_release(new_triggers.tcp->sock);
13746 kfree(new_triggers.tcp);
13747 kfree(new_triggers.nd_config);
13752 static int nl80211_send_coalesce_rules(struct sk_buff *msg,
13753 struct cfg80211_registered_device *rdev)
13755 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
13757 struct cfg80211_coalesce_rules *rule;
13759 if (!rdev->coalesce->n_rules)
13762 nl_rules = nla_nest_start_noflag(msg, NL80211_ATTR_COALESCE_RULE);
13766 for (i = 0; i < rdev->coalesce->n_rules; i++) {
13767 nl_rule = nla_nest_start_noflag(msg, i + 1);
13771 rule = &rdev->coalesce->rules[i];
13772 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
13776 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
13780 nl_pats = nla_nest_start_noflag(msg,
13781 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
13785 for (j = 0; j < rule->n_patterns; j++) {
13786 nl_pat = nla_nest_start_noflag(msg, j + 1);
13789 pat_len = rule->patterns[j].pattern_len;
13790 if (nla_put(msg, NL80211_PKTPAT_MASK,
13791 DIV_ROUND_UP(pat_len, 8),
13792 rule->patterns[j].mask) ||
13793 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
13794 rule->patterns[j].pattern) ||
13795 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
13796 rule->patterns[j].pkt_offset))
13798 nla_nest_end(msg, nl_pat);
13800 nla_nest_end(msg, nl_pats);
13801 nla_nest_end(msg, nl_rule);
13803 nla_nest_end(msg, nl_rules);
13808 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
13810 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13811 struct sk_buff *msg;
13814 if (!rdev->wiphy.coalesce)
13815 return -EOPNOTSUPP;
13817 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13821 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13822 NL80211_CMD_GET_COALESCE);
13824 goto nla_put_failure;
13826 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
13827 goto nla_put_failure;
13829 genlmsg_end(msg, hdr);
13830 return genlmsg_reply(msg, info);
13837 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
13839 struct cfg80211_coalesce *coalesce = rdev->coalesce;
13841 struct cfg80211_coalesce_rules *rule;
13846 for (i = 0; i < coalesce->n_rules; i++) {
13847 rule = &coalesce->rules[i];
13848 for (j = 0; j < rule->n_patterns; j++)
13849 kfree(rule->patterns[j].mask);
13850 kfree(rule->patterns);
13852 kfree(coalesce->rules);
13854 rdev->coalesce = NULL;
13857 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
13858 struct nlattr *rule,
13859 struct cfg80211_coalesce_rules *new_rule)
13862 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
13863 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
13864 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
13865 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
13867 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_COALESCE_RULE_MAX,
13868 rule, nl80211_coalesce_policy, NULL);
13872 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
13874 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
13875 if (new_rule->delay > coalesce->max_delay)
13878 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
13879 new_rule->condition =
13880 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
13882 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
13885 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
13888 if (n_patterns > coalesce->n_patterns)
13891 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
13893 if (!new_rule->patterns)
13896 new_rule->n_patterns = n_patterns;
13899 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
13903 err = nla_parse_nested_deprecated(pat_tb, MAX_NL80211_PKTPAT,
13905 nl80211_packet_pattern_policy,
13910 if (!pat_tb[NL80211_PKTPAT_MASK] ||
13911 !pat_tb[NL80211_PKTPAT_PATTERN])
13913 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
13914 mask_len = DIV_ROUND_UP(pat_len, 8);
13915 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
13917 if (pat_len > coalesce->pattern_max_len ||
13918 pat_len < coalesce->pattern_min_len)
13921 if (!pat_tb[NL80211_PKTPAT_OFFSET])
13924 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
13925 if (pkt_offset > coalesce->max_pkt_offset)
13927 new_rule->patterns[i].pkt_offset = pkt_offset;
13929 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
13933 new_rule->patterns[i].mask = mask_pat;
13934 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
13937 mask_pat += mask_len;
13938 new_rule->patterns[i].pattern = mask_pat;
13939 new_rule->patterns[i].pattern_len = pat_len;
13940 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
13948 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
13950 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13951 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
13952 struct cfg80211_coalesce new_coalesce = {};
13953 struct cfg80211_coalesce *n_coalesce;
13954 int err, rem_rule, n_rules = 0, i, j;
13955 struct nlattr *rule;
13956 struct cfg80211_coalesce_rules *tmp_rule;
13958 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
13959 return -EOPNOTSUPP;
13961 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
13962 cfg80211_rdev_free_coalesce(rdev);
13963 rdev_set_coalesce(rdev, NULL);
13967 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
13970 if (n_rules > coalesce->n_rules)
13973 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
13975 if (!new_coalesce.rules)
13978 new_coalesce.n_rules = n_rules;
13981 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
13983 err = nl80211_parse_coalesce_rule(rdev, rule,
13984 &new_coalesce.rules[i]);
13991 err = rdev_set_coalesce(rdev, &new_coalesce);
13995 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
14000 cfg80211_rdev_free_coalesce(rdev);
14001 rdev->coalesce = n_coalesce;
14005 for (i = 0; i < new_coalesce.n_rules; i++) {
14006 tmp_rule = &new_coalesce.rules[i];
14007 for (j = 0; j < tmp_rule->n_patterns; j++)
14008 kfree(tmp_rule->patterns[j].mask);
14009 kfree(tmp_rule->patterns);
14011 kfree(new_coalesce.rules);
14016 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
14018 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14019 struct net_device *dev = info->user_ptr[1];
14020 struct wireless_dev *wdev = dev->ieee80211_ptr;
14021 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
14022 struct cfg80211_gtk_rekey_data rekey_data = {};
14025 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
14028 err = nla_parse_nested_deprecated(tb, MAX_NL80211_REKEY_DATA,
14029 info->attrs[NL80211_ATTR_REKEY_DATA],
14030 nl80211_rekey_policy, info->extack);
14034 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
14035 !tb[NL80211_REKEY_DATA_KCK])
14037 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN &&
14038 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK &&
14039 nla_len(tb[NL80211_REKEY_DATA_KEK]) == NL80211_KEK_EXT_LEN))
14041 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN &&
14042 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK &&
14043 nla_len(tb[NL80211_REKEY_DATA_KCK]) == NL80211_KCK_EXT_LEN) &&
14044 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KCK_32 &&
14045 nla_len(tb[NL80211_REKEY_DATA_KCK]) == NL80211_KCK_EXT_LEN_32))
14048 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
14049 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
14050 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
14051 rekey_data.kek_len = nla_len(tb[NL80211_REKEY_DATA_KEK]);
14052 rekey_data.kck_len = nla_len(tb[NL80211_REKEY_DATA_KCK]);
14053 if (tb[NL80211_REKEY_DATA_AKM])
14054 rekey_data.akm = nla_get_u32(tb[NL80211_REKEY_DATA_AKM]);
14057 if (!wdev->connected) {
14062 if (!rdev->ops->set_rekey_data) {
14067 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
14073 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
14074 struct genl_info *info)
14076 struct net_device *dev = info->user_ptr[1];
14077 struct wireless_dev *wdev = dev->ieee80211_ptr;
14079 if (wdev->iftype != NL80211_IFTYPE_AP &&
14080 wdev->iftype != NL80211_IFTYPE_P2P_GO)
14083 if (wdev->ap_unexpected_nlportid)
14086 wdev->ap_unexpected_nlportid = info->snd_portid;
14090 static int nl80211_probe_client(struct sk_buff *skb,
14091 struct genl_info *info)
14093 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14094 struct net_device *dev = info->user_ptr[1];
14095 struct wireless_dev *wdev = dev->ieee80211_ptr;
14096 struct sk_buff *msg;
14102 if (wdev->iftype != NL80211_IFTYPE_AP &&
14103 wdev->iftype != NL80211_IFTYPE_P2P_GO)
14104 return -EOPNOTSUPP;
14106 if (!info->attrs[NL80211_ATTR_MAC])
14109 if (!rdev->ops->probe_client)
14110 return -EOPNOTSUPP;
14112 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14116 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
14117 NL80211_CMD_PROBE_CLIENT);
14123 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
14125 err = rdev_probe_client(rdev, dev, addr, &cookie);
14129 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14131 goto nla_put_failure;
14133 genlmsg_end(msg, hdr);
14135 return genlmsg_reply(msg, info);
14144 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
14146 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14147 struct cfg80211_beacon_registration *reg, *nreg;
14150 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
14151 return -EOPNOTSUPP;
14153 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
14157 /* First, check if already registered. */
14158 spin_lock_bh(&rdev->beacon_registrations_lock);
14159 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
14160 if (reg->nlportid == info->snd_portid) {
14165 /* Add it to the list */
14166 nreg->nlportid = info->snd_portid;
14167 list_add(&nreg->list, &rdev->beacon_registrations);
14169 spin_unlock_bh(&rdev->beacon_registrations_lock);
14173 spin_unlock_bh(&rdev->beacon_registrations_lock);
14178 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
14180 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14181 struct wireless_dev *wdev = info->user_ptr[1];
14184 if (!rdev->ops->start_p2p_device)
14185 return -EOPNOTSUPP;
14187 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
14188 return -EOPNOTSUPP;
14190 if (wdev_running(wdev))
14193 if (rfkill_blocked(rdev->wiphy.rfkill))
14196 err = rdev_start_p2p_device(rdev, wdev);
14200 wdev->is_running = true;
14206 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
14208 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14209 struct wireless_dev *wdev = info->user_ptr[1];
14211 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
14212 return -EOPNOTSUPP;
14214 if (!rdev->ops->stop_p2p_device)
14215 return -EOPNOTSUPP;
14217 cfg80211_stop_p2p_device(rdev, wdev);
14222 static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
14224 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14225 struct wireless_dev *wdev = info->user_ptr[1];
14226 struct cfg80211_nan_conf conf = {};
14229 if (wdev->iftype != NL80211_IFTYPE_NAN)
14230 return -EOPNOTSUPP;
14232 if (wdev_running(wdev))
14235 if (rfkill_blocked(rdev->wiphy.rfkill))
14238 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
14242 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
14244 if (info->attrs[NL80211_ATTR_BANDS]) {
14245 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
14247 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
14248 return -EOPNOTSUPP;
14250 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
14253 conf.bands = bands;
14256 err = rdev_start_nan(rdev, wdev, &conf);
14260 wdev->is_running = true;
14266 static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
14268 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14269 struct wireless_dev *wdev = info->user_ptr[1];
14271 if (wdev->iftype != NL80211_IFTYPE_NAN)
14272 return -EOPNOTSUPP;
14274 cfg80211_stop_nan(rdev, wdev);
14279 static int validate_nan_filter(struct nlattr *filter_attr)
14281 struct nlattr *attr;
14282 int len = 0, n_entries = 0, rem;
14284 nla_for_each_nested(attr, filter_attr, rem) {
14285 len += nla_len(attr);
14295 static int handle_nan_filter(struct nlattr *attr_filter,
14296 struct cfg80211_nan_func *func,
14299 struct nlattr *attr;
14300 int n_entries, rem, i;
14301 struct cfg80211_nan_func_filter *filter;
14303 n_entries = validate_nan_filter(attr_filter);
14307 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
14309 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
14314 nla_for_each_nested(attr, attr_filter, rem) {
14315 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
14316 if (!filter[i].filter)
14319 filter[i].len = nla_len(attr);
14323 func->num_tx_filters = n_entries;
14324 func->tx_filters = filter;
14326 func->num_rx_filters = n_entries;
14327 func->rx_filters = filter;
14334 nla_for_each_nested(attr, attr_filter, rem) {
14335 kfree(filter[i].filter);
14342 static int nl80211_nan_add_func(struct sk_buff *skb,
14343 struct genl_info *info)
14345 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14346 struct wireless_dev *wdev = info->user_ptr[1];
14347 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
14348 struct cfg80211_nan_func *func;
14349 struct sk_buff *msg = NULL;
14353 if (wdev->iftype != NL80211_IFTYPE_NAN)
14354 return -EOPNOTSUPP;
14356 if (!wdev_running(wdev))
14359 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
14362 err = nla_parse_nested_deprecated(tb, NL80211_NAN_FUNC_ATTR_MAX,
14363 info->attrs[NL80211_ATTR_NAN_FUNC],
14364 nl80211_nan_func_policy,
14369 func = kzalloc(sizeof(*func), GFP_KERNEL);
14373 func->cookie = cfg80211_assign_cookie(rdev);
14375 if (!tb[NL80211_NAN_FUNC_TYPE]) {
14381 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
14383 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
14388 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
14389 sizeof(func->service_id));
14391 func->close_range =
14392 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
14394 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
14395 func->serv_spec_info_len =
14396 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
14397 func->serv_spec_info =
14398 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
14399 func->serv_spec_info_len,
14401 if (!func->serv_spec_info) {
14407 if (tb[NL80211_NAN_FUNC_TTL])
14408 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
14410 switch (func->type) {
14411 case NL80211_NAN_FUNC_PUBLISH:
14412 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
14417 func->publish_type =
14418 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
14419 func->publish_bcast =
14420 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
14422 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
14423 func->publish_bcast) {
14428 case NL80211_NAN_FUNC_SUBSCRIBE:
14429 func->subscribe_active =
14430 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
14432 case NL80211_NAN_FUNC_FOLLOW_UP:
14433 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
14434 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] ||
14435 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) {
14440 func->followup_id =
14441 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
14442 func->followup_reqid =
14443 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
14444 memcpy(func->followup_dest.addr,
14445 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
14446 sizeof(func->followup_dest.addr));
14457 if (tb[NL80211_NAN_FUNC_SRF]) {
14458 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
14460 err = nla_parse_nested_deprecated(srf_tb,
14461 NL80211_NAN_SRF_ATTR_MAX,
14462 tb[NL80211_NAN_FUNC_SRF],
14463 nl80211_nan_srf_policy,
14468 func->srf_include =
14469 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
14471 if (srf_tb[NL80211_NAN_SRF_BF]) {
14472 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
14473 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
14479 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
14481 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
14482 func->srf_bf_len, GFP_KERNEL);
14483 if (!func->srf_bf) {
14489 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
14491 struct nlattr *attr, *mac_attr =
14492 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
14493 int n_entries, rem, i = 0;
14500 n_entries = validate_acl_mac_addrs(mac_attr);
14501 if (n_entries <= 0) {
14506 func->srf_num_macs = n_entries;
14508 kcalloc(n_entries, sizeof(*func->srf_macs),
14510 if (!func->srf_macs) {
14515 nla_for_each_nested(attr, mac_attr, rem)
14516 memcpy(func->srf_macs[i++].addr, nla_data(attr),
14517 sizeof(*func->srf_macs));
14521 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
14522 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
14528 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
14529 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
14535 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14541 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
14542 NL80211_CMD_ADD_NAN_FUNCTION);
14543 /* This can't really happen - we just allocated 4KB */
14544 if (WARN_ON(!hdr)) {
14549 err = rdev_add_nan_func(rdev, wdev, func);
14552 cfg80211_free_nan_func(func);
14557 /* propagate the instance id and cookie to userspace */
14558 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
14560 goto nla_put_failure;
14562 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
14564 goto nla_put_failure;
14566 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
14567 func->instance_id))
14568 goto nla_put_failure;
14570 nla_nest_end(msg, func_attr);
14572 genlmsg_end(msg, hdr);
14573 return genlmsg_reply(msg, info);
14580 static int nl80211_nan_del_func(struct sk_buff *skb,
14581 struct genl_info *info)
14583 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14584 struct wireless_dev *wdev = info->user_ptr[1];
14587 if (wdev->iftype != NL80211_IFTYPE_NAN)
14588 return -EOPNOTSUPP;
14590 if (!wdev_running(wdev))
14593 if (!info->attrs[NL80211_ATTR_COOKIE])
14596 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
14598 rdev_del_nan_func(rdev, wdev, cookie);
14603 static int nl80211_nan_change_config(struct sk_buff *skb,
14604 struct genl_info *info)
14606 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14607 struct wireless_dev *wdev = info->user_ptr[1];
14608 struct cfg80211_nan_conf conf = {};
14611 if (wdev->iftype != NL80211_IFTYPE_NAN)
14612 return -EOPNOTSUPP;
14614 if (!wdev_running(wdev))
14617 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
14619 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
14620 if (conf.master_pref <= 1 || conf.master_pref == 255)
14623 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
14626 if (info->attrs[NL80211_ATTR_BANDS]) {
14627 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
14629 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
14630 return -EOPNOTSUPP;
14632 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
14635 conf.bands = bands;
14636 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
14642 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
14645 void cfg80211_nan_match(struct wireless_dev *wdev,
14646 struct cfg80211_nan_match_params *match, gfp_t gfp)
14648 struct wiphy *wiphy = wdev->wiphy;
14649 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14650 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
14651 struct sk_buff *msg;
14654 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
14657 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14661 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
14667 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14668 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14669 wdev->netdev->ifindex)) ||
14670 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14672 goto nla_put_failure;
14674 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
14675 NL80211_ATTR_PAD) ||
14676 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
14677 goto nla_put_failure;
14679 match_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_MATCH);
14681 goto nla_put_failure;
14683 local_func_attr = nla_nest_start_noflag(msg,
14684 NL80211_NAN_MATCH_FUNC_LOCAL);
14685 if (!local_func_attr)
14686 goto nla_put_failure;
14688 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
14689 goto nla_put_failure;
14691 nla_nest_end(msg, local_func_attr);
14693 peer_func_attr = nla_nest_start_noflag(msg,
14694 NL80211_NAN_MATCH_FUNC_PEER);
14695 if (!peer_func_attr)
14696 goto nla_put_failure;
14698 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
14699 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
14700 goto nla_put_failure;
14702 if (match->info && match->info_len &&
14703 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
14705 goto nla_put_failure;
14707 nla_nest_end(msg, peer_func_attr);
14708 nla_nest_end(msg, match_attr);
14709 genlmsg_end(msg, hdr);
14711 if (!wdev->owner_nlportid)
14712 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
14713 msg, 0, NL80211_MCGRP_NAN, gfp);
14715 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
14716 wdev->owner_nlportid);
14723 EXPORT_SYMBOL(cfg80211_nan_match);
14725 void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
14727 enum nl80211_nan_func_term_reason reason,
14728 u64 cookie, gfp_t gfp)
14730 struct wiphy *wiphy = wdev->wiphy;
14731 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14732 struct sk_buff *msg;
14733 struct nlattr *func_attr;
14736 if (WARN_ON(!inst_id))
14739 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14743 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
14749 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14750 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14751 wdev->netdev->ifindex)) ||
14752 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14754 goto nla_put_failure;
14756 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14758 goto nla_put_failure;
14760 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
14762 goto nla_put_failure;
14764 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
14765 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
14766 goto nla_put_failure;
14768 nla_nest_end(msg, func_attr);
14769 genlmsg_end(msg, hdr);
14771 if (!wdev->owner_nlportid)
14772 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
14773 msg, 0, NL80211_MCGRP_NAN, gfp);
14775 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
14776 wdev->owner_nlportid);
14783 EXPORT_SYMBOL(cfg80211_nan_func_terminated);
14785 static int nl80211_get_protocol_features(struct sk_buff *skb,
14786 struct genl_info *info)
14789 struct sk_buff *msg;
14791 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14795 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
14796 NL80211_CMD_GET_PROTOCOL_FEATURES);
14798 goto nla_put_failure;
14800 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
14801 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
14802 goto nla_put_failure;
14804 genlmsg_end(msg, hdr);
14805 return genlmsg_reply(msg, info);
14812 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
14814 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14815 struct cfg80211_update_ft_ies_params ft_params;
14816 struct net_device *dev = info->user_ptr[1];
14818 if (!rdev->ops->update_ft_ies)
14819 return -EOPNOTSUPP;
14821 if (!info->attrs[NL80211_ATTR_MDID] ||
14822 !info->attrs[NL80211_ATTR_IE])
14825 memset(&ft_params, 0, sizeof(ft_params));
14826 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
14827 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
14828 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
14830 return rdev_update_ft_ies(rdev, dev, &ft_params);
14833 static int nl80211_crit_protocol_start(struct sk_buff *skb,
14834 struct genl_info *info)
14836 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14837 struct wireless_dev *wdev = info->user_ptr[1];
14838 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
14842 if (!rdev->ops->crit_proto_start)
14843 return -EOPNOTSUPP;
14845 if (WARN_ON(!rdev->ops->crit_proto_stop))
14848 if (rdev->crit_proto_nlportid)
14851 /* determine protocol if provided */
14852 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
14853 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
14855 if (proto >= NUM_NL80211_CRIT_PROTO)
14858 /* timeout must be provided */
14859 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
14863 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
14865 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
14867 rdev->crit_proto_nlportid = info->snd_portid;
14872 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
14873 struct genl_info *info)
14875 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14876 struct wireless_dev *wdev = info->user_ptr[1];
14878 if (!rdev->ops->crit_proto_stop)
14879 return -EOPNOTSUPP;
14881 if (rdev->crit_proto_nlportid) {
14882 rdev->crit_proto_nlportid = 0;
14883 rdev_crit_proto_stop(rdev, wdev);
14888 static int nl80211_vendor_check_policy(const struct wiphy_vendor_command *vcmd,
14889 struct nlattr *attr,
14890 struct netlink_ext_ack *extack)
14892 if (vcmd->policy == VENDOR_CMD_RAW_DATA) {
14893 if (attr->nla_type & NLA_F_NESTED) {
14894 NL_SET_ERR_MSG_ATTR(extack, attr,
14895 "unexpected nested data");
14902 if (!(attr->nla_type & NLA_F_NESTED)) {
14903 NL_SET_ERR_MSG_ATTR(extack, attr, "expected nested data");
14907 return nla_validate_nested(attr, vcmd->maxattr, vcmd->policy, extack);
14910 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
14912 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14913 struct wireless_dev *wdev =
14914 __cfg80211_wdev_from_attrs(rdev, genl_info_net(info),
14919 if (!rdev->wiphy.vendor_commands)
14920 return -EOPNOTSUPP;
14922 if (IS_ERR(wdev)) {
14923 err = PTR_ERR(wdev);
14924 if (err != -EINVAL)
14927 } else if (wdev->wiphy != &rdev->wiphy) {
14931 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
14932 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
14935 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
14936 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
14937 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
14938 const struct wiphy_vendor_command *vcmd;
14942 vcmd = &rdev->wiphy.vendor_commands[i];
14944 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
14947 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
14948 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
14951 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
14955 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
14956 if (!wdev_running(wdev))
14964 return -EOPNOTSUPP;
14966 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
14967 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
14968 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
14970 err = nl80211_vendor_check_policy(vcmd,
14971 info->attrs[NL80211_ATTR_VENDOR_DATA],
14977 rdev->cur_cmd_info = info;
14978 err = vcmd->doit(&rdev->wiphy, wdev, data, len);
14979 rdev->cur_cmd_info = NULL;
14983 return -EOPNOTSUPP;
14986 static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
14987 struct netlink_callback *cb,
14988 struct cfg80211_registered_device **rdev,
14989 struct wireless_dev **wdev)
14991 struct nlattr **attrbuf;
14997 unsigned int data_len = 0;
15000 /* subtract the 1 again here */
15001 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
15002 struct wireless_dev *tmp;
15006 *rdev = wiphy_to_rdev(wiphy);
15010 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
15011 if (tmp->identifier == cb->args[1] - 1) {
15018 /* keep rtnl locked in successful case */
15022 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
15026 err = nlmsg_parse_deprecated(cb->nlh,
15027 GENL_HDRLEN + nl80211_fam.hdrsize,
15028 attrbuf, nl80211_fam.maxattr,
15029 nl80211_policy, NULL);
15033 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
15034 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) {
15039 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(skb->sk), attrbuf);
15043 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
15044 if (IS_ERR(*rdev)) {
15045 err = PTR_ERR(*rdev);
15049 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
15050 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
15052 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
15053 const struct wiphy_vendor_command *vcmd;
15055 vcmd = &(*rdev)->wiphy.vendor_commands[i];
15057 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
15060 if (!vcmd->dumpit) {
15069 if (vcmd_idx < 0) {
15074 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
15075 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
15076 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
15078 err = nl80211_vendor_check_policy(
15079 &(*rdev)->wiphy.vendor_commands[vcmd_idx],
15080 attrbuf[NL80211_ATTR_VENDOR_DATA],
15086 /* 0 is the first index - add 1 to parse only once */
15087 cb->args[0] = (*rdev)->wiphy_idx + 1;
15088 /* add 1 to know if it was NULL */
15089 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
15090 cb->args[2] = vcmd_idx;
15091 cb->args[3] = (unsigned long)data;
15092 cb->args[4] = data_len;
15094 /* keep rtnl locked in successful case */
15101 static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
15102 struct netlink_callback *cb)
15104 struct cfg80211_registered_device *rdev;
15105 struct wireless_dev *wdev;
15106 unsigned int vcmd_idx;
15107 const struct wiphy_vendor_command *vcmd;
15111 struct nlattr *vendor_data;
15114 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
15118 vcmd_idx = cb->args[2];
15119 data = (void *)cb->args[3];
15120 data_len = cb->args[4];
15121 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
15123 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
15124 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
15129 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
15135 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
15136 if (!wdev_running(wdev)) {
15144 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
15145 cb->nlh->nlmsg_seq, NLM_F_MULTI,
15146 NL80211_CMD_VENDOR);
15150 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15151 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
15153 NL80211_ATTR_PAD))) {
15154 genlmsg_cancel(skb, hdr);
15158 vendor_data = nla_nest_start_noflag(skb,
15159 NL80211_ATTR_VENDOR_DATA);
15160 if (!vendor_data) {
15161 genlmsg_cancel(skb, hdr);
15165 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
15166 (unsigned long *)&cb->args[5]);
15167 nla_nest_end(skb, vendor_data);
15169 if (err == -ENOBUFS || err == -ENOENT) {
15170 genlmsg_cancel(skb, hdr);
15172 } else if (err <= 0) {
15173 genlmsg_cancel(skb, hdr);
15177 genlmsg_end(skb, hdr);
15186 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
15187 enum nl80211_commands cmd,
15188 enum nl80211_attrs attr,
15191 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15193 if (WARN_ON(!rdev->cur_cmd_info))
15196 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
15197 rdev->cur_cmd_info->snd_portid,
15198 rdev->cur_cmd_info->snd_seq,
15199 cmd, attr, NULL, GFP_KERNEL);
15201 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
15203 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
15205 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
15206 void *hdr = ((void **)skb->cb)[1];
15207 struct nlattr *data = ((void **)skb->cb)[2];
15209 /* clear CB data for netlink core to own from now on */
15210 memset(skb->cb, 0, sizeof(skb->cb));
15212 if (WARN_ON(!rdev->cur_cmd_info)) {
15217 nla_nest_end(skb, data);
15218 genlmsg_end(skb, hdr);
15219 return genlmsg_reply(skb, rdev->cur_cmd_info);
15221 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
15223 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy *wiphy)
15225 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15227 if (WARN_ON(!rdev->cur_cmd_info))
15230 return rdev->cur_cmd_info->snd_portid;
15232 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_get_sender);
15234 static int nl80211_set_qos_map(struct sk_buff *skb,
15235 struct genl_info *info)
15237 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15238 struct cfg80211_qos_map *qos_map = NULL;
15239 struct net_device *dev = info->user_ptr[1];
15240 u8 *pos, len, num_des, des_len, des;
15243 if (!rdev->ops->set_qos_map)
15244 return -EOPNOTSUPP;
15246 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
15247 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
15248 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
15253 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
15257 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
15259 des_len = num_des *
15260 sizeof(struct cfg80211_dscp_exception);
15261 memcpy(qos_map->dscp_exception, pos, des_len);
15262 qos_map->num_des = num_des;
15263 for (des = 0; des < num_des; des++) {
15264 if (qos_map->dscp_exception[des].up > 7) {
15271 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
15274 wdev_lock(dev->ieee80211_ptr);
15275 ret = nl80211_key_allowed(dev->ieee80211_ptr);
15277 ret = rdev_set_qos_map(rdev, dev, qos_map);
15278 wdev_unlock(dev->ieee80211_ptr);
15284 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
15286 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15287 struct net_device *dev = info->user_ptr[1];
15288 struct wireless_dev *wdev = dev->ieee80211_ptr;
15291 u16 admitted_time = 0;
15294 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
15295 return -EOPNOTSUPP;
15297 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
15298 !info->attrs[NL80211_ATTR_USER_PRIO])
15301 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
15302 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
15304 /* WMM uses TIDs 0-7 even for TSPEC */
15305 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
15306 /* TODO: handle 802.11 TSPEC/admission control
15307 * need more attributes for that (e.g. BA session requirement);
15308 * change the WMM adminssion test above to allow both then
15313 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
15315 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
15317 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
15318 if (!admitted_time)
15323 switch (wdev->iftype) {
15324 case NL80211_IFTYPE_STATION:
15325 case NL80211_IFTYPE_P2P_CLIENT:
15326 if (wdev->connected)
15335 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
15342 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
15344 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15345 struct net_device *dev = info->user_ptr[1];
15346 struct wireless_dev *wdev = dev->ieee80211_ptr;
15351 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
15354 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
15355 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
15358 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
15364 static int nl80211_tdls_channel_switch(struct sk_buff *skb,
15365 struct genl_info *info)
15367 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15368 struct net_device *dev = info->user_ptr[1];
15369 struct wireless_dev *wdev = dev->ieee80211_ptr;
15370 struct cfg80211_chan_def chandef = {};
15375 if (!rdev->ops->tdls_channel_switch ||
15376 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
15377 return -EOPNOTSUPP;
15379 switch (dev->ieee80211_ptr->iftype) {
15380 case NL80211_IFTYPE_STATION:
15381 case NL80211_IFTYPE_P2P_CLIENT:
15384 return -EOPNOTSUPP;
15387 if (!info->attrs[NL80211_ATTR_MAC] ||
15388 !info->attrs[NL80211_ATTR_OPER_CLASS])
15391 err = nl80211_parse_chandef(rdev, info, &chandef);
15396 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
15397 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
15398 * specification is not defined for them.
15400 if (chandef.chan->band == NL80211_BAND_2GHZ &&
15401 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
15402 chandef.width != NL80211_CHAN_WIDTH_20)
15405 /* we will be active on the TDLS link */
15406 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
15410 /* don't allow switching to DFS channels */
15411 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
15414 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
15415 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
15418 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
15424 static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
15425 struct genl_info *info)
15427 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15428 struct net_device *dev = info->user_ptr[1];
15429 struct wireless_dev *wdev = dev->ieee80211_ptr;
15432 if (!rdev->ops->tdls_channel_switch ||
15433 !rdev->ops->tdls_cancel_channel_switch ||
15434 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
15435 return -EOPNOTSUPP;
15437 switch (dev->ieee80211_ptr->iftype) {
15438 case NL80211_IFTYPE_STATION:
15439 case NL80211_IFTYPE_P2P_CLIENT:
15442 return -EOPNOTSUPP;
15445 if (!info->attrs[NL80211_ATTR_MAC])
15448 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
15451 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
15457 static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
15458 struct genl_info *info)
15460 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15461 struct net_device *dev = info->user_ptr[1];
15462 struct wireless_dev *wdev = dev->ieee80211_ptr;
15463 const struct nlattr *nla;
15466 if (!rdev->ops->set_multicast_to_unicast)
15467 return -EOPNOTSUPP;
15469 if (wdev->iftype != NL80211_IFTYPE_AP &&
15470 wdev->iftype != NL80211_IFTYPE_P2P_GO)
15471 return -EOPNOTSUPP;
15473 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
15474 enabled = nla_get_flag(nla);
15476 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
15479 static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
15481 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15482 struct net_device *dev = info->user_ptr[1];
15483 struct wireless_dev *wdev = dev->ieee80211_ptr;
15484 struct cfg80211_pmk_conf pmk_conf = {};
15487 if (wdev->iftype != NL80211_IFTYPE_STATION &&
15488 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
15489 return -EOPNOTSUPP;
15491 if (!wiphy_ext_feature_isset(&rdev->wiphy,
15492 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
15493 return -EOPNOTSUPP;
15495 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
15499 if (!wdev->connected) {
15504 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
15505 if (memcmp(pmk_conf.aa, wdev->u.client.connected_addr, ETH_ALEN)) {
15510 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
15511 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
15512 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
15513 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
15518 if (info->attrs[NL80211_ATTR_PMKR0_NAME])
15519 pmk_conf.pmk_r0_name =
15520 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
15522 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
15528 static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
15530 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15531 struct net_device *dev = info->user_ptr[1];
15532 struct wireless_dev *wdev = dev->ieee80211_ptr;
15536 if (wdev->iftype != NL80211_IFTYPE_STATION &&
15537 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
15538 return -EOPNOTSUPP;
15540 if (!wiphy_ext_feature_isset(&rdev->wiphy,
15541 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
15542 return -EOPNOTSUPP;
15544 if (!info->attrs[NL80211_ATTR_MAC])
15548 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
15549 ret = rdev_del_pmk(rdev, dev, aa);
15555 static int nl80211_external_auth(struct sk_buff *skb, struct genl_info *info)
15557 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15558 struct net_device *dev = info->user_ptr[1];
15559 struct cfg80211_external_auth_params params;
15561 if (!rdev->ops->external_auth)
15562 return -EOPNOTSUPP;
15564 if (!info->attrs[NL80211_ATTR_SSID] &&
15565 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
15566 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
15569 if (!info->attrs[NL80211_ATTR_BSSID])
15572 if (!info->attrs[NL80211_ATTR_STATUS_CODE])
15575 memset(¶ms, 0, sizeof(params));
15577 if (info->attrs[NL80211_ATTR_SSID]) {
15578 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
15579 if (params.ssid.ssid_len == 0)
15581 memcpy(params.ssid.ssid,
15582 nla_data(info->attrs[NL80211_ATTR_SSID]),
15583 params.ssid.ssid_len);
15586 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]),
15589 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
15591 if (info->attrs[NL80211_ATTR_PMKID])
15592 params.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
15594 return rdev_external_auth(rdev, dev, ¶ms);
15597 static int nl80211_tx_control_port(struct sk_buff *skb, struct genl_info *info)
15599 bool dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
15600 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15601 struct net_device *dev = info->user_ptr[1];
15602 struct wireless_dev *wdev = dev->ieee80211_ptr;
15612 if (!wiphy_ext_feature_isset(&rdev->wiphy,
15613 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
15614 return -EOPNOTSUPP;
15616 if (!rdev->ops->tx_control_port)
15617 return -EOPNOTSUPP;
15619 if (!info->attrs[NL80211_ATTR_FRAME] ||
15620 !info->attrs[NL80211_ATTR_MAC] ||
15621 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
15622 GENL_SET_ERR_MSG(info, "Frame, MAC or ethertype missing");
15628 switch (wdev->iftype) {
15629 case NL80211_IFTYPE_AP:
15630 case NL80211_IFTYPE_P2P_GO:
15631 case NL80211_IFTYPE_MESH_POINT:
15633 case NL80211_IFTYPE_ADHOC:
15634 if (wdev->u.ibss.current_bss)
15638 case NL80211_IFTYPE_STATION:
15639 case NL80211_IFTYPE_P2P_CLIENT:
15640 if (wdev->connected)
15651 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
15652 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
15653 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
15654 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
15656 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
15658 link_id = nl80211_link_id_or_invalid(info->attrs);
15660 err = rdev_tx_control_port(rdev, dev, buf, len,
15661 dest, cpu_to_be16(proto), noencrypt, link_id,
15662 dont_wait_for_ack ? NULL : &cookie);
15663 if (!err && !dont_wait_for_ack)
15664 nl_set_extack_cookie_u64(info->extack, cookie);
15671 static int nl80211_get_ftm_responder_stats(struct sk_buff *skb,
15672 struct genl_info *info)
15674 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15675 struct net_device *dev = info->user_ptr[1];
15676 struct wireless_dev *wdev = dev->ieee80211_ptr;
15677 struct cfg80211_ftm_responder_stats ftm_stats = {};
15678 unsigned int link_id = nl80211_link_id(info->attrs);
15679 struct sk_buff *msg;
15681 struct nlattr *ftm_stats_attr;
15684 if (wdev->iftype != NL80211_IFTYPE_AP ||
15685 !wdev->links[link_id].ap.beacon_interval)
15686 return -EOPNOTSUPP;
15688 err = rdev_get_ftm_responder_stats(rdev, dev, &ftm_stats);
15692 if (!ftm_stats.filled)
15695 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15699 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
15700 NL80211_CMD_GET_FTM_RESPONDER_STATS);
15702 goto nla_put_failure;
15704 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
15705 goto nla_put_failure;
15707 ftm_stats_attr = nla_nest_start_noflag(msg,
15708 NL80211_ATTR_FTM_RESPONDER_STATS);
15709 if (!ftm_stats_attr)
15710 goto nla_put_failure;
15712 #define SET_FTM(field, name, type) \
15713 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
15714 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \
15715 ftm_stats.field)) \
15716 goto nla_put_failure; } while (0)
15717 #define SET_FTM_U64(field, name) \
15718 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
15719 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \
15720 ftm_stats.field, NL80211_FTM_STATS_PAD)) \
15721 goto nla_put_failure; } while (0)
15723 SET_FTM(success_num, SUCCESS_NUM, u32);
15724 SET_FTM(partial_num, PARTIAL_NUM, u32);
15725 SET_FTM(failed_num, FAILED_NUM, u32);
15726 SET_FTM(asap_num, ASAP_NUM, u32);
15727 SET_FTM(non_asap_num, NON_ASAP_NUM, u32);
15728 SET_FTM_U64(total_duration_ms, TOTAL_DURATION_MSEC);
15729 SET_FTM(unknown_triggers_num, UNKNOWN_TRIGGERS_NUM, u32);
15730 SET_FTM(reschedule_requests_num, RESCHEDULE_REQUESTS_NUM, u32);
15731 SET_FTM(out_of_window_triggers_num, OUT_OF_WINDOW_TRIGGERS_NUM, u32);
15734 nla_nest_end(msg, ftm_stats_attr);
15736 genlmsg_end(msg, hdr);
15737 return genlmsg_reply(msg, info);
15744 static int nl80211_update_owe_info(struct sk_buff *skb, struct genl_info *info)
15746 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15747 struct cfg80211_update_owe_info owe_info;
15748 struct net_device *dev = info->user_ptr[1];
15750 if (!rdev->ops->update_owe_info)
15751 return -EOPNOTSUPP;
15753 if (!info->attrs[NL80211_ATTR_STATUS_CODE] ||
15754 !info->attrs[NL80211_ATTR_MAC])
15757 memset(&owe_info, 0, sizeof(owe_info));
15758 owe_info.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
15759 nla_memcpy(owe_info.peer, info->attrs[NL80211_ATTR_MAC], ETH_ALEN);
15761 if (info->attrs[NL80211_ATTR_IE]) {
15762 owe_info.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
15763 owe_info.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
15766 return rdev_update_owe_info(rdev, dev, &owe_info);
15769 static int nl80211_probe_mesh_link(struct sk_buff *skb, struct genl_info *info)
15771 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15772 struct net_device *dev = info->user_ptr[1];
15773 struct wireless_dev *wdev = dev->ieee80211_ptr;
15774 struct station_info sinfo = {};
15780 if (!rdev->ops->probe_mesh_link || !rdev->ops->get_station)
15781 return -EOPNOTSUPP;
15783 if (!info->attrs[NL80211_ATTR_MAC] ||
15784 !info->attrs[NL80211_ATTR_FRAME]) {
15785 GENL_SET_ERR_MSG(info, "Frame or MAC missing");
15789 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
15790 return -EOPNOTSUPP;
15792 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
15793 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
15794 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
15796 if (len < sizeof(struct ethhdr))
15799 if (!ether_addr_equal(buf, dest) || is_multicast_ether_addr(buf) ||
15800 !ether_addr_equal(buf + ETH_ALEN, dev->dev_addr))
15803 err = rdev_get_station(rdev, dev, dest, &sinfo);
15807 cfg80211_sinfo_release_content(&sinfo);
15809 return rdev_probe_mesh_link(rdev, dev, dest, buf, len);
15812 static int parse_tid_conf(struct cfg80211_registered_device *rdev,
15813 struct nlattr *attrs[], struct net_device *dev,
15814 struct cfg80211_tid_cfg *tid_conf,
15815 struct genl_info *info, const u8 *peer,
15816 unsigned int link_id)
15818 struct netlink_ext_ack *extack = info->extack;
15822 if (!attrs[NL80211_TID_CONFIG_ATTR_TIDS])
15825 tid_conf->config_override =
15826 nla_get_flag(attrs[NL80211_TID_CONFIG_ATTR_OVERRIDE]);
15827 tid_conf->tids = nla_get_u16(attrs[NL80211_TID_CONFIG_ATTR_TIDS]);
15829 if (tid_conf->config_override) {
15830 if (rdev->ops->reset_tid_config) {
15831 err = rdev_reset_tid_config(rdev, dev, peer,
15840 if (attrs[NL80211_TID_CONFIG_ATTR_NOACK]) {
15841 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_NOACK);
15843 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_NOACK]);
15846 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]) {
15847 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT);
15848 tid_conf->retry_short =
15849 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]);
15851 if (tid_conf->retry_short > rdev->wiphy.max_data_retry_count)
15855 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]) {
15856 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
15857 tid_conf->retry_long =
15858 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]);
15860 if (tid_conf->retry_long > rdev->wiphy.max_data_retry_count)
15864 if (attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]) {
15865 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);
15867 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]);
15870 if (attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]) {
15871 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);
15873 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]);
15876 if (attrs[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL]) {
15877 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMSDU_CTRL);
15879 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL]);
15882 if (attrs[NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE]) {
15883 u32 idx = NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE, attr;
15885 tid_conf->txrate_type = nla_get_u8(attrs[idx]);
15887 if (tid_conf->txrate_type != NL80211_TX_RATE_AUTOMATIC) {
15888 attr = NL80211_TID_CONFIG_ATTR_TX_RATE;
15889 err = nl80211_parse_tx_bitrate_mask(info, attrs, attr,
15890 &tid_conf->txrate_mask, dev,
15895 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE);
15897 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE);
15901 mask = rdev->wiphy.tid_config_support.peer;
15903 mask = rdev->wiphy.tid_config_support.vif;
15905 if (tid_conf->mask & ~mask) {
15906 NL_SET_ERR_MSG(extack, "unsupported TID configuration");
15913 static int nl80211_set_tid_config(struct sk_buff *skb,
15914 struct genl_info *info)
15916 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15917 struct nlattr *attrs[NL80211_TID_CONFIG_ATTR_MAX + 1];
15918 unsigned int link_id = nl80211_link_id(info->attrs);
15919 struct net_device *dev = info->user_ptr[1];
15920 struct cfg80211_tid_config *tid_config;
15921 struct nlattr *tid;
15922 int conf_idx = 0, rem_conf;
15926 if (!info->attrs[NL80211_ATTR_TID_CONFIG])
15929 if (!rdev->ops->set_tid_config)
15930 return -EOPNOTSUPP;
15932 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
15936 tid_config = kzalloc(struct_size(tid_config, tid_conf, num_conf),
15941 tid_config->n_tid_conf = num_conf;
15943 if (info->attrs[NL80211_ATTR_MAC])
15944 tid_config->peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
15946 wdev_lock(dev->ieee80211_ptr);
15948 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
15950 ret = nla_parse_nested(attrs, NL80211_TID_CONFIG_ATTR_MAX,
15956 ret = parse_tid_conf(rdev, attrs, dev,
15957 &tid_config->tid_conf[conf_idx],
15958 info, tid_config->peer, link_id);
15965 ret = rdev_set_tid_config(rdev, dev, tid_config);
15969 wdev_unlock(dev->ieee80211_ptr);
15973 static int nl80211_color_change(struct sk_buff *skb, struct genl_info *info)
15975 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15976 struct cfg80211_color_change_settings params = {};
15977 struct net_device *dev = info->user_ptr[1];
15978 struct wireless_dev *wdev = dev->ieee80211_ptr;
15979 struct nlattr **tb;
15983 if (!rdev->ops->color_change)
15984 return -EOPNOTSUPP;
15986 if (!wiphy_ext_feature_isset(&rdev->wiphy,
15987 NL80211_EXT_FEATURE_BSS_COLOR))
15988 return -EOPNOTSUPP;
15990 if (wdev->iftype != NL80211_IFTYPE_AP)
15991 return -EOPNOTSUPP;
15993 if (!info->attrs[NL80211_ATTR_COLOR_CHANGE_COUNT] ||
15994 !info->attrs[NL80211_ATTR_COLOR_CHANGE_COLOR] ||
15995 !info->attrs[NL80211_ATTR_COLOR_CHANGE_ELEMS])
15998 params.count = nla_get_u8(info->attrs[NL80211_ATTR_COLOR_CHANGE_COUNT]);
15999 params.color = nla_get_u8(info->attrs[NL80211_ATTR_COLOR_CHANGE_COLOR]);
16001 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_next,
16006 tb = kcalloc(NL80211_ATTR_MAX + 1, sizeof(*tb), GFP_KERNEL);
16010 err = nla_parse_nested(tb, NL80211_ATTR_MAX,
16011 info->attrs[NL80211_ATTR_COLOR_CHANGE_ELEMS],
16012 nl80211_policy, info->extack);
16016 err = nl80211_parse_beacon(rdev, tb, ¶ms.beacon_color_change,
16021 if (!tb[NL80211_ATTR_CNTDWN_OFFS_BEACON]) {
16026 if (nla_len(tb[NL80211_ATTR_CNTDWN_OFFS_BEACON]) != sizeof(u16)) {
16031 offset = nla_get_u16(tb[NL80211_ATTR_CNTDWN_OFFS_BEACON]);
16032 if (offset >= params.beacon_color_change.tail_len) {
16037 if (params.beacon_color_change.tail[offset] != params.count) {
16042 params.counter_offset_beacon = offset;
16044 if (tb[NL80211_ATTR_CNTDWN_OFFS_PRESP]) {
16045 if (nla_len(tb[NL80211_ATTR_CNTDWN_OFFS_PRESP]) !=
16051 offset = nla_get_u16(tb[NL80211_ATTR_CNTDWN_OFFS_PRESP]);
16052 if (offset >= params.beacon_color_change.probe_resp_len) {
16057 if (params.beacon_color_change.probe_resp[offset] !=
16063 params.counter_offset_presp = offset;
16067 err = rdev_color_change(rdev, dev, ¶ms);
16071 kfree(params.beacon_next.mbssid_ies);
16072 kfree(params.beacon_color_change.mbssid_ies);
16073 kfree(params.beacon_next.rnr_ies);
16074 kfree(params.beacon_color_change.rnr_ies);
16079 static int nl80211_set_fils_aad(struct sk_buff *skb,
16080 struct genl_info *info)
16082 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16083 struct net_device *dev = info->user_ptr[1];
16084 struct cfg80211_fils_aad fils_aad = {};
16087 if (!info->attrs[NL80211_ATTR_MAC] ||
16088 !info->attrs[NL80211_ATTR_FILS_KEK] ||
16089 !info->attrs[NL80211_ATTR_FILS_NONCES])
16092 fils_aad.macaddr = nla_data(info->attrs[NL80211_ATTR_MAC]);
16093 fils_aad.kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
16094 fils_aad.kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
16095 nonces = nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
16096 fils_aad.snonce = nonces;
16097 fils_aad.anonce = nonces + FILS_NONCE_LEN;
16099 return rdev_set_fils_aad(rdev, dev, &fils_aad);
16102 static int nl80211_add_link(struct sk_buff *skb, struct genl_info *info)
16104 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16105 unsigned int link_id = nl80211_link_id(info->attrs);
16106 struct net_device *dev = info->user_ptr[1];
16107 struct wireless_dev *wdev = dev->ieee80211_ptr;
16110 if (!(wdev->wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO))
16113 switch (wdev->iftype) {
16114 case NL80211_IFTYPE_AP:
16120 if (!info->attrs[NL80211_ATTR_MAC] ||
16121 !is_valid_ether_addr(nla_data(info->attrs[NL80211_ATTR_MAC])))
16125 wdev->valid_links |= BIT(link_id);
16126 ether_addr_copy(wdev->links[link_id].addr,
16127 nla_data(info->attrs[NL80211_ATTR_MAC]));
16129 ret = rdev_add_intf_link(rdev, wdev, link_id);
16131 wdev->valid_links &= ~BIT(link_id);
16132 eth_zero_addr(wdev->links[link_id].addr);
16139 static int nl80211_remove_link(struct sk_buff *skb, struct genl_info *info)
16141 unsigned int link_id = nl80211_link_id(info->attrs);
16142 struct net_device *dev = info->user_ptr[1];
16143 struct wireless_dev *wdev = dev->ieee80211_ptr;
16145 /* cannot remove if there's no link */
16146 if (!info->attrs[NL80211_ATTR_MLO_LINK_ID])
16149 switch (wdev->iftype) {
16150 case NL80211_IFTYPE_AP:
16157 cfg80211_remove_link(wdev, link_id);
16164 nl80211_add_mod_link_station(struct sk_buff *skb, struct genl_info *info,
16167 struct link_station_parameters params = {};
16168 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16169 struct net_device *dev = info->user_ptr[1];
16172 if ((add && !rdev->ops->add_link_station) ||
16173 (!add && !rdev->ops->mod_link_station))
16174 return -EOPNOTSUPP;
16176 if (add && !info->attrs[NL80211_ATTR_MAC])
16179 if (!info->attrs[NL80211_ATTR_MLD_ADDR])
16182 if (add && !info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
16185 params.mld_mac = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
16187 if (info->attrs[NL80211_ATTR_MAC]) {
16188 params.link_mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
16189 if (!is_valid_ether_addr(params.link_mac))
16193 if (!info->attrs[NL80211_ATTR_MLO_LINK_ID])
16196 params.link_id = nla_get_u8(info->attrs[NL80211_ATTR_MLO_LINK_ID]);
16198 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
16199 params.supported_rates =
16200 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
16201 params.supported_rates_len =
16202 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
16205 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
16207 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
16209 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
16211 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
16213 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
16215 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
16216 params.he_capa_len =
16217 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
16219 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) {
16221 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
16222 params.eht_capa_len =
16223 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
16225 if (!ieee80211_eht_capa_size_ok((const u8 *)params.he_capa,
16226 (const u8 *)params.eht_capa,
16227 params.eht_capa_len,
16233 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
16234 params.he_6ghz_capa =
16235 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
16237 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
16238 params.opmode_notif_used = true;
16239 params.opmode_notif =
16240 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
16243 err = nl80211_parse_sta_txpower_setting(info, ¶ms.txpwr,
16244 ¶ms.txpwr_set);
16248 wdev_lock(dev->ieee80211_ptr);
16250 err = rdev_add_link_station(rdev, dev, ¶ms);
16252 err = rdev_mod_link_station(rdev, dev, ¶ms);
16253 wdev_unlock(dev->ieee80211_ptr);
16259 nl80211_add_link_station(struct sk_buff *skb, struct genl_info *info)
16261 return nl80211_add_mod_link_station(skb, info, true);
16265 nl80211_modify_link_station(struct sk_buff *skb, struct genl_info *info)
16267 return nl80211_add_mod_link_station(skb, info, false);
16271 nl80211_remove_link_station(struct sk_buff *skb, struct genl_info *info)
16273 struct link_station_del_parameters params = {};
16274 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16275 struct net_device *dev = info->user_ptr[1];
16278 if (!rdev->ops->del_link_station)
16279 return -EOPNOTSUPP;
16281 if (!info->attrs[NL80211_ATTR_MLD_ADDR] ||
16282 !info->attrs[NL80211_ATTR_MLO_LINK_ID])
16285 params.mld_mac = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
16286 params.link_id = nla_get_u8(info->attrs[NL80211_ATTR_MLO_LINK_ID]);
16288 wdev_lock(dev->ieee80211_ptr);
16289 ret = rdev_del_link_station(rdev, dev, ¶ms);
16290 wdev_unlock(dev->ieee80211_ptr);
16295 static int nl80211_set_hw_timestamp(struct sk_buff *skb,
16296 struct genl_info *info)
16298 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16299 struct net_device *dev = info->user_ptr[1];
16300 struct cfg80211_set_hw_timestamp hwts = {};
16302 if (!rdev->wiphy.hw_timestamp_max_peers)
16303 return -EOPNOTSUPP;
16305 if (!info->attrs[NL80211_ATTR_MAC] &&
16306 rdev->wiphy.hw_timestamp_max_peers != CFG80211_HW_TIMESTAMP_ALL_PEERS)
16307 return -EOPNOTSUPP;
16309 if (info->attrs[NL80211_ATTR_MAC])
16310 hwts.macaddr = nla_data(info->attrs[NL80211_ATTR_MAC]);
16313 nla_get_flag(info->attrs[NL80211_ATTR_HW_TIMESTAMP_ENABLED]);
16315 return rdev_set_hw_timestamp(rdev, dev, &hwts);
16318 #define NL80211_FLAG_NEED_WIPHY 0x01
16319 #define NL80211_FLAG_NEED_NETDEV 0x02
16320 #define NL80211_FLAG_NEED_RTNL 0x04
16321 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
16322 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
16323 NL80211_FLAG_CHECK_NETDEV_UP)
16324 #define NL80211_FLAG_NEED_WDEV 0x10
16325 /* If a netdev is associated, it must be UP, P2P must be started */
16326 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
16327 NL80211_FLAG_CHECK_NETDEV_UP)
16328 #define NL80211_FLAG_CLEAR_SKB 0x20
16329 #define NL80211_FLAG_NO_WIPHY_MTX 0x40
16330 #define NL80211_FLAG_MLO_VALID_LINK_ID 0x80
16331 #define NL80211_FLAG_MLO_UNSUPPORTED 0x100
16333 #define INTERNAL_FLAG_SELECTORS(__sel) \
16334 SELECTOR(__sel, NONE, 0) /* must be first */ \
16335 SELECTOR(__sel, WIPHY, \
16336 NL80211_FLAG_NEED_WIPHY) \
16337 SELECTOR(__sel, WDEV, \
16338 NL80211_FLAG_NEED_WDEV) \
16339 SELECTOR(__sel, NETDEV, \
16340 NL80211_FLAG_NEED_NETDEV) \
16341 SELECTOR(__sel, NETDEV_LINK, \
16342 NL80211_FLAG_NEED_NETDEV | \
16343 NL80211_FLAG_MLO_VALID_LINK_ID) \
16344 SELECTOR(__sel, NETDEV_NO_MLO, \
16345 NL80211_FLAG_NEED_NETDEV | \
16346 NL80211_FLAG_MLO_UNSUPPORTED) \
16347 SELECTOR(__sel, WIPHY_RTNL, \
16348 NL80211_FLAG_NEED_WIPHY | \
16349 NL80211_FLAG_NEED_RTNL) \
16350 SELECTOR(__sel, WIPHY_RTNL_NOMTX, \
16351 NL80211_FLAG_NEED_WIPHY | \
16352 NL80211_FLAG_NEED_RTNL | \
16353 NL80211_FLAG_NO_WIPHY_MTX) \
16354 SELECTOR(__sel, WDEV_RTNL, \
16355 NL80211_FLAG_NEED_WDEV | \
16356 NL80211_FLAG_NEED_RTNL) \
16357 SELECTOR(__sel, NETDEV_RTNL, \
16358 NL80211_FLAG_NEED_NETDEV | \
16359 NL80211_FLAG_NEED_RTNL) \
16360 SELECTOR(__sel, NETDEV_UP, \
16361 NL80211_FLAG_NEED_NETDEV_UP) \
16362 SELECTOR(__sel, NETDEV_UP_LINK, \
16363 NL80211_FLAG_NEED_NETDEV_UP | \
16364 NL80211_FLAG_MLO_VALID_LINK_ID) \
16365 SELECTOR(__sel, NETDEV_UP_NO_MLO, \
16366 NL80211_FLAG_NEED_NETDEV_UP | \
16367 NL80211_FLAG_MLO_UNSUPPORTED) \
16368 SELECTOR(__sel, NETDEV_UP_NO_MLO_CLEAR, \
16369 NL80211_FLAG_NEED_NETDEV_UP | \
16370 NL80211_FLAG_CLEAR_SKB | \
16371 NL80211_FLAG_MLO_UNSUPPORTED) \
16372 SELECTOR(__sel, NETDEV_UP_NOTMX, \
16373 NL80211_FLAG_NEED_NETDEV_UP | \
16374 NL80211_FLAG_NO_WIPHY_MTX) \
16375 SELECTOR(__sel, NETDEV_UP_NOTMX_NOMLO, \
16376 NL80211_FLAG_NEED_NETDEV_UP | \
16377 NL80211_FLAG_NO_WIPHY_MTX | \
16378 NL80211_FLAG_MLO_UNSUPPORTED) \
16379 SELECTOR(__sel, NETDEV_UP_CLEAR, \
16380 NL80211_FLAG_NEED_NETDEV_UP | \
16381 NL80211_FLAG_CLEAR_SKB) \
16382 SELECTOR(__sel, WDEV_UP, \
16383 NL80211_FLAG_NEED_WDEV_UP) \
16384 SELECTOR(__sel, WDEV_UP_LINK, \
16385 NL80211_FLAG_NEED_WDEV_UP | \
16386 NL80211_FLAG_MLO_VALID_LINK_ID) \
16387 SELECTOR(__sel, WDEV_UP_RTNL, \
16388 NL80211_FLAG_NEED_WDEV_UP | \
16389 NL80211_FLAG_NEED_RTNL) \
16390 SELECTOR(__sel, WIPHY_CLEAR, \
16391 NL80211_FLAG_NEED_WIPHY | \
16392 NL80211_FLAG_CLEAR_SKB)
16394 enum nl80211_internal_flags_selector {
16395 #define SELECTOR(_, name, value) NL80211_IFL_SEL_##name,
16396 INTERNAL_FLAG_SELECTORS(_)
16400 static u32 nl80211_internal_flags[] = {
16401 #define SELECTOR(_, name, value) [NL80211_IFL_SEL_##name] = value,
16402 INTERNAL_FLAG_SELECTORS(_)
16406 static int nl80211_pre_doit(const struct genl_split_ops *ops,
16407 struct sk_buff *skb,
16408 struct genl_info *info)
16410 struct cfg80211_registered_device *rdev = NULL;
16411 struct wireless_dev *wdev = NULL;
16412 struct net_device *dev = NULL;
16413 u32 internal_flags;
16416 if (WARN_ON(ops->internal_flags >= ARRAY_SIZE(nl80211_internal_flags)))
16419 internal_flags = nl80211_internal_flags[ops->internal_flags];
16422 if (internal_flags & NL80211_FLAG_NEED_WIPHY) {
16423 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
16424 if (IS_ERR(rdev)) {
16425 err = PTR_ERR(rdev);
16428 info->user_ptr[0] = rdev;
16429 } else if (internal_flags & NL80211_FLAG_NEED_NETDEV ||
16430 internal_flags & NL80211_FLAG_NEED_WDEV) {
16431 wdev = __cfg80211_wdev_from_attrs(NULL, genl_info_net(info),
16433 if (IS_ERR(wdev)) {
16434 err = PTR_ERR(wdev);
16438 dev = wdev->netdev;
16440 rdev = wiphy_to_rdev(wdev->wiphy);
16442 if (internal_flags & NL80211_FLAG_NEED_NETDEV) {
16448 info->user_ptr[1] = dev;
16450 info->user_ptr[1] = wdev;
16453 if (internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
16454 !wdev_running(wdev)) {
16459 info->user_ptr[0] = rdev;
16462 if (internal_flags & NL80211_FLAG_MLO_VALID_LINK_ID) {
16463 struct nlattr *link_id = info->attrs[NL80211_ATTR_MLO_LINK_ID];
16470 /* MLO -> require valid link ID */
16471 if (wdev->valid_links &&
16473 !(wdev->valid_links & BIT(nla_get_u8(link_id))))) {
16478 /* non-MLO -> no link ID attribute accepted */
16479 if (!wdev->valid_links && link_id) {
16485 if (internal_flags & NL80211_FLAG_MLO_UNSUPPORTED) {
16486 if (info->attrs[NL80211_ATTR_MLO_LINK_ID] ||
16487 (wdev && wdev->valid_links)) {
16493 if (rdev && !(internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) {
16494 wiphy_lock(&rdev->wiphy);
16495 /* we keep the mutex locked until post_doit */
16496 __release(&rdev->wiphy.mtx);
16498 if (!(internal_flags & NL80211_FLAG_NEED_RTNL))
16508 static void nl80211_post_doit(const struct genl_split_ops *ops,
16509 struct sk_buff *skb,
16510 struct genl_info *info)
16512 u32 internal_flags = nl80211_internal_flags[ops->internal_flags];
16514 if (info->user_ptr[1]) {
16515 if (internal_flags & NL80211_FLAG_NEED_WDEV) {
16516 struct wireless_dev *wdev = info->user_ptr[1];
16518 dev_put(wdev->netdev);
16520 dev_put(info->user_ptr[1]);
16524 if (info->user_ptr[0] &&
16525 !(internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) {
16526 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16528 /* we kept the mutex locked since pre_doit */
16529 __acquire(&rdev->wiphy.mtx);
16530 wiphy_unlock(&rdev->wiphy);
16533 if (internal_flags & NL80211_FLAG_NEED_RTNL)
16536 /* If needed, clear the netlink message payload from the SKB
16537 * as it might contain key data that shouldn't stick around on
16538 * the heap after the SKB is freed. The netlink message header
16539 * is still needed for further processing, so leave it intact.
16541 if (internal_flags & NL80211_FLAG_CLEAR_SKB) {
16542 struct nlmsghdr *nlh = nlmsg_hdr(skb);
16544 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
16548 static int nl80211_set_sar_sub_specs(struct cfg80211_registered_device *rdev,
16549 struct cfg80211_sar_specs *sar_specs,
16550 struct nlattr *spec[], int index)
16552 u32 range_index, i;
16554 if (!sar_specs || !spec)
16557 if (!spec[NL80211_SAR_ATTR_SPECS_POWER] ||
16558 !spec[NL80211_SAR_ATTR_SPECS_RANGE_INDEX])
16561 range_index = nla_get_u32(spec[NL80211_SAR_ATTR_SPECS_RANGE_INDEX]);
16563 /* check if range_index exceeds num_freq_ranges */
16564 if (range_index >= rdev->wiphy.sar_capa->num_freq_ranges)
16567 /* check if range_index duplicates */
16568 for (i = 0; i < index; i++) {
16569 if (sar_specs->sub_specs[i].freq_range_index == range_index)
16573 sar_specs->sub_specs[index].power =
16574 nla_get_s32(spec[NL80211_SAR_ATTR_SPECS_POWER]);
16576 sar_specs->sub_specs[index].freq_range_index = range_index;
16581 static int nl80211_set_sar_specs(struct sk_buff *skb, struct genl_info *info)
16583 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16584 struct nlattr *spec[NL80211_SAR_ATTR_SPECS_MAX + 1];
16585 struct nlattr *tb[NL80211_SAR_ATTR_MAX + 1];
16586 struct cfg80211_sar_specs *sar_spec;
16587 enum nl80211_sar_type type;
16588 struct nlattr *spec_list;
16592 if (!rdev->wiphy.sar_capa || !rdev->ops->set_sar_specs)
16593 return -EOPNOTSUPP;
16595 if (!info->attrs[NL80211_ATTR_SAR_SPEC])
16598 nla_parse_nested(tb, NL80211_SAR_ATTR_MAX,
16599 info->attrs[NL80211_ATTR_SAR_SPEC],
16602 if (!tb[NL80211_SAR_ATTR_TYPE] || !tb[NL80211_SAR_ATTR_SPECS])
16605 type = nla_get_u32(tb[NL80211_SAR_ATTR_TYPE]);
16606 if (type != rdev->wiphy.sar_capa->type)
16610 nla_for_each_nested(spec_list, tb[NL80211_SAR_ATTR_SPECS], rem)
16613 if (specs > rdev->wiphy.sar_capa->num_freq_ranges)
16616 sar_spec = kzalloc(struct_size(sar_spec, sub_specs, specs), GFP_KERNEL);
16620 sar_spec->type = type;
16622 nla_for_each_nested(spec_list, tb[NL80211_SAR_ATTR_SPECS], rem) {
16623 nla_parse_nested(spec, NL80211_SAR_ATTR_SPECS_MAX,
16624 spec_list, NULL, NULL);
16627 case NL80211_SAR_TYPE_POWER:
16628 if (nl80211_set_sar_sub_specs(rdev, sar_spec,
16641 sar_spec->num_sub_specs = specs;
16643 rdev->cur_cmd_info = info;
16644 err = rdev_set_sar_specs(rdev, sar_spec);
16645 rdev->cur_cmd_info = NULL;
16651 #define SELECTOR(__sel, name, value) \
16652 ((__sel) == (value)) ? NL80211_IFL_SEL_##name :
16653 int __missing_selector(void);
16654 #define IFLAGS(__val) INTERNAL_FLAG_SELECTORS(__val) __missing_selector()
16656 static const struct genl_ops nl80211_ops[] = {
16658 .cmd = NL80211_CMD_GET_WIPHY,
16659 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16660 .doit = nl80211_get_wiphy,
16661 .dumpit = nl80211_dump_wiphy,
16662 .done = nl80211_dump_wiphy_done,
16663 /* can be retrieved by unprivileged users */
16664 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
16668 static const struct genl_small_ops nl80211_small_ops[] = {
16670 .cmd = NL80211_CMD_SET_WIPHY,
16671 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16672 .doit = nl80211_set_wiphy,
16673 .flags = GENL_UNS_ADMIN_PERM,
16676 .cmd = NL80211_CMD_GET_INTERFACE,
16677 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16678 .doit = nl80211_get_interface,
16679 .dumpit = nl80211_dump_interface,
16680 /* can be retrieved by unprivileged users */
16681 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV),
16684 .cmd = NL80211_CMD_SET_INTERFACE,
16685 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16686 .doit = nl80211_set_interface,
16687 .flags = GENL_UNS_ADMIN_PERM,
16688 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV |
16689 NL80211_FLAG_NEED_RTNL),
16692 .cmd = NL80211_CMD_NEW_INTERFACE,
16693 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16694 .doit = nl80211_new_interface,
16695 .flags = GENL_UNS_ADMIN_PERM,
16697 IFLAGS(NL80211_FLAG_NEED_WIPHY |
16698 NL80211_FLAG_NEED_RTNL |
16699 /* we take the wiphy mutex later ourselves */
16700 NL80211_FLAG_NO_WIPHY_MTX),
16703 .cmd = NL80211_CMD_DEL_INTERFACE,
16704 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16705 .doit = nl80211_del_interface,
16706 .flags = GENL_UNS_ADMIN_PERM,
16707 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV |
16708 NL80211_FLAG_NEED_RTNL),
16711 .cmd = NL80211_CMD_GET_KEY,
16712 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16713 .doit = nl80211_get_key,
16714 .flags = GENL_UNS_ADMIN_PERM,
16715 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16718 .cmd = NL80211_CMD_SET_KEY,
16719 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16720 .doit = nl80211_set_key,
16721 .flags = GENL_UNS_ADMIN_PERM,
16722 /* cannot use NL80211_FLAG_MLO_VALID_LINK_ID, depends on key */
16723 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16724 NL80211_FLAG_CLEAR_SKB),
16727 .cmd = NL80211_CMD_NEW_KEY,
16728 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16729 .doit = nl80211_new_key,
16730 .flags = GENL_UNS_ADMIN_PERM,
16731 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16732 NL80211_FLAG_CLEAR_SKB),
16735 .cmd = NL80211_CMD_DEL_KEY,
16736 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16737 .doit = nl80211_del_key,
16738 .flags = GENL_UNS_ADMIN_PERM,
16739 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16742 .cmd = NL80211_CMD_SET_BEACON,
16743 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16744 .flags = GENL_UNS_ADMIN_PERM,
16745 .doit = nl80211_set_beacon,
16746 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16747 NL80211_FLAG_MLO_VALID_LINK_ID),
16750 .cmd = NL80211_CMD_START_AP,
16751 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16752 .flags = GENL_UNS_ADMIN_PERM,
16753 .doit = nl80211_start_ap,
16754 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16755 NL80211_FLAG_MLO_VALID_LINK_ID),
16758 .cmd = NL80211_CMD_STOP_AP,
16759 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16760 .flags = GENL_UNS_ADMIN_PERM,
16761 .doit = nl80211_stop_ap,
16762 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16763 NL80211_FLAG_MLO_VALID_LINK_ID),
16766 .cmd = NL80211_CMD_GET_STATION,
16767 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16768 .doit = nl80211_get_station,
16769 .dumpit = nl80211_dump_station,
16770 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
16773 .cmd = NL80211_CMD_SET_STATION,
16774 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16775 .doit = nl80211_set_station,
16776 .flags = GENL_UNS_ADMIN_PERM,
16777 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16780 .cmd = NL80211_CMD_NEW_STATION,
16781 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16782 .doit = nl80211_new_station,
16783 .flags = GENL_UNS_ADMIN_PERM,
16784 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16787 .cmd = NL80211_CMD_DEL_STATION,
16788 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16789 .doit = nl80211_del_station,
16790 .flags = GENL_UNS_ADMIN_PERM,
16791 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16794 .cmd = NL80211_CMD_GET_MPATH,
16795 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16796 .doit = nl80211_get_mpath,
16797 .dumpit = nl80211_dump_mpath,
16798 .flags = GENL_UNS_ADMIN_PERM,
16799 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16802 .cmd = NL80211_CMD_GET_MPP,
16803 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16804 .doit = nl80211_get_mpp,
16805 .dumpit = nl80211_dump_mpp,
16806 .flags = GENL_UNS_ADMIN_PERM,
16807 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16810 .cmd = NL80211_CMD_SET_MPATH,
16811 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16812 .doit = nl80211_set_mpath,
16813 .flags = GENL_UNS_ADMIN_PERM,
16814 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16817 .cmd = NL80211_CMD_NEW_MPATH,
16818 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16819 .doit = nl80211_new_mpath,
16820 .flags = GENL_UNS_ADMIN_PERM,
16821 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16824 .cmd = NL80211_CMD_DEL_MPATH,
16825 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16826 .doit = nl80211_del_mpath,
16827 .flags = GENL_UNS_ADMIN_PERM,
16828 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16831 .cmd = NL80211_CMD_SET_BSS,
16832 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16833 .doit = nl80211_set_bss,
16834 .flags = GENL_UNS_ADMIN_PERM,
16835 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16836 NL80211_FLAG_MLO_VALID_LINK_ID),
16839 .cmd = NL80211_CMD_GET_REG,
16840 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16841 .doit = nl80211_get_reg_do,
16842 .dumpit = nl80211_get_reg_dump,
16843 /* can be retrieved by unprivileged users */
16845 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
16847 .cmd = NL80211_CMD_SET_REG,
16848 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16849 .doit = nl80211_set_reg,
16850 .flags = GENL_ADMIN_PERM,
16854 .cmd = NL80211_CMD_REQ_SET_REG,
16855 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16856 .doit = nl80211_req_set_reg,
16857 .flags = GENL_ADMIN_PERM,
16860 .cmd = NL80211_CMD_RELOAD_REGDB,
16861 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16862 .doit = nl80211_reload_regdb,
16863 .flags = GENL_ADMIN_PERM,
16866 .cmd = NL80211_CMD_GET_MESH_CONFIG,
16867 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16868 .doit = nl80211_get_mesh_config,
16869 /* can be retrieved by unprivileged users */
16870 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16873 .cmd = NL80211_CMD_SET_MESH_CONFIG,
16874 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16875 .doit = nl80211_update_mesh_config,
16876 .flags = GENL_UNS_ADMIN_PERM,
16877 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16880 .cmd = NL80211_CMD_TRIGGER_SCAN,
16881 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16882 .doit = nl80211_trigger_scan,
16883 .flags = GENL_UNS_ADMIN_PERM,
16884 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
16887 .cmd = NL80211_CMD_ABORT_SCAN,
16888 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16889 .doit = nl80211_abort_scan,
16890 .flags = GENL_UNS_ADMIN_PERM,
16891 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
16894 .cmd = NL80211_CMD_GET_SCAN,
16895 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16896 .dumpit = nl80211_dump_scan,
16899 .cmd = NL80211_CMD_START_SCHED_SCAN,
16900 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16901 .doit = nl80211_start_sched_scan,
16902 .flags = GENL_UNS_ADMIN_PERM,
16903 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16906 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
16907 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16908 .doit = nl80211_stop_sched_scan,
16909 .flags = GENL_UNS_ADMIN_PERM,
16910 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16913 .cmd = NL80211_CMD_AUTHENTICATE,
16914 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16915 .doit = nl80211_authenticate,
16916 .flags = GENL_UNS_ADMIN_PERM,
16917 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16918 NL80211_FLAG_CLEAR_SKB),
16921 .cmd = NL80211_CMD_ASSOCIATE,
16922 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16923 .doit = nl80211_associate,
16924 .flags = GENL_UNS_ADMIN_PERM,
16925 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16926 NL80211_FLAG_CLEAR_SKB),
16929 .cmd = NL80211_CMD_DEAUTHENTICATE,
16930 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16931 .doit = nl80211_deauthenticate,
16932 .flags = GENL_UNS_ADMIN_PERM,
16933 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16936 .cmd = NL80211_CMD_DISASSOCIATE,
16937 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16938 .doit = nl80211_disassociate,
16939 .flags = GENL_UNS_ADMIN_PERM,
16940 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16943 .cmd = NL80211_CMD_JOIN_IBSS,
16944 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16945 .doit = nl80211_join_ibss,
16946 .flags = GENL_UNS_ADMIN_PERM,
16947 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16950 .cmd = NL80211_CMD_LEAVE_IBSS,
16951 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16952 .doit = nl80211_leave_ibss,
16953 .flags = GENL_UNS_ADMIN_PERM,
16954 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16956 #ifdef CONFIG_NL80211_TESTMODE
16958 .cmd = NL80211_CMD_TESTMODE,
16959 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16960 .doit = nl80211_testmode_do,
16961 .dumpit = nl80211_testmode_dump,
16962 .flags = GENL_UNS_ADMIN_PERM,
16963 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
16967 .cmd = NL80211_CMD_CONNECT,
16968 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16969 .doit = nl80211_connect,
16970 .flags = GENL_UNS_ADMIN_PERM,
16971 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16972 NL80211_FLAG_CLEAR_SKB),
16975 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
16976 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16977 .doit = nl80211_update_connect_params,
16978 .flags = GENL_ADMIN_PERM,
16979 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
16980 NL80211_FLAG_CLEAR_SKB),
16983 .cmd = NL80211_CMD_DISCONNECT,
16984 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16985 .doit = nl80211_disconnect,
16986 .flags = GENL_UNS_ADMIN_PERM,
16987 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
16990 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
16991 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
16992 .doit = nl80211_wiphy_netns,
16993 .flags = GENL_UNS_ADMIN_PERM,
16994 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY |
16995 NL80211_FLAG_NEED_RTNL |
16996 NL80211_FLAG_NO_WIPHY_MTX),
16999 .cmd = NL80211_CMD_GET_SURVEY,
17000 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17001 .dumpit = nl80211_dump_survey,
17004 .cmd = NL80211_CMD_SET_PMKSA,
17005 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17006 .doit = nl80211_setdel_pmksa,
17007 .flags = GENL_UNS_ADMIN_PERM,
17008 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17009 NL80211_FLAG_CLEAR_SKB),
17012 .cmd = NL80211_CMD_DEL_PMKSA,
17013 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17014 .doit = nl80211_setdel_pmksa,
17015 .flags = GENL_UNS_ADMIN_PERM,
17016 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17019 .cmd = NL80211_CMD_FLUSH_PMKSA,
17020 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17021 .doit = nl80211_flush_pmksa,
17022 .flags = GENL_UNS_ADMIN_PERM,
17023 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17026 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
17027 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17028 .doit = nl80211_remain_on_channel,
17029 .flags = GENL_UNS_ADMIN_PERM,
17030 /* FIXME: requiring a link ID here is probably not good */
17031 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP |
17032 NL80211_FLAG_MLO_VALID_LINK_ID),
17035 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
17036 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17037 .doit = nl80211_cancel_remain_on_channel,
17038 .flags = GENL_UNS_ADMIN_PERM,
17039 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17042 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
17043 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17044 .doit = nl80211_set_tx_bitrate_mask,
17045 .flags = GENL_UNS_ADMIN_PERM,
17046 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV |
17047 NL80211_FLAG_MLO_VALID_LINK_ID),
17050 .cmd = NL80211_CMD_REGISTER_FRAME,
17051 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17052 .doit = nl80211_register_mgmt,
17053 .flags = GENL_UNS_ADMIN_PERM,
17054 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV),
17057 .cmd = NL80211_CMD_FRAME,
17058 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17059 .doit = nl80211_tx_mgmt,
17060 .flags = GENL_UNS_ADMIN_PERM,
17061 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17064 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
17065 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17066 .doit = nl80211_tx_mgmt_cancel_wait,
17067 .flags = GENL_UNS_ADMIN_PERM,
17068 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17071 .cmd = NL80211_CMD_SET_POWER_SAVE,
17072 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17073 .doit = nl80211_set_power_save,
17074 .flags = GENL_UNS_ADMIN_PERM,
17075 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17078 .cmd = NL80211_CMD_GET_POWER_SAVE,
17079 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17080 .doit = nl80211_get_power_save,
17081 /* can be retrieved by unprivileged users */
17082 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17085 .cmd = NL80211_CMD_SET_CQM,
17086 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17087 .doit = nl80211_set_cqm,
17088 .flags = GENL_UNS_ADMIN_PERM,
17089 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17092 .cmd = NL80211_CMD_SET_CHANNEL,
17093 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17094 .doit = nl80211_set_channel,
17095 .flags = GENL_UNS_ADMIN_PERM,
17096 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV |
17097 NL80211_FLAG_MLO_VALID_LINK_ID),
17100 .cmd = NL80211_CMD_JOIN_MESH,
17101 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17102 .doit = nl80211_join_mesh,
17103 .flags = GENL_UNS_ADMIN_PERM,
17104 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17107 .cmd = NL80211_CMD_LEAVE_MESH,
17108 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17109 .doit = nl80211_leave_mesh,
17110 .flags = GENL_UNS_ADMIN_PERM,
17111 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17114 .cmd = NL80211_CMD_JOIN_OCB,
17115 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17116 .doit = nl80211_join_ocb,
17117 .flags = GENL_UNS_ADMIN_PERM,
17118 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17121 .cmd = NL80211_CMD_LEAVE_OCB,
17122 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17123 .doit = nl80211_leave_ocb,
17124 .flags = GENL_UNS_ADMIN_PERM,
17125 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17129 .cmd = NL80211_CMD_GET_WOWLAN,
17130 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17131 .doit = nl80211_get_wowlan,
17132 /* can be retrieved by unprivileged users */
17133 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
17136 .cmd = NL80211_CMD_SET_WOWLAN,
17137 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17138 .doit = nl80211_set_wowlan,
17139 .flags = GENL_UNS_ADMIN_PERM,
17140 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
17144 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
17145 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17146 .doit = nl80211_set_rekey_data,
17147 .flags = GENL_UNS_ADMIN_PERM,
17148 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17149 NL80211_FLAG_CLEAR_SKB),
17152 .cmd = NL80211_CMD_TDLS_MGMT,
17153 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17154 .doit = nl80211_tdls_mgmt,
17155 .flags = GENL_UNS_ADMIN_PERM,
17156 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17157 NL80211_FLAG_MLO_VALID_LINK_ID),
17160 .cmd = NL80211_CMD_TDLS_OPER,
17161 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17162 .doit = nl80211_tdls_oper,
17163 .flags = GENL_UNS_ADMIN_PERM,
17164 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17167 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
17168 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17169 .doit = nl80211_register_unexpected_frame,
17170 .flags = GENL_UNS_ADMIN_PERM,
17171 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17174 .cmd = NL80211_CMD_PROBE_CLIENT,
17175 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17176 .doit = nl80211_probe_client,
17177 .flags = GENL_UNS_ADMIN_PERM,
17178 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17181 .cmd = NL80211_CMD_REGISTER_BEACONS,
17182 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17183 .doit = nl80211_register_beacons,
17184 .flags = GENL_UNS_ADMIN_PERM,
17185 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
17188 .cmd = NL80211_CMD_SET_NOACK_MAP,
17189 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17190 .doit = nl80211_set_noack_map,
17191 .flags = GENL_UNS_ADMIN_PERM,
17192 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17195 .cmd = NL80211_CMD_START_P2P_DEVICE,
17196 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17197 .doit = nl80211_start_p2p_device,
17198 .flags = GENL_UNS_ADMIN_PERM,
17199 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV |
17200 NL80211_FLAG_NEED_RTNL),
17203 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
17204 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17205 .doit = nl80211_stop_p2p_device,
17206 .flags = GENL_UNS_ADMIN_PERM,
17207 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP |
17208 NL80211_FLAG_NEED_RTNL),
17211 .cmd = NL80211_CMD_START_NAN,
17212 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17213 .doit = nl80211_start_nan,
17214 .flags = GENL_ADMIN_PERM,
17215 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV |
17216 NL80211_FLAG_NEED_RTNL),
17219 .cmd = NL80211_CMD_STOP_NAN,
17220 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17221 .doit = nl80211_stop_nan,
17222 .flags = GENL_ADMIN_PERM,
17223 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP |
17224 NL80211_FLAG_NEED_RTNL),
17227 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
17228 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17229 .doit = nl80211_nan_add_func,
17230 .flags = GENL_ADMIN_PERM,
17231 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17234 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
17235 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17236 .doit = nl80211_nan_del_func,
17237 .flags = GENL_ADMIN_PERM,
17238 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17241 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
17242 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17243 .doit = nl80211_nan_change_config,
17244 .flags = GENL_ADMIN_PERM,
17245 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17248 .cmd = NL80211_CMD_SET_MCAST_RATE,
17249 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17250 .doit = nl80211_set_mcast_rate,
17251 .flags = GENL_UNS_ADMIN_PERM,
17252 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17255 .cmd = NL80211_CMD_SET_MAC_ACL,
17256 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17257 .doit = nl80211_set_mac_acl,
17258 .flags = GENL_UNS_ADMIN_PERM,
17259 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV |
17260 NL80211_FLAG_MLO_UNSUPPORTED),
17263 .cmd = NL80211_CMD_RADAR_DETECT,
17264 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17265 .doit = nl80211_start_radar_detection,
17266 .flags = GENL_UNS_ADMIN_PERM,
17267 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17268 NL80211_FLAG_NO_WIPHY_MTX |
17269 NL80211_FLAG_MLO_UNSUPPORTED),
17272 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
17273 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17274 .doit = nl80211_get_protocol_features,
17277 .cmd = NL80211_CMD_UPDATE_FT_IES,
17278 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17279 .doit = nl80211_update_ft_ies,
17280 .flags = GENL_UNS_ADMIN_PERM,
17281 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17284 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
17285 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17286 .doit = nl80211_crit_protocol_start,
17287 .flags = GENL_UNS_ADMIN_PERM,
17288 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17291 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
17292 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17293 .doit = nl80211_crit_protocol_stop,
17294 .flags = GENL_UNS_ADMIN_PERM,
17295 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17298 .cmd = NL80211_CMD_GET_COALESCE,
17299 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17300 .doit = nl80211_get_coalesce,
17301 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
17304 .cmd = NL80211_CMD_SET_COALESCE,
17305 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17306 .doit = nl80211_set_coalesce,
17307 .flags = GENL_UNS_ADMIN_PERM,
17308 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY),
17311 .cmd = NL80211_CMD_CHANNEL_SWITCH,
17312 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17313 .doit = nl80211_channel_switch,
17314 .flags = GENL_UNS_ADMIN_PERM,
17315 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17316 NL80211_FLAG_MLO_VALID_LINK_ID),
17319 .cmd = NL80211_CMD_VENDOR,
17320 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17321 .doit = nl80211_vendor_cmd,
17322 .dumpit = nl80211_vendor_cmd_dump,
17323 .flags = GENL_UNS_ADMIN_PERM,
17324 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY |
17325 NL80211_FLAG_CLEAR_SKB),
17328 .cmd = NL80211_CMD_SET_QOS_MAP,
17329 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17330 .doit = nl80211_set_qos_map,
17331 .flags = GENL_UNS_ADMIN_PERM,
17332 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17335 .cmd = NL80211_CMD_ADD_TX_TS,
17336 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17337 .doit = nl80211_add_tx_ts,
17338 .flags = GENL_UNS_ADMIN_PERM,
17339 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17340 NL80211_FLAG_MLO_UNSUPPORTED),
17343 .cmd = NL80211_CMD_DEL_TX_TS,
17344 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17345 .doit = nl80211_del_tx_ts,
17346 .flags = GENL_UNS_ADMIN_PERM,
17347 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17350 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
17351 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17352 .doit = nl80211_tdls_channel_switch,
17353 .flags = GENL_UNS_ADMIN_PERM,
17354 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17357 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
17358 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17359 .doit = nl80211_tdls_cancel_channel_switch,
17360 .flags = GENL_UNS_ADMIN_PERM,
17361 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17364 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
17365 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17366 .doit = nl80211_set_multicast_to_unicast,
17367 .flags = GENL_UNS_ADMIN_PERM,
17368 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV),
17371 .cmd = NL80211_CMD_SET_PMK,
17372 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17373 .doit = nl80211_set_pmk,
17374 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17375 NL80211_FLAG_CLEAR_SKB),
17378 .cmd = NL80211_CMD_DEL_PMK,
17379 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17380 .doit = nl80211_del_pmk,
17381 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17384 .cmd = NL80211_CMD_EXTERNAL_AUTH,
17385 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17386 .doit = nl80211_external_auth,
17387 .flags = GENL_ADMIN_PERM,
17388 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17391 .cmd = NL80211_CMD_CONTROL_PORT_FRAME,
17392 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17393 .doit = nl80211_tx_control_port,
17394 .flags = GENL_UNS_ADMIN_PERM,
17395 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17398 .cmd = NL80211_CMD_GET_FTM_RESPONDER_STATS,
17399 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17400 .doit = nl80211_get_ftm_responder_stats,
17401 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV |
17402 NL80211_FLAG_MLO_VALID_LINK_ID),
17405 .cmd = NL80211_CMD_PEER_MEASUREMENT_START,
17406 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17407 .doit = nl80211_pmsr_start,
17408 .flags = GENL_UNS_ADMIN_PERM,
17409 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP),
17412 .cmd = NL80211_CMD_NOTIFY_RADAR,
17413 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17414 .doit = nl80211_notify_radar_detection,
17415 .flags = GENL_UNS_ADMIN_PERM,
17416 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17419 .cmd = NL80211_CMD_UPDATE_OWE_INFO,
17420 .doit = nl80211_update_owe_info,
17421 .flags = GENL_ADMIN_PERM,
17422 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17425 .cmd = NL80211_CMD_PROBE_MESH_LINK,
17426 .doit = nl80211_probe_mesh_link,
17427 .flags = GENL_UNS_ADMIN_PERM,
17428 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17431 .cmd = NL80211_CMD_SET_TID_CONFIG,
17432 .doit = nl80211_set_tid_config,
17433 .flags = GENL_UNS_ADMIN_PERM,
17434 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV |
17435 NL80211_FLAG_MLO_VALID_LINK_ID),
17438 .cmd = NL80211_CMD_SET_SAR_SPECS,
17439 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17440 .doit = nl80211_set_sar_specs,
17441 .flags = GENL_UNS_ADMIN_PERM,
17442 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY |
17443 NL80211_FLAG_NEED_RTNL),
17446 .cmd = NL80211_CMD_COLOR_CHANGE_REQUEST,
17447 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17448 .doit = nl80211_color_change,
17449 .flags = GENL_UNS_ADMIN_PERM,
17450 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17453 .cmd = NL80211_CMD_SET_FILS_AAD,
17454 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
17455 .doit = nl80211_set_fils_aad,
17456 .flags = GENL_UNS_ADMIN_PERM,
17457 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17460 .cmd = NL80211_CMD_ADD_LINK,
17461 .doit = nl80211_add_link,
17462 .flags = GENL_UNS_ADMIN_PERM,
17463 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17466 .cmd = NL80211_CMD_REMOVE_LINK,
17467 .doit = nl80211_remove_link,
17468 .flags = GENL_UNS_ADMIN_PERM,
17469 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17470 NL80211_FLAG_MLO_VALID_LINK_ID),
17473 .cmd = NL80211_CMD_ADD_LINK_STA,
17474 .doit = nl80211_add_link_station,
17475 .flags = GENL_UNS_ADMIN_PERM,
17476 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17477 NL80211_FLAG_MLO_VALID_LINK_ID),
17480 .cmd = NL80211_CMD_MODIFY_LINK_STA,
17481 .doit = nl80211_modify_link_station,
17482 .flags = GENL_UNS_ADMIN_PERM,
17483 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17484 NL80211_FLAG_MLO_VALID_LINK_ID),
17487 .cmd = NL80211_CMD_REMOVE_LINK_STA,
17488 .doit = nl80211_remove_link_station,
17489 .flags = GENL_UNS_ADMIN_PERM,
17490 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP |
17491 NL80211_FLAG_MLO_VALID_LINK_ID),
17494 .cmd = NL80211_CMD_SET_HW_TIMESTAMP,
17495 .doit = nl80211_set_hw_timestamp,
17496 .flags = GENL_UNS_ADMIN_PERM,
17497 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP),
17501 static struct genl_family nl80211_fam __ro_after_init = {
17502 .name = NL80211_GENL_NAME, /* have users key off the name instead */
17503 .hdrsize = 0, /* no private header */
17504 .version = 1, /* no particular meaning now */
17505 .maxattr = NL80211_ATTR_MAX,
17506 .policy = nl80211_policy,
17508 .pre_doit = nl80211_pre_doit,
17509 .post_doit = nl80211_post_doit,
17510 .module = THIS_MODULE,
17511 .ops = nl80211_ops,
17512 .n_ops = ARRAY_SIZE(nl80211_ops),
17513 .small_ops = nl80211_small_ops,
17514 .n_small_ops = ARRAY_SIZE(nl80211_small_ops),
17515 .resv_start_op = NL80211_CMD_REMOVE_LINK_STA + 1,
17516 .mcgrps = nl80211_mcgrps,
17517 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
17518 .parallel_ops = true,
17521 /* notification functions */
17523 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
17524 enum nl80211_commands cmd)
17526 struct sk_buff *msg;
17527 struct nl80211_dump_wiphy_state state = {};
17529 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
17530 cmd != NL80211_CMD_DEL_WIPHY);
17532 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17536 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
17541 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17542 NL80211_MCGRP_CONFIG, GFP_KERNEL);
17545 void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
17546 struct wireless_dev *wdev,
17547 enum nl80211_commands cmd)
17549 struct sk_buff *msg;
17551 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17555 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, cmd) < 0) {
17560 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17561 NL80211_MCGRP_CONFIG, GFP_KERNEL);
17564 static int nl80211_add_scan_req(struct sk_buff *msg,
17565 struct cfg80211_registered_device *rdev)
17567 struct cfg80211_scan_request *req = rdev->scan_req;
17568 struct nlattr *nest;
17570 struct cfg80211_scan_info *info;
17575 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_SSIDS);
17577 goto nla_put_failure;
17578 for (i = 0; i < req->n_ssids; i++) {
17579 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
17580 goto nla_put_failure;
17582 nla_nest_end(msg, nest);
17584 if (req->flags & NL80211_SCAN_FLAG_FREQ_KHZ) {
17585 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQ_KHZ);
17587 goto nla_put_failure;
17588 for (i = 0; i < req->n_channels; i++) {
17589 if (nla_put_u32(msg, i,
17590 ieee80211_channel_to_khz(req->channels[i])))
17591 goto nla_put_failure;
17593 nla_nest_end(msg, nest);
17595 nest = nla_nest_start_noflag(msg,
17596 NL80211_ATTR_SCAN_FREQUENCIES);
17598 goto nla_put_failure;
17599 for (i = 0; i < req->n_channels; i++) {
17600 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
17601 goto nla_put_failure;
17603 nla_nest_end(msg, nest);
17607 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
17608 goto nla_put_failure;
17611 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
17612 goto nla_put_failure;
17614 info = rdev->int_scan_req ? &rdev->int_scan_req->info :
17615 &rdev->scan_req->info;
17616 if (info->scan_start_tsf &&
17617 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
17618 info->scan_start_tsf, NL80211_BSS_PAD) ||
17619 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
17621 goto nla_put_failure;
17628 static int nl80211_prep_scan_msg(struct sk_buff *msg,
17629 struct cfg80211_registered_device *rdev,
17630 struct wireless_dev *wdev,
17631 u32 portid, u32 seq, int flags,
17636 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
17640 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17641 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
17642 wdev->netdev->ifindex)) ||
17643 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17645 goto nla_put_failure;
17647 /* ignore errors and send incomplete event anyway */
17648 nl80211_add_scan_req(msg, rdev);
17650 genlmsg_end(msg, hdr);
17654 genlmsg_cancel(msg, hdr);
17659 nl80211_prep_sched_scan_msg(struct sk_buff *msg,
17660 struct cfg80211_sched_scan_request *req, u32 cmd)
17664 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
17668 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
17669 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
17670 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
17671 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
17673 goto nla_put_failure;
17675 genlmsg_end(msg, hdr);
17679 genlmsg_cancel(msg, hdr);
17683 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
17684 struct wireless_dev *wdev)
17686 struct sk_buff *msg;
17688 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17692 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
17693 NL80211_CMD_TRIGGER_SCAN) < 0) {
17698 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17699 NL80211_MCGRP_SCAN, GFP_KERNEL);
17702 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
17703 struct wireless_dev *wdev, bool aborted)
17705 struct sk_buff *msg;
17707 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17711 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
17712 aborted ? NL80211_CMD_SCAN_ABORTED :
17713 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
17721 /* send message created by nl80211_build_scan_msg() */
17722 void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
17723 struct sk_buff *msg)
17728 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17729 NL80211_MCGRP_SCAN, GFP_KERNEL);
17732 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
17734 struct sk_buff *msg;
17736 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17740 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
17745 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
17746 NL80211_MCGRP_SCAN, GFP_KERNEL);
17749 static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
17750 struct regulatory_request *request)
17752 /* Userspace can always count this one always being set */
17753 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
17754 goto nla_put_failure;
17756 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
17757 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
17758 NL80211_REGDOM_TYPE_WORLD))
17759 goto nla_put_failure;
17760 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
17761 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
17762 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
17763 goto nla_put_failure;
17764 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
17765 request->intersect) {
17766 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
17767 NL80211_REGDOM_TYPE_INTERSECTION))
17768 goto nla_put_failure;
17770 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
17771 NL80211_REGDOM_TYPE_COUNTRY) ||
17772 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
17774 goto nla_put_failure;
17777 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
17778 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
17781 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
17782 goto nla_put_failure;
17785 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
17786 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
17787 goto nla_put_failure;
17797 * This can happen on global regulatory changes or device specific settings
17798 * based on custom regulatory domains.
17800 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
17801 struct regulatory_request *request)
17803 struct sk_buff *msg;
17806 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17810 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
17812 goto nla_put_failure;
17814 if (!nl80211_reg_change_event_fill(msg, request))
17815 goto nla_put_failure;
17817 genlmsg_end(msg, hdr);
17820 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
17821 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
17830 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
17831 struct net_device *netdev,
17832 const u8 *buf, size_t len,
17833 enum nl80211_commands cmd, gfp_t gfp,
17834 int uapsd_queues, const u8 *req_ies,
17835 size_t req_ies_len, bool reconnect)
17837 struct sk_buff *msg;
17840 msg = nlmsg_new(100 + len + req_ies_len, gfp);
17844 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
17850 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17851 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17852 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
17854 nla_put(msg, NL80211_ATTR_REQ_IE, req_ies_len, req_ies)))
17855 goto nla_put_failure;
17857 if (reconnect && nla_put_flag(msg, NL80211_ATTR_RECONNECT_REQUESTED))
17858 goto nla_put_failure;
17860 if (uapsd_queues >= 0) {
17861 struct nlattr *nla_wmm =
17862 nla_nest_start_noflag(msg, NL80211_ATTR_STA_WME);
17864 goto nla_put_failure;
17866 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
17868 goto nla_put_failure;
17870 nla_nest_end(msg, nla_wmm);
17873 genlmsg_end(msg, hdr);
17875 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17876 NL80211_MCGRP_MLME, gfp);
17883 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
17884 struct net_device *netdev, const u8 *buf,
17885 size_t len, gfp_t gfp)
17887 nl80211_send_mlme_event(rdev, netdev, buf, len,
17888 NL80211_CMD_AUTHENTICATE, gfp, -1, NULL, 0,
17892 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
17893 struct net_device *netdev,
17894 struct cfg80211_rx_assoc_resp *data)
17896 nl80211_send_mlme_event(rdev, netdev, data->buf, data->len,
17897 NL80211_CMD_ASSOCIATE, GFP_KERNEL,
17898 data->uapsd_queues,
17899 data->req_ies, data->req_ies_len, false);
17902 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
17903 struct net_device *netdev, const u8 *buf,
17904 size_t len, bool reconnect, gfp_t gfp)
17906 nl80211_send_mlme_event(rdev, netdev, buf, len,
17907 NL80211_CMD_DEAUTHENTICATE, gfp, -1, NULL, 0,
17911 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
17912 struct net_device *netdev, const u8 *buf,
17913 size_t len, bool reconnect, gfp_t gfp)
17915 nl80211_send_mlme_event(rdev, netdev, buf, len,
17916 NL80211_CMD_DISASSOCIATE, gfp, -1, NULL, 0,
17920 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
17923 struct wireless_dev *wdev = dev->ieee80211_ptr;
17924 struct wiphy *wiphy = wdev->wiphy;
17925 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17926 const struct ieee80211_mgmt *mgmt = (void *)buf;
17929 if (WARN_ON(len < 2))
17932 if (ieee80211_is_deauth(mgmt->frame_control)) {
17933 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
17934 } else if (ieee80211_is_disassoc(mgmt->frame_control)) {
17935 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
17936 } else if (ieee80211_is_beacon(mgmt->frame_control)) {
17937 if (wdev->unprot_beacon_reported &&
17938 elapsed_jiffies_msecs(wdev->unprot_beacon_reported) < 10000)
17940 cmd = NL80211_CMD_UNPROT_BEACON;
17941 wdev->unprot_beacon_reported = jiffies;
17946 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
17947 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1,
17950 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
17952 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
17953 struct net_device *netdev, int cmd,
17954 const u8 *addr, gfp_t gfp)
17956 struct sk_buff *msg;
17959 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17963 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
17969 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17970 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17971 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
17972 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
17973 goto nla_put_failure;
17975 genlmsg_end(msg, hdr);
17977 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17978 NL80211_MCGRP_MLME, gfp);
17985 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
17986 struct net_device *netdev, const u8 *addr,
17989 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
17993 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
17994 struct net_device *netdev, const u8 *addr,
17997 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
18001 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
18002 struct net_device *netdev,
18003 struct cfg80211_connect_resp_params *cr,
18006 struct sk_buff *msg;
18009 size_t link_info_size = 0;
18010 const u8 *connected_addr = cr->valid_links ?
18011 cr->ap_mld_addr : cr->links[0].bssid;
18013 if (cr->valid_links) {
18014 for_each_valid_link(cr, link) {
18015 /* Nested attribute header */
18016 link_info_size += NLA_HDRLEN;
18018 link_info_size += nla_total_size(sizeof(u8));
18019 link_info_size += cr->links[link].addr ?
18020 nla_total_size(ETH_ALEN) : 0;
18021 link_info_size += (cr->links[link].bssid ||
18022 cr->links[link].bss) ?
18023 nla_total_size(ETH_ALEN) : 0;
18024 link_info_size += nla_total_size(sizeof(u16));
18028 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
18029 cr->fils.kek_len + cr->fils.pmk_len +
18030 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0) + link_info_size,
18035 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
18041 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18042 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18044 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, connected_addr)) ||
18045 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
18046 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
18049 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
18050 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
18051 cr->timeout_reason))) ||
18053 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
18055 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
18057 (cr->fils.update_erp_next_seq_num &&
18058 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
18059 cr->fils.erp_next_seq_num)) ||
18060 (cr->status == WLAN_STATUS_SUCCESS &&
18062 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len,
18065 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) ||
18067 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid)))))
18068 goto nla_put_failure;
18070 if (cr->valid_links) {
18072 struct nlattr *nested;
18074 nested = nla_nest_start(msg, NL80211_ATTR_MLO_LINKS);
18076 goto nla_put_failure;
18078 for_each_valid_link(cr, link) {
18079 struct nlattr *nested_mlo_links;
18080 const u8 *bssid = cr->links[link].bss ?
18081 cr->links[link].bss->bssid :
18082 cr->links[link].bssid;
18084 nested_mlo_links = nla_nest_start(msg, i);
18085 if (!nested_mlo_links)
18086 goto nla_put_failure;
18088 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link) ||
18090 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, bssid)) ||
18091 (cr->links[link].addr &&
18092 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
18093 cr->links[link].addr)) ||
18094 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
18095 cr->links[link].status))
18096 goto nla_put_failure;
18098 nla_nest_end(msg, nested_mlo_links);
18101 nla_nest_end(msg, nested);
18104 genlmsg_end(msg, hdr);
18106 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18107 NL80211_MCGRP_MLME, gfp);
18114 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
18115 struct net_device *netdev,
18116 struct cfg80211_roam_info *info, gfp_t gfp)
18118 struct sk_buff *msg;
18120 size_t link_info_size = 0;
18122 const u8 *connected_addr = info->ap_mld_addr ?
18123 info->ap_mld_addr :
18124 (info->links[0].bss ?
18125 info->links[0].bss->bssid :
18126 info->links[0].bssid);
18128 if (info->valid_links) {
18129 for_each_valid_link(info, link) {
18130 /* Nested attribute header */
18131 link_info_size += NLA_HDRLEN;
18133 link_info_size += nla_total_size(sizeof(u8));
18134 link_info_size += info->links[link].addr ?
18135 nla_total_size(ETH_ALEN) : 0;
18136 link_info_size += (info->links[link].bssid ||
18137 info->links[link].bss) ?
18138 nla_total_size(ETH_ALEN) : 0;
18142 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len +
18143 info->fils.kek_len + info->fils.pmk_len +
18144 (info->fils.pmkid ? WLAN_PMKID_LEN : 0) +
18145 link_info_size, gfp);
18149 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
18155 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18156 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18157 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, connected_addr) ||
18159 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
18162 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
18164 (info->fils.update_erp_next_seq_num &&
18165 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
18166 info->fils.erp_next_seq_num)) ||
18168 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len,
18169 info->fils.kek)) ||
18171 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) ||
18172 (info->fils.pmkid &&
18173 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid)))
18174 goto nla_put_failure;
18176 if (info->valid_links) {
18178 struct nlattr *nested;
18180 nested = nla_nest_start(msg, NL80211_ATTR_MLO_LINKS);
18182 goto nla_put_failure;
18184 for_each_valid_link(info, link) {
18185 struct nlattr *nested_mlo_links;
18186 const u8 *bssid = info->links[link].bss ?
18187 info->links[link].bss->bssid :
18188 info->links[link].bssid;
18190 nested_mlo_links = nla_nest_start(msg, i);
18191 if (!nested_mlo_links)
18192 goto nla_put_failure;
18194 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link) ||
18196 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, bssid)) ||
18197 (info->links[link].addr &&
18198 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
18199 info->links[link].addr)))
18200 goto nla_put_failure;
18202 nla_nest_end(msg, nested_mlo_links);
18205 nla_nest_end(msg, nested);
18208 genlmsg_end(msg, hdr);
18210 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18211 NL80211_MCGRP_MLME, gfp);
18218 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
18219 struct net_device *netdev, const u8 *bssid,
18220 const u8 *td_bitmap, u8 td_bitmap_len)
18222 struct sk_buff *msg;
18225 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
18229 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED);
18235 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18236 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18237 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
18238 goto nla_put_failure;
18240 if ((td_bitmap_len > 0) && td_bitmap)
18241 if (nla_put(msg, NL80211_ATTR_TD_BITMAP,
18242 td_bitmap_len, td_bitmap))
18243 goto nla_put_failure;
18245 genlmsg_end(msg, hdr);
18247 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18248 NL80211_MCGRP_MLME, GFP_KERNEL);
18255 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
18256 struct net_device *netdev, u16 reason,
18257 const u8 *ie, size_t ie_len, bool from_ap)
18259 struct sk_buff *msg;
18262 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
18266 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
18272 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18273 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18275 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
18277 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
18278 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
18279 goto nla_put_failure;
18281 genlmsg_end(msg, hdr);
18283 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18284 NL80211_MCGRP_MLME, GFP_KERNEL);
18291 void cfg80211_links_removed(struct net_device *dev, u16 link_mask)
18293 struct wireless_dev *wdev = dev->ieee80211_ptr;
18294 struct wiphy *wiphy = wdev->wiphy;
18295 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18296 struct sk_buff *msg;
18297 struct nlattr *links;
18300 ASSERT_WDEV_LOCK(wdev);
18301 trace_cfg80211_links_removed(dev, link_mask);
18303 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
18304 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
18307 if (WARN_ON(!wdev->valid_links || !link_mask ||
18308 (wdev->valid_links & link_mask) != link_mask ||
18309 wdev->valid_links == link_mask))
18312 cfg80211_wdev_release_link_bsses(wdev, link_mask);
18313 wdev->valid_links &= ~link_mask;
18315 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
18319 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_LINKS_REMOVED);
18325 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18326 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
18327 goto nla_put_failure;
18329 links = nla_nest_start(msg, NL80211_ATTR_MLO_LINKS);
18331 goto nla_put_failure;
18333 while (link_mask) {
18334 struct nlattr *link;
18335 int link_id = __ffs(link_mask);
18337 link = nla_nest_start(msg, link_id + 1);
18339 goto nla_put_failure;
18341 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id))
18342 goto nla_put_failure;
18344 nla_nest_end(msg, link);
18345 link_mask &= ~(1 << link_id);
18348 nla_nest_end(msg, links);
18350 genlmsg_end(msg, hdr);
18352 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18353 NL80211_MCGRP_MLME, GFP_KERNEL);
18359 EXPORT_SYMBOL(cfg80211_links_removed);
18361 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
18362 struct net_device *netdev, const u8 *bssid,
18365 struct sk_buff *msg;
18368 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18372 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
18378 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18379 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18380 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
18381 goto nla_put_failure;
18383 genlmsg_end(msg, hdr);
18385 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18386 NL80211_MCGRP_MLME, gfp);
18393 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
18394 const u8 *ie, u8 ie_len,
18395 int sig_dbm, gfp_t gfp)
18397 struct wireless_dev *wdev = dev->ieee80211_ptr;
18398 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
18399 struct sk_buff *msg;
18402 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
18405 trace_cfg80211_notify_new_peer_candidate(dev, addr);
18407 msg = nlmsg_new(100 + ie_len, gfp);
18411 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
18417 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18418 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
18419 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
18421 nla_put(msg, NL80211_ATTR_IE, ie_len, ie)) ||
18423 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)))
18424 goto nla_put_failure;
18426 genlmsg_end(msg, hdr);
18428 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18429 NL80211_MCGRP_MLME, gfp);
18435 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
18437 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
18438 struct net_device *netdev, const u8 *addr,
18439 enum nl80211_key_type key_type, int key_id,
18440 const u8 *tsc, gfp_t gfp)
18442 struct sk_buff *msg;
18445 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18449 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
18455 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18456 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18457 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
18458 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
18460 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
18461 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
18462 goto nla_put_failure;
18464 genlmsg_end(msg, hdr);
18466 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18467 NL80211_MCGRP_MLME, gfp);
18474 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
18475 struct ieee80211_channel *channel_before,
18476 struct ieee80211_channel *channel_after)
18478 struct sk_buff *msg;
18480 struct nlattr *nl_freq;
18482 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
18486 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
18493 * Since we are applying the beacon hint to a wiphy we know its
18494 * wiphy_idx is valid
18496 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
18497 goto nla_put_failure;
18500 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_BEFORE);
18502 goto nla_put_failure;
18504 if (nl80211_msg_put_channel(msg, wiphy, channel_before, false))
18505 goto nla_put_failure;
18506 nla_nest_end(msg, nl_freq);
18509 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_AFTER);
18511 goto nla_put_failure;
18513 if (nl80211_msg_put_channel(msg, wiphy, channel_after, false))
18514 goto nla_put_failure;
18515 nla_nest_end(msg, nl_freq);
18517 genlmsg_end(msg, hdr);
18520 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
18521 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
18530 static void nl80211_send_remain_on_chan_event(
18531 int cmd, struct cfg80211_registered_device *rdev,
18532 struct wireless_dev *wdev, u64 cookie,
18533 struct ieee80211_channel *chan,
18534 unsigned int duration, gfp_t gfp)
18536 struct sk_buff *msg;
18539 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18543 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
18549 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18550 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
18551 wdev->netdev->ifindex)) ||
18552 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
18553 NL80211_ATTR_PAD) ||
18554 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
18555 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
18556 NL80211_CHAN_NO_HT) ||
18557 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
18559 goto nla_put_failure;
18561 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
18562 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
18563 goto nla_put_failure;
18565 genlmsg_end(msg, hdr);
18567 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18568 NL80211_MCGRP_MLME, gfp);
18575 void cfg80211_assoc_comeback(struct net_device *netdev,
18576 const u8 *ap_addr, u32 timeout)
18578 struct wireless_dev *wdev = netdev->ieee80211_ptr;
18579 struct wiphy *wiphy = wdev->wiphy;
18580 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18581 struct sk_buff *msg;
18584 trace_cfg80211_assoc_comeback(wdev, ap_addr, timeout);
18586 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
18590 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ASSOC_COMEBACK);
18596 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18597 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
18598 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ap_addr) ||
18599 nla_put_u32(msg, NL80211_ATTR_TIMEOUT, timeout))
18600 goto nla_put_failure;
18602 genlmsg_end(msg, hdr);
18604 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18605 NL80211_MCGRP_MLME, GFP_KERNEL);
18611 EXPORT_SYMBOL(cfg80211_assoc_comeback);
18613 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
18614 struct ieee80211_channel *chan,
18615 unsigned int duration, gfp_t gfp)
18617 struct wiphy *wiphy = wdev->wiphy;
18618 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18620 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
18621 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
18622 rdev, wdev, cookie, chan,
18625 EXPORT_SYMBOL(cfg80211_ready_on_channel);
18627 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
18628 struct ieee80211_channel *chan,
18631 struct wiphy *wiphy = wdev->wiphy;
18632 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18634 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
18635 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
18636 rdev, wdev, cookie, chan, 0, gfp);
18638 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
18640 void cfg80211_tx_mgmt_expired(struct wireless_dev *wdev, u64 cookie,
18641 struct ieee80211_channel *chan,
18644 struct wiphy *wiphy = wdev->wiphy;
18645 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18647 trace_cfg80211_tx_mgmt_expired(wdev, cookie, chan);
18648 nl80211_send_remain_on_chan_event(NL80211_CMD_FRAME_WAIT_CANCEL,
18649 rdev, wdev, cookie, chan, 0, gfp);
18651 EXPORT_SYMBOL(cfg80211_tx_mgmt_expired);
18653 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
18654 struct station_info *sinfo, gfp_t gfp)
18656 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
18657 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18658 struct sk_buff *msg;
18660 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
18662 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18666 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
18667 rdev, dev, mac_addr, sinfo) < 0) {
18672 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18673 NL80211_MCGRP_MLME, gfp);
18675 EXPORT_SYMBOL(cfg80211_new_sta);
18677 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
18678 struct station_info *sinfo, gfp_t gfp)
18680 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
18681 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18682 struct sk_buff *msg;
18683 struct station_info empty_sinfo = {};
18686 sinfo = &empty_sinfo;
18688 trace_cfg80211_del_sta(dev, mac_addr);
18690 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
18692 cfg80211_sinfo_release_content(sinfo);
18696 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
18697 rdev, dev, mac_addr, sinfo) < 0) {
18702 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18703 NL80211_MCGRP_MLME, gfp);
18705 EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
18707 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
18708 enum nl80211_connect_failed_reason reason,
18711 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
18712 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18713 struct sk_buff *msg;
18716 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
18720 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
18726 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
18727 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
18728 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
18729 goto nla_put_failure;
18731 genlmsg_end(msg, hdr);
18733 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18734 NL80211_MCGRP_MLME, gfp);
18740 EXPORT_SYMBOL(cfg80211_conn_failed);
18742 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
18743 const u8 *addr, gfp_t gfp)
18745 struct wireless_dev *wdev = dev->ieee80211_ptr;
18746 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
18747 struct sk_buff *msg;
18749 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
18754 msg = nlmsg_new(100, gfp);
18758 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
18764 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18765 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
18766 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
18767 goto nla_put_failure;
18769 genlmsg_end(msg, hdr);
18770 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
18778 bool cfg80211_rx_spurious_frame(struct net_device *dev,
18779 const u8 *addr, gfp_t gfp)
18781 struct wireless_dev *wdev = dev->ieee80211_ptr;
18784 trace_cfg80211_rx_spurious_frame(dev, addr);
18786 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
18787 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
18788 trace_cfg80211_return_bool(false);
18791 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
18793 trace_cfg80211_return_bool(ret);
18796 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
18798 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
18799 const u8 *addr, gfp_t gfp)
18801 struct wireless_dev *wdev = dev->ieee80211_ptr;
18804 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
18806 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
18807 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
18808 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
18809 trace_cfg80211_return_bool(false);
18812 ret = __nl80211_unexpected_frame(dev,
18813 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
18815 trace_cfg80211_return_bool(ret);
18818 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
18820 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
18821 struct wireless_dev *wdev, u32 nlportid,
18822 struct cfg80211_rx_info *info, gfp_t gfp)
18824 struct net_device *netdev = wdev->netdev;
18825 struct sk_buff *msg;
18828 msg = nlmsg_new(100 + info->len, gfp);
18832 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
18838 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18839 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
18840 netdev->ifindex)) ||
18841 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
18842 NL80211_ATTR_PAD) ||
18843 (info->have_link_id &&
18844 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, info->link_id)) ||
18845 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, KHZ_TO_MHZ(info->freq)) ||
18846 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET, info->freq % 1000) ||
18848 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, info->sig_dbm)) ||
18849 nla_put(msg, NL80211_ATTR_FRAME, info->len, info->buf) ||
18851 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, info->flags)) ||
18852 (info->rx_tstamp && nla_put_u64_64bit(msg,
18853 NL80211_ATTR_RX_HW_TIMESTAMP,
18855 NL80211_ATTR_PAD)) ||
18856 (info->ack_tstamp && nla_put_u64_64bit(msg,
18857 NL80211_ATTR_TX_HW_TIMESTAMP,
18859 NL80211_ATTR_PAD)))
18860 goto nla_put_failure;
18862 genlmsg_end(msg, hdr);
18864 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
18871 static void nl80211_frame_tx_status(struct wireless_dev *wdev,
18872 struct cfg80211_tx_status *status,
18873 gfp_t gfp, enum nl80211_commands command)
18875 struct wiphy *wiphy = wdev->wiphy;
18876 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
18877 struct net_device *netdev = wdev->netdev;
18878 struct sk_buff *msg;
18881 if (command == NL80211_CMD_FRAME_TX_STATUS)
18882 trace_cfg80211_mgmt_tx_status(wdev, status->cookie,
18885 trace_cfg80211_control_port_tx_status(wdev, status->cookie,
18888 msg = nlmsg_new(100 + status->len, gfp);
18892 hdr = nl80211hdr_put(msg, 0, 0, 0, command);
18898 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18899 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
18900 netdev->ifindex)) ||
18901 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
18902 NL80211_ATTR_PAD) ||
18903 nla_put(msg, NL80211_ATTR_FRAME, status->len, status->buf) ||
18904 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, status->cookie,
18905 NL80211_ATTR_PAD) ||
18906 (status->ack && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
18907 (status->tx_tstamp &&
18908 nla_put_u64_64bit(msg, NL80211_ATTR_TX_HW_TIMESTAMP,
18909 status->tx_tstamp, NL80211_ATTR_PAD)) ||
18910 (status->ack_tstamp &&
18911 nla_put_u64_64bit(msg, NL80211_ATTR_RX_HW_TIMESTAMP,
18912 status->ack_tstamp, NL80211_ATTR_PAD)))
18913 goto nla_put_failure;
18915 genlmsg_end(msg, hdr);
18917 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
18918 NL80211_MCGRP_MLME, gfp);
18925 void cfg80211_control_port_tx_status(struct wireless_dev *wdev, u64 cookie,
18926 const u8 *buf, size_t len, bool ack,
18929 struct cfg80211_tx_status status = {
18936 nl80211_frame_tx_status(wdev, &status, gfp,
18937 NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS);
18939 EXPORT_SYMBOL(cfg80211_control_port_tx_status);
18941 void cfg80211_mgmt_tx_status_ext(struct wireless_dev *wdev,
18942 struct cfg80211_tx_status *status, gfp_t gfp)
18944 nl80211_frame_tx_status(wdev, status, gfp, NL80211_CMD_FRAME_TX_STATUS);
18946 EXPORT_SYMBOL(cfg80211_mgmt_tx_status_ext);
18948 static int __nl80211_rx_control_port(struct net_device *dev,
18949 struct sk_buff *skb,
18954 struct wireless_dev *wdev = dev->ieee80211_ptr;
18955 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
18956 struct ethhdr *ehdr = eth_hdr(skb);
18957 const u8 *addr = ehdr->h_source;
18958 u16 proto = be16_to_cpu(skb->protocol);
18959 struct sk_buff *msg;
18961 struct nlattr *frame;
18963 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid);
18968 msg = nlmsg_new(100 + skb->len, gfp);
18972 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME);
18978 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
18979 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
18980 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
18981 NL80211_ATTR_PAD) ||
18982 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
18983 nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) ||
18985 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)) ||
18986 (unencrypted && nla_put_flag(msg,
18987 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
18988 goto nla_put_failure;
18990 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len);
18992 goto nla_put_failure;
18994 skb_copy_bits(skb, 0, nla_data(frame), skb->len);
18995 genlmsg_end(msg, hdr);
18997 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
19004 bool cfg80211_rx_control_port(struct net_device *dev, struct sk_buff *skb,
19005 bool unencrypted, int link_id)
19009 trace_cfg80211_rx_control_port(dev, skb, unencrypted, link_id);
19010 ret = __nl80211_rx_control_port(dev, skb, unencrypted, link_id,
19012 trace_cfg80211_return_bool(ret == 0);
19015 EXPORT_SYMBOL(cfg80211_rx_control_port);
19017 static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
19018 const char *mac, gfp_t gfp)
19020 struct wireless_dev *wdev = dev->ieee80211_ptr;
19021 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19022 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19028 cb = (void **)msg->cb;
19030 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
19036 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19037 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
19038 goto nla_put_failure;
19040 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
19041 goto nla_put_failure;
19043 cb[1] = nla_nest_start_noflag(msg, NL80211_ATTR_CQM);
19045 goto nla_put_failure;
19055 static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
19057 void **cb = (void **)msg->cb;
19058 struct cfg80211_registered_device *rdev = cb[2];
19060 nla_nest_end(msg, cb[1]);
19061 genlmsg_end(msg, cb[0]);
19063 memset(msg->cb, 0, sizeof(msg->cb));
19065 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19066 NL80211_MCGRP_MLME, gfp);
19069 void cfg80211_cqm_rssi_notify(struct net_device *dev,
19070 enum nl80211_cqm_rssi_threshold_event rssi_event,
19071 s32 rssi_level, gfp_t gfp)
19073 struct sk_buff *msg;
19074 struct wireless_dev *wdev = dev->ieee80211_ptr;
19075 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19077 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
19079 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
19080 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
19083 if (wdev->cqm_config) {
19084 wdev->cqm_config->last_rssi_event_value = rssi_level;
19086 cfg80211_cqm_rssi_update(rdev, dev);
19088 if (rssi_level == 0)
19089 rssi_level = wdev->cqm_config->last_rssi_event_value;
19092 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
19096 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
19098 goto nla_put_failure;
19100 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
19102 goto nla_put_failure;
19104 cfg80211_send_cqm(msg, gfp);
19111 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
19113 void cfg80211_cqm_txe_notify(struct net_device *dev,
19114 const u8 *peer, u32 num_packets,
19115 u32 rate, u32 intvl, gfp_t gfp)
19117 struct sk_buff *msg;
19119 msg = cfg80211_prepare_cqm(dev, peer, gfp);
19123 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
19124 goto nla_put_failure;
19126 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
19127 goto nla_put_failure;
19129 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
19130 goto nla_put_failure;
19132 cfg80211_send_cqm(msg, gfp);
19138 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
19140 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
19141 const u8 *peer, u32 num_packets, gfp_t gfp)
19143 struct sk_buff *msg;
19145 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
19147 msg = cfg80211_prepare_cqm(dev, peer, gfp);
19151 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
19152 goto nla_put_failure;
19154 cfg80211_send_cqm(msg, gfp);
19160 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
19162 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
19164 struct sk_buff *msg;
19166 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
19170 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
19171 goto nla_put_failure;
19173 cfg80211_send_cqm(msg, gfp);
19179 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
19181 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
19182 struct net_device *netdev, const u8 *bssid,
19183 const u8 *replay_ctr, gfp_t gfp)
19185 struct sk_buff *msg;
19186 struct nlattr *rekey_attr;
19189 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19193 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
19199 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19200 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19201 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
19202 goto nla_put_failure;
19204 rekey_attr = nla_nest_start_noflag(msg, NL80211_ATTR_REKEY_DATA);
19206 goto nla_put_failure;
19208 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
19209 NL80211_REPLAY_CTR_LEN, replay_ctr))
19210 goto nla_put_failure;
19212 nla_nest_end(msg, rekey_attr);
19214 genlmsg_end(msg, hdr);
19216 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19217 NL80211_MCGRP_MLME, gfp);
19224 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
19225 const u8 *replay_ctr, gfp_t gfp)
19227 struct wireless_dev *wdev = dev->ieee80211_ptr;
19228 struct wiphy *wiphy = wdev->wiphy;
19229 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19231 trace_cfg80211_gtk_rekey_notify(dev, bssid);
19232 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
19234 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
19237 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
19238 struct net_device *netdev, int index,
19239 const u8 *bssid, bool preauth, gfp_t gfp)
19241 struct sk_buff *msg;
19242 struct nlattr *attr;
19245 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19249 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
19255 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19256 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
19257 goto nla_put_failure;
19259 attr = nla_nest_start_noflag(msg, NL80211_ATTR_PMKSA_CANDIDATE);
19261 goto nla_put_failure;
19263 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
19264 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
19266 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
19267 goto nla_put_failure;
19269 nla_nest_end(msg, attr);
19271 genlmsg_end(msg, hdr);
19273 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19274 NL80211_MCGRP_MLME, gfp);
19281 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
19282 const u8 *bssid, bool preauth, gfp_t gfp)
19284 struct wireless_dev *wdev = dev->ieee80211_ptr;
19285 struct wiphy *wiphy = wdev->wiphy;
19286 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19288 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
19289 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
19291 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
19293 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
19294 struct net_device *netdev,
19295 unsigned int link_id,
19296 struct cfg80211_chan_def *chandef,
19298 enum nl80211_commands notif,
19299 u8 count, bool quiet, u16 punct_bitmap)
19301 struct wireless_dev *wdev = netdev->ieee80211_ptr;
19302 struct sk_buff *msg;
19305 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19309 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
19315 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
19316 goto nla_put_failure;
19318 if (wdev->valid_links &&
19319 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id))
19320 goto nla_put_failure;
19322 if (nl80211_send_chandef(msg, chandef))
19323 goto nla_put_failure;
19325 if (notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) {
19326 if (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count))
19327 goto nla_put_failure;
19329 nla_put_flag(msg, NL80211_ATTR_CH_SWITCH_BLOCK_TX))
19330 goto nla_put_failure;
19333 if (nla_put_u32(msg, NL80211_ATTR_PUNCT_BITMAP, punct_bitmap))
19334 goto nla_put_failure;
19336 genlmsg_end(msg, hdr);
19338 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19339 NL80211_MCGRP_MLME, gfp);
19346 void cfg80211_ch_switch_notify(struct net_device *dev,
19347 struct cfg80211_chan_def *chandef,
19348 unsigned int link_id, u16 punct_bitmap)
19350 struct wireless_dev *wdev = dev->ieee80211_ptr;
19351 struct wiphy *wiphy = wdev->wiphy;
19352 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19354 ASSERT_WDEV_LOCK(wdev);
19355 WARN_INVALID_LINK_ID(wdev, link_id);
19357 trace_cfg80211_ch_switch_notify(dev, chandef, link_id, punct_bitmap);
19359 switch (wdev->iftype) {
19360 case NL80211_IFTYPE_STATION:
19361 case NL80211_IFTYPE_P2P_CLIENT:
19362 if (!WARN_ON(!wdev->links[link_id].client.current_bss))
19363 cfg80211_update_assoc_bss_entry(wdev, link_id,
19366 case NL80211_IFTYPE_MESH_POINT:
19367 wdev->u.mesh.chandef = *chandef;
19368 wdev->u.mesh.preset_chandef = *chandef;
19370 case NL80211_IFTYPE_AP:
19371 case NL80211_IFTYPE_P2P_GO:
19372 wdev->links[link_id].ap.chandef = *chandef;
19374 case NL80211_IFTYPE_ADHOC:
19375 wdev->u.ibss.chandef = *chandef;
19382 cfg80211_sched_dfs_chan_update(rdev);
19384 nl80211_ch_switch_notify(rdev, dev, link_id, chandef, GFP_KERNEL,
19385 NL80211_CMD_CH_SWITCH_NOTIFY, 0, false,
19388 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
19390 void cfg80211_ch_switch_started_notify(struct net_device *dev,
19391 struct cfg80211_chan_def *chandef,
19392 unsigned int link_id, u8 count,
19393 bool quiet, u16 punct_bitmap)
19395 struct wireless_dev *wdev = dev->ieee80211_ptr;
19396 struct wiphy *wiphy = wdev->wiphy;
19397 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19399 ASSERT_WDEV_LOCK(wdev);
19400 WARN_INVALID_LINK_ID(wdev, link_id);
19402 trace_cfg80211_ch_switch_started_notify(dev, chandef, link_id,
19406 nl80211_ch_switch_notify(rdev, dev, link_id, chandef, GFP_KERNEL,
19407 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY,
19408 count, quiet, punct_bitmap);
19410 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
19412 int cfg80211_bss_color_notify(struct net_device *dev,
19413 enum nl80211_commands cmd, u8 count,
19416 struct wireless_dev *wdev = dev->ieee80211_ptr;
19417 struct wiphy *wiphy = wdev->wiphy;
19418 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19419 struct sk_buff *msg;
19422 ASSERT_WDEV_LOCK(wdev);
19424 trace_cfg80211_bss_color_notify(dev, cmd, count, color_bitmap);
19426 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
19430 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
19432 goto nla_put_failure;
19434 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
19435 goto nla_put_failure;
19437 if (cmd == NL80211_CMD_COLOR_CHANGE_STARTED &&
19438 nla_put_u32(msg, NL80211_ATTR_COLOR_CHANGE_COUNT, count))
19439 goto nla_put_failure;
19441 if (cmd == NL80211_CMD_OBSS_COLOR_COLLISION &&
19442 nla_put_u64_64bit(msg, NL80211_ATTR_OBSS_COLOR_BITMAP,
19443 color_bitmap, NL80211_ATTR_PAD))
19444 goto nla_put_failure;
19446 genlmsg_end(msg, hdr);
19448 return genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
19449 msg, 0, NL80211_MCGRP_MLME, GFP_KERNEL);
19455 EXPORT_SYMBOL(cfg80211_bss_color_notify);
19458 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
19459 const struct cfg80211_chan_def *chandef,
19460 enum nl80211_radar_event event,
19461 struct net_device *netdev, gfp_t gfp)
19463 struct sk_buff *msg;
19466 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19470 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
19476 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
19477 goto nla_put_failure;
19479 /* NOP and radar events don't need a netdev parameter */
19481 struct wireless_dev *wdev = netdev->ieee80211_ptr;
19483 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19484 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
19486 goto nla_put_failure;
19489 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
19490 goto nla_put_failure;
19492 if (nl80211_send_chandef(msg, chandef))
19493 goto nla_put_failure;
19495 genlmsg_end(msg, hdr);
19497 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19498 NL80211_MCGRP_MLME, gfp);
19505 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac,
19506 struct sta_opmode_info *sta_opmode,
19509 struct sk_buff *msg;
19510 struct wireless_dev *wdev = dev->ieee80211_ptr;
19511 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19517 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19521 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED);
19527 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
19528 goto nla_put_failure;
19530 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
19531 goto nla_put_failure;
19533 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
19534 goto nla_put_failure;
19536 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) &&
19537 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode))
19538 goto nla_put_failure;
19540 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) &&
19541 nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw))
19542 goto nla_put_failure;
19544 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) &&
19545 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss))
19546 goto nla_put_failure;
19548 genlmsg_end(msg, hdr);
19550 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19551 NL80211_MCGRP_MLME, gfp);
19558 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify);
19560 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
19561 u64 cookie, bool acked, s32 ack_signal,
19562 bool is_valid_ack_signal, gfp_t gfp)
19564 struct wireless_dev *wdev = dev->ieee80211_ptr;
19565 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19566 struct sk_buff *msg;
19569 trace_cfg80211_probe_status(dev, addr, cookie, acked);
19571 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19576 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
19582 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19583 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
19584 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
19585 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
19586 NL80211_ATTR_PAD) ||
19587 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
19588 (is_valid_ack_signal && nla_put_s32(msg, NL80211_ATTR_ACK_SIGNAL,
19590 goto nla_put_failure;
19592 genlmsg_end(msg, hdr);
19594 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19595 NL80211_MCGRP_MLME, gfp);
19601 EXPORT_SYMBOL(cfg80211_probe_status);
19603 void cfg80211_report_obss_beacon_khz(struct wiphy *wiphy, const u8 *frame,
19604 size_t len, int freq, int sig_dbm)
19606 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19607 struct sk_buff *msg;
19609 struct cfg80211_beacon_registration *reg;
19611 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
19613 spin_lock_bh(&rdev->beacon_registrations_lock);
19614 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
19615 msg = nlmsg_new(len + 100, GFP_ATOMIC);
19617 spin_unlock_bh(&rdev->beacon_registrations_lock);
19621 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
19623 goto nla_put_failure;
19625 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19627 (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
19628 KHZ_TO_MHZ(freq)) ||
19629 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET,
19632 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
19633 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
19634 goto nla_put_failure;
19636 genlmsg_end(msg, hdr);
19638 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
19640 spin_unlock_bh(&rdev->beacon_registrations_lock);
19644 spin_unlock_bh(&rdev->beacon_registrations_lock);
19647 EXPORT_SYMBOL(cfg80211_report_obss_beacon_khz);
19650 static int cfg80211_net_detect_results(struct sk_buff *msg,
19651 struct cfg80211_wowlan_wakeup *wakeup)
19653 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
19654 struct nlattr *nl_results, *nl_match, *nl_freqs;
19657 nl_results = nla_nest_start_noflag(msg,
19658 NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
19662 for (i = 0; i < nd->n_matches; i++) {
19663 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
19665 nl_match = nla_nest_start_noflag(msg, i);
19669 /* The SSID attribute is optional in nl80211, but for
19670 * simplicity reasons it's always present in the
19671 * cfg80211 structure. If a driver can't pass the
19672 * SSID, that needs to be changed. A zero length SSID
19673 * is still a valid SSID (wildcard), so it cannot be
19674 * used for this purpose.
19676 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
19677 match->ssid.ssid)) {
19678 nla_nest_cancel(msg, nl_match);
19682 if (match->n_channels) {
19683 nl_freqs = nla_nest_start_noflag(msg,
19684 NL80211_ATTR_SCAN_FREQUENCIES);
19686 nla_nest_cancel(msg, nl_match);
19690 for (j = 0; j < match->n_channels; j++) {
19691 if (nla_put_u32(msg, j, match->channels[j])) {
19692 nla_nest_cancel(msg, nl_freqs);
19693 nla_nest_cancel(msg, nl_match);
19698 nla_nest_end(msg, nl_freqs);
19701 nla_nest_end(msg, nl_match);
19705 nla_nest_end(msg, nl_results);
19709 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
19710 struct cfg80211_wowlan_wakeup *wakeup,
19713 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19714 struct sk_buff *msg;
19718 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
19721 size += wakeup->packet_present_len;
19723 msg = nlmsg_new(size, gfp);
19727 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
19731 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19732 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
19736 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
19737 wdev->netdev->ifindex))
19741 struct nlattr *reasons;
19743 reasons = nla_nest_start_noflag(msg,
19744 NL80211_ATTR_WOWLAN_TRIGGERS);
19748 if (wakeup->disconnect &&
19749 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
19751 if (wakeup->magic_pkt &&
19752 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
19754 if (wakeup->gtk_rekey_failure &&
19755 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
19757 if (wakeup->eap_identity_req &&
19758 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
19760 if (wakeup->four_way_handshake &&
19761 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
19763 if (wakeup->rfkill_release &&
19764 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
19767 if (wakeup->pattern_idx >= 0 &&
19768 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
19769 wakeup->pattern_idx))
19772 if (wakeup->tcp_match &&
19773 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
19776 if (wakeup->tcp_connlost &&
19777 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
19780 if (wakeup->tcp_nomoretokens &&
19782 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
19785 if (wakeup->packet) {
19786 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
19787 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
19789 if (!wakeup->packet_80211) {
19791 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
19793 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
19796 if (wakeup->packet_len &&
19797 nla_put_u32(msg, len_attr, wakeup->packet_len))
19800 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
19805 if (wakeup->net_detect &&
19806 cfg80211_net_detect_results(msg, wakeup))
19809 nla_nest_end(msg, reasons);
19812 genlmsg_end(msg, hdr);
19814 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19815 NL80211_MCGRP_MLME, gfp);
19821 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
19824 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
19825 enum nl80211_tdls_operation oper,
19826 u16 reason_code, gfp_t gfp)
19828 struct wireless_dev *wdev = dev->ieee80211_ptr;
19829 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19830 struct sk_buff *msg;
19833 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
19836 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19840 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
19846 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19847 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
19848 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
19849 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
19850 (reason_code > 0 &&
19851 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
19852 goto nla_put_failure;
19854 genlmsg_end(msg, hdr);
19856 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19857 NL80211_MCGRP_MLME, gfp);
19863 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
19865 static int nl80211_netlink_notify(struct notifier_block * nb,
19866 unsigned long state,
19869 struct netlink_notify *notify = _notify;
19870 struct cfg80211_registered_device *rdev;
19871 struct wireless_dev *wdev;
19872 struct cfg80211_beacon_registration *reg, *tmp;
19874 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
19875 return NOTIFY_DONE;
19879 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
19880 struct cfg80211_sched_scan_request *sched_scan_req;
19882 list_for_each_entry_rcu(sched_scan_req,
19883 &rdev->sched_scan_req_list,
19885 if (sched_scan_req->owner_nlportid == notify->portid) {
19886 sched_scan_req->nl_owner_dead = true;
19887 wiphy_work_queue(&rdev->wiphy,
19888 &rdev->sched_scan_stop_wk);
19892 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
19893 cfg80211_mlme_unregister_socket(wdev, notify->portid);
19895 if (wdev->owner_nlportid == notify->portid) {
19896 wdev->nl_owner_dead = true;
19897 schedule_work(&rdev->destroy_work);
19898 } else if (wdev->conn_owner_nlportid == notify->portid) {
19899 schedule_work(&wdev->disconnect_wk);
19902 cfg80211_release_pmsr(wdev, notify->portid);
19905 spin_lock_bh(&rdev->beacon_registrations_lock);
19906 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
19908 if (reg->nlportid == notify->portid) {
19909 list_del(®->list);
19914 spin_unlock_bh(&rdev->beacon_registrations_lock);
19920 * It is possible that the user space process that is controlling the
19921 * indoor setting disappeared, so notify the regulatory core.
19923 regulatory_netlink_notify(notify->portid);
19927 static struct notifier_block nl80211_netlink_notifier = {
19928 .notifier_call = nl80211_netlink_notify,
19931 void cfg80211_ft_event(struct net_device *netdev,
19932 struct cfg80211_ft_event_params *ft_event)
19934 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
19935 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
19936 struct sk_buff *msg;
19939 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
19941 if (!ft_event->target_ap)
19944 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len,
19949 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
19953 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19954 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19955 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
19958 if (ft_event->ies &&
19959 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
19961 if (ft_event->ric_ies &&
19962 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
19963 ft_event->ric_ies))
19966 genlmsg_end(msg, hdr);
19968 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19969 NL80211_MCGRP_MLME, GFP_KERNEL);
19974 EXPORT_SYMBOL(cfg80211_ft_event);
19976 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
19978 struct cfg80211_registered_device *rdev;
19979 struct sk_buff *msg;
19983 rdev = wiphy_to_rdev(wdev->wiphy);
19984 if (!rdev->crit_proto_nlportid)
19987 nlportid = rdev->crit_proto_nlportid;
19988 rdev->crit_proto_nlportid = 0;
19990 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
19994 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
19996 goto nla_put_failure;
19998 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19999 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
20001 goto nla_put_failure;
20003 genlmsg_end(msg, hdr);
20005 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
20011 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
20013 void nl80211_send_ap_stopped(struct wireless_dev *wdev, unsigned int link_id)
20015 struct wiphy *wiphy = wdev->wiphy;
20016 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
20017 struct sk_buff *msg;
20020 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
20024 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
20028 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20029 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
20030 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
20031 NL80211_ATTR_PAD) ||
20032 (wdev->valid_links &&
20033 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)))
20036 genlmsg_end(msg, hdr);
20038 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
20039 NL80211_MCGRP_MLME, GFP_KERNEL);
20045 int cfg80211_external_auth_request(struct net_device *dev,
20046 struct cfg80211_external_auth_params *params,
20049 struct wireless_dev *wdev = dev->ieee80211_ptr;
20050 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
20051 struct sk_buff *msg;
20054 if (!wdev->conn_owner_nlportid)
20057 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
20061 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH);
20063 goto nla_put_failure;
20065 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20066 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
20067 nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, params->key_mgmt_suite) ||
20068 nla_put_u32(msg, NL80211_ATTR_EXTERNAL_AUTH_ACTION,
20070 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) ||
20071 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len,
20072 params->ssid.ssid) ||
20073 (!is_zero_ether_addr(params->mld_addr) &&
20074 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN, params->mld_addr)))
20075 goto nla_put_failure;
20077 genlmsg_end(msg, hdr);
20078 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
20079 wdev->conn_owner_nlportid);
20086 EXPORT_SYMBOL(cfg80211_external_auth_request);
20088 void cfg80211_update_owe_info_event(struct net_device *netdev,
20089 struct cfg80211_update_owe_info *owe_info,
20092 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
20093 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
20094 struct sk_buff *msg;
20097 trace_cfg80211_update_owe_info_event(wiphy, netdev, owe_info);
20099 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
20103 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_UPDATE_OWE_INFO);
20105 goto nla_put_failure;
20107 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20108 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
20109 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, owe_info->peer))
20110 goto nla_put_failure;
20112 if (!owe_info->ie_len ||
20113 nla_put(msg, NL80211_ATTR_IE, owe_info->ie_len, owe_info->ie))
20114 goto nla_put_failure;
20116 if (owe_info->assoc_link_id != -1) {
20117 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID,
20118 owe_info->assoc_link_id))
20119 goto nla_put_failure;
20121 if (!is_zero_ether_addr(owe_info->peer_mld_addr) &&
20122 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN,
20123 owe_info->peer_mld_addr))
20124 goto nla_put_failure;
20127 genlmsg_end(msg, hdr);
20129 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20130 NL80211_MCGRP_MLME, gfp);
20134 genlmsg_cancel(msg, hdr);
20137 EXPORT_SYMBOL(cfg80211_update_owe_info_event);
20139 /* initialisation/exit functions */
20141 int __init nl80211_init(void)
20145 err = genl_register_family(&nl80211_fam);
20149 err = netlink_register_notifier(&nl80211_netlink_notifier);
20155 genl_unregister_family(&nl80211_fam);
20159 void nl80211_exit(void)
20161 netlink_unregister_notifier(&nl80211_netlink_notifier);
20162 genl_unregister_family(&nl80211_fam);