Lines Matching +full:mcast +full:- +full:groups
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-2025 Intel Corporation
32 #include "rdev-ops.h"
42 /* multicast groups */
50 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
74 int wiphy_idx = -1;
75 int ifidx = -1;
78 return ERR_PTR(-EINVAL);
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);
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);
150 return ERR_PTR(-EINVAL);
164 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
165 if (wdev->identifier != (u32)wdev_id)
175 return ERR_PTR(-EINVAL);
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 */
197 return ERR_PTR(-EINVAL);
204 return ERR_PTR(-ENODEV);
206 if (netns != wiphy_net(&rdev->wiphy))
207 return ERR_PTR(-ENODEV);
222 return __cfg80211_rdev_from_attrs(netns, info->attrs);
239 s1g_bcn = ieee80211_is_s1g_beacon(mgmt->frame_control);
244 ieee80211_s1g_optional_len(ext->frame_control);
255 if (ieee80211_hdrlen(mgmt->frame_control) != hdrlen)
259 len -= fixedlen;
270 return -EINVAL;
288 return -EINVAL;
295 return -EINVAL;
309 return -EINVAL;
324 return -EINVAL;
329 return -EINVAL;
526 NUM_NL80211_BANDS - 1),
528 [NL80211_NAN_BAND_CONF_RSSI_CLOSE] = NLA_POLICY_MIN(NLA_S8, -59),
529 [NL80211_NAN_BAND_CONF_RSSI_MIDDLE] = NLA_POLICY_MIN(NLA_S8, -74),
566 .len = 20-1 },
592 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
622 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1),
634 /* allow 3 for NUL-termination, we used to declare this NLA_STRING */
705 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
801 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1),
803 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
815 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1),
863 [NL80211_ATTR_VLAN_ID] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
906 NLA_POLICY_RANGE(NLA_U8, 0, IEEE80211_MLD_MAX_NUM_LINKS - 1),
945 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1),
1091 if (!cb->args[0]) {
1098 return -ENOMEM;
1102 err = nlmsg_parse_deprecated(cb->nlh,
1112 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(cb->skb->sk),
1119 *rdev = wiphy_to_rdev((*wdev)->wiphy);
1120 mutex_lock(&(*rdev)->wiphy.mtx);
1122 /* 0 is the first index - add 1 to parse only once */
1123 cb->args[0] = (*rdev)->wiphy_idx + 1;
1124 cb->args[1] = (*wdev)->identifier;
1131 wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
1134 return -ENODEV;
1139 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
1140 if (tmp->identifier == cb->args[1]) {
1148 return -ENODEV;
1150 mutex_lock(&(*rdev)->wiphy.mtx);
1182 rule->wmm_rule.client[j].cw_min) ||
1184 rule->wmm_rule.client[j].cw_max) ||
1186 rule->wmm_rule.client[j].aifsn) ||
1188 rule->wmm_rule.client[j].cot))
1198 return -ENOBUFS;
1206 * list to protect old user-space tools from breaking
1208 if (!large && chan->flags &
1211 if (!large && chan->freq_offset)
1215 chan->center_freq))
1218 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_OFFSET, chan->freq_offset))
1221 if ((chan->flags & IEEE80211_CHAN_PSD) &&
1222 nla_put_s8(msg, NL80211_FREQUENCY_ATTR_PSD, chan->psd))
1225 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
1228 if (chan->flags & IEEE80211_CHAN_NO_IR) {
1234 if (chan->flags & IEEE80211_CHAN_RADAR) {
1240 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
1243 chan->dfs_state))
1250 chan->dfs_cac_ms))
1256 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
1259 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
1262 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
1265 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
1268 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
1271 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
1274 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
1277 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
1280 if ((chan->flags & IEEE80211_CHAN_NO_HE) &&
1283 if ((chan->flags & IEEE80211_CHAN_NO_320MHZ) &&
1286 if ((chan->flags & IEEE80211_CHAN_NO_EHT) &&
1289 if ((chan->flags & IEEE80211_CHAN_DFS_CONCURRENT) &&
1292 if ((chan->flags & IEEE80211_CHAN_NO_6GHZ_VLP_CLIENT) &&
1295 if ((chan->flags & IEEE80211_CHAN_NO_6GHZ_AFC_CLIENT) &&
1298 if ((chan->flags & IEEE80211_CHAN_CAN_MONITOR) &&
1301 if ((chan->flags & IEEE80211_CHAN_ALLOW_6GHZ_VLP_AP) &&
1304 if ((chan->flags & IEEE80211_CHAN_ALLOW_20MHZ_ACTIVITY) &&
1308 if ((chan->flags & IEEE80211_CHAN_NO_4MHZ) &&
1311 if ((chan->flags & IEEE80211_CHAN_NO_8MHZ) &&
1314 if ((chan->flags & IEEE80211_CHAN_NO_16MHZ) &&
1320 DBM_TO_MBM(chan->max_power)))
1325 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1327 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) {
1336 return -ENOBUFS;
1346 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
1347 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
1375 * nl80211_link_id - return link ID
1397 return -1;
1416 info->extack);
1420 k->def = !!tb[NL80211_KEY_DEFAULT];
1421 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
1422 k->defbeacon = !!tb[NL80211_KEY_DEFAULT_BEACON];
1424 if (k->def) {
1425 k->def_uni = true;
1426 k->def_multi = true;
1428 if (k->defmgmt || k->defbeacon)
1429 k->def_multi = true;
1432 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
1435 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
1436 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
1440 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
1441 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
1445 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
1448 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
1454 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1457 info->extack);
1461 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1462 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1466 k->p.mode = nla_get_u8(tb[NL80211_KEY_MODE]);
1473 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
1474 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
1475 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
1478 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
1479 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
1480 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
1483 if (info->attrs[NL80211_ATTR_KEY_IDX])
1484 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1486 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
1487 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
1489 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
1490 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
1492 if (k->def) {
1493 k->def_uni = true;
1494 k->def_multi = true;
1496 if (k->defmgmt)
1497 k->def_multi = true;
1499 if (info->attrs[NL80211_ATTR_KEY_TYPE])
1500 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1502 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
1505 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1506 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
1508 info->extack);
1512 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1513 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1524 k->idx = -1;
1525 k->type = -1;
1527 if (info->attrs[NL80211_ATTR_KEY])
1528 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k);
1535 if ((k->def ? 1 : 0) + (k->defmgmt ? 1 : 0) +
1536 (k->defbeacon ? 1 : 0) > 1) {
1539 return -EINVAL;
1542 if (k->defmgmt || k->defbeacon) {
1543 if (k->def_uni || !k->def_multi) {
1545 "defmgmt/defbeacon key must be mcast");
1546 return -EINVAL;
1550 if (k->idx != -1) {
1551 if (k->defmgmt) {
1552 if (k->idx < 4 || k->idx > 5) {
1555 return -EINVAL;
1557 } else if (k->defbeacon) {
1558 if (k->idx < 6 || k->idx > 7) {
1561 return -EINVAL;
1563 } else if (k->def) {
1564 if (k->idx < 0 || k->idx > 3) {
1565 GENL_SET_ERR_MSG(info, "def key idx not 0-3");
1566 return -EINVAL;
1569 if (k->idx < 0 || k->idx > 7) {
1570 GENL_SET_ERR_MSG(info, "key idx not 0-7");
1571 return -EINVAL;
1583 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS];
1600 return ERR_PTR(-ENOMEM);
1602 result->def = -1;
1606 parse.idx = -1;
1611 err = -EINVAL;
1615 GENL_SET_ERR_MSG(info, "key index out of range [0-3]");
1625 result->def = parse.idx;
1637 err = -EINVAL;
1640 result->params[parse.idx].cipher = parse.p.cipher;
1641 result->params[parse.idx].key_len = parse.p.key_len;
1642 result->params[parse.idx].key = result->data[parse.idx];
1643 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
1650 if (result->def < 0) {
1651 err = -EINVAL;
1664 lockdep_assert_wiphy(wdev->wiphy);
1666 switch (wdev->iftype) {
1673 if (wdev->u.ibss.current_bss)
1675 return -ENOLINK;
1678 if (wdev->connected)
1680 return -ENOLINK;
1682 if (wiphy_ext_feature_isset(wdev->wiphy,
1685 return -EINVAL;
1692 return -EINVAL;
1704 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1729 return -ENOBUFS;
1748 for (i = 0; i < c->n_limits; i++) {
1754 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX, c->limits[i].max))
1757 c->limits[i].types))
1764 if (c->beacon_int_infra_match &&
1768 c->num_different_channels) ||
1770 c->max_interfaces))
1774 c->radar_detect_widths) ||
1776 c->radar_detect_regions)))
1778 if (c->beacon_int_min_gcd &&
1780 c->beacon_int_min_gcd))
1787 return -ENOBUFS;
1804 c = wiphy->radio[0].iface_combinations;
1805 n = wiphy->radio[0].n_iface_combinations;
1807 c = wiphy->iface_combinations;
1808 n = wiphy->n_iface_combinations;
1818 return -ENOBUFS;
1825 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1834 return -ENOBUFS;
1837 tcp->data_payload_max))
1838 return -ENOBUFS;
1841 tcp->data_payload_max))
1842 return -ENOBUFS;
1844 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1845 return -ENOBUFS;
1847 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1848 sizeof(*tcp->tok), tcp->tok))
1849 return -ENOBUFS;
1852 tcp->data_interval_max))
1853 return -ENOBUFS;
1856 tcp->wake_payload_max))
1857 return -ENOBUFS;
1869 if (!rdev->wiphy.wowlan)
1875 return -ENOBUFS;
1877 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1879 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1881 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1883 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1885 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1887 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1889 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1891 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1893 return -ENOBUFS;
1895 if (rdev->wiphy.wowlan->n_patterns) {
1897 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1898 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1899 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1900 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1905 return -ENOBUFS;
1908 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1910 rdev->wiphy.wowlan->max_nd_match_sets))
1911 return -ENOBUFS;
1914 return -ENOBUFS;
1927 if (!rdev->wiphy.coalesce)
1930 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1931 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1932 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1933 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1934 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1935 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1938 return -ENOBUFS;
1948 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap;
1949 const struct ieee80211_sta_eht_cap *eht_cap = &iftdata->eht_cap;
1952 iftdata->types_mask))
1953 return -ENOBUFS;
1955 if (he_cap->has_he) {
1957 sizeof(he_cap->he_cap_elem.mac_cap_info),
1958 he_cap->he_cap_elem.mac_cap_info) ||
1960 sizeof(he_cap->he_cap_elem.phy_cap_info),
1961 he_cap->he_cap_elem.phy_cap_info) ||
1963 sizeof(he_cap->he_mcs_nss_supp),
1964 &he_cap->he_mcs_nss_supp) ||
1966 sizeof(he_cap->ppe_thres), he_cap->ppe_thres))
1967 return -ENOBUFS;
1970 if (eht_cap->has_eht && he_cap->has_he) {
1975 is_ap = iftdata->types_mask & BIT(NL80211_IFTYPE_AP) ||
1976 iftdata->types_mask & BIT(NL80211_IFTYPE_P2P_GO);
1979 ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
1980 &eht_cap->eht_cap_elem,
1983 ppe_thres_hdr = get_unaligned_le16(&eht_cap->eht_ppe_thres[0]);
1986 eht_cap->eht_cap_elem.phy_cap_info);
1989 sizeof(eht_cap->eht_cap_elem.mac_cap_info),
1990 eht_cap->eht_cap_elem.mac_cap_info) ||
1992 sizeof(eht_cap->eht_cap_elem.phy_cap_info),
1993 eht_cap->eht_cap_elem.phy_cap_info) ||
1995 mcs_nss_size, &eht_cap->eht_mcs_nss_supp) ||
1997 ppe_thresh_size, eht_cap->eht_ppe_thres))
1998 return -ENOBUFS;
2001 if (sband->band == NL80211_BAND_6GHZ &&
2003 sizeof(iftdata->he_6ghz_capa),
2004 &iftdata->he_6ghz_capa))
2005 return -ENOBUFS;
2007 if (iftdata->vendor_elems.data && iftdata->vendor_elems.len &&
2009 iftdata->vendor_elems.len, iftdata->vendor_elems.data))
2010 return -ENOBUFS;
2024 if (sband->ht_cap.ht_supported &&
2026 sizeof(sband->ht_cap.mcs),
2027 &sband->ht_cap.mcs) ||
2029 sband->ht_cap.cap) ||
2031 sband->ht_cap.ampdu_factor) ||
2033 sband->ht_cap.ampdu_density)))
2034 return -ENOBUFS;
2037 if (sband->vht_cap.vht_supported &&
2039 sizeof(sband->vht_cap.vht_mcs),
2040 &sband->vht_cap.vht_mcs) ||
2042 sband->vht_cap.cap)))
2043 return -ENOBUFS;
2045 if (large && sband->n_iftype_data) {
2053 return -ENOBUFS;
2060 return -ENOBUFS;
2073 if (large && sband->edmg_cap.channels &&
2075 sband->edmg_cap.channels) ||
2077 sband->edmg_cap.bw_config)))
2079 return -ENOBUFS;
2084 return -ENOBUFS;
2086 for (i = 0; i < sband->n_bitrates; i++) {
2089 return -ENOBUFS;
2091 rate = &sband->bitrates[i];
2093 rate->bitrate))
2094 return -ENOBUFS;
2095 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
2098 return -ENOBUFS;
2106 if (sband->band == NL80211_BAND_S1GHZ && sband->s1g_cap.s1g &&
2108 sizeof(sband->s1g_cap.cap),
2109 sband->s1g_cap.cap) ||
2111 sizeof(sband->s1g_cap.nss_mcs),
2112 sband->s1g_cap.nss_mcs)))
2113 return -ENOBUFS;
2132 return -ENOBUFS;
2137 return -ENOBUFS;
2144 return -ENOBUFS;
2155 return -ENOBUFS;
2160 return -ENOBUFS;
2167 return -ENOBUFS;
2180 if (rdev->ops->op) { \
2214 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
2219 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
2224 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
2225 rdev->ops->join_mesh) {
2230 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
2234 if (rdev->wiphy.max_sched_scan_reqs)
2238 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
2249 if (rdev->ops->connect || rdev->ops->auth) {
2255 if (rdev->ops->disconnect || rdev->ops->deauth) {
2263 return -ENOBUFS;
2272 if (!cap->ftm.supported)
2277 return -ENOBUFS;
2279 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP))
2280 return -ENOBUFS;
2281 if (cap->ftm.non_asap &&
2283 return -ENOBUFS;
2284 if (cap->ftm.request_lci &&
2286 return -ENOBUFS;
2287 if (cap->ftm.request_civicloc &&
2289 return -ENOBUFS;
2291 cap->ftm.preambles))
2292 return -ENOBUFS;
2294 cap->ftm.bandwidths))
2295 return -ENOBUFS;
2296 if (cap->ftm.max_bursts_exponent >= 0 &&
2298 cap->ftm.max_bursts_exponent))
2299 return -ENOBUFS;
2300 if (cap->ftm.max_ftms_per_burst &&
2302 cap->ftm.max_ftms_per_burst))
2303 return -ENOBUFS;
2304 if (cap->ftm.trigger_based &&
2306 return -ENOBUFS;
2307 if (cap->ftm.non_trigger_based &&
2309 return -ENOBUFS;
2318 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa;
2331 return -ENOBUFS;
2333 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers))
2334 return -ENOBUFS;
2336 if (cap->report_ap_tsf &&
2338 return -ENOBUFS;
2340 if (cap->randomize_mac_addr &&
2342 return -ENOBUFS;
2346 return -ENOBUFS;
2349 return -ENOBUFS;
2365 if (!rdev->wiphy.num_iftype_akm_suites ||
2366 !rdev->wiphy.iftype_akm_suites)
2371 return -ENOBUFS;
2373 for (i = 0; i < rdev->wiphy.num_iftype_akm_suites; i++) {
2376 return -ENOBUFS;
2378 iftype_akms = &rdev->wiphy.iftype_akm_suites[i];
2381 iftype_akms->iftypes_mask))
2382 return -ENOBUFS;
2385 sizeof(u32) * iftype_akms->n_akm_suites,
2386 iftype_akms->akm_suites)) {
2387 return -ENOBUFS;
2403 if (!rdev->wiphy.tid_config_support.vif &&
2404 !rdev->wiphy.tid_config_support.peer)
2409 return -ENOSPC;
2411 if (rdev->wiphy.tid_config_support.vif &&
2413 rdev->wiphy.tid_config_support.vif,
2417 if (rdev->wiphy.tid_config_support.peer &&
2419 rdev->wiphy.tid_config_support.peer,
2425 rdev->wiphy.tid_config_support.max_retry))
2428 rdev->wiphy.tid_config_support.max_retry))
2436 return -ENOBUFS;
2447 if (!rdev->wiphy.sar_capa)
2450 num_freq_ranges = rdev->wiphy.sar_capa->num_freq_ranges;
2454 return -ENOSPC;
2456 if (nla_put_u32(msg, NL80211_SAR_ATTR_TYPE, rdev->wiphy.sar_capa->type))
2470 rdev->wiphy.sar_capa->freq_ranges[i].start_freq))
2474 rdev->wiphy.sar_capa->freq_ranges[i].end_freq))
2486 return -ENOBUFS;
2493 if (!wiphy->mbssid_max_interfaces)
2498 return -ENOBUFS;
2501 wiphy->mbssid_max_interfaces))
2504 if (wiphy->ema_max_profile_periodicity &&
2507 wiphy->ema_max_profile_periodicity))
2515 return -ENOBUFS;
2520 const struct wiphy_radio *r = &wiphy->radio[idx];
2521 const struct wiphy_radio_cfg *rcfg = &wiphy->radio_cfg[idx];
2527 return -ENOBUFS;
2532 if (rcfg->rts_threshold &&
2534 rcfg->rts_threshold))
2537 if (r->antenna_mask &&
2539 r->antenna_mask))
2542 for (i = 0; i < r->n_freq_range; i++) {
2543 const struct wiphy_radio_freq_range *range = &r->freq_range[i];
2550 range->start_freq) ||
2552 range->end_freq))
2558 for (i = 0; i < r->n_iface_combinations; i++)
2561 &r->iface_combinations[i],
2570 return -ENOBUFS;
2578 if (!wiphy->n_radio)
2583 return -ENOBUFS;
2585 for (i = 0; i < wiphy->n_radio; i++)
2593 -1, true, NLA_F_NESTED))
2594 return -ENOBUFS;
2600 return -ENOBUFS;
2609 return -ENOBUFS;
2611 if (wiphy->nan_capa.flags & WIPHY_NAN_FLAGS_CONFIGURABLE_SYNC &&
2615 if ((wiphy->nan_capa.flags & WIPHY_NAN_FLAGS_USERSPACE_DE) &&
2620 wiphy->nan_capa.op_mode) ||
2622 wiphy->nan_capa.n_antennas) ||
2624 wiphy->nan_capa.max_channel_switch_time) ||
2626 wiphy->nan_capa.dev_capabilities))
2635 return -ENOBUFS;
2658 rdev->wiphy.mgmt_stypes;
2663 return -ENOBUFS;
2666 return -EINVAL;
2668 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2670 wiphy_name(&rdev->wiphy)) ||
2678 switch (state->split_start) {
2681 rdev->wiphy.retry_short) ||
2683 rdev->wiphy.retry_long) ||
2685 rdev->wiphy.frag_threshold) ||
2687 rdev->wiphy.rts_threshold) ||
2689 rdev->wiphy.coverage_class) ||
2691 rdev->wiphy.max_scan_ssids) ||
2693 rdev->wiphy.max_sched_scan_ssids) ||
2695 rdev->wiphy.max_scan_ie_len) ||
2697 rdev->wiphy.max_sched_scan_ie_len) ||
2699 rdev->wiphy.max_match_sets))
2702 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
2705 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
2708 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
2711 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
2714 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
2717 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
2720 state->split_start++;
2721 if (state->split)
2726 sizeof(u32) * rdev->wiphy.n_cipher_suites,
2727 rdev->wiphy.cipher_suites))
2731 rdev->wiphy.max_num_pmkids))
2734 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
2739 rdev->wiphy.available_antennas_tx) ||
2741 rdev->wiphy.available_antennas_rx))
2744 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
2746 rdev->wiphy.probe_resp_offload))
2749 if ((rdev->wiphy.available_antennas_tx ||
2750 rdev->wiphy.available_antennas_rx) &&
2751 rdev->ops->get_antenna) {
2755 res = rdev_get_antenna(rdev, -1, &tx_ant, &rx_ant);
2767 state->split_start++;
2768 if (state->split)
2773 rdev->wiphy.interface_modes))
2775 state->split_start++;
2776 if (state->split)
2785 for (band = state->band_start;
2786 band < (state->split ?
2793 if (band > NL80211_BAND_5GHZ && !state->split)
2796 sband = rdev->wiphy.bands[band];
2805 switch (state->chan_start) {
2808 state->split))
2810 state->chan_start++;
2811 if (state->split)
2821 for (i = state->chan_start - 1;
2822 i < sband->n_channels;
2829 chan = &sband->channels[i];
2832 msg, &rdev->wiphy, chan,
2833 state->split))
2837 if (state->split)
2840 if (i < sband->n_channels)
2841 state->chan_start = i + 2;
2843 state->chan_start = 0;
2849 if (state->split) {
2851 if (state->chan_start)
2852 band--;
2859 state->band_start = band + 1;
2861 state->band_start = 0;
2864 if (state->band_start == 0 && state->chan_start == 0)
2865 state->split_start++;
2866 if (state->split)
2878 if (state->split) {
2881 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
2884 if (rdev->wiphy.features &
2890 if (rdev->wiphy.sar_capa)
2897 state->split_start++;
2898 if (state->split)
2902 if (rdev->ops->remain_on_channel &&
2903 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
2906 rdev->wiphy.max_remain_on_channel_duration))
2909 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
2913 state->split_start++;
2914 if (state->split)
2919 if (nl80211_send_wowlan(msg, rdev, state->split))
2921 state->split_start++;
2922 if (state->split)
2925 state->split_start++;
2930 rdev->wiphy.software_iftypes))
2933 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
2935 rdev->wiphy.n_radio ? 0 : -1,
2936 state->split, 0))
2939 state->split_start++;
2940 if (state->split)
2944 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
2946 rdev->wiphy.ap_sme_capa))
2949 features = rdev->wiphy.features;
2951 * We can only add the per-channel limit information if the
2955 if (state->split)
2960 if (rdev->wiphy.ht_capa_mod_mask &&
2962 sizeof(*rdev->wiphy.ht_capa_mod_mask),
2963 rdev->wiphy.ht_capa_mod_mask))
2966 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
2967 rdev->wiphy.max_acl_mac_addrs &&
2969 rdev->wiphy.max_acl_mac_addrs))
2982 if (state->split)
2983 state->split_start++;
2985 state->split_start = 0;
2992 rdev->wiphy.max_sched_scan_plans) ||
2994 rdev->wiphy.max_sched_scan_plan_interval) ||
2996 rdev->wiphy.max_sched_scan_plan_iterations))
2999 if (rdev->wiphy.extended_capabilities &&
3001 rdev->wiphy.extended_capabilities_len,
3002 rdev->wiphy.extended_capabilities) ||
3004 rdev->wiphy.extended_capabilities_len,
3005 rdev->wiphy.extended_capabilities_mask)))
3008 if (rdev->wiphy.vht_capa_mod_mask &&
3010 sizeof(*rdev->wiphy.vht_capa_mod_mask),
3011 rdev->wiphy.vht_capa_mod_mask))
3015 rdev->wiphy.perm_addr))
3018 if (!is_zero_ether_addr(rdev->wiphy.addr_mask) &&
3020 rdev->wiphy.addr_mask))
3023 if (rdev->wiphy.n_addresses > 1) {
3030 for (i = 0; i < rdev->wiphy.n_addresses; i++)
3032 rdev->wiphy.addresses[i].addr))
3038 state->split_start++;
3044 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
3049 if (rdev->wiphy.max_ap_assoc_sta &&
3051 rdev->wiphy.max_ap_assoc_sta))
3054 state->split_start++;
3057 if (rdev->wiphy.n_vendor_commands) {
3066 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
3067 info = &rdev->wiphy.vendor_commands[i].info;
3074 if (rdev->wiphy.n_vendor_events) {
3083 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
3084 info = &rdev->wiphy.vendor_events[i];
3090 state->split_start++;
3093 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
3095 rdev->wiphy.max_num_csa_counters))
3098 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
3102 if (rdev->wiphy.max_sched_scan_reqs &&
3104 rdev->wiphy.max_sched_scan_reqs))
3108 sizeof(rdev->wiphy.ext_features),
3109 rdev->wiphy.ext_features))
3112 if (rdev->wiphy.bss_param_support) {
3114 u32 parsup = rdev->wiphy.bss_param_support;
3146 if (rdev->wiphy.bss_select_support) {
3148 u32 bss_select_support = rdev->wiphy.bss_select_support;
3166 state->split_start++;
3169 if (rdev->wiphy.num_iftype_ext_capab &&
3170 rdev->wiphy.iftype_ext_capab) {
3178 for (i = state->capa_start;
3179 i < rdev->wiphy.num_iftype_ext_capab; i++) {
3182 capab = &rdev->wiphy.iftype_ext_capab[i];
3188 capab->iftype) ||
3190 capab->extended_capabilities_len,
3191 capab->extended_capabilities) ||
3193 capab->extended_capabilities_len,
3194 capab->extended_capabilities_mask))
3197 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO &&
3200 capab->eml_capabilities) ||
3203 capab->mld_capa_and_ops)))
3207 if (state->split)
3211 if (i < rdev->wiphy.num_iftype_ext_capab) {
3212 state->capa_start = i + 1;
3218 rdev->wiphy.nan_supported_bands))
3221 if (wiphy_ext_feature_isset(&rdev->wiphy,
3233 rdev->wiphy.txq_limit))
3236 rdev->wiphy.txq_memory_limit))
3239 rdev->wiphy.txq_quantum))
3243 state->split_start++;
3249 state->split_start++;
3252 if (rdev->wiphy.akm_suites &&
3254 sizeof(u32) * rdev->wiphy.n_akm_suites,
3255 rdev->wiphy.akm_suites))
3263 state->split_start++;
3269 if (nl80211_put_mbssid_support(&rdev->wiphy, msg))
3273 rdev->wiphy.max_num_akm_suites))
3276 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO)
3279 if (rdev->wiphy.hw_timestamp_max_peers &&
3281 rdev->wiphy.hw_timestamp_max_peers))
3284 state->split_start++;
3287 if (nl80211_put_radios(&rdev->wiphy, msg))
3290 state->split_start++;
3293 if (nl80211_put_nan_capa(&rdev->wiphy, msg))
3297 state->split_start = 0;
3306 return -EMSGSIZE;
3317 return -ENOMEM;
3319 ret = nlmsg_parse_deprecated(cb->nlh,
3329 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
3331 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
3333 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
3339 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
3341 ret = -ENODEV;
3344 if (netdev->ieee80211_ptr) {
3346 netdev->ieee80211_ptr->wiphy);
3347 state->filter_wiphy = rdev->wiphy_idx;
3360 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
3368 return -ENOMEM;
3370 state->filter_wiphy = -1;
3377 cb->args[0] = (long)state;
3381 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3383 if (++idx <= state->start)
3385 if (state->filter_wiphy != -1 &&
3386 state->filter_wiphy != rdev->wiphy_idx)
3388 wiphy_lock(&rdev->wiphy);
3393 NETLINK_CB(cb->skb).portid,
3394 cb->nlh->nlmsg_seq,
3410 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
3411 !skb->len && !state->split &&
3412 cb->min_dump_alloc < 4096) {
3413 cb->min_dump_alloc = 4096;
3414 state->split_start = 0;
3415 wiphy_unlock(&rdev->wiphy);
3419 idx--;
3422 } while (state->split_start > 0);
3423 wiphy_unlock(&rdev->wiphy);
3428 state->start = idx;
3430 return skb->len;
3435 kfree((void *)cb->args[0]);
3442 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3447 return -ENOMEM;
3450 info->snd_portid, info->snd_seq, 0,
3453 return -ENOBUFS;
3475 return -EINVAL;
3478 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
3479 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
3480 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
3481 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
3484 return -EINVAL;
3485 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
3498 * low-level driver when the AP starts or the mesh is joined.
3500 * the channel in the start-ap or join-mesh commands instead.
3507 wdev->iftype == NL80211_IFTYPE_AP ||
3508 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
3509 wdev->iftype == NL80211_IFTYPE_MONITOR ||
3510 wdev->iftype == NL80211_IFTYPE_P2P_GO;
3517 struct netlink_ext_ack *extack = info->extack;
3518 struct nlattr **attrs = info->attrs;
3524 return -EINVAL;
3528 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3529 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
3531 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
3534 chandef->chan = ieee80211_get_channel_khz(&rdev->wiphy, control_freq);
3535 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
3536 chandef->center_freq1 = KHZ_TO_MHZ(control_freq);
3537 chandef->freq1_offset = control_freq % 1000;
3538 chandef->center_freq2 = 0;
3539 chandef->s1g_primary_2mhz = false;
3541 if (!chandef->chan) {
3544 return -EINVAL;
3557 cfg80211_chandef_create(chandef, chandef->chan,
3561 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) {
3565 return -EINVAL;
3573 return -EINVAL;
3580 return -EINVAL;
3583 chandef->width = nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]);
3585 chandef->center_freq1 =
3587 chandef->freq1_offset = nla_get_u32_default(
3592 chandef->center_freq2 =
3595 chandef->s1g_primary_2mhz = nla_get_flag(
3599 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
3600 chandef->edmg.channels =
3601 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
3603 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
3604 chandef->edmg.bw_config =
3605 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
3607 chandef->edmg.bw_config = 0;
3608 chandef->edmg.channels = 0;
3611 if (info->attrs[NL80211_ATTR_PUNCT_BITMAP]) {
3612 chandef->punctured =
3613 nla_get_u32(info->attrs[NL80211_ATTR_PUNCT_BITMAP]);
3615 if (chandef->punctured &&
3616 !wiphy_ext_feature_isset(&rdev->wiphy,
3620 return -EINVAL;
3626 return -EINVAL;
3629 if (!_cfg80211_chandef_usable(&rdev->wiphy, chandef,
3633 return -EINVAL;
3636 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
3637 chandef->width == NL80211_CHAN_WIDTH_10) &&
3638 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) {
3640 return -EINVAL;
3665 wdev = dev->ieee80211_ptr;
3667 return -EOPNOTSUPP;
3669 iftype = wdev->iftype;
3672 if (wdev && wdev->valid_links)
3673 return -EINVAL;
3686 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
3688 return -EINVAL;
3689 if (wdev->links[link_id].ap.beacon_interval) {
3692 if (!dev || !rdev->ops->set_ap_chanwidth ||
3693 !(rdev->wiphy.features &
3695 return -EBUSY;
3698 cur_chan = wdev->links[link_id].ap.chandef.chan;
3700 return -EBUSY;
3703 switch (wdev->links[link_id].ap.chandef.width) {
3713 return -EINVAL;
3726 return -EINVAL;
3733 wdev->links[link_id].ap.chandef = chandef;
3735 wdev->u.ap.preset_chandef = chandef;
3746 return -EINVAL;
3751 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3752 int link_id = nl80211_link_id_or_invalid(info->attrs);
3753 struct net_device *netdev = info->user_ptr[1];
3765 if (!rdev->ops->set_wiphy_params)
3766 return -EOPNOTSUPP;
3768 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
3770 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
3774 old_rts = rdev->wiphy.radio_cfg[radio_idx].rts_threshold;
3776 rdev->wiphy.radio_cfg[radio_idx].rts_threshold = rts_threshold;
3780 rdev->wiphy.radio_cfg[radio_idx].rts_threshold = old_rts;
3797 int radio_idx = -1;
3803 * done for backward compatibility -- previously
3810 if (info->attrs[NL80211_ATTR_IFINDEX]) {
3811 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
3814 if (netdev && netdev->ieee80211_ptr)
3815 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
3822 info->attrs);
3831 wdev = netdev->ieee80211_ptr;
3833 guard(wiphy)(&rdev->wiphy);
3840 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
3842 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
3848 if (info->attrs[NL80211_ATTR_WIPHY_RADIO_INDEX]) {
3849 /* Radio idx is not expected for non-multi radio wiphy */
3850 if (rdev->wiphy.n_radio <= 0)
3851 return -EINVAL;
3854 info->attrs[NL80211_ATTR_WIPHY_RADIO_INDEX]);
3855 if (radio_idx >= rdev->wiphy.n_radio)
3856 return -EINVAL;
3861 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
3865 if (!rdev->ops->set_txq_params)
3866 return -EOPNOTSUPP;
3869 return -EINVAL;
3871 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3872 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3873 return -EINVAL;
3876 return -ENETDOWN;
3879 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
3885 info->extack);
3894 nl80211_link_id_or_invalid(info->attrs);
3897 !(netdev->ieee80211_ptr->valid_links &
3899 result = -ENOLINK;
3901 !netdev->ieee80211_ptr->valid_links)
3902 result = -EINVAL;
3911 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3912 int link_id = nl80211_link_id_or_invalid(info->attrs);
3927 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
3932 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
3935 if (!rdev->ops->set_tx_power)
3936 return -EOPNOTSUPP;
3939 type = nla_get_u32(info->attrs[idx]);
3941 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
3943 return -EINVAL;
3947 mbm = nla_get_u32(info->attrs[idx]);
3956 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
3957 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
3960 if ((!rdev->wiphy.available_antennas_tx &&
3961 !rdev->wiphy.available_antennas_rx) ||
3962 !rdev->ops->set_antenna)
3963 return -EOPNOTSUPP;
3965 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
3966 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
3970 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
3971 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
3972 return -EINVAL;
3974 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
3975 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
3984 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
3986 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
3991 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
3993 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
3998 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
4000 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
4002 return -EINVAL;
4004 if (frag_threshold != (u32) -1) {
4016 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
4018 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
4022 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
4023 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
4024 return -EINVAL;
4027 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
4031 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
4032 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
4033 return -EOPNOTSUPP;
4038 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) {
4039 if (!wiphy_ext_feature_isset(&rdev->wiphy,
4041 return -EOPNOTSUPP;
4044 info->attrs[NL80211_ATTR_TXQ_LIMIT]);
4048 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) {
4049 if (!wiphy_ext_feature_isset(&rdev->wiphy,
4051 return -EOPNOTSUPP;
4054 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]);
4058 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) {
4059 if (!wiphy_ext_feature_isset(&rdev->wiphy,
4061 return -EOPNOTSUPP;
4064 info->attrs[NL80211_ATTR_TXQ_QUANTUM]);
4075 if (!rdev->ops->set_wiphy_params)
4076 return -EOPNOTSUPP;
4078 if (rdev->wiphy.n_radio) {
4079 old_radio_rts_threshold = kcalloc(rdev->wiphy.n_radio,
4083 return -ENOMEM;
4086 old_retry_short = rdev->wiphy.retry_short;
4087 old_retry_long = rdev->wiphy.retry_long;
4088 old_frag_threshold = rdev->wiphy.frag_threshold;
4089 old_rts_threshold = rdev->wiphy.rts_threshold;
4091 for (i = 0 ; i < rdev->wiphy.n_radio; i++)
4093 rdev->wiphy.radio_cfg[i].rts_threshold;
4095 old_coverage_class = rdev->wiphy.coverage_class;
4096 old_txq_limit = rdev->wiphy.txq_limit;
4097 old_txq_memory_limit = rdev->wiphy.txq_memory_limit;
4098 old_txq_quantum = rdev->wiphy.txq_quantum;
4101 rdev->wiphy.retry_short = retry_short;
4103 rdev->wiphy.retry_long = retry_long;
4105 rdev->wiphy.frag_threshold = frag_threshold;
4108 rdev->wiphy.rts_threshold = rts_threshold;
4109 for (i = 0 ; i < rdev->wiphy.n_radio; i++)
4110 rdev->wiphy.radio_cfg[i].rts_threshold =
4111 rdev->wiphy.rts_threshold;
4114 rdev->wiphy.coverage_class = coverage_class;
4116 rdev->wiphy.txq_limit = txq_limit;
4118 rdev->wiphy.txq_memory_limit = txq_memory_limit;
4120 rdev->wiphy.txq_quantum = txq_quantum;
4124 rdev->wiphy.retry_short = old_retry_short;
4125 rdev->wiphy.retry_long = old_retry_long;
4126 rdev->wiphy.frag_threshold = old_frag_threshold;
4127 rdev->wiphy.rts_threshold = old_rts_threshold;
4129 for (i = 0 ; i < rdev->wiphy.n_radio; i++)
4130 rdev->wiphy.radio_cfg[i].rts_threshold =
4133 rdev->wiphy.coverage_class = old_coverage_class;
4134 rdev->wiphy.txq_limit = old_txq_limit;
4135 rdev->wiphy.txq_memory_limit = old_txq_memory_limit;
4136 rdev->wiphy.txq_quantum = old_txq_quantum;
4150 return -EINVAL;
4153 chandef->chan->center_freq))
4154 return -ENOBUFS;
4156 chandef->chan->freq_offset))
4157 return -ENOBUFS;
4158 switch (chandef->width) {
4164 return -ENOBUFS;
4169 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
4170 return -ENOBUFS;
4171 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
4172 return -ENOBUFS;
4173 if (chandef->center_freq2 &&
4174 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
4175 return -ENOBUFS;
4176 if (chandef->punctured &&
4177 nla_put_u32(msg, NL80211_ATTR_PUNCT_BITMAP, chandef->punctured))
4178 return -ENOBUFS;
4189 struct net_device *dev = wdev->netdev;
4192 lockdep_assert_wiphy(&rdev->wiphy);
4200 return -1;
4203 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4204 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
4207 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
4208 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
4213 rdev->devlist_generation ^
4215 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr) ||
4216 nla_put_u32(msg, NL80211_ATTR_VIF_RADIO_MASK, wdev->radio_mask))
4219 if (rdev->ops->get_channel && !wdev->valid_links) {
4228 if (rdev->ops->get_tx_power && !wdev->valid_links) {
4231 ret = rdev_get_tx_power(rdev, wdev, -1, 0, &dbm);
4238 switch (wdev->iftype) {
4241 if (wdev->u.ap.ssid_len &&
4242 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ap.ssid_len,
4243 wdev->u.ap.ssid))
4248 if (wdev->u.client.ssid_len &&
4249 nla_put(msg, NL80211_ATTR_SSID, wdev->u.client.ssid_len,
4250 wdev->u.client.ssid))
4254 if (wdev->u.ibss.ssid_len &&
4255 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ibss.ssid_len,
4256 wdev->u.ibss.ssid))
4264 if (rdev->ops->get_txq_stats) {
4274 if (wdev->valid_links) {
4293 wdev->links[link_id].addr))
4300 if (rdev->ops->get_tx_power) {
4303 ret = rdev_get_tx_power(rdev, wdev, -1, link_id, &dbm);
4320 return -EMSGSIZE;
4327 int wp_start = cb->args[0];
4328 int if_start = cb->args[1];
4329 int filter_wiphy = -1;
4335 if (!cb->args[2]) {
4337 .filter_wiphy = -1,
4347 * if filtering, set cb->args[2] to +1 since 0 is the default
4351 cb->args[2] = filter_wiphy + 1;
4353 cb->args[2] = -1;
4354 } else if (cb->args[2] > 0) {
4355 filter_wiphy = cb->args[2] - 1;
4359 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
4366 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
4371 guard(wiphy)(&rdev->wiphy);
4373 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4379 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
4380 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4392 cb->args[0] = wp_idx;
4393 cb->args[1] = if_idx;
4395 ret = skb->len;
4405 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4406 struct wireless_dev *wdev = info->user_ptr[1];
4410 return -ENOMEM;
4412 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
4415 return -ENOBUFS;
4439 return -EINVAL;
4442 return -EINVAL;
4451 return -EOPNOTSUPP;
4466 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
4468 return -EINVAL;
4470 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
4471 ¶ms->flags);
4479 if (params->flags & MONITOR_FLAG_COOK_FRAMES)
4480 return -EOPNOTSUPP;
4482 if (params->flags & MONITOR_FLAG_ACTIVE &&
4483 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
4484 return -EOPNOTSUPP;
4486 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
4491 return -EINVAL;
4493 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
4494 return -EOPNOTSUPP;
4497 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
4501 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
4502 return -EINVAL;
4504 params->vht_mumimo_groups = mumimo_groups;
4508 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
4512 return -EINVAL;
4514 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
4515 return -EOPNOTSUPP;
4517 params->vht_mumimo_follow_addr =
4518 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
4531 return -EBUSY;
4537 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
4541 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
4548 return -EOPNOTSUPP;
4554 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4555 struct nlattr *attr = info->attrs[NL80211_ATTR_VIF_RADIO_MASK];
4563 allowed = BIT(rdev->wiphy.n_radio) - 1;
4566 return -EINVAL;
4576 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4580 struct net_device *dev = info->user_ptr[1];
4581 struct wireless_dev *wdev = dev->ieee80211_ptr;
4587 otype = ntype = dev->ieee80211_ptr->iftype;
4589 if (info->attrs[NL80211_ATTR_IFTYPE]) {
4590 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
4595 if (info->attrs[NL80211_ATTR_MESH_ID]) {
4597 return -EINVAL;
4599 return -EINVAL;
4601 return -EBUSY;
4603 wdev->u.mesh.id_up_len =
4604 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
4605 memcpy(wdev->u.mesh.id,
4606 nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
4607 wdev->u.mesh.id_up_len);
4610 if (info->attrs[NL80211_ATTR_4ADDR]) {
4611 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
4617 params.use_4addr = -1;
4630 return -EBUSY;
4637 if (!err && params.use_4addr != -1)
4638 dev->ieee80211_ptr->use_4addr = params.use_4addr;
4641 wdev->radio_mask = radio_mask;
4651 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4661 if (!info->attrs[NL80211_ATTR_IFNAME])
4662 return -EINVAL;
4664 if (info->attrs[NL80211_ATTR_IFTYPE])
4665 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
4667 if (!rdev->ops->add_virtual_intf)
4668 return -EOPNOTSUPP;
4671 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
4672 info->attrs[NL80211_ATTR_MAC]) {
4673 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
4676 return -EADDRNOTAVAIL;
4679 if (info->attrs[NL80211_ATTR_4ADDR]) {
4680 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
4686 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0))
4687 return -EOPNOTSUPP;
4699 return -ENOMEM;
4702 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
4706 return -EPROTO;
4712 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
4713 wdev->owner_nlportid = info->snd_portid;
4717 if (!info->attrs[NL80211_ATTR_MESH_ID])
4719 wdev->u.mesh.id_up_len =
4720 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
4721 memcpy(wdev->u.mesh.id,
4722 nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
4723 wdev->u.mesh.id_up_len);
4739 wdev->radio_mask = radio_mask;
4741 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
4744 return -ENOBUFS;
4752 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4757 guard(wiphy)(&rdev->wiphy);
4764 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4765 struct wireless_dev *wdev = info->user_ptr[1];
4767 if (!rdev->ops->del_virtual_intf)
4768 return -EOPNOTSUPP;
4779 mutex_unlock(&rdev->wiphy.mtx);
4788 if (!wdev->netdev)
4789 info->user_ptr[1] = NULL;
4791 dev_close(wdev->netdev);
4793 mutex_lock(&rdev->wiphy.mtx);
4800 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4801 struct net_device *dev = info->user_ptr[1];
4804 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
4805 return -EINVAL;
4807 if (!rdev->ops->set_noack_map)
4808 return -EOPNOTSUPP;
4810 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
4820 if (link_id != -1) {
4823 return -EINVAL;
4829 if (wdev->valid_links) {
4830 if (link_id == -1) {
4833 return -EINVAL;
4835 if (!(wdev->valid_links & BIT(link_id))) {
4837 return -EINVAL;
4839 } else if (link_id != -1) {
4840 GENL_SET_ERR_MSG(info, "link ID not allowed for non-MLO group key");
4841 return -EINVAL;
4858 if ((params->seq &&
4859 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
4860 params->seq_len, params->seq)) ||
4861 (params->cipher &&
4862 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
4863 params->cipher)))
4866 key = nla_nest_start_noflag(cookie->msg, NL80211_ATTR_KEY);
4870 if ((params->seq &&
4871 nla_put(cookie->msg, NL80211_KEY_SEQ,
4872 params->seq_len, params->seq)) ||
4873 (params->cipher &&
4874 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
4875 params->cipher)))
4878 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
4881 nla_nest_end(cookie->msg, key);
4885 cookie->error = 1;
4890 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4892 struct net_device *dev = info->user_ptr[1];
4902 int link_id = nl80211_link_id_or_invalid(info->attrs);
4903 struct wireless_dev *wdev = dev->ieee80211_ptr;
4905 if (wiphy_ext_feature_isset(&rdev->wiphy,
4909 if ((wdev->iftype == NL80211_IFTYPE_STATION ||
4910 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) &&
4911 wiphy_ext_feature_isset(&rdev->wiphy,
4915 if (info->attrs[NL80211_ATTR_KEY_IDX]) {
4916 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
4920 return -EINVAL;
4924 if (info->attrs[NL80211_ATTR_MAC])
4925 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4928 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
4929 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
4933 return -EINVAL;
4937 if (!rdev->ops->get_key)
4938 return -EOPNOTSUPP;
4940 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
4941 return -ENOENT;
4945 return -ENOMEM;
4947 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4955 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4979 err = -ENOBUFS;
4987 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4990 struct net_device *dev = info->user_ptr[1];
4991 int link_id = nl80211_link_id_or_invalid(info->attrs);
4992 struct wireless_dev *wdev = dev->ieee80211_ptr;
4999 return -EINVAL;
5006 return -EINVAL;
5009 if (!rdev->ops->set_default_key)
5010 return -EOPNOTSUPP;
5027 wdev->wext.default_key = key.idx;
5032 return -EINVAL;
5034 if (!rdev->ops->set_default_mgmt_key)
5035 return -EOPNOTSUPP;
5050 wdev->wext.default_mgmt_key = key.idx;
5055 return -EINVAL;
5057 if (!rdev->ops->set_default_beacon_key)
5058 return -EOPNOTSUPP;
5070 wiphy_ext_feature_isset(&rdev->wiphy,
5074 if (info->attrs[NL80211_ATTR_MAC])
5075 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5078 return -EINVAL;
5089 return -EINVAL;
5094 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5096 struct net_device *dev = info->user_ptr[1];
5099 int link_id = nl80211_link_id_or_invalid(info->attrs);
5100 struct wireless_dev *wdev = dev->ieee80211_ptr;
5108 return -EINVAL;
5111 if (info->attrs[NL80211_ATTR_MAC])
5112 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5114 if (key.type == -1) {
5125 return -EINVAL;
5129 info->attrs[NL80211_ATTR_VLAN_ID])
5130 key.p.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
5132 if (!rdev->ops->add_key)
5133 return -EOPNOTSUPP;
5139 return -EINVAL;
5163 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5165 struct net_device *dev = info->user_ptr[1];
5168 int link_id = nl80211_link_id_or_invalid(info->attrs);
5169 struct wireless_dev *wdev = dev->ieee80211_ptr;
5175 if (info->attrs[NL80211_ATTR_MAC])
5176 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5178 if (key.type == -1) {
5188 return -EINVAL;
5192 return -EINVAL;
5194 if (!rdev->ops->del_key)
5195 return -EOPNOTSUPP;
5200 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
5201 err = -ENOENT;
5214 if (key.idx == wdev->wext.default_key)
5215 wdev->wext.default_key = -1;
5216 else if (key.idx == wdev->wext.default_mgmt_key)
5217 wdev->wext.default_mgmt_key = -1;
5232 return -EINVAL;
5253 if (!wiphy->max_acl_mac_addrs)
5254 return ERR_PTR(-EOPNOTSUPP);
5256 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
5257 return ERR_PTR(-EINVAL);
5259 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
5262 return ERR_PTR(-EINVAL);
5264 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
5265 return ERR_PTR(-EINVAL);
5267 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
5271 if (n_entries > wiphy->max_acl_mac_addrs)
5272 return ERR_PTR(-EOPNOTSUPP);
5276 return ERR_PTR(-ENOMEM);
5277 acl->n_acl_entries = n_entries;
5279 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
5280 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
5283 acl->acl_policy = acl_policy;
5290 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5291 struct net_device *dev = info->user_ptr[1];
5295 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5296 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5297 return -EOPNOTSUPP;
5299 if (!dev->ieee80211_ptr->links[0].ap.beacon_interval)
5300 return -EINVAL;
5302 acl = parse_acl_data(&rdev->wiphy, info);
5323 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
5325 &sband->bitrates[ridx];
5326 if (rate == srate->bitrate) {
5331 if (ridx == sband->n_bitrates)
5358 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
5405 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5409 if (!sband->vht_cap.vht_supported)
5418 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
5419 mcs[i] = txrate->mcs[i];
5458 struct net_device *dev = info->user_ptr[1];
5459 struct wireless_dev *wdev = dev->ieee80211_ptr;
5469 return le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80);
5472 switch (chandef->width) {
5474 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80p80;
5477 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_160;
5480 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80;
5499 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
5511 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
5512 mcs[i] = txrate->mcs[i];
5524 struct net_device *dev = info->user_ptr[1];
5525 struct wireless_dev *wdev = dev->ieee80211_ptr;
5527 unsigned int link_id = nl80211_link_id(info->attrs);
5531 &eht_cap->eht_mcs_nss_supp.only_20mhz;
5533 mcs_7 = u8_get_bits(mcs->rx_tx_mcs7_max_nss,
5535 mcs_9 = u8_get_bits(mcs->rx_tx_mcs9_max_nss,
5537 mcs_11 = u8_get_bits(mcs->rx_tx_mcs11_max_nss,
5539 mcs_13 = u8_get_bits(mcs->rx_tx_mcs13_max_nss,
5546 switch (wdev->iftype) {
5548 width = wdev->u.ibss.chandef.width;
5551 width = wdev->u.mesh.chandef.width;
5554 width = wdev->u.ocb.chandef.width;
5557 if (wdev->valid_links)
5558 width = wdev->links[link_id].ap.chandef.width;
5560 width = wdev->u.ap.preset_chandef.width;
5566 mcs = &eht_cap->eht_mcs_nss_supp.bw._320;
5569 mcs = &eht_cap->eht_mcs_nss_supp.bw._160;
5572 mcs = &eht_cap->eht_mcs_nss_supp.bw._80;
5576 mcs_7 = u8_get_bits(mcs->rx_tx_mcs9_max_nss,
5578 mcs_9 = u8_get_bits(mcs->rx_tx_mcs9_max_nss,
5580 mcs_11 = u8_get_bits(mcs->rx_tx_mcs11_max_nss,
5582 mcs_13 = u8_get_bits(mcs->rx_tx_mcs13_max_nss,
5587 if (eht_cap->eht_cap_elem.phy_cap_info[6] &
5598 mcs_7--;
5603 mcs_9--;
5608 mcs_11--;
5613 mcs_13--;
5627 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
5631 eht_cap = ieee80211_get_eht_iftype_cap(sband, wdev->iftype);
5636 if (txrate->mcs[0] & 0x4000) {
5637 if (sband->band != NL80211_BAND_6GHZ)
5640 if (!(eht_cap->eht_cap_elem.phy_cap_info[6] &
5645 mcs_nss_len = ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
5646 &eht_cap->eht_cap_elem,
5647 wdev->iftype ==
5651 /* Supported iftypes for setting non-20 MHZ only EHT MCS */
5652 switch (wdev->iftype) {
5669 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
5670 mcs[i] = txrate->mcs[i];
5687 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5688 struct wireless_dev *wdev = dev->ieee80211_ptr;
5704 sband = rdev->wiphy.bands[i];
5709 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
5710 memcpy(mask->control[i].ht_mcs,
5711 sband->ht_cap.mcs.rx_mask,
5712 sizeof(mask->control[i].ht_mcs));
5714 if (sband->vht_cap.vht_supported) {
5715 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
5716 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
5719 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype);
5724 he_build_mcs_mask(he_tx_mcs_map, mask->control[i].he_mcs);
5726 mask->control[i].he_gi = 0xFF;
5727 mask->control[i].he_ltf = 0xFF;
5729 eht_cap = ieee80211_get_eht_iftype_cap(sband, wdev->iftype);
5733 mcs_nss_len = ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
5734 &eht_cap->eht_cap_elem,
5735 wdev->iftype ==
5739 mask->control[i].eht_mcs);
5741 mask->control[i].eht_gi = 0xFF;
5742 mask->control[i].eht_ltf = 0xFF;
5758 return -EINVAL;
5759 sband = rdev->wiphy.bands[band];
5761 return -EINVAL;
5765 info->extack);
5769 mask->control[band].legacy = rateset_to_mask(
5773 if ((mask->control[band].legacy == 0) &&
5775 return -EINVAL;
5782 mask->control[band].ht_mcs))
5783 return -EINVAL;
5790 mask->control[band].vht_mcs))
5791 return -EINVAL;
5795 mask->control[band].gi =
5797 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
5798 return -EINVAL;
5803 mask->control[band].he_mcs,
5805 return -EINVAL;
5808 mask->control[band].he_gi =
5811 mask->control[band].he_ltf =
5817 mask->control[band].eht_mcs))
5818 return -EINVAL;
5821 mask->control[band].eht_gi =
5824 mask->control[band].eht_ltf =
5827 if (mask->control[band].legacy == 0) {
5831 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
5832 rdev->wiphy.bands[band]->vht_cap.vht_supported ||
5833 ieee80211_get_he_iftype_cap(sband, wdev->iftype) ||
5834 ieee80211_get_eht_iftype_cap(sband, wdev->iftype)))
5835 return -EINVAL;
5838 if (mask->control[band].ht_mcs[i])
5842 if (mask->control[band].vht_mcs[i])
5846 if (mask->control[band].he_mcs[i])
5850 if (mask->control[band].eht_mcs[i])
5854 return -EINVAL;
5867 u32 rate = beacon_rate->control[band].legacy;
5871 return -EINVAL;
5875 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
5876 return -EINVAL;
5877 } else if (beacon_rate->control[band].ht_mcs[i]) {
5880 return -EINVAL;
5883 return -EINVAL;
5888 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
5889 return -EINVAL;
5890 } else if (beacon_rate->control[band].vht_mcs[i]) {
5893 return -EINVAL;
5896 return -EINVAL;
5901 if (hweight16(beacon_rate->control[band].he_mcs[i]) > 1) {
5902 return -EINVAL;
5903 } else if (beacon_rate->control[band].he_mcs[i]) {
5906 return -EINVAL;
5909 return -EINVAL;
5914 if (hweight16(beacon_rate->control[band].eht_mcs[i]) > 1) {
5915 return -EINVAL;
5916 } else if (beacon_rate->control[band].eht_mcs[i]) {
5919 return -EINVAL;
5922 return -EINVAL;
5927 return -EINVAL;
5930 !wiphy_ext_feature_isset(&rdev->wiphy,
5932 return -EINVAL;
5934 !wiphy_ext_feature_isset(&rdev->wiphy,
5936 return -EINVAL;
5938 !wiphy_ext_feature_isset(&rdev->wiphy,
5940 return -EINVAL;
5942 !wiphy_ext_feature_isset(&rdev->wiphy,
5944 return -EINVAL;
5947 !wiphy_ext_feature_isset(&rdev->wiphy,
5949 return -EINVAL;
5962 int tx_link_id = -1;
5964 if (!wiphy->mbssid_max_interfaces)
5965 return -EOPNOTSUPP;
5970 return -EINVAL;
5972 config->ema = nla_get_flag(tb[NL80211_MBSSID_CONFIG_ATTR_EMA]);
5973 if (config->ema) {
5974 if (!wiphy->ema_max_profile_periodicity)
5975 return -EOPNOTSUPP;
5977 if (num_elems > wiphy->ema_max_profile_periodicity)
5978 return -EINVAL;
5981 config->index = nla_get_u8(tb[NL80211_MBSSID_CONFIG_ATTR_INDEX]);
5982 if (config->index >= wiphy->mbssid_max_interfaces ||
5983 (!config->index && !num_elems))
5984 return -EINVAL;
5993 if ((!config->index && tx_ifindex != dev->ifindex) ||
5994 (config->index && tx_ifindex == dev->ifindex))
5995 return -EINVAL;
5997 if (tx_ifindex != dev->ifindex) {
6001 if (!tx_netdev || !tx_netdev->ieee80211_ptr ||
6002 tx_netdev->ieee80211_ptr->wiphy != wiphy ||
6003 tx_netdev->ieee80211_ptr->iftype !=
6006 return -EINVAL;
6009 config->tx_wdev = tx_netdev->ieee80211_ptr;
6010 /* Caller should call dev_put(config->tx_wdev) from this point */
6012 if (config->tx_wdev->valid_links) {
6013 if (tx_link_id == -1 ||
6014 !(config->tx_wdev->valid_links & BIT(tx_link_id)))
6015 return -ENOLINK;
6017 config->tx_link_id = tx_link_id;
6021 return -EINVAL;
6023 config->tx_wdev = dev->ieee80211_ptr;
6025 } else if (!config->index) {
6027 return -EINVAL;
6029 config->tx_wdev = dev->ieee80211_ptr;
6031 return -EINVAL;
6045 if (!wiphy->mbssid_max_interfaces)
6046 return ERR_PTR(-EINVAL);
6050 return ERR_PTR(-EINVAL);
6056 return ERR_PTR(-ENOMEM);
6057 elems->cnt = num_elems;
6060 elems->elem[i].data = nla_data(nl_elems);
6061 elems->elem[i].len = nla_len(nl_elems);
6088 return ERR_PTR(-ENOMEM);
6089 elems->cnt = num_elems;
6092 elems->elem[i].data = nla_data(nl_elems);
6093 elems->elem[i].len = nla_len(nl_elems);
6111 return -EINVAL;
6113 he_bss_color->color =
6115 he_bss_color->enabled =
6117 he_bss_color->partial =
6133 bcn->link_id = nl80211_link_id(attrs);
6136 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
6137 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
6138 if (!bcn->head_len)
6139 return -EINVAL;
6144 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
6145 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
6150 return -EINVAL;
6153 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
6154 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
6158 bcn->proberesp_ies =
6160 bcn->proberesp_ies_len =
6165 bcn->assocresp_ies =
6167 bcn->assocresp_ies_len =
6172 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
6173 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
6187 wiphy_ext_feature_isset(&rdev->wiphy,
6189 bcn->ftm_responder = 1;
6191 return -EOPNOTSUPP;
6194 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]);
6195 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]);
6199 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
6200 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
6203 bcn->ftm_responder = -1;
6208 &bcn->he_bss_color);
6211 bcn->he_bss_color_valid = true;
6216 nl80211_parse_mbssid_elems(&rdev->wiphy,
6222 bcn->mbssid_ies = mbssid;
6224 if (bcn->mbssid_ies && attrs[NL80211_ATTR_EMA_RNR_ELEMS]) {
6226 nl80211_parse_rnr_elems(&rdev->wiphy,
6233 if (rnr && rnr->cnt < bcn->mbssid_ies->cnt)
6234 return -EINVAL;
6236 bcn->rnr_ies = rnr;
6255 return -EINVAL;
6257 he_obss_pd->sr_ctrl = nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL]);
6260 he_obss_pd->min_offset =
6263 he_obss_pd->max_offset =
6266 he_obss_pd->non_srg_max_offset =
6269 if (he_obss_pd->min_offset > he_obss_pd->max_offset)
6270 return -EINVAL;
6273 memcpy(he_obss_pd->bss_color_bitmap,
6275 sizeof(he_obss_pd->bss_color_bitmap));
6278 memcpy(he_obss_pd->partial_bssid_bitmap,
6280 sizeof(he_obss_pd->partial_bssid_bitmap));
6282 he_obss_pd->enable = true;
6294 if (!wiphy_ext_feature_isset(&rdev->wiphy,
6296 return -EINVAL;
6306 fd->update = true;
6313 return -EINVAL;
6315 fd->tmpl_len = nla_len(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]);
6316 fd->tmpl = nla_data(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]);
6317 fd->min_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN]);
6318 fd->max_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX]);
6319 fd->update = true;
6331 if (!wiphy_ext_feature_isset(&rdev->wiphy,
6333 return -EINVAL;
6342 presp->update = true;
6348 return -EINVAL;
6350 presp->tmpl = nla_data(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]);
6351 presp->tmpl_len = nla_len(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]);
6352 presp->interval = nla_get_u32(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT]);
6353 presp->update = true;
6365 for (i = 0; i < rates->datalen; i++) {
6366 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
6367 params->ht_required = true;
6368 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
6369 params->vht_required = true;
6370 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_HE_PHY)
6371 params->he_required = true;
6372 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_SAE_H2E)
6373 params->sae_h2e_required = true;
6384 const struct cfg80211_beacon_data *bcn = ¶ms->beacon;
6385 size_t ies_len = bcn->tail_len;
6386 const u8 *ies = bcn->tail;
6397 if (cap && cap->datalen >= sizeof(*params->ht_cap))
6398 params->ht_cap = (void *)cap->data;
6400 if (cap && cap->datalen >= sizeof(*params->vht_cap))
6401 params->vht_cap = (void *)cap->data;
6403 if (cap && cap->datalen >= sizeof(*params->he_cap) + 1)
6404 params->he_cap = (void *)(cap->data + 1);
6406 if (cap && cap->datalen >= sizeof(*params->he_oper) + 1)
6407 params->he_oper = (void *)(cap->data + 1);
6410 if (!cap->datalen)
6411 return -EINVAL;
6412 params->eht_cap = (void *)(cap->data + 1);
6413 if (!ieee80211_eht_capa_size_ok((const u8 *)params->he_cap,
6414 (const u8 *)params->eht_cap,
6415 cap->datalen - 1, true))
6416 return -EINVAL;
6420 if (!cap->datalen)
6421 return -EINVAL;
6422 params->eht_oper = (void *)(cap->data + 1);
6423 if (!ieee80211_eht_oper_size_ok((const u8 *)params->eht_oper,
6424 cap->datalen - 1))
6425 return -EINVAL;
6435 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
6436 if (wdev->iftype != NL80211_IFTYPE_AP &&
6437 wdev->iftype != NL80211_IFTYPE_P2P_GO)
6440 if (!wdev->u.ap.preset_chandef.chan)
6443 params->chandef = wdev->u.ap.preset_chandef;
6459 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
6462 if (!wiphy_ext_feature_isset(&rdev->wiphy,
6470 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
6471 !wiphy_ext_feature_isset(&rdev->wiphy,
6481 &rdev->wiphy,
6487 if (!wiphy_ext_feature_isset(&rdev->wiphy,
6505 struct wiphy *wiphy = wdev->wiphy;
6518 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
6519 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
6522 (wdev->u.ap.ssid_len &&
6523 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ap.ssid_len,
6524 wdev->u.ap.ssid)) ||
6525 (wdev->valid_links &&
6540 struct ieee80211_channel *channel = params->chandef.chan;
6542 if ((params->he_cap || params->he_oper) &&
6543 (channel->flags & IEEE80211_CHAN_NO_HE))
6544 return -EOPNOTSUPP;
6546 if ((params->eht_cap || params->eht_oper) &&
6547 (channel->flags & IEEE80211_CHAN_NO_EHT))
6548 return -EOPNOTSUPP;
6561 if (!rdev->wiphy.bands[NL80211_BAND_S1GHZ])
6562 return -EINVAL;
6571 return -EINVAL;
6573 sb->short_head = nla_data(tb[NL80211_S1G_SHORT_BEACON_ATTR_HEAD]);
6574 sb->short_head_len = nla_len(tb[NL80211_S1G_SHORT_BEACON_ATTR_HEAD]);
6575 sb->short_tail_len = 0;
6578 sb->short_tail =
6580 sb->short_tail_len =
6584 sb->update = true;
6590 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6592 unsigned int link_id = nl80211_link_id(info->attrs);
6593 struct net_device *dev = info->user_ptr[1];
6594 struct wireless_dev *wdev = dev->ieee80211_ptr;
6598 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6599 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6600 return -EOPNOTSUPP;
6602 if (!rdev->ops->start_ap)
6603 return -EOPNOTSUPP;
6605 if (wdev->links[link_id].cac_started)
6606 return -EBUSY;
6608 if (wdev->links[link_id].ap.beacon_interval)
6609 return -EALREADY;
6612 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
6613 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
6614 !info->attrs[NL80211_ATTR_BEACON_HEAD])
6615 return -EINVAL;
6617 if (info->attrs[NL80211_ATTR_SMPS_MODE] &&
6618 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]) != NL80211_SMPS_OFF)
6619 return -EOPNOTSUPP;
6623 return -ENOMEM;
6625 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms->beacon,
6626 info->extack);
6630 params->beacon_interval =
6631 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
6632 params->dtim_period =
6633 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
6635 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
6636 params->beacon_interval);
6645 * additional information -- drivers must check!
6647 if (info->attrs[NL80211_ATTR_SSID]) {
6648 params->ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6649 params->ssid_len =
6650 nla_len(info->attrs[NL80211_ATTR_SSID]);
6651 if (params->ssid_len == 0) {
6652 err = -EINVAL;
6656 if (wdev->u.ap.ssid_len &&
6657 (wdev->u.ap.ssid_len != params->ssid_len ||
6658 memcmp(wdev->u.ap.ssid, params->ssid, params->ssid_len))) {
6660 err = -EINVAL;
6663 } else if (wdev->valid_links) {
6665 err = -EINVAL;
6669 if (info->attrs[NL80211_ATTR_HIDDEN_SSID])
6670 params->hidden_ssid = nla_get_u32(
6671 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
6673 params->privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
6675 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
6676 params->auth_type = nla_get_u32(
6677 info->attrs[NL80211_ATTR_AUTH_TYPE]);
6678 if (!nl80211_valid_auth_type(rdev, params->auth_type,
6680 err = -EINVAL;
6684 params->auth_type = NL80211_AUTHTYPE_AUTOMATIC;
6686 err = nl80211_crypto_settings(rdev, info, ¶ms->crypto,
6691 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
6692 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER)) {
6693 err = -EOPNOTSUPP;
6696 params->inactivity_timeout = nla_get_u16(
6697 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
6700 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
6701 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
6702 err = -EINVAL;
6705 params->p2p_ctwindow =
6706 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
6707 if (params->p2p_ctwindow != 0 &&
6708 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN)) {
6709 err = -EINVAL;
6714 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
6717 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
6718 err = -EINVAL;
6721 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
6722 params->p2p_opp_ps = tmp;
6723 if (params->p2p_opp_ps != 0 &&
6724 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS)) {
6725 err = -EINVAL;
6730 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6731 err = nl80211_parse_chandef(rdev, info, ¶ms->chandef);
6734 } else if (wdev->valid_links) {
6736 err = -EINVAL;
6738 } else if (wdev->u.ap.preset_chandef.chan) {
6739 params->chandef = wdev->u.ap.preset_chandef;
6741 err = -EINVAL;
6745 beacon_check.iftype = wdev->iftype;
6748 cfg80211_get_6ghz_power_type(params->beacon.tail,
6749 params->beacon.tail_len);
6750 if (!cfg80211_reg_check_beaconing(&rdev->wiphy, ¶ms->chandef,
6752 err = -EINVAL;
6756 if (info->attrs[NL80211_ATTR_TX_RATES]) {
6757 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
6759 ¶ms->beacon_rate,
6764 err = validate_beacon_tx_rate(rdev, params->chandef.chan->band,
6765 ¶ms->beacon_rate);
6770 params->pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
6771 if (params->pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
6772 err = -EOPNOTSUPP;
6776 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
6777 params->acl = parse_acl_data(&rdev->wiphy, info);
6778 if (IS_ERR(params->acl)) {
6779 err = PTR_ERR(params->acl);
6780 params->acl = NULL;
6785 params->twt_responder =
6786 nla_get_flag(info->attrs[NL80211_ATTR_TWT_RESPONDER]);
6788 if (info->attrs[NL80211_ATTR_HE_OBSS_PD]) {
6790 info->attrs[NL80211_ATTR_HE_OBSS_PD],
6791 ¶ms->he_obss_pd);
6796 if (info->attrs[NL80211_ATTR_FILS_DISCOVERY]) {
6798 info->attrs[NL80211_ATTR_FILS_DISCOVERY],
6799 ¶ms->fils_discovery);
6804 if (info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP]) {
6806 rdev, info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP],
6807 ¶ms->unsol_bcast_probe_resp);
6812 if (info->attrs[NL80211_ATTR_MBSSID_CONFIG]) {
6813 err = nl80211_parse_mbssid_config(&rdev->wiphy, dev, link_id,
6814 info->attrs[NL80211_ATTR_MBSSID_CONFIG],
6815 ¶ms->mbssid_config,
6816 params->beacon.mbssid_ies ?
6817 params->beacon.mbssid_ies->cnt :
6823 if (!params->mbssid_config.ema && params->beacon.rnr_ies) {
6824 err = -EINVAL;
6828 if (info->attrs[NL80211_ATTR_S1G_SHORT_BEACON]) {
6829 if (!info->attrs[NL80211_ATTR_S1G_LONG_BEACON_PERIOD]) {
6830 err = -EINVAL;
6834 params->s1g_long_beacon_period = nla_get_u8(
6835 info->attrs[NL80211_ATTR_S1G_LONG_BEACON_PERIOD]);
6838 rdev, info->attrs[NL80211_ATTR_S1G_SHORT_BEACON],
6839 ¶ms->s1g_short_beacon);
6852 if (info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS])
6853 params->flags = nla_get_u32(
6854 info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS]);
6855 else if (info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])
6856 params->flags |= NL80211_AP_SETTINGS_EXTERNAL_AUTH_SUPPORT;
6858 if (wdev->conn_owner_nlportid &&
6859 info->attrs[NL80211_ATTR_SOCKET_OWNER] &&
6860 wdev->conn_owner_nlportid != info->snd_portid) {
6861 err = -EINVAL;
6865 /* FIXME: validate MLO/link-id against driver capabilities */
6869 wdev->links[link_id].ap.beacon_interval = params->beacon_interval;
6870 wdev->links[link_id].ap.chandef = params->chandef;
6871 wdev->u.ap.ssid_len = params->ssid_len;
6872 memcpy(wdev->u.ap.ssid, params->ssid,
6873 params->ssid_len);
6875 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
6876 wdev->conn_owner_nlportid = info->snd_portid;
6881 kfree(params->acl);
6882 kfree(params->beacon.mbssid_ies);
6883 if (params->mbssid_config.tx_wdev &&
6884 params->mbssid_config.tx_wdev->netdev &&
6885 params->mbssid_config.tx_wdev->netdev != dev)
6886 dev_put(params->mbssid_config.tx_wdev->netdev);
6887 kfree(params->beacon.rnr_ies);
6895 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6897 unsigned int link_id = nl80211_link_id(info->attrs);
6898 struct net_device *dev = info->user_ptr[1];
6899 struct wireless_dev *wdev = dev->ieee80211_ptr;
6904 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6905 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6906 return -EOPNOTSUPP;
6908 if (!rdev->ops->change_beacon)
6909 return -EOPNOTSUPP;
6911 if (!wdev->links[link_id].ap.beacon_interval)
6912 return -EINVAL;
6916 return -ENOMEM;
6918 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms->beacon,
6919 info->extack);
6924 beacon_check.iftype = wdev->iftype;
6927 cfg80211_get_6ghz_power_type(params->beacon.tail,
6928 params->beacon.tail_len);
6929 if (!cfg80211_reg_check_beaconing(&rdev->wiphy,
6930 &wdev->links[link_id].ap.chandef,
6932 err = -EINVAL;
6936 attr = info->attrs[NL80211_ATTR_FILS_DISCOVERY];
6939 ¶ms->fils_discovery);
6944 attr = info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP];
6947 ¶ms->unsol_bcast_probe_resp);
6952 attr = info->attrs[NL80211_ATTR_S1G_SHORT_BEACON];
6955 ¶ms->s1g_short_beacon);
6963 kfree(params->beacon.mbssid_ies);
6964 kfree(params->beacon.rnr_ies);
6971 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6972 unsigned int link_id = nl80211_link_id(info->attrs);
6973 struct net_device *dev = info->user_ptr[1];
6999 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
7004 params->sta_flags_mask = sta_flags->mask;
7005 params->sta_flags_set = sta_flags->set;
7006 params->sta_flags_set &= params->sta_flags_mask;
7007 if ((params->sta_flags_mask |
7008 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
7009 return -EINVAL;
7015 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
7019 if (nla_parse_nested_deprecated(flags, NL80211_STA_FLAG_MAX, nla, sta_flags_policy, info->extack))
7020 return -EINVAL;
7032 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
7039 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
7043 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
7048 return -EINVAL;
7053 params->sta_flags_set |= (1<<flag);
7057 return -EINVAL;
7077 /* report 16-bit bitrate only if we can */
7086 switch (info->bw) {
7125 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS));
7132 WARN_ON(!(info->flags & RATE_INFO_FLAGS_EHT_MCS));
7139 if (info->flags & RATE_INFO_FLAGS_MCS) {
7140 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
7142 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
7145 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
7146 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
7148 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
7150 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
7153 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) {
7154 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs))
7156 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss))
7158 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi))
7160 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm))
7162 if (info->bw == RATE_INFO_BW_HE_RU &&
7164 info->he_ru_alloc))
7166 } else if (info->flags & RATE_INFO_FLAGS_S1G_MCS) {
7167 if (nla_put_u8(msg, NL80211_RATE_INFO_S1G_MCS, info->mcs))
7169 if (nla_put_u8(msg, NL80211_RATE_INFO_S1G_NSS, info->nss))
7171 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
7174 } else if (info->flags & RATE_INFO_FLAGS_EHT_MCS) {
7175 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_MCS, info->mcs))
7177 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_NSS, info->nss))
7179 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_GI, info->eht_gi))
7181 if (info->bw == RATE_INFO_BW_EHT_RU &&
7183 info->eht_ru_alloc))
7225 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
7227 link_sinfo->memb)) \
7231 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
7233 link_sinfo->memb, NL80211_STA_INFO_PAD)) \
7243 if (link_sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
7246 (u32)link_sinfo->rx_bytes))
7249 if (link_sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
7252 (u32)link_sinfo->tx_bytes))
7260 if (wiphy_ext_feature_isset(&rdev->wiphy,
7264 switch (rdev->wiphy.signal_type) {
7272 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
7273 if (!nl80211_put_signal(msg, link_sinfo->chains,
7274 link_sinfo->chain_signal,
7278 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
7279 if (!nl80211_put_signal(msg, link_sinfo->chains,
7280 link_sinfo->chain_signal_avg,
7284 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
7285 if (!nl80211_put_sta_rate(msg, &link_sinfo->txrate,
7289 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
7290 if (!nl80211_put_sta_rate(msg, &link_sinfo->rxrate,
7302 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
7308 if (((link_sinfo->bss_param.flags &
7311 ((link_sinfo->bss_param.flags &
7315 ((link_sinfo->bss_param.flags &
7320 link_sinfo->bss_param.dtim_period) ||
7322 link_sinfo->bss_param.beacon_interval))
7333 if (wiphy_ext_feature_isset(&rdev->wiphy,
7342 if (link_sinfo->pertid) {
7355 tidstats = &link_sinfo->pertid[tid];
7357 if (!tidstats->filled)
7365 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
7367 tidstats->memb, NL80211_TID_STATS_PAD)) \
7377 if ((tidstats->filled &
7379 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
7393 return -EMSGSIZE;
7412 return -1;
7415 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
7417 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
7426 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
7428 sinfo->memb)) \
7432 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
7434 sinfo->memb, NL80211_STA_INFO_PAD)) \
7442 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
7445 (u32)sinfo->rx_bytes))
7448 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
7451 (u32)sinfo->tx_bytes))
7459 if (wiphy_ext_feature_isset(&rdev->wiphy,
7463 switch (rdev->wiphy.signal_type) {
7471 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
7472 if (!nl80211_put_signal(msg, sinfo->chains,
7473 sinfo->chain_signal,
7477 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
7478 if (!nl80211_put_signal(msg, sinfo->chains,
7479 sinfo->chain_signal_avg,
7483 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
7484 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
7488 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
7489 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
7512 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
7518 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
7520 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
7522 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
7525 sinfo->bss_param.dtim_period) ||
7527 sinfo->bss_param.beacon_interval))
7532 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) &&
7535 &sinfo->sta_flags))
7543 if (wiphy_ext_feature_isset(&rdev->wiphy,
7552 if (sinfo->pertid) {
7565 tidstats = &sinfo->pertid[tid];
7567 if (!tidstats->filled)
7575 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
7577 tidstats->memb, NL80211_TID_STATS_PAD)) \
7587 if ((tidstats->filled &
7589 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
7601 if (sinfo->assoc_req_ies_len &&
7602 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
7603 sinfo->assoc_req_ies))
7606 if (sinfo->assoc_resp_ies_len &&
7607 nla_put(msg, NL80211_ATTR_RESP_IE, sinfo->assoc_resp_ies_len,
7608 sinfo->assoc_resp_ies))
7611 if (sinfo->mlo_params_valid) {
7613 sinfo->assoc_link_id))
7616 if (!is_zero_ether_addr(sinfo->mld_addr) &&
7618 sinfo->mld_addr))
7622 if (link_stats && sinfo->valid_links) {
7628 link_sinfo = sinfo->links[link_id];
7633 if (!is_valid_ether_addr(link_sinfo->addr))
7645 link_sinfo->addr))
7663 return -EMSGSIZE;
7672 sinfo->signal = -99;
7675 link_sinfo = sinfo->links[link_id];
7679 if ((link_sinfo->filled &
7681 sinfo->tx_packets += link_sinfo->tx_packets;
7682 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
7685 if ((link_sinfo->filled &
7687 sinfo->rx_packets += link_sinfo->rx_packets;
7688 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
7691 if (link_sinfo->filled &
7694 sinfo->tx_bytes += link_sinfo->tx_bytes;
7695 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES);
7698 if (link_sinfo->filled &
7701 sinfo->rx_bytes += link_sinfo->rx_bytes;
7702 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES);
7705 if (link_sinfo->filled &
7707 sinfo->tx_retries += link_sinfo->tx_retries;
7708 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);
7711 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_FAILED)) {
7712 sinfo->tx_failed += link_sinfo->tx_failed;
7713 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
7716 if (link_sinfo->filled &
7718 sinfo->rx_dropped_misc += link_sinfo->rx_dropped_misc;
7719 sinfo->filled |=
7723 if (link_sinfo->filled &
7725 sinfo->beacon_loss_count +=
7726 link_sinfo->beacon_loss_count;
7727 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_LOSS);
7730 if (link_sinfo->filled &
7732 sinfo->expected_throughput +=
7733 link_sinfo->expected_throughput;
7734 sinfo->filled |=
7738 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_MPDUS)) {
7739 sinfo->rx_mpdu_count += link_sinfo->rx_mpdu_count;
7740 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_MPDUS);
7743 if (link_sinfo->filled &
7745 sinfo->fcs_err_count += link_sinfo->fcs_err_count;
7746 sinfo->filled |=
7750 if (link_sinfo->filled &
7752 sinfo->rx_beacon += link_sinfo->rx_beacon;
7753 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_BEACON_RX);
7757 if ((link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_SIGNAL)) &&
7758 link_sinfo->signal > sinfo->signal) {
7759 sinfo->signal = link_sinfo->signal;
7760 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL);
7763 if ((link_sinfo->filled &
7765 link_sinfo->signal_avg > sinfo->signal_avg) {
7766 sinfo->signal_avg = link_sinfo->signal_avg;
7767 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
7773 if ((link_sinfo->filled &
7776 link_inactive_time > link_sinfo->inactive_time)) {
7777 link_inactive_time = link_sinfo->inactive_time;
7778 sinfo->inactive_time = link_sinfo->inactive_time;
7779 sinfo->filled |= NL80211_STA_INFO_INACTIVE_TIME;
7782 if (link_sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM) &&
7784 sinfo->bss_param.dtim_period >
7785 link_sinfo->bss_param.dtim_period)) {
7786 sinfo->bss_param.dtim_period =
7787 link_sinfo->bss_param.dtim_period;
7788 sinfo->filled |= NL80211_STA_BSS_PARAM_DTIM_PERIOD;
7789 sinfo->bss_param.beacon_interval =
7790 link_sinfo->bss_param.beacon_interval;
7791 sinfo->filled |= NL80211_STA_BSS_PARAM_BEACON_INTERVAL;
7795 if ((link_sinfo->filled &
7798 link_inactive_time > link_sinfo->inactive_time)) {
7799 sinfo->txrate = link_sinfo->txrate;
7800 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
7802 if ((link_sinfo->filled &
7805 link_inactive_time > link_sinfo->inactive_time)) {
7806 sinfo->rxrate = link_sinfo->rxrate;
7807 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
7810 if (link_sinfo->filled &
7813 link_inactive_time > link_sinfo->inactive_time)) {
7814 sinfo->tx_duration += link_sinfo->tx_duration;
7815 sinfo->filled |=
7818 if (link_sinfo->filled &
7821 link_inactive_time > link_sinfo->inactive_time)) {
7822 sinfo->rx_duration += link_sinfo->rx_duration;
7823 sinfo->filled |=
7829 if (sinfo->pertid) {
7830 sinfo->pertid->rx_msdu +=
7831 link_sinfo->pertid->rx_msdu;
7832 sinfo->pertid->tx_msdu +=
7833 link_sinfo->pertid->tx_msdu;
7834 sinfo->pertid->tx_msdu_retries +=
7835 link_sinfo->pertid->tx_msdu_retries;
7836 sinfo->pertid->tx_msdu_failed +=
7837 link_sinfo->pertid->tx_msdu_failed;
7839 sinfo->pertid->filled |=
7847 /* Reset sinfo->filled bits to exclude fields which don't make
7850 sinfo->filled &= ~BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL);
7851 sinfo->filled &= ~BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG);
7861 int sta_idx = cb->args[2];
7869 __acquire(&rdev->wiphy.mtx);
7871 if (!wdev->netdev) {
7872 err = -EINVAL;
7876 if (!rdev->ops->dump_station) {
7877 err = -EOPNOTSUPP;
7888 err = -ENOMEM;
7894 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
7896 if (err == -ENOENT)
7910 NETLINK_CB(cb->skb).portid,
7911 cb->nlh->nlmsg_seq, NLM_F_MULTI,
7912 rdev, wdev->netdev, mac_addr,
7920 cb->args[2] = sta_idx;
7921 err = skb->len;
7925 wiphy_unlock(&rdev->wiphy);
7932 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7933 struct net_device *dev = info->user_ptr[1];
7941 if (!info->attrs[NL80211_ATTR_MAC])
7942 return -EINVAL;
7944 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
7946 if (!rdev->ops->get_station)
7947 return -EOPNOTSUPP;
7953 return -ENOMEM;
7966 return -ENOMEM;
7973 info->snd_portid, info->snd_seq, 0,
7976 return -ENOBUFS;
7986 if (params->listen_interval != -1 &&
7988 return -EINVAL;
7990 if (params->support_p2p_ps != -1 &&
7992 return -EINVAL;
7994 if (params->aid &&
7995 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
7997 return -EINVAL;
8006 * No ignoring the TDLS flag here -- the userspace mesh
8010 if (params->sta_flags_mask &
8014 return -EINVAL;
8018 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
8019 return -EINVAL;
8021 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
8024 /* disallow mesh-specific things */
8025 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
8026 return -EINVAL;
8027 if (params->local_pm)
8028 return -EINVAL;
8029 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
8030 return -EINVAL;
8036 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
8037 return -EINVAL;
8040 * a hostapd/wpa_supplicant issue -- it always includes the
8043 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
8049 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
8050 return -EINVAL;
8051 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
8052 return -EINVAL;
8053 if (params->link_sta_params.supported_rates)
8054 return -EINVAL;
8055 if (params->ext_capab || params->link_sta_params.ht_capa ||
8056 params->link_sta_params.vht_capa ||
8057 params->link_sta_params.he_capa ||
8058 params->link_sta_params.eht_capa)
8059 return -EINVAL;
8060 if (params->sta_flags_mask & BIT(NL80211_STA_FLAG_SPP_AMSDU))
8061 return -EINVAL;
8066 if (params->vlan)
8067 return -EINVAL;
8072 params->eml_cap_present)
8073 return -EINVAL;
8078 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
8079 return -EOPNOTSUPP;
8084 if (params->sta_flags_mask &
8092 return -EINVAL;
8095 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
8096 params->sta_flags_mask &
8099 return -EINVAL;
8104 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
8105 return -EINVAL;
8109 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
8111 return -EINVAL;
8113 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
8114 !params->link_sta_params.supported_rates)
8115 return -EINVAL;
8119 return -EINVAL;
8121 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
8122 return -EINVAL;
8125 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
8126 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
8127 return -EINVAL;
8138 params->link_sta_params.opmode_notif_used = false;
8150 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
8159 return ERR_PTR(-ENODEV);
8161 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
8162 ret = -EINVAL;
8166 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
8167 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
8168 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
8169 ret = -EINVAL;
8174 ret = -ENETDOWN;
8192 if (!info->attrs[NL80211_ATTR_STA_WME])
8195 nla = info->attrs[NL80211_ATTR_STA_WME];
8198 info->extack);
8203 params->uapsd_queues = nla_get_u8(
8205 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
8206 return -EINVAL;
8209 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
8211 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
8212 return -EINVAL;
8214 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
8222 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
8223 params->supported_channels =
8224 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
8225 params->supported_channels_len =
8226 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
8232 if (params->supported_channels_len % 2)
8233 return -EINVAL;
8236 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
8237 params->supported_oper_classes =
8238 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
8239 params->supported_oper_classes_len =
8240 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
8250 if (info->attrs[NL80211_ATTR_PEER_AID])
8251 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
8252 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
8253 params->link_sta_params.ht_capa =
8254 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
8255 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
8256 params->link_sta_params.vht_capa =
8257 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
8258 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
8259 params->link_sta_params.he_capa =
8260 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
8261 params->link_sta_params.he_capa_len =
8262 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
8264 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) {
8265 params->link_sta_params.eht_capa =
8266 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
8267 params->link_sta_params.eht_capa_len =
8268 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
8270 if (!ieee80211_eht_capa_size_ok((const u8 *)params->link_sta_params.he_capa,
8271 (const u8 *)params->link_sta_params.eht_capa,
8272 params->link_sta_params.eht_capa_len,
8274 return -EINVAL;
8278 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY])
8279 params->link_sta_params.s1g_capa =
8280 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY]);
8293 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8296 if (info->attrs[NL80211_ATTR_STA_TX_POWER_SETTING]) {
8297 if (!rdev->ops->set_tx_power ||
8298 !wiphy_ext_feature_isset(&rdev->wiphy,
8300 return -EOPNOTSUPP;
8303 txpwr->type = nla_get_u8(info->attrs[idx]);
8305 if (txpwr->type == NL80211_TX_POWER_LIMITED) {
8308 if (info->attrs[idx])
8309 txpwr->power = nla_get_s16(info->attrs[idx]);
8311 return -EINVAL;
8324 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8325 struct net_device *dev = info->user_ptr[1];
8332 if (!rdev->ops->change_station)
8333 return -EOPNOTSUPP;
8340 if (info->attrs[NL80211_ATTR_STA_AID])
8341 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
8343 if (info->attrs[NL80211_ATTR_VLAN_ID])
8344 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
8346 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
8348 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
8350 params.listen_interval = -1;
8352 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS])
8354 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
8356 params.support_p2p_ps = -1;
8358 if (!info->attrs[NL80211_ATTR_MAC])
8359 return -EINVAL;
8362 nl80211_link_id_or_invalid(info->attrs);
8364 if (info->attrs[NL80211_ATTR_MLD_ADDR]) {
8371 return -EINVAL;
8373 mac_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
8376 nla_data(info->attrs[NL80211_ATTR_MAC]);
8378 return -EINVAL;
8380 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
8384 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
8386 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
8388 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
8391 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
8393 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
8397 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
8399 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
8401 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
8404 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
8405 return -EINVAL;
8407 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
8409 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
8411 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
8413 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
8414 if (info->attrs[NL80211_ATTR_MESH_PEER_AID])
8416 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
8420 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE])
8422 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
8424 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
8427 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
8430 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
8432 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
8434 if (info->attrs[NL80211_ATTR_EML_CAPABILITY]) {
8437 nla_get_u16(info->attrs[NL80211_ATTR_EML_CAPABILITY]);
8440 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
8442 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
8445 !wiphy_ext_feature_isset(&rdev->wiphy,
8447 return -EOPNOTSUPP;
8464 switch (dev->ieee80211_ptr->iftype) {
8474 err = -EOPNOTSUPP;
8489 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8491 struct net_device *dev = info->user_ptr[1];
8492 struct wireless_dev *wdev = dev->ieee80211_ptr;
8500 if (!rdev->ops->add_station)
8501 return -EOPNOTSUPP;
8503 if (!info->attrs[NL80211_ATTR_MAC])
8504 return -EINVAL;
8506 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
8507 return -EINVAL;
8509 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
8510 return -EINVAL;
8512 if (!info->attrs[NL80211_ATTR_STA_AID] &&
8513 !info->attrs[NL80211_ATTR_PEER_AID])
8514 return -EINVAL;
8517 nl80211_link_id_or_invalid(info->attrs);
8519 if (info->attrs[NL80211_ATTR_MLD_ADDR]) {
8520 mac_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
8523 nla_data(info->attrs[NL80211_ATTR_MAC]);
8525 return -EINVAL;
8527 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
8531 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
8533 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
8535 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
8537 if (info->attrs[NL80211_ATTR_VLAN_ID])
8538 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
8540 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
8542 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
8549 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
8552 if (info->attrs[NL80211_ATTR_PEER_AID])
8553 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
8555 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
8557 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
8559 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
8563 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
8565 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
8567 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
8570 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
8572 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
8574 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
8576 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
8578 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
8580 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
8582 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
8584 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) {
8586 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
8588 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
8594 return -EINVAL;
8598 if (info->attrs[NL80211_ATTR_EML_CAPABILITY]) {
8601 nla_get_u16(info->attrs[NL80211_ATTR_EML_CAPABILITY]);
8604 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
8606 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
8608 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY])
8610 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY]);
8612 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
8615 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
8618 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
8620 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
8622 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
8624 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
8627 !wiphy_ext_feature_isset(&rdev->wiphy,
8629 return -EOPNOTSUPP;
8645 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
8646 return -EINVAL;
8661 return -EINVAL;
8667 return -EINVAL;
8672 switch (dev->ieee80211_ptr->iftype) {
8677 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
8683 info->attrs[NL80211_ATTR_PEER_AID])
8684 return -EINVAL;
8689 if (!(rdev->wiphy.features &
8692 return -EINVAL;
8694 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8697 return -EINVAL;
8725 return -EINVAL;
8728 info->attrs[NL80211_ATTR_PEER_AID])
8729 return -EINVAL;
8740 return -EINVAL;
8743 return -EINVAL;
8745 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
8746 return -EOPNOTSUPP;
8748 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
8749 return -EOPNOTSUPP;
8757 return -EOPNOTSUPP;
8762 if (wdev->valid_links) {
8764 err = -EINVAL;
8767 if (!(wdev->valid_links & BIT(params.link_sta_params.link_id))) {
8768 err = -ENOLINK;
8773 err = -EINVAL;
8785 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8786 struct net_device *dev = info->user_ptr[1];
8787 struct wireless_dev *wdev = dev->ieee80211_ptr;
8789 int link_id = nl80211_link_id_or_invalid(info->attrs);
8793 if (info->attrs[NL80211_ATTR_MAC])
8794 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
8796 switch (wdev->iftype) {
8805 if (wiphy_ext_feature_isset(&rdev->wiphy,
8808 return -EINVAL;
8810 return -EINVAL;
8813 if (!rdev->ops->del_station)
8814 return -EOPNOTSUPP;
8816 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
8818 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
8821 return -EINVAL;
8827 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
8829 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8831 return -EINVAL; /* 0 is reserved */
8837 /* Link ID not expected in case of non-ML operation */
8838 if (!wdev->valid_links && link_id != -1)
8839 return -EINVAL;
8842 if (wdev->valid_links && link_id >= 0 &&
8843 !(wdev->valid_links & BIT(link_id)))
8844 return -EINVAL;
8861 return -1;
8863 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
8866 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
8872 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
8874 pinfo->frame_qlen))
8876 if (((pinfo->filled & MPATH_INFO_SN) &&
8877 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
8878 ((pinfo->filled & MPATH_INFO_METRIC) &&
8880 pinfo->metric)) ||
8881 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
8883 pinfo->exptime)) ||
8884 ((pinfo->filled & MPATH_INFO_FLAGS) &&
8886 pinfo->flags)) ||
8887 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
8889 pinfo->discovery_timeout)) ||
8890 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
8892 pinfo->discovery_retries)) ||
8893 ((pinfo->filled & MPATH_INFO_HOP_COUNT) &&
8895 pinfo->hop_count)) ||
8896 ((pinfo->filled & MPATH_INFO_PATH_CHANGE) &&
8898 pinfo->path_change_count)))
8908 return -EMSGSIZE;
8919 int path_idx = cb->args[2];
8926 __acquire(&rdev->wiphy.mtx);
8928 if (!rdev->ops->dump_mpath) {
8929 err = -EOPNOTSUPP;
8933 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
8934 err = -EOPNOTSUPP;
8939 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
8941 if (err == -ENOENT)
8946 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
8947 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8948 wdev->netdev, dst, next_hop,
8956 cb->args[2] = path_idx;
8957 err = skb->len;
8959 wiphy_unlock(&rdev->wiphy);
8965 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8967 struct net_device *dev = info->user_ptr[1];
8975 if (!info->attrs[NL80211_ATTR_MAC])
8976 return -EINVAL;
8978 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
8980 if (!rdev->ops->get_mpath)
8981 return -EOPNOTSUPP;
8983 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
8984 return -EOPNOTSUPP;
8992 return -ENOMEM;
8994 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
8997 return -ENOBUFS;
9005 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9006 struct net_device *dev = info->user_ptr[1];
9010 if (!info->attrs[NL80211_ATTR_MAC])
9011 return -EINVAL;
9013 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
9014 return -EINVAL;
9016 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
9017 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
9019 if (!rdev->ops->change_mpath)
9020 return -EOPNOTSUPP;
9022 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
9023 return -EOPNOTSUPP;
9030 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9031 struct net_device *dev = info->user_ptr[1];
9035 if (!info->attrs[NL80211_ATTR_MAC])
9036 return -EINVAL;
9038 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
9039 return -EINVAL;
9041 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
9042 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
9044 if (!rdev->ops->add_mpath)
9045 return -EOPNOTSUPP;
9047 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
9048 return -EOPNOTSUPP;
9055 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9056 struct net_device *dev = info->user_ptr[1];
9059 if (info->attrs[NL80211_ATTR_MAC])
9060 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
9062 if (!rdev->ops->del_mpath)
9063 return -EOPNOTSUPP;
9065 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
9066 return -EOPNOTSUPP;
9073 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9075 struct net_device *dev = info->user_ptr[1];
9083 if (!info->attrs[NL80211_ATTR_MAC])
9084 return -EINVAL;
9086 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
9088 if (!rdev->ops->get_mpp)
9089 return -EOPNOTSUPP;
9091 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
9092 return -EOPNOTSUPP;
9100 return -ENOMEM;
9102 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
9105 return -ENOBUFS;
9119 int path_idx = cb->args[2];
9126 __acquire(&rdev->wiphy.mtx);
9128 if (!rdev->ops->dump_mpp) {
9129 err = -EOPNOTSUPP;
9133 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
9134 err = -EOPNOTSUPP;
9139 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
9141 if (err == -ENOENT)
9146 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
9147 cb->nlh->nlmsg_seq, NLM_F_MULTI,
9148 wdev->netdev, dst, mpp,
9156 cb->args[2] = path_idx;
9157 err = skb->len;
9159 wiphy_unlock(&rdev->wiphy);
9165 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9166 struct net_device *dev = info->user_ptr[1];
9168 u32 bss_param_support = rdev->wiphy.bss_param_support;
9173 params.link_id = nl80211_link_id_or_invalid(info->attrs);
9175 params.use_cts_prot = -1;
9176 params.use_short_preamble = -1;
9177 params.use_short_slot_time = -1;
9178 params.ap_isolate = -1;
9179 params.ht_opmode = -1;
9180 params.p2p_ctwindow = -1;
9181 params.p2p_opp_ps = -1;
9183 strict = nla_get_flag(info->attrs[NL80211_ATTR_BSS_PARAM]);
9184 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT]) {
9186 return -EINVAL;
9188 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
9191 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]) {
9194 return -EINVAL;
9196 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
9199 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]) {
9202 return -EINVAL;
9204 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
9207 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9210 return -EINVAL;
9212 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9214 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9217 if (info->attrs[NL80211_ATTR_AP_ISOLATE]) {
9219 return -EINVAL;
9221 !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
9224 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE]) {
9226 return -EINVAL;
9228 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
9232 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
9233 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
9234 return -EINVAL;
9236 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
9239 return -EINVAL;
9243 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
9246 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
9247 return -EINVAL;
9248 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
9250 return -EINVAL;
9253 !(rdev->wiphy.bss_param_support & WIPHY_BSS_PARAM_P2P_OPPPS))
9254 return -EINVAL;
9257 if (!rdev->ops->change_bss)
9258 return -EOPNOTSUPP;
9260 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
9261 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
9262 return -EOPNOTSUPP;
9264 changed &= rdev->wiphy.bss_param_support;
9280 * completely when built-in to the kernel right between the time
9285 return -EINPROGRESS;
9288 nla_get_u32_default(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE],
9294 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
9295 return -EINVAL;
9297 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
9300 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9301 owner_nlportid = info->snd_portid;
9302 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
9311 return -EINVAL;
9323 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9324 struct net_device *dev = info->user_ptr[1];
9325 struct wireless_dev *wdev = dev->ieee80211_ptr;
9332 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
9333 return -EOPNOTSUPP;
9335 if (!rdev->ops->get_mesh_config)
9336 return -EOPNOTSUPP;
9339 if (!wdev->u.mesh.id_len)
9350 return -ENOMEM;
9351 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9358 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9429 return -ENOBUFS;
9464 NLA_POLICY_RANGE(NLA_S32, -255, 0),
9507 cfg->param = fn(tb[attr]); \
9508 mask |= BIT((attr) - 1); \
9512 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
9513 return -EINVAL;
9514 if (nla_parse_nested_deprecated(tb, NL80211_MESHCONF_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_CONFIG], nl80211_meshconf_params_policy, info->extack))
9515 return -EINVAL;
9553 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535))
9554 return -EINVAL;
9563 (cfg->dot11MeshHWMPactivePathTimeout < 1 ||
9564 cfg->dot11MeshHWMPactivePathTimeout > 65535))
9565 return -EINVAL;
9597 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
9605 return -EINVAL;
9610 cfg->ht_opmode = ht_opmode;
9611 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
9618 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 ||
9619 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535))
9620 return -EINVAL;
9647 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9650 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
9651 return -EINVAL;
9652 if (nla_parse_nested_deprecated(tb, NL80211_MESH_SETUP_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_SETUP], nl80211_mesh_setup_params_policy, info->extack))
9653 return -EINVAL;
9656 setup->sync_method =
9662 setup->path_sel_proto =
9668 setup->path_metric =
9676 setup->ie = nla_data(ieattr);
9677 setup->ie_len = nla_len(ieattr);
9680 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
9681 return -EINVAL;
9682 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
9683 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
9684 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
9685 if (setup->is_secure)
9686 setup->user_mpm = true;
9689 if (!setup->user_mpm)
9690 return -EINVAL;
9691 setup->auth_id =
9701 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9702 struct net_device *dev = info->user_ptr[1];
9703 struct wireless_dev *wdev = dev->ieee80211_ptr;
9708 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
9709 return -EOPNOTSUPP;
9711 if (!rdev->ops->update_mesh_config)
9712 return -EOPNOTSUPP;
9718 if (!wdev->u.mesh.id_len)
9719 err = -ENOLINK;
9733 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
9734 (regdom->dfs_region &&
9735 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
9742 for (i = 0; i < regdom->n_reg_rules; i++) {
9749 reg_rule = ®dom->reg_rules[i];
9750 freq_range = ®_rule->freq_range;
9751 power_rule = ®_rule->power_rule;
9757 max_bandwidth_khz = freq_range->max_bandwidth_khz;
9763 reg_rule->flags) ||
9765 freq_range->start_freq_khz) ||
9767 freq_range->end_freq_khz) ||
9771 power_rule->max_antenna_gain) ||
9773 power_rule->max_eirp) ||
9775 reg_rule->dfs_cac_ms))
9778 if ((reg_rule->flags & NL80211_RRF_PSD) &&
9780 reg_rule->psd))
9790 return -EMSGSIZE;
9799 int err = -EMSGSIZE;
9804 return -ENOBUFS;
9806 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9813 if (info->attrs[NL80211_ATTR_WIPHY]) {
9822 wiphy = &rdev->wiphy;
9823 self_managed = wiphy->regulatory_flags &
9830 /* a self-managed-reg device must have a private regdom */
9832 err = -EINVAL;
9873 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
9877 return -1;
9893 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
9902 return -EMSGSIZE;
9910 int err, reg_idx, start = cb->args[2];
9915 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
9925 regdom = get_wiphy_regdom(&rdev->wiphy);
9932 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
9933 NLM_F_MULTI, &rdev->wiphy, regdom);
9935 reg_idx--;
9940 cb->args[2] = reg_idx;
9941 err = skb->len;
9961 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
9962 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
9965 return -EINVAL;
9967 return -EINVAL;
9969 return -EINVAL;
9971 return -EINVAL;
9973 return -EINVAL;
9975 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
9977 freq_range->start_freq_khz =
9979 freq_range->end_freq_khz =
9981 freq_range->max_bandwidth_khz =
9984 power_rule->max_eirp =
9988 power_rule->max_antenna_gain =
9992 reg_rule->dfs_cac_ms =
10008 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
10009 return -EINVAL;
10011 if (!info->attrs[NL80211_ATTR_REG_RULES])
10012 return -EINVAL;
10014 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
10016 if (info->attrs[NL80211_ATTR_DFS_REGION])
10017 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
10019 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
10023 return -EINVAL;
10028 r = -EINVAL;
10034 r = -ENOMEM;
10038 rd->n_reg_rules = num_rules;
10039 rd->alpha2[0] = alpha2[0];
10040 rd->alpha2[1] = alpha2[1];
10047 rd->dfs_region = dfs_region;
10049 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
10053 info->extack);
10056 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
10063 r = -EINVAL;
10110 return b < NUM_NL80211_BANDS && wiphy->bands[b];
10125 return -EINVAL;
10137 return -EINVAL;
10142 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
10145 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
10148 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
10149 bss_select->param.band_pref =
10151 if (!is_band_valid(wiphy, bss_select->param.band_pref))
10152 return -EINVAL;
10159 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
10160 bss_select->param.adjust.band = adj_param->band;
10161 bss_select->param.adjust.delta = adj_param->delta;
10162 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
10163 return -EINVAL;
10166 /* user-space did not provide behaviour attribute */
10167 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
10168 return -EINVAL;
10170 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
10171 return -EINVAL;
10192 return -EINVAL;
10197 /* don't allow or configure an mcast address */
10200 return -EINVAL;
10220 lockdep_assert_wiphy(wdev->wiphy);
10228 radio_idx = cfg80211_get_radio_idx_by_chan(wdev->wiphy, chan);
10243 if (!chandef || !chandef->chan)
10246 if (!(chandef->chan->flags & IEEE80211_CHAN_RADAR))
10250 * chandef->chan is a radar channel. If the radio/link onto
10252 * which the input 'chan' falls, off-channel operation should
10256 link_radio_idx = cfg80211_get_radio_idx_by_chan(wdev->wiphy,
10257 chandef->chan);
10267 return regulatory_pre_cac_allowed(wdev->wiphy);
10291 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
10319 return -EOPNOTSUPP;
10324 if (!(wiphy->features & randomness_flag) ||
10325 (wdev && wdev->connected))
10326 return -EOPNOTSUPP;
10342 req->mac_addr, req->mac_addr_mask,
10343 &req->flags,
10354 req->req.mac_addr,
10355 req->req.mac_addr_mask,
10356 &req->req.flags,
10362 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10363 struct wireless_dev *wdev = info->user_ptr[1];
10373 wiphy = &rdev->wiphy;
10375 if (wdev->iftype == NL80211_IFTYPE_NAN)
10376 return -EOPNOTSUPP;
10378 if (!rdev->ops->scan)
10379 return -EOPNOTSUPP;
10381 if (rdev->scan_req || rdev->scan_msg)
10382 return -EBUSY;
10384 if (info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ]) {
10387 return -EOPNOTSUPP;
10388 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ];
10390 } else if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES])
10391 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQUENCIES];
10396 return -EINVAL;
10401 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
10402 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
10405 if (n_ssids > wiphy->max_scan_ssids)
10406 return -EINVAL;
10408 if (info->attrs[NL80211_ATTR_IE])
10409 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10413 if (ie_len > wiphy->max_scan_ie_len)
10414 return -EINVAL;
10418 size = size_add(size, array_size(sizeof(*request->req.ssids), n_ssids));
10423 return -ENOMEM;
10426 request->req.ssids = (void *)request + ssids_offset;
10427 request->req.n_ssids = n_ssids;
10429 request->req.ie = (void *)request + ie_offset;
10443 err = -EINVAL;
10448 if (chan->flags & IEEE80211_CHAN_DISABLED ||
10449 chan->flags & IEEE80211_CHAN_S1G_NO_PRIMARY ||
10453 request->req.channels[i] = chan;
10463 if (!wiphy->bands[band])
10465 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
10468 chan = &wiphy->bands[band]->channels[j];
10470 if (chan->flags & IEEE80211_CHAN_DISABLED ||
10471 chan->flags &
10476 request->req.channels[i] = chan;
10483 err = -EINVAL;
10487 request->req.n_channels = i;
10489 for (i = 0; i < request->req.n_channels; i++) {
10490 struct ieee80211_channel *chan = request->req.channels[i];
10492 /* if we can go off-channel to the target channel we're good */
10497 err = -EBUSY;
10504 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
10506 err = -EINVAL;
10509 request->req.ssids[i].ssid_len = nla_len(attr);
10510 memcpy(request->req.ssids[i].ssid,
10516 if (info->attrs[NL80211_ATTR_IE]) {
10517 request->req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10518 memcpy((void *)request->req.ie,
10519 nla_data(info->attrs[NL80211_ATTR_IE]),
10520 request->req.ie_len);
10524 if (wiphy->bands[i])
10525 request->req.rates[i] =
10526 (1 << wiphy->bands[i]->n_bitrates) - 1;
10528 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
10530 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
10535 err = -EINVAL;
10539 if (!wiphy->bands[band])
10542 err = ieee80211_get_ratemask(wiphy->bands[band],
10545 &request->req.rates[band]);
10551 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
10552 request->req.duration =
10553 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
10554 request->req.duration_mandatory =
10555 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
10558 err = nl80211_check_scan_flags_reg(wiphy, wdev, info->attrs, request);
10562 request->req.no_cck =
10563 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
10574 if (info->attrs[NL80211_ATTR_BSSID])
10575 memcpy(request->req.bssid,
10576 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
10577 else if (!(request->req.flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
10578 info->attrs[NL80211_ATTR_MAC])
10579 memcpy(request->req.bssid,
10580 nla_data(info->attrs[NL80211_ATTR_MAC]),
10583 eth_broadcast_addr(request->req.bssid);
10585 request->req.tsf_report_link_id =
10586 nl80211_link_id_or_invalid(info->attrs);
10587 request->req.wdev = wdev;
10588 request->req.wiphy = &rdev->wiphy;
10589 request->req.scan_start = jiffies;
10591 rdev->scan_req = request;
10598 dev_hold(wdev->netdev);
10603 rdev->scan_req = NULL;
10611 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10612 struct wireless_dev *wdev = info->user_ptr[1];
10614 if (!rdev->ops->abort_scan)
10615 return -EOPNOTSUPP;
10617 if (rdev->scan_msg)
10620 if (!rdev->scan_req)
10621 return -ENOENT;
10646 return -EINVAL;
10648 request->scan_plans[0].interval =
10650 if (!request->scan_plans[0].interval)
10651 return -EINVAL;
10653 if (request->scan_plans[0].interval >
10654 wiphy->max_sched_scan_plan_interval)
10655 request->scan_plans[0].interval =
10656 wiphy->max_sched_scan_plan_interval;
10665 return -EINVAL;
10675 return -EINVAL;
10677 request->scan_plans[i].interval =
10679 if (!request->scan_plans[i].interval ||
10680 request->scan_plans[i].interval >
10681 wiphy->max_sched_scan_plan_interval)
10682 return -EINVAL;
10685 request->scan_plans[i].iterations =
10687 if (!request->scan_plans[i].iterations ||
10688 (request->scan_plans[i].iterations >
10689 wiphy->max_sched_scan_plan_iterations))
10690 return -EINVAL;
10691 } else if (i < n_plans - 1) {
10696 return -EINVAL;
10706 if (request->scan_plans[n_plans - 1].iterations)
10707 return -EINVAL;
10728 return ERR_PTR(-EINVAL);
10738 if (n_ssids > wiphy->max_sched_scan_ssids)
10739 return ERR_PTR(-EINVAL);
10748 * global RSSI for all other matchsets - if there are other matchsets.
10767 return ERR_PTR(-EINVAL);
10786 return ERR_PTR(-EINVAL);
10793 if (ie_len > wiphy->max_sched_scan_ie_len)
10794 return ERR_PTR(-EINVAL);
10802 return ERR_PTR(-EINVAL);
10815 return ERR_PTR(-EINVAL);
10820 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
10821 return ERR_PTR(-EINVAL);
10827 return ERR_PTR(-EINVAL);
10830 size = size_add(size, array_size(sizeof(*request->ssids), n_ssids));
10831 size = size_add(size, array_size(sizeof(*request->match_sets),
10833 size = size_add(size, array_size(sizeof(*request->scan_plans),
10838 return ERR_PTR(-ENOMEM);
10839 request->n_channels = n_channels;
10842 request->ssids = (void *)request +
10844 request->n_ssids = n_ssids;
10847 request->ie = (void *)(request->ssids + n_ssids);
10849 request->ie = (void *)(request->channels + n_channels);
10853 if (request->ie)
10854 request->match_sets = (void *)(request->ie + ie_len);
10856 request->match_sets =
10857 (void *)(request->ssids + n_ssids);
10859 request->match_sets =
10860 (void *)(request->channels + n_channels);
10862 request->n_match_sets = n_match_sets;
10865 request->scan_plans = (void *)(request->match_sets +
10867 else if (request->ie)
10868 request->scan_plans = (void *)(request->ie + ie_len);
10870 request->scan_plans = (void *)(request->ssids + n_ssids);
10872 request->scan_plans = (void *)(request->channels + n_channels);
10874 request->n_scan_plans = n_plans;
10887 err = -EINVAL;
10892 if (chan->flags & IEEE80211_CHAN_DISABLED)
10895 request->channels[i] = chan;
10903 if (!wiphy->bands[band])
10905 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
10908 chan = &wiphy->bands[band]->channels[j];
10910 if (chan->flags & IEEE80211_CHAN_DISABLED)
10913 request->channels[i] = chan;
10920 err = -EINVAL;
10924 request->n_channels = i;
10931 err = -EINVAL;
10934 request->ssids[i].ssid_len = nla_len(attr);
10935 memcpy(request->ssids[i].ssid, nla_data(attr),
10968 err = -EINVAL;
10973 memcpy(request->match_sets[i].ssid.ssid,
10975 request->match_sets[i].ssid.ssid_len =
10979 memcpy(request->match_sets[i].bssid,
10982 /* special attribute - old implementation w/a */
10983 request->match_sets[i].rssi_thold = default_match_rssi;
10986 request->match_sets[i].rssi_thold =
10993 request->match_sets[0].rssi_thold = default_match_rssi;
10995 request->min_rssi_thold = INT_MAX;
10997 request->min_rssi_thold =
10998 min(request->match_sets[i].rssi_thold,
10999 request->min_rssi_thold);
11001 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
11005 request->ie_len = ie_len;
11006 memcpy((void *)request->ie,
11008 request->ie_len);
11016 request->delay =
11020 request->relative_rssi = nla_get_s8(
11022 request->relative_rssi_set = true;
11025 if (request->relative_rssi_set &&
11031 request->rssi_adjust.band = rssi_adjust->band;
11032 request->rssi_adjust.delta = rssi_adjust->delta;
11033 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
11034 err = -EINVAL;
11043 request->scan_start = jiffies;
11055 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11056 struct net_device *dev = info->user_ptr[1];
11057 struct wireless_dev *wdev = dev->ieee80211_ptr;
11062 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
11063 return -EOPNOTSUPP;
11065 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
11070 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
11071 info->attrs,
11072 rdev->wiphy.max_match_sets);
11079 * or if driver does not support multi-scheduled scan
11081 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1)
11082 sched_scan_req->reqid = cfg80211_assign_cookie(rdev);
11088 sched_scan_req->dev = dev;
11089 sched_scan_req->wiphy = &rdev->wiphy;
11091 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
11092 sched_scan_req->owner_nlportid = info->snd_portid;
11109 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11112 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
11113 return -EOPNOTSUPP;
11115 if (info->attrs[NL80211_ATTR_COOKIE]) {
11116 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
11120 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
11123 if (!req || req->reqid ||
11124 (req->owner_nlportid &&
11125 req->owner_nlportid != info->snd_portid))
11126 return -ENOENT;
11134 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11135 struct net_device *dev = info->user_ptr[1];
11136 struct wireless_dev *wdev = dev->ieee80211_ptr;
11137 int link_id = nl80211_link_id(info->attrs);
11138 struct wiphy *wiphy = wdev->wiphy;
11144 flush_delayed_work(&rdev->dfs_update_channels_wk);
11146 switch (wdev->iftype) {
11153 /* caution - see cfg80211_beaconing_iface_active() below */
11154 return -EINVAL;
11161 return -EINVAL;
11167 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
11172 return -EINVAL;
11175 return -EINVAL;
11177 if (nla_get_flag(info->attrs[NL80211_ATTR_RADAR_BACKGROUND]))
11185 if (wdev->valid_links &&
11186 !wdev->links[link_id].ap.beacon_interval) {
11189 return -EBUSY;
11193 if (wdev->links[link_id].cac_started)
11194 return -EBUSY;
11198 return -EOPNOTSUPP;
11200 if (!rdev->ops->start_radar_detection)
11201 return -EOPNOTSUPP;
11203 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
11212 switch (wdev->iftype) {
11215 wdev->links[link_id].ap.chandef = chandef;
11218 wdev->u.ibss.chandef = chandef;
11221 wdev->u.mesh.chandef = chandef;
11226 wdev->links[link_id].cac_started = true;
11227 wdev->links[link_id].cac_start_time = jiffies;
11228 wdev->links[link_id].cac_time_ms = cac_time_ms;
11236 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11237 struct net_device *dev = info->user_ptr[1];
11238 struct wireless_dev *wdev = dev->ieee80211_ptr;
11239 struct wiphy *wiphy = wdev->wiphy;
11248 return -EINVAL;
11257 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
11266 return -EINVAL;
11272 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE)
11279 rdev->radar_chandef = chandef;
11282 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
11300 return -EINVAL;
11303 if (rdev->wiphy.max_num_csa_counters &&
11304 (*n_offsets > rdev->wiphy.max_num_csa_counters))
11305 return -EINVAL;
11309 /* sanity checks - counters should fit and be the same */
11314 return -EINVAL;
11316 if (first_count != -1 && data[offset] != first_count)
11317 return -EINVAL;
11325 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11326 unsigned int link_id = nl80211_link_id(info->attrs);
11327 struct net_device *dev = info->user_ptr[1];
11328 struct wireless_dev *wdev = dev->ieee80211_ptr;
11336 if (!rdev->ops->channel_switch ||
11337 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
11338 return -EOPNOTSUPP;
11340 switch (dev->ieee80211_ptr->iftype) {
11352 if (!wdev->links[link_id].ap.beacon_interval)
11353 return -ENOTCONN;
11356 if (!wdev->u.ibss.ssid_len)
11357 return -ENOTCONN;
11360 if (!wdev->u.mesh.id_len)
11361 return -ENOTCONN;
11364 return -EOPNOTSUPP;
11368 params.beacon_csa.ftm_responder = -1;
11370 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
11371 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
11372 return -EINVAL;
11375 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
11376 return -EINVAL;
11381 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
11383 return -EINVAL;
11390 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after,
11391 info->extack);
11398 err = -ENOMEM;
11403 info->attrs[NL80211_ATTR_CSA_IES],
11404 nl80211_policy, info->extack);
11409 info->extack);
11414 err = -EINVAL;
11441 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
11442 wdev->iftype)) {
11443 err = -EINVAL;
11447 err = cfg80211_chandef_dfs_required(wdev->wiphy,
11449 wdev->iftype);
11456 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
11457 err = -EINVAL;
11462 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
11465 if ((wdev->iftype == NL80211_IFTYPE_AP ||
11466 wdev->iftype == NL80211_IFTYPE_P2P_GO) &&
11467 info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP]) {
11469 rdev, info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP],
11493 struct cfg80211_bss *res = &intbss->pub;
11499 lockdep_assert_wiphy(wdev->wiphy);
11501 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
11504 return -1;
11508 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
11510 if (wdev->netdev &&
11511 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
11520 if ((!is_zero_ether_addr(res->bssid) &&
11521 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
11526 if (rcu_access_pointer(res->proberesp_ies) &&
11533 ies = rcu_dereference(res->ies);
11535 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
11538 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
11539 ies->len, ies->data))
11544 ies = rcu_dereference(res->beacon_ies);
11545 if (ies && ies->from_beacon) {
11546 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
11549 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
11550 ies->len, ies->data))
11555 if (res->beacon_interval &&
11556 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
11558 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
11559 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
11561 res->channel->freq_offset) ||
11563 jiffies_to_msecs(jiffies - intbss->ts)))
11566 if (intbss->parent_tsf &&
11568 intbss->parent_tsf, NL80211_BSS_PAD) ||
11570 intbss->parent_bssid)))
11573 if (res->ts_boottime &&
11575 res->ts_boottime, NL80211_BSS_PAD))
11578 if (!nl80211_put_signal(msg, intbss->pub.chains,
11579 intbss->pub.chain_signal,
11583 if (intbss->bss_source != BSS_SOURCE_STA_PROFILE) {
11584 switch (rdev->wiphy.signal_type) {
11587 res->signal))
11592 res->signal))
11600 switch (wdev->iftype) {
11604 if (intbss == wdev->links[link_id].client.current_bss &&
11607 (wdev->valid_links &&
11611 wdev->u.client.connected_addr)))))
11616 if (intbss == wdev->u.ibss.current_bss &&
11625 if (nla_put_u32(msg, NL80211_BSS_USE_FOR, res->use_for))
11628 if (res->cannot_use_reasons &&
11630 res->cannot_use_reasons,
11643 return -EMSGSIZE;
11652 int start = cb->args[2], idx = 0;
11658 return -ENOMEM;
11666 __acquire(&rdev->wiphy.mtx);
11672 spin_lock_bh(&rdev->bss_lock);
11676 * into multiple messages. It is unlikely that any more bss-es will be
11683 cb->seq = rdev->bss_generation;
11685 list_for_each_entry(scan, &rdev->bss_list, list) {
11689 !(scan->pub.use_for & NL80211_BSS_USE_FOR_NORMAL))
11692 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11694 idx--;
11699 spin_unlock_bh(&rdev->bss_lock);
11701 cb->args[2] = idx;
11702 wiphy_unlock(&rdev->wiphy);
11704 return skb->len;
11716 if (!survey->channel && !allow_radio_stats)
11722 return -ENOMEM;
11724 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
11731 if (survey->channel &&
11733 survey->channel->center_freq))
11736 if (survey->channel && survey->channel->freq_offset &&
11738 survey->channel->freq_offset))
11741 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
11742 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
11744 if ((survey->filled & SURVEY_INFO_IN_USE) &&
11747 if ((survey->filled & SURVEY_INFO_TIME) &&
11749 survey->time, NL80211_SURVEY_INFO_PAD))
11751 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
11753 survey->time_busy, NL80211_SURVEY_INFO_PAD))
11755 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
11757 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
11759 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
11761 survey->time_rx, NL80211_SURVEY_INFO_PAD))
11763 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
11765 survey->time_tx, NL80211_SURVEY_INFO_PAD))
11767 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
11769 survey->time_scan, NL80211_SURVEY_INFO_PAD))
11771 if ((survey->filled & SURVEY_INFO_TIME_BSS_RX) &&
11773 survey->time_bss_rx, NL80211_SURVEY_INFO_PAD))
11783 return -EMSGSIZE;
11792 int survey_idx = cb->args[2];
11798 return -ENOMEM;
11806 __acquire(&rdev->wiphy.mtx);
11811 if (!wdev->netdev) {
11812 res = -EINVAL;
11816 if (!rdev->ops->dump_survey) {
11817 res = -EOPNOTSUPP;
11822 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
11823 if (res == -ENOENT)
11828 /* don't send disabled channels, but do send non-channel data */
11830 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
11836 NETLINK_CB(cb->skb).portid,
11837 cb->nlh->nlmsg_seq, NLM_F_MULTI,
11838 wdev->netdev, radio_stats, &survey) < 0)
11844 cb->args[2] = survey_idx;
11845 res = skb->len;
11848 wiphy_unlock(&rdev->wiphy);
11854 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11855 struct net_device *dev = info->user_ptr[1];
11865 if (!info->attrs[NL80211_ATTR_MAC])
11866 return -EINVAL;
11868 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
11869 return -EINVAL;
11871 if (!info->attrs[NL80211_ATTR_SSID])
11872 return -EINVAL;
11874 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
11875 return -EINVAL;
11882 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
11883 return -EINVAL;
11885 return -EINVAL;
11890 return -EINVAL;
11892 return -EINVAL;
11902 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
11903 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
11909 return -EINVAL;
11912 if (!rdev->ops->auth)
11913 return -EOPNOTSUPP;
11915 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
11916 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
11917 return -EOPNOTSUPP;
11919 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
11920 freq = MHZ_TO_KHZ(nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
11921 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
11923 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
11925 chan = nl80211_get_valid_chan(&rdev->wiphy, freq);
11927 return -EINVAL;
11929 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
11930 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
11932 if (info->attrs[NL80211_ATTR_IE]) {
11933 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
11934 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
11937 if (info->attrs[NL80211_ATTR_SUPPORTED_SELECTORS]) {
11939 nla_data(info->attrs[NL80211_ATTR_SUPPORTED_SELECTORS]);
11941 nla_len(info->attrs[NL80211_ATTR_SUPPORTED_SELECTORS]);
11944 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
11946 return -EINVAL;
11952 !info->attrs[NL80211_ATTR_AUTH_DATA])
11953 return -EINVAL;
11955 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
11960 return -EINVAL;
11961 req.auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
11962 req.auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
11965 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
11978 req.link_id = nl80211_link_id_or_invalid(info->attrs);
11980 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO))
11981 return -EINVAL;
11982 if (!info->attrs[NL80211_ATTR_MLD_ADDR])
11983 return -EINVAL;
11984 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
11986 return -EINVAL;
11989 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len,
11993 return -ENOENT;
11997 cfg80211_put_bss(&rdev->wiphy, req.bss);
12005 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
12007 return -EINVAL;
12010 if (!rdev->ops->tx_control_port ||
12011 !wiphy_ext_feature_isset(&rdev->wiphy,
12013 return -EOPNOTSUPP;
12025 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
12027 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
12031 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
12032 settings->control_port_ethertype = cpu_to_be16(proto);
12033 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
12035 return -EINVAL;
12036 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
12037 settings->control_port_no_encrypt = true;
12039 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
12041 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
12047 settings->control_port_over_nl80211 = true;
12049 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_PREAUTH])
12050 settings->control_port_no_preauth = true;
12053 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
12057 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
12058 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
12059 settings->n_ciphers_pairwise = len / sizeof(u32);
12062 return -EINVAL;
12064 if (settings->n_ciphers_pairwise > cipher_limit)
12065 return -EINVAL;
12067 memcpy(settings->ciphers_pairwise, data, len);
12069 for (i = 0; i < settings->n_ciphers_pairwise; i++)
12071 &rdev->wiphy,
12072 settings->ciphers_pairwise[i]))
12073 return -EINVAL;
12076 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
12077 settings->cipher_group =
12078 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
12079 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
12080 settings->cipher_group))
12081 return -EINVAL;
12084 if (info->attrs[NL80211_ATTR_WPA_VERSIONS])
12085 settings->wpa_versions =
12086 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
12088 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
12092 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
12093 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
12094 settings->n_akm_suites = len / sizeof(u32);
12097 return -EINVAL;
12099 if (settings->n_akm_suites > rdev->wiphy.max_num_akm_suites)
12100 return -EINVAL;
12102 memcpy(settings->akm_suites, data, len);
12105 if (info->attrs[NL80211_ATTR_PMK]) {
12106 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
12107 return -EINVAL;
12108 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12110 !wiphy_ext_feature_isset(&rdev->wiphy,
12112 return -EINVAL;
12113 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
12116 if (info->attrs[NL80211_ATTR_SAE_PASSWORD]) {
12117 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12119 !wiphy_ext_feature_isset(&rdev->wiphy,
12121 return -EINVAL;
12122 settings->sae_pwd =
12123 nla_data(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
12124 settings->sae_pwd_len =
12125 nla_len(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
12128 settings->sae_pwe =
12129 nla_get_u8_default(info->attrs[NL80211_ATTR_SAE_PWE],
12146 return ERR_PTR(-EINVAL);
12154 chan = nl80211_get_valid_chan(&rdev->wiphy, freq);
12156 return ERR_PTR(-EINVAL);
12163 bss = __cfg80211_get_bss(&rdev->wiphy, chan, bssid,
12169 return ERR_PTR(-ENOENT);
12187 return -ENOMEM;
12189 nla_for_each_nested(link, info->attrs[NL80211_ATTR_MLO_LINKS], rem) {
12195 NL_SET_BAD_ATTR(info->extack, link);
12196 return -EINVAL;
12202 NL_SET_BAD_ATTR(info->extack, link);
12203 return -EINVAL;
12211 NL_SET_ERR_MSG_ATTR(info->extack, link,
12224 NL_SET_ERR_MSG_ATTR(info->extack,
12227 return -EINVAL;
12233 NL_SET_ERR_MSG_ATTR(info->extack,
12235 "cannot deal with non-inheritance");
12236 return -EINVAL;
12249 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12250 struct net_device *dev = info->user_ptr[1];
12256 if (dev->ieee80211_ptr->conn_owner_nlportid &&
12257 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
12258 return -EPERM;
12260 if (!info->attrs[NL80211_ATTR_SSID])
12261 return -EINVAL;
12263 if (!rdev->ops->assoc)
12264 return -EOPNOTSUPP;
12266 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
12267 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
12268 return -EOPNOTSUPP;
12270 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
12271 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
12273 if (info->attrs[NL80211_ATTR_IE]) {
12274 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12275 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12279 NL_SET_ERR_MSG_ATTR(info->extack,
12280 info->attrs[NL80211_ATTR_IE],
12281 "non-inheritance makes no sense");
12282 return -EINVAL;
12286 if (info->attrs[NL80211_ATTR_USE_MFP]) {
12288 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
12292 return -EINVAL;
12295 if (info->attrs[NL80211_ATTR_PREV_BSSID])
12296 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
12298 if (info->attrs[NL80211_ATTR_SUPPORTED_SELECTORS]) {
12300 nla_data(info->attrs[NL80211_ATTR_SUPPORTED_SELECTORS]);
12302 nla_len(info->attrs[NL80211_ATTR_SUPPORTED_SELECTORS]);
12305 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
12308 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
12310 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
12313 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
12314 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
12315 return -EINVAL;
12317 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
12321 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
12324 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE]))
12327 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_EHT]))
12330 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
12332 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
12335 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
12336 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
12337 return -EINVAL;
12339 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
12343 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
12344 if (!((rdev->wiphy.features &
12346 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
12347 !wiphy_ext_feature_isset(&rdev->wiphy,
12349 return -EINVAL;
12353 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
12354 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
12355 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
12356 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
12357 return -EINVAL;
12359 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
12362 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]) {
12363 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY])
12364 return -EINVAL;
12366 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]),
12370 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY]) {
12371 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK])
12372 return -EINVAL;
12374 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY]),
12378 if (nla_get_flag(info->attrs[NL80211_ATTR_ASSOC_SPP_AMSDU])) {
12379 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12381 GENL_SET_ERR_MSG(info, "SPP A-MSDUs not supported");
12382 return -EINVAL;
12387 req.link_id = nl80211_link_id_or_invalid(info->attrs);
12389 if (info->attrs[NL80211_ATTR_MLO_LINKS]) {
12391 return -EINVAL;
12393 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO))
12394 return -EINVAL;
12396 if (info->attrs[NL80211_ATTR_MAC] ||
12397 info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
12398 !info->attrs[NL80211_ATTR_MLD_ADDR])
12399 return -EINVAL;
12401 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
12410 err = -EINVAL;
12416 "cannot have per-link elems on assoc link");
12417 err = -EINVAL;
12424 err = -EINVAL;
12428 if (info->attrs[NL80211_ATTR_ASSOC_MLD_EXT_CAPA_OPS])
12430 nla_get_u16(info->attrs[NL80211_ATTR_ASSOC_MLD_EXT_CAPA_OPS]);
12433 return -EINVAL;
12435 req.bss = nl80211_assoc_bss(rdev, ssid, ssid_len, info->attrs,
12436 -1, -1);
12439 ap_addr = req.bss->bssid;
12441 if (info->attrs[NL80211_ATTR_ASSOC_MLD_EXT_CAPA_OPS])
12442 return -EINVAL;
12451 info->extack);
12453 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
12454 dev->ieee80211_ptr->conn_owner_nlportid =
12455 info->snd_portid;
12456 memcpy(dev->ieee80211_ptr->disconnect_bssid,
12461 if (info->attrs[NL80211_ATTR_MLO_LINKS]) {
12463 info->attrs[NL80211_ATTR_MLO_LINKS],
12482 NL_SET_BAD_ATTR(info->extack, link);
12491 cfg80211_put_bss(&rdev->wiphy, req.links[link_id].bss);
12492 cfg80211_put_bss(&rdev->wiphy, req.bss);
12499 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12500 struct net_device *dev = info->user_ptr[1];
12506 if (dev->ieee80211_ptr->conn_owner_nlportid &&
12507 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
12508 return -EPERM;
12510 if (!info->attrs[NL80211_ATTR_MAC])
12511 return -EINVAL;
12513 if (!info->attrs[NL80211_ATTR_REASON_CODE])
12514 return -EINVAL;
12516 if (!rdev->ops->deauth)
12517 return -EOPNOTSUPP;
12519 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
12520 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
12521 return -EOPNOTSUPP;
12523 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
12525 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
12528 return -EINVAL;
12531 if (info->attrs[NL80211_ATTR_IE]) {
12532 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12533 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12536 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
12544 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12545 struct net_device *dev = info->user_ptr[1];
12551 if (dev->ieee80211_ptr->conn_owner_nlportid &&
12552 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
12553 return -EPERM;
12555 if (!info->attrs[NL80211_ATTR_MAC])
12556 return -EINVAL;
12558 if (!info->attrs[NL80211_ATTR_REASON_CODE])
12559 return -EINVAL;
12561 if (!rdev->ops->disassoc)
12562 return -EOPNOTSUPP;
12564 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
12565 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
12566 return -EOPNOTSUPP;
12568 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
12570 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
12573 return -EINVAL;
12576 if (info->attrs[NL80211_ATTR_IE]) {
12577 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12578 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12581 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
12592 struct wiphy *wiphy = &rdev->wiphy;
12599 sband = wiphy->bands[band];
12603 for (i = 0; i < sband->n_bitrates; i++) {
12604 if (sband->bitrates[i].bitrate == rateval) {
12617 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12618 struct net_device *dev = info->user_ptr[1];
12626 if (!info->attrs[NL80211_ATTR_SSID] ||
12627 !nla_len(info->attrs[NL80211_ATTR_SSID]))
12628 return -EINVAL;
12632 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
12634 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
12641 if (!rdev->ops->join_ibss)
12642 return -EOPNOTSUPP;
12644 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
12645 return -EOPNOTSUPP;
12647 wiphy = &rdev->wiphy;
12649 if (info->attrs[NL80211_ATTR_MAC]) {
12650 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
12653 return -EINVAL;
12655 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
12656 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
12658 if (info->attrs[NL80211_ATTR_IE]) {
12659 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12660 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12667 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
12669 return -EINVAL;
12678 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
12679 return -EINVAL;
12684 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
12685 return -EINVAL;
12686 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12688 return -EINVAL;
12691 return -EINVAL;
12693 return -EINVAL;
12696 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
12697 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
12699 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
12701 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
12703 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
12705 wiphy->bands[ibss.chandef.chan->band];
12713 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
12715 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
12718 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
12719 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
12720 return -EINVAL;
12722 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
12726 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
12728 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
12729 return -EINVAL;
12731 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
12741 return -EINVAL;
12746 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
12748 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
12760 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
12765 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
12766 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
12773 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12774 struct net_device *dev = info->user_ptr[1];
12776 if (!rdev->ops->leave_ibss)
12777 return -EOPNOTSUPP;
12779 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
12780 return -EOPNOTSUPP;
12787 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12788 struct net_device *dev = info->user_ptr[1];
12792 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
12793 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
12794 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
12795 return -EOPNOTSUPP;
12797 if (!rdev->ops->set_mcast_rate)
12798 return -EOPNOTSUPP;
12802 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
12803 return -EINVAL;
12805 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
12807 return -EINVAL;
12834 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
12839 info->vendor_id))
12842 info->subcmd))
12850 if (wdev->netdev &&
12852 wdev->netdev->ifindex))
12860 ((void **)skb->cb)[0] = rdev;
12861 ((void **)skb->cb)[1] = hdr;
12862 ((void **)skb->cb)[2] = data;
12884 if (WARN_ON(vendor_event_idx != -1))
12890 vendor_event_idx >= wiphy->n_vendor_events))
12892 info = &wiphy->vendor_events[vendor_event_idx];
12906 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
12907 void *hdr = ((void **)skb->cb)[1];
12909 struct nlattr *data = ((void **)skb->cb)[2];
12913 memset(skb->cb, 0, sizeof(skb->cb));
12918 if (nlhdr->nlmsg_pid) {
12919 genlmsg_unicast(wiphy_net(&rdev->wiphy), skb,
12920 nlhdr->nlmsg_pid);
12922 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
12925 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12934 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12938 lockdep_assert_held(&rdev->wiphy.mtx);
12941 info->attrs);
12943 if (!rdev->ops->testmode_cmd)
12944 return -EOPNOTSUPP;
12948 if (err != -EINVAL)
12951 } else if (wdev->wiphy != &rdev->wiphy) {
12952 return -EINVAL;
12955 if (!info->attrs[NL80211_ATTR_TESTDATA])
12956 return -EINVAL;
12958 rdev->cur_cmd_info = info;
12960 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
12961 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
12962 rdev->cur_cmd_info = NULL;
12979 if (cb->args[0]) {
12984 phy_idx = cb->args[0] - 1;
12988 err = -ENOENT;
12995 err = -ENOMEM;
12999 err = nlmsg_parse_deprecated(cb->nlh,
13006 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
13011 phy_idx = rdev->wiphy_idx;
13014 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
13017 if (cb->args[1]) {
13018 data = nla_data((void *)cb->args[1]);
13019 data_len = nla_len((void *)cb->args[1]);
13022 if (!rdev->ops->testmode_dump) {
13023 err = -EOPNOTSUPP;
13028 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
13029 cb->nlh->nlmsg_seq, NLM_F_MULTI,
13049 if (err == -ENOBUFS || err == -ENOENT) {
13060 err = skb->len;
13062 cb->args[0] = phy_idx + 1;
13072 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13073 struct net_device *dev = info->user_ptr[1];
13082 if (!info->attrs[NL80211_ATTR_SSID] ||
13083 !nla_len(info->attrs[NL80211_ATTR_SSID]))
13084 return -EINVAL;
13086 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
13088 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
13091 return -EINVAL;
13095 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
13097 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
13098 !wiphy_ext_feature_isset(&rdev->wiphy,
13100 return -EINVAL;
13101 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
13108 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
13109 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
13110 return -EOPNOTSUPP;
13112 wiphy = &rdev->wiphy;
13114 connect.bg_scan_period = -1;
13115 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
13116 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
13118 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
13121 if (info->attrs[NL80211_ATTR_MAC])
13122 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
13123 else if (info->attrs[NL80211_ATTR_MAC_HINT])
13125 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
13126 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
13127 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
13129 if (info->attrs[NL80211_ATTR_IE]) {
13130 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
13131 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
13134 if (info->attrs[NL80211_ATTR_USE_MFP]) {
13135 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
13137 !wiphy_ext_feature_isset(&rdev->wiphy,
13139 return -EOPNOTSUPP;
13144 if (info->attrs[NL80211_ATTR_PREV_BSSID])
13146 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
13148 if (info->attrs[NL80211_ATTR_WIPHY_FREQ])
13150 info->attrs[NL80211_ATTR_WIPHY_FREQ]));
13151 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET])
13153 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]);
13158 return -EINVAL;
13159 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
13160 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
13164 return -EINVAL;
13167 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
13169 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
13171 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
13173 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
13176 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
13182 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
13185 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
13187 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
13190 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
13191 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
13193 return -EINVAL;
13196 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
13200 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
13203 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE]))
13206 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_EHT]))
13209 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
13211 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
13214 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
13215 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
13217 return -EINVAL;
13220 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
13224 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
13225 if (!((rdev->wiphy.features &
13227 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
13228 !wiphy_ext_feature_isset(&rdev->wiphy,
13231 return -EINVAL;
13236 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
13237 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
13239 return -EOPNOTSUPP;
13242 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
13246 return -EINVAL;
13249 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
13257 if (wiphy_ext_feature_isset(&rdev->wiphy,
13259 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
13260 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
13261 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
13262 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
13264 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
13266 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
13268 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
13270 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
13273 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
13275 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
13277 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
13278 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
13279 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
13280 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
13281 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
13283 return -EINVAL;
13286 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
13287 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
13291 return -EINVAL;
13296 if (nla_get_flag(info->attrs[NL80211_ATTR_MLO_SUPPORT]))
13304 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
13305 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
13307 memcpy(dev->ieee80211_ptr->disconnect_bssid,
13310 eth_zero_addr(dev->ieee80211_ptr->disconnect_bssid);
13320 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13321 struct net_device *dev = info->user_ptr[1];
13322 struct wireless_dev *wdev = dev->ieee80211_ptr;
13327 if (!rdev->ops->update_connect_params)
13328 return -EOPNOTSUPP;
13330 if (info->attrs[NL80211_ATTR_IE]) {
13331 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
13332 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
13336 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy,
13340 * when driver supports fils-sk offload all attributes must be
13341 * provided. So the else covers "fils-sk-not-all" and
13342 * "no-fils-sk-any".
13345 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
13346 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
13347 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
13348 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
13350 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
13352 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
13354 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
13356 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
13359 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
13361 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
13363 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
13365 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
13366 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
13367 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
13368 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
13369 return -EINVAL;
13372 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
13373 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
13376 return -EINVAL;
13380 return -EINVAL;
13386 if (!wdev->connected)
13387 return -ENOLINK;
13394 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13395 struct net_device *dev = info->user_ptr[1];
13398 if (dev->ieee80211_ptr->conn_owner_nlportid &&
13399 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
13400 return -EPERM;
13402 reason = nla_get_u16_default(info->attrs[NL80211_ATTR_REASON_CODE],
13406 return -EINVAL;
13408 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
13409 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
13410 return -EOPNOTSUPP;
13417 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13421 if (info->attrs[NL80211_ATTR_PID]) {
13422 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
13425 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
13426 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
13430 return -EINVAL;
13439 if (!net_eq(wiphy_net(&rdev->wiphy), net))
13448 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13449 struct net_device *dev = info->user_ptr[1];
13455 ap_pmksa_caching_support = wiphy_ext_feature_isset(&rdev->wiphy,
13458 if (!info->attrs[NL80211_ATTR_PMKID])
13459 return -EINVAL;
13461 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
13463 if (info->attrs[NL80211_ATTR_MAC]) {
13464 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
13465 } else if (info->attrs[NL80211_ATTR_SSID] &&
13466 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
13467 info->attrs[NL80211_ATTR_PMK]) {
13468 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
13469 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
13470 pmksa.cache_id = nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
13472 return -EINVAL;
13475 if (info->attrs[NL80211_ATTR_PMK]) {
13476 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
13477 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
13480 if (info->attrs[NL80211_ATTR_PMK_LIFETIME])
13482 nla_get_u32(info->attrs[NL80211_ATTR_PMK_LIFETIME]);
13484 if (info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD])
13486 nla_get_u8(info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD]);
13488 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
13489 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
13490 !((dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP ||
13491 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO) &&
13493 return -EOPNOTSUPP;
13495 if (!rdev->ops->set_pmksa)
13496 return -EOPNOTSUPP;
13503 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13504 struct net_device *dev = info->user_ptr[1];
13512 sae_offload_support = wiphy_ext_feature_isset(&rdev->wiphy,
13514 owe_offload_support = wiphy_ext_feature_isset(&rdev->wiphy,
13516 ap_pmksa_caching_support = wiphy_ext_feature_isset(&rdev->wiphy,
13519 if (info->attrs[NL80211_ATTR_PMKID])
13520 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
13522 if (info->attrs[NL80211_ATTR_MAC]) {
13523 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
13524 } else if (info->attrs[NL80211_ATTR_SSID]) {
13528 if (info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
13529 info->attrs[NL80211_ATTR_PMK]) {
13530 pmksa.cache_id = nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
13532 return -EINVAL;
13534 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
13535 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
13537 return -EINVAL;
13540 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
13541 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
13542 !((dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP ||
13543 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO) &&
13545 return -EOPNOTSUPP;
13547 if (!rdev->ops->del_pmksa)
13548 return -EOPNOTSUPP;
13555 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13556 struct net_device *dev = info->user_ptr[1];
13558 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
13559 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
13560 return -EOPNOTSUPP;
13562 if (!rdev->ops->flush_pmksa)
13563 return -EOPNOTSUPP;
13570 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13571 struct net_device *dev = info->user_ptr[1];
13579 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
13580 !rdev->ops->tdls_mgmt)
13581 return -EOPNOTSUPP;
13583 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
13584 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
13585 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
13586 !info->attrs[NL80211_ATTR_IE] ||
13587 !info->attrs[NL80211_ATTR_MAC])
13588 return -EINVAL;
13590 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
13591 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
13592 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
13593 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
13594 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
13595 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
13597 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
13598 link_id = nl80211_link_id_or_invalid(info->attrs);
13603 nla_data(info->attrs[NL80211_ATTR_IE]),
13604 nla_len(info->attrs[NL80211_ATTR_IE]));
13609 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13610 struct net_device *dev = info->user_ptr[1];
13614 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
13615 !rdev->ops->tdls_oper)
13616 return -EOPNOTSUPP;
13618 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
13619 !info->attrs[NL80211_ATTR_MAC])
13620 return -EINVAL;
13622 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
13623 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
13631 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13632 unsigned int link_id = nl80211_link_id(info->attrs);
13633 struct wireless_dev *wdev = info->user_ptr[1];
13641 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
13642 !info->attrs[NL80211_ATTR_DURATION])
13643 return -EINVAL;
13645 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
13647 if (!rdev->ops->remain_on_channel ||
13648 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
13649 return -EOPNOTSUPP;
13656 duration > rdev->wiphy.max_remain_on_channel_duration)
13657 return -EINVAL;
13671 return -EBUSY;
13679 return -EBUSY;
13684 return -ENOMEM;
13686 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13689 err = -ENOBUFS;
13708 err = -ENOBUFS;
13717 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13718 struct wireless_dev *wdev = info->user_ptr[1];
13721 if (!info->attrs[NL80211_ATTR_COOKIE])
13722 return -EINVAL;
13724 if (!rdev->ops->cancel_remain_on_channel)
13725 return -EOPNOTSUPP;
13727 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
13736 unsigned int link_id = nl80211_link_id(info->attrs);
13737 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13738 struct net_device *dev = info->user_ptr[1];
13741 if (!rdev->ops->set_bitrate_mask)
13742 return -EOPNOTSUPP;
13744 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
13755 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13756 struct wireless_dev *wdev = info->user_ptr[1];
13759 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
13760 return -EINVAL;
13762 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
13763 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
13765 switch (wdev->iftype) {
13776 if (!wiphy_ext_feature_isset(wdev->wiphy,
13778 !(wdev->wiphy->nan_capa.flags &
13780 return -EOPNOTSUPP;
13783 return -EOPNOTSUPP;
13787 if (!rdev->ops->mgmt_tx)
13788 return -EOPNOTSUPP;
13790 if (info->attrs[NL80211_ATTR_RECEIVE_MULTICAST] &&
13791 !wiphy_ext_feature_isset(&rdev->wiphy,
13795 return -EOPNOTSUPP;
13798 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
13799 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
13800 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]),
13801 info->attrs[NL80211_ATTR_RECEIVE_MULTICAST],
13802 info->extack);
13807 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13808 struct wireless_dev *wdev = info->user_ptr[1];
13816 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
13819 if (!info->attrs[NL80211_ATTR_FRAME])
13820 return -EINVAL;
13822 if (!rdev->ops->mgmt_tx)
13823 return -EOPNOTSUPP;
13825 switch (wdev->iftype) {
13827 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
13828 return -EINVAL;
13839 if (!wiphy_ext_feature_isset(wdev->wiphy,
13841 !(wdev->wiphy->nan_capa.flags &
13843 return -EOPNOTSUPP;
13846 return -EOPNOTSUPP;
13849 if (info->attrs[NL80211_ATTR_DURATION]) {
13850 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
13851 return -EINVAL;
13852 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
13859 params.wait > rdev->wiphy.max_remain_on_channel_duration)
13860 return -EINVAL;
13863 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
13865 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
13866 return -EINVAL;
13868 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
13874 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
13881 return -EINVAL;
13885 return -EBUSY;
13887 params.link_id = nl80211_link_id_or_invalid(info->attrs);
13894 !(wdev->valid_links & BIT(params.link_id)))
13895 return -EINVAL;
13897 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
13898 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
13900 err = nl80211_parse_counter_offsets(rdev, NULL, params.len, -1,
13901 info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX],
13910 return -ENOMEM;
13912 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13915 err = -ENOBUFS;
13937 err = -ENOBUFS;
13945 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13946 struct wireless_dev *wdev = info->user_ptr[1];
13949 if (!info->attrs[NL80211_ATTR_COOKIE])
13950 return -EINVAL;
13952 if (!rdev->ops->mgmt_tx_cancel_wait)
13953 return -EOPNOTSUPP;
13955 switch (wdev->iftype) {
13965 if (!wiphy_ext_feature_isset(wdev->wiphy,
13967 return -EOPNOTSUPP;
13970 return -EOPNOTSUPP;
13973 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
13980 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13982 struct net_device *dev = info->user_ptr[1];
13987 if (!info->attrs[NL80211_ATTR_PS_STATE])
13988 return -EINVAL;
13990 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
13992 wdev = dev->ieee80211_ptr;
13994 if (!rdev->ops->set_power_mgmt)
13995 return -EOPNOTSUPP;
13999 if (state == wdev->ps)
14002 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
14004 wdev->ps = state;
14010 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14013 struct net_device *dev = info->user_ptr[1];
14018 wdev = dev->ieee80211_ptr;
14020 if (!rdev->ops->set_power_mgmt)
14021 return -EOPNOTSUPP;
14025 return -ENOMEM;
14027 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
14030 err = -ENOBUFS;
14034 if (wdev->ps)
14046 err = -ENOBUFS;
14066 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14067 struct net_device *dev = info->user_ptr[1];
14068 struct wireless_dev *wdev = dev->ieee80211_ptr;
14071 return -EINVAL;
14073 if (!rdev->ops->set_cqm_txe_config)
14074 return -EOPNOTSUPP;
14076 if (wdev->iftype != NL80211_IFTYPE_STATION &&
14077 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
14078 return -EOPNOTSUPP;
14087 struct wireless_dev *wdev = dev->ieee80211_ptr;
14099 if (!cqm_config->last_rssi_event_value &&
14100 wdev->links[0].client.current_bss &&
14101 rdev->ops->get_station) {
14105 mac_addr = wdev->links[0].client.current_bss->pub.bssid;
14113 cqm_config->last_rssi_event_value =
14117 last = cqm_config->last_rssi_event_value;
14118 hyst = cqm_config->rssi_hyst;
14119 n = cqm_config->n_rssi_thresholds;
14123 if (last < cqm_config->rssi_thresholds[i])
14127 low_index = i - 1;
14130 low = cqm_config->rssi_thresholds[low_index] - hyst;
14136 high = cqm_config->rssi_thresholds[i] + hyst - 1;
14148 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14150 struct net_device *dev = info->user_ptr[1];
14151 struct wireless_dev *wdev = dev->ieee80211_ptr;
14158 return -EINVAL;
14163 if (wdev->iftype != NL80211_IFTYPE_STATION &&
14164 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
14165 return -EOPNOTSUPP;
14170 old = wiphy_dereference(wdev->wiphy, wdev->cqm_config);
14177 if (!wiphy_ext_feature_isset(&rdev->wiphy,
14179 !rdev->ops->set_cqm_rssi_range_config)
14180 return -EOPNOTSUPP;
14182 if (!rdev->ops->set_cqm_rssi_config)
14183 return -EOPNOTSUPP;
14191 return -ENOMEM;
14193 cqm_config->rssi_hyst = hysteresis;
14194 cqm_config->n_rssi_thresholds = n_thresholds;
14195 memcpy(cqm_config->rssi_thresholds, thresholds,
14198 cqm_config->use_range_api = n_thresholds > 1 ||
14199 !rdev->ops->set_cqm_rssi_config;
14201 rcu_assign_pointer(wdev->cqm_config, cqm_config);
14203 if (cqm_config->use_range_api)
14210 RCU_INIT_POINTER(wdev->cqm_config, NULL);
14212 if (old->use_range_api)
14219 rcu_assign_pointer(wdev->cqm_config, old);
14234 cqm = info->attrs[NL80211_ATTR_CQM];
14236 return -EINVAL;
14240 info->extack);
14252 return -EINVAL;
14268 return -EINVAL;
14273 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14274 struct net_device *dev = info->user_ptr[1];
14287 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14288 struct net_device *dev = info->user_ptr[1];
14295 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14296 struct net_device *dev = info->user_ptr[1];
14305 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
14312 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
14313 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
14314 return -EINVAL;
14316 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
14317 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
14319 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
14321 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
14322 return -EINVAL;
14324 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
14326 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
14335 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
14337 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
14339 return -EINVAL;
14342 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
14352 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
14361 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
14362 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
14364 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
14368 return -EINVAL;
14370 sband = rdev->wiphy.bands[setup.chandef.chan->band];
14378 if (info->attrs[NL80211_ATTR_TX_RATES]) {
14379 err = nl80211_parse_tx_bitrate_mask(info, info->attrs,
14387 return -EINVAL;
14389 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
14396 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
14398 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
14408 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER])
14409 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
14416 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14417 struct net_device *dev = info->user_ptr[1];
14426 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
14430 if (!wowlan->n_patterns)
14435 return -ENOBUFS;
14437 for (i = 0; i < wowlan->n_patterns; i++) {
14440 return -ENOBUFS;
14441 pat_len = wowlan->patterns[i].pattern_len;
14443 wowlan->patterns[i].mask) ||
14445 wowlan->patterns[i].pattern) ||
14447 wowlan->patterns[i].pkt_offset))
14448 return -ENOBUFS;
14467 return -ENOBUFS;
14469 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
14470 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
14471 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
14472 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
14473 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
14475 tcp->payload_len, tcp->payload) ||
14477 tcp->data_interval) ||
14479 tcp->wake_len, tcp->wake_data) ||
14481 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
14482 return -ENOBUFS;
14484 if (tcp->payload_seq.len &&
14486 sizeof(tcp->payload_seq), &tcp->payload_seq))
14487 return -ENOBUFS;
14489 if (tcp->payload_tok.len &&
14491 sizeof(tcp->payload_tok) + tcp->tokens_size,
14492 &tcp->payload_tok))
14493 return -ENOBUFS;
14511 return -ENOBUFS;
14513 if (req->n_scan_plans == 1 &&
14515 req->scan_plans[0].interval * 1000))
14516 return -ENOBUFS;
14518 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
14519 return -ENOBUFS;
14521 if (req->relative_rssi_set) {
14525 req->relative_rssi))
14526 return -ENOBUFS;
14528 rssi_adjust.band = req->rssi_adjust.band;
14529 rssi_adjust.delta = req->rssi_adjust.delta;
14532 return -ENOBUFS;
14537 return -ENOBUFS;
14539 for (i = 0; i < req->n_channels; i++) {
14540 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
14541 return -ENOBUFS;
14546 if (req->n_match_sets) {
14550 return -ENOBUFS;
14552 for (i = 0; i < req->n_match_sets; i++) {
14555 return -ENOBUFS;
14558 req->match_sets[i].ssid.ssid_len,
14559 req->match_sets[i].ssid.ssid))
14560 return -ENOBUFS;
14568 return -ENOBUFS;
14570 for (i = 0; i < req->n_scan_plans; i++) {
14573 return -ENOBUFS;
14576 req->scan_plans[i].interval) ||
14577 (req->scan_plans[i].iterations &&
14579 req->scan_plans[i].iterations)))
14580 return -ENOBUFS;
14592 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14597 if (!rdev->wiphy.wowlan)
14598 return -EOPNOTSUPP;
14600 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
14602 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
14603 rdev->wiphy.wowlan_config->tcp->payload_len +
14604 rdev->wiphy.wowlan_config->tcp->wake_len +
14605 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
14610 return -ENOMEM;
14612 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
14617 if (rdev->wiphy.wowlan_config) {
14625 if ((rdev->wiphy.wowlan_config->any &&
14627 (rdev->wiphy.wowlan_config->disconnect &&
14629 (rdev->wiphy.wowlan_config->magic_pkt &&
14631 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
14633 (rdev->wiphy.wowlan_config->eap_identity_req &&
14635 (rdev->wiphy.wowlan_config->four_way_handshake &&
14637 (rdev->wiphy.wowlan_config->rfkill_release &&
14645 rdev->wiphy.wowlan_config->tcp))
14650 rdev->wiphy.wowlan_config->nd_config))
14661 return -ENOBUFS;
14676 if (!rdev->wiphy.wowlan->tcp)
14677 return -EINVAL;
14692 return -EINVAL;
14695 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
14696 return -EINVAL;
14699 rdev->wiphy.wowlan->tcp->data_interval_max ||
14701 return -EINVAL;
14704 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
14705 return -EINVAL;
14709 return -EINVAL;
14715 tokens_size = tokln - sizeof(*tok);
14717 if (!tok->len || tokens_size % tok->len)
14718 return -EINVAL;
14719 if (!rdev->wiphy.wowlan->tcp->tok)
14720 return -EINVAL;
14721 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
14722 return -EINVAL;
14723 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
14724 return -EINVAL;
14725 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
14726 return -EINVAL;
14727 if (tok->offset + tok->len > data_size)
14728 return -EINVAL;
14733 if (!rdev->wiphy.wowlan->tcp->seq)
14734 return -EINVAL;
14735 if (seq->len == 0 || seq->len > 4)
14736 return -EINVAL;
14737 if (seq->len + seq->offset > data_size)
14738 return -EINVAL;
14748 return -ENOMEM;
14749 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
14750 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
14751 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
14756 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
14757 IPPROTO_TCP, &cfg->sock, 1);
14762 if (inet_csk_get_port(cfg->sock->sk, port)) {
14763 sock_release(cfg->sock);
14765 return -EADDRINUSE;
14767 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
14771 return -EINVAL;
14773 cfg->src_port = port;
14776 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
14777 cfg->payload_len = data_size;
14778 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
14779 memcpy((void *)cfg->payload,
14783 cfg->payload_seq = *seq;
14784 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
14785 cfg->wake_len = wake_size;
14786 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
14787 memcpy((void *)cfg->wake_data,
14790 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
14792 memcpy((void *)cfg->wake_mask,
14796 cfg->tokens_size = tokens_size;
14797 cfg->payload_tok = *tok;
14798 memcpy(cfg->payload_tok.token_stream, tok->token_stream,
14802 trig->tcp = cfg;
14817 return -ENOMEM;
14819 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
14820 err = -EOPNOTSUPP;
14829 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
14830 wowlan->max_nd_match_sets);
14831 err = PTR_ERR_OR_ZERO(trig->nd_config);
14833 trig->nd_config = NULL;
14842 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14846 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
14848 bool prev_enabled = rdev->wiphy.wowlan_config;
14852 return -EOPNOTSUPP;
14854 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
14856 rdev->wiphy.wowlan_config = NULL;
14861 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
14862 nl80211_wowlan_policy, info->extack);
14867 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
14868 return -EINVAL;
14873 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
14874 return -EINVAL;
14880 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
14881 return -EINVAL;
14887 return -EINVAL;
14890 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
14891 return -EINVAL;
14897 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
14898 return -EINVAL;
14904 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
14905 return -EINVAL;
14911 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
14912 return -EINVAL;
14928 if (n_patterns > wowlan->n_patterns)
14929 return -EINVAL;
14935 return -ENOMEM;
14948 info->extack);
14952 err = -EINVAL;
14960 if (pat_len > wowlan->pattern_max_len ||
14961 pat_len < wowlan->pattern_min_len)
14967 if (pkt_offset > wowlan->max_pkt_offset)
14973 err = -ENOMEM;
15014 err = -EINVAL;
15020 err = -ENOMEM;
15024 rdev->wiphy.wowlan_config = ntrig;
15027 if (rdev->ops->set_wakeup &&
15028 prev_enabled != !!rdev->wiphy.wowlan_config)
15029 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
15036 if (new_triggers.tcp && new_triggers.tcp->sock)
15037 sock_release(new_triggers.tcp->sock);
15051 if (!rdev->coalesce->n_rules)
15056 return -ENOBUFS;
15058 for (i = 0; i < rdev->coalesce->n_rules; i++) {
15061 return -ENOBUFS;
15063 rule = &rdev->coalesce->rules[i];
15065 rule->delay))
15066 return -ENOBUFS;
15069 rule->condition))
15070 return -ENOBUFS;
15075 return -ENOBUFS;
15077 for (j = 0; j < rule->n_patterns; j++) {
15080 return -ENOBUFS;
15081 pat_len = rule->patterns[j].pattern_len;
15084 rule->patterns[j].mask) ||
15086 rule->patterns[j].pattern) ||
15088 rule->patterns[j].pkt_offset))
15089 return -ENOBUFS;
15102 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15106 if (!rdev->wiphy.coalesce)
15107 return -EOPNOTSUPP;
15111 return -ENOMEM;
15113 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
15118 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
15126 return -ENOBUFS;
15137 for (i = 0; i < coalesce->n_rules; i++) {
15138 rule = &coalesce->rules[i];
15139 for (j = 0; j < rule->n_patterns; j++)
15140 kfree(rule->patterns[j].mask);
15141 kfree(rule->patterns);
15151 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
15162 new_rule->delay =
15164 if (new_rule->delay > coalesce->max_delay)
15165 return -EINVAL;
15168 new_rule->condition =
15172 return -EINVAL;
15177 if (n_patterns > coalesce->n_patterns)
15178 return -EINVAL;
15180 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
15182 if (!new_rule->patterns)
15183 return -ENOMEM;
15185 new_rule->n_patterns = n_patterns;
15201 return -EINVAL;
15205 return -EINVAL;
15206 if (pat_len > coalesce->pattern_max_len ||
15207 pat_len < coalesce->pattern_min_len)
15208 return -EINVAL;
15212 if (pkt_offset > coalesce->max_pkt_offset)
15213 return -EINVAL;
15214 new_rule->patterns[i].pkt_offset = pkt_offset;
15218 return -ENOMEM;
15220 new_rule->patterns[i].mask = mask_pat;
15225 new_rule->patterns[i].pattern = mask_pat;
15226 new_rule->patterns[i].pattern_len = pat_len;
15237 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15238 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
15243 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
15244 return -EOPNOTSUPP;
15246 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
15247 cfg80211_free_coalesce(rdev->coalesce);
15248 rdev->coalesce = NULL;
15253 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
15256 if (n_rules > coalesce->n_rules)
15257 return -EINVAL;
15262 return -ENOMEM;
15264 new_coalesce->n_rules = n_rules;
15267 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
15270 &new_coalesce->rules[i]);
15281 cfg80211_free_coalesce(rdev->coalesce);
15282 rdev->coalesce = new_coalesce;
15293 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15294 struct net_device *dev = info->user_ptr[1];
15295 struct wireless_dev *wdev = dev->ieee80211_ptr;
15300 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
15301 return -EINVAL;
15304 info->attrs[NL80211_ATTR_REKEY_DATA],
15305 nl80211_rekey_policy, info->extack);
15311 return -EINVAL;
15313 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK &&
15315 return -ERANGE;
15317 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK &&
15319 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KCK_32 &&
15321 return -ERANGE;
15331 if (!wdev->connected)
15332 return -ENOTCONN;
15334 if (!rdev->ops->set_rekey_data)
15335 return -EOPNOTSUPP;
15343 struct net_device *dev = info->user_ptr[1];
15344 struct wireless_dev *wdev = dev->ieee80211_ptr;
15346 if (wdev->iftype != NL80211_IFTYPE_AP &&
15347 wdev->iftype != NL80211_IFTYPE_P2P_GO)
15348 return -EINVAL;
15350 if (wdev->ap_unexpected_nlportid)
15351 return -EBUSY;
15353 wdev->ap_unexpected_nlportid = info->snd_portid;
15360 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15361 struct net_device *dev = info->user_ptr[1];
15362 struct wireless_dev *wdev = dev->ieee80211_ptr;
15369 if (wdev->iftype != NL80211_IFTYPE_AP &&
15370 wdev->iftype != NL80211_IFTYPE_P2P_GO)
15371 return -EOPNOTSUPP;
15373 if (!info->attrs[NL80211_ATTR_MAC])
15374 return -EINVAL;
15376 if (!rdev->ops->probe_client)
15377 return -EOPNOTSUPP;
15381 return -ENOMEM;
15383 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
15386 err = -ENOBUFS;
15390 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
15405 err = -ENOBUFS;
15413 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15417 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
15418 return -EOPNOTSUPP;
15422 return -ENOMEM;
15425 spin_lock_bh(&rdev->beacon_registrations_lock);
15426 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
15427 if (reg->nlportid == info->snd_portid) {
15428 rv = -EALREADY;
15433 nreg->nlportid = info->snd_portid;
15434 list_add(&nreg->list, &rdev->beacon_registrations);
15436 spin_unlock_bh(&rdev->beacon_registrations_lock);
15440 spin_unlock_bh(&rdev->beacon_registrations_lock);
15447 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15448 struct wireless_dev *wdev = info->user_ptr[1];
15451 if (!rdev->ops->start_p2p_device)
15452 return -EOPNOTSUPP;
15454 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
15455 return -EOPNOTSUPP;
15460 if (rfkill_blocked(rdev->wiphy.rfkill))
15461 return -ERFKILL;
15467 wdev->is_running = true;
15468 rdev->opencount++;
15475 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15476 struct wireless_dev *wdev = info->user_ptr[1];
15478 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
15479 return -EOPNOTSUPP;
15481 if (!rdev->ops->stop_p2p_device)
15482 return -EOPNOTSUPP;
15517 if (BIT(band) & ~(u32)wiphy->nan_supported_bands)
15518 return -EINVAL;
15524 return -EINVAL;
15526 cfg->chan = nl80211_get_nan_channel(wiphy, freq);
15527 if (!cfg->chan)
15528 return -EINVAL;
15532 cfg->rssi_close =
15535 return -EINVAL;
15539 cfg->rssi_middle =
15541 if (!cfg->rssi_close || cfg->rssi_middle >= cfg->rssi_close)
15542 return -EINVAL;
15546 cfg->awake_dw_interval =
15549 if (band == NL80211_BAND_2GHZ && cfg->awake_dw_interval == 0)
15550 return -EINVAL;
15553 cfg->disable_scan =
15568 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
15569 conf->master_pref =
15570 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
15575 if (info->attrs[NL80211_ATTR_BANDS]) {
15576 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
15578 if (bands & ~(u32)wiphy->nan_supported_bands)
15579 return -EOPNOTSUPP;
15582 return -EINVAL;
15584 conf->bands = bands;
15588 conf->band_cfgs[NL80211_BAND_2GHZ].awake_dw_interval = 1;
15589 if (conf->bands & BIT(NL80211_BAND_5GHZ) || !conf->bands)
15590 conf->band_cfgs[NL80211_BAND_5GHZ].awake_dw_interval = 1;
15593 conf->band_cfgs[NL80211_BAND_2GHZ].chan =
15595 if (!conf->band_cfgs[NL80211_BAND_2GHZ].chan)
15596 return -EINVAL;
15598 if (!info->attrs[NL80211_ATTR_NAN_CONFIG])
15602 info->attrs[NL80211_ATTR_NAN_CONFIG], NULL,
15603 info->extack);
15609 conf->cluster_id =
15613 conf->extra_nan_attrs =
15615 conf->extra_nan_attrs_len =
15620 conf->vendor_elems =
15622 conf->vendor_elems_len =
15637 info->extack);
15642 return -EINVAL;
15645 if (conf->bands && !(conf->bands & BIT(band)))
15646 return -EINVAL;
15648 cfg = &conf->band_cfgs[band];
15658 conf->scan_period =
15662 conf->scan_dwell_time =
15666 conf->discovery_beacon_interval =
15670 conf->enable_dw_notification =
15674 if (!conf->band_cfgs[NL80211_BAND_5GHZ].chan &&
15675 (!conf->bands || conf->bands & BIT(NL80211_BAND_5GHZ))) {
15677 conf->band_cfgs[NL80211_BAND_5GHZ].chan =
15679 if (!conf->band_cfgs[NL80211_BAND_5GHZ].chan)
15680 conf->band_cfgs[NL80211_BAND_5GHZ].chan =
15684 if (!conf->band_cfgs[NL80211_BAND_5GHZ].chan &&
15685 conf->bands & BIT(NL80211_BAND_5GHZ)) {
15686 NL_SET_ERR_MSG_ATTR(info->extack,
15687 info->attrs[NL80211_ATTR_BANDS],
15689 return -EINVAL;
15701 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15702 struct wireless_dev *wdev = info->user_ptr[1];
15706 if (wdev->iftype != NL80211_IFTYPE_NAN)
15707 return -EOPNOTSUPP;
15710 return -EEXIST;
15712 if (rfkill_blocked(rdev->wiphy.rfkill))
15713 return -ERFKILL;
15716 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
15717 return -EINVAL;
15719 err = nl80211_parse_nan_conf(&rdev->wiphy, info, &conf, NULL);
15727 wdev->is_running = true;
15728 rdev->opencount++;
15735 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15736 struct wireless_dev *wdev = info->user_ptr[1];
15738 if (wdev->iftype != NL80211_IFTYPE_NAN)
15739 return -EOPNOTSUPP;
15757 return -EINVAL;
15774 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
15776 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
15778 return -ENOMEM;
15790 func->num_tx_filters = n_entries;
15791 func->tx_filters = filter;
15793 func->num_rx_filters = n_entries;
15794 func->rx_filters = filter;
15806 return -ENOMEM;
15812 struct cfg80211_registered_device *rdev = info->user_ptr[0];
15813 struct wireless_dev *wdev = info->user_ptr[1];
15820 if (wdev->iftype != NL80211_IFTYPE_NAN)
15821 return -EOPNOTSUPP;
15824 return -ENOTCONN;
15826 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
15827 return -EINVAL;
15830 info->attrs[NL80211_ATTR_NAN_FUNC],
15832 info->extack);
15838 return -ENOMEM;
15840 func->cookie = cfg80211_assign_cookie(rdev);
15843 err = -EINVAL;
15848 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
15851 err = -EINVAL;
15855 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
15856 sizeof(func->service_id));
15858 func->close_range =
15862 func->serv_spec_info_len =
15864 func->serv_spec_info =
15866 func->serv_spec_info_len,
15868 if (!func->serv_spec_info) {
15869 err = -ENOMEM;
15875 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
15877 switch (func->type) {
15880 err = -EINVAL;
15884 func->publish_type =
15886 func->publish_bcast =
15889 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
15890 func->publish_bcast) {
15891 err = -EINVAL;
15896 func->subscribe_active =
15903 err = -EINVAL;
15907 func->followup_id =
15909 func->followup_reqid =
15911 memcpy(func->followup_dest.addr,
15913 sizeof(func->followup_dest.addr));
15914 if (func->ttl) {
15915 err = -EINVAL;
15920 err = -EINVAL;
15931 info->extack);
15935 func->srf_include =
15941 err = -EINVAL;
15945 func->srf_bf_len =
15947 func->srf_bf =
15949 func->srf_bf_len, GFP_KERNEL);
15950 if (!func->srf_bf) {
15951 err = -ENOMEM;
15955 func->srf_bf_idx =
15963 err = -EINVAL;
15969 err = -EINVAL;
15973 func->srf_num_macs = n_entries;
15974 func->srf_macs =
15975 kcalloc(n_entries, sizeof(*func->srf_macs),
15977 if (!func->srf_macs) {
15978 err = -ENOMEM;
15983 memcpy(func->srf_macs[i++].addr, nla_data(attr),
15984 sizeof(*func->srf_macs));
16004 err = -ENOMEM;
16008 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
16010 /* This can't really happen - we just allocated 4KB */
16012 err = -ENOMEM;
16025 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
16034 func->instance_id))
16044 return -ENOBUFS;
16050 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16051 struct wireless_dev *wdev = info->user_ptr[1];
16054 if (wdev->iftype != NL80211_IFTYPE_NAN)
16055 return -EOPNOTSUPP;
16058 return -ENOTCONN;
16060 if (!info->attrs[NL80211_ATTR_COOKIE])
16061 return -EINVAL;
16063 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
16073 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16074 struct wireless_dev *wdev = info->user_ptr[1];
16079 if (wdev->iftype != NL80211_IFTYPE_NAN)
16080 return -EOPNOTSUPP;
16083 return -ENOTCONN;
16085 err = nl80211_parse_nan_conf(&rdev->wiphy, info, &conf, &changed);
16090 return -EINVAL;
16098 struct wiphy *wiphy = wdev->wiphy;
16104 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
16117 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16118 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16119 wdev->netdev->ifindex)) ||
16124 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
16126 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
16138 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
16148 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
16149 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
16152 if (match->info && match->info_len &&
16153 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
16154 match->info))
16161 if (!wdev->owner_nlportid)
16162 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
16165 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
16166 wdev->owner_nlportid);
16180 struct wiphy *wiphy = wdev->wiphy;
16199 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16200 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16201 wdev->netdev->ifindex)) ||
16221 if (!wdev->owner_nlportid)
16222 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
16225 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
16226 wdev->owner_nlportid);
16243 return -ENOMEM;
16245 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
16259 return -ENOBUFS;
16264 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16266 struct net_device *dev = info->user_ptr[1];
16268 if (!rdev->ops->update_ft_ies)
16269 return -EOPNOTSUPP;
16271 if (!info->attrs[NL80211_ATTR_MDID] ||
16272 !info->attrs[NL80211_ATTR_IE])
16273 return -EINVAL;
16276 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
16277 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
16278 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
16286 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16287 struct wireless_dev *wdev = info->user_ptr[1];
16292 if (!rdev->ops->crit_proto_start)
16293 return -EOPNOTSUPP;
16295 if (WARN_ON(!rdev->ops->crit_proto_stop))
16296 return -EINVAL;
16298 if (rdev->crit_proto_nlportid)
16299 return -EBUSY;
16302 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
16303 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
16306 return -EINVAL;
16309 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
16310 return -EINVAL;
16313 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
16317 rdev->crit_proto_nlportid = info->snd_portid;
16325 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16326 struct wireless_dev *wdev = info->user_ptr[1];
16328 if (!rdev->ops->crit_proto_stop)
16329 return -EOPNOTSUPP;
16331 if (rdev->crit_proto_nlportid) {
16332 rdev->crit_proto_nlportid = 0;
16342 if (vcmd->policy == VENDOR_CMD_RAW_DATA) {
16343 if (attr->nla_type & NLA_F_NESTED) {
16346 return -EINVAL;
16352 if (!(attr->nla_type & NLA_F_NESTED)) {
16354 return -EINVAL;
16357 return nla_validate_nested(attr, vcmd->maxattr, vcmd->policy, extack);
16362 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16365 info->attrs);
16369 if (!rdev->wiphy.vendor_commands)
16370 return -EOPNOTSUPP;
16374 if (err != -EINVAL)
16377 } else if (wdev->wiphy != &rdev->wiphy) {
16378 return -EINVAL;
16381 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
16382 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
16383 return -EINVAL;
16385 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
16386 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
16387 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
16392 vcmd = &rdev->wiphy.vendor_commands[i];
16394 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
16397 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
16400 return -EINVAL;
16401 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
16402 !wdev->netdev)
16403 return -EINVAL;
16405 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
16407 return -ENETDOWN;
16413 if (!vcmd->doit)
16414 return -EOPNOTSUPP;
16416 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
16417 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
16418 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
16421 info->attrs[NL80211_ATTR_VENDOR_DATA],
16422 info->extack);
16427 rdev->cur_cmd_info = info;
16428 err = vcmd->doit(&rdev->wiphy, wdev, data, len);
16429 rdev->cur_cmd_info = NULL;
16433 return -EOPNOTSUPP;
16444 int vcmd_idx = -1;
16449 if (cb->args[0]) {
16451 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
16455 return -ENODEV;
16459 if (cb->args[1]) {
16460 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
16461 if (tmp->identifier == cb->args[1] - 1) {
16474 return -ENOMEM;
16476 err = nlmsg_parse_deprecated(cb->nlh,
16485 err = -EINVAL;
16489 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(skb->sk), attrbuf);
16493 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
16502 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
16505 vcmd = &(*rdev)->wiphy.vendor_commands[i];
16507 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
16510 if (!vcmd->dumpit) {
16511 err = -EOPNOTSUPP;
16520 err = -EOPNOTSUPP;
16529 &(*rdev)->wiphy.vendor_commands[vcmd_idx],
16531 cb->extack);
16536 /* 0 is the first index - add 1 to parse only once */
16537 cb->args[0] = (*rdev)->wiphy_idx + 1;
16539 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
16540 cb->args[2] = vcmd_idx;
16541 cb->args[3] = (unsigned long)data;
16542 cb->args[4] = data_len;
16568 vcmd_idx = cb->args[2];
16569 data = (void *)cb->args[3];
16570 data_len = cb->args[4];
16571 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
16573 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
16576 err = -EINVAL;
16579 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
16580 !wdev->netdev) {
16581 err = -EINVAL;
16585 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
16587 err = -ENETDOWN;
16594 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
16595 cb->nlh->nlmsg_seq, NLM_F_MULTI,
16600 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16615 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
16616 (unsigned long *)&cb->args[5]);
16619 if (err == -ENOBUFS || err == -ENOENT) {
16630 err = skb->len;
16643 if (WARN_ON(!rdev->cur_cmd_info))
16647 rdev->cur_cmd_info->snd_portid,
16648 rdev->cur_cmd_info->snd_seq,
16655 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
16656 void *hdr = ((void **)skb->cb)[1];
16657 struct nlattr *data = ((void **)skb->cb)[2];
16660 memset(skb->cb, 0, sizeof(skb->cb));
16662 if (WARN_ON(!rdev->cur_cmd_info)) {
16664 return -EINVAL;
16669 return genlmsg_reply(skb, rdev->cur_cmd_info);
16677 if (WARN_ON(!rdev->cur_cmd_info))
16680 return rdev->cur_cmd_info->snd_portid;
16687 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16689 struct net_device *dev = info->user_ptr[1];
16693 if (!rdev->ops->set_qos_map)
16694 return -EOPNOTSUPP;
16696 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
16697 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
16698 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
16701 return -EINVAL;
16705 return -ENOMEM;
16707 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
16711 memcpy(qos_map->dscp_exception, pos, des_len);
16712 qos_map->num_des = num_des;
16714 if (qos_map->dscp_exception[des].up > 7) {
16716 return -EINVAL;
16721 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
16724 ret = nl80211_key_allowed(dev->ieee80211_ptr);
16734 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16735 struct net_device *dev = info->user_ptr[1];
16736 struct wireless_dev *wdev = dev->ieee80211_ptr;
16741 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
16742 return -EOPNOTSUPP;
16744 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
16745 !info->attrs[NL80211_ATTR_USER_PRIO])
16746 return -EINVAL;
16748 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
16749 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
16751 /* WMM uses TIDs 0-7 even for TSPEC */
16757 return -EINVAL;
16760 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
16762 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
16764 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
16766 return -EINVAL;
16769 switch (wdev->iftype) {
16772 if (wdev->connected)
16774 return -ENOTCONN;
16776 return -EOPNOTSUPP;
16784 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16785 struct net_device *dev = info->user_ptr[1];
16789 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
16790 return -EINVAL;
16792 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
16793 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
16801 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16802 struct net_device *dev = info->user_ptr[1];
16803 struct wireless_dev *wdev = dev->ieee80211_ptr;
16809 if (!rdev->ops->tdls_channel_switch ||
16810 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
16811 return -EOPNOTSUPP;
16813 switch (dev->ieee80211_ptr->iftype) {
16818 return -EOPNOTSUPP;
16821 if (!info->attrs[NL80211_ATTR_MAC] ||
16822 !info->attrs[NL80211_ATTR_OPER_CLASS])
16823 return -EINVAL;
16830 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
16834 if (chandef.chan->band == NL80211_BAND_2GHZ &&
16837 return -EINVAL;
16840 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
16841 wdev->iftype))
16842 return -EINVAL;
16845 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
16846 return -EINVAL;
16848 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
16849 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
16857 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16858 struct net_device *dev = info->user_ptr[1];
16861 if (!rdev->ops->tdls_channel_switch ||
16862 !rdev->ops->tdls_cancel_channel_switch ||
16863 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
16864 return -EOPNOTSUPP;
16866 switch (dev->ieee80211_ptr->iftype) {
16871 return -EOPNOTSUPP;
16874 if (!info->attrs[NL80211_ATTR_MAC])
16875 return -EINVAL;
16877 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
16887 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16888 struct net_device *dev = info->user_ptr[1];
16889 struct wireless_dev *wdev = dev->ieee80211_ptr;
16893 if (!rdev->ops->set_multicast_to_unicast)
16894 return -EOPNOTSUPP;
16896 if (wdev->iftype != NL80211_IFTYPE_AP &&
16897 wdev->iftype != NL80211_IFTYPE_P2P_GO)
16898 return -EOPNOTSUPP;
16900 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
16908 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16909 struct net_device *dev = info->user_ptr[1];
16910 struct wireless_dev *wdev = dev->ieee80211_ptr;
16913 if (wdev->iftype != NL80211_IFTYPE_STATION &&
16914 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
16915 return -EOPNOTSUPP;
16917 if (!wiphy_ext_feature_isset(&rdev->wiphy,
16919 return -EOPNOTSUPP;
16921 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
16922 return -EINVAL;
16924 if (!wdev->connected)
16925 return -ENOTCONN;
16927 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
16928 if (memcmp(pmk_conf.aa, wdev->u.client.connected_addr, ETH_ALEN))
16929 return -EINVAL;
16931 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
16932 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
16935 return -EINVAL;
16937 if (info->attrs[NL80211_ATTR_PMKR0_NAME])
16939 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
16946 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16947 struct net_device *dev = info->user_ptr[1];
16948 struct wireless_dev *wdev = dev->ieee80211_ptr;
16951 if (wdev->iftype != NL80211_IFTYPE_STATION &&
16952 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
16953 return -EOPNOTSUPP;
16955 if (!wiphy_ext_feature_isset(&rdev->wiphy,
16957 return -EOPNOTSUPP;
16959 if (!info->attrs[NL80211_ATTR_MAC])
16960 return -EINVAL;
16962 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
16968 struct cfg80211_registered_device *rdev = info->user_ptr[0];
16969 struct net_device *dev = info->user_ptr[1];
16972 if (!rdev->ops->external_auth)
16973 return -EOPNOTSUPP;
16975 if (!info->attrs[NL80211_ATTR_SSID] &&
16976 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
16977 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
16978 return -EINVAL;
16980 if (!info->attrs[NL80211_ATTR_BSSID])
16981 return -EINVAL;
16983 if (!info->attrs[NL80211_ATTR_STATUS_CODE])
16984 return -EINVAL;
16988 if (info->attrs[NL80211_ATTR_SSID]) {
16989 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
16991 return -EINVAL;
16993 nla_data(info->attrs[NL80211_ATTR_SSID]),
16997 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]),
17000 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
17002 if (info->attrs[NL80211_ATTR_PMKID])
17003 params.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
17010 bool dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
17011 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17012 struct net_device *dev = info->user_ptr[1];
17013 struct wireless_dev *wdev = dev->ieee80211_ptr;
17023 if (!wiphy_ext_feature_isset(&rdev->wiphy,
17025 return -EOPNOTSUPP;
17027 if (!rdev->ops->tx_control_port)
17028 return -EOPNOTSUPP;
17030 if (!info->attrs[NL80211_ATTR_FRAME] ||
17031 !info->attrs[NL80211_ATTR_MAC] ||
17032 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
17034 return -EINVAL;
17037 switch (wdev->iftype) {
17043 if (wdev->u.ibss.current_bss)
17045 return -ENOTCONN;
17048 if (wdev->connected)
17050 return -ENOTCONN;
17052 return -EOPNOTSUPP;
17055 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
17056 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
17057 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
17058 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
17060 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
17062 link_id = nl80211_link_id_or_invalid(info->attrs);
17068 nl_set_extack_cookie_u64(info->extack, cookie);
17075 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17076 struct net_device *dev = info->user_ptr[1];
17077 struct wireless_dev *wdev = dev->ieee80211_ptr;
17079 unsigned int link_id = nl80211_link_id(info->attrs);
17085 if (wdev->iftype != NL80211_IFTYPE_AP ||
17086 !wdev->links[link_id].ap.beacon_interval)
17087 return -EOPNOTSUPP;
17094 return -ENODATA;
17098 return -ENOMEM;
17100 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
17105 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
17142 return -ENOBUFS;
17147 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17149 struct net_device *dev = info->user_ptr[1];
17151 if (!rdev->ops->update_owe_info)
17152 return -EOPNOTSUPP;
17154 if (!info->attrs[NL80211_ATTR_STATUS_CODE] ||
17155 !info->attrs[NL80211_ATTR_MAC])
17156 return -EINVAL;
17159 owe_info.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
17160 nla_memcpy(owe_info.peer, info->attrs[NL80211_ATTR_MAC], ETH_ALEN);
17162 if (info->attrs[NL80211_ATTR_IE]) {
17163 owe_info.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
17164 owe_info.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
17172 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17173 struct net_device *dev = info->user_ptr[1];
17174 struct wireless_dev *wdev = dev->ieee80211_ptr;
17181 if (!rdev->ops->probe_mesh_link || !rdev->ops->get_station)
17182 return -EOPNOTSUPP;
17184 if (!info->attrs[NL80211_ATTR_MAC] ||
17185 !info->attrs[NL80211_ATTR_FRAME]) {
17187 return -EINVAL;
17190 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
17191 return -EOPNOTSUPP;
17193 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
17194 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
17195 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
17198 return -EINVAL;
17201 !ether_addr_equal(buf + ETH_ALEN, dev->dev_addr))
17202 return -EINVAL;
17219 struct netlink_ext_ack *extack = info->extack;
17224 return -EINVAL;
17226 tid_conf->config_override =
17228 tid_conf->tids = nla_get_u16(attrs[NL80211_TID_CONFIG_ATTR_TIDS]);
17230 if (tid_conf->config_override) {
17231 if (rdev->ops->reset_tid_config) {
17233 tid_conf->tids);
17237 return -EINVAL;
17242 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_NOACK);
17243 tid_conf->noack =
17248 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT);
17249 tid_conf->retry_short =
17252 if (tid_conf->retry_short > rdev->wiphy.max_data_retry_count)
17253 return -EINVAL;
17257 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
17258 tid_conf->retry_long =
17261 if (tid_conf->retry_long > rdev->wiphy.max_data_retry_count)
17262 return -EINVAL;
17266 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);
17267 tid_conf->ampdu =
17272 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);
17273 tid_conf->rtscts =
17278 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMSDU_CTRL);
17279 tid_conf->amsdu =
17286 tid_conf->txrate_type = nla_get_u8(attrs[idx]);
17288 if (tid_conf->txrate_type != NL80211_TX_RATE_AUTOMATIC) {
17291 &tid_conf->txrate_mask, dev,
17296 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE);
17298 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE);
17302 mask = rdev->wiphy.tid_config_support.peer;
17304 mask = rdev->wiphy.tid_config_support.vif;
17306 if (tid_conf->mask & ~mask) {
17308 return -EOPNOTSUPP;
17317 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17319 unsigned int link_id = nl80211_link_id(info->attrs);
17320 struct net_device *dev = info->user_ptr[1];
17324 int ret = -EINVAL;
17327 if (!info->attrs[NL80211_ATTR_TID_CONFIG])
17328 return -EINVAL;
17330 if (!rdev->ops->set_tid_config)
17331 return -EOPNOTSUPP;
17333 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
17340 return -ENOMEM;
17342 tid_config->n_tid_conf = num_conf;
17344 if (info->attrs[NL80211_ATTR_MAC])
17345 tid_config->peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
17347 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
17356 &tid_config->tid_conf[conf_idx],
17357 info, tid_config->peer, link_id);
17373 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17375 struct net_device *dev = info->user_ptr[1];
17376 struct wireless_dev *wdev = dev->ieee80211_ptr;
17381 if (!rdev->ops->color_change)
17382 return -EOPNOTSUPP;
17384 if (!wiphy_ext_feature_isset(&rdev->wiphy,
17386 return -EOPNOTSUPP;
17388 if (wdev->iftype != NL80211_IFTYPE_AP)
17389 return -EOPNOTSUPP;
17391 if (!info->attrs[NL80211_ATTR_COLOR_CHANGE_COUNT] ||
17392 !info->attrs[NL80211_ATTR_COLOR_CHANGE_COLOR] ||
17393 !info->attrs[NL80211_ATTR_COLOR_CHANGE_ELEMS])
17394 return -EINVAL;
17396 params.count = nla_get_u8(info->attrs[NL80211_ATTR_COLOR_CHANGE_COUNT]);
17397 params.color = nla_get_u8(info->attrs[NL80211_ATTR_COLOR_CHANGE_COLOR]);
17399 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_next,
17400 info->extack);
17406 return -ENOMEM;
17409 info->attrs[NL80211_ATTR_COLOR_CHANGE_ELEMS],
17410 nl80211_policy, info->extack);
17415 info->extack);
17420 err = -EINVAL;
17425 err = -EINVAL;
17431 err = -EINVAL;
17436 err = -EINVAL;
17445 err = -EINVAL;
17451 err = -EINVAL;
17457 err = -EINVAL;
17464 if (info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP]) {
17466 rdev, info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP],
17472 params.link_id = nl80211_link_id(info->attrs);
17487 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17488 struct net_device *dev = info->user_ptr[1];
17492 if (!info->attrs[NL80211_ATTR_MAC] ||
17493 !info->attrs[NL80211_ATTR_FILS_KEK] ||
17494 !info->attrs[NL80211_ATTR_FILS_NONCES])
17495 return -EINVAL;
17497 fils_aad.macaddr = nla_data(info->attrs[NL80211_ATTR_MAC]);
17498 fils_aad.kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
17499 fils_aad.kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
17500 nonces = nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
17509 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17510 unsigned int link_id = nl80211_link_id(info->attrs);
17511 struct net_device *dev = info->user_ptr[1];
17512 struct wireless_dev *wdev = dev->ieee80211_ptr;
17515 if (!(wdev->wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO))
17516 return -EINVAL;
17518 switch (wdev->iftype) {
17522 return -EINVAL;
17525 if (!info->attrs[NL80211_ATTR_MAC] ||
17526 !is_valid_ether_addr(nla_data(info->attrs[NL80211_ATTR_MAC])))
17527 return -EINVAL;
17529 wdev->valid_links |= BIT(link_id);
17530 ether_addr_copy(wdev->links[link_id].addr,
17531 nla_data(info->attrs[NL80211_ATTR_MAC]));
17535 wdev->valid_links &= ~BIT(link_id);
17536 eth_zero_addr(wdev->links[link_id].addr);
17544 unsigned int link_id = nl80211_link_id(info->attrs);
17545 struct net_device *dev = info->user_ptr[1];
17546 struct wireless_dev *wdev = dev->ieee80211_ptr;
17549 if (!info->attrs[NL80211_ATTR_MLO_LINK_ID])
17550 return -EINVAL;
17552 switch (wdev->iftype) {
17556 return -EINVAL;
17569 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17570 struct net_device *dev = info->user_ptr[1];
17573 if ((add && !rdev->ops->add_link_station) ||
17574 (!add && !rdev->ops->mod_link_station))
17575 return -EOPNOTSUPP;
17577 if (add && !info->attrs[NL80211_ATTR_MAC])
17578 return -EINVAL;
17580 if (!info->attrs[NL80211_ATTR_MLD_ADDR])
17581 return -EINVAL;
17583 if (add && !info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
17584 return -EINVAL;
17586 params.mld_mac = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
17588 if (info->attrs[NL80211_ATTR_MAC]) {
17589 params.link_mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
17591 return -EINVAL;
17594 if (!info->attrs[NL80211_ATTR_MLO_LINK_ID])
17595 return -EINVAL;
17597 params.link_id = nla_get_u8(info->attrs[NL80211_ATTR_MLO_LINK_ID]);
17599 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
17601 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
17603 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
17606 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
17608 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
17610 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
17612 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
17614 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
17616 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
17618 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
17620 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) {
17622 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
17624 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]);
17630 return -EINVAL;
17634 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY])
17636 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]);
17638 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
17641 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
17671 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17672 struct net_device *dev = info->user_ptr[1];
17674 if (!rdev->ops->del_link_station)
17675 return -EOPNOTSUPP;
17677 if (!info->attrs[NL80211_ATTR_MLD_ADDR] ||
17678 !info->attrs[NL80211_ATTR_MLO_LINK_ID])
17679 return -EINVAL;
17681 params.mld_mac = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]);
17682 params.link_id = nla_get_u8(info->attrs[NL80211_ATTR_MLO_LINK_ID]);
17690 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17691 struct net_device *dev = info->user_ptr[1];
17694 if (!rdev->wiphy.hw_timestamp_max_peers)
17695 return -EOPNOTSUPP;
17697 if (!info->attrs[NL80211_ATTR_MAC] &&
17698 rdev->wiphy.hw_timestamp_max_peers != CFG80211_HW_TIMESTAMP_ALL_PEERS)
17699 return -EOPNOTSUPP;
17701 if (info->attrs[NL80211_ATTR_MAC])
17702 hwts.macaddr = nla_data(info->attrs[NL80211_ATTR_MAC]);
17705 nla_get_flag(info->attrs[NL80211_ATTR_HW_TIMESTAMP_ENABLED]);
17714 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17715 struct net_device *dev = info->user_ptr[1];
17716 struct wireless_dev *wdev = dev->ieee80211_ptr;
17718 if (wdev->iftype != NL80211_IFTYPE_STATION &&
17719 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
17720 return -EOPNOTSUPP;
17722 if (!wdev->connected)
17723 return -ENOLINK;
17725 if (!info->attrs[NL80211_ATTR_MLO_TTLM_DLINK] ||
17726 !info->attrs[NL80211_ATTR_MLO_TTLM_ULINK])
17727 return -EINVAL;
17730 info->attrs[NL80211_ATTR_MLO_TTLM_DLINK],
17733 info->attrs[NL80211_ATTR_MLO_TTLM_ULINK],
17741 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17742 struct net_device *dev = info->user_ptr[1];
17743 struct wireless_dev *wdev = dev->ieee80211_ptr;
17749 if (!wdev->valid_links)
17750 return -EINVAL;
17752 if (dev->ieee80211_ptr->conn_owner_nlportid &&
17753 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
17754 return -EPERM;
17756 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
17757 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
17758 return -EOPNOTSUPP;
17761 if (info->attrs[NL80211_ATTR_MLO_LINKS]) {
17777 if (info->attrs[NL80211_ATTR_MLO_RECONF_REM_LINKS])
17779 nla_get_u16(info->attrs[NL80211_ATTR_MLO_RECONF_REM_LINKS]);
17785 (wdev->valid_links & add_links) ||
17786 ((wdev->valid_links & req.rem_links) != req.rem_links)) {
17787 err = -EINVAL;
17791 if (info->attrs[NL80211_ATTR_ASSOC_MLD_EXT_CAPA_OPS])
17793 nla_get_u16(info->attrs[NL80211_ATTR_ASSOC_MLD_EXT_CAPA_OPS]);
17799 cfg80211_put_bss(&rdev->wiphy, req.add_links[link_id].bss);
17807 struct cfg80211_registered_device *rdev = info->user_ptr[0];
17808 struct net_device *dev = info->user_ptr[1];
17809 struct wireless_dev *wdev = dev->ieee80211_ptr;
17812 if (wdev->iftype != NL80211_IFTYPE_STATION &&
17813 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
17814 return -EOPNOTSUPP;
17816 if (!wdev->connected)
17817 return -ENOLINK;
17819 val = nla_get_flag(info->attrs[NL80211_ATTR_EPCS]);
17922 if (WARN_ON(ops->internal_flags >= ARRAY_SIZE(nl80211_internal_flags)))
17923 return -EINVAL;
17925 internal_flags = nl80211_internal_flags[ops->internal_flags];
17934 info->user_ptr[0] = rdev;
17938 info->attrs);
17944 dev = wdev->netdev;
17946 rdev = wiphy_to_rdev(wdev->wiphy);
17950 err = -EINVAL;
17954 info->user_ptr[1] = dev;
17956 info->user_ptr[1] = wdev;
17961 err = -ENETDOWN;
17965 info->user_ptr[0] = rdev;
17969 struct nlattr *link_id = info->attrs[NL80211_ATTR_MLO_LINK_ID];
17972 err = -EINVAL;
17976 /* MLO -> require valid link ID */
17977 if (wdev->valid_links &&
17979 !(wdev->valid_links & BIT(nla_get_u8(link_id))))) {
17980 err = -EINVAL;
17984 /* non-MLO -> no link ID attribute accepted */
17985 if (!wdev->valid_links && link_id) {
17986 err = -EINVAL;
17992 if (info->attrs[NL80211_ATTR_MLO_LINK_ID] ||
17993 (wdev && wdev->valid_links)) {
17994 err = -EINVAL;
18000 wiphy_lock(&rdev->wiphy);
18002 __release(&rdev->wiphy.mtx);
18018 u32 internal_flags = nl80211_internal_flags[ops->internal_flags];
18020 if (info->user_ptr[1]) {
18022 struct wireless_dev *wdev = info->user_ptr[1];
18024 dev_put(wdev->netdev);
18026 dev_put(info->user_ptr[1]);
18030 if (info->user_ptr[0] &&
18032 struct cfg80211_registered_device *rdev = info->user_ptr[0];
18035 __acquire(&rdev->wiphy.mtx);
18036 wiphy_unlock(&rdev->wiphy);
18061 return -EINVAL;
18065 return -EINVAL;
18070 if (range_index >= rdev->wiphy.sar_capa->num_freq_ranges)
18071 return -EINVAL;
18075 if (sar_specs->sub_specs[i].freq_range_index == range_index)
18076 return -EINVAL;
18079 sar_specs->sub_specs[index].power =
18082 sar_specs->sub_specs[index].freq_range_index = range_index;
18089 struct cfg80211_registered_device *rdev = info->user_ptr[0];
18098 if (!rdev->wiphy.sar_capa || !rdev->ops->set_sar_specs)
18099 return -EOPNOTSUPP;
18101 if (!info->attrs[NL80211_ATTR_SAR_SPEC])
18102 return -EINVAL;
18105 info->attrs[NL80211_ATTR_SAR_SPEC],
18109 return -EINVAL;
18112 if (type != rdev->wiphy.sar_capa->type)
18113 return -EINVAL;
18119 if (specs > rdev->wiphy.sar_capa->num_freq_ranges)
18120 return -EINVAL;
18124 return -ENOMEM;
18126 sar_spec->num_sub_specs = specs;
18127 sar_spec->type = type;
18137 err = -EINVAL;
18142 err = -EINVAL;
18148 sar_spec->num_sub_specs = specs;
18150 rdev->cur_cmd_info = info;
18152 rdev->cur_cmd_info = NULL;
19071 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19090 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19097 struct cfg80211_scan_request_int *req = rdev->scan_req;
19108 for (i = 0; i < req->req.n_ssids; i++) {
19109 if (nla_put(msg, i, req->req.ssids[i].ssid_len,
19110 req->req.ssids[i].ssid))
19115 if (req->req.flags & NL80211_SCAN_FLAG_FREQ_KHZ) {
19119 for (i = 0; i < req->req.n_channels; i++) {
19121 ieee80211_channel_to_khz(req->req.channels[i])))
19130 for (i = 0; i < req->req.n_channels; i++) {
19132 req->req.channels[i]->center_freq))
19138 if (req->req.ie &&
19139 nla_put(msg, NL80211_ATTR_IE, req->req.ie_len, req->req.ie))
19142 if (req->req.flags &&
19143 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->req.flags))
19146 info = rdev->int_scan_req ? &rdev->int_scan_req->info :
19147 &rdev->scan_req->info;
19148 if (info->scan_start_tsf &&
19150 info->scan_start_tsf, NL80211_BSS_PAD) ||
19152 info->tsf_bssid)))
19157 return -ENOBUFS;
19170 return -1;
19172 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19173 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
19174 wdev->netdev->ifindex)) ||
19187 return -EMSGSIZE;
19198 return -1;
19201 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
19202 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
19203 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
19212 return -EMSGSIZE;
19230 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19260 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19277 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
19285 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
19288 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
19292 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
19296 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
19297 request->intersect) {
19305 request->alpha2))
19309 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
19310 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
19313 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
19317 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
19378 msg = nlmsg_new(100 + event->buf_len + event->req_ies_len, gfp);
19382 hdr = nl80211hdr_put(msg, 0, 0, 0, event->cmd);
19388 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19389 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19390 nla_put(msg, NL80211_ATTR_FRAME, event->buf_len, event->buf) ||
19391 (event->req_ies &&
19392 nla_put(msg, NL80211_ATTR_REQ_IE, event->req_ies_len,
19393 event->req_ies)))
19396 if (event->reconnect &&
19400 if (event->uapsd_queues >= 0) {
19407 event->uapsd_queues))
19415 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19431 .uapsd_queues = -1,
19443 .buf = data->buf,
19444 .buf_len = data->len,
19445 .uapsd_queues = data->uapsd_queues,
19446 .req_ies = data->req_ies,
19447 .req_ies_len = data->req_ies_len,
19462 .uapsd_queues = -1,
19477 .uapsd_queues = -1,
19486 struct wireless_dev *wdev = dev->ieee80211_ptr;
19487 struct wiphy *wiphy = wdev->wiphy;
19493 .uapsd_queues = -1,
19499 if (ieee80211_is_deauth(mgmt->frame_control)) {
19501 } else if (ieee80211_is_disassoc(mgmt->frame_control)) {
19503 } else if (ieee80211_is_beacon(mgmt->frame_control)) {
19504 if (wdev->unprot_beacon_reported &&
19505 elapsed_jiffies_msecs(wdev->unprot_beacon_reported) < 10000)
19508 wdev->unprot_beacon_reported = jiffies;
19535 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19536 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19543 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19576 const u8 *connected_addr = cr->valid_links ?
19577 cr->ap_mld_addr : cr->links[0].bssid;
19579 if (cr->valid_links) {
19585 link_info_size += cr->links[link].addr ?
19587 link_info_size += (cr->links[link].bssid ||
19588 cr->links[link].bss) ?
19594 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
19595 cr->fils.kek_len + cr->fils.pmk_len +
19596 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0) + link_info_size,
19607 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19608 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19612 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
19613 cr->status) ||
19614 (cr->status < 0 &&
19617 cr->timeout_reason))) ||
19618 (cr->req_ie &&
19619 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
19620 (cr->resp_ie &&
19621 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
19622 cr->resp_ie)) ||
19623 (cr->fils.update_erp_next_seq_num &&
19625 cr->fils.erp_next_seq_num)) ||
19626 (cr->status == WLAN_STATUS_SUCCESS &&
19627 ((cr->fils.kek &&
19628 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len,
19629 cr->fils.kek)) ||
19630 (cr->fils.pmk &&
19631 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) ||
19632 (cr->fils.pmkid &&
19633 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid)))))
19636 if (cr->valid_links) {
19646 const u8 *bssid = cr->links[link].bss ?
19647 cr->links[link].bss->bssid :
19648 cr->links[link].bssid;
19657 (cr->links[link].addr &&
19659 cr->links[link].addr)) ||
19661 cr->links[link].status))
19672 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19688 const u8 *connected_addr = info->ap_mld_addr ?
19689 info->ap_mld_addr :
19690 (info->links[0].bss ?
19691 info->links[0].bss->bssid :
19692 info->links[0].bssid);
19694 if (info->valid_links) {
19700 link_info_size += info->links[link].addr ?
19702 link_info_size += (info->links[link].bssid ||
19703 info->links[link].bss) ?
19708 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len +
19709 info->fils.kek_len + info->fils.pmk_len +
19710 (info->fils.pmkid ? WLAN_PMKID_LEN : 0) +
19721 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19722 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19724 (info->req_ie &&
19725 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
19726 info->req_ie)) ||
19727 (info->resp_ie &&
19728 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
19729 info->resp_ie)) ||
19730 (info->fils.update_erp_next_seq_num &&
19732 info->fils.erp_next_seq_num)) ||
19733 (info->fils.kek &&
19734 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len,
19735 info->fils.kek)) ||
19736 (info->fils.pmk &&
19737 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) ||
19738 (info->fils.pmkid &&
19739 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid)))
19742 if (info->valid_links) {
19752 const u8 *bssid = info->links[link].bss ?
19753 info->links[link].bss->bssid :
19754 info->links[link].bssid;
19763 (info->links[link].addr &&
19765 info->links[link].addr)))
19776 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19801 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19802 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19812 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19837 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19838 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19848 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19858 struct wireless_dev *wdev = dev->ieee80211_ptr;
19859 struct wiphy *wiphy = wdev->wiphy;
19865 lockdep_assert_wiphy(wdev->wiphy);
19868 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION &&
19869 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT))
19872 if (WARN_ON(!wdev->valid_links || !link_mask ||
19873 (wdev->valid_links & link_mask) != link_mask ||
19874 wdev->valid_links == link_mask))
19878 wdev->valid_links &= ~link_mask;
19890 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19891 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
19917 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19929 struct wireless_dev *wdev = dev->ieee80211_ptr;
19930 struct wiphy *wiphy = wdev->wiphy;
19934 .buf = data->buf,
19935 .buf_len = data->len,
19936 .uapsd_queues = -1,
19960 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
19961 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
19967 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
19979 struct wireless_dev *wdev = dev->ieee80211_ptr;
19980 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
19984 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
19999 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20000 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
20010 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20037 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20038 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
20041 (key_id != -1 &&
20048 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20129 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20130 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
20131 wdev->netdev->ifindex)) ||
20134 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
20147 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20158 struct wireless_dev *wdev = netdev->ieee80211_ptr;
20159 struct wiphy *wiphy = wdev->wiphy;
20176 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20177 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
20184 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20197 struct wiphy *wiphy = wdev->wiphy;
20211 struct wiphy *wiphy = wdev->wiphy;
20224 struct wiphy *wiphy = wdev->wiphy;
20236 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
20252 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20260 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
20282 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20291 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
20306 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
20313 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20325 struct wireless_dev *wdev = dev->ieee80211_ptr;
20326 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
20329 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
20344 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20345 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
20352 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
20363 struct wireless_dev *wdev = dev->ieee80211_ptr;
20368 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
20369 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
20383 struct wireless_dev *wdev = dev->ieee80211_ptr;
20388 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
20389 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
20390 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
20406 struct net_device *netdev = wdev->netdev;
20410 msg = nlmsg_new(100 + info->len, gfp);
20412 return -ENOMEM;
20417 return -ENOMEM;
20420 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20422 netdev->ifindex)) ||
20425 (info->have_link_id &&
20426 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, info->link_id)) ||
20427 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, KHZ_TO_MHZ(info->freq)) ||
20428 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET, info->freq % 1000) ||
20429 (info->sig_dbm &&
20430 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, info->sig_dbm)) ||
20431 nla_put(msg, NL80211_ATTR_FRAME, info->len, info->buf) ||
20432 (info->flags &&
20433 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, info->flags)) ||
20434 (info->rx_tstamp && nla_put_u64_64bit(msg,
20436 info->rx_tstamp,
20438 (info->ack_tstamp && nla_put_u64_64bit(msg,
20440 info->ack_tstamp,
20446 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
20450 return -ENOBUFS;
20457 struct wiphy *wiphy = wdev->wiphy;
20459 struct net_device *netdev = wdev->netdev;
20464 trace_cfg80211_mgmt_tx_status(wdev, status->cookie,
20465 status->ack);
20467 trace_cfg80211_control_port_tx_status(wdev, status->cookie,
20468 status->ack);
20470 msg = nlmsg_new(100 + status->len, gfp);
20480 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20482 netdev->ifindex)) ||
20485 nla_put(msg, NL80211_ATTR_FRAME, status->len, status->buf) ||
20486 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, status->cookie,
20488 (status->ack && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
20489 (status->tx_tstamp &&
20491 status->tx_tstamp, NL80211_ATTR_PAD)) ||
20492 (status->ack_tstamp &&
20494 status->ack_tstamp, NL80211_ATTR_PAD)))
20499 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20536 struct wireless_dev *wdev = dev->ieee80211_ptr;
20537 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
20539 const u8 *addr = ehdr->h_source;
20540 u16 proto = be16_to_cpu(skb->protocol);
20545 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid);
20548 return -ENOENT;
20550 msg = nlmsg_new(100 + skb->len, gfp);
20552 return -ENOMEM;
20557 return -ENOBUFS;
20560 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20561 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
20572 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len);
20576 skb_copy_bits(skb, 0, nla_data(frame), skb->len);
20579 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
20583 return -ENOBUFS;
20602 struct wireless_dev *wdev = dev->ieee80211_ptr;
20603 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
20610 cb = (void **)msg->cb;
20618 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20619 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
20639 void **cb = (void **)msg->cb;
20645 memset(msg->cb, 0, sizeof(msg->cb));
20647 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20655 struct wireless_dev *wdev = dev->ieee80211_ptr;
20665 cqm_config = rcu_dereference(wdev->cqm_config);
20667 cqm_config->last_rssi_event_value = rssi_level;
20668 cqm_config->last_rssi_event_type = rssi_event;
20669 wiphy_work_queue(wdev->wiphy, &wdev->cqm_rssi_work);
20685 cqm_config = wiphy_dereference(wdev->wiphy, wdev->cqm_config);
20689 if (cqm_config->use_range_api)
20690 cfg80211_cqm_rssi_update(rdev, wdev->netdev, cqm_config);
20692 rssi_level = cqm_config->last_rssi_event_value;
20693 rssi_event = cqm_config->last_rssi_event_type;
20695 msg = cfg80211_prepare_cqm(wdev->netdev, NULL, GFP_KERNEL);
20801 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20802 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
20818 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20829 struct wireless_dev *wdev = dev->ieee80211_ptr;
20830 struct wiphy *wiphy = wdev->wiphy;
20857 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
20858 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
20875 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20886 struct wireless_dev *wdev = dev->ieee80211_ptr;
20887 struct wiphy *wiphy = wdev->wiphy;
20903 struct wireless_dev *wdev = netdev->ieee80211_ptr;
20917 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
20920 if (wdev->valid_links &&
20937 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
20949 struct wireless_dev *wdev = dev->ieee80211_ptr;
20950 struct wiphy *wiphy = wdev->wiphy;
20953 lockdep_assert_wiphy(wdev->wiphy);
20958 switch (wdev->iftype) {
20961 if (!WARN_ON(!wdev->links[link_id].client.current_bss))
20963 chandef->chan);
20966 wdev->u.mesh.chandef = *chandef;
20967 wdev->u.mesh.preset_chandef = *chandef;
20971 wdev->links[link_id].ap.chandef = *chandef;
20974 wdev->u.ibss.chandef = *chandef;
20994 struct wireless_dev *wdev = dev->ieee80211_ptr;
20995 struct wiphy *wiphy = wdev->wiphy;
20998 lockdep_assert_wiphy(wdev->wiphy);
21014 struct wireless_dev *wdev = dev->ieee80211_ptr;
21015 struct wiphy *wiphy = wdev->wiphy;
21020 lockdep_assert_wiphy(wdev->wiphy);
21026 return -ENOMEM;
21032 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
21035 if (wdev->valid_links &&
21050 return genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
21055 return -EINVAL;
21078 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
21083 struct wireless_dev *wdev = netdev->ieee80211_ptr;
21085 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
21099 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21112 struct wireless_dev *wdev = dev->ieee80211_ptr;
21113 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
21129 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
21132 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
21138 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) &&
21139 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode))
21142 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) &&
21143 nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw))
21146 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) &&
21147 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss))
21152 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21166 struct wireless_dev *wdev = dev->ieee80211_ptr;
21167 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
21184 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21185 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
21196 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21215 spin_lock_bh(&rdev->beacon_registrations_lock);
21216 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
21219 spin_unlock_bh(&rdev->beacon_registrations_lock);
21227 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21240 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
21242 spin_unlock_bh(&rdev->beacon_registrations_lock);
21246 spin_unlock_bh(&rdev->beacon_registrations_lock);
21255 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
21262 return -EMSGSIZE;
21264 for (i = 0; i < nd->n_matches; i++) {
21265 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
21278 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
21279 match->ssid.ssid)) {
21284 if (match->n_channels) {
21292 for (j = 0; j < match->n_channels; j++) {
21293 if (nla_put_u32(msg, j, match->channels[j])) {
21315 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
21320 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
21323 size += wakeup->packet_present_len;
21333 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21338 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
21339 wdev->netdev->ifindex))
21350 if (wakeup->disconnect &&
21353 if (wakeup->magic_pkt &&
21356 if (wakeup->gtk_rekey_failure &&
21359 if (wakeup->eap_identity_req &&
21362 if (wakeup->four_way_handshake &&
21365 if (wakeup->rfkill_release &&
21369 if (wakeup->pattern_idx >= 0 &&
21371 wakeup->pattern_idx))
21374 if (wakeup->tcp_match &&
21378 if (wakeup->tcp_connlost &&
21382 if (wakeup->tcp_nomoretokens &&
21387 if (wakeup->unprot_deauth_disassoc &&
21392 if (wakeup->packet) {
21396 if (!wakeup->packet_80211) {
21403 if (wakeup->packet_len &&
21404 nla_put_u32(msg, len_attr, wakeup->packet_len))
21407 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
21408 wakeup->packet))
21412 if (wakeup->net_detect &&
21421 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21435 struct wireless_dev *wdev = dev->ieee80211_ptr;
21436 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
21440 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
21453 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21454 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
21463 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21481 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
21490 &rdev->sched_scan_req_list,
21492 if (sched_scan_req->owner_nlportid == notify->portid) {
21493 sched_scan_req->nl_owner_dead = true;
21494 wiphy_work_queue(&rdev->wiphy,
21495 &rdev->sched_scan_stop_wk);
21499 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
21500 cfg80211_mlme_unregister_socket(wdev, notify->portid);
21502 if (wdev->owner_nlportid == notify->portid) {
21503 wdev->nl_owner_dead = true;
21504 schedule_work(&rdev->destroy_work);
21505 } else if (wdev->conn_owner_nlportid == notify->portid) {
21506 schedule_work(&wdev->disconnect_wk);
21509 cfg80211_release_pmsr(wdev, notify->portid);
21512 spin_lock_bh(&rdev->beacon_registrations_lock);
21513 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
21515 if (reg->nlportid == notify->portid) {
21516 list_del(®->list);
21521 spin_unlock_bh(&rdev->beacon_registrations_lock);
21530 regulatory_netlink_notify(notify->portid);
21541 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
21548 if (!ft_event->target_ap)
21551 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len,
21560 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21561 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
21562 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
21565 if (ft_event->ies &&
21566 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
21568 if (ft_event->ric_ies &&
21569 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
21570 ft_event->ric_ies))
21575 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21590 rdev = wiphy_to_rdev(wdev->wiphy);
21591 if (!rdev->crit_proto_nlportid)
21594 nlportid = rdev->crit_proto_nlportid;
21595 rdev->crit_proto_nlportid = 0;
21605 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21612 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
21622 struct wiphy *wiphy = wdev->wiphy;
21635 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21636 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
21639 (wdev->valid_links &&
21656 struct wireless_dev *wdev = dev->ieee80211_ptr;
21657 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
21661 if (!wdev->conn_owner_nlportid)
21662 return -EINVAL;
21666 return -ENOMEM;
21672 /* Some historical mistakes in drivers <-> userspace interface (notably
21673 * between drivers and wpa_supplicant) led to a big-endian conversion
21677 * in big-endian. Note that newer wpa_supplicant will also detect this
21680 if (params->key_mgmt_suite == WLAN_AKM_SUITE_SAE) {
21686 params->key_mgmt_suite))
21690 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21691 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
21693 params->action) ||
21694 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) ||
21695 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len,
21696 params->ssid.ssid) ||
21697 (!is_zero_ether_addr(params->mld_addr) &&
21698 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN, params->mld_addr)))
21702 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
21703 wdev->conn_owner_nlportid);
21708 return -ENOBUFS;
21716 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
21731 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21732 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
21733 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, owe_info->peer))
21736 if (!owe_info->ie_len ||
21737 nla_put(msg, NL80211_ATTR_IE, owe_info->ie_len, owe_info->ie))
21740 if (owe_info->assoc_link_id != -1) {
21742 owe_info->assoc_link_id))
21745 if (!is_zero_ether_addr(owe_info->peer_mld_addr) &&
21747 owe_info->peer_mld_addr))
21753 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21765 struct wiphy *wiphy = wdev->wiphy;
21768 if (wdev->iftype == NL80211_IFTYPE_STATION &&
21772 wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR)))
21779 struct wireless_dev *wdev = netdev->ieee80211_ptr;
21780 struct wiphy *wiphy = wdev->wiphy;
21801 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
21813 struct wiphy *wiphy = wdev->wiphy;
21820 if (!wdev->owner_nlportid)
21832 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21835 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq))
21840 genlmsg_unicast(wiphy_net(wiphy), msg, wdev->owner_nlportid);
21853 struct wiphy *wiphy = wdev->wiphy;
21860 memcpy(wdev->u.nan.cluster_id, cluster_id, ETH_ALEN);
21870 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
21879 if (!wdev->owner_nlportid)
21884 wdev->owner_nlportid);