1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This is the new netlink-based wireless configuration interface. 4 * 5 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net> 6 * Copyright 2013-2014 Intel Mobile Communications GmbH 7 * Copyright 2015-2017 Intel Deutschland GmbH 8 * Copyright (C) 2018-2023 Intel Corporation 9 */ 10 11 #include <linux/if.h> 12 #include <linux/module.h> 13 #include <linux/err.h> 14 #include <linux/slab.h> 15 #include <linux/list.h> 16 #include <linux/if_ether.h> 17 #include <linux/ieee80211.h> 18 #include <linux/nl80211.h> 19 #include <linux/rtnetlink.h> 20 #include <linux/netlink.h> 21 #include <linux/nospec.h> 22 #include <linux/etherdevice.h> 23 #include <linux/if_vlan.h> 24 #include <net/net_namespace.h> 25 #include <net/genetlink.h> 26 #include <net/cfg80211.h> 27 #include <net/sock.h> 28 #include <net/inet_connection_sock.h> 29 #include "core.h" 30 #include "nl80211.h" 31 #include "reg.h" 32 #include "rdev-ops.h" 33 34 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev, 35 struct genl_info *info, 36 struct cfg80211_crypto_settings *settings, 37 int cipher_limit); 38 39 /* the netlink family */ 40 static struct genl_family nl80211_fam; 41 42 /* multicast groups */ 43 enum nl80211_multicast_groups { 44 NL80211_MCGRP_CONFIG, 45 NL80211_MCGRP_SCAN, 46 NL80211_MCGRP_REGULATORY, 47 NL80211_MCGRP_MLME, 48 NL80211_MCGRP_VENDOR, 49 NL80211_MCGRP_NAN, 50 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */ 51 }; 52 53 static const struct genl_multicast_group nl80211_mcgrps[] = { 54 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG }, 55 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN }, 56 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG }, 57 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME }, 58 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR }, 59 [NL80211_MCGRP_NAN] = { .name = NL80211_MULTICAST_GROUP_NAN }, 60 #ifdef CONFIG_NL80211_TESTMODE 61 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE } 62 #endif 63 }; 64 65 /* returns ERR_PTR values */ 66 static struct wireless_dev * 67 __cfg80211_wdev_from_attrs(struct cfg80211_registered_device *rdev, 68 struct net *netns, struct nlattr **attrs) 69 { 70 struct wireless_dev *result = NULL; 71 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX]; 72 bool have_wdev_id = attrs[NL80211_ATTR_WDEV]; 73 u64 wdev_id = 0; 74 int wiphy_idx = -1; 75 int ifidx = -1; 76 77 if (!have_ifidx && !have_wdev_id) 78 return ERR_PTR(-EINVAL); 79 80 if (have_ifidx) 81 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]); 82 if (have_wdev_id) { 83 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]); 84 wiphy_idx = wdev_id >> 32; 85 } 86 87 if (rdev) { 88 struct wireless_dev *wdev; 89 90 lockdep_assert_held(&rdev->wiphy.mtx); 91 92 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 93 if (have_ifidx && wdev->netdev && 94 wdev->netdev->ifindex == ifidx) { 95 result = wdev; 96 break; 97 } 98 if (have_wdev_id && wdev->identifier == (u32)wdev_id) { 99 result = wdev; 100 break; 101 } 102 } 103 104 return result ?: ERR_PTR(-ENODEV); 105 } 106 107 ASSERT_RTNL(); 108 109 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 110 struct wireless_dev *wdev; 111 112 if (wiphy_net(&rdev->wiphy) != netns) 113 continue; 114 115 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx) 116 continue; 117 118 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 119 if (have_ifidx && wdev->netdev && 120 wdev->netdev->ifindex == ifidx) { 121 result = wdev; 122 break; 123 } 124 if (have_wdev_id && wdev->identifier == (u32)wdev_id) { 125 result = wdev; 126 break; 127 } 128 } 129 130 if (result) 131 break; 132 } 133 134 if (result) 135 return result; 136 return ERR_PTR(-ENODEV); 137 } 138 139 static struct cfg80211_registered_device * 140 __cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs) 141 { 142 struct cfg80211_registered_device *rdev = NULL, *tmp; 143 struct net_device *netdev; 144 145 ASSERT_RTNL(); 146 147 if (!attrs[NL80211_ATTR_WIPHY] && 148 !attrs[NL80211_ATTR_IFINDEX] && 149 !attrs[NL80211_ATTR_WDEV]) 150 return ERR_PTR(-EINVAL); 151 152 if (attrs[NL80211_ATTR_WIPHY]) 153 rdev = cfg80211_rdev_by_wiphy_idx( 154 nla_get_u32(attrs[NL80211_ATTR_WIPHY])); 155 156 if (attrs[NL80211_ATTR_WDEV]) { 157 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]); 158 struct wireless_dev *wdev; 159 bool found = false; 160 161 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32); 162 if (tmp) { 163 /* make sure wdev exists */ 164 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) { 165 if (wdev->identifier != (u32)wdev_id) 166 continue; 167 found = true; 168 break; 169 } 170 171 if (!found) 172 tmp = NULL; 173 174 if (rdev && tmp != rdev) 175 return ERR_PTR(-EINVAL); 176 rdev = tmp; 177 } 178 } 179 180 if (attrs[NL80211_ATTR_IFINDEX]) { 181 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]); 182 183 netdev = __dev_get_by_index(netns, ifindex); 184 if (netdev) { 185 if (netdev->ieee80211_ptr) 186 tmp = wiphy_to_rdev( 187 netdev->ieee80211_ptr->wiphy); 188 else 189 tmp = NULL; 190 191 /* not wireless device -- return error */ 192 if (!tmp) 193 return ERR_PTR(-EINVAL); 194 195 /* mismatch -- return error */ 196 if (rdev && tmp != rdev) 197 return ERR_PTR(-EINVAL); 198 199 rdev = tmp; 200 } 201 } 202 203 if (!rdev) 204 return ERR_PTR(-ENODEV); 205 206 if (netns != wiphy_net(&rdev->wiphy)) 207 return ERR_PTR(-ENODEV); 208 209 return rdev; 210 } 211 212 /* 213 * This function returns a pointer to the driver 214 * that the genl_info item that is passed refers to. 215 * 216 * The result of this can be a PTR_ERR and hence must 217 * be checked with IS_ERR() for errors. 218 */ 219 static struct cfg80211_registered_device * 220 cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info) 221 { 222 return __cfg80211_rdev_from_attrs(netns, info->attrs); 223 } 224 225 static int validate_beacon_head(const struct nlattr *attr, 226 struct netlink_ext_ack *extack) 227 { 228 const u8 *data = nla_data(attr); 229 unsigned int len = nla_len(attr); 230 const struct element *elem; 231 const struct ieee80211_mgmt *mgmt = (void *)data; 232 unsigned int fixedlen, hdrlen; 233 bool s1g_bcn; 234 235 if (len < offsetofend(typeof(*mgmt), frame_control)) 236 goto err; 237 238 s1g_bcn = ieee80211_is_s1g_beacon(mgmt->frame_control); 239 if (s1g_bcn) { 240 fixedlen = offsetof(struct ieee80211_ext, 241 u.s1g_beacon.variable); 242 hdrlen = offsetof(struct ieee80211_ext, u.s1g_beacon); 243 } else { 244 fixedlen = offsetof(struct ieee80211_mgmt, 245 u.beacon.variable); 246 hdrlen = offsetof(struct ieee80211_mgmt, u.beacon); 247 } 248 249 if (len < fixedlen) 250 goto err; 251 252 if (ieee80211_hdrlen(mgmt->frame_control) != hdrlen) 253 goto err; 254 255 data += fixedlen; 256 len -= fixedlen; 257 258 for_each_element(elem, data, len) { 259 /* nothing */ 260 } 261 262 if (for_each_element_completed(elem, data, len)) 263 return 0; 264 265 err: 266 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed beacon head"); 267 return -EINVAL; 268 } 269 270 static int validate_ie_attr(const struct nlattr *attr, 271 struct netlink_ext_ack *extack) 272 { 273 const u8 *data = nla_data(attr); 274 unsigned int len = nla_len(attr); 275 const struct element *elem; 276 277 for_each_element(elem, data, len) { 278 /* nothing */ 279 } 280 281 if (for_each_element_completed(elem, data, len)) 282 return 0; 283 284 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed information elements"); 285 return -EINVAL; 286 } 287 288 static int validate_he_capa(const struct nlattr *attr, 289 struct netlink_ext_ack *extack) 290 { 291 if (!ieee80211_he_capa_size_ok(nla_data(attr), nla_len(attr))) 292 return -EINVAL; 293 294 return 0; 295 } 296 297 /* policy for the attributes */ 298 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR]; 299 300 static const struct nla_policy 301 nl80211_ftm_responder_policy[NL80211_FTM_RESP_ATTR_MAX + 1] = { 302 [NL80211_FTM_RESP_ATTR_ENABLED] = { .type = NLA_FLAG, }, 303 [NL80211_FTM_RESP_ATTR_LCI] = { .type = NLA_BINARY, 304 .len = U8_MAX }, 305 [NL80211_FTM_RESP_ATTR_CIVICLOC] = { .type = NLA_BINARY, 306 .len = U8_MAX }, 307 }; 308 309 static const struct nla_policy 310 nl80211_pmsr_ftm_req_attr_policy[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1] = { 311 [NL80211_PMSR_FTM_REQ_ATTR_ASAP] = { .type = NLA_FLAG }, 312 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE] = { .type = NLA_U32 }, 313 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP] = 314 NLA_POLICY_MAX(NLA_U8, 15), 315 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD] = { .type = NLA_U16 }, 316 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION] = 317 NLA_POLICY_MAX(NLA_U8, 15), 318 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST] = 319 NLA_POLICY_MAX(NLA_U8, 31), 320 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES] = { .type = NLA_U8 }, 321 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI] = { .type = NLA_FLAG }, 322 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC] = { .type = NLA_FLAG }, 323 [NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED] = { .type = NLA_FLAG }, 324 [NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED] = { .type = NLA_FLAG }, 325 [NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK] = { .type = NLA_FLAG }, 326 [NL80211_PMSR_FTM_REQ_ATTR_BSS_COLOR] = { .type = NLA_U8 }, 327 }; 328 329 static const struct nla_policy 330 nl80211_pmsr_req_data_policy[NL80211_PMSR_TYPE_MAX + 1] = { 331 [NL80211_PMSR_TYPE_FTM] = 332 NLA_POLICY_NESTED(nl80211_pmsr_ftm_req_attr_policy), 333 }; 334 335 static const struct nla_policy 336 nl80211_pmsr_req_attr_policy[NL80211_PMSR_REQ_ATTR_MAX + 1] = { 337 [NL80211_PMSR_REQ_ATTR_DATA] = 338 NLA_POLICY_NESTED(nl80211_pmsr_req_data_policy), 339 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF] = { .type = NLA_FLAG }, 340 }; 341 342 static const struct nla_policy 343 nl80211_pmsr_peer_attr_policy[NL80211_PMSR_PEER_ATTR_MAX + 1] = { 344 [NL80211_PMSR_PEER_ATTR_ADDR] = NLA_POLICY_ETH_ADDR, 345 [NL80211_PMSR_PEER_ATTR_CHAN] = NLA_POLICY_NESTED(nl80211_policy), 346 [NL80211_PMSR_PEER_ATTR_REQ] = 347 NLA_POLICY_NESTED(nl80211_pmsr_req_attr_policy), 348 [NL80211_PMSR_PEER_ATTR_RESP] = { .type = NLA_REJECT }, 349 }; 350 351 static const struct nla_policy 352 nl80211_pmsr_attr_policy[NL80211_PMSR_ATTR_MAX + 1] = { 353 [NL80211_PMSR_ATTR_MAX_PEERS] = { .type = NLA_REJECT }, 354 [NL80211_PMSR_ATTR_REPORT_AP_TSF] = { .type = NLA_REJECT }, 355 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR] = { .type = NLA_REJECT }, 356 [NL80211_PMSR_ATTR_TYPE_CAPA] = { .type = NLA_REJECT }, 357 [NL80211_PMSR_ATTR_PEERS] = 358 NLA_POLICY_NESTED_ARRAY(nl80211_pmsr_peer_attr_policy), 359 }; 360 361 static const struct nla_policy 362 he_obss_pd_policy[NL80211_HE_OBSS_PD_ATTR_MAX + 1] = { 363 [NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] = 364 NLA_POLICY_RANGE(NLA_U8, 1, 20), 365 [NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET] = 366 NLA_POLICY_RANGE(NLA_U8, 1, 20), 367 [NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET] = 368 NLA_POLICY_RANGE(NLA_U8, 1, 20), 369 [NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP] = 370 NLA_POLICY_EXACT_LEN(8), 371 [NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP] = 372 NLA_POLICY_EXACT_LEN(8), 373 [NL80211_HE_OBSS_PD_ATTR_SR_CTRL] = { .type = NLA_U8 }, 374 }; 375 376 static const struct nla_policy 377 he_bss_color_policy[NL80211_HE_BSS_COLOR_ATTR_MAX + 1] = { 378 [NL80211_HE_BSS_COLOR_ATTR_COLOR] = NLA_POLICY_RANGE(NLA_U8, 1, 63), 379 [NL80211_HE_BSS_COLOR_ATTR_DISABLED] = { .type = NLA_FLAG }, 380 [NL80211_HE_BSS_COLOR_ATTR_PARTIAL] = { .type = NLA_FLAG }, 381 }; 382 383 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = { 384 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY, 385 .len = NL80211_MAX_SUPP_RATES }, 386 [NL80211_TXRATE_HT] = { .type = NLA_BINARY, 387 .len = NL80211_MAX_SUPP_HT_RATES }, 388 [NL80211_TXRATE_VHT] = NLA_POLICY_EXACT_LEN_WARN(sizeof(struct nl80211_txrate_vht)), 389 [NL80211_TXRATE_GI] = { .type = NLA_U8 }, 390 [NL80211_TXRATE_HE] = NLA_POLICY_EXACT_LEN(sizeof(struct nl80211_txrate_he)), 391 [NL80211_TXRATE_HE_GI] = NLA_POLICY_RANGE(NLA_U8, 392 NL80211_RATE_INFO_HE_GI_0_8, 393 NL80211_RATE_INFO_HE_GI_3_2), 394 [NL80211_TXRATE_HE_LTF] = NLA_POLICY_RANGE(NLA_U8, 395 NL80211_RATE_INFO_HE_1XLTF, 396 NL80211_RATE_INFO_HE_4XLTF), 397 }; 398 399 static const struct nla_policy 400 nl80211_tid_config_attr_policy[NL80211_TID_CONFIG_ATTR_MAX + 1] = { 401 [NL80211_TID_CONFIG_ATTR_VIF_SUPP] = { .type = NLA_U64 }, 402 [NL80211_TID_CONFIG_ATTR_PEER_SUPP] = { .type = NLA_U64 }, 403 [NL80211_TID_CONFIG_ATTR_OVERRIDE] = { .type = NLA_FLAG }, 404 [NL80211_TID_CONFIG_ATTR_TIDS] = NLA_POLICY_RANGE(NLA_U16, 1, 0xff), 405 [NL80211_TID_CONFIG_ATTR_NOACK] = 406 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE), 407 [NL80211_TID_CONFIG_ATTR_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1), 408 [NL80211_TID_CONFIG_ATTR_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1), 409 [NL80211_TID_CONFIG_ATTR_AMPDU_CTRL] = 410 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE), 411 [NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL] = 412 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE), 413 [NL80211_TID_CONFIG_ATTR_AMSDU_CTRL] = 414 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE), 415 [NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE] = 416 NLA_POLICY_MAX(NLA_U8, NL80211_TX_RATE_FIXED), 417 [NL80211_TID_CONFIG_ATTR_TX_RATE] = 418 NLA_POLICY_NESTED(nl80211_txattr_policy), 419 }; 420 421 static const struct nla_policy 422 nl80211_fils_discovery_policy[NL80211_FILS_DISCOVERY_ATTR_MAX + 1] = { 423 [NL80211_FILS_DISCOVERY_ATTR_INT_MIN] = NLA_POLICY_MAX(NLA_U32, 10000), 424 [NL80211_FILS_DISCOVERY_ATTR_INT_MAX] = NLA_POLICY_MAX(NLA_U32, 10000), 425 [NL80211_FILS_DISCOVERY_ATTR_TMPL] = 426 NLA_POLICY_RANGE(NLA_BINARY, 427 NL80211_FILS_DISCOVERY_TMPL_MIN_LEN, 428 IEEE80211_MAX_DATA_LEN), 429 }; 430 431 static const struct nla_policy 432 nl80211_unsol_bcast_probe_resp_policy[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX + 1] = { 433 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT] = NLA_POLICY_MAX(NLA_U32, 20), 434 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL] = { .type = NLA_BINARY, 435 .len = IEEE80211_MAX_DATA_LEN } 436 }; 437 438 static const struct nla_policy 439 sar_specs_policy[NL80211_SAR_ATTR_SPECS_MAX + 1] = { 440 [NL80211_SAR_ATTR_SPECS_POWER] = { .type = NLA_S32 }, 441 [NL80211_SAR_ATTR_SPECS_RANGE_INDEX] = {.type = NLA_U32 }, 442 }; 443 444 static const struct nla_policy 445 sar_policy[NL80211_SAR_ATTR_MAX + 1] = { 446 [NL80211_SAR_ATTR_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_SAR_TYPE), 447 [NL80211_SAR_ATTR_SPECS] = NLA_POLICY_NESTED_ARRAY(sar_specs_policy), 448 }; 449 450 static const struct nla_policy 451 nl80211_mbssid_config_policy[NL80211_MBSSID_CONFIG_ATTR_MAX + 1] = { 452 [NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES] = NLA_POLICY_MIN(NLA_U8, 2), 453 [NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY] = 454 NLA_POLICY_MIN(NLA_U8, 1), 455 [NL80211_MBSSID_CONFIG_ATTR_INDEX] = { .type = NLA_U8 }, 456 [NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX] = { .type = NLA_U32 }, 457 [NL80211_MBSSID_CONFIG_ATTR_EMA] = { .type = NLA_FLAG }, 458 }; 459 460 static const struct nla_policy 461 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = { 462 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 }, 463 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 }, 464 }; 465 466 static struct netlink_range_validation nl80211_punct_bitmap_range = { 467 .min = 0, 468 .max = 0xffff, 469 }; 470 471 static struct netlink_range_validation q_range = { 472 .max = INT_MAX, 473 }; 474 475 static const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = { 476 [0] = { .strict_start_type = NL80211_ATTR_HE_OBSS_PD }, 477 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 }, 478 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING, 479 .len = 20-1 }, 480 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED }, 481 482 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 }, 483 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 }, 484 [NL80211_ATTR_WIPHY_EDMG_CHANNELS] = NLA_POLICY_RANGE(NLA_U8, 485 NL80211_EDMG_CHANNELS_MIN, 486 NL80211_EDMG_CHANNELS_MAX), 487 [NL80211_ATTR_WIPHY_EDMG_BW_CONFIG] = NLA_POLICY_RANGE(NLA_U8, 488 NL80211_EDMG_BW_CONFIG_MIN, 489 NL80211_EDMG_BW_CONFIG_MAX), 490 491 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 }, 492 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 }, 493 [NL80211_ATTR_CENTER_FREQ1_OFFSET] = NLA_POLICY_RANGE(NLA_U32, 0, 999), 494 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 }, 495 496 [NL80211_ATTR_WIPHY_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1), 497 [NL80211_ATTR_WIPHY_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1), 498 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 }, 499 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 }, 500 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 }, 501 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG }, 502 503 [NL80211_ATTR_IFTYPE] = NLA_POLICY_MAX(NLA_U32, NL80211_IFTYPE_MAX), 504 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 }, 505 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 }, 506 507 [NL80211_ATTR_MAC] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 508 [NL80211_ATTR_PREV_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 509 510 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, }, 511 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY, 512 .len = WLAN_MAX_KEY_LEN }, 513 [NL80211_ATTR_KEY_IDX] = NLA_POLICY_MAX(NLA_U8, 7), 514 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 }, 515 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG }, 516 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 }, 517 [NL80211_ATTR_KEY_TYPE] = 518 NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES), 519 520 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 }, 521 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 }, 522 [NL80211_ATTR_BEACON_HEAD] = 523 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_beacon_head, 524 IEEE80211_MAX_DATA_LEN), 525 [NL80211_ATTR_BEACON_TAIL] = 526 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr, 527 IEEE80211_MAX_DATA_LEN), 528 [NL80211_ATTR_STA_AID] = 529 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID), 530 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED }, 531 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 }, 532 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY, 533 .len = NL80211_MAX_SUPP_RATES }, 534 [NL80211_ATTR_STA_PLINK_ACTION] = 535 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1), 536 [NL80211_ATTR_STA_TX_POWER_SETTING] = 537 NLA_POLICY_RANGE(NLA_U8, 538 NL80211_TX_POWER_AUTOMATIC, 539 NL80211_TX_POWER_FIXED), 540 [NL80211_ATTR_STA_TX_POWER] = { .type = NLA_S16 }, 541 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 }, 542 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ }, 543 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY, 544 .len = IEEE80211_MAX_MESH_ID_LEN }, 545 [NL80211_ATTR_MPATH_NEXT_HOP] = NLA_POLICY_ETH_ADDR_COMPAT, 546 547 /* allow 3 for NUL-termination, we used to declare this NLA_STRING */ 548 [NL80211_ATTR_REG_ALPHA2] = NLA_POLICY_RANGE(NLA_BINARY, 2, 3), 549 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED }, 550 551 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 }, 552 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 }, 553 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 }, 554 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY, 555 .len = NL80211_MAX_SUPP_RATES }, 556 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 }, 557 558 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED }, 559 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG }, 560 561 [NL80211_ATTR_HT_CAPABILITY] = NLA_POLICY_EXACT_LEN_WARN(NL80211_HT_CAPABILITY_LEN), 562 563 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 }, 564 [NL80211_ATTR_IE] = NLA_POLICY_VALIDATE_FN(NLA_BINARY, 565 validate_ie_attr, 566 IEEE80211_MAX_DATA_LEN), 567 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED }, 568 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED }, 569 570 [NL80211_ATTR_SSID] = { .type = NLA_BINARY, 571 .len = IEEE80211_MAX_SSID_LEN }, 572 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 }, 573 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 }, 574 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG }, 575 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG }, 576 [NL80211_ATTR_USE_MFP] = NLA_POLICY_RANGE(NLA_U32, 577 NL80211_MFP_NO, 578 NL80211_MFP_OPTIONAL), 579 [NL80211_ATTR_STA_FLAGS2] = 580 NLA_POLICY_EXACT_LEN_WARN(sizeof(struct nl80211_sta_flag_update)), 581 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG }, 582 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 }, 583 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG }, 584 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211] = { .type = NLA_FLAG }, 585 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG }, 586 [NL80211_ATTR_STATUS_CODE] = { .type = NLA_U16 }, 587 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 }, 588 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 }, 589 [NL80211_ATTR_PID] = { .type = NLA_U32 }, 590 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 }, 591 [NL80211_ATTR_PMKID] = NLA_POLICY_EXACT_LEN_WARN(WLAN_PMKID_LEN), 592 [NL80211_ATTR_DURATION] = { .type = NLA_U32 }, 593 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 }, 594 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED }, 595 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY, 596 .len = IEEE80211_MAX_DATA_LEN }, 597 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, }, 598 [NL80211_ATTR_PS_STATE] = NLA_POLICY_RANGE(NLA_U32, 599 NL80211_PS_DISABLED, 600 NL80211_PS_ENABLED), 601 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, }, 602 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG }, 603 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 }, 604 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 }, 605 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 }, 606 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 }, 607 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 }, 608 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 }, 609 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 }, 610 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG }, 611 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED }, 612 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED }, 613 [NL80211_ATTR_STA_PLINK_STATE] = 614 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1), 615 [NL80211_ATTR_MEASUREMENT_DURATION] = { .type = NLA_U16 }, 616 [NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY] = { .type = NLA_FLAG }, 617 [NL80211_ATTR_MESH_PEER_AID] = 618 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID), 619 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 }, 620 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED }, 621 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED }, 622 [NL80211_ATTR_HIDDEN_SSID] = 623 NLA_POLICY_RANGE(NLA_U32, 624 NL80211_HIDDEN_SSID_NOT_IN_USE, 625 NL80211_HIDDEN_SSID_ZERO_CONTENTS), 626 [NL80211_ATTR_IE_PROBE_RESP] = 627 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr, 628 IEEE80211_MAX_DATA_LEN), 629 [NL80211_ATTR_IE_ASSOC_RESP] = 630 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr, 631 IEEE80211_MAX_DATA_LEN), 632 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG }, 633 [NL80211_ATTR_STA_WME] = NLA_POLICY_NESTED(nl80211_sta_wme_policy), 634 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED }, 635 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG }, 636 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 }, 637 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 }, 638 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 }, 639 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG }, 640 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG }, 641 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG }, 642 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG }, 643 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY, 644 .len = IEEE80211_MAX_DATA_LEN }, 645 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 }, 646 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG }, 647 [NL80211_ATTR_HT_CAPABILITY_MASK] = { 648 .len = NL80211_HT_CAPABILITY_LEN 649 }, 650 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 }, 651 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 }, 652 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 }, 653 [NL80211_ATTR_WDEV] = { .type = NLA_U64 }, 654 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 }, 655 656 /* need to include at least Auth Transaction and Status Code */ 657 [NL80211_ATTR_AUTH_DATA] = NLA_POLICY_MIN_LEN(4), 658 659 [NL80211_ATTR_VHT_CAPABILITY] = NLA_POLICY_EXACT_LEN_WARN(NL80211_VHT_CAPABILITY_LEN), 660 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 }, 661 [NL80211_ATTR_P2P_CTWINDOW] = NLA_POLICY_MAX(NLA_U8, 127), 662 [NL80211_ATTR_P2P_OPPPS] = NLA_POLICY_MAX(NLA_U8, 1), 663 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] = 664 NLA_POLICY_RANGE(NLA_U32, 665 NL80211_MESH_POWER_UNKNOWN + 1, 666 NL80211_MESH_POWER_MAX), 667 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 }, 668 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED }, 669 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 }, 670 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, }, 671 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, }, 672 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG }, 673 [NL80211_ATTR_VHT_CAPABILITY_MASK] = { 674 .len = NL80211_VHT_CAPABILITY_LEN, 675 }, 676 [NL80211_ATTR_MDID] = { .type = NLA_U16 }, 677 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY, 678 .len = IEEE80211_MAX_DATA_LEN }, 679 [NL80211_ATTR_CRIT_PROT_ID] = { .type = NLA_U16 }, 680 [NL80211_ATTR_MAX_CRIT_PROT_DURATION] = 681 NLA_POLICY_MAX(NLA_U16, NL80211_CRIT_PROTO_MAX_DURATION), 682 [NL80211_ATTR_PEER_AID] = 683 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID), 684 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 }, 685 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG }, 686 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED }, 687 [NL80211_ATTR_CNTDWN_OFFS_BEACON] = { .type = NLA_BINARY }, 688 [NL80211_ATTR_CNTDWN_OFFS_PRESP] = { .type = NLA_BINARY }, 689 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = NLA_POLICY_MIN_LEN(2), 690 /* 691 * The value of the Length field of the Supported Operating 692 * Classes element is between 2 and 253. 693 */ 694 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = 695 NLA_POLICY_RANGE(NLA_BINARY, 2, 253), 696 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG }, 697 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 }, 698 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 }, 699 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 }, 700 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY }, 701 [NL80211_ATTR_QOS_MAP] = NLA_POLICY_RANGE(NLA_BINARY, 702 IEEE80211_QOS_MAP_LEN_MIN, 703 IEEE80211_QOS_MAP_LEN_MAX), 704 [NL80211_ATTR_MAC_HINT] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 705 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 }, 706 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 }, 707 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG }, 708 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY }, 709 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG }, 710 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1), 711 [NL80211_ATTR_USER_PRIO] = 712 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1), 713 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 }, 714 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 }, 715 [NL80211_ATTR_OPER_CLASS] = { .type = NLA_U8 }, 716 [NL80211_ATTR_MAC_MASK] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 717 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG }, 718 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 }, 719 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 }, 720 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG }, 721 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG }, 722 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED }, 723 [NL80211_ATTR_STA_SUPPORT_P2P_PS] = 724 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1), 725 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = { 726 .len = VHT_MUMIMO_GROUPS_DATA_LEN 727 }, 728 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 729 [NL80211_ATTR_NAN_MASTER_PREF] = NLA_POLICY_MIN(NLA_U8, 1), 730 [NL80211_ATTR_BANDS] = { .type = NLA_U32 }, 731 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED }, 732 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY, 733 .len = FILS_MAX_KEK_LEN }, 734 [NL80211_ATTR_FILS_NONCES] = NLA_POLICY_EXACT_LEN_WARN(2 * FILS_NONCE_LEN), 735 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, }, 736 [NL80211_ATTR_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 737 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 }, 738 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = { 739 .len = sizeof(struct nl80211_bss_select_rssi_adjust) 740 }, 741 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 }, 742 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY, 743 .len = FILS_ERP_MAX_USERNAME_LEN }, 744 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY, 745 .len = FILS_ERP_MAX_REALM_LEN }, 746 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 }, 747 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY, 748 .len = FILS_ERP_MAX_RRK_LEN }, 749 [NL80211_ATTR_FILS_CACHE_ID] = NLA_POLICY_EXACT_LEN_WARN(2), 750 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN }, 751 [NL80211_ATTR_PMKR0_NAME] = NLA_POLICY_EXACT_LEN(WLAN_PMK_NAME_LEN), 752 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG }, 753 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT] = { .type = NLA_FLAG }, 754 755 [NL80211_ATTR_TXQ_LIMIT] = { .type = NLA_U32 }, 756 [NL80211_ATTR_TXQ_MEMORY_LIMIT] = { .type = NLA_U32 }, 757 [NL80211_ATTR_TXQ_QUANTUM] = NLA_POLICY_FULL_RANGE(NLA_U32, &q_range), 758 [NL80211_ATTR_HE_CAPABILITY] = 759 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_he_capa, 760 NL80211_HE_MAX_CAPABILITY_LEN), 761 [NL80211_ATTR_FTM_RESPONDER] = 762 NLA_POLICY_NESTED(nl80211_ftm_responder_policy), 763 [NL80211_ATTR_TIMEOUT] = NLA_POLICY_MIN(NLA_U32, 1), 764 [NL80211_ATTR_PEER_MEASUREMENTS] = 765 NLA_POLICY_NESTED(nl80211_pmsr_attr_policy), 766 [NL80211_ATTR_AIRTIME_WEIGHT] = NLA_POLICY_MIN(NLA_U16, 1), 767 [NL80211_ATTR_SAE_PASSWORD] = { .type = NLA_BINARY, 768 .len = SAE_PASSWORD_MAX_LEN }, 769 [NL80211_ATTR_TWT_RESPONDER] = { .type = NLA_FLAG }, 770 [NL80211_ATTR_HE_OBSS_PD] = NLA_POLICY_NESTED(he_obss_pd_policy), 771 [NL80211_ATTR_VLAN_ID] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2), 772 [NL80211_ATTR_HE_BSS_COLOR] = NLA_POLICY_NESTED(he_bss_color_policy), 773 [NL80211_ATTR_TID_CONFIG] = 774 NLA_POLICY_NESTED_ARRAY(nl80211_tid_config_attr_policy), 775 [NL80211_ATTR_CONTROL_PORT_NO_PREAUTH] = { .type = NLA_FLAG }, 776 [NL80211_ATTR_PMK_LIFETIME] = NLA_POLICY_MIN(NLA_U32, 1), 777 [NL80211_ATTR_PMK_REAUTH_THRESHOLD] = NLA_POLICY_RANGE(NLA_U8, 1, 100), 778 [NL80211_ATTR_RECEIVE_MULTICAST] = { .type = NLA_FLAG }, 779 [NL80211_ATTR_WIPHY_FREQ_OFFSET] = NLA_POLICY_RANGE(NLA_U32, 0, 999), 780 [NL80211_ATTR_SCAN_FREQ_KHZ] = { .type = NLA_NESTED }, 781 [NL80211_ATTR_HE_6GHZ_CAPABILITY] = 782 NLA_POLICY_EXACT_LEN(sizeof(struct ieee80211_he_6ghz_capa)), 783 [NL80211_ATTR_FILS_DISCOVERY] = 784 NLA_POLICY_NESTED(nl80211_fils_discovery_policy), 785 [NL80211_ATTR_UNSOL_BCAST_PROBE_RESP] = 786 NLA_POLICY_NESTED(nl80211_unsol_bcast_probe_resp_policy), 787 [NL80211_ATTR_S1G_CAPABILITY] = 788 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN), 789 [NL80211_ATTR_S1G_CAPABILITY_MASK] = 790 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN), 791 [NL80211_ATTR_SAE_PWE] = 792 NLA_POLICY_RANGE(NLA_U8, NL80211_SAE_PWE_HUNT_AND_PECK, 793 NL80211_SAE_PWE_BOTH), 794 [NL80211_ATTR_RECONNECT_REQUESTED] = { .type = NLA_REJECT }, 795 [NL80211_ATTR_SAR_SPEC] = NLA_POLICY_NESTED(sar_policy), 796 [NL80211_ATTR_DISABLE_HE] = { .type = NLA_FLAG }, 797 [NL80211_ATTR_OBSS_COLOR_BITMAP] = { .type = NLA_U64 }, 798 [NL80211_ATTR_COLOR_CHANGE_COUNT] = { .type = NLA_U8 }, 799 [NL80211_ATTR_COLOR_CHANGE_COLOR] = { .type = NLA_U8 }, 800 [NL80211_ATTR_COLOR_CHANGE_ELEMS] = NLA_POLICY_NESTED(nl80211_policy), 801 [NL80211_ATTR_MBSSID_CONFIG] = 802 NLA_POLICY_NESTED(nl80211_mbssid_config_policy), 803 [NL80211_ATTR_MBSSID_ELEMS] = { .type = NLA_NESTED }, 804 [NL80211_ATTR_RADAR_BACKGROUND] = { .type = NLA_FLAG }, 805 [NL80211_ATTR_AP_SETTINGS_FLAGS] = { .type = NLA_U32 }, 806 [NL80211_ATTR_EHT_CAPABILITY] = 807 NLA_POLICY_RANGE(NLA_BINARY, 808 NL80211_EHT_MIN_CAPABILITY_LEN, 809 NL80211_EHT_MAX_CAPABILITY_LEN), 810 [NL80211_ATTR_DISABLE_EHT] = { .type = NLA_FLAG }, 811 [NL80211_ATTR_MLO_LINKS] = 812 NLA_POLICY_NESTED_ARRAY(nl80211_policy), 813 [NL80211_ATTR_MLO_LINK_ID] = 814 NLA_POLICY_RANGE(NLA_U8, 0, IEEE80211_MLD_MAX_NUM_LINKS), 815 [NL80211_ATTR_MLD_ADDR] = NLA_POLICY_EXACT_LEN(ETH_ALEN), 816 [NL80211_ATTR_MLO_SUPPORT] = { .type = NLA_FLAG }, 817 [NL80211_ATTR_MAX_NUM_AKM_SUITES] = { .type = NLA_REJECT }, 818 [NL80211_ATTR_PUNCT_BITMAP] = 819 NLA_POLICY_FULL_RANGE(NLA_U32, &nl80211_punct_bitmap_range), 820 821 [NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS] = { .type = NLA_U16 }, 822 [NL80211_ATTR_HW_TIMESTAMP_ENABLED] = { .type = NLA_FLAG }, 823 [NL80211_ATTR_EMA_RNR_ELEMS] = { .type = NLA_NESTED }, 824 [NL80211_ATTR_MLO_LINK_DISABLED] = { .type = NLA_FLAG }, 825 }; 826 827 /* policy for the key attributes */ 828 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = { 829 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN }, 830 [NL80211_KEY_IDX] = { .type = NLA_U8 }, 831 [NL80211_KEY_CIPHER] = { .type = NLA_U32 }, 832 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 }, 833 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG }, 834 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG }, 835 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1), 836 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED }, 837 [NL80211_KEY_MODE] = NLA_POLICY_RANGE(NLA_U8, 0, NL80211_KEY_SET_TX), 838 }; 839 840 /* policy for the key default flags */ 841 static const struct nla_policy 842 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = { 843 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG }, 844 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG }, 845 }; 846 847 #ifdef CONFIG_PM 848 /* policy for WoWLAN attributes */ 849 static const struct nla_policy 850 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = { 851 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG }, 852 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG }, 853 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG }, 854 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED }, 855 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG }, 856 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG }, 857 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG }, 858 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG }, 859 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED }, 860 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED }, 861 }; 862 863 static const struct nla_policy 864 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = { 865 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 }, 866 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 }, 867 [NL80211_WOWLAN_TCP_DST_MAC] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 868 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 }, 869 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 }, 870 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = NLA_POLICY_MIN_LEN(1), 871 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = { 872 .len = sizeof(struct nl80211_wowlan_tcp_data_seq) 873 }, 874 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = { 875 .len = sizeof(struct nl80211_wowlan_tcp_data_token) 876 }, 877 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 }, 878 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = NLA_POLICY_MIN_LEN(1), 879 [NL80211_WOWLAN_TCP_WAKE_MASK] = NLA_POLICY_MIN_LEN(1), 880 }; 881 #endif /* CONFIG_PM */ 882 883 /* policy for coalesce rule attributes */ 884 static const struct nla_policy 885 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = { 886 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 }, 887 [NL80211_ATTR_COALESCE_RULE_CONDITION] = 888 NLA_POLICY_RANGE(NLA_U32, 889 NL80211_COALESCE_CONDITION_MATCH, 890 NL80211_COALESCE_CONDITION_NO_MATCH), 891 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED }, 892 }; 893 894 /* policy for GTK rekey offload attributes */ 895 static const struct nla_policy 896 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = { 897 [NL80211_REKEY_DATA_KEK] = { 898 .type = NLA_BINARY, 899 .len = NL80211_KEK_EXT_LEN 900 }, 901 [NL80211_REKEY_DATA_KCK] = { 902 .type = NLA_BINARY, 903 .len = NL80211_KCK_EXT_LEN_32 904 }, 905 [NL80211_REKEY_DATA_REPLAY_CTR] = NLA_POLICY_EXACT_LEN(NL80211_REPLAY_CTR_LEN), 906 [NL80211_REKEY_DATA_AKM] = { .type = NLA_U32 }, 907 }; 908 909 static const struct nla_policy 910 nl80211_match_band_rssi_policy[NUM_NL80211_BANDS] = { 911 [NL80211_BAND_2GHZ] = { .type = NLA_S32 }, 912 [NL80211_BAND_5GHZ] = { .type = NLA_S32 }, 913 [NL80211_BAND_6GHZ] = { .type = NLA_S32 }, 914 [NL80211_BAND_60GHZ] = { .type = NLA_S32 }, 915 [NL80211_BAND_LC] = { .type = NLA_S32 }, 916 }; 917 918 static const struct nla_policy 919 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = { 920 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY, 921 .len = IEEE80211_MAX_SSID_LEN }, 922 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 923 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 }, 924 [NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI] = 925 NLA_POLICY_NESTED(nl80211_match_band_rssi_policy), 926 }; 927 928 static const struct nla_policy 929 nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = { 930 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 }, 931 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 }, 932 }; 933 934 static const struct nla_policy 935 nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = { 936 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG }, 937 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 }, 938 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = { 939 .len = sizeof(struct nl80211_bss_select_rssi_adjust) 940 }, 941 }; 942 943 /* policy for NAN function attributes */ 944 static const struct nla_policy 945 nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = { 946 [NL80211_NAN_FUNC_TYPE] = 947 NLA_POLICY_MAX(NLA_U8, NL80211_NAN_FUNC_MAX_TYPE), 948 [NL80211_NAN_FUNC_SERVICE_ID] = { 949 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN }, 950 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 }, 951 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG }, 952 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG }, 953 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 }, 954 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 }, 955 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN), 956 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG }, 957 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 }, 958 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY, 959 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN }, 960 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED }, 961 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED }, 962 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED }, 963 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 }, 964 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 }, 965 }; 966 967 /* policy for Service Response Filter attributes */ 968 static const struct nla_policy 969 nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = { 970 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG }, 971 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY, 972 .len = NL80211_NAN_FUNC_SRF_MAX_LEN }, 973 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 }, 974 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED }, 975 }; 976 977 /* policy for packet pattern attributes */ 978 static const struct nla_policy 979 nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = { 980 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, }, 981 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, }, 982 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 }, 983 }; 984 985 static int nl80211_prepare_wdev_dump(struct netlink_callback *cb, 986 struct cfg80211_registered_device **rdev, 987 struct wireless_dev **wdev, 988 struct nlattr **attrbuf) 989 { 990 int err; 991 992 if (!cb->args[0]) { 993 struct nlattr **attrbuf_free = NULL; 994 995 if (!attrbuf) { 996 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), 997 GFP_KERNEL); 998 if (!attrbuf) 999 return -ENOMEM; 1000 attrbuf_free = attrbuf; 1001 } 1002 1003 err = nlmsg_parse_deprecated(cb->nlh, 1004 GENL_HDRLEN + nl80211_fam.hdrsize, 1005 attrbuf, nl80211_fam.maxattr, 1006 nl80211_policy, NULL); 1007 if (err) { 1008 kfree(attrbuf_free); 1009 return err; 1010 } 1011 1012 rtnl_lock(); 1013 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(cb->skb->sk), 1014 attrbuf); 1015 kfree(attrbuf_free); 1016 if (IS_ERR(*wdev)) { 1017 rtnl_unlock(); 1018 return PTR_ERR(*wdev); 1019 } 1020 *rdev = wiphy_to_rdev((*wdev)->wiphy); 1021 mutex_lock(&(*rdev)->wiphy.mtx); 1022 rtnl_unlock(); 1023 /* 0 is the first index - add 1 to parse only once */ 1024 cb->args[0] = (*rdev)->wiphy_idx + 1; 1025 cb->args[1] = (*wdev)->identifier; 1026 } else { 1027 /* subtract the 1 again here */ 1028 struct wiphy *wiphy; 1029 struct wireless_dev *tmp; 1030 1031 rtnl_lock(); 1032 wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1); 1033 if (!wiphy) { 1034 rtnl_unlock(); 1035 return -ENODEV; 1036 } 1037 *rdev = wiphy_to_rdev(wiphy); 1038 *wdev = NULL; 1039 1040 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) { 1041 if (tmp->identifier == cb->args[1]) { 1042 *wdev = tmp; 1043 break; 1044 } 1045 } 1046 1047 if (!*wdev) { 1048 rtnl_unlock(); 1049 return -ENODEV; 1050 } 1051 mutex_lock(&(*rdev)->wiphy.mtx); 1052 rtnl_unlock(); 1053 } 1054 1055 return 0; 1056 } 1057 1058 /* message building helper */ 1059 void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq, 1060 int flags, u8 cmd) 1061 { 1062 /* since there is no private header just add the generic one */ 1063 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd); 1064 } 1065 1066 static int nl80211_msg_put_wmm_rules(struct sk_buff *msg, 1067 const struct ieee80211_reg_rule *rule) 1068 { 1069 int j; 1070 struct nlattr *nl_wmm_rules = 1071 nla_nest_start_noflag(msg, NL80211_FREQUENCY_ATTR_WMM); 1072 1073 if (!nl_wmm_rules) 1074 goto nla_put_failure; 1075 1076 for (j = 0; j < IEEE80211_NUM_ACS; j++) { 1077 struct nlattr *nl_wmm_rule = nla_nest_start_noflag(msg, j); 1078 1079 if (!nl_wmm_rule) 1080 goto nla_put_failure; 1081 1082 if (nla_put_u16(msg, NL80211_WMMR_CW_MIN, 1083 rule->wmm_rule.client[j].cw_min) || 1084 nla_put_u16(msg, NL80211_WMMR_CW_MAX, 1085 rule->wmm_rule.client[j].cw_max) || 1086 nla_put_u8(msg, NL80211_WMMR_AIFSN, 1087 rule->wmm_rule.client[j].aifsn) || 1088 nla_put_u16(msg, NL80211_WMMR_TXOP, 1089 rule->wmm_rule.client[j].cot)) 1090 goto nla_put_failure; 1091 1092 nla_nest_end(msg, nl_wmm_rule); 1093 } 1094 nla_nest_end(msg, nl_wmm_rules); 1095 1096 return 0; 1097 1098 nla_put_failure: 1099 return -ENOBUFS; 1100 } 1101 1102 static int nl80211_msg_put_channel(struct sk_buff *msg, struct wiphy *wiphy, 1103 struct ieee80211_channel *chan, 1104 bool large) 1105 { 1106 /* Some channels must be completely excluded from the 1107 * list to protect old user-space tools from breaking 1108 */ 1109 if (!large && chan->flags & 1110 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ)) 1111 return 0; 1112 if (!large && chan->freq_offset) 1113 return 0; 1114 1115 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ, 1116 chan->center_freq)) 1117 goto nla_put_failure; 1118 1119 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_OFFSET, chan->freq_offset)) 1120 goto nla_put_failure; 1121 1122 if ((chan->flags & IEEE80211_CHAN_DISABLED) && 1123 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED)) 1124 goto nla_put_failure; 1125 if (chan->flags & IEEE80211_CHAN_NO_IR) { 1126 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR)) 1127 goto nla_put_failure; 1128 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS)) 1129 goto nla_put_failure; 1130 } 1131 if (chan->flags & IEEE80211_CHAN_RADAR) { 1132 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR)) 1133 goto nla_put_failure; 1134 if (large) { 1135 u32 time; 1136 1137 time = elapsed_jiffies_msecs(chan->dfs_state_entered); 1138 1139 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE, 1140 chan->dfs_state)) 1141 goto nla_put_failure; 1142 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME, 1143 time)) 1144 goto nla_put_failure; 1145 if (nla_put_u32(msg, 1146 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME, 1147 chan->dfs_cac_ms)) 1148 goto nla_put_failure; 1149 } 1150 } 1151 1152 if (large) { 1153 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) && 1154 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS)) 1155 goto nla_put_failure; 1156 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) && 1157 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS)) 1158 goto nla_put_failure; 1159 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) && 1160 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ)) 1161 goto nla_put_failure; 1162 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) && 1163 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ)) 1164 goto nla_put_failure; 1165 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) && 1166 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY)) 1167 goto nla_put_failure; 1168 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) && 1169 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT)) 1170 goto nla_put_failure; 1171 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) && 1172 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ)) 1173 goto nla_put_failure; 1174 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) && 1175 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ)) 1176 goto nla_put_failure; 1177 if ((chan->flags & IEEE80211_CHAN_NO_HE) && 1178 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HE)) 1179 goto nla_put_failure; 1180 if ((chan->flags & IEEE80211_CHAN_1MHZ) && 1181 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_1MHZ)) 1182 goto nla_put_failure; 1183 if ((chan->flags & IEEE80211_CHAN_2MHZ) && 1184 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_2MHZ)) 1185 goto nla_put_failure; 1186 if ((chan->flags & IEEE80211_CHAN_4MHZ) && 1187 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_4MHZ)) 1188 goto nla_put_failure; 1189 if ((chan->flags & IEEE80211_CHAN_8MHZ) && 1190 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_8MHZ)) 1191 goto nla_put_failure; 1192 if ((chan->flags & IEEE80211_CHAN_16MHZ) && 1193 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_16MHZ)) 1194 goto nla_put_failure; 1195 if ((chan->flags & IEEE80211_CHAN_NO_320MHZ) && 1196 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_320MHZ)) 1197 goto nla_put_failure; 1198 if ((chan->flags & IEEE80211_CHAN_NO_EHT) && 1199 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_EHT)) 1200 goto nla_put_failure; 1201 } 1202 1203 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER, 1204 DBM_TO_MBM(chan->max_power))) 1205 goto nla_put_failure; 1206 1207 if (large) { 1208 const struct ieee80211_reg_rule *rule = 1209 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq)); 1210 1211 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) { 1212 if (nl80211_msg_put_wmm_rules(msg, rule)) 1213 goto nla_put_failure; 1214 } 1215 } 1216 1217 return 0; 1218 1219 nla_put_failure: 1220 return -ENOBUFS; 1221 } 1222 1223 static bool nl80211_put_txq_stats(struct sk_buff *msg, 1224 struct cfg80211_txq_stats *txqstats, 1225 int attrtype) 1226 { 1227 struct nlattr *txqattr; 1228 1229 #define PUT_TXQVAL_U32(attr, memb) do { \ 1230 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \ 1231 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \ 1232 return false; \ 1233 } while (0) 1234 1235 txqattr = nla_nest_start_noflag(msg, attrtype); 1236 if (!txqattr) 1237 return false; 1238 1239 PUT_TXQVAL_U32(BACKLOG_BYTES, backlog_bytes); 1240 PUT_TXQVAL_U32(BACKLOG_PACKETS, backlog_packets); 1241 PUT_TXQVAL_U32(FLOWS, flows); 1242 PUT_TXQVAL_U32(DROPS, drops); 1243 PUT_TXQVAL_U32(ECN_MARKS, ecn_marks); 1244 PUT_TXQVAL_U32(OVERLIMIT, overlimit); 1245 PUT_TXQVAL_U32(OVERMEMORY, overmemory); 1246 PUT_TXQVAL_U32(COLLISIONS, collisions); 1247 PUT_TXQVAL_U32(TX_BYTES, tx_bytes); 1248 PUT_TXQVAL_U32(TX_PACKETS, tx_packets); 1249 PUT_TXQVAL_U32(MAX_FLOWS, max_flows); 1250 nla_nest_end(msg, txqattr); 1251 1252 #undef PUT_TXQVAL_U32 1253 return true; 1254 } 1255 1256 /* netlink command implementations */ 1257 1258 /** 1259 * nl80211_link_id - return link ID 1260 * @attrs: attributes to look at 1261 * 1262 * Returns: the link ID or 0 if not given 1263 * 1264 * Note this function doesn't do any validation of the link 1265 * ID validity wrt. links that were actually added, so it must 1266 * be called only from ops with %NL80211_FLAG_MLO_VALID_LINK_ID 1267 * or if additional validation is done. 1268 */ 1269 static unsigned int nl80211_link_id(struct nlattr **attrs) 1270 { 1271 struct nlattr *linkid = attrs[NL80211_ATTR_MLO_LINK_ID]; 1272 1273 if (!linkid) 1274 return 0; 1275 1276 return nla_get_u8(linkid); 1277 } 1278 1279 static int nl80211_link_id_or_invalid(struct nlattr **attrs) 1280 { 1281 struct nlattr *linkid = attrs[NL80211_ATTR_MLO_LINK_ID]; 1282 1283 if (!linkid) 1284 return -1; 1285 1286 return nla_get_u8(linkid); 1287 } 1288 1289 struct key_parse { 1290 struct key_params p; 1291 int idx; 1292 int type; 1293 bool def, defmgmt, defbeacon; 1294 bool def_uni, def_multi; 1295 }; 1296 1297 static int nl80211_parse_key_new(struct genl_info *info, struct nlattr *key, 1298 struct key_parse *k) 1299 { 1300 struct nlattr *tb[NL80211_KEY_MAX + 1]; 1301 int err = nla_parse_nested_deprecated(tb, NL80211_KEY_MAX, key, 1302 nl80211_key_policy, 1303 info->extack); 1304 if (err) 1305 return err; 1306 1307 k->def = !!tb[NL80211_KEY_DEFAULT]; 1308 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT]; 1309 k->defbeacon = !!tb[NL80211_KEY_DEFAULT_BEACON]; 1310 1311 if (k->def) { 1312 k->def_uni = true; 1313 k->def_multi = true; 1314 } 1315 if (k->defmgmt || k->defbeacon) 1316 k->def_multi = true; 1317 1318 if (tb[NL80211_KEY_IDX]) 1319 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]); 1320 1321 if (tb[NL80211_KEY_DATA]) { 1322 k->p.key = nla_data(tb[NL80211_KEY_DATA]); 1323 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]); 1324 } 1325 1326 if (tb[NL80211_KEY_SEQ]) { 1327 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]); 1328 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]); 1329 } 1330 1331 if (tb[NL80211_KEY_CIPHER]) 1332 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]); 1333 1334 if (tb[NL80211_KEY_TYPE]) 1335 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]); 1336 1337 if (tb[NL80211_KEY_DEFAULT_TYPES]) { 1338 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES]; 1339 1340 err = nla_parse_nested_deprecated(kdt, 1341 NUM_NL80211_KEY_DEFAULT_TYPES - 1, 1342 tb[NL80211_KEY_DEFAULT_TYPES], 1343 nl80211_key_default_policy, 1344 info->extack); 1345 if (err) 1346 return err; 1347 1348 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST]; 1349 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST]; 1350 } 1351 1352 if (tb[NL80211_KEY_MODE]) 1353 k->p.mode = nla_get_u8(tb[NL80211_KEY_MODE]); 1354 1355 return 0; 1356 } 1357 1358 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k) 1359 { 1360 if (info->attrs[NL80211_ATTR_KEY_DATA]) { 1361 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]); 1362 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]); 1363 } 1364 1365 if (info->attrs[NL80211_ATTR_KEY_SEQ]) { 1366 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]); 1367 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]); 1368 } 1369 1370 if (info->attrs[NL80211_ATTR_KEY_IDX]) 1371 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]); 1372 1373 if (info->attrs[NL80211_ATTR_KEY_CIPHER]) 1374 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]); 1375 1376 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT]; 1377 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT]; 1378 1379 if (k->def) { 1380 k->def_uni = true; 1381 k->def_multi = true; 1382 } 1383 if (k->defmgmt) 1384 k->def_multi = true; 1385 1386 if (info->attrs[NL80211_ATTR_KEY_TYPE]) 1387 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]); 1388 1389 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) { 1390 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES]; 1391 int err = nla_parse_nested_deprecated(kdt, 1392 NUM_NL80211_KEY_DEFAULT_TYPES - 1, 1393 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES], 1394 nl80211_key_default_policy, 1395 info->extack); 1396 if (err) 1397 return err; 1398 1399 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST]; 1400 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST]; 1401 } 1402 1403 return 0; 1404 } 1405 1406 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k) 1407 { 1408 int err; 1409 1410 memset(k, 0, sizeof(*k)); 1411 k->idx = -1; 1412 k->type = -1; 1413 1414 if (info->attrs[NL80211_ATTR_KEY]) 1415 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k); 1416 else 1417 err = nl80211_parse_key_old(info, k); 1418 1419 if (err) 1420 return err; 1421 1422 if ((k->def ? 1 : 0) + (k->defmgmt ? 1 : 0) + 1423 (k->defbeacon ? 1 : 0) > 1) { 1424 GENL_SET_ERR_MSG(info, 1425 "key with multiple default flags is invalid"); 1426 return -EINVAL; 1427 } 1428 1429 if (k->defmgmt || k->defbeacon) { 1430 if (k->def_uni || !k->def_multi) { 1431 GENL_SET_ERR_MSG(info, 1432 "defmgmt/defbeacon key must be mcast"); 1433 return -EINVAL; 1434 } 1435 } 1436 1437 if (k->idx != -1) { 1438 if (k->defmgmt) { 1439 if (k->idx < 4 || k->idx > 5) { 1440 GENL_SET_ERR_MSG(info, 1441 "defmgmt key idx not 4 or 5"); 1442 return -EINVAL; 1443 } 1444 } else if (k->defbeacon) { 1445 if (k->idx < 6 || k->idx > 7) { 1446 GENL_SET_ERR_MSG(info, 1447 "defbeacon key idx not 6 or 7"); 1448 return -EINVAL; 1449 } 1450 } else if (k->def) { 1451 if (k->idx < 0 || k->idx > 3) { 1452 GENL_SET_ERR_MSG(info, "def key idx not 0-3"); 1453 return -EINVAL; 1454 } 1455 } else { 1456 if (k->idx < 0 || k->idx > 7) { 1457 GENL_SET_ERR_MSG(info, "key idx not 0-7"); 1458 return -EINVAL; 1459 } 1460 } 1461 } 1462 1463 return 0; 1464 } 1465 1466 static struct cfg80211_cached_keys * 1467 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev, 1468 struct genl_info *info, bool *no_ht) 1469 { 1470 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS]; 1471 struct key_parse parse; 1472 struct nlattr *key; 1473 struct cfg80211_cached_keys *result; 1474 int rem, err, def = 0; 1475 bool have_key = false; 1476 1477 nla_for_each_nested(key, keys, rem) { 1478 have_key = true; 1479 break; 1480 } 1481 1482 if (!have_key) 1483 return NULL; 1484 1485 result = kzalloc(sizeof(*result), GFP_KERNEL); 1486 if (!result) 1487 return ERR_PTR(-ENOMEM); 1488 1489 result->def = -1; 1490 1491 nla_for_each_nested(key, keys, rem) { 1492 memset(&parse, 0, sizeof(parse)); 1493 parse.idx = -1; 1494 1495 err = nl80211_parse_key_new(info, key, &parse); 1496 if (err) 1497 goto error; 1498 err = -EINVAL; 1499 if (!parse.p.key) 1500 goto error; 1501 if (parse.idx < 0 || parse.idx > 3) { 1502 GENL_SET_ERR_MSG(info, "key index out of range [0-3]"); 1503 goto error; 1504 } 1505 if (parse.def) { 1506 if (def) { 1507 GENL_SET_ERR_MSG(info, 1508 "only one key can be default"); 1509 goto error; 1510 } 1511 def = 1; 1512 result->def = parse.idx; 1513 if (!parse.def_uni || !parse.def_multi) 1514 goto error; 1515 } else if (parse.defmgmt) 1516 goto error; 1517 err = cfg80211_validate_key_settings(rdev, &parse.p, 1518 parse.idx, false, NULL); 1519 if (err) 1520 goto error; 1521 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 && 1522 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) { 1523 GENL_SET_ERR_MSG(info, "connect key must be WEP"); 1524 err = -EINVAL; 1525 goto error; 1526 } 1527 result->params[parse.idx].cipher = parse.p.cipher; 1528 result->params[parse.idx].key_len = parse.p.key_len; 1529 result->params[parse.idx].key = result->data[parse.idx]; 1530 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len); 1531 1532 /* must be WEP key if we got here */ 1533 if (no_ht) 1534 *no_ht = true; 1535 } 1536 1537 if (result->def < 0) { 1538 err = -EINVAL; 1539 GENL_SET_ERR_MSG(info, "need a default/TX key"); 1540 goto error; 1541 } 1542 1543 return result; 1544 error: 1545 kfree(result); 1546 return ERR_PTR(err); 1547 } 1548 1549 static int nl80211_key_allowed(struct wireless_dev *wdev) 1550 { 1551 ASSERT_WDEV_LOCK(wdev); 1552 1553 switch (wdev->iftype) { 1554 case NL80211_IFTYPE_AP: 1555 case NL80211_IFTYPE_AP_VLAN: 1556 case NL80211_IFTYPE_P2P_GO: 1557 case NL80211_IFTYPE_MESH_POINT: 1558 break; 1559 case NL80211_IFTYPE_ADHOC: 1560 if (wdev->u.ibss.current_bss) 1561 return 0; 1562 return -ENOLINK; 1563 case NL80211_IFTYPE_STATION: 1564 case NL80211_IFTYPE_P2P_CLIENT: 1565 if (wdev->connected) 1566 return 0; 1567 return -ENOLINK; 1568 case NL80211_IFTYPE_NAN: 1569 if (wiphy_ext_feature_isset(wdev->wiphy, 1570 NL80211_EXT_FEATURE_SECURE_NAN)) 1571 return 0; 1572 return -EINVAL; 1573 case NL80211_IFTYPE_UNSPECIFIED: 1574 case NL80211_IFTYPE_OCB: 1575 case NL80211_IFTYPE_MONITOR: 1576 case NL80211_IFTYPE_P2P_DEVICE: 1577 case NL80211_IFTYPE_WDS: 1578 case NUM_NL80211_IFTYPES: 1579 return -EINVAL; 1580 } 1581 1582 return 0; 1583 } 1584 1585 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy, 1586 u32 freq) 1587 { 1588 struct ieee80211_channel *chan; 1589 1590 chan = ieee80211_get_channel_khz(wiphy, freq); 1591 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) 1592 return NULL; 1593 return chan; 1594 } 1595 1596 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes) 1597 { 1598 struct nlattr *nl_modes = nla_nest_start_noflag(msg, attr); 1599 int i; 1600 1601 if (!nl_modes) 1602 goto nla_put_failure; 1603 1604 i = 0; 1605 while (ifmodes) { 1606 if ((ifmodes & 1) && nla_put_flag(msg, i)) 1607 goto nla_put_failure; 1608 ifmodes >>= 1; 1609 i++; 1610 } 1611 1612 nla_nest_end(msg, nl_modes); 1613 return 0; 1614 1615 nla_put_failure: 1616 return -ENOBUFS; 1617 } 1618 1619 static int nl80211_put_iface_combinations(struct wiphy *wiphy, 1620 struct sk_buff *msg, 1621 bool large) 1622 { 1623 struct nlattr *nl_combis; 1624 int i, j; 1625 1626 nl_combis = nla_nest_start_noflag(msg, 1627 NL80211_ATTR_INTERFACE_COMBINATIONS); 1628 if (!nl_combis) 1629 goto nla_put_failure; 1630 1631 for (i = 0; i < wiphy->n_iface_combinations; i++) { 1632 const struct ieee80211_iface_combination *c; 1633 struct nlattr *nl_combi, *nl_limits; 1634 1635 c = &wiphy->iface_combinations[i]; 1636 1637 nl_combi = nla_nest_start_noflag(msg, i + 1); 1638 if (!nl_combi) 1639 goto nla_put_failure; 1640 1641 nl_limits = nla_nest_start_noflag(msg, 1642 NL80211_IFACE_COMB_LIMITS); 1643 if (!nl_limits) 1644 goto nla_put_failure; 1645 1646 for (j = 0; j < c->n_limits; j++) { 1647 struct nlattr *nl_limit; 1648 1649 nl_limit = nla_nest_start_noflag(msg, j + 1); 1650 if (!nl_limit) 1651 goto nla_put_failure; 1652 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX, 1653 c->limits[j].max)) 1654 goto nla_put_failure; 1655 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES, 1656 c->limits[j].types)) 1657 goto nla_put_failure; 1658 nla_nest_end(msg, nl_limit); 1659 } 1660 1661 nla_nest_end(msg, nl_limits); 1662 1663 if (c->beacon_int_infra_match && 1664 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH)) 1665 goto nla_put_failure; 1666 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS, 1667 c->num_different_channels) || 1668 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM, 1669 c->max_interfaces)) 1670 goto nla_put_failure; 1671 if (large && 1672 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS, 1673 c->radar_detect_widths) || 1674 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS, 1675 c->radar_detect_regions))) 1676 goto nla_put_failure; 1677 if (c->beacon_int_min_gcd && 1678 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD, 1679 c->beacon_int_min_gcd)) 1680 goto nla_put_failure; 1681 1682 nla_nest_end(msg, nl_combi); 1683 } 1684 1685 nla_nest_end(msg, nl_combis); 1686 1687 return 0; 1688 nla_put_failure: 1689 return -ENOBUFS; 1690 } 1691 1692 #ifdef CONFIG_PM 1693 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev, 1694 struct sk_buff *msg) 1695 { 1696 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp; 1697 struct nlattr *nl_tcp; 1698 1699 if (!tcp) 1700 return 0; 1701 1702 nl_tcp = nla_nest_start_noflag(msg, 1703 NL80211_WOWLAN_TRIG_TCP_CONNECTION); 1704 if (!nl_tcp) 1705 return -ENOBUFS; 1706 1707 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD, 1708 tcp->data_payload_max)) 1709 return -ENOBUFS; 1710 1711 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD, 1712 tcp->data_payload_max)) 1713 return -ENOBUFS; 1714 1715 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ)) 1716 return -ENOBUFS; 1717 1718 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN, 1719 sizeof(*tcp->tok), tcp->tok)) 1720 return -ENOBUFS; 1721 1722 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL, 1723 tcp->data_interval_max)) 1724 return -ENOBUFS; 1725 1726 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD, 1727 tcp->wake_payload_max)) 1728 return -ENOBUFS; 1729 1730 nla_nest_end(msg, nl_tcp); 1731 return 0; 1732 } 1733 1734 static int nl80211_send_wowlan(struct sk_buff *msg, 1735 struct cfg80211_registered_device *rdev, 1736 bool large) 1737 { 1738 struct nlattr *nl_wowlan; 1739 1740 if (!rdev->wiphy.wowlan) 1741 return 0; 1742 1743 nl_wowlan = nla_nest_start_noflag(msg, 1744 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED); 1745 if (!nl_wowlan) 1746 return -ENOBUFS; 1747 1748 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) && 1749 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) || 1750 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) && 1751 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) || 1752 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) && 1753 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) || 1754 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) && 1755 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) || 1756 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) && 1757 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) || 1758 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) && 1759 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) || 1760 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) && 1761 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) || 1762 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) && 1763 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))) 1764 return -ENOBUFS; 1765 1766 if (rdev->wiphy.wowlan->n_patterns) { 1767 struct nl80211_pattern_support pat = { 1768 .max_patterns = rdev->wiphy.wowlan->n_patterns, 1769 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len, 1770 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len, 1771 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset, 1772 }; 1773 1774 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN, 1775 sizeof(pat), &pat)) 1776 return -ENOBUFS; 1777 } 1778 1779 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) && 1780 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT, 1781 rdev->wiphy.wowlan->max_nd_match_sets)) 1782 return -ENOBUFS; 1783 1784 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg)) 1785 return -ENOBUFS; 1786 1787 nla_nest_end(msg, nl_wowlan); 1788 1789 return 0; 1790 } 1791 #endif 1792 1793 static int nl80211_send_coalesce(struct sk_buff *msg, 1794 struct cfg80211_registered_device *rdev) 1795 { 1796 struct nl80211_coalesce_rule_support rule; 1797 1798 if (!rdev->wiphy.coalesce) 1799 return 0; 1800 1801 rule.max_rules = rdev->wiphy.coalesce->n_rules; 1802 rule.max_delay = rdev->wiphy.coalesce->max_delay; 1803 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns; 1804 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len; 1805 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len; 1806 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset; 1807 1808 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule)) 1809 return -ENOBUFS; 1810 1811 return 0; 1812 } 1813 1814 static int 1815 nl80211_send_iftype_data(struct sk_buff *msg, 1816 const struct ieee80211_supported_band *sband, 1817 const struct ieee80211_sband_iftype_data *iftdata) 1818 { 1819 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap; 1820 const struct ieee80211_sta_eht_cap *eht_cap = &iftdata->eht_cap; 1821 1822 if (nl80211_put_iftypes(msg, NL80211_BAND_IFTYPE_ATTR_IFTYPES, 1823 iftdata->types_mask)) 1824 return -ENOBUFS; 1825 1826 if (he_cap->has_he) { 1827 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC, 1828 sizeof(he_cap->he_cap_elem.mac_cap_info), 1829 he_cap->he_cap_elem.mac_cap_info) || 1830 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY, 1831 sizeof(he_cap->he_cap_elem.phy_cap_info), 1832 he_cap->he_cap_elem.phy_cap_info) || 1833 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET, 1834 sizeof(he_cap->he_mcs_nss_supp), 1835 &he_cap->he_mcs_nss_supp) || 1836 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE, 1837 sizeof(he_cap->ppe_thres), he_cap->ppe_thres)) 1838 return -ENOBUFS; 1839 } 1840 1841 if (eht_cap->has_eht && he_cap->has_he) { 1842 u8 mcs_nss_size, ppe_thresh_size; 1843 u16 ppe_thres_hdr; 1844 bool is_ap; 1845 1846 is_ap = iftdata->types_mask & BIT(NL80211_IFTYPE_AP) || 1847 iftdata->types_mask & BIT(NL80211_IFTYPE_P2P_GO); 1848 1849 mcs_nss_size = 1850 ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem, 1851 &eht_cap->eht_cap_elem, 1852 is_ap); 1853 1854 ppe_thres_hdr = get_unaligned_le16(&eht_cap->eht_ppe_thres[0]); 1855 ppe_thresh_size = 1856 ieee80211_eht_ppe_size(ppe_thres_hdr, 1857 eht_cap->eht_cap_elem.phy_cap_info); 1858 1859 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MAC, 1860 sizeof(eht_cap->eht_cap_elem.mac_cap_info), 1861 eht_cap->eht_cap_elem.mac_cap_info) || 1862 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PHY, 1863 sizeof(eht_cap->eht_cap_elem.phy_cap_info), 1864 eht_cap->eht_cap_elem.phy_cap_info) || 1865 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_MCS_SET, 1866 mcs_nss_size, &eht_cap->eht_mcs_nss_supp) || 1867 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_EHT_CAP_PPE, 1868 ppe_thresh_size, eht_cap->eht_ppe_thres)) 1869 return -ENOBUFS; 1870 } 1871 1872 if (sband->band == NL80211_BAND_6GHZ && 1873 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA, 1874 sizeof(iftdata->he_6ghz_capa), 1875 &iftdata->he_6ghz_capa)) 1876 return -ENOBUFS; 1877 1878 if (iftdata->vendor_elems.data && iftdata->vendor_elems.len && 1879 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_VENDOR_ELEMS, 1880 iftdata->vendor_elems.len, iftdata->vendor_elems.data)) 1881 return -ENOBUFS; 1882 1883 return 0; 1884 } 1885 1886 static int nl80211_send_band_rateinfo(struct sk_buff *msg, 1887 struct ieee80211_supported_band *sband, 1888 bool large) 1889 { 1890 struct nlattr *nl_rates, *nl_rate; 1891 struct ieee80211_rate *rate; 1892 int i; 1893 1894 /* add HT info */ 1895 if (sband->ht_cap.ht_supported && 1896 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET, 1897 sizeof(sband->ht_cap.mcs), 1898 &sband->ht_cap.mcs) || 1899 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA, 1900 sband->ht_cap.cap) || 1901 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR, 1902 sband->ht_cap.ampdu_factor) || 1903 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY, 1904 sband->ht_cap.ampdu_density))) 1905 return -ENOBUFS; 1906 1907 /* add VHT info */ 1908 if (sband->vht_cap.vht_supported && 1909 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET, 1910 sizeof(sband->vht_cap.vht_mcs), 1911 &sband->vht_cap.vht_mcs) || 1912 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA, 1913 sband->vht_cap.cap))) 1914 return -ENOBUFS; 1915 1916 if (large && sband->n_iftype_data) { 1917 struct nlattr *nl_iftype_data = 1918 nla_nest_start_noflag(msg, 1919 NL80211_BAND_ATTR_IFTYPE_DATA); 1920 int err; 1921 1922 if (!nl_iftype_data) 1923 return -ENOBUFS; 1924 1925 for (i = 0; i < sband->n_iftype_data; i++) { 1926 struct nlattr *iftdata; 1927 1928 iftdata = nla_nest_start_noflag(msg, i + 1); 1929 if (!iftdata) 1930 return -ENOBUFS; 1931 1932 err = nl80211_send_iftype_data(msg, sband, 1933 &sband->iftype_data[i]); 1934 if (err) 1935 return err; 1936 1937 nla_nest_end(msg, iftdata); 1938 } 1939 1940 nla_nest_end(msg, nl_iftype_data); 1941 } 1942 1943 /* add EDMG info */ 1944 if (large && sband->edmg_cap.channels && 1945 (nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_CHANNELS, 1946 sband->edmg_cap.channels) || 1947 nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_BW_CONFIG, 1948 sband->edmg_cap.bw_config))) 1949 1950 return -ENOBUFS; 1951 1952 /* add bitrates */ 1953 nl_rates = nla_nest_start_noflag(msg, NL80211_BAND_ATTR_RATES); 1954 if (!nl_rates) 1955 return -ENOBUFS; 1956 1957 for (i = 0; i < sband->n_bitrates; i++) { 1958 nl_rate = nla_nest_start_noflag(msg, i); 1959 if (!nl_rate) 1960 return -ENOBUFS; 1961 1962 rate = &sband->bitrates[i]; 1963 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE, 1964 rate->bitrate)) 1965 return -ENOBUFS; 1966 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) && 1967 nla_put_flag(msg, 1968 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE)) 1969 return -ENOBUFS; 1970 1971 nla_nest_end(msg, nl_rate); 1972 } 1973 1974 nla_nest_end(msg, nl_rates); 1975 1976 /* S1G capabilities */ 1977 if (sband->band == NL80211_BAND_S1GHZ && sband->s1g_cap.s1g && 1978 (nla_put(msg, NL80211_BAND_ATTR_S1G_CAPA, 1979 sizeof(sband->s1g_cap.cap), 1980 sband->s1g_cap.cap) || 1981 nla_put(msg, NL80211_BAND_ATTR_S1G_MCS_NSS_SET, 1982 sizeof(sband->s1g_cap.nss_mcs), 1983 sband->s1g_cap.nss_mcs))) 1984 return -ENOBUFS; 1985 1986 return 0; 1987 } 1988 1989 static int 1990 nl80211_send_mgmt_stypes(struct sk_buff *msg, 1991 const struct ieee80211_txrx_stypes *mgmt_stypes) 1992 { 1993 u16 stypes; 1994 struct nlattr *nl_ftypes, *nl_ifs; 1995 enum nl80211_iftype ift; 1996 int i; 1997 1998 if (!mgmt_stypes) 1999 return 0; 2000 2001 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_TX_FRAME_TYPES); 2002 if (!nl_ifs) 2003 return -ENOBUFS; 2004 2005 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) { 2006 nl_ftypes = nla_nest_start_noflag(msg, ift); 2007 if (!nl_ftypes) 2008 return -ENOBUFS; 2009 i = 0; 2010 stypes = mgmt_stypes[ift].tx; 2011 while (stypes) { 2012 if ((stypes & 1) && 2013 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE, 2014 (i << 4) | IEEE80211_FTYPE_MGMT)) 2015 return -ENOBUFS; 2016 stypes >>= 1; 2017 i++; 2018 } 2019 nla_nest_end(msg, nl_ftypes); 2020 } 2021 2022 nla_nest_end(msg, nl_ifs); 2023 2024 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_RX_FRAME_TYPES); 2025 if (!nl_ifs) 2026 return -ENOBUFS; 2027 2028 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) { 2029 nl_ftypes = nla_nest_start_noflag(msg, ift); 2030 if (!nl_ftypes) 2031 return -ENOBUFS; 2032 i = 0; 2033 stypes = mgmt_stypes[ift].rx; 2034 while (stypes) { 2035 if ((stypes & 1) && 2036 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE, 2037 (i << 4) | IEEE80211_FTYPE_MGMT)) 2038 return -ENOBUFS; 2039 stypes >>= 1; 2040 i++; 2041 } 2042 nla_nest_end(msg, nl_ftypes); 2043 } 2044 nla_nest_end(msg, nl_ifs); 2045 2046 return 0; 2047 } 2048 2049 #define CMD(op, n) \ 2050 do { \ 2051 if (rdev->ops->op) { \ 2052 i++; \ 2053 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \ 2054 goto nla_put_failure; \ 2055 } \ 2056 } while (0) 2057 2058 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev, 2059 struct sk_buff *msg) 2060 { 2061 int i = 0; 2062 2063 /* 2064 * do *NOT* add anything into this function, new things need to be 2065 * advertised only to new versions of userspace that can deal with 2066 * the split (and they can't possibly care about new features... 2067 */ 2068 CMD(add_virtual_intf, NEW_INTERFACE); 2069 CMD(change_virtual_intf, SET_INTERFACE); 2070 CMD(add_key, NEW_KEY); 2071 CMD(start_ap, START_AP); 2072 CMD(add_station, NEW_STATION); 2073 CMD(add_mpath, NEW_MPATH); 2074 CMD(update_mesh_config, SET_MESH_CONFIG); 2075 CMD(change_bss, SET_BSS); 2076 CMD(auth, AUTHENTICATE); 2077 CMD(assoc, ASSOCIATE); 2078 CMD(deauth, DEAUTHENTICATE); 2079 CMD(disassoc, DISASSOCIATE); 2080 CMD(join_ibss, JOIN_IBSS); 2081 CMD(join_mesh, JOIN_MESH); 2082 CMD(set_pmksa, SET_PMKSA); 2083 CMD(del_pmksa, DEL_PMKSA); 2084 CMD(flush_pmksa, FLUSH_PMKSA); 2085 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) 2086 CMD(remain_on_channel, REMAIN_ON_CHANNEL); 2087 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK); 2088 CMD(mgmt_tx, FRAME); 2089 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL); 2090 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) { 2091 i++; 2092 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS)) 2093 goto nla_put_failure; 2094 } 2095 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap || 2096 rdev->ops->join_mesh) { 2097 i++; 2098 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL)) 2099 goto nla_put_failure; 2100 } 2101 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) { 2102 CMD(tdls_mgmt, TDLS_MGMT); 2103 CMD(tdls_oper, TDLS_OPER); 2104 } 2105 if (rdev->wiphy.max_sched_scan_reqs) 2106 CMD(sched_scan_start, START_SCHED_SCAN); 2107 CMD(probe_client, PROBE_CLIENT); 2108 CMD(set_noack_map, SET_NOACK_MAP); 2109 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) { 2110 i++; 2111 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS)) 2112 goto nla_put_failure; 2113 } 2114 CMD(start_p2p_device, START_P2P_DEVICE); 2115 CMD(set_mcast_rate, SET_MCAST_RATE); 2116 #ifdef CONFIG_NL80211_TESTMODE 2117 CMD(testmode_cmd, TESTMODE); 2118 #endif 2119 2120 if (rdev->ops->connect || rdev->ops->auth) { 2121 i++; 2122 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT)) 2123 goto nla_put_failure; 2124 } 2125 2126 if (rdev->ops->disconnect || rdev->ops->deauth) { 2127 i++; 2128 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT)) 2129 goto nla_put_failure; 2130 } 2131 2132 return i; 2133 nla_put_failure: 2134 return -ENOBUFS; 2135 } 2136 2137 static int 2138 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities *cap, 2139 struct sk_buff *msg) 2140 { 2141 struct nlattr *ftm; 2142 2143 if (!cap->ftm.supported) 2144 return 0; 2145 2146 ftm = nla_nest_start_noflag(msg, NL80211_PMSR_TYPE_FTM); 2147 if (!ftm) 2148 return -ENOBUFS; 2149 2150 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP)) 2151 return -ENOBUFS; 2152 if (cap->ftm.non_asap && 2153 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP)) 2154 return -ENOBUFS; 2155 if (cap->ftm.request_lci && 2156 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI)) 2157 return -ENOBUFS; 2158 if (cap->ftm.request_civicloc && 2159 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC)) 2160 return -ENOBUFS; 2161 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES, 2162 cap->ftm.preambles)) 2163 return -ENOBUFS; 2164 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS, 2165 cap->ftm.bandwidths)) 2166 return -ENOBUFS; 2167 if (cap->ftm.max_bursts_exponent >= 0 && 2168 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT, 2169 cap->ftm.max_bursts_exponent)) 2170 return -ENOBUFS; 2171 if (cap->ftm.max_ftms_per_burst && 2172 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST, 2173 cap->ftm.max_ftms_per_burst)) 2174 return -ENOBUFS; 2175 if (cap->ftm.trigger_based && 2176 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_TRIGGER_BASED)) 2177 return -ENOBUFS; 2178 if (cap->ftm.non_trigger_based && 2179 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED)) 2180 return -ENOBUFS; 2181 2182 nla_nest_end(msg, ftm); 2183 return 0; 2184 } 2185 2186 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device *rdev, 2187 struct sk_buff *msg) 2188 { 2189 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa; 2190 struct nlattr *pmsr, *caps; 2191 2192 if (!cap) 2193 return 0; 2194 2195 /* 2196 * we don't need to clean up anything here since the caller 2197 * will genlmsg_cancel() if we fail 2198 */ 2199 2200 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS); 2201 if (!pmsr) 2202 return -ENOBUFS; 2203 2204 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers)) 2205 return -ENOBUFS; 2206 2207 if (cap->report_ap_tsf && 2208 nla_put_flag(msg, NL80211_PMSR_ATTR_REPORT_AP_TSF)) 2209 return -ENOBUFS; 2210 2211 if (cap->randomize_mac_addr && 2212 nla_put_flag(msg, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR)) 2213 return -ENOBUFS; 2214 2215 caps = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_TYPE_CAPA); 2216 if (!caps) 2217 return -ENOBUFS; 2218 2219 if (nl80211_send_pmsr_ftm_capa(cap, msg)) 2220 return -ENOBUFS; 2221 2222 nla_nest_end(msg, caps); 2223 nla_nest_end(msg, pmsr); 2224 2225 return 0; 2226 } 2227 2228 static int 2229 nl80211_put_iftype_akm_suites(struct cfg80211_registered_device *rdev, 2230 struct sk_buff *msg) 2231 { 2232 int i; 2233 struct nlattr *nested, *nested_akms; 2234 const struct wiphy_iftype_akm_suites *iftype_akms; 2235 2236 if (!rdev->wiphy.num_iftype_akm_suites || 2237 !rdev->wiphy.iftype_akm_suites) 2238 return 0; 2239 2240 nested = nla_nest_start(msg, NL80211_ATTR_IFTYPE_AKM_SUITES); 2241 if (!nested) 2242 return -ENOBUFS; 2243 2244 for (i = 0; i < rdev->wiphy.num_iftype_akm_suites; i++) { 2245 nested_akms = nla_nest_start(msg, i + 1); 2246 if (!nested_akms) 2247 return -ENOBUFS; 2248 2249 iftype_akms = &rdev->wiphy.iftype_akm_suites[i]; 2250 2251 if (nl80211_put_iftypes(msg, NL80211_IFTYPE_AKM_ATTR_IFTYPES, 2252 iftype_akms->iftypes_mask)) 2253 return -ENOBUFS; 2254 2255 if (nla_put(msg, NL80211_IFTYPE_AKM_ATTR_SUITES, 2256 sizeof(u32) * iftype_akms->n_akm_suites, 2257 iftype_akms->akm_suites)) { 2258 return -ENOBUFS; 2259 } 2260 nla_nest_end(msg, nested_akms); 2261 } 2262 2263 nla_nest_end(msg, nested); 2264 2265 return 0; 2266 } 2267 2268 static int 2269 nl80211_put_tid_config_support(struct cfg80211_registered_device *rdev, 2270 struct sk_buff *msg) 2271 { 2272 struct nlattr *supp; 2273 2274 if (!rdev->wiphy.tid_config_support.vif && 2275 !rdev->wiphy.tid_config_support.peer) 2276 return 0; 2277 2278 supp = nla_nest_start(msg, NL80211_ATTR_TID_CONFIG); 2279 if (!supp) 2280 return -ENOSPC; 2281 2282 if (rdev->wiphy.tid_config_support.vif && 2283 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_VIF_SUPP, 2284 rdev->wiphy.tid_config_support.vif, 2285 NL80211_TID_CONFIG_ATTR_PAD)) 2286 goto fail; 2287 2288 if (rdev->wiphy.tid_config_support.peer && 2289 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_PEER_SUPP, 2290 rdev->wiphy.tid_config_support.peer, 2291 NL80211_TID_CONFIG_ATTR_PAD)) 2292 goto fail; 2293 2294 /* for now we just use the same value ... makes more sense */ 2295 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_SHORT, 2296 rdev->wiphy.tid_config_support.max_retry)) 2297 goto fail; 2298 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_LONG, 2299 rdev->wiphy.tid_config_support.max_retry)) 2300 goto fail; 2301 2302 nla_nest_end(msg, supp); 2303 2304 return 0; 2305 fail: 2306 nla_nest_cancel(msg, supp); 2307 return -ENOBUFS; 2308 } 2309 2310 static int 2311 nl80211_put_sar_specs(struct cfg80211_registered_device *rdev, 2312 struct sk_buff *msg) 2313 { 2314 struct nlattr *sar_capa, *specs, *sub_freq_range; 2315 u8 num_freq_ranges; 2316 int i; 2317 2318 if (!rdev->wiphy.sar_capa) 2319 return 0; 2320 2321 num_freq_ranges = rdev->wiphy.sar_capa->num_freq_ranges; 2322 2323 sar_capa = nla_nest_start(msg, NL80211_ATTR_SAR_SPEC); 2324 if (!sar_capa) 2325 return -ENOSPC; 2326 2327 if (nla_put_u32(msg, NL80211_SAR_ATTR_TYPE, rdev->wiphy.sar_capa->type)) 2328 goto fail; 2329 2330 specs = nla_nest_start(msg, NL80211_SAR_ATTR_SPECS); 2331 if (!specs) 2332 goto fail; 2333 2334 /* report supported freq_ranges */ 2335 for (i = 0; i < num_freq_ranges; i++) { 2336 sub_freq_range = nla_nest_start(msg, i + 1); 2337 if (!sub_freq_range) 2338 goto fail; 2339 2340 if (nla_put_u32(msg, NL80211_SAR_ATTR_SPECS_START_FREQ, 2341 rdev->wiphy.sar_capa->freq_ranges[i].start_freq)) 2342 goto fail; 2343 2344 if (nla_put_u32(msg, NL80211_SAR_ATTR_SPECS_END_FREQ, 2345 rdev->wiphy.sar_capa->freq_ranges[i].end_freq)) 2346 goto fail; 2347 2348 nla_nest_end(msg, sub_freq_range); 2349 } 2350 2351 nla_nest_end(msg, specs); 2352 nla_nest_end(msg, sar_capa); 2353 2354 return 0; 2355 fail: 2356 nla_nest_cancel(msg, sar_capa); 2357 return -ENOBUFS; 2358 } 2359 2360 static int nl80211_put_mbssid_support(struct wiphy *wiphy, struct sk_buff *msg) 2361 { 2362 struct nlattr *config; 2363 2364 if (!wiphy->mbssid_max_interfaces) 2365 return 0; 2366 2367 config = nla_nest_start(msg, NL80211_ATTR_MBSSID_CONFIG); 2368 if (!config) 2369 return -ENOBUFS; 2370 2371 if (nla_put_u8(msg, NL80211_MBSSID_CONFIG_ATTR_MAX_INTERFACES, 2372 wiphy->mbssid_max_interfaces)) 2373 goto fail; 2374 2375 if (wiphy->ema_max_profile_periodicity && 2376 nla_put_u8(msg, 2377 NL80211_MBSSID_CONFIG_ATTR_MAX_EMA_PROFILE_PERIODICITY, 2378 wiphy->ema_max_profile_periodicity)) 2379 goto fail; 2380 2381 nla_nest_end(msg, config); 2382 return 0; 2383 2384 fail: 2385 nla_nest_cancel(msg, config); 2386 return -ENOBUFS; 2387 } 2388 2389 struct nl80211_dump_wiphy_state { 2390 s64 filter_wiphy; 2391 long start; 2392 long split_start, band_start, chan_start, capa_start; 2393 bool split; 2394 }; 2395 2396 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev, 2397 enum nl80211_commands cmd, 2398 struct sk_buff *msg, u32 portid, u32 seq, 2399 int flags, struct nl80211_dump_wiphy_state *state) 2400 { 2401 void *hdr; 2402 struct nlattr *nl_bands, *nl_band; 2403 struct nlattr *nl_freqs, *nl_freq; 2404 struct nlattr *nl_cmds; 2405 enum nl80211_band band; 2406 struct ieee80211_channel *chan; 2407 int i; 2408 const struct ieee80211_txrx_stypes *mgmt_stypes = 2409 rdev->wiphy.mgmt_stypes; 2410 u32 features; 2411 2412 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd); 2413 if (!hdr) 2414 return -ENOBUFS; 2415 2416 if (WARN_ON(!state)) 2417 return -EINVAL; 2418 2419 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 2420 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME, 2421 wiphy_name(&rdev->wiphy)) || 2422 nla_put_u32(msg, NL80211_ATTR_GENERATION, 2423 cfg80211_rdev_list_generation)) 2424 goto nla_put_failure; 2425 2426 if (cmd != NL80211_CMD_NEW_WIPHY) 2427 goto finish; 2428 2429 switch (state->split_start) { 2430 case 0: 2431 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT, 2432 rdev->wiphy.retry_short) || 2433 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG, 2434 rdev->wiphy.retry_long) || 2435 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD, 2436 rdev->wiphy.frag_threshold) || 2437 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD, 2438 rdev->wiphy.rts_threshold) || 2439 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS, 2440 rdev->wiphy.coverage_class) || 2441 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS, 2442 rdev->wiphy.max_scan_ssids) || 2443 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS, 2444 rdev->wiphy.max_sched_scan_ssids) || 2445 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN, 2446 rdev->wiphy.max_scan_ie_len) || 2447 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN, 2448 rdev->wiphy.max_sched_scan_ie_len) || 2449 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS, 2450 rdev->wiphy.max_match_sets)) 2451 goto nla_put_failure; 2452 2453 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) && 2454 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN)) 2455 goto nla_put_failure; 2456 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) && 2457 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH)) 2458 goto nla_put_failure; 2459 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) && 2460 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD)) 2461 goto nla_put_failure; 2462 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) && 2463 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT)) 2464 goto nla_put_failure; 2465 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) && 2466 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT)) 2467 goto nla_put_failure; 2468 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) && 2469 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP)) 2470 goto nla_put_failure; 2471 state->split_start++; 2472 if (state->split) 2473 break; 2474 fallthrough; 2475 case 1: 2476 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES, 2477 sizeof(u32) * rdev->wiphy.n_cipher_suites, 2478 rdev->wiphy.cipher_suites)) 2479 goto nla_put_failure; 2480 2481 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS, 2482 rdev->wiphy.max_num_pmkids)) 2483 goto nla_put_failure; 2484 2485 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) && 2486 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE)) 2487 goto nla_put_failure; 2488 2489 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX, 2490 rdev->wiphy.available_antennas_tx) || 2491 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX, 2492 rdev->wiphy.available_antennas_rx)) 2493 goto nla_put_failure; 2494 2495 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) && 2496 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD, 2497 rdev->wiphy.probe_resp_offload)) 2498 goto nla_put_failure; 2499 2500 if ((rdev->wiphy.available_antennas_tx || 2501 rdev->wiphy.available_antennas_rx) && 2502 rdev->ops->get_antenna) { 2503 u32 tx_ant = 0, rx_ant = 0; 2504 int res; 2505 2506 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant); 2507 if (!res) { 2508 if (nla_put_u32(msg, 2509 NL80211_ATTR_WIPHY_ANTENNA_TX, 2510 tx_ant) || 2511 nla_put_u32(msg, 2512 NL80211_ATTR_WIPHY_ANTENNA_RX, 2513 rx_ant)) 2514 goto nla_put_failure; 2515 } 2516 } 2517 2518 state->split_start++; 2519 if (state->split) 2520 break; 2521 fallthrough; 2522 case 2: 2523 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES, 2524 rdev->wiphy.interface_modes)) 2525 goto nla_put_failure; 2526 state->split_start++; 2527 if (state->split) 2528 break; 2529 fallthrough; 2530 case 3: 2531 nl_bands = nla_nest_start_noflag(msg, 2532 NL80211_ATTR_WIPHY_BANDS); 2533 if (!nl_bands) 2534 goto nla_put_failure; 2535 2536 for (band = state->band_start; 2537 band < (state->split ? 2538 NUM_NL80211_BANDS : 2539 NL80211_BAND_60GHZ + 1); 2540 band++) { 2541 struct ieee80211_supported_band *sband; 2542 2543 /* omit higher bands for ancient software */ 2544 if (band > NL80211_BAND_5GHZ && !state->split) 2545 break; 2546 2547 sband = rdev->wiphy.bands[band]; 2548 2549 if (!sband) 2550 continue; 2551 2552 nl_band = nla_nest_start_noflag(msg, band); 2553 if (!nl_band) 2554 goto nla_put_failure; 2555 2556 switch (state->chan_start) { 2557 case 0: 2558 if (nl80211_send_band_rateinfo(msg, sband, 2559 state->split)) 2560 goto nla_put_failure; 2561 state->chan_start++; 2562 if (state->split) 2563 break; 2564 fallthrough; 2565 default: 2566 /* add frequencies */ 2567 nl_freqs = nla_nest_start_noflag(msg, 2568 NL80211_BAND_ATTR_FREQS); 2569 if (!nl_freqs) 2570 goto nla_put_failure; 2571 2572 for (i = state->chan_start - 1; 2573 i < sband->n_channels; 2574 i++) { 2575 nl_freq = nla_nest_start_noflag(msg, 2576 i); 2577 if (!nl_freq) 2578 goto nla_put_failure; 2579 2580 chan = &sband->channels[i]; 2581 2582 if (nl80211_msg_put_channel( 2583 msg, &rdev->wiphy, chan, 2584 state->split)) 2585 goto nla_put_failure; 2586 2587 nla_nest_end(msg, nl_freq); 2588 if (state->split) 2589 break; 2590 } 2591 if (i < sband->n_channels) 2592 state->chan_start = i + 2; 2593 else 2594 state->chan_start = 0; 2595 nla_nest_end(msg, nl_freqs); 2596 } 2597 2598 nla_nest_end(msg, nl_band); 2599 2600 if (state->split) { 2601 /* start again here */ 2602 if (state->chan_start) 2603 band--; 2604 break; 2605 } 2606 } 2607 nla_nest_end(msg, nl_bands); 2608 2609 if (band < NUM_NL80211_BANDS) 2610 state->band_start = band + 1; 2611 else 2612 state->band_start = 0; 2613 2614 /* if bands & channels are done, continue outside */ 2615 if (state->band_start == 0 && state->chan_start == 0) 2616 state->split_start++; 2617 if (state->split) 2618 break; 2619 fallthrough; 2620 case 4: 2621 nl_cmds = nla_nest_start_noflag(msg, 2622 NL80211_ATTR_SUPPORTED_COMMANDS); 2623 if (!nl_cmds) 2624 goto nla_put_failure; 2625 2626 i = nl80211_add_commands_unsplit(rdev, msg); 2627 if (i < 0) 2628 goto nla_put_failure; 2629 if (state->split) { 2630 CMD(crit_proto_start, CRIT_PROTOCOL_START); 2631 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP); 2632 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH) 2633 CMD(channel_switch, CHANNEL_SWITCH); 2634 CMD(set_qos_map, SET_QOS_MAP); 2635 if (rdev->wiphy.features & 2636 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION) 2637 CMD(add_tx_ts, ADD_TX_TS); 2638 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST); 2639 CMD(update_connect_params, UPDATE_CONNECT_PARAMS); 2640 CMD(update_ft_ies, UPDATE_FT_IES); 2641 if (rdev->wiphy.sar_capa) 2642 CMD(set_sar_specs, SET_SAR_SPECS); 2643 } 2644 #undef CMD 2645 2646 nla_nest_end(msg, nl_cmds); 2647 state->split_start++; 2648 if (state->split) 2649 break; 2650 fallthrough; 2651 case 5: 2652 if (rdev->ops->remain_on_channel && 2653 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) && 2654 nla_put_u32(msg, 2655 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION, 2656 rdev->wiphy.max_remain_on_channel_duration)) 2657 goto nla_put_failure; 2658 2659 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) && 2660 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK)) 2661 goto nla_put_failure; 2662 2663 state->split_start++; 2664 if (state->split) 2665 break; 2666 fallthrough; 2667 case 6: 2668 #ifdef CONFIG_PM 2669 if (nl80211_send_wowlan(msg, rdev, state->split)) 2670 goto nla_put_failure; 2671 state->split_start++; 2672 if (state->split) 2673 break; 2674 #else 2675 state->split_start++; 2676 #endif 2677 fallthrough; 2678 case 7: 2679 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES, 2680 rdev->wiphy.software_iftypes)) 2681 goto nla_put_failure; 2682 2683 if (nl80211_put_iface_combinations(&rdev->wiphy, msg, 2684 state->split)) 2685 goto nla_put_failure; 2686 2687 state->split_start++; 2688 if (state->split) 2689 break; 2690 fallthrough; 2691 case 8: 2692 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) && 2693 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME, 2694 rdev->wiphy.ap_sme_capa)) 2695 goto nla_put_failure; 2696 2697 features = rdev->wiphy.features; 2698 /* 2699 * We can only add the per-channel limit information if the 2700 * dump is split, otherwise it makes it too big. Therefore 2701 * only advertise it in that case. 2702 */ 2703 if (state->split) 2704 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS; 2705 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features)) 2706 goto nla_put_failure; 2707 2708 if (rdev->wiphy.ht_capa_mod_mask && 2709 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK, 2710 sizeof(*rdev->wiphy.ht_capa_mod_mask), 2711 rdev->wiphy.ht_capa_mod_mask)) 2712 goto nla_put_failure; 2713 2714 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME && 2715 rdev->wiphy.max_acl_mac_addrs && 2716 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX, 2717 rdev->wiphy.max_acl_mac_addrs)) 2718 goto nla_put_failure; 2719 2720 /* 2721 * Any information below this point is only available to 2722 * applications that can deal with it being split. This 2723 * helps ensure that newly added capabilities don't break 2724 * older tools by overrunning their buffers. 2725 * 2726 * We still increment split_start so that in the split 2727 * case we'll continue with more data in the next round, 2728 * but break unconditionally so unsplit data stops here. 2729 */ 2730 if (state->split) 2731 state->split_start++; 2732 else 2733 state->split_start = 0; 2734 break; 2735 case 9: 2736 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes)) 2737 goto nla_put_failure; 2738 2739 if (nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS, 2740 rdev->wiphy.max_sched_scan_plans) || 2741 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL, 2742 rdev->wiphy.max_sched_scan_plan_interval) || 2743 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS, 2744 rdev->wiphy.max_sched_scan_plan_iterations)) 2745 goto nla_put_failure; 2746 2747 if (rdev->wiphy.extended_capabilities && 2748 (nla_put(msg, NL80211_ATTR_EXT_CAPA, 2749 rdev->wiphy.extended_capabilities_len, 2750 rdev->wiphy.extended_capabilities) || 2751 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK, 2752 rdev->wiphy.extended_capabilities_len, 2753 rdev->wiphy.extended_capabilities_mask))) 2754 goto nla_put_failure; 2755 2756 if (rdev->wiphy.vht_capa_mod_mask && 2757 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK, 2758 sizeof(*rdev->wiphy.vht_capa_mod_mask), 2759 rdev->wiphy.vht_capa_mod_mask)) 2760 goto nla_put_failure; 2761 2762 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, 2763 rdev->wiphy.perm_addr)) 2764 goto nla_put_failure; 2765 2766 if (!is_zero_ether_addr(rdev->wiphy.addr_mask) && 2767 nla_put(msg, NL80211_ATTR_MAC_MASK, ETH_ALEN, 2768 rdev->wiphy.addr_mask)) 2769 goto nla_put_failure; 2770 2771 if (rdev->wiphy.n_addresses > 1) { 2772 void *attr; 2773 2774 attr = nla_nest_start(msg, NL80211_ATTR_MAC_ADDRS); 2775 if (!attr) 2776 goto nla_put_failure; 2777 2778 for (i = 0; i < rdev->wiphy.n_addresses; i++) 2779 if (nla_put(msg, i + 1, ETH_ALEN, 2780 rdev->wiphy.addresses[i].addr)) 2781 goto nla_put_failure; 2782 2783 nla_nest_end(msg, attr); 2784 } 2785 2786 state->split_start++; 2787 break; 2788 case 10: 2789 if (nl80211_send_coalesce(msg, rdev)) 2790 goto nla_put_failure; 2791 2792 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) && 2793 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) || 2794 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ))) 2795 goto nla_put_failure; 2796 2797 if (rdev->wiphy.max_ap_assoc_sta && 2798 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA, 2799 rdev->wiphy.max_ap_assoc_sta)) 2800 goto nla_put_failure; 2801 2802 state->split_start++; 2803 break; 2804 case 11: 2805 if (rdev->wiphy.n_vendor_commands) { 2806 const struct nl80211_vendor_cmd_info *info; 2807 struct nlattr *nested; 2808 2809 nested = nla_nest_start_noflag(msg, 2810 NL80211_ATTR_VENDOR_DATA); 2811 if (!nested) 2812 goto nla_put_failure; 2813 2814 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) { 2815 info = &rdev->wiphy.vendor_commands[i].info; 2816 if (nla_put(msg, i + 1, sizeof(*info), info)) 2817 goto nla_put_failure; 2818 } 2819 nla_nest_end(msg, nested); 2820 } 2821 2822 if (rdev->wiphy.n_vendor_events) { 2823 const struct nl80211_vendor_cmd_info *info; 2824 struct nlattr *nested; 2825 2826 nested = nla_nest_start_noflag(msg, 2827 NL80211_ATTR_VENDOR_EVENTS); 2828 if (!nested) 2829 goto nla_put_failure; 2830 2831 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) { 2832 info = &rdev->wiphy.vendor_events[i]; 2833 if (nla_put(msg, i + 1, sizeof(*info), info)) 2834 goto nla_put_failure; 2835 } 2836 nla_nest_end(msg, nested); 2837 } 2838 state->split_start++; 2839 break; 2840 case 12: 2841 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH && 2842 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS, 2843 rdev->wiphy.max_num_csa_counters)) 2844 goto nla_put_failure; 2845 2846 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED && 2847 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG)) 2848 goto nla_put_failure; 2849 2850 if (rdev->wiphy.max_sched_scan_reqs && 2851 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS, 2852 rdev->wiphy.max_sched_scan_reqs)) 2853 goto nla_put_failure; 2854 2855 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES, 2856 sizeof(rdev->wiphy.ext_features), 2857 rdev->wiphy.ext_features)) 2858 goto nla_put_failure; 2859 2860 if (rdev->wiphy.bss_select_support) { 2861 struct nlattr *nested; 2862 u32 bss_select_support = rdev->wiphy.bss_select_support; 2863 2864 nested = nla_nest_start_noflag(msg, 2865 NL80211_ATTR_BSS_SELECT); 2866 if (!nested) 2867 goto nla_put_failure; 2868 2869 i = 0; 2870 while (bss_select_support) { 2871 if ((bss_select_support & 1) && 2872 nla_put_flag(msg, i)) 2873 goto nla_put_failure; 2874 i++; 2875 bss_select_support >>= 1; 2876 } 2877 nla_nest_end(msg, nested); 2878 } 2879 2880 state->split_start++; 2881 break; 2882 case 13: 2883 if (rdev->wiphy.num_iftype_ext_capab && 2884 rdev->wiphy.iftype_ext_capab) { 2885 struct nlattr *nested_ext_capab, *nested; 2886 2887 nested = nla_nest_start_noflag(msg, 2888 NL80211_ATTR_IFTYPE_EXT_CAPA); 2889 if (!nested) 2890 goto nla_put_failure; 2891 2892 for (i = state->capa_start; 2893 i < rdev->wiphy.num_iftype_ext_capab; i++) { 2894 const struct wiphy_iftype_ext_capab *capab; 2895 2896 capab = &rdev->wiphy.iftype_ext_capab[i]; 2897 2898 nested_ext_capab = nla_nest_start_noflag(msg, 2899 i); 2900 if (!nested_ext_capab || 2901 nla_put_u32(msg, NL80211_ATTR_IFTYPE, 2902 capab->iftype) || 2903 nla_put(msg, NL80211_ATTR_EXT_CAPA, 2904 capab->extended_capabilities_len, 2905 capab->extended_capabilities) || 2906 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK, 2907 capab->extended_capabilities_len, 2908 capab->extended_capabilities_mask)) 2909 goto nla_put_failure; 2910 2911 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO && 2912 (nla_put_u16(msg, 2913 NL80211_ATTR_EML_CAPABILITY, 2914 capab->eml_capabilities) || 2915 nla_put_u16(msg, 2916 NL80211_ATTR_MLD_CAPA_AND_OPS, 2917 capab->mld_capa_and_ops))) 2918 goto nla_put_failure; 2919 2920 nla_nest_end(msg, nested_ext_capab); 2921 if (state->split) 2922 break; 2923 } 2924 nla_nest_end(msg, nested); 2925 if (i < rdev->wiphy.num_iftype_ext_capab) { 2926 state->capa_start = i + 1; 2927 break; 2928 } 2929 } 2930 2931 if (nla_put_u32(msg, NL80211_ATTR_BANDS, 2932 rdev->wiphy.nan_supported_bands)) 2933 goto nla_put_failure; 2934 2935 if (wiphy_ext_feature_isset(&rdev->wiphy, 2936 NL80211_EXT_FEATURE_TXQS)) { 2937 struct cfg80211_txq_stats txqstats = {}; 2938 int res; 2939 2940 res = rdev_get_txq_stats(rdev, NULL, &txqstats); 2941 if (!res && 2942 !nl80211_put_txq_stats(msg, &txqstats, 2943 NL80211_ATTR_TXQ_STATS)) 2944 goto nla_put_failure; 2945 2946 if (nla_put_u32(msg, NL80211_ATTR_TXQ_LIMIT, 2947 rdev->wiphy.txq_limit)) 2948 goto nla_put_failure; 2949 if (nla_put_u32(msg, NL80211_ATTR_TXQ_MEMORY_LIMIT, 2950 rdev->wiphy.txq_memory_limit)) 2951 goto nla_put_failure; 2952 if (nla_put_u32(msg, NL80211_ATTR_TXQ_QUANTUM, 2953 rdev->wiphy.txq_quantum)) 2954 goto nla_put_failure; 2955 } 2956 2957 state->split_start++; 2958 break; 2959 case 14: 2960 if (nl80211_send_pmsr_capa(rdev, msg)) 2961 goto nla_put_failure; 2962 2963 state->split_start++; 2964 break; 2965 case 15: 2966 if (rdev->wiphy.akm_suites && 2967 nla_put(msg, NL80211_ATTR_AKM_SUITES, 2968 sizeof(u32) * rdev->wiphy.n_akm_suites, 2969 rdev->wiphy.akm_suites)) 2970 goto nla_put_failure; 2971 2972 if (nl80211_put_iftype_akm_suites(rdev, msg)) 2973 goto nla_put_failure; 2974 2975 if (nl80211_put_tid_config_support(rdev, msg)) 2976 goto nla_put_failure; 2977 state->split_start++; 2978 break; 2979 case 16: 2980 if (nl80211_put_sar_specs(rdev, msg)) 2981 goto nla_put_failure; 2982 2983 if (nl80211_put_mbssid_support(&rdev->wiphy, msg)) 2984 goto nla_put_failure; 2985 2986 if (nla_put_u16(msg, NL80211_ATTR_MAX_NUM_AKM_SUITES, 2987 rdev->wiphy.max_num_akm_suites)) 2988 goto nla_put_failure; 2989 2990 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO) 2991 nla_put_flag(msg, NL80211_ATTR_MLO_SUPPORT); 2992 2993 if (rdev->wiphy.hw_timestamp_max_peers && 2994 nla_put_u16(msg, NL80211_ATTR_MAX_HW_TIMESTAMP_PEERS, 2995 rdev->wiphy.hw_timestamp_max_peers)) 2996 goto nla_put_failure; 2997 2998 /* done */ 2999 state->split_start = 0; 3000 break; 3001 } 3002 finish: 3003 genlmsg_end(msg, hdr); 3004 return 0; 3005 3006 nla_put_failure: 3007 genlmsg_cancel(msg, hdr); 3008 return -EMSGSIZE; 3009 } 3010 3011 static int nl80211_dump_wiphy_parse(struct sk_buff *skb, 3012 struct netlink_callback *cb, 3013 struct nl80211_dump_wiphy_state *state) 3014 { 3015 struct nlattr **tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL); 3016 int ret; 3017 3018 if (!tb) 3019 return -ENOMEM; 3020 3021 ret = nlmsg_parse_deprecated(cb->nlh, 3022 GENL_HDRLEN + nl80211_fam.hdrsize, 3023 tb, nl80211_fam.maxattr, 3024 nl80211_policy, NULL); 3025 /* ignore parse errors for backward compatibility */ 3026 if (ret) { 3027 ret = 0; 3028 goto out; 3029 } 3030 3031 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP]; 3032 if (tb[NL80211_ATTR_WIPHY]) 3033 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]); 3034 if (tb[NL80211_ATTR_WDEV]) 3035 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32; 3036 if (tb[NL80211_ATTR_IFINDEX]) { 3037 struct net_device *netdev; 3038 struct cfg80211_registered_device *rdev; 3039 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]); 3040 3041 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx); 3042 if (!netdev) { 3043 ret = -ENODEV; 3044 goto out; 3045 } 3046 if (netdev->ieee80211_ptr) { 3047 rdev = wiphy_to_rdev( 3048 netdev->ieee80211_ptr->wiphy); 3049 state->filter_wiphy = rdev->wiphy_idx; 3050 } 3051 } 3052 3053 ret = 0; 3054 out: 3055 kfree(tb); 3056 return ret; 3057 } 3058 3059 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb) 3060 { 3061 int idx = 0, ret; 3062 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0]; 3063 struct cfg80211_registered_device *rdev; 3064 3065 rtnl_lock(); 3066 if (!state) { 3067 state = kzalloc(sizeof(*state), GFP_KERNEL); 3068 if (!state) { 3069 rtnl_unlock(); 3070 return -ENOMEM; 3071 } 3072 state->filter_wiphy = -1; 3073 ret = nl80211_dump_wiphy_parse(skb, cb, state); 3074 if (ret) { 3075 kfree(state); 3076 rtnl_unlock(); 3077 return ret; 3078 } 3079 cb->args[0] = (long)state; 3080 } 3081 3082 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 3083 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk))) 3084 continue; 3085 if (++idx <= state->start) 3086 continue; 3087 if (state->filter_wiphy != -1 && 3088 state->filter_wiphy != rdev->wiphy_idx) 3089 continue; 3090 wiphy_lock(&rdev->wiphy); 3091 /* attempt to fit multiple wiphy data chunks into the skb */ 3092 do { 3093 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, 3094 skb, 3095 NETLINK_CB(cb->skb).portid, 3096 cb->nlh->nlmsg_seq, 3097 NLM_F_MULTI, state); 3098 if (ret < 0) { 3099 /* 3100 * If sending the wiphy data didn't fit (ENOBUFS 3101 * or EMSGSIZE returned), this SKB is still 3102 * empty (so it's not too big because another 3103 * wiphy dataset is already in the skb) and 3104 * we've not tried to adjust the dump allocation 3105 * yet ... then adjust the alloc size to be 3106 * bigger, and return 1 but with the empty skb. 3107 * This results in an empty message being RX'ed 3108 * in userspace, but that is ignored. 3109 * 3110 * We can then retry with the larger buffer. 3111 */ 3112 if ((ret == -ENOBUFS || ret == -EMSGSIZE) && 3113 !skb->len && !state->split && 3114 cb->min_dump_alloc < 4096) { 3115 cb->min_dump_alloc = 4096; 3116 state->split_start = 0; 3117 wiphy_unlock(&rdev->wiphy); 3118 rtnl_unlock(); 3119 return 1; 3120 } 3121 idx--; 3122 break; 3123 } 3124 } while (state->split_start > 0); 3125 wiphy_unlock(&rdev->wiphy); 3126 break; 3127 } 3128 rtnl_unlock(); 3129 3130 state->start = idx; 3131 3132 return skb->len; 3133 } 3134 3135 static int nl80211_dump_wiphy_done(struct netlink_callback *cb) 3136 { 3137 kfree((void *)cb->args[0]); 3138 return 0; 3139 } 3140 3141 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info) 3142 { 3143 struct sk_buff *msg; 3144 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 3145 struct nl80211_dump_wiphy_state state = {}; 3146 3147 msg = nlmsg_new(4096, GFP_KERNEL); 3148 if (!msg) 3149 return -ENOMEM; 3150 3151 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg, 3152 info->snd_portid, info->snd_seq, 0, 3153 &state) < 0) { 3154 nlmsg_free(msg); 3155 return -ENOBUFS; 3156 } 3157 3158 return genlmsg_reply(msg, info); 3159 } 3160 3161 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = { 3162 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 }, 3163 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 }, 3164 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 }, 3165 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 }, 3166 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 }, 3167 }; 3168 3169 static int parse_txq_params(struct nlattr *tb[], 3170 struct ieee80211_txq_params *txq_params) 3171 { 3172 u8 ac; 3173 3174 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] || 3175 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] || 3176 !tb[NL80211_TXQ_ATTR_AIFS]) 3177 return -EINVAL; 3178 3179 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]); 3180 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]); 3181 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]); 3182 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]); 3183 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]); 3184 3185 if (ac >= NL80211_NUM_ACS) 3186 return -EINVAL; 3187 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS); 3188 return 0; 3189 } 3190 3191 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev) 3192 { 3193 /* 3194 * You can only set the channel explicitly for some interfaces, 3195 * most have their channel managed via their respective 3196 * "establish a connection" command (connect, join, ...) 3197 * 3198 * For AP/GO and mesh mode, the channel can be set with the 3199 * channel userspace API, but is only stored and passed to the 3200 * low-level driver when the AP starts or the mesh is joined. 3201 * This is for backward compatibility, userspace can also give 3202 * the channel in the start-ap or join-mesh commands instead. 3203 * 3204 * Monitors are special as they are normally slaved to 3205 * whatever else is going on, so they have their own special 3206 * operation to set the monitor channel if possible. 3207 */ 3208 return !wdev || 3209 wdev->iftype == NL80211_IFTYPE_AP || 3210 wdev->iftype == NL80211_IFTYPE_MESH_POINT || 3211 wdev->iftype == NL80211_IFTYPE_MONITOR || 3212 wdev->iftype == NL80211_IFTYPE_P2P_GO; 3213 } 3214 3215 static int nl80211_parse_punct_bitmap(struct cfg80211_registered_device *rdev, 3216 struct genl_info *info, 3217 const struct cfg80211_chan_def *chandef, 3218 u16 *punct_bitmap) 3219 { 3220 if (!wiphy_ext_feature_isset(&rdev->wiphy, NL80211_EXT_FEATURE_PUNCT)) 3221 return -EINVAL; 3222 3223 *punct_bitmap = nla_get_u32(info->attrs[NL80211_ATTR_PUNCT_BITMAP]); 3224 if (!cfg80211_valid_disable_subchannel_bitmap(punct_bitmap, chandef)) 3225 return -EINVAL; 3226 3227 return 0; 3228 } 3229 3230 int nl80211_parse_chandef(struct cfg80211_registered_device *rdev, 3231 struct genl_info *info, 3232 struct cfg80211_chan_def *chandef) 3233 { 3234 struct netlink_ext_ack *extack = info->extack; 3235 struct nlattr **attrs = info->attrs; 3236 u32 control_freq; 3237 3238 if (!attrs[NL80211_ATTR_WIPHY_FREQ]) { 3239 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ], 3240 "Frequency is missing"); 3241 return -EINVAL; 3242 } 3243 3244 control_freq = MHZ_TO_KHZ( 3245 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); 3246 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]) 3247 control_freq += 3248 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]); 3249 3250 memset(chandef, 0, sizeof(*chandef)); 3251 chandef->chan = ieee80211_get_channel_khz(&rdev->wiphy, control_freq); 3252 chandef->width = NL80211_CHAN_WIDTH_20_NOHT; 3253 chandef->center_freq1 = KHZ_TO_MHZ(control_freq); 3254 chandef->freq1_offset = control_freq % 1000; 3255 chandef->center_freq2 = 0; 3256 3257 /* Primary channel not allowed */ 3258 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED) { 3259 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ], 3260 "Channel is disabled"); 3261 return -EINVAL; 3262 } 3263 3264 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) { 3265 enum nl80211_channel_type chantype; 3266 3267 chantype = nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]); 3268 3269 switch (chantype) { 3270 case NL80211_CHAN_NO_HT: 3271 case NL80211_CHAN_HT20: 3272 case NL80211_CHAN_HT40PLUS: 3273 case NL80211_CHAN_HT40MINUS: 3274 cfg80211_chandef_create(chandef, chandef->chan, 3275 chantype); 3276 /* user input for center_freq is incorrect */ 3277 if (attrs[NL80211_ATTR_CENTER_FREQ1] && 3278 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) { 3279 NL_SET_ERR_MSG_ATTR(extack, 3280 attrs[NL80211_ATTR_CENTER_FREQ1], 3281 "bad center frequency 1"); 3282 return -EINVAL; 3283 } 3284 /* center_freq2 must be zero */ 3285 if (attrs[NL80211_ATTR_CENTER_FREQ2] && 3286 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2])) { 3287 NL_SET_ERR_MSG_ATTR(extack, 3288 attrs[NL80211_ATTR_CENTER_FREQ2], 3289 "center frequency 2 can't be used"); 3290 return -EINVAL; 3291 } 3292 break; 3293 default: 3294 NL_SET_ERR_MSG_ATTR(extack, 3295 attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE], 3296 "invalid channel type"); 3297 return -EINVAL; 3298 } 3299 } else if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) { 3300 chandef->width = 3301 nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]); 3302 if (chandef->chan->band == NL80211_BAND_S1GHZ) { 3303 /* User input error for channel width doesn't match channel */ 3304 if (chandef->width != ieee80211_s1g_channel_width(chandef->chan)) { 3305 NL_SET_ERR_MSG_ATTR(extack, 3306 attrs[NL80211_ATTR_CHANNEL_WIDTH], 3307 "bad channel width"); 3308 return -EINVAL; 3309 } 3310 } 3311 if (attrs[NL80211_ATTR_CENTER_FREQ1]) { 3312 chandef->center_freq1 = 3313 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]); 3314 if (attrs[NL80211_ATTR_CENTER_FREQ1_OFFSET]) 3315 chandef->freq1_offset = nla_get_u32( 3316 attrs[NL80211_ATTR_CENTER_FREQ1_OFFSET]); 3317 else 3318 chandef->freq1_offset = 0; 3319 } 3320 if (attrs[NL80211_ATTR_CENTER_FREQ2]) 3321 chandef->center_freq2 = 3322 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]); 3323 } 3324 3325 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) { 3326 chandef->edmg.channels = 3327 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]); 3328 3329 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]) 3330 chandef->edmg.bw_config = 3331 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]); 3332 } else { 3333 chandef->edmg.bw_config = 0; 3334 chandef->edmg.channels = 0; 3335 } 3336 3337 if (!cfg80211_chandef_valid(chandef)) { 3338 NL_SET_ERR_MSG(extack, "invalid channel definition"); 3339 return -EINVAL; 3340 } 3341 3342 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef, 3343 IEEE80211_CHAN_DISABLED)) { 3344 NL_SET_ERR_MSG(extack, "(extension) channel is disabled"); 3345 return -EINVAL; 3346 } 3347 3348 if ((chandef->width == NL80211_CHAN_WIDTH_5 || 3349 chandef->width == NL80211_CHAN_WIDTH_10) && 3350 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) { 3351 NL_SET_ERR_MSG(extack, "5/10 MHz not supported"); 3352 return -EINVAL; 3353 } 3354 3355 return 0; 3356 } 3357 3358 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev, 3359 struct net_device *dev, 3360 struct genl_info *info, 3361 int _link_id) 3362 { 3363 struct cfg80211_chan_def chandef; 3364 int result; 3365 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR; 3366 struct wireless_dev *wdev = NULL; 3367 int link_id = _link_id; 3368 3369 if (dev) 3370 wdev = dev->ieee80211_ptr; 3371 if (!nl80211_can_set_dev_channel(wdev)) 3372 return -EOPNOTSUPP; 3373 if (wdev) 3374 iftype = wdev->iftype; 3375 3376 if (link_id < 0) { 3377 if (wdev && wdev->valid_links) 3378 return -EINVAL; 3379 link_id = 0; 3380 } 3381 3382 result = nl80211_parse_chandef(rdev, info, &chandef); 3383 if (result) 3384 return result; 3385 3386 switch (iftype) { 3387 case NL80211_IFTYPE_AP: 3388 case NL80211_IFTYPE_P2P_GO: 3389 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef, 3390 iftype)) 3391 return -EINVAL; 3392 if (wdev->links[link_id].ap.beacon_interval) { 3393 struct ieee80211_channel *cur_chan; 3394 3395 if (!dev || !rdev->ops->set_ap_chanwidth || 3396 !(rdev->wiphy.features & 3397 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) 3398 return -EBUSY; 3399 3400 /* Only allow dynamic channel width changes */ 3401 cur_chan = wdev->links[link_id].ap.chandef.chan; 3402 if (chandef.chan != cur_chan) 3403 return -EBUSY; 3404 3405 /* only allow this for regular channel widths */ 3406 switch (wdev->links[link_id].ap.chandef.width) { 3407 case NL80211_CHAN_WIDTH_20_NOHT: 3408 case NL80211_CHAN_WIDTH_20: 3409 case NL80211_CHAN_WIDTH_40: 3410 case NL80211_CHAN_WIDTH_80: 3411 case NL80211_CHAN_WIDTH_80P80: 3412 case NL80211_CHAN_WIDTH_160: 3413 case NL80211_CHAN_WIDTH_320: 3414 break; 3415 default: 3416 return -EINVAL; 3417 } 3418 3419 switch (chandef.width) { 3420 case NL80211_CHAN_WIDTH_20_NOHT: 3421 case NL80211_CHAN_WIDTH_20: 3422 case NL80211_CHAN_WIDTH_40: 3423 case NL80211_CHAN_WIDTH_80: 3424 case NL80211_CHAN_WIDTH_80P80: 3425 case NL80211_CHAN_WIDTH_160: 3426 case NL80211_CHAN_WIDTH_320: 3427 break; 3428 default: 3429 return -EINVAL; 3430 } 3431 3432 result = rdev_set_ap_chanwidth(rdev, dev, link_id, 3433 &chandef); 3434 if (result) 3435 return result; 3436 wdev->links[link_id].ap.chandef = chandef; 3437 } else { 3438 wdev->u.ap.preset_chandef = chandef; 3439 } 3440 return 0; 3441 case NL80211_IFTYPE_MESH_POINT: 3442 return cfg80211_set_mesh_channel(rdev, wdev, &chandef); 3443 case NL80211_IFTYPE_MONITOR: 3444 return cfg80211_set_monitor_channel(rdev, &chandef); 3445 default: 3446 break; 3447 } 3448 3449 return -EINVAL; 3450 } 3451 3452 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info) 3453 { 3454 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 3455 int link_id = nl80211_link_id_or_invalid(info->attrs); 3456 struct net_device *netdev = info->user_ptr[1]; 3457 int ret; 3458 3459 wdev_lock(netdev->ieee80211_ptr); 3460 ret = __nl80211_set_channel(rdev, netdev, info, link_id); 3461 wdev_unlock(netdev->ieee80211_ptr); 3462 3463 return ret; 3464 } 3465 3466 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info) 3467 { 3468 struct cfg80211_registered_device *rdev = NULL; 3469 struct net_device *netdev = NULL; 3470 struct wireless_dev *wdev; 3471 int result = 0, rem_txq_params = 0; 3472 struct nlattr *nl_txq_params; 3473 u32 changed; 3474 u8 retry_short = 0, retry_long = 0; 3475 u32 frag_threshold = 0, rts_threshold = 0; 3476 u8 coverage_class = 0; 3477 u32 txq_limit = 0, txq_memory_limit = 0, txq_quantum = 0; 3478 3479 rtnl_lock(); 3480 /* 3481 * Try to find the wiphy and netdev. Normally this 3482 * function shouldn't need the netdev, but this is 3483 * done for backward compatibility -- previously 3484 * setting the channel was done per wiphy, but now 3485 * it is per netdev. Previous userland like hostapd 3486 * also passed a netdev to set_wiphy, so that it is 3487 * possible to let that go to the right netdev! 3488 */ 3489 3490 if (info->attrs[NL80211_ATTR_IFINDEX]) { 3491 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]); 3492 3493 netdev = __dev_get_by_index(genl_info_net(info), ifindex); 3494 if (netdev && netdev->ieee80211_ptr) 3495 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy); 3496 else 3497 netdev = NULL; 3498 } 3499 3500 if (!netdev) { 3501 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info), 3502 info->attrs); 3503 if (IS_ERR(rdev)) { 3504 rtnl_unlock(); 3505 return PTR_ERR(rdev); 3506 } 3507 wdev = NULL; 3508 netdev = NULL; 3509 result = 0; 3510 } else 3511 wdev = netdev->ieee80211_ptr; 3512 3513 wiphy_lock(&rdev->wiphy); 3514 3515 /* 3516 * end workaround code, by now the rdev is available 3517 * and locked, and wdev may or may not be NULL. 3518 */ 3519 3520 if (info->attrs[NL80211_ATTR_WIPHY_NAME]) 3521 result = cfg80211_dev_rename( 3522 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME])); 3523 rtnl_unlock(); 3524 3525 if (result) 3526 goto out; 3527 3528 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) { 3529 struct ieee80211_txq_params txq_params; 3530 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1]; 3531 3532 if (!rdev->ops->set_txq_params) { 3533 result = -EOPNOTSUPP; 3534 goto out; 3535 } 3536 3537 if (!netdev) { 3538 result = -EINVAL; 3539 goto out; 3540 } 3541 3542 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 3543 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) { 3544 result = -EINVAL; 3545 goto out; 3546 } 3547 3548 if (!netif_running(netdev)) { 3549 result = -ENETDOWN; 3550 goto out; 3551 } 3552 3553 nla_for_each_nested(nl_txq_params, 3554 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS], 3555 rem_txq_params) { 3556 result = nla_parse_nested_deprecated(tb, 3557 NL80211_TXQ_ATTR_MAX, 3558 nl_txq_params, 3559 txq_params_policy, 3560 info->extack); 3561 if (result) 3562 goto out; 3563 result = parse_txq_params(tb, &txq_params); 3564 if (result) 3565 goto out; 3566 3567 txq_params.link_id = 3568 nl80211_link_id_or_invalid(info->attrs); 3569 3570 wdev_lock(netdev->ieee80211_ptr); 3571 if (txq_params.link_id >= 0 && 3572 !(netdev->ieee80211_ptr->valid_links & 3573 BIT(txq_params.link_id))) 3574 result = -ENOLINK; 3575 else if (txq_params.link_id >= 0 && 3576 !netdev->ieee80211_ptr->valid_links) 3577 result = -EINVAL; 3578 else 3579 result = rdev_set_txq_params(rdev, netdev, 3580 &txq_params); 3581 wdev_unlock(netdev->ieee80211_ptr); 3582 if (result) 3583 goto out; 3584 } 3585 } 3586 3587 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) { 3588 int link_id = nl80211_link_id_or_invalid(info->attrs); 3589 3590 if (wdev) { 3591 wdev_lock(wdev); 3592 result = __nl80211_set_channel( 3593 rdev, 3594 nl80211_can_set_dev_channel(wdev) ? netdev : NULL, 3595 info, link_id); 3596 wdev_unlock(wdev); 3597 } else { 3598 result = __nl80211_set_channel(rdev, netdev, info, link_id); 3599 } 3600 3601 if (result) 3602 goto out; 3603 } 3604 3605 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) { 3606 struct wireless_dev *txp_wdev = wdev; 3607 enum nl80211_tx_power_setting type; 3608 int idx, mbm = 0; 3609 3610 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER)) 3611 txp_wdev = NULL; 3612 3613 if (!rdev->ops->set_tx_power) { 3614 result = -EOPNOTSUPP; 3615 goto out; 3616 } 3617 3618 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING; 3619 type = nla_get_u32(info->attrs[idx]); 3620 3621 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] && 3622 (type != NL80211_TX_POWER_AUTOMATIC)) { 3623 result = -EINVAL; 3624 goto out; 3625 } 3626 3627 if (type != NL80211_TX_POWER_AUTOMATIC) { 3628 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL; 3629 mbm = nla_get_u32(info->attrs[idx]); 3630 } 3631 3632 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm); 3633 if (result) 3634 goto out; 3635 } 3636 3637 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] && 3638 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) { 3639 u32 tx_ant, rx_ant; 3640 3641 if ((!rdev->wiphy.available_antennas_tx && 3642 !rdev->wiphy.available_antennas_rx) || 3643 !rdev->ops->set_antenna) { 3644 result = -EOPNOTSUPP; 3645 goto out; 3646 } 3647 3648 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]); 3649 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]); 3650 3651 /* reject antenna configurations which don't match the 3652 * available antenna masks, except for the "all" mask */ 3653 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) || 3654 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) { 3655 result = -EINVAL; 3656 goto out; 3657 } 3658 3659 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx; 3660 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx; 3661 3662 result = rdev_set_antenna(rdev, tx_ant, rx_ant); 3663 if (result) 3664 goto out; 3665 } 3666 3667 changed = 0; 3668 3669 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) { 3670 retry_short = nla_get_u8( 3671 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]); 3672 3673 changed |= WIPHY_PARAM_RETRY_SHORT; 3674 } 3675 3676 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) { 3677 retry_long = nla_get_u8( 3678 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]); 3679 3680 changed |= WIPHY_PARAM_RETRY_LONG; 3681 } 3682 3683 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) { 3684 frag_threshold = nla_get_u32( 3685 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]); 3686 if (frag_threshold < 256) { 3687 result = -EINVAL; 3688 goto out; 3689 } 3690 3691 if (frag_threshold != (u32) -1) { 3692 /* 3693 * Fragments (apart from the last one) are required to 3694 * have even length. Make the fragmentation code 3695 * simpler by stripping LSB should someone try to use 3696 * odd threshold value. 3697 */ 3698 frag_threshold &= ~0x1; 3699 } 3700 changed |= WIPHY_PARAM_FRAG_THRESHOLD; 3701 } 3702 3703 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) { 3704 rts_threshold = nla_get_u32( 3705 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]); 3706 changed |= WIPHY_PARAM_RTS_THRESHOLD; 3707 } 3708 3709 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) { 3710 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) { 3711 result = -EINVAL; 3712 goto out; 3713 } 3714 3715 coverage_class = nla_get_u8( 3716 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]); 3717 changed |= WIPHY_PARAM_COVERAGE_CLASS; 3718 } 3719 3720 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) { 3721 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION)) { 3722 result = -EOPNOTSUPP; 3723 goto out; 3724 } 3725 3726 changed |= WIPHY_PARAM_DYN_ACK; 3727 } 3728 3729 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) { 3730 if (!wiphy_ext_feature_isset(&rdev->wiphy, 3731 NL80211_EXT_FEATURE_TXQS)) { 3732 result = -EOPNOTSUPP; 3733 goto out; 3734 } 3735 txq_limit = nla_get_u32( 3736 info->attrs[NL80211_ATTR_TXQ_LIMIT]); 3737 changed |= WIPHY_PARAM_TXQ_LIMIT; 3738 } 3739 3740 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) { 3741 if (!wiphy_ext_feature_isset(&rdev->wiphy, 3742 NL80211_EXT_FEATURE_TXQS)) { 3743 result = -EOPNOTSUPP; 3744 goto out; 3745 } 3746 txq_memory_limit = nla_get_u32( 3747 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]); 3748 changed |= WIPHY_PARAM_TXQ_MEMORY_LIMIT; 3749 } 3750 3751 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) { 3752 if (!wiphy_ext_feature_isset(&rdev->wiphy, 3753 NL80211_EXT_FEATURE_TXQS)) { 3754 result = -EOPNOTSUPP; 3755 goto out; 3756 } 3757 txq_quantum = nla_get_u32( 3758 info->attrs[NL80211_ATTR_TXQ_QUANTUM]); 3759 changed |= WIPHY_PARAM_TXQ_QUANTUM; 3760 } 3761 3762 if (changed) { 3763 u8 old_retry_short, old_retry_long; 3764 u32 old_frag_threshold, old_rts_threshold; 3765 u8 old_coverage_class; 3766 u32 old_txq_limit, old_txq_memory_limit, old_txq_quantum; 3767 3768 if (!rdev->ops->set_wiphy_params) { 3769 result = -EOPNOTSUPP; 3770 goto out; 3771 } 3772 3773 old_retry_short = rdev->wiphy.retry_short; 3774 old_retry_long = rdev->wiphy.retry_long; 3775 old_frag_threshold = rdev->wiphy.frag_threshold; 3776 old_rts_threshold = rdev->wiphy.rts_threshold; 3777 old_coverage_class = rdev->wiphy.coverage_class; 3778 old_txq_limit = rdev->wiphy.txq_limit; 3779 old_txq_memory_limit = rdev->wiphy.txq_memory_limit; 3780 old_txq_quantum = rdev->wiphy.txq_quantum; 3781 3782 if (changed & WIPHY_PARAM_RETRY_SHORT) 3783 rdev->wiphy.retry_short = retry_short; 3784 if (changed & WIPHY_PARAM_RETRY_LONG) 3785 rdev->wiphy.retry_long = retry_long; 3786 if (changed & WIPHY_PARAM_FRAG_THRESHOLD) 3787 rdev->wiphy.frag_threshold = frag_threshold; 3788 if (changed & WIPHY_PARAM_RTS_THRESHOLD) 3789 rdev->wiphy.rts_threshold = rts_threshold; 3790 if (changed & WIPHY_PARAM_COVERAGE_CLASS) 3791 rdev->wiphy.coverage_class = coverage_class; 3792 if (changed & WIPHY_PARAM_TXQ_LIMIT) 3793 rdev->wiphy.txq_limit = txq_limit; 3794 if (changed & WIPHY_PARAM_TXQ_MEMORY_LIMIT) 3795 rdev->wiphy.txq_memory_limit = txq_memory_limit; 3796 if (changed & WIPHY_PARAM_TXQ_QUANTUM) 3797 rdev->wiphy.txq_quantum = txq_quantum; 3798 3799 result = rdev_set_wiphy_params(rdev, changed); 3800 if (result) { 3801 rdev->wiphy.retry_short = old_retry_short; 3802 rdev->wiphy.retry_long = old_retry_long; 3803 rdev->wiphy.frag_threshold = old_frag_threshold; 3804 rdev->wiphy.rts_threshold = old_rts_threshold; 3805 rdev->wiphy.coverage_class = old_coverage_class; 3806 rdev->wiphy.txq_limit = old_txq_limit; 3807 rdev->wiphy.txq_memory_limit = old_txq_memory_limit; 3808 rdev->wiphy.txq_quantum = old_txq_quantum; 3809 goto out; 3810 } 3811 } 3812 3813 result = 0; 3814 3815 out: 3816 wiphy_unlock(&rdev->wiphy); 3817 return result; 3818 } 3819 3820 int nl80211_send_chandef(struct sk_buff *msg, const struct cfg80211_chan_def *chandef) 3821 { 3822 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 3823 return -EINVAL; 3824 3825 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, 3826 chandef->chan->center_freq)) 3827 return -ENOBUFS; 3828 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET, 3829 chandef->chan->freq_offset)) 3830 return -ENOBUFS; 3831 switch (chandef->width) { 3832 case NL80211_CHAN_WIDTH_20_NOHT: 3833 case NL80211_CHAN_WIDTH_20: 3834 case NL80211_CHAN_WIDTH_40: 3835 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, 3836 cfg80211_get_chandef_type(chandef))) 3837 return -ENOBUFS; 3838 break; 3839 default: 3840 break; 3841 } 3842 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width)) 3843 return -ENOBUFS; 3844 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1)) 3845 return -ENOBUFS; 3846 if (chandef->center_freq2 && 3847 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2)) 3848 return -ENOBUFS; 3849 return 0; 3850 } 3851 EXPORT_SYMBOL(nl80211_send_chandef); 3852 3853 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags, 3854 struct cfg80211_registered_device *rdev, 3855 struct wireless_dev *wdev, 3856 enum nl80211_commands cmd) 3857 { 3858 struct net_device *dev = wdev->netdev; 3859 void *hdr; 3860 3861 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE && 3862 cmd != NL80211_CMD_DEL_INTERFACE && 3863 cmd != NL80211_CMD_SET_INTERFACE); 3864 3865 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd); 3866 if (!hdr) 3867 return -1; 3868 3869 if (dev && 3870 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 3871 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name))) 3872 goto nla_put_failure; 3873 3874 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 3875 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) || 3876 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 3877 NL80211_ATTR_PAD) || 3878 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) || 3879 nla_put_u32(msg, NL80211_ATTR_GENERATION, 3880 rdev->devlist_generation ^ 3881 (cfg80211_rdev_list_generation << 2)) || 3882 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr)) 3883 goto nla_put_failure; 3884 3885 if (rdev->ops->get_channel && !wdev->valid_links) { 3886 struct cfg80211_chan_def chandef = {}; 3887 int ret; 3888 3889 ret = rdev_get_channel(rdev, wdev, 0, &chandef); 3890 if (ret == 0 && nl80211_send_chandef(msg, &chandef)) 3891 goto nla_put_failure; 3892 } 3893 3894 if (rdev->ops->get_tx_power) { 3895 int dbm, ret; 3896 3897 ret = rdev_get_tx_power(rdev, wdev, &dbm); 3898 if (ret == 0 && 3899 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL, 3900 DBM_TO_MBM(dbm))) 3901 goto nla_put_failure; 3902 } 3903 3904 wdev_lock(wdev); 3905 switch (wdev->iftype) { 3906 case NL80211_IFTYPE_AP: 3907 case NL80211_IFTYPE_P2P_GO: 3908 if (wdev->u.ap.ssid_len && 3909 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ap.ssid_len, 3910 wdev->u.ap.ssid)) 3911 goto nla_put_failure_locked; 3912 break; 3913 case NL80211_IFTYPE_STATION: 3914 case NL80211_IFTYPE_P2P_CLIENT: 3915 if (wdev->u.client.ssid_len && 3916 nla_put(msg, NL80211_ATTR_SSID, wdev->u.client.ssid_len, 3917 wdev->u.client.ssid)) 3918 goto nla_put_failure_locked; 3919 break; 3920 case NL80211_IFTYPE_ADHOC: 3921 if (wdev->u.ibss.ssid_len && 3922 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ibss.ssid_len, 3923 wdev->u.ibss.ssid)) 3924 goto nla_put_failure_locked; 3925 break; 3926 default: 3927 /* nothing */ 3928 break; 3929 } 3930 wdev_unlock(wdev); 3931 3932 if (rdev->ops->get_txq_stats) { 3933 struct cfg80211_txq_stats txqstats = {}; 3934 int ret = rdev_get_txq_stats(rdev, wdev, &txqstats); 3935 3936 if (ret == 0 && 3937 !nl80211_put_txq_stats(msg, &txqstats, 3938 NL80211_ATTR_TXQ_STATS)) 3939 goto nla_put_failure; 3940 } 3941 3942 if (wdev->valid_links) { 3943 unsigned int link_id; 3944 struct nlattr *links = nla_nest_start(msg, 3945 NL80211_ATTR_MLO_LINKS); 3946 3947 if (!links) 3948 goto nla_put_failure; 3949 3950 for_each_valid_link(wdev, link_id) { 3951 struct nlattr *link = nla_nest_start(msg, link_id + 1); 3952 struct cfg80211_chan_def chandef = {}; 3953 int ret; 3954 3955 if (!link) 3956 goto nla_put_failure; 3957 3958 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)) 3959 goto nla_put_failure; 3960 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, 3961 wdev->links[link_id].addr)) 3962 goto nla_put_failure; 3963 3964 ret = rdev_get_channel(rdev, wdev, link_id, &chandef); 3965 if (ret == 0 && nl80211_send_chandef(msg, &chandef)) 3966 goto nla_put_failure; 3967 3968 nla_nest_end(msg, link); 3969 } 3970 3971 nla_nest_end(msg, links); 3972 } 3973 3974 genlmsg_end(msg, hdr); 3975 return 0; 3976 3977 nla_put_failure_locked: 3978 wdev_unlock(wdev); 3979 nla_put_failure: 3980 genlmsg_cancel(msg, hdr); 3981 return -EMSGSIZE; 3982 } 3983 3984 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb) 3985 { 3986 int wp_idx = 0; 3987 int if_idx = 0; 3988 int wp_start = cb->args[0]; 3989 int if_start = cb->args[1]; 3990 int filter_wiphy = -1; 3991 struct cfg80211_registered_device *rdev; 3992 struct wireless_dev *wdev; 3993 int ret; 3994 3995 rtnl_lock(); 3996 if (!cb->args[2]) { 3997 struct nl80211_dump_wiphy_state state = { 3998 .filter_wiphy = -1, 3999 }; 4000 4001 ret = nl80211_dump_wiphy_parse(skb, cb, &state); 4002 if (ret) 4003 goto out_unlock; 4004 4005 filter_wiphy = state.filter_wiphy; 4006 4007 /* 4008 * if filtering, set cb->args[2] to +1 since 0 is the default 4009 * value needed to determine that parsing is necessary. 4010 */ 4011 if (filter_wiphy >= 0) 4012 cb->args[2] = filter_wiphy + 1; 4013 else 4014 cb->args[2] = -1; 4015 } else if (cb->args[2] > 0) { 4016 filter_wiphy = cb->args[2] - 1; 4017 } 4018 4019 list_for_each_entry(rdev, &cfg80211_rdev_list, list) { 4020 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk))) 4021 continue; 4022 if (wp_idx < wp_start) { 4023 wp_idx++; 4024 continue; 4025 } 4026 4027 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx) 4028 continue; 4029 4030 if_idx = 0; 4031 4032 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 4033 if (if_idx < if_start) { 4034 if_idx++; 4035 continue; 4036 } 4037 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid, 4038 cb->nlh->nlmsg_seq, NLM_F_MULTI, 4039 rdev, wdev, 4040 NL80211_CMD_NEW_INTERFACE) < 0) { 4041 goto out; 4042 } 4043 if_idx++; 4044 } 4045 4046 if_start = 0; 4047 wp_idx++; 4048 } 4049 out: 4050 cb->args[0] = wp_idx; 4051 cb->args[1] = if_idx; 4052 4053 ret = skb->len; 4054 out_unlock: 4055 rtnl_unlock(); 4056 4057 return ret; 4058 } 4059 4060 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info) 4061 { 4062 struct sk_buff *msg; 4063 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4064 struct wireless_dev *wdev = info->user_ptr[1]; 4065 4066 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4067 if (!msg) 4068 return -ENOMEM; 4069 4070 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0, 4071 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) { 4072 nlmsg_free(msg); 4073 return -ENOBUFS; 4074 } 4075 4076 return genlmsg_reply(msg, info); 4077 } 4078 4079 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = { 4080 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG }, 4081 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG }, 4082 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG }, 4083 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG }, 4084 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG }, 4085 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG }, 4086 }; 4087 4088 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags) 4089 { 4090 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1]; 4091 int flag; 4092 4093 *mntrflags = 0; 4094 4095 if (!nla) 4096 return -EINVAL; 4097 4098 if (nla_parse_nested_deprecated(flags, NL80211_MNTR_FLAG_MAX, nla, mntr_flags_policy, NULL)) 4099 return -EINVAL; 4100 4101 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++) 4102 if (flags[flag]) 4103 *mntrflags |= (1<<flag); 4104 4105 *mntrflags |= MONITOR_FLAG_CHANGED; 4106 4107 return 0; 4108 } 4109 4110 static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev, 4111 enum nl80211_iftype type, 4112 struct genl_info *info, 4113 struct vif_params *params) 4114 { 4115 bool change = false; 4116 int err; 4117 4118 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) { 4119 if (type != NL80211_IFTYPE_MONITOR) 4120 return -EINVAL; 4121 4122 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS], 4123 ¶ms->flags); 4124 if (err) 4125 return err; 4126 4127 change = true; 4128 } 4129 4130 if (params->flags & MONITOR_FLAG_ACTIVE && 4131 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR)) 4132 return -EOPNOTSUPP; 4133 4134 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) { 4135 const u8 *mumimo_groups; 4136 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER; 4137 4138 if (type != NL80211_IFTYPE_MONITOR) 4139 return -EINVAL; 4140 4141 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag)) 4142 return -EOPNOTSUPP; 4143 4144 mumimo_groups = 4145 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]); 4146 4147 /* bits 0 and 63 are reserved and must be zero */ 4148 if ((mumimo_groups[0] & BIT(0)) || 4149 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7))) 4150 return -EINVAL; 4151 4152 params->vht_mumimo_groups = mumimo_groups; 4153 change = true; 4154 } 4155 4156 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) { 4157 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER; 4158 4159 if (type != NL80211_IFTYPE_MONITOR) 4160 return -EINVAL; 4161 4162 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag)) 4163 return -EOPNOTSUPP; 4164 4165 params->vht_mumimo_follow_addr = 4166 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]); 4167 change = true; 4168 } 4169 4170 return change ? 1 : 0; 4171 } 4172 4173 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev, 4174 struct net_device *netdev, u8 use_4addr, 4175 enum nl80211_iftype iftype) 4176 { 4177 if (!use_4addr) { 4178 if (netdev && netif_is_bridge_port(netdev)) 4179 return -EBUSY; 4180 return 0; 4181 } 4182 4183 switch (iftype) { 4184 case NL80211_IFTYPE_AP_VLAN: 4185 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP) 4186 return 0; 4187 break; 4188 case NL80211_IFTYPE_STATION: 4189 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION) 4190 return 0; 4191 break; 4192 default: 4193 break; 4194 } 4195 4196 return -EOPNOTSUPP; 4197 } 4198 4199 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info) 4200 { 4201 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4202 struct vif_params params; 4203 int err; 4204 enum nl80211_iftype otype, ntype; 4205 struct net_device *dev = info->user_ptr[1]; 4206 bool change = false; 4207 4208 memset(¶ms, 0, sizeof(params)); 4209 4210 otype = ntype = dev->ieee80211_ptr->iftype; 4211 4212 if (info->attrs[NL80211_ATTR_IFTYPE]) { 4213 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]); 4214 if (otype != ntype) 4215 change = true; 4216 } 4217 4218 if (info->attrs[NL80211_ATTR_MESH_ID]) { 4219 struct wireless_dev *wdev = dev->ieee80211_ptr; 4220 4221 if (ntype != NL80211_IFTYPE_MESH_POINT) 4222 return -EINVAL; 4223 if (otype != NL80211_IFTYPE_MESH_POINT) 4224 return -EINVAL; 4225 if (netif_running(dev)) 4226 return -EBUSY; 4227 4228 wdev_lock(wdev); 4229 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != 4230 IEEE80211_MAX_MESH_ID_LEN); 4231 wdev->u.mesh.id_up_len = 4232 nla_len(info->attrs[NL80211_ATTR_MESH_ID]); 4233 memcpy(wdev->u.mesh.id, 4234 nla_data(info->attrs[NL80211_ATTR_MESH_ID]), 4235 wdev->u.mesh.id_up_len); 4236 wdev_unlock(wdev); 4237 } 4238 4239 if (info->attrs[NL80211_ATTR_4ADDR]) { 4240 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]); 4241 change = true; 4242 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype); 4243 if (err) 4244 return err; 4245 } else { 4246 params.use_4addr = -1; 4247 } 4248 4249 err = nl80211_parse_mon_options(rdev, ntype, info, ¶ms); 4250 if (err < 0) 4251 return err; 4252 if (err > 0) 4253 change = true; 4254 4255 if (change) 4256 err = cfg80211_change_iface(rdev, dev, ntype, ¶ms); 4257 else 4258 err = 0; 4259 4260 if (!err && params.use_4addr != -1) 4261 dev->ieee80211_ptr->use_4addr = params.use_4addr; 4262 4263 if (change && !err) { 4264 struct wireless_dev *wdev = dev->ieee80211_ptr; 4265 4266 nl80211_notify_iface(rdev, wdev, NL80211_CMD_SET_INTERFACE); 4267 } 4268 4269 return err; 4270 } 4271 4272 static int _nl80211_new_interface(struct sk_buff *skb, struct genl_info *info) 4273 { 4274 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4275 struct vif_params params; 4276 struct wireless_dev *wdev; 4277 struct sk_buff *msg; 4278 int err; 4279 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED; 4280 4281 memset(¶ms, 0, sizeof(params)); 4282 4283 if (!info->attrs[NL80211_ATTR_IFNAME]) 4284 return -EINVAL; 4285 4286 if (info->attrs[NL80211_ATTR_IFTYPE]) 4287 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]); 4288 4289 if (!rdev->ops->add_virtual_intf) 4290 return -EOPNOTSUPP; 4291 4292 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN || 4293 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) && 4294 info->attrs[NL80211_ATTR_MAC]) { 4295 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC], 4296 ETH_ALEN); 4297 if (!is_valid_ether_addr(params.macaddr)) 4298 return -EADDRNOTAVAIL; 4299 } 4300 4301 if (info->attrs[NL80211_ATTR_4ADDR]) { 4302 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]); 4303 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type); 4304 if (err) 4305 return err; 4306 } 4307 4308 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0)) 4309 return -EOPNOTSUPP; 4310 4311 err = nl80211_parse_mon_options(rdev, type, info, ¶ms); 4312 if (err < 0) 4313 return err; 4314 4315 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4316 if (!msg) 4317 return -ENOMEM; 4318 4319 wdev = rdev_add_virtual_intf(rdev, 4320 nla_data(info->attrs[NL80211_ATTR_IFNAME]), 4321 NET_NAME_USER, type, ¶ms); 4322 if (WARN_ON(!wdev)) { 4323 nlmsg_free(msg); 4324 return -EPROTO; 4325 } else if (IS_ERR(wdev)) { 4326 nlmsg_free(msg); 4327 return PTR_ERR(wdev); 4328 } 4329 4330 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) 4331 wdev->owner_nlportid = info->snd_portid; 4332 4333 switch (type) { 4334 case NL80211_IFTYPE_MESH_POINT: 4335 if (!info->attrs[NL80211_ATTR_MESH_ID]) 4336 break; 4337 wdev_lock(wdev); 4338 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN != 4339 IEEE80211_MAX_MESH_ID_LEN); 4340 wdev->u.mesh.id_up_len = 4341 nla_len(info->attrs[NL80211_ATTR_MESH_ID]); 4342 memcpy(wdev->u.mesh.id, 4343 nla_data(info->attrs[NL80211_ATTR_MESH_ID]), 4344 wdev->u.mesh.id_up_len); 4345 wdev_unlock(wdev); 4346 break; 4347 case NL80211_IFTYPE_NAN: 4348 case NL80211_IFTYPE_P2P_DEVICE: 4349 /* 4350 * P2P Device and NAN do not have a netdev, so don't go 4351 * through the netdev notifier and must be added here 4352 */ 4353 cfg80211_init_wdev(wdev); 4354 cfg80211_register_wdev(rdev, wdev); 4355 break; 4356 default: 4357 break; 4358 } 4359 4360 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0, 4361 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) { 4362 nlmsg_free(msg); 4363 return -ENOBUFS; 4364 } 4365 4366 return genlmsg_reply(msg, info); 4367 } 4368 4369 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info) 4370 { 4371 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4372 int ret; 4373 4374 /* to avoid failing a new interface creation due to pending removal */ 4375 cfg80211_destroy_ifaces(rdev); 4376 4377 wiphy_lock(&rdev->wiphy); 4378 ret = _nl80211_new_interface(skb, info); 4379 wiphy_unlock(&rdev->wiphy); 4380 4381 return ret; 4382 } 4383 4384 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info) 4385 { 4386 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4387 struct wireless_dev *wdev = info->user_ptr[1]; 4388 4389 if (!rdev->ops->del_virtual_intf) 4390 return -EOPNOTSUPP; 4391 4392 /* 4393 * We hold RTNL, so this is safe, without RTNL opencount cannot 4394 * reach 0, and thus the rdev cannot be deleted. 4395 * 4396 * We need to do it for the dev_close(), since that will call 4397 * the netdev notifiers, and we need to acquire the mutex there 4398 * but don't know if we get there from here or from some other 4399 * place (e.g. "ip link set ... down"). 4400 */ 4401 mutex_unlock(&rdev->wiphy.mtx); 4402 4403 /* 4404 * If we remove a wireless device without a netdev then clear 4405 * user_ptr[1] so that nl80211_post_doit won't dereference it 4406 * to check if it needs to do dev_put(). Otherwise it crashes 4407 * since the wdev has been freed, unlike with a netdev where 4408 * we need the dev_put() for the netdev to really be freed. 4409 */ 4410 if (!wdev->netdev) 4411 info->user_ptr[1] = NULL; 4412 else 4413 dev_close(wdev->netdev); 4414 4415 mutex_lock(&rdev->wiphy.mtx); 4416 4417 return cfg80211_remove_virtual_intf(rdev, wdev); 4418 } 4419 4420 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info) 4421 { 4422 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4423 struct net_device *dev = info->user_ptr[1]; 4424 u16 noack_map; 4425 4426 if (!info->attrs[NL80211_ATTR_NOACK_MAP]) 4427 return -EINVAL; 4428 4429 if (!rdev->ops->set_noack_map) 4430 return -EOPNOTSUPP; 4431 4432 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]); 4433 4434 return rdev_set_noack_map(rdev, dev, noack_map); 4435 } 4436 4437 static int nl80211_validate_key_link_id(struct genl_info *info, 4438 struct wireless_dev *wdev, 4439 int link_id, bool pairwise) 4440 { 4441 if (pairwise) { 4442 if (link_id != -1) { 4443 GENL_SET_ERR_MSG(info, 4444 "link ID not allowed for pairwise key"); 4445 return -EINVAL; 4446 } 4447 4448 return 0; 4449 } 4450 4451 if (wdev->valid_links) { 4452 if (link_id == -1) { 4453 GENL_SET_ERR_MSG(info, 4454 "link ID must for MLO group key"); 4455 return -EINVAL; 4456 } 4457 if (!(wdev->valid_links & BIT(link_id))) { 4458 GENL_SET_ERR_MSG(info, "invalid link ID for MLO group key"); 4459 return -EINVAL; 4460 } 4461 } else if (link_id != -1) { 4462 GENL_SET_ERR_MSG(info, "link ID not allowed for non-MLO group key"); 4463 return -EINVAL; 4464 } 4465 4466 return 0; 4467 } 4468 4469 struct get_key_cookie { 4470 struct sk_buff *msg; 4471 int error; 4472 int idx; 4473 }; 4474 4475 static void get_key_callback(void *c, struct key_params *params) 4476 { 4477 struct nlattr *key; 4478 struct get_key_cookie *cookie = c; 4479 4480 if ((params->seq && 4481 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ, 4482 params->seq_len, params->seq)) || 4483 (params->cipher && 4484 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER, 4485 params->cipher))) 4486 goto nla_put_failure; 4487 4488 key = nla_nest_start_noflag(cookie->msg, NL80211_ATTR_KEY); 4489 if (!key) 4490 goto nla_put_failure; 4491 4492 if ((params->seq && 4493 nla_put(cookie->msg, NL80211_KEY_SEQ, 4494 params->seq_len, params->seq)) || 4495 (params->cipher && 4496 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER, 4497 params->cipher))) 4498 goto nla_put_failure; 4499 4500 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx)) 4501 goto nla_put_failure; 4502 4503 nla_nest_end(cookie->msg, key); 4504 4505 return; 4506 nla_put_failure: 4507 cookie->error = 1; 4508 } 4509 4510 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info) 4511 { 4512 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4513 int err; 4514 struct net_device *dev = info->user_ptr[1]; 4515 u8 key_idx = 0; 4516 const u8 *mac_addr = NULL; 4517 bool pairwise; 4518 struct get_key_cookie cookie = { 4519 .error = 0, 4520 }; 4521 void *hdr; 4522 struct sk_buff *msg; 4523 bool bigtk_support = false; 4524 int link_id = nl80211_link_id_or_invalid(info->attrs); 4525 struct wireless_dev *wdev = dev->ieee80211_ptr; 4526 4527 if (wiphy_ext_feature_isset(&rdev->wiphy, 4528 NL80211_EXT_FEATURE_BEACON_PROTECTION)) 4529 bigtk_support = true; 4530 4531 if ((wdev->iftype == NL80211_IFTYPE_STATION || 4532 wdev->iftype == NL80211_IFTYPE_P2P_CLIENT) && 4533 wiphy_ext_feature_isset(&rdev->wiphy, 4534 NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT)) 4535 bigtk_support = true; 4536 4537 if (info->attrs[NL80211_ATTR_KEY_IDX]) { 4538 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]); 4539 4540 if (key_idx >= 6 && key_idx <= 7 && !bigtk_support) { 4541 GENL_SET_ERR_MSG(info, "BIGTK not supported"); 4542 return -EINVAL; 4543 } 4544 } 4545 4546 if (info->attrs[NL80211_ATTR_MAC]) 4547 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 4548 4549 pairwise = !!mac_addr; 4550 if (info->attrs[NL80211_ATTR_KEY_TYPE]) { 4551 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]); 4552 4553 if (kt != NL80211_KEYTYPE_GROUP && 4554 kt != NL80211_KEYTYPE_PAIRWISE) 4555 return -EINVAL; 4556 pairwise = kt == NL80211_KEYTYPE_PAIRWISE; 4557 } 4558 4559 if (!rdev->ops->get_key) 4560 return -EOPNOTSUPP; 4561 4562 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN)) 4563 return -ENOENT; 4564 4565 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 4566 if (!msg) 4567 return -ENOMEM; 4568 4569 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 4570 NL80211_CMD_NEW_KEY); 4571 if (!hdr) 4572 goto nla_put_failure; 4573 4574 cookie.msg = msg; 4575 cookie.idx = key_idx; 4576 4577 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 4578 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx)) 4579 goto nla_put_failure; 4580 if (mac_addr && 4581 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr)) 4582 goto nla_put_failure; 4583 4584 err = nl80211_validate_key_link_id(info, wdev, link_id, pairwise); 4585 if (err) 4586 goto free_msg; 4587 4588 err = rdev_get_key(rdev, dev, link_id, key_idx, pairwise, mac_addr, 4589 &cookie, get_key_callback); 4590 4591 if (err) 4592 goto free_msg; 4593 4594 if (cookie.error) 4595 goto nla_put_failure; 4596 4597 genlmsg_end(msg, hdr); 4598 return genlmsg_reply(msg, info); 4599 4600 nla_put_failure: 4601 err = -ENOBUFS; 4602 free_msg: 4603 nlmsg_free(msg); 4604 return err; 4605 } 4606 4607 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info) 4608 { 4609 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4610 struct key_parse key; 4611 int err; 4612 struct net_device *dev = info->user_ptr[1]; 4613 int link_id = nl80211_link_id_or_invalid(info->attrs); 4614 struct wireless_dev *wdev = dev->ieee80211_ptr; 4615 4616 err = nl80211_parse_key(info, &key); 4617 if (err) 4618 return err; 4619 4620 if (key.idx < 0) 4621 return -EINVAL; 4622 4623 /* Only support setting default key and 4624 * Extended Key ID action NL80211_KEY_SET_TX. 4625 */ 4626 if (!key.def && !key.defmgmt && !key.defbeacon && 4627 !(key.p.mode == NL80211_KEY_SET_TX)) 4628 return -EINVAL; 4629 4630 wdev_lock(wdev); 4631 4632 if (key.def) { 4633 if (!rdev->ops->set_default_key) { 4634 err = -EOPNOTSUPP; 4635 goto out; 4636 } 4637 4638 err = nl80211_key_allowed(wdev); 4639 if (err) 4640 goto out; 4641 4642 err = nl80211_validate_key_link_id(info, wdev, link_id, false); 4643 if (err) 4644 goto out; 4645 4646 err = rdev_set_default_key(rdev, dev, link_id, key.idx, 4647 key.def_uni, key.def_multi); 4648 4649 if (err) 4650 goto out; 4651 4652 #ifdef CONFIG_CFG80211_WEXT 4653 wdev->wext.default_key = key.idx; 4654 #endif 4655 } else if (key.defmgmt) { 4656 if (key.def_uni || !key.def_multi) { 4657 err = -EINVAL; 4658 goto out; 4659 } 4660 4661 if (!rdev->ops->set_default_mgmt_key) { 4662 err = -EOPNOTSUPP; 4663 goto out; 4664 } 4665 4666 err = nl80211_key_allowed(wdev); 4667 if (err) 4668 goto out; 4669 4670 err = nl80211_validate_key_link_id(info, wdev, link_id, false); 4671 if (err) 4672 goto out; 4673 4674 err = rdev_set_default_mgmt_key(rdev, dev, link_id, key.idx); 4675 if (err) 4676 goto out; 4677 4678 #ifdef CONFIG_CFG80211_WEXT 4679 wdev->wext.default_mgmt_key = key.idx; 4680 #endif 4681 } else if (key.defbeacon) { 4682 if (key.def_uni || !key.def_multi) { 4683 err = -EINVAL; 4684 goto out; 4685 } 4686 4687 if (!rdev->ops->set_default_beacon_key) { 4688 err = -EOPNOTSUPP; 4689 goto out; 4690 } 4691 4692 err = nl80211_key_allowed(wdev); 4693 if (err) 4694 goto out; 4695 4696 err = nl80211_validate_key_link_id(info, wdev, link_id, false); 4697 if (err) 4698 goto out; 4699 4700 err = rdev_set_default_beacon_key(rdev, dev, link_id, key.idx); 4701 if (err) 4702 goto out; 4703 } else if (key.p.mode == NL80211_KEY_SET_TX && 4704 wiphy_ext_feature_isset(&rdev->wiphy, 4705 NL80211_EXT_FEATURE_EXT_KEY_ID)) { 4706 u8 *mac_addr = NULL; 4707 4708 if (info->attrs[NL80211_ATTR_MAC]) 4709 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 4710 4711 if (!mac_addr || key.idx < 0 || key.idx > 1) { 4712 err = -EINVAL; 4713 goto out; 4714 } 4715 4716 err = nl80211_validate_key_link_id(info, wdev, link_id, true); 4717 if (err) 4718 goto out; 4719 4720 err = rdev_add_key(rdev, dev, link_id, key.idx, 4721 NL80211_KEYTYPE_PAIRWISE, 4722 mac_addr, &key.p); 4723 } else { 4724 err = -EINVAL; 4725 } 4726 out: 4727 wdev_unlock(wdev); 4728 4729 return err; 4730 } 4731 4732 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info) 4733 { 4734 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4735 int err; 4736 struct net_device *dev = info->user_ptr[1]; 4737 struct key_parse key; 4738 const u8 *mac_addr = NULL; 4739 int link_id = nl80211_link_id_or_invalid(info->attrs); 4740 struct wireless_dev *wdev = dev->ieee80211_ptr; 4741 4742 err = nl80211_parse_key(info, &key); 4743 if (err) 4744 return err; 4745 4746 if (!key.p.key) { 4747 GENL_SET_ERR_MSG(info, "no key"); 4748 return -EINVAL; 4749 } 4750 4751 if (info->attrs[NL80211_ATTR_MAC]) 4752 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 4753 4754 if (key.type == -1) { 4755 if (mac_addr) 4756 key.type = NL80211_KEYTYPE_PAIRWISE; 4757 else 4758 key.type = NL80211_KEYTYPE_GROUP; 4759 } 4760 4761 /* for now */ 4762 if (key.type != NL80211_KEYTYPE_PAIRWISE && 4763 key.type != NL80211_KEYTYPE_GROUP) { 4764 GENL_SET_ERR_MSG(info, "key type not pairwise or group"); 4765 return -EINVAL; 4766 } 4767 4768 if (key.type == NL80211_KEYTYPE_GROUP && 4769 info->attrs[NL80211_ATTR_VLAN_ID]) 4770 key.p.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]); 4771 4772 if (!rdev->ops->add_key) 4773 return -EOPNOTSUPP; 4774 4775 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx, 4776 key.type == NL80211_KEYTYPE_PAIRWISE, 4777 mac_addr)) { 4778 GENL_SET_ERR_MSG(info, "key setting validation failed"); 4779 return -EINVAL; 4780 } 4781 4782 wdev_lock(wdev); 4783 err = nl80211_key_allowed(wdev); 4784 if (err) 4785 GENL_SET_ERR_MSG(info, "key not allowed"); 4786 4787 if (!err) 4788 err = nl80211_validate_key_link_id(info, wdev, link_id, 4789 key.type == NL80211_KEYTYPE_PAIRWISE); 4790 4791 if (!err) { 4792 err = rdev_add_key(rdev, dev, link_id, key.idx, 4793 key.type == NL80211_KEYTYPE_PAIRWISE, 4794 mac_addr, &key.p); 4795 if (err) 4796 GENL_SET_ERR_MSG(info, "key addition failed"); 4797 } 4798 wdev_unlock(wdev); 4799 4800 return err; 4801 } 4802 4803 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info) 4804 { 4805 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4806 int err; 4807 struct net_device *dev = info->user_ptr[1]; 4808 u8 *mac_addr = NULL; 4809 struct key_parse key; 4810 int link_id = nl80211_link_id_or_invalid(info->attrs); 4811 struct wireless_dev *wdev = dev->ieee80211_ptr; 4812 4813 err = nl80211_parse_key(info, &key); 4814 if (err) 4815 return err; 4816 4817 if (info->attrs[NL80211_ATTR_MAC]) 4818 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 4819 4820 if (key.type == -1) { 4821 if (mac_addr) 4822 key.type = NL80211_KEYTYPE_PAIRWISE; 4823 else 4824 key.type = NL80211_KEYTYPE_GROUP; 4825 } 4826 4827 /* for now */ 4828 if (key.type != NL80211_KEYTYPE_PAIRWISE && 4829 key.type != NL80211_KEYTYPE_GROUP) 4830 return -EINVAL; 4831 4832 if (!cfg80211_valid_key_idx(rdev, key.idx, 4833 key.type == NL80211_KEYTYPE_PAIRWISE)) 4834 return -EINVAL; 4835 4836 if (!rdev->ops->del_key) 4837 return -EOPNOTSUPP; 4838 4839 wdev_lock(wdev); 4840 err = nl80211_key_allowed(wdev); 4841 4842 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr && 4843 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN)) 4844 err = -ENOENT; 4845 4846 if (!err) 4847 err = nl80211_validate_key_link_id(info, wdev, link_id, 4848 key.type == NL80211_KEYTYPE_PAIRWISE); 4849 4850 if (!err) 4851 err = rdev_del_key(rdev, dev, link_id, key.idx, 4852 key.type == NL80211_KEYTYPE_PAIRWISE, 4853 mac_addr); 4854 4855 #ifdef CONFIG_CFG80211_WEXT 4856 if (!err) { 4857 if (key.idx == wdev->wext.default_key) 4858 wdev->wext.default_key = -1; 4859 else if (key.idx == wdev->wext.default_mgmt_key) 4860 wdev->wext.default_mgmt_key = -1; 4861 } 4862 #endif 4863 wdev_unlock(wdev); 4864 4865 return err; 4866 } 4867 4868 /* This function returns an error or the number of nested attributes */ 4869 static int validate_acl_mac_addrs(struct nlattr *nl_attr) 4870 { 4871 struct nlattr *attr; 4872 int n_entries = 0, tmp; 4873 4874 nla_for_each_nested(attr, nl_attr, tmp) { 4875 if (nla_len(attr) != ETH_ALEN) 4876 return -EINVAL; 4877 4878 n_entries++; 4879 } 4880 4881 return n_entries; 4882 } 4883 4884 /* 4885 * This function parses ACL information and allocates memory for ACL data. 4886 * On successful return, the calling function is responsible to free the 4887 * ACL buffer returned by this function. 4888 */ 4889 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy, 4890 struct genl_info *info) 4891 { 4892 enum nl80211_acl_policy acl_policy; 4893 struct nlattr *attr; 4894 struct cfg80211_acl_data *acl; 4895 int i = 0, n_entries, tmp; 4896 4897 if (!wiphy->max_acl_mac_addrs) 4898 return ERR_PTR(-EOPNOTSUPP); 4899 4900 if (!info->attrs[NL80211_ATTR_ACL_POLICY]) 4901 return ERR_PTR(-EINVAL); 4902 4903 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]); 4904 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED && 4905 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED) 4906 return ERR_PTR(-EINVAL); 4907 4908 if (!info->attrs[NL80211_ATTR_MAC_ADDRS]) 4909 return ERR_PTR(-EINVAL); 4910 4911 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]); 4912 if (n_entries < 0) 4913 return ERR_PTR(n_entries); 4914 4915 if (n_entries > wiphy->max_acl_mac_addrs) 4916 return ERR_PTR(-ENOTSUPP); 4917 4918 acl = kzalloc(struct_size(acl, mac_addrs, n_entries), GFP_KERNEL); 4919 if (!acl) 4920 return ERR_PTR(-ENOMEM); 4921 acl->n_acl_entries = n_entries; 4922 4923 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) { 4924 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN); 4925 i++; 4926 } 4927 acl->acl_policy = acl_policy; 4928 4929 return acl; 4930 } 4931 4932 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info) 4933 { 4934 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 4935 struct net_device *dev = info->user_ptr[1]; 4936 struct cfg80211_acl_data *acl; 4937 int err; 4938 4939 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 4940 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 4941 return -EOPNOTSUPP; 4942 4943 if (!dev->ieee80211_ptr->links[0].ap.beacon_interval) 4944 return -EINVAL; 4945 4946 acl = parse_acl_data(&rdev->wiphy, info); 4947 if (IS_ERR(acl)) 4948 return PTR_ERR(acl); 4949 4950 err = rdev_set_mac_acl(rdev, dev, acl); 4951 4952 kfree(acl); 4953 4954 return err; 4955 } 4956 4957 static u32 rateset_to_mask(struct ieee80211_supported_band *sband, 4958 u8 *rates, u8 rates_len) 4959 { 4960 u8 i; 4961 u32 mask = 0; 4962 4963 for (i = 0; i < rates_len; i++) { 4964 int rate = (rates[i] & 0x7f) * 5; 4965 int ridx; 4966 4967 for (ridx = 0; ridx < sband->n_bitrates; ridx++) { 4968 struct ieee80211_rate *srate = 4969 &sband->bitrates[ridx]; 4970 if (rate == srate->bitrate) { 4971 mask |= 1 << ridx; 4972 break; 4973 } 4974 } 4975 if (ridx == sband->n_bitrates) 4976 return 0; /* rate not found */ 4977 } 4978 4979 return mask; 4980 } 4981 4982 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband, 4983 u8 *rates, u8 rates_len, 4984 u8 mcs[IEEE80211_HT_MCS_MASK_LEN]) 4985 { 4986 u8 i; 4987 4988 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN); 4989 4990 for (i = 0; i < rates_len; i++) { 4991 int ridx, rbit; 4992 4993 ridx = rates[i] / 8; 4994 rbit = BIT(rates[i] % 8); 4995 4996 /* check validity */ 4997 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN)) 4998 return false; 4999 5000 /* check availability */ 5001 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN); 5002 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit) 5003 mcs[ridx] |= rbit; 5004 else 5005 return false; 5006 } 5007 5008 return true; 5009 } 5010 5011 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map) 5012 { 5013 u16 mcs_mask = 0; 5014 5015 switch (vht_mcs_map) { 5016 case IEEE80211_VHT_MCS_NOT_SUPPORTED: 5017 break; 5018 case IEEE80211_VHT_MCS_SUPPORT_0_7: 5019 mcs_mask = 0x00FF; 5020 break; 5021 case IEEE80211_VHT_MCS_SUPPORT_0_8: 5022 mcs_mask = 0x01FF; 5023 break; 5024 case IEEE80211_VHT_MCS_SUPPORT_0_9: 5025 mcs_mask = 0x03FF; 5026 break; 5027 default: 5028 break; 5029 } 5030 5031 return mcs_mask; 5032 } 5033 5034 static void vht_build_mcs_mask(u16 vht_mcs_map, 5035 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX]) 5036 { 5037 u8 nss; 5038 5039 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) { 5040 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03); 5041 vht_mcs_map >>= 2; 5042 } 5043 } 5044 5045 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband, 5046 struct nl80211_txrate_vht *txrate, 5047 u16 mcs[NL80211_VHT_NSS_MAX]) 5048 { 5049 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 5050 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {}; 5051 u8 i; 5052 5053 if (!sband->vht_cap.vht_supported) 5054 return false; 5055 5056 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX); 5057 5058 /* Build vht_mcs_mask from VHT capabilities */ 5059 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask); 5060 5061 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 5062 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i]) 5063 mcs[i] = txrate->mcs[i]; 5064 else 5065 return false; 5066 } 5067 5068 return true; 5069 } 5070 5071 static u16 he_mcs_map_to_mcs_mask(u8 he_mcs_map) 5072 { 5073 switch (he_mcs_map) { 5074 case IEEE80211_HE_MCS_NOT_SUPPORTED: 5075 return 0; 5076 case IEEE80211_HE_MCS_SUPPORT_0_7: 5077 return 0x00FF; 5078 case IEEE80211_HE_MCS_SUPPORT_0_9: 5079 return 0x03FF; 5080 case IEEE80211_HE_MCS_SUPPORT_0_11: 5081 return 0xFFF; 5082 default: 5083 break; 5084 } 5085 return 0; 5086 } 5087 5088 static void he_build_mcs_mask(u16 he_mcs_map, 5089 u16 he_mcs_mask[NL80211_HE_NSS_MAX]) 5090 { 5091 u8 nss; 5092 5093 for (nss = 0; nss < NL80211_HE_NSS_MAX; nss++) { 5094 he_mcs_mask[nss] = he_mcs_map_to_mcs_mask(he_mcs_map & 0x03); 5095 he_mcs_map >>= 2; 5096 } 5097 } 5098 5099 static u16 he_get_txmcsmap(struct genl_info *info, unsigned int link_id, 5100 const struct ieee80211_sta_he_cap *he_cap) 5101 { 5102 struct net_device *dev = info->user_ptr[1]; 5103 struct wireless_dev *wdev = dev->ieee80211_ptr; 5104 struct cfg80211_chan_def *chandef; 5105 __le16 tx_mcs; 5106 5107 chandef = wdev_chandef(wdev, link_id); 5108 if (!chandef) { 5109 /* 5110 * This is probably broken, but we never maintained 5111 * a chandef in these cases, so it always was. 5112 */ 5113 return le16_to_cpu(he_cap->he_mcs_nss_supp.tx_mcs_80); 5114 } 5115 5116 switch (chandef->width) { 5117 case NL80211_CHAN_WIDTH_80P80: 5118 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80p80; 5119 break; 5120 case NL80211_CHAN_WIDTH_160: 5121 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_160; 5122 break; 5123 default: 5124 tx_mcs = he_cap->he_mcs_nss_supp.tx_mcs_80; 5125 break; 5126 } 5127 5128 return le16_to_cpu(tx_mcs); 5129 } 5130 5131 static bool he_set_mcs_mask(struct genl_info *info, 5132 struct wireless_dev *wdev, 5133 struct ieee80211_supported_band *sband, 5134 struct nl80211_txrate_he *txrate, 5135 u16 mcs[NL80211_HE_NSS_MAX], 5136 unsigned int link_id) 5137 { 5138 const struct ieee80211_sta_he_cap *he_cap; 5139 u16 tx_mcs_mask[NL80211_HE_NSS_MAX] = {}; 5140 u16 tx_mcs_map = 0; 5141 u8 i; 5142 5143 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype); 5144 if (!he_cap) 5145 return false; 5146 5147 memset(mcs, 0, sizeof(u16) * NL80211_HE_NSS_MAX); 5148 5149 tx_mcs_map = he_get_txmcsmap(info, link_id, he_cap); 5150 5151 /* Build he_mcs_mask from HE capabilities */ 5152 he_build_mcs_mask(tx_mcs_map, tx_mcs_mask); 5153 5154 for (i = 0; i < NL80211_HE_NSS_MAX; i++) { 5155 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i]) 5156 mcs[i] = txrate->mcs[i]; 5157 else 5158 return false; 5159 } 5160 5161 return true; 5162 } 5163 5164 static int nl80211_parse_tx_bitrate_mask(struct genl_info *info, 5165 struct nlattr *attrs[], 5166 enum nl80211_attrs attr, 5167 struct cfg80211_bitrate_mask *mask, 5168 struct net_device *dev, 5169 bool default_all_enabled, 5170 unsigned int link_id) 5171 { 5172 struct nlattr *tb[NL80211_TXRATE_MAX + 1]; 5173 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 5174 struct wireless_dev *wdev = dev->ieee80211_ptr; 5175 int rem, i; 5176 struct nlattr *tx_rates; 5177 struct ieee80211_supported_band *sband; 5178 u16 vht_tx_mcs_map, he_tx_mcs_map; 5179 5180 memset(mask, 0, sizeof(*mask)); 5181 /* Default to all rates enabled */ 5182 for (i = 0; i < NUM_NL80211_BANDS; i++) { 5183 const struct ieee80211_sta_he_cap *he_cap; 5184 5185 if (!default_all_enabled) 5186 break; 5187 5188 sband = rdev->wiphy.bands[i]; 5189 5190 if (!sband) 5191 continue; 5192 5193 mask->control[i].legacy = (1 << sband->n_bitrates) - 1; 5194 memcpy(mask->control[i].ht_mcs, 5195 sband->ht_cap.mcs.rx_mask, 5196 sizeof(mask->control[i].ht_mcs)); 5197 5198 if (sband->vht_cap.vht_supported) { 5199 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map); 5200 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs); 5201 } 5202 5203 he_cap = ieee80211_get_he_iftype_cap(sband, wdev->iftype); 5204 if (!he_cap) 5205 continue; 5206 5207 he_tx_mcs_map = he_get_txmcsmap(info, link_id, he_cap); 5208 he_build_mcs_mask(he_tx_mcs_map, mask->control[i].he_mcs); 5209 5210 mask->control[i].he_gi = 0xFF; 5211 mask->control[i].he_ltf = 0xFF; 5212 } 5213 5214 /* if no rates are given set it back to the defaults */ 5215 if (!attrs[attr]) 5216 goto out; 5217 5218 /* The nested attribute uses enum nl80211_band as the index. This maps 5219 * directly to the enum nl80211_band values used in cfg80211. 5220 */ 5221 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8); 5222 nla_for_each_nested(tx_rates, attrs[attr], rem) { 5223 enum nl80211_band band = nla_type(tx_rates); 5224 int err; 5225 5226 if (band < 0 || band >= NUM_NL80211_BANDS) 5227 return -EINVAL; 5228 sband = rdev->wiphy.bands[band]; 5229 if (sband == NULL) 5230 return -EINVAL; 5231 err = nla_parse_nested_deprecated(tb, NL80211_TXRATE_MAX, 5232 tx_rates, 5233 nl80211_txattr_policy, 5234 info->extack); 5235 if (err) 5236 return err; 5237 if (tb[NL80211_TXRATE_LEGACY]) { 5238 mask->control[band].legacy = rateset_to_mask( 5239 sband, 5240 nla_data(tb[NL80211_TXRATE_LEGACY]), 5241 nla_len(tb[NL80211_TXRATE_LEGACY])); 5242 if ((mask->control[band].legacy == 0) && 5243 nla_len(tb[NL80211_TXRATE_LEGACY])) 5244 return -EINVAL; 5245 } 5246 if (tb[NL80211_TXRATE_HT]) { 5247 if (!ht_rateset_to_mask( 5248 sband, 5249 nla_data(tb[NL80211_TXRATE_HT]), 5250 nla_len(tb[NL80211_TXRATE_HT]), 5251 mask->control[band].ht_mcs)) 5252 return -EINVAL; 5253 } 5254 5255 if (tb[NL80211_TXRATE_VHT]) { 5256 if (!vht_set_mcs_mask( 5257 sband, 5258 nla_data(tb[NL80211_TXRATE_VHT]), 5259 mask->control[band].vht_mcs)) 5260 return -EINVAL; 5261 } 5262 5263 if (tb[NL80211_TXRATE_GI]) { 5264 mask->control[band].gi = 5265 nla_get_u8(tb[NL80211_TXRATE_GI]); 5266 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI) 5267 return -EINVAL; 5268 } 5269 if (tb[NL80211_TXRATE_HE] && 5270 !he_set_mcs_mask(info, wdev, sband, 5271 nla_data(tb[NL80211_TXRATE_HE]), 5272 mask->control[band].he_mcs, 5273 link_id)) 5274 return -EINVAL; 5275 5276 if (tb[NL80211_TXRATE_HE_GI]) 5277 mask->control[band].he_gi = 5278 nla_get_u8(tb[NL80211_TXRATE_HE_GI]); 5279 if (tb[NL80211_TXRATE_HE_LTF]) 5280 mask->control[band].he_ltf = 5281 nla_get_u8(tb[NL80211_TXRATE_HE_LTF]); 5282 5283 if (mask->control[band].legacy == 0) { 5284 /* don't allow empty legacy rates if HT, VHT or HE 5285 * are not even supported. 5286 */ 5287 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported || 5288 rdev->wiphy.bands[band]->vht_cap.vht_supported || 5289 ieee80211_get_he_iftype_cap(sband, wdev->iftype))) 5290 return -EINVAL; 5291 5292 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) 5293 if (mask->control[band].ht_mcs[i]) 5294 goto out; 5295 5296 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) 5297 if (mask->control[band].vht_mcs[i]) 5298 goto out; 5299 5300 for (i = 0; i < NL80211_HE_NSS_MAX; i++) 5301 if (mask->control[band].he_mcs[i]) 5302 goto out; 5303 5304 /* legacy and mcs rates may not be both empty */ 5305 return -EINVAL; 5306 } 5307 } 5308 5309 out: 5310 return 0; 5311 } 5312 5313 static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev, 5314 enum nl80211_band band, 5315 struct cfg80211_bitrate_mask *beacon_rate) 5316 { 5317 u32 count_ht, count_vht, count_he, i; 5318 u32 rate = beacon_rate->control[band].legacy; 5319 5320 /* Allow only one rate */ 5321 if (hweight32(rate) > 1) 5322 return -EINVAL; 5323 5324 count_ht = 0; 5325 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) { 5326 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) { 5327 return -EINVAL; 5328 } else if (beacon_rate->control[band].ht_mcs[i]) { 5329 count_ht++; 5330 if (count_ht > 1) 5331 return -EINVAL; 5332 } 5333 if (count_ht && rate) 5334 return -EINVAL; 5335 } 5336 5337 count_vht = 0; 5338 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) { 5339 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) { 5340 return -EINVAL; 5341 } else if (beacon_rate->control[band].vht_mcs[i]) { 5342 count_vht++; 5343 if (count_vht > 1) 5344 return -EINVAL; 5345 } 5346 if (count_vht && rate) 5347 return -EINVAL; 5348 } 5349 5350 count_he = 0; 5351 for (i = 0; i < NL80211_HE_NSS_MAX; i++) { 5352 if (hweight16(beacon_rate->control[band].he_mcs[i]) > 1) { 5353 return -EINVAL; 5354 } else if (beacon_rate->control[band].he_mcs[i]) { 5355 count_he++; 5356 if (count_he > 1) 5357 return -EINVAL; 5358 } 5359 if (count_he && rate) 5360 return -EINVAL; 5361 } 5362 5363 if ((count_ht && count_vht && count_he) || 5364 (!rate && !count_ht && !count_vht && !count_he)) 5365 return -EINVAL; 5366 5367 if (rate && 5368 !wiphy_ext_feature_isset(&rdev->wiphy, 5369 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY)) 5370 return -EINVAL; 5371 if (count_ht && 5372 !wiphy_ext_feature_isset(&rdev->wiphy, 5373 NL80211_EXT_FEATURE_BEACON_RATE_HT)) 5374 return -EINVAL; 5375 if (count_vht && 5376 !wiphy_ext_feature_isset(&rdev->wiphy, 5377 NL80211_EXT_FEATURE_BEACON_RATE_VHT)) 5378 return -EINVAL; 5379 if (count_he && 5380 !wiphy_ext_feature_isset(&rdev->wiphy, 5381 NL80211_EXT_FEATURE_BEACON_RATE_HE)) 5382 return -EINVAL; 5383 5384 return 0; 5385 } 5386 5387 static int nl80211_parse_mbssid_config(struct wiphy *wiphy, 5388 struct net_device *dev, 5389 struct nlattr *attrs, 5390 struct cfg80211_mbssid_config *config, 5391 u8 num_elems) 5392 { 5393 struct nlattr *tb[NL80211_MBSSID_CONFIG_ATTR_MAX + 1]; 5394 5395 if (!wiphy->mbssid_max_interfaces) 5396 return -EOPNOTSUPP; 5397 5398 if (nla_parse_nested(tb, NL80211_MBSSID_CONFIG_ATTR_MAX, attrs, NULL, 5399 NULL) || 5400 !tb[NL80211_MBSSID_CONFIG_ATTR_INDEX]) 5401 return -EINVAL; 5402 5403 config->ema = nla_get_flag(tb[NL80211_MBSSID_CONFIG_ATTR_EMA]); 5404 if (config->ema) { 5405 if (!wiphy->ema_max_profile_periodicity) 5406 return -EOPNOTSUPP; 5407 5408 if (num_elems > wiphy->ema_max_profile_periodicity) 5409 return -EINVAL; 5410 } 5411 5412 config->index = nla_get_u8(tb[NL80211_MBSSID_CONFIG_ATTR_INDEX]); 5413 if (config->index >= wiphy->mbssid_max_interfaces || 5414 (!config->index && !num_elems)) 5415 return -EINVAL; 5416 5417 if (tb[NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX]) { 5418 u32 tx_ifindex = 5419 nla_get_u32(tb[NL80211_MBSSID_CONFIG_ATTR_TX_IFINDEX]); 5420 5421 if ((!config->index && tx_ifindex != dev->ifindex) || 5422 (config->index && tx_ifindex == dev->ifindex)) 5423 return -EINVAL; 5424 5425 if (tx_ifindex != dev->ifindex) { 5426 struct net_device *tx_netdev = 5427 dev_get_by_index(wiphy_net(wiphy), tx_ifindex); 5428 5429 if (!tx_netdev || !tx_netdev->ieee80211_ptr || 5430 tx_netdev->ieee80211_ptr->wiphy != wiphy || 5431 tx_netdev->ieee80211_ptr->iftype != 5432 NL80211_IFTYPE_AP) { 5433 dev_put(tx_netdev); 5434 return -EINVAL; 5435 } 5436 5437 config->tx_wdev = tx_netdev->ieee80211_ptr; 5438 } else { 5439 config->tx_wdev = dev->ieee80211_ptr; 5440 } 5441 } else if (!config->index) { 5442 config->tx_wdev = dev->ieee80211_ptr; 5443 } else { 5444 return -EINVAL; 5445 } 5446 5447 return 0; 5448 } 5449 5450 static struct cfg80211_mbssid_elems * 5451 nl80211_parse_mbssid_elems(struct wiphy *wiphy, struct nlattr *attrs) 5452 { 5453 struct nlattr *nl_elems; 5454 struct cfg80211_mbssid_elems *elems; 5455 int rem_elems; 5456 u8 i = 0, num_elems = 0; 5457 5458 if (!wiphy->mbssid_max_interfaces) 5459 return ERR_PTR(-EINVAL); 5460 5461 nla_for_each_nested(nl_elems, attrs, rem_elems) { 5462 if (num_elems >= 255) 5463 return ERR_PTR(-EINVAL); 5464 num_elems++; 5465 } 5466 5467 elems = kzalloc(struct_size(elems, elem, num_elems), GFP_KERNEL); 5468 if (!elems) 5469 return ERR_PTR(-ENOMEM); 5470 elems->cnt = num_elems; 5471 5472 nla_for_each_nested(nl_elems, attrs, rem_elems) { 5473 elems->elem[i].data = nla_data(nl_elems); 5474 elems->elem[i].len = nla_len(nl_elems); 5475 i++; 5476 } 5477 return elems; 5478 } 5479 5480 static struct cfg80211_rnr_elems * 5481 nl80211_parse_rnr_elems(struct wiphy *wiphy, struct nlattr *attrs, 5482 struct netlink_ext_ack *extack) 5483 { 5484 struct nlattr *nl_elems; 5485 struct cfg80211_rnr_elems *elems; 5486 int rem_elems; 5487 u8 i = 0, num_elems = 0; 5488 5489 nla_for_each_nested(nl_elems, attrs, rem_elems) { 5490 int ret; 5491 5492 ret = validate_ie_attr(nl_elems, extack); 5493 if (ret) 5494 return ERR_PTR(ret); 5495 5496 num_elems++; 5497 } 5498 5499 elems = kzalloc(struct_size(elems, elem, num_elems), GFP_KERNEL); 5500 if (!elems) 5501 return ERR_PTR(-ENOMEM); 5502 elems->cnt = num_elems; 5503 5504 nla_for_each_nested(nl_elems, attrs, rem_elems) { 5505 elems->elem[i].data = nla_data(nl_elems); 5506 elems->elem[i].len = nla_len(nl_elems); 5507 i++; 5508 } 5509 return elems; 5510 } 5511 5512 static int nl80211_parse_he_bss_color(struct nlattr *attrs, 5513 struct cfg80211_he_bss_color *he_bss_color) 5514 { 5515 struct nlattr *tb[NL80211_HE_BSS_COLOR_ATTR_MAX + 1]; 5516 int err; 5517 5518 err = nla_parse_nested(tb, NL80211_HE_BSS_COLOR_ATTR_MAX, attrs, 5519 he_bss_color_policy, NULL); 5520 if (err) 5521 return err; 5522 5523 if (!tb[NL80211_HE_BSS_COLOR_ATTR_COLOR]) 5524 return -EINVAL; 5525 5526 he_bss_color->color = 5527 nla_get_u8(tb[NL80211_HE_BSS_COLOR_ATTR_COLOR]); 5528 he_bss_color->enabled = 5529 !nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_DISABLED]); 5530 he_bss_color->partial = 5531 nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_PARTIAL]); 5532 5533 return 0; 5534 } 5535 5536 static int nl80211_parse_beacon(struct cfg80211_registered_device *rdev, 5537 struct nlattr *attrs[], 5538 struct cfg80211_beacon_data *bcn, 5539 struct netlink_ext_ack *extack) 5540 { 5541 bool haveinfo = false; 5542 int err; 5543 5544 memset(bcn, 0, sizeof(*bcn)); 5545 5546 bcn->link_id = nl80211_link_id(attrs); 5547 5548 if (attrs[NL80211_ATTR_BEACON_HEAD]) { 5549 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]); 5550 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]); 5551 if (!bcn->head_len) 5552 return -EINVAL; 5553 haveinfo = true; 5554 } 5555 5556 if (attrs[NL80211_ATTR_BEACON_TAIL]) { 5557 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]); 5558 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]); 5559 haveinfo = true; 5560 } 5561 5562 if (!haveinfo) 5563 return -EINVAL; 5564 5565 if (attrs[NL80211_ATTR_IE]) { 5566 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]); 5567 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]); 5568 } 5569 5570 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) { 5571 bcn->proberesp_ies = 5572 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]); 5573 bcn->proberesp_ies_len = 5574 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]); 5575 } 5576 5577 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) { 5578 bcn->assocresp_ies = 5579 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]); 5580 bcn->assocresp_ies_len = 5581 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]); 5582 } 5583 5584 if (attrs[NL80211_ATTR_PROBE_RESP]) { 5585 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]); 5586 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]); 5587 } 5588 5589 if (attrs[NL80211_ATTR_FTM_RESPONDER]) { 5590 struct nlattr *tb[NL80211_FTM_RESP_ATTR_MAX + 1]; 5591 5592 err = nla_parse_nested_deprecated(tb, 5593 NL80211_FTM_RESP_ATTR_MAX, 5594 attrs[NL80211_ATTR_FTM_RESPONDER], 5595 NULL, NULL); 5596 if (err) 5597 return err; 5598 5599 if (tb[NL80211_FTM_RESP_ATTR_ENABLED] && 5600 wiphy_ext_feature_isset(&rdev->wiphy, 5601 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER)) 5602 bcn->ftm_responder = 1; 5603 else 5604 return -EOPNOTSUPP; 5605 5606 if (tb[NL80211_FTM_RESP_ATTR_LCI]) { 5607 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]); 5608 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]); 5609 } 5610 5611 if (tb[NL80211_FTM_RESP_ATTR_CIVICLOC]) { 5612 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]); 5613 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]); 5614 } 5615 } else { 5616 bcn->ftm_responder = -1; 5617 } 5618 5619 if (attrs[NL80211_ATTR_HE_BSS_COLOR]) { 5620 err = nl80211_parse_he_bss_color(attrs[NL80211_ATTR_HE_BSS_COLOR], 5621 &bcn->he_bss_color); 5622 if (err) 5623 return err; 5624 bcn->he_bss_color_valid = true; 5625 } 5626 5627 if (attrs[NL80211_ATTR_MBSSID_ELEMS]) { 5628 struct cfg80211_mbssid_elems *mbssid = 5629 nl80211_parse_mbssid_elems(&rdev->wiphy, 5630 attrs[NL80211_ATTR_MBSSID_ELEMS]); 5631 5632 if (IS_ERR(mbssid)) 5633 return PTR_ERR(mbssid); 5634 5635 bcn->mbssid_ies = mbssid; 5636 5637 if (bcn->mbssid_ies && attrs[NL80211_ATTR_EMA_RNR_ELEMS]) { 5638 struct cfg80211_rnr_elems *rnr = 5639 nl80211_parse_rnr_elems(&rdev->wiphy, 5640 attrs[NL80211_ATTR_EMA_RNR_ELEMS], 5641 extack); 5642 5643 if (IS_ERR(rnr)) 5644 return PTR_ERR(rnr); 5645 5646 if (rnr && rnr->cnt < bcn->mbssid_ies->cnt) 5647 return -EINVAL; 5648 5649 bcn->rnr_ies = rnr; 5650 } 5651 } 5652 5653 return 0; 5654 } 5655 5656 static int nl80211_parse_he_obss_pd(struct nlattr *attrs, 5657 struct ieee80211_he_obss_pd *he_obss_pd) 5658 { 5659 struct nlattr *tb[NL80211_HE_OBSS_PD_ATTR_MAX + 1]; 5660 int err; 5661 5662 err = nla_parse_nested(tb, NL80211_HE_OBSS_PD_ATTR_MAX, attrs, 5663 he_obss_pd_policy, NULL); 5664 if (err) 5665 return err; 5666 5667 if (!tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL]) 5668 return -EINVAL; 5669 5670 he_obss_pd->sr_ctrl = nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_SR_CTRL]); 5671 5672 if (tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET]) 5673 he_obss_pd->min_offset = 5674 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET]); 5675 if (tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET]) 5676 he_obss_pd->max_offset = 5677 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET]); 5678 if (tb[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET]) 5679 he_obss_pd->non_srg_max_offset = 5680 nla_get_u8(tb[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET]); 5681 5682 if (he_obss_pd->min_offset > he_obss_pd->max_offset) 5683 return -EINVAL; 5684 5685 if (tb[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP]) 5686 memcpy(he_obss_pd->bss_color_bitmap, 5687 nla_data(tb[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP]), 5688 sizeof(he_obss_pd->bss_color_bitmap)); 5689 5690 if (tb[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP]) 5691 memcpy(he_obss_pd->partial_bssid_bitmap, 5692 nla_data(tb[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP]), 5693 sizeof(he_obss_pd->partial_bssid_bitmap)); 5694 5695 he_obss_pd->enable = true; 5696 5697 return 0; 5698 } 5699 5700 static int nl80211_parse_fils_discovery(struct cfg80211_registered_device *rdev, 5701 struct nlattr *attrs, 5702 struct cfg80211_ap_settings *params) 5703 { 5704 struct nlattr *tb[NL80211_FILS_DISCOVERY_ATTR_MAX + 1]; 5705 int ret; 5706 struct cfg80211_fils_discovery *fd = ¶ms->fils_discovery; 5707 5708 if (!wiphy_ext_feature_isset(&rdev->wiphy, 5709 NL80211_EXT_FEATURE_FILS_DISCOVERY)) 5710 return -EINVAL; 5711 5712 ret = nla_parse_nested(tb, NL80211_FILS_DISCOVERY_ATTR_MAX, attrs, 5713 NULL, NULL); 5714 if (ret) 5715 return ret; 5716 5717 if (!tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN] || 5718 !tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX] || 5719 !tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]) 5720 return -EINVAL; 5721 5722 fd->tmpl_len = nla_len(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]); 5723 fd->tmpl = nla_data(tb[NL80211_FILS_DISCOVERY_ATTR_TMPL]); 5724 fd->min_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MIN]); 5725 fd->max_interval = nla_get_u32(tb[NL80211_FILS_DISCOVERY_ATTR_INT_MAX]); 5726 5727 return 0; 5728 } 5729 5730 static int 5731 nl80211_parse_unsol_bcast_probe_resp(struct cfg80211_registered_device *rdev, 5732 struct nlattr *attrs, 5733 struct cfg80211_ap_settings *params) 5734 { 5735 struct nlattr *tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX + 1]; 5736 int ret; 5737 struct cfg80211_unsol_bcast_probe_resp *presp = 5738 ¶ms->unsol_bcast_probe_resp; 5739 5740 if (!wiphy_ext_feature_isset(&rdev->wiphy, 5741 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP)) 5742 return -EINVAL; 5743 5744 ret = nla_parse_nested(tb, NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX, 5745 attrs, NULL, NULL); 5746 if (ret) 5747 return ret; 5748 5749 if (!tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT] || 5750 !tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]) 5751 return -EINVAL; 5752 5753 presp->tmpl = nla_data(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]); 5754 presp->tmpl_len = nla_len(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL]); 5755 presp->interval = nla_get_u32(tb[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT]); 5756 return 0; 5757 } 5758 5759 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params, 5760 const struct element *rates) 5761 { 5762 int i; 5763 5764 if (!rates) 5765 return; 5766 5767 for (i = 0; i < rates->datalen; i++) { 5768 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY) 5769 params->ht_required = true; 5770 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY) 5771 params->vht_required = true; 5772 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_HE_PHY) 5773 params->he_required = true; 5774 if (rates->data[i] == BSS_MEMBERSHIP_SELECTOR_SAE_H2E) 5775 params->sae_h2e_required = true; 5776 } 5777 } 5778 5779 /* 5780 * Since the nl80211 API didn't include, from the beginning, attributes about 5781 * HT/VHT requirements/capabilities, we parse them out of the IEs for the 5782 * benefit of drivers that rebuild IEs in the firmware. 5783 */ 5784 static int nl80211_calculate_ap_params(struct cfg80211_ap_settings *params) 5785 { 5786 const struct cfg80211_beacon_data *bcn = ¶ms->beacon; 5787 size_t ies_len = bcn->tail_len; 5788 const u8 *ies = bcn->tail; 5789 const struct element *rates; 5790 const struct element *cap; 5791 5792 rates = cfg80211_find_elem(WLAN_EID_SUPP_RATES, ies, ies_len); 5793 nl80211_check_ap_rate_selectors(params, rates); 5794 5795 rates = cfg80211_find_elem(WLAN_EID_EXT_SUPP_RATES, ies, ies_len); 5796 nl80211_check_ap_rate_selectors(params, rates); 5797 5798 cap = cfg80211_find_elem(WLAN_EID_HT_CAPABILITY, ies, ies_len); 5799 if (cap && cap->datalen >= sizeof(*params->ht_cap)) 5800 params->ht_cap = (void *)cap->data; 5801 cap = cfg80211_find_elem(WLAN_EID_VHT_CAPABILITY, ies, ies_len); 5802 if (cap && cap->datalen >= sizeof(*params->vht_cap)) 5803 params->vht_cap = (void *)cap->data; 5804 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_HE_CAPABILITY, ies, ies_len); 5805 if (cap && cap->datalen >= sizeof(*params->he_cap) + 1) 5806 params->he_cap = (void *)(cap->data + 1); 5807 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_HE_OPERATION, ies, ies_len); 5808 if (cap && cap->datalen >= sizeof(*params->he_oper) + 1) 5809 params->he_oper = (void *)(cap->data + 1); 5810 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_EHT_CAPABILITY, ies, ies_len); 5811 if (cap) { 5812 if (!cap->datalen) 5813 return -EINVAL; 5814 params->eht_cap = (void *)(cap->data + 1); 5815 if (!ieee80211_eht_capa_size_ok((const u8 *)params->he_cap, 5816 (const u8 *)params->eht_cap, 5817 cap->datalen - 1, true)) 5818 return -EINVAL; 5819 } 5820 cap = cfg80211_find_ext_elem(WLAN_EID_EXT_EHT_OPERATION, ies, ies_len); 5821 if (cap) { 5822 if (!cap->datalen) 5823 return -EINVAL; 5824 params->eht_oper = (void *)(cap->data + 1); 5825 if (!ieee80211_eht_oper_size_ok((const u8 *)params->eht_oper, 5826 cap->datalen - 1)) 5827 return -EINVAL; 5828 } 5829 return 0; 5830 } 5831 5832 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev, 5833 struct cfg80211_ap_settings *params) 5834 { 5835 struct wireless_dev *wdev; 5836 5837 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) { 5838 if (wdev->iftype != NL80211_IFTYPE_AP && 5839 wdev->iftype != NL80211_IFTYPE_P2P_GO) 5840 continue; 5841 5842 if (!wdev->u.ap.preset_chandef.chan) 5843 continue; 5844 5845 params->chandef = wdev->u.ap.preset_chandef; 5846 return true; 5847 } 5848 5849 return false; 5850 } 5851 5852 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev, 5853 enum nl80211_auth_type auth_type, 5854 enum nl80211_commands cmd) 5855 { 5856 if (auth_type > NL80211_AUTHTYPE_MAX) 5857 return false; 5858 5859 switch (cmd) { 5860 case NL80211_CMD_AUTHENTICATE: 5861 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) && 5862 auth_type == NL80211_AUTHTYPE_SAE) 5863 return false; 5864 if (!wiphy_ext_feature_isset(&rdev->wiphy, 5865 NL80211_EXT_FEATURE_FILS_STA) && 5866 (auth_type == NL80211_AUTHTYPE_FILS_SK || 5867 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS || 5868 auth_type == NL80211_AUTHTYPE_FILS_PK)) 5869 return false; 5870 return true; 5871 case NL80211_CMD_CONNECT: 5872 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) && 5873 !wiphy_ext_feature_isset(&rdev->wiphy, 5874 NL80211_EXT_FEATURE_SAE_OFFLOAD) && 5875 auth_type == NL80211_AUTHTYPE_SAE) 5876 return false; 5877 5878 /* FILS with SK PFS or PK not supported yet */ 5879 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS || 5880 auth_type == NL80211_AUTHTYPE_FILS_PK) 5881 return false; 5882 if (!wiphy_ext_feature_isset( 5883 &rdev->wiphy, 5884 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) && 5885 auth_type == NL80211_AUTHTYPE_FILS_SK) 5886 return false; 5887 return true; 5888 case NL80211_CMD_START_AP: 5889 if (!wiphy_ext_feature_isset(&rdev->wiphy, 5890 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP) && 5891 auth_type == NL80211_AUTHTYPE_SAE) 5892 return false; 5893 /* FILS not supported yet */ 5894 if (auth_type == NL80211_AUTHTYPE_FILS_SK || 5895 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS || 5896 auth_type == NL80211_AUTHTYPE_FILS_PK) 5897 return false; 5898 return true; 5899 default: 5900 return false; 5901 } 5902 } 5903 5904 static void nl80211_send_ap_started(struct wireless_dev *wdev, 5905 unsigned int link_id) 5906 { 5907 struct wiphy *wiphy = wdev->wiphy; 5908 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 5909 struct sk_buff *msg; 5910 void *hdr; 5911 5912 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 5913 if (!msg) 5914 return; 5915 5916 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_START_AP); 5917 if (!hdr) 5918 goto out; 5919 5920 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 5921 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) || 5922 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 5923 NL80211_ATTR_PAD) || 5924 (wdev->u.ap.ssid_len && 5925 nla_put(msg, NL80211_ATTR_SSID, wdev->u.ap.ssid_len, 5926 wdev->u.ap.ssid)) || 5927 (wdev->valid_links && 5928 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id))) 5929 goto out; 5930 5931 genlmsg_end(msg, hdr); 5932 5933 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0, 5934 NL80211_MCGRP_MLME, GFP_KERNEL); 5935 return; 5936 out: 5937 nlmsg_free(msg); 5938 } 5939 5940 static int nl80211_validate_ap_phy_operation(struct cfg80211_ap_settings *params) 5941 { 5942 struct ieee80211_channel *channel = params->chandef.chan; 5943 5944 if ((params->he_cap || params->he_oper) && 5945 (channel->flags & IEEE80211_CHAN_NO_HE)) 5946 return -EOPNOTSUPP; 5947 5948 if ((params->eht_cap || params->eht_oper) && 5949 (channel->flags & IEEE80211_CHAN_NO_EHT)) 5950 return -EOPNOTSUPP; 5951 5952 return 0; 5953 } 5954 5955 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info) 5956 { 5957 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 5958 unsigned int link_id = nl80211_link_id(info->attrs); 5959 struct net_device *dev = info->user_ptr[1]; 5960 struct wireless_dev *wdev = dev->ieee80211_ptr; 5961 struct cfg80211_ap_settings *params; 5962 int err; 5963 5964 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 5965 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 5966 return -EOPNOTSUPP; 5967 5968 if (!rdev->ops->start_ap) 5969 return -EOPNOTSUPP; 5970 5971 if (wdev->links[link_id].ap.beacon_interval) 5972 return -EALREADY; 5973 5974 /* these are required for START_AP */ 5975 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] || 5976 !info->attrs[NL80211_ATTR_DTIM_PERIOD] || 5977 !info->attrs[NL80211_ATTR_BEACON_HEAD]) 5978 return -EINVAL; 5979 5980 params = kzalloc(sizeof(*params), GFP_KERNEL); 5981 if (!params) 5982 return -ENOMEM; 5983 5984 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms->beacon, 5985 info->extack); 5986 if (err) 5987 goto out; 5988 5989 params->beacon_interval = 5990 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]); 5991 params->dtim_period = 5992 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]); 5993 5994 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype, 5995 params->beacon_interval); 5996 if (err) 5997 goto out; 5998 5999 /* 6000 * In theory, some of these attributes should be required here 6001 * but since they were not used when the command was originally 6002 * added, keep them optional for old user space programs to let 6003 * them continue to work with drivers that do not need the 6004 * additional information -- drivers must check! 6005 */ 6006 if (info->attrs[NL80211_ATTR_SSID]) { 6007 params->ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 6008 params->ssid_len = 6009 nla_len(info->attrs[NL80211_ATTR_SSID]); 6010 if (params->ssid_len == 0) { 6011 err = -EINVAL; 6012 goto out; 6013 } 6014 6015 if (wdev->u.ap.ssid_len && 6016 (wdev->u.ap.ssid_len != params->ssid_len || 6017 memcmp(wdev->u.ap.ssid, params->ssid, params->ssid_len))) { 6018 /* require identical SSID for MLO */ 6019 err = -EINVAL; 6020 goto out; 6021 } 6022 } else if (wdev->valid_links) { 6023 /* require SSID for MLO */ 6024 err = -EINVAL; 6025 goto out; 6026 } 6027 6028 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) 6029 params->hidden_ssid = nla_get_u32( 6030 info->attrs[NL80211_ATTR_HIDDEN_SSID]); 6031 6032 params->privacy = !!info->attrs[NL80211_ATTR_PRIVACY]; 6033 6034 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) { 6035 params->auth_type = nla_get_u32( 6036 info->attrs[NL80211_ATTR_AUTH_TYPE]); 6037 if (!nl80211_valid_auth_type(rdev, params->auth_type, 6038 NL80211_CMD_START_AP)) { 6039 err = -EINVAL; 6040 goto out; 6041 } 6042 } else 6043 params->auth_type = NL80211_AUTHTYPE_AUTOMATIC; 6044 6045 err = nl80211_crypto_settings(rdev, info, ¶ms->crypto, 6046 NL80211_MAX_NR_CIPHER_SUITES); 6047 if (err) 6048 goto out; 6049 6050 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) { 6051 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER)) { 6052 err = -EOPNOTSUPP; 6053 goto out; 6054 } 6055 params->inactivity_timeout = nla_get_u16( 6056 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]); 6057 } 6058 6059 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) { 6060 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) { 6061 err = -EINVAL; 6062 goto out; 6063 } 6064 params->p2p_ctwindow = 6065 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]); 6066 if (params->p2p_ctwindow != 0 && 6067 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN)) { 6068 err = -EINVAL; 6069 goto out; 6070 } 6071 } 6072 6073 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) { 6074 u8 tmp; 6075 6076 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) { 6077 err = -EINVAL; 6078 goto out; 6079 } 6080 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]); 6081 params->p2p_opp_ps = tmp; 6082 if (params->p2p_opp_ps != 0 && 6083 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS)) { 6084 err = -EINVAL; 6085 goto out; 6086 } 6087 } 6088 6089 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) { 6090 err = nl80211_parse_chandef(rdev, info, ¶ms->chandef); 6091 if (err) 6092 goto out; 6093 } else if (wdev->valid_links) { 6094 /* with MLD need to specify the channel configuration */ 6095 err = -EINVAL; 6096 goto out; 6097 } else if (wdev->u.ap.preset_chandef.chan) { 6098 params->chandef = wdev->u.ap.preset_chandef; 6099 } else if (!nl80211_get_ap_channel(rdev, params)) { 6100 err = -EINVAL; 6101 goto out; 6102 } 6103 6104 if (info->attrs[NL80211_ATTR_PUNCT_BITMAP]) { 6105 err = nl80211_parse_punct_bitmap(rdev, info, 6106 ¶ms->chandef, 6107 ¶ms->punct_bitmap); 6108 if (err) 6109 goto out; 6110 } 6111 6112 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms->chandef, 6113 wdev->iftype)) { 6114 err = -EINVAL; 6115 goto out; 6116 } 6117 6118 wdev_lock(wdev); 6119 6120 if (info->attrs[NL80211_ATTR_TX_RATES]) { 6121 err = nl80211_parse_tx_bitrate_mask(info, info->attrs, 6122 NL80211_ATTR_TX_RATES, 6123 ¶ms->beacon_rate, 6124 dev, false, link_id); 6125 if (err) 6126 goto out_unlock; 6127 6128 err = validate_beacon_tx_rate(rdev, params->chandef.chan->band, 6129 ¶ms->beacon_rate); 6130 if (err) 6131 goto out_unlock; 6132 } 6133 6134 if (info->attrs[NL80211_ATTR_SMPS_MODE]) { 6135 params->smps_mode = 6136 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]); 6137 switch (params->smps_mode) { 6138 case NL80211_SMPS_OFF: 6139 break; 6140 case NL80211_SMPS_STATIC: 6141 if (!(rdev->wiphy.features & 6142 NL80211_FEATURE_STATIC_SMPS)) { 6143 err = -EINVAL; 6144 goto out_unlock; 6145 } 6146 break; 6147 case NL80211_SMPS_DYNAMIC: 6148 if (!(rdev->wiphy.features & 6149 NL80211_FEATURE_DYNAMIC_SMPS)) { 6150 err = -EINVAL; 6151 goto out_unlock; 6152 } 6153 break; 6154 default: 6155 err = -EINVAL; 6156 goto out_unlock; 6157 } 6158 } else { 6159 params->smps_mode = NL80211_SMPS_OFF; 6160 } 6161 6162 params->pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]); 6163 if (params->pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) { 6164 err = -EOPNOTSUPP; 6165 goto out_unlock; 6166 } 6167 6168 if (info->attrs[NL80211_ATTR_ACL_POLICY]) { 6169 params->acl = parse_acl_data(&rdev->wiphy, info); 6170 if (IS_ERR(params->acl)) { 6171 err = PTR_ERR(params->acl); 6172 params->acl = NULL; 6173 goto out_unlock; 6174 } 6175 } 6176 6177 params->twt_responder = 6178 nla_get_flag(info->attrs[NL80211_ATTR_TWT_RESPONDER]); 6179 6180 if (info->attrs[NL80211_ATTR_HE_OBSS_PD]) { 6181 err = nl80211_parse_he_obss_pd( 6182 info->attrs[NL80211_ATTR_HE_OBSS_PD], 6183 ¶ms->he_obss_pd); 6184 if (err) 6185 goto out_unlock; 6186 } 6187 6188 if (info->attrs[NL80211_ATTR_FILS_DISCOVERY]) { 6189 err = nl80211_parse_fils_discovery(rdev, 6190 info->attrs[NL80211_ATTR_FILS_DISCOVERY], 6191 params); 6192 if (err) 6193 goto out_unlock; 6194 } 6195 6196 if (info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP]) { 6197 err = nl80211_parse_unsol_bcast_probe_resp( 6198 rdev, info->attrs[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP], 6199 params); 6200 if (err) 6201 goto out_unlock; 6202 } 6203 6204 if (info->attrs[NL80211_ATTR_MBSSID_CONFIG]) { 6205 err = nl80211_parse_mbssid_config(&rdev->wiphy, dev, 6206 info->attrs[NL80211_ATTR_MBSSID_CONFIG], 6207 ¶ms->mbssid_config, 6208 params->beacon.mbssid_ies ? 6209 params->beacon.mbssid_ies->cnt : 6210 0); 6211 if (err) 6212 goto out_unlock; 6213 } 6214 6215 if (!params->mbssid_config.ema && params->beacon.rnr_ies) { 6216 err = -EINVAL; 6217 goto out_unlock; 6218 } 6219 6220 err = nl80211_calculate_ap_params(params); 6221 if (err) 6222 goto out_unlock; 6223 6224 err = nl80211_validate_ap_phy_operation(params); 6225 if (err) 6226 goto out_unlock; 6227 6228 if (info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS]) 6229 params->flags = nla_get_u32( 6230 info->attrs[NL80211_ATTR_AP_SETTINGS_FLAGS]); 6231 else if (info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT]) 6232 params->flags |= NL80211_AP_SETTINGS_EXTERNAL_AUTH_SUPPORT; 6233 6234 if (wdev->conn_owner_nlportid && 6235 info->attrs[NL80211_ATTR_SOCKET_OWNER] && 6236 wdev->conn_owner_nlportid != info->snd_portid) { 6237 err = -EINVAL; 6238 goto out_unlock; 6239 } 6240 6241 /* FIXME: validate MLO/link-id against driver capabilities */ 6242 6243 err = rdev_start_ap(rdev, dev, params); 6244 if (!err) { 6245 wdev->links[link_id].ap.beacon_interval = params->beacon_interval; 6246 wdev->links[link_id].ap.chandef = params->chandef; 6247 wdev->u.ap.ssid_len = params->ssid_len; 6248 memcpy(wdev->u.ap.ssid, params->ssid, 6249 params->ssid_len); 6250 6251 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) 6252 wdev->conn_owner_nlportid = info->snd_portid; 6253 6254 nl80211_send_ap_started(wdev, link_id); 6255 } 6256 out_unlock: 6257 wdev_unlock(wdev); 6258 out: 6259 kfree(params->acl); 6260 kfree(params->beacon.mbssid_ies); 6261 if (params->mbssid_config.tx_wdev && 6262 params->mbssid_config.tx_wdev->netdev && 6263 params->mbssid_config.tx_wdev->netdev != dev) 6264 dev_put(params->mbssid_config.tx_wdev->netdev); 6265 kfree(params->beacon.rnr_ies); 6266 kfree(params); 6267 6268 return err; 6269 } 6270 6271 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info) 6272 { 6273 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 6274 unsigned int link_id = nl80211_link_id(info->attrs); 6275 struct net_device *dev = info->user_ptr[1]; 6276 struct wireless_dev *wdev = dev->ieee80211_ptr; 6277 struct cfg80211_beacon_data params; 6278 int err; 6279 6280 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 6281 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 6282 return -EOPNOTSUPP; 6283 6284 if (!rdev->ops->change_beacon) 6285 return -EOPNOTSUPP; 6286 6287 if (!wdev->links[link_id].ap.beacon_interval) 6288 return -EINVAL; 6289 6290 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms, info->extack); 6291 if (err) 6292 goto out; 6293 6294 wdev_lock(wdev); 6295 err = rdev_change_beacon(rdev, dev, ¶ms); 6296 wdev_unlock(wdev); 6297 6298 out: 6299 kfree(params.mbssid_ies); 6300 kfree(params.rnr_ies); 6301 return err; 6302 } 6303 6304 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info) 6305 { 6306 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 6307 unsigned int link_id = nl80211_link_id(info->attrs); 6308 struct net_device *dev = info->user_ptr[1]; 6309 6310 return cfg80211_stop_ap(rdev, dev, link_id, false); 6311 } 6312 6313 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = { 6314 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG }, 6315 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG }, 6316 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG }, 6317 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG }, 6318 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG }, 6319 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG }, 6320 }; 6321 6322 static int parse_station_flags(struct genl_info *info, 6323 enum nl80211_iftype iftype, 6324 struct station_parameters *params) 6325 { 6326 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1]; 6327 struct nlattr *nla; 6328 int flag; 6329 6330 /* 6331 * Try parsing the new attribute first so userspace 6332 * can specify both for older kernels. 6333 */ 6334 nla = info->attrs[NL80211_ATTR_STA_FLAGS2]; 6335 if (nla) { 6336 struct nl80211_sta_flag_update *sta_flags; 6337 6338 sta_flags = nla_data(nla); 6339 params->sta_flags_mask = sta_flags->mask; 6340 params->sta_flags_set = sta_flags->set; 6341 params->sta_flags_set &= params->sta_flags_mask; 6342 if ((params->sta_flags_mask | 6343 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID)) 6344 return -EINVAL; 6345 return 0; 6346 } 6347 6348 /* if present, parse the old attribute */ 6349 6350 nla = info->attrs[NL80211_ATTR_STA_FLAGS]; 6351 if (!nla) 6352 return 0; 6353 6354 if (nla_parse_nested_deprecated(flags, NL80211_STA_FLAG_MAX, nla, sta_flags_policy, info->extack)) 6355 return -EINVAL; 6356 6357 /* 6358 * Only allow certain flags for interface types so that 6359 * other attributes are silently ignored. Remember that 6360 * this is backward compatibility code with old userspace 6361 * and shouldn't be hit in other cases anyway. 6362 */ 6363 switch (iftype) { 6364 case NL80211_IFTYPE_AP: 6365 case NL80211_IFTYPE_AP_VLAN: 6366 case NL80211_IFTYPE_P2P_GO: 6367 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) | 6368 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) | 6369 BIT(NL80211_STA_FLAG_WME) | 6370 BIT(NL80211_STA_FLAG_MFP); 6371 break; 6372 case NL80211_IFTYPE_P2P_CLIENT: 6373 case NL80211_IFTYPE_STATION: 6374 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) | 6375 BIT(NL80211_STA_FLAG_TDLS_PEER); 6376 break; 6377 case NL80211_IFTYPE_MESH_POINT: 6378 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) | 6379 BIT(NL80211_STA_FLAG_MFP) | 6380 BIT(NL80211_STA_FLAG_AUTHORIZED); 6381 break; 6382 default: 6383 return -EINVAL; 6384 } 6385 6386 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) { 6387 if (flags[flag]) { 6388 params->sta_flags_set |= (1<<flag); 6389 6390 /* no longer support new API additions in old API */ 6391 if (flag > NL80211_STA_FLAG_MAX_OLD_API) 6392 return -EINVAL; 6393 } 6394 } 6395 6396 return 0; 6397 } 6398 6399 bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info, int attr) 6400 { 6401 struct nlattr *rate; 6402 u32 bitrate; 6403 u16 bitrate_compat; 6404 enum nl80211_rate_info rate_flg; 6405 6406 rate = nla_nest_start_noflag(msg, attr); 6407 if (!rate) 6408 return false; 6409 6410 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */ 6411 bitrate = cfg80211_calculate_bitrate(info); 6412 /* report 16-bit bitrate only if we can */ 6413 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0; 6414 if (bitrate > 0 && 6415 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate)) 6416 return false; 6417 if (bitrate_compat > 0 && 6418 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat)) 6419 return false; 6420 6421 switch (info->bw) { 6422 case RATE_INFO_BW_1: 6423 rate_flg = NL80211_RATE_INFO_1_MHZ_WIDTH; 6424 break; 6425 case RATE_INFO_BW_2: 6426 rate_flg = NL80211_RATE_INFO_2_MHZ_WIDTH; 6427 break; 6428 case RATE_INFO_BW_4: 6429 rate_flg = NL80211_RATE_INFO_4_MHZ_WIDTH; 6430 break; 6431 case RATE_INFO_BW_5: 6432 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH; 6433 break; 6434 case RATE_INFO_BW_8: 6435 rate_flg = NL80211_RATE_INFO_8_MHZ_WIDTH; 6436 break; 6437 case RATE_INFO_BW_10: 6438 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH; 6439 break; 6440 case RATE_INFO_BW_16: 6441 rate_flg = NL80211_RATE_INFO_16_MHZ_WIDTH; 6442 break; 6443 default: 6444 WARN_ON(1); 6445 fallthrough; 6446 case RATE_INFO_BW_20: 6447 rate_flg = 0; 6448 break; 6449 case RATE_INFO_BW_40: 6450 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH; 6451 break; 6452 case RATE_INFO_BW_80: 6453 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH; 6454 break; 6455 case RATE_INFO_BW_160: 6456 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH; 6457 break; 6458 case RATE_INFO_BW_HE_RU: 6459 rate_flg = 0; 6460 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS)); 6461 break; 6462 case RATE_INFO_BW_320: 6463 rate_flg = NL80211_RATE_INFO_320_MHZ_WIDTH; 6464 break; 6465 case RATE_INFO_BW_EHT_RU: 6466 rate_flg = 0; 6467 WARN_ON(!(info->flags & RATE_INFO_FLAGS_EHT_MCS)); 6468 break; 6469 } 6470 6471 if (rate_flg && nla_put_flag(msg, rate_flg)) 6472 return false; 6473 6474 if (info->flags & RATE_INFO_FLAGS_MCS) { 6475 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs)) 6476 return false; 6477 if (info->flags & RATE_INFO_FLAGS_SHORT_GI && 6478 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI)) 6479 return false; 6480 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) { 6481 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs)) 6482 return false; 6483 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss)) 6484 return false; 6485 if (info->flags & RATE_INFO_FLAGS_SHORT_GI && 6486 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI)) 6487 return false; 6488 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) { 6489 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs)) 6490 return false; 6491 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss)) 6492 return false; 6493 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi)) 6494 return false; 6495 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm)) 6496 return false; 6497 if (info->bw == RATE_INFO_BW_HE_RU && 6498 nla_put_u8(msg, NL80211_RATE_INFO_HE_RU_ALLOC, 6499 info->he_ru_alloc)) 6500 return false; 6501 } else if (info->flags & RATE_INFO_FLAGS_S1G_MCS) { 6502 if (nla_put_u8(msg, NL80211_RATE_INFO_S1G_MCS, info->mcs)) 6503 return false; 6504 if (nla_put_u8(msg, NL80211_RATE_INFO_S1G_NSS, info->nss)) 6505 return false; 6506 if (info->flags & RATE_INFO_FLAGS_SHORT_GI && 6507 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI)) 6508 return false; 6509 } else if (info->flags & RATE_INFO_FLAGS_EHT_MCS) { 6510 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_MCS, info->mcs)) 6511 return false; 6512 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_NSS, info->nss)) 6513 return false; 6514 if (nla_put_u8(msg, NL80211_RATE_INFO_EHT_GI, info->eht_gi)) 6515 return false; 6516 if (info->bw == RATE_INFO_BW_EHT_RU && 6517 nla_put_u8(msg, NL80211_RATE_INFO_EHT_RU_ALLOC, 6518 info->eht_ru_alloc)) 6519 return false; 6520 } 6521 6522 nla_nest_end(msg, rate); 6523 return true; 6524 } 6525 6526 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal, 6527 int id) 6528 { 6529 void *attr; 6530 int i = 0; 6531 6532 if (!mask) 6533 return true; 6534 6535 attr = nla_nest_start_noflag(msg, id); 6536 if (!attr) 6537 return false; 6538 6539 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) { 6540 if (!(mask & BIT(i))) 6541 continue; 6542 6543 if (nla_put_u8(msg, i, signal[i])) 6544 return false; 6545 } 6546 6547 nla_nest_end(msg, attr); 6548 6549 return true; 6550 } 6551 6552 static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid, 6553 u32 seq, int flags, 6554 struct cfg80211_registered_device *rdev, 6555 struct net_device *dev, 6556 const u8 *mac_addr, struct station_info *sinfo) 6557 { 6558 void *hdr; 6559 struct nlattr *sinfoattr, *bss_param; 6560 6561 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd); 6562 if (!hdr) { 6563 cfg80211_sinfo_release_content(sinfo); 6564 return -1; 6565 } 6566 6567 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 6568 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) || 6569 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation)) 6570 goto nla_put_failure; 6571 6572 sinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_STA_INFO); 6573 if (!sinfoattr) 6574 goto nla_put_failure; 6575 6576 #define PUT_SINFO(attr, memb, type) do { \ 6577 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \ 6578 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \ 6579 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \ 6580 sinfo->memb)) \ 6581 goto nla_put_failure; \ 6582 } while (0) 6583 #define PUT_SINFO_U64(attr, memb) do { \ 6584 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \ 6585 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \ 6586 sinfo->memb, NL80211_STA_INFO_PAD)) \ 6587 goto nla_put_failure; \ 6588 } while (0) 6589 6590 PUT_SINFO(CONNECTED_TIME, connected_time, u32); 6591 PUT_SINFO(INACTIVE_TIME, inactive_time, u32); 6592 PUT_SINFO_U64(ASSOC_AT_BOOTTIME, assoc_at); 6593 6594 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) | 6595 BIT_ULL(NL80211_STA_INFO_RX_BYTES64)) && 6596 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES, 6597 (u32)sinfo->rx_bytes)) 6598 goto nla_put_failure; 6599 6600 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) | 6601 BIT_ULL(NL80211_STA_INFO_TX_BYTES64)) && 6602 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES, 6603 (u32)sinfo->tx_bytes)) 6604 goto nla_put_failure; 6605 6606 PUT_SINFO_U64(RX_BYTES64, rx_bytes); 6607 PUT_SINFO_U64(TX_BYTES64, tx_bytes); 6608 PUT_SINFO(LLID, llid, u16); 6609 PUT_SINFO(PLID, plid, u16); 6610 PUT_SINFO(PLINK_STATE, plink_state, u8); 6611 PUT_SINFO_U64(RX_DURATION, rx_duration); 6612 PUT_SINFO_U64(TX_DURATION, tx_duration); 6613 6614 if (wiphy_ext_feature_isset(&rdev->wiphy, 6615 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS)) 6616 PUT_SINFO(AIRTIME_WEIGHT, airtime_weight, u16); 6617 6618 switch (rdev->wiphy.signal_type) { 6619 case CFG80211_SIGNAL_TYPE_MBM: 6620 PUT_SINFO(SIGNAL, signal, u8); 6621 PUT_SINFO(SIGNAL_AVG, signal_avg, u8); 6622 break; 6623 default: 6624 break; 6625 } 6626 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) { 6627 if (!nl80211_put_signal(msg, sinfo->chains, 6628 sinfo->chain_signal, 6629 NL80211_STA_INFO_CHAIN_SIGNAL)) 6630 goto nla_put_failure; 6631 } 6632 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) { 6633 if (!nl80211_put_signal(msg, sinfo->chains, 6634 sinfo->chain_signal_avg, 6635 NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) 6636 goto nla_put_failure; 6637 } 6638 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) { 6639 if (!nl80211_put_sta_rate(msg, &sinfo->txrate, 6640 NL80211_STA_INFO_TX_BITRATE)) 6641 goto nla_put_failure; 6642 } 6643 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) { 6644 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate, 6645 NL80211_STA_INFO_RX_BITRATE)) 6646 goto nla_put_failure; 6647 } 6648 6649 PUT_SINFO(RX_PACKETS, rx_packets, u32); 6650 PUT_SINFO(TX_PACKETS, tx_packets, u32); 6651 PUT_SINFO(TX_RETRIES, tx_retries, u32); 6652 PUT_SINFO(TX_FAILED, tx_failed, u32); 6653 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32); 6654 PUT_SINFO(AIRTIME_LINK_METRIC, airtime_link_metric, u32); 6655 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32); 6656 PUT_SINFO(LOCAL_PM, local_pm, u32); 6657 PUT_SINFO(PEER_PM, peer_pm, u32); 6658 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32); 6659 PUT_SINFO(CONNECTED_TO_GATE, connected_to_gate, u8); 6660 PUT_SINFO(CONNECTED_TO_AS, connected_to_as, u8); 6661 6662 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) { 6663 bss_param = nla_nest_start_noflag(msg, 6664 NL80211_STA_INFO_BSS_PARAM); 6665 if (!bss_param) 6666 goto nla_put_failure; 6667 6668 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) && 6669 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) || 6670 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) && 6671 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) || 6672 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) && 6673 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) || 6674 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD, 6675 sinfo->bss_param.dtim_period) || 6676 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL, 6677 sinfo->bss_param.beacon_interval)) 6678 goto nla_put_failure; 6679 6680 nla_nest_end(msg, bss_param); 6681 } 6682 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) && 6683 nla_put(msg, NL80211_STA_INFO_STA_FLAGS, 6684 sizeof(struct nl80211_sta_flag_update), 6685 &sinfo->sta_flags)) 6686 goto nla_put_failure; 6687 6688 PUT_SINFO_U64(T_OFFSET, t_offset); 6689 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc); 6690 PUT_SINFO_U64(BEACON_RX, rx_beacon); 6691 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8); 6692 PUT_SINFO(RX_MPDUS, rx_mpdu_count, u32); 6693 PUT_SINFO(FCS_ERROR_COUNT, fcs_err_count, u32); 6694 if (wiphy_ext_feature_isset(&rdev->wiphy, 6695 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT)) { 6696 PUT_SINFO(ACK_SIGNAL, ack_signal, u8); 6697 PUT_SINFO(ACK_SIGNAL_AVG, avg_ack_signal, s8); 6698 } 6699 6700 #undef PUT_SINFO 6701 #undef PUT_SINFO_U64 6702 6703 if (sinfo->pertid) { 6704 struct nlattr *tidsattr; 6705 int tid; 6706 6707 tidsattr = nla_nest_start_noflag(msg, 6708 NL80211_STA_INFO_TID_STATS); 6709 if (!tidsattr) 6710 goto nla_put_failure; 6711 6712 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) { 6713 struct cfg80211_tid_stats *tidstats; 6714 struct nlattr *tidattr; 6715 6716 tidstats = &sinfo->pertid[tid]; 6717 6718 if (!tidstats->filled) 6719 continue; 6720 6721 tidattr = nla_nest_start_noflag(msg, tid + 1); 6722 if (!tidattr) 6723 goto nla_put_failure; 6724 6725 #define PUT_TIDVAL_U64(attr, memb) do { \ 6726 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \ 6727 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \ 6728 tidstats->memb, NL80211_TID_STATS_PAD)) \ 6729 goto nla_put_failure; \ 6730 } while (0) 6731 6732 PUT_TIDVAL_U64(RX_MSDU, rx_msdu); 6733 PUT_TIDVAL_U64(TX_MSDU, tx_msdu); 6734 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries); 6735 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed); 6736 6737 #undef PUT_TIDVAL_U64 6738 if ((tidstats->filled & 6739 BIT(NL80211_TID_STATS_TXQ_STATS)) && 6740 !nl80211_put_txq_stats(msg, &tidstats->txq_stats, 6741 NL80211_TID_STATS_TXQ_STATS)) 6742 goto nla_put_failure; 6743 6744 nla_nest_end(msg, tidattr); 6745 } 6746 6747 nla_nest_end(msg, tidsattr); 6748 } 6749 6750 nla_nest_end(msg, sinfoattr); 6751 6752 if (sinfo->assoc_req_ies_len && 6753 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len, 6754 sinfo->assoc_req_ies)) 6755 goto nla_put_failure; 6756 6757 if (sinfo->assoc_resp_ies_len && 6758 nla_put(msg, NL80211_ATTR_RESP_IE, sinfo->assoc_resp_ies_len, 6759 sinfo->assoc_resp_ies)) 6760 goto nla_put_failure; 6761 6762 if (sinfo->mlo_params_valid) { 6763 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, 6764 sinfo->assoc_link_id)) 6765 goto nla_put_failure; 6766 6767 if (!is_zero_ether_addr(sinfo->mld_addr) && 6768 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN, 6769 sinfo->mld_addr)) 6770 goto nla_put_failure; 6771 } 6772 6773 cfg80211_sinfo_release_content(sinfo); 6774 genlmsg_end(msg, hdr); 6775 return 0; 6776 6777 nla_put_failure: 6778 cfg80211_sinfo_release_content(sinfo); 6779 genlmsg_cancel(msg, hdr); 6780 return -EMSGSIZE; 6781 } 6782 6783 static int nl80211_dump_station(struct sk_buff *skb, 6784 struct netlink_callback *cb) 6785 { 6786 struct station_info sinfo; 6787 struct cfg80211_registered_device *rdev; 6788 struct wireless_dev *wdev; 6789 u8 mac_addr[ETH_ALEN]; 6790 int sta_idx = cb->args[2]; 6791 int err; 6792 6793 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL); 6794 if (err) 6795 return err; 6796 /* nl80211_prepare_wdev_dump acquired it in the successful case */ 6797 __acquire(&rdev->wiphy.mtx); 6798 6799 if (!wdev->netdev) { 6800 err = -EINVAL; 6801 goto out_err; 6802 } 6803 6804 if (!rdev->ops->dump_station) { 6805 err = -EOPNOTSUPP; 6806 goto out_err; 6807 } 6808 6809 while (1) { 6810 memset(&sinfo, 0, sizeof(sinfo)); 6811 err = rdev_dump_station(rdev, wdev->netdev, sta_idx, 6812 mac_addr, &sinfo); 6813 if (err == -ENOENT) 6814 break; 6815 if (err) 6816 goto out_err; 6817 6818 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION, 6819 NETLINK_CB(cb->skb).portid, 6820 cb->nlh->nlmsg_seq, NLM_F_MULTI, 6821 rdev, wdev->netdev, mac_addr, 6822 &sinfo) < 0) 6823 goto out; 6824 6825 sta_idx++; 6826 } 6827 6828 out: 6829 cb->args[2] = sta_idx; 6830 err = skb->len; 6831 out_err: 6832 wiphy_unlock(&rdev->wiphy); 6833 6834 return err; 6835 } 6836 6837 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info) 6838 { 6839 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 6840 struct net_device *dev = info->user_ptr[1]; 6841 struct station_info sinfo; 6842 struct sk_buff *msg; 6843 u8 *mac_addr = NULL; 6844 int err; 6845 6846 memset(&sinfo, 0, sizeof(sinfo)); 6847 6848 if (!info->attrs[NL80211_ATTR_MAC]) 6849 return -EINVAL; 6850 6851 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 6852 6853 if (!rdev->ops->get_station) 6854 return -EOPNOTSUPP; 6855 6856 err = rdev_get_station(rdev, dev, mac_addr, &sinfo); 6857 if (err) 6858 return err; 6859 6860 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 6861 if (!msg) { 6862 cfg80211_sinfo_release_content(&sinfo); 6863 return -ENOMEM; 6864 } 6865 6866 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 6867 info->snd_portid, info->snd_seq, 0, 6868 rdev, dev, mac_addr, &sinfo) < 0) { 6869 nlmsg_free(msg); 6870 return -ENOBUFS; 6871 } 6872 6873 return genlmsg_reply(msg, info); 6874 } 6875 6876 int cfg80211_check_station_change(struct wiphy *wiphy, 6877 struct station_parameters *params, 6878 enum cfg80211_station_type statype) 6879 { 6880 if (params->listen_interval != -1 && 6881 statype != CFG80211_STA_AP_CLIENT_UNASSOC) 6882 return -EINVAL; 6883 6884 if (params->support_p2p_ps != -1 && 6885 statype != CFG80211_STA_AP_CLIENT_UNASSOC) 6886 return -EINVAL; 6887 6888 if (params->aid && 6889 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) && 6890 statype != CFG80211_STA_AP_CLIENT_UNASSOC) 6891 return -EINVAL; 6892 6893 /* When you run into this, adjust the code below for the new flag */ 6894 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7); 6895 6896 switch (statype) { 6897 case CFG80211_STA_MESH_PEER_KERNEL: 6898 case CFG80211_STA_MESH_PEER_USER: 6899 /* 6900 * No ignoring the TDLS flag here -- the userspace mesh 6901 * code doesn't have the bug of including TDLS in the 6902 * mask everywhere. 6903 */ 6904 if (params->sta_flags_mask & 6905 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) | 6906 BIT(NL80211_STA_FLAG_MFP) | 6907 BIT(NL80211_STA_FLAG_AUTHORIZED))) 6908 return -EINVAL; 6909 break; 6910 case CFG80211_STA_TDLS_PEER_SETUP: 6911 case CFG80211_STA_TDLS_PEER_ACTIVE: 6912 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))) 6913 return -EINVAL; 6914 /* ignore since it can't change */ 6915 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER); 6916 break; 6917 default: 6918 /* disallow mesh-specific things */ 6919 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION) 6920 return -EINVAL; 6921 if (params->local_pm) 6922 return -EINVAL; 6923 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) 6924 return -EINVAL; 6925 } 6926 6927 if (statype != CFG80211_STA_TDLS_PEER_SETUP && 6928 statype != CFG80211_STA_TDLS_PEER_ACTIVE) { 6929 /* TDLS can't be set, ... */ 6930 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) 6931 return -EINVAL; 6932 /* 6933 * ... but don't bother the driver with it. This works around 6934 * a hostapd/wpa_supplicant issue -- it always includes the 6935 * TLDS_PEER flag in the mask even for AP mode. 6936 */ 6937 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER); 6938 } 6939 6940 if (statype != CFG80211_STA_TDLS_PEER_SETUP && 6941 statype != CFG80211_STA_AP_CLIENT_UNASSOC) { 6942 /* reject other things that can't change */ 6943 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD) 6944 return -EINVAL; 6945 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY) 6946 return -EINVAL; 6947 if (params->link_sta_params.supported_rates) 6948 return -EINVAL; 6949 if (params->ext_capab || params->link_sta_params.ht_capa || 6950 params->link_sta_params.vht_capa || 6951 params->link_sta_params.he_capa || 6952 params->link_sta_params.eht_capa) 6953 return -EINVAL; 6954 } 6955 6956 if (statype != CFG80211_STA_AP_CLIENT && 6957 statype != CFG80211_STA_AP_CLIENT_UNASSOC) { 6958 if (params->vlan) 6959 return -EINVAL; 6960 } 6961 6962 switch (statype) { 6963 case CFG80211_STA_AP_MLME_CLIENT: 6964 /* Use this only for authorizing/unauthorizing a station */ 6965 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED))) 6966 return -EOPNOTSUPP; 6967 break; 6968 case CFG80211_STA_AP_CLIENT: 6969 case CFG80211_STA_AP_CLIENT_UNASSOC: 6970 /* accept only the listed bits */ 6971 if (params->sta_flags_mask & 6972 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) | 6973 BIT(NL80211_STA_FLAG_AUTHENTICATED) | 6974 BIT(NL80211_STA_FLAG_ASSOCIATED) | 6975 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) | 6976 BIT(NL80211_STA_FLAG_WME) | 6977 BIT(NL80211_STA_FLAG_MFP))) 6978 return -EINVAL; 6979 6980 /* but authenticated/associated only if driver handles it */ 6981 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) && 6982 params->sta_flags_mask & 6983 (BIT(NL80211_STA_FLAG_AUTHENTICATED) | 6984 BIT(NL80211_STA_FLAG_ASSOCIATED))) 6985 return -EINVAL; 6986 break; 6987 case CFG80211_STA_IBSS: 6988 case CFG80211_STA_AP_STA: 6989 /* reject any changes other than AUTHORIZED */ 6990 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED)) 6991 return -EINVAL; 6992 break; 6993 case CFG80211_STA_TDLS_PEER_SETUP: 6994 /* reject any changes other than AUTHORIZED or WME */ 6995 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) | 6996 BIT(NL80211_STA_FLAG_WME))) 6997 return -EINVAL; 6998 /* force (at least) rates when authorizing */ 6999 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) && 7000 !params->link_sta_params.supported_rates) 7001 return -EINVAL; 7002 break; 7003 case CFG80211_STA_TDLS_PEER_ACTIVE: 7004 /* reject any changes */ 7005 return -EINVAL; 7006 case CFG80211_STA_MESH_PEER_KERNEL: 7007 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE) 7008 return -EINVAL; 7009 break; 7010 case CFG80211_STA_MESH_PEER_USER: 7011 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION && 7012 params->plink_action != NL80211_PLINK_ACTION_BLOCK) 7013 return -EINVAL; 7014 break; 7015 } 7016 7017 /* 7018 * Older kernel versions ignored this attribute entirely, so don't 7019 * reject attempts to update it but mark it as unused instead so the 7020 * driver won't look at the data. 7021 */ 7022 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC && 7023 statype != CFG80211_STA_TDLS_PEER_SETUP) 7024 params->link_sta_params.opmode_notif_used = false; 7025 7026 return 0; 7027 } 7028 EXPORT_SYMBOL(cfg80211_check_station_change); 7029 7030 /* 7031 * Get vlan interface making sure it is running and on the right wiphy. 7032 */ 7033 static struct net_device *get_vlan(struct genl_info *info, 7034 struct cfg80211_registered_device *rdev) 7035 { 7036 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN]; 7037 struct net_device *v; 7038 int ret; 7039 7040 if (!vlanattr) 7041 return NULL; 7042 7043 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr)); 7044 if (!v) 7045 return ERR_PTR(-ENODEV); 7046 7047 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) { 7048 ret = -EINVAL; 7049 goto error; 7050 } 7051 7052 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN && 7053 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 7054 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) { 7055 ret = -EINVAL; 7056 goto error; 7057 } 7058 7059 if (!netif_running(v)) { 7060 ret = -ENETDOWN; 7061 goto error; 7062 } 7063 7064 return v; 7065 error: 7066 dev_put(v); 7067 return ERR_PTR(ret); 7068 } 7069 7070 static int nl80211_parse_sta_wme(struct genl_info *info, 7071 struct station_parameters *params) 7072 { 7073 struct nlattr *tb[NL80211_STA_WME_MAX + 1]; 7074 struct nlattr *nla; 7075 int err; 7076 7077 /* parse WME attributes if present */ 7078 if (!info->attrs[NL80211_ATTR_STA_WME]) 7079 return 0; 7080 7081 nla = info->attrs[NL80211_ATTR_STA_WME]; 7082 err = nla_parse_nested_deprecated(tb, NL80211_STA_WME_MAX, nla, 7083 nl80211_sta_wme_policy, 7084 info->extack); 7085 if (err) 7086 return err; 7087 7088 if (tb[NL80211_STA_WME_UAPSD_QUEUES]) 7089 params->uapsd_queues = nla_get_u8( 7090 tb[NL80211_STA_WME_UAPSD_QUEUES]); 7091 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK) 7092 return -EINVAL; 7093 7094 if (tb[NL80211_STA_WME_MAX_SP]) 7095 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]); 7096 7097 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK) 7098 return -EINVAL; 7099 7100 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD; 7101 7102 return 0; 7103 } 7104 7105 static int nl80211_parse_sta_channel_info(struct genl_info *info, 7106 struct station_parameters *params) 7107 { 7108 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) { 7109 params->supported_channels = 7110 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]); 7111 params->supported_channels_len = 7112 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]); 7113 /* 7114 * Need to include at least one (first channel, number of 7115 * channels) tuple for each subband (checked in policy), 7116 * and must have proper tuples for the rest of the data as well. 7117 */ 7118 if (params->supported_channels_len % 2) 7119 return -EINVAL; 7120 } 7121 7122 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) { 7123 params->supported_oper_classes = 7124 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]); 7125 params->supported_oper_classes_len = 7126 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]); 7127 } 7128 return 0; 7129 } 7130 7131 static int nl80211_set_station_tdls(struct genl_info *info, 7132 struct station_parameters *params) 7133 { 7134 int err; 7135 /* Dummy STA entry gets updated once the peer capabilities are known */ 7136 if (info->attrs[NL80211_ATTR_PEER_AID]) 7137 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]); 7138 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) 7139 params->link_sta_params.ht_capa = 7140 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]); 7141 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) 7142 params->link_sta_params.vht_capa = 7143 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]); 7144 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) { 7145 params->link_sta_params.he_capa = 7146 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]); 7147 params->link_sta_params.he_capa_len = 7148 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]); 7149 7150 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) { 7151 params->link_sta_params.eht_capa = 7152 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]); 7153 params->link_sta_params.eht_capa_len = 7154 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]); 7155 7156 if (!ieee80211_eht_capa_size_ok((const u8 *)params->link_sta_params.he_capa, 7157 (const u8 *)params->link_sta_params.eht_capa, 7158 params->link_sta_params.eht_capa_len, 7159 false)) 7160 return -EINVAL; 7161 } 7162 } 7163 7164 err = nl80211_parse_sta_channel_info(info, params); 7165 if (err) 7166 return err; 7167 7168 return nl80211_parse_sta_wme(info, params); 7169 } 7170 7171 static int nl80211_parse_sta_txpower_setting(struct genl_info *info, 7172 struct sta_txpwr *txpwr, 7173 bool *txpwr_set) 7174 { 7175 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7176 int idx; 7177 7178 if (info->attrs[NL80211_ATTR_STA_TX_POWER_SETTING]) { 7179 if (!rdev->ops->set_tx_power || 7180 !wiphy_ext_feature_isset(&rdev->wiphy, 7181 NL80211_EXT_FEATURE_STA_TX_PWR)) 7182 return -EOPNOTSUPP; 7183 7184 idx = NL80211_ATTR_STA_TX_POWER_SETTING; 7185 txpwr->type = nla_get_u8(info->attrs[idx]); 7186 7187 if (txpwr->type == NL80211_TX_POWER_LIMITED) { 7188 idx = NL80211_ATTR_STA_TX_POWER; 7189 7190 if (info->attrs[idx]) 7191 txpwr->power = nla_get_s16(info->attrs[idx]); 7192 else 7193 return -EINVAL; 7194 } 7195 7196 *txpwr_set = true; 7197 } else { 7198 *txpwr_set = false; 7199 } 7200 7201 return 0; 7202 } 7203 7204 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info) 7205 { 7206 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7207 struct net_device *dev = info->user_ptr[1]; 7208 struct station_parameters params; 7209 u8 *mac_addr; 7210 int err; 7211 7212 memset(¶ms, 0, sizeof(params)); 7213 7214 if (!rdev->ops->change_station) 7215 return -EOPNOTSUPP; 7216 7217 /* 7218 * AID and listen_interval properties can be set only for unassociated 7219 * station. Include these parameters here and will check them in 7220 * cfg80211_check_station_change(). 7221 */ 7222 if (info->attrs[NL80211_ATTR_STA_AID]) 7223 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]); 7224 7225 if (info->attrs[NL80211_ATTR_VLAN_ID]) 7226 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]); 7227 7228 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]) 7229 params.listen_interval = 7230 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]); 7231 else 7232 params.listen_interval = -1; 7233 7234 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) 7235 params.support_p2p_ps = 7236 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]); 7237 else 7238 params.support_p2p_ps = -1; 7239 7240 if (!info->attrs[NL80211_ATTR_MAC]) 7241 return -EINVAL; 7242 7243 params.link_sta_params.link_id = 7244 nl80211_link_id_or_invalid(info->attrs); 7245 7246 if (info->attrs[NL80211_ATTR_MLD_ADDR]) { 7247 /* If MLD_ADDR attribute is set then this is an MLD station 7248 * and the MLD_ADDR attribute holds the MLD address and the 7249 * MAC attribute holds for the LINK address. 7250 * In that case, the link_id is also expected to be valid. 7251 */ 7252 if (params.link_sta_params.link_id < 0) 7253 return -EINVAL; 7254 7255 mac_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 7256 params.link_sta_params.mld_mac = mac_addr; 7257 params.link_sta_params.link_mac = 7258 nla_data(info->attrs[NL80211_ATTR_MAC]); 7259 if (!is_valid_ether_addr(params.link_sta_params.link_mac)) 7260 return -EINVAL; 7261 } else { 7262 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 7263 } 7264 7265 7266 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) { 7267 params.link_sta_params.supported_rates = 7268 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 7269 params.link_sta_params.supported_rates_len = 7270 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 7271 } 7272 7273 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) { 7274 params.capability = 7275 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]); 7276 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY; 7277 } 7278 7279 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) { 7280 params.ext_capab = 7281 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]); 7282 params.ext_capab_len = 7283 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]); 7284 } 7285 7286 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms)) 7287 return -EINVAL; 7288 7289 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) 7290 params.plink_action = 7291 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]); 7292 7293 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) { 7294 params.plink_state = 7295 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]); 7296 if (info->attrs[NL80211_ATTR_MESH_PEER_AID]) 7297 params.peer_aid = nla_get_u16( 7298 info->attrs[NL80211_ATTR_MESH_PEER_AID]); 7299 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE; 7300 } 7301 7302 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) 7303 params.local_pm = nla_get_u32( 7304 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]); 7305 7306 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) { 7307 params.link_sta_params.opmode_notif_used = true; 7308 params.link_sta_params.opmode_notif = 7309 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]); 7310 } 7311 7312 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]) 7313 params.link_sta_params.he_6ghz_capa = 7314 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]); 7315 7316 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]) 7317 params.airtime_weight = 7318 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]); 7319 7320 if (params.airtime_weight && 7321 !wiphy_ext_feature_isset(&rdev->wiphy, 7322 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS)) 7323 return -EOPNOTSUPP; 7324 7325 err = nl80211_parse_sta_txpower_setting(info, 7326 ¶ms.link_sta_params.txpwr, 7327 ¶ms.link_sta_params.txpwr_set); 7328 if (err) 7329 return err; 7330 7331 /* Include parameters for TDLS peer (will check later) */ 7332 err = nl80211_set_station_tdls(info, ¶ms); 7333 if (err) 7334 return err; 7335 7336 params.vlan = get_vlan(info, rdev); 7337 if (IS_ERR(params.vlan)) 7338 return PTR_ERR(params.vlan); 7339 7340 switch (dev->ieee80211_ptr->iftype) { 7341 case NL80211_IFTYPE_AP: 7342 case NL80211_IFTYPE_AP_VLAN: 7343 case NL80211_IFTYPE_P2P_GO: 7344 case NL80211_IFTYPE_P2P_CLIENT: 7345 case NL80211_IFTYPE_STATION: 7346 case NL80211_IFTYPE_ADHOC: 7347 case NL80211_IFTYPE_MESH_POINT: 7348 break; 7349 default: 7350 err = -EOPNOTSUPP; 7351 goto out_put_vlan; 7352 } 7353 7354 /* driver will call cfg80211_check_station_change() */ 7355 wdev_lock(dev->ieee80211_ptr); 7356 err = rdev_change_station(rdev, dev, mac_addr, ¶ms); 7357 wdev_unlock(dev->ieee80211_ptr); 7358 7359 out_put_vlan: 7360 dev_put(params.vlan); 7361 7362 return err; 7363 } 7364 7365 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info) 7366 { 7367 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7368 int err; 7369 struct net_device *dev = info->user_ptr[1]; 7370 struct wireless_dev *wdev = dev->ieee80211_ptr; 7371 struct station_parameters params; 7372 u8 *mac_addr = NULL; 7373 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) | 7374 BIT(NL80211_STA_FLAG_ASSOCIATED); 7375 7376 memset(¶ms, 0, sizeof(params)); 7377 7378 if (!rdev->ops->add_station) 7379 return -EOPNOTSUPP; 7380 7381 if (!info->attrs[NL80211_ATTR_MAC]) 7382 return -EINVAL; 7383 7384 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]) 7385 return -EINVAL; 7386 7387 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) 7388 return -EINVAL; 7389 7390 if (!info->attrs[NL80211_ATTR_STA_AID] && 7391 !info->attrs[NL80211_ATTR_PEER_AID]) 7392 return -EINVAL; 7393 7394 params.link_sta_params.link_id = 7395 nl80211_link_id_or_invalid(info->attrs); 7396 7397 if (info->attrs[NL80211_ATTR_MLD_ADDR]) { 7398 mac_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 7399 params.link_sta_params.mld_mac = mac_addr; 7400 params.link_sta_params.link_mac = 7401 nla_data(info->attrs[NL80211_ATTR_MAC]); 7402 if (!is_valid_ether_addr(params.link_sta_params.link_mac)) 7403 return -EINVAL; 7404 } else { 7405 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 7406 } 7407 7408 params.link_sta_params.supported_rates = 7409 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 7410 params.link_sta_params.supported_rates_len = 7411 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 7412 params.listen_interval = 7413 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]); 7414 7415 if (info->attrs[NL80211_ATTR_VLAN_ID]) 7416 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]); 7417 7418 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) { 7419 params.support_p2p_ps = 7420 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]); 7421 } else { 7422 /* 7423 * if not specified, assume it's supported for P2P GO interface, 7424 * and is NOT supported for AP interface 7425 */ 7426 params.support_p2p_ps = 7427 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO; 7428 } 7429 7430 if (info->attrs[NL80211_ATTR_PEER_AID]) 7431 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]); 7432 else 7433 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]); 7434 7435 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) { 7436 params.capability = 7437 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]); 7438 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY; 7439 } 7440 7441 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) { 7442 params.ext_capab = 7443 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]); 7444 params.ext_capab_len = 7445 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]); 7446 } 7447 7448 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) 7449 params.link_sta_params.ht_capa = 7450 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]); 7451 7452 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) 7453 params.link_sta_params.vht_capa = 7454 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]); 7455 7456 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) { 7457 params.link_sta_params.he_capa = 7458 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]); 7459 params.link_sta_params.he_capa_len = 7460 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]); 7461 7462 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) { 7463 params.link_sta_params.eht_capa = 7464 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]); 7465 params.link_sta_params.eht_capa_len = 7466 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]); 7467 7468 if (!ieee80211_eht_capa_size_ok((const u8 *)params.link_sta_params.he_capa, 7469 (const u8 *)params.link_sta_params.eht_capa, 7470 params.link_sta_params.eht_capa_len, 7471 false)) 7472 return -EINVAL; 7473 } 7474 } 7475 7476 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]) 7477 params.link_sta_params.he_6ghz_capa = 7478 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]); 7479 7480 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) { 7481 params.link_sta_params.opmode_notif_used = true; 7482 params.link_sta_params.opmode_notif = 7483 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]); 7484 } 7485 7486 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) 7487 params.plink_action = 7488 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]); 7489 7490 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]) 7491 params.airtime_weight = 7492 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]); 7493 7494 if (params.airtime_weight && 7495 !wiphy_ext_feature_isset(&rdev->wiphy, 7496 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS)) 7497 return -EOPNOTSUPP; 7498 7499 err = nl80211_parse_sta_txpower_setting(info, 7500 ¶ms.link_sta_params.txpwr, 7501 ¶ms.link_sta_params.txpwr_set); 7502 if (err) 7503 return err; 7504 7505 err = nl80211_parse_sta_channel_info(info, ¶ms); 7506 if (err) 7507 return err; 7508 7509 err = nl80211_parse_sta_wme(info, ¶ms); 7510 if (err) 7511 return err; 7512 7513 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms)) 7514 return -EINVAL; 7515 7516 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT 7517 * as userspace might just pass through the capabilities from the IEs 7518 * directly, rather than enforcing this restriction and returning an 7519 * error in this case. 7520 */ 7521 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) { 7522 params.link_sta_params.ht_capa = NULL; 7523 params.link_sta_params.vht_capa = NULL; 7524 7525 /* HE and EHT require WME */ 7526 if (params.link_sta_params.he_capa_len || 7527 params.link_sta_params.he_6ghz_capa || 7528 params.link_sta_params.eht_capa_len) 7529 return -EINVAL; 7530 } 7531 7532 /* Ensure that HT/VHT capabilities are not set for 6 GHz HE STA */ 7533 if (params.link_sta_params.he_6ghz_capa && 7534 (params.link_sta_params.ht_capa || params.link_sta_params.vht_capa)) 7535 return -EINVAL; 7536 7537 /* When you run into this, adjust the code below for the new flag */ 7538 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7); 7539 7540 switch (dev->ieee80211_ptr->iftype) { 7541 case NL80211_IFTYPE_AP: 7542 case NL80211_IFTYPE_AP_VLAN: 7543 case NL80211_IFTYPE_P2P_GO: 7544 /* ignore WME attributes if iface/sta is not capable */ 7545 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) || 7546 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) 7547 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD; 7548 7549 /* TDLS peers cannot be added */ 7550 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) || 7551 info->attrs[NL80211_ATTR_PEER_AID]) 7552 return -EINVAL; 7553 /* but don't bother the driver with it */ 7554 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER); 7555 7556 /* allow authenticated/associated only if driver handles it */ 7557 if (!(rdev->wiphy.features & 7558 NL80211_FEATURE_FULL_AP_CLIENT_STATE) && 7559 params.sta_flags_mask & auth_assoc) 7560 return -EINVAL; 7561 7562 /* Older userspace, or userspace wanting to be compatible with 7563 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth 7564 * and assoc flags in the mask, but assumes the station will be 7565 * added as associated anyway since this was the required driver 7566 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was 7567 * introduced. 7568 * In order to not bother drivers with this quirk in the API 7569 * set the flags in both the mask and set for new stations in 7570 * this case. 7571 */ 7572 if (!(params.sta_flags_mask & auth_assoc)) { 7573 params.sta_flags_mask |= auth_assoc; 7574 params.sta_flags_set |= auth_assoc; 7575 } 7576 7577 /* must be last in here for error handling */ 7578 params.vlan = get_vlan(info, rdev); 7579 if (IS_ERR(params.vlan)) 7580 return PTR_ERR(params.vlan); 7581 break; 7582 case NL80211_IFTYPE_MESH_POINT: 7583 /* ignore uAPSD data */ 7584 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD; 7585 7586 /* associated is disallowed */ 7587 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED)) 7588 return -EINVAL; 7589 /* TDLS peers cannot be added */ 7590 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) || 7591 info->attrs[NL80211_ATTR_PEER_AID]) 7592 return -EINVAL; 7593 break; 7594 case NL80211_IFTYPE_STATION: 7595 case NL80211_IFTYPE_P2P_CLIENT: 7596 /* ignore uAPSD data */ 7597 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD; 7598 7599 /* these are disallowed */ 7600 if (params.sta_flags_mask & 7601 (BIT(NL80211_STA_FLAG_ASSOCIATED) | 7602 BIT(NL80211_STA_FLAG_AUTHENTICATED))) 7603 return -EINVAL; 7604 /* Only TDLS peers can be added */ 7605 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))) 7606 return -EINVAL; 7607 /* Can only add if TDLS ... */ 7608 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS)) 7609 return -EOPNOTSUPP; 7610 /* ... with external setup is supported */ 7611 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP)) 7612 return -EOPNOTSUPP; 7613 /* 7614 * Older wpa_supplicant versions always mark the TDLS peer 7615 * as authorized, but it shouldn't yet be. 7616 */ 7617 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED); 7618 break; 7619 default: 7620 return -EOPNOTSUPP; 7621 } 7622 7623 /* be aware of params.vlan when changing code here */ 7624 7625 wdev_lock(dev->ieee80211_ptr); 7626 if (wdev->valid_links) { 7627 if (params.link_sta_params.link_id < 0) { 7628 err = -EINVAL; 7629 goto out; 7630 } 7631 if (!(wdev->valid_links & BIT(params.link_sta_params.link_id))) { 7632 err = -ENOLINK; 7633 goto out; 7634 } 7635 } else { 7636 if (params.link_sta_params.link_id >= 0) { 7637 err = -EINVAL; 7638 goto out; 7639 } 7640 } 7641 err = rdev_add_station(rdev, dev, mac_addr, ¶ms); 7642 out: 7643 wdev_unlock(dev->ieee80211_ptr); 7644 dev_put(params.vlan); 7645 return err; 7646 } 7647 7648 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info) 7649 { 7650 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7651 struct net_device *dev = info->user_ptr[1]; 7652 struct station_del_parameters params; 7653 int ret; 7654 7655 memset(¶ms, 0, sizeof(params)); 7656 7657 if (info->attrs[NL80211_ATTR_MAC]) 7658 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]); 7659 7660 switch (dev->ieee80211_ptr->iftype) { 7661 case NL80211_IFTYPE_AP: 7662 case NL80211_IFTYPE_AP_VLAN: 7663 case NL80211_IFTYPE_MESH_POINT: 7664 case NL80211_IFTYPE_P2P_GO: 7665 /* always accept these */ 7666 break; 7667 case NL80211_IFTYPE_ADHOC: 7668 /* conditionally accept */ 7669 if (wiphy_ext_feature_isset(&rdev->wiphy, 7670 NL80211_EXT_FEATURE_DEL_IBSS_STA)) 7671 break; 7672 return -EINVAL; 7673 default: 7674 return -EINVAL; 7675 } 7676 7677 if (!rdev->ops->del_station) 7678 return -EOPNOTSUPP; 7679 7680 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) { 7681 params.subtype = 7682 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]); 7683 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 && 7684 params.subtype != IEEE80211_STYPE_DEAUTH >> 4) 7685 return -EINVAL; 7686 } else { 7687 /* Default to Deauthentication frame */ 7688 params.subtype = IEEE80211_STYPE_DEAUTH >> 4; 7689 } 7690 7691 if (info->attrs[NL80211_ATTR_REASON_CODE]) { 7692 params.reason_code = 7693 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 7694 if (params.reason_code == 0) 7695 return -EINVAL; /* 0 is reserved */ 7696 } else { 7697 /* Default to reason code 2 */ 7698 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID; 7699 } 7700 7701 wdev_lock(dev->ieee80211_ptr); 7702 ret = rdev_del_station(rdev, dev, ¶ms); 7703 wdev_unlock(dev->ieee80211_ptr); 7704 7705 return ret; 7706 } 7707 7708 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq, 7709 int flags, struct net_device *dev, 7710 u8 *dst, u8 *next_hop, 7711 struct mpath_info *pinfo) 7712 { 7713 void *hdr; 7714 struct nlattr *pinfoattr; 7715 7716 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH); 7717 if (!hdr) 7718 return -1; 7719 7720 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 7721 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) || 7722 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) || 7723 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation)) 7724 goto nla_put_failure; 7725 7726 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MPATH_INFO); 7727 if (!pinfoattr) 7728 goto nla_put_failure; 7729 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) && 7730 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN, 7731 pinfo->frame_qlen)) 7732 goto nla_put_failure; 7733 if (((pinfo->filled & MPATH_INFO_SN) && 7734 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) || 7735 ((pinfo->filled & MPATH_INFO_METRIC) && 7736 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC, 7737 pinfo->metric)) || 7738 ((pinfo->filled & MPATH_INFO_EXPTIME) && 7739 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME, 7740 pinfo->exptime)) || 7741 ((pinfo->filled & MPATH_INFO_FLAGS) && 7742 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS, 7743 pinfo->flags)) || 7744 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) && 7745 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT, 7746 pinfo->discovery_timeout)) || 7747 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) && 7748 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES, 7749 pinfo->discovery_retries)) || 7750 ((pinfo->filled & MPATH_INFO_HOP_COUNT) && 7751 nla_put_u8(msg, NL80211_MPATH_INFO_HOP_COUNT, 7752 pinfo->hop_count)) || 7753 ((pinfo->filled & MPATH_INFO_PATH_CHANGE) && 7754 nla_put_u32(msg, NL80211_MPATH_INFO_PATH_CHANGE, 7755 pinfo->path_change_count))) 7756 goto nla_put_failure; 7757 7758 nla_nest_end(msg, pinfoattr); 7759 7760 genlmsg_end(msg, hdr); 7761 return 0; 7762 7763 nla_put_failure: 7764 genlmsg_cancel(msg, hdr); 7765 return -EMSGSIZE; 7766 } 7767 7768 static int nl80211_dump_mpath(struct sk_buff *skb, 7769 struct netlink_callback *cb) 7770 { 7771 struct mpath_info pinfo; 7772 struct cfg80211_registered_device *rdev; 7773 struct wireless_dev *wdev; 7774 u8 dst[ETH_ALEN]; 7775 u8 next_hop[ETH_ALEN]; 7776 int path_idx = cb->args[2]; 7777 int err; 7778 7779 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL); 7780 if (err) 7781 return err; 7782 /* nl80211_prepare_wdev_dump acquired it in the successful case */ 7783 __acquire(&rdev->wiphy.mtx); 7784 7785 if (!rdev->ops->dump_mpath) { 7786 err = -EOPNOTSUPP; 7787 goto out_err; 7788 } 7789 7790 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) { 7791 err = -EOPNOTSUPP; 7792 goto out_err; 7793 } 7794 7795 while (1) { 7796 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst, 7797 next_hop, &pinfo); 7798 if (err == -ENOENT) 7799 break; 7800 if (err) 7801 goto out_err; 7802 7803 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid, 7804 cb->nlh->nlmsg_seq, NLM_F_MULTI, 7805 wdev->netdev, dst, next_hop, 7806 &pinfo) < 0) 7807 goto out; 7808 7809 path_idx++; 7810 } 7811 7812 out: 7813 cb->args[2] = path_idx; 7814 err = skb->len; 7815 out_err: 7816 wiphy_unlock(&rdev->wiphy); 7817 return err; 7818 } 7819 7820 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info) 7821 { 7822 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7823 int err; 7824 struct net_device *dev = info->user_ptr[1]; 7825 struct mpath_info pinfo; 7826 struct sk_buff *msg; 7827 u8 *dst = NULL; 7828 u8 next_hop[ETH_ALEN]; 7829 7830 memset(&pinfo, 0, sizeof(pinfo)); 7831 7832 if (!info->attrs[NL80211_ATTR_MAC]) 7833 return -EINVAL; 7834 7835 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 7836 7837 if (!rdev->ops->get_mpath) 7838 return -EOPNOTSUPP; 7839 7840 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) 7841 return -EOPNOTSUPP; 7842 7843 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo); 7844 if (err) 7845 return err; 7846 7847 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 7848 if (!msg) 7849 return -ENOMEM; 7850 7851 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0, 7852 dev, dst, next_hop, &pinfo) < 0) { 7853 nlmsg_free(msg); 7854 return -ENOBUFS; 7855 } 7856 7857 return genlmsg_reply(msg, info); 7858 } 7859 7860 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info) 7861 { 7862 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7863 struct net_device *dev = info->user_ptr[1]; 7864 u8 *dst = NULL; 7865 u8 *next_hop = NULL; 7866 7867 if (!info->attrs[NL80211_ATTR_MAC]) 7868 return -EINVAL; 7869 7870 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]) 7871 return -EINVAL; 7872 7873 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 7874 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]); 7875 7876 if (!rdev->ops->change_mpath) 7877 return -EOPNOTSUPP; 7878 7879 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) 7880 return -EOPNOTSUPP; 7881 7882 return rdev_change_mpath(rdev, dev, dst, next_hop); 7883 } 7884 7885 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info) 7886 { 7887 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7888 struct net_device *dev = info->user_ptr[1]; 7889 u8 *dst = NULL; 7890 u8 *next_hop = NULL; 7891 7892 if (!info->attrs[NL80211_ATTR_MAC]) 7893 return -EINVAL; 7894 7895 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]) 7896 return -EINVAL; 7897 7898 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 7899 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]); 7900 7901 if (!rdev->ops->add_mpath) 7902 return -EOPNOTSUPP; 7903 7904 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) 7905 return -EOPNOTSUPP; 7906 7907 return rdev_add_mpath(rdev, dev, dst, next_hop); 7908 } 7909 7910 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info) 7911 { 7912 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7913 struct net_device *dev = info->user_ptr[1]; 7914 u8 *dst = NULL; 7915 7916 if (info->attrs[NL80211_ATTR_MAC]) 7917 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 7918 7919 if (!rdev->ops->del_mpath) 7920 return -EOPNOTSUPP; 7921 7922 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) 7923 return -EOPNOTSUPP; 7924 7925 return rdev_del_mpath(rdev, dev, dst); 7926 } 7927 7928 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info) 7929 { 7930 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 7931 int err; 7932 struct net_device *dev = info->user_ptr[1]; 7933 struct mpath_info pinfo; 7934 struct sk_buff *msg; 7935 u8 *dst = NULL; 7936 u8 mpp[ETH_ALEN]; 7937 7938 memset(&pinfo, 0, sizeof(pinfo)); 7939 7940 if (!info->attrs[NL80211_ATTR_MAC]) 7941 return -EINVAL; 7942 7943 dst = nla_data(info->attrs[NL80211_ATTR_MAC]); 7944 7945 if (!rdev->ops->get_mpp) 7946 return -EOPNOTSUPP; 7947 7948 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) 7949 return -EOPNOTSUPP; 7950 7951 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo); 7952 if (err) 7953 return err; 7954 7955 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 7956 if (!msg) 7957 return -ENOMEM; 7958 7959 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0, 7960 dev, dst, mpp, &pinfo) < 0) { 7961 nlmsg_free(msg); 7962 return -ENOBUFS; 7963 } 7964 7965 return genlmsg_reply(msg, info); 7966 } 7967 7968 static int nl80211_dump_mpp(struct sk_buff *skb, 7969 struct netlink_callback *cb) 7970 { 7971 struct mpath_info pinfo; 7972 struct cfg80211_registered_device *rdev; 7973 struct wireless_dev *wdev; 7974 u8 dst[ETH_ALEN]; 7975 u8 mpp[ETH_ALEN]; 7976 int path_idx = cb->args[2]; 7977 int err; 7978 7979 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL); 7980 if (err) 7981 return err; 7982 /* nl80211_prepare_wdev_dump acquired it in the successful case */ 7983 __acquire(&rdev->wiphy.mtx); 7984 7985 if (!rdev->ops->dump_mpp) { 7986 err = -EOPNOTSUPP; 7987 goto out_err; 7988 } 7989 7990 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) { 7991 err = -EOPNOTSUPP; 7992 goto out_err; 7993 } 7994 7995 while (1) { 7996 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst, 7997 mpp, &pinfo); 7998 if (err == -ENOENT) 7999 break; 8000 if (err) 8001 goto out_err; 8002 8003 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid, 8004 cb->nlh->nlmsg_seq, NLM_F_MULTI, 8005 wdev->netdev, dst, mpp, 8006 &pinfo) < 0) 8007 goto out; 8008 8009 path_idx++; 8010 } 8011 8012 out: 8013 cb->args[2] = path_idx; 8014 err = skb->len; 8015 out_err: 8016 wiphy_unlock(&rdev->wiphy); 8017 return err; 8018 } 8019 8020 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info) 8021 { 8022 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 8023 struct net_device *dev = info->user_ptr[1]; 8024 struct wireless_dev *wdev = dev->ieee80211_ptr; 8025 struct bss_parameters params; 8026 int err; 8027 8028 memset(¶ms, 0, sizeof(params)); 8029 params.link_id = nl80211_link_id_or_invalid(info->attrs); 8030 /* default to not changing parameters */ 8031 params.use_cts_prot = -1; 8032 params.use_short_preamble = -1; 8033 params.use_short_slot_time = -1; 8034 params.ap_isolate = -1; 8035 params.ht_opmode = -1; 8036 params.p2p_ctwindow = -1; 8037 params.p2p_opp_ps = -1; 8038 8039 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT]) 8040 params.use_cts_prot = 8041 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]); 8042 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]) 8043 params.use_short_preamble = 8044 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]); 8045 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]) 8046 params.use_short_slot_time = 8047 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]); 8048 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) { 8049 params.basic_rates = 8050 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 8051 params.basic_rates_len = 8052 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 8053 } 8054 if (info->attrs[NL80211_ATTR_AP_ISOLATE]) 8055 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]); 8056 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE]) 8057 params.ht_opmode = 8058 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]); 8059 8060 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) { 8061 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 8062 return -EINVAL; 8063 params.p2p_ctwindow = 8064 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]); 8065 if (params.p2p_ctwindow != 0 && 8066 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN)) 8067 return -EINVAL; 8068 } 8069 8070 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) { 8071 u8 tmp; 8072 8073 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 8074 return -EINVAL; 8075 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]); 8076 params.p2p_opp_ps = tmp; 8077 if (params.p2p_opp_ps && 8078 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS)) 8079 return -EINVAL; 8080 } 8081 8082 if (!rdev->ops->change_bss) 8083 return -EOPNOTSUPP; 8084 8085 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 8086 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 8087 return -EOPNOTSUPP; 8088 8089 wdev_lock(wdev); 8090 err = rdev_change_bss(rdev, dev, ¶ms); 8091 wdev_unlock(wdev); 8092 8093 return err; 8094 } 8095 8096 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info) 8097 { 8098 char *data = NULL; 8099 bool is_indoor; 8100 enum nl80211_user_reg_hint_type user_reg_hint_type; 8101 u32 owner_nlportid; 8102 8103 /* 8104 * You should only get this when cfg80211 hasn't yet initialized 8105 * completely when built-in to the kernel right between the time 8106 * window between nl80211_init() and regulatory_init(), if that is 8107 * even possible. 8108 */ 8109 if (unlikely(!rcu_access_pointer(cfg80211_regdomain))) 8110 return -EINPROGRESS; 8111 8112 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]) 8113 user_reg_hint_type = 8114 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]); 8115 else 8116 user_reg_hint_type = NL80211_USER_REG_HINT_USER; 8117 8118 switch (user_reg_hint_type) { 8119 case NL80211_USER_REG_HINT_USER: 8120 case NL80211_USER_REG_HINT_CELL_BASE: 8121 if (!info->attrs[NL80211_ATTR_REG_ALPHA2]) 8122 return -EINVAL; 8123 8124 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]); 8125 return regulatory_hint_user(data, user_reg_hint_type); 8126 case NL80211_USER_REG_HINT_INDOOR: 8127 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) { 8128 owner_nlportid = info->snd_portid; 8129 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR]; 8130 } else { 8131 owner_nlportid = 0; 8132 is_indoor = true; 8133 } 8134 8135 return regulatory_hint_indoor(is_indoor, owner_nlportid); 8136 default: 8137 return -EINVAL; 8138 } 8139 } 8140 8141 static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info) 8142 { 8143 return reg_reload_regdb(); 8144 } 8145 8146 static int nl80211_get_mesh_config(struct sk_buff *skb, 8147 struct genl_info *info) 8148 { 8149 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 8150 struct net_device *dev = info->user_ptr[1]; 8151 struct wireless_dev *wdev = dev->ieee80211_ptr; 8152 struct mesh_config cur_params; 8153 int err = 0; 8154 void *hdr; 8155 struct nlattr *pinfoattr; 8156 struct sk_buff *msg; 8157 8158 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) 8159 return -EOPNOTSUPP; 8160 8161 if (!rdev->ops->get_mesh_config) 8162 return -EOPNOTSUPP; 8163 8164 wdev_lock(wdev); 8165 /* If not connected, get default parameters */ 8166 if (!wdev->u.mesh.id_len) 8167 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params)); 8168 else 8169 err = rdev_get_mesh_config(rdev, dev, &cur_params); 8170 wdev_unlock(wdev); 8171 8172 if (err) 8173 return err; 8174 8175 /* Draw up a netlink message to send back */ 8176 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 8177 if (!msg) 8178 return -ENOMEM; 8179 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 8180 NL80211_CMD_GET_MESH_CONFIG); 8181 if (!hdr) 8182 goto out; 8183 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MESH_CONFIG); 8184 if (!pinfoattr) 8185 goto nla_put_failure; 8186 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 8187 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT, 8188 cur_params.dot11MeshRetryTimeout) || 8189 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT, 8190 cur_params.dot11MeshConfirmTimeout) || 8191 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT, 8192 cur_params.dot11MeshHoldingTimeout) || 8193 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS, 8194 cur_params.dot11MeshMaxPeerLinks) || 8195 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES, 8196 cur_params.dot11MeshMaxRetries) || 8197 nla_put_u8(msg, NL80211_MESHCONF_TTL, 8198 cur_params.dot11MeshTTL) || 8199 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL, 8200 cur_params.element_ttl) || 8201 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS, 8202 cur_params.auto_open_plinks) || 8203 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, 8204 cur_params.dot11MeshNbrOffsetMaxNeighbor) || 8205 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, 8206 cur_params.dot11MeshHWMPmaxPREQretries) || 8207 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME, 8208 cur_params.path_refresh_time) || 8209 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, 8210 cur_params.min_discovery_timeout) || 8211 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, 8212 cur_params.dot11MeshHWMPactivePathTimeout) || 8213 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, 8214 cur_params.dot11MeshHWMPpreqMinInterval) || 8215 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, 8216 cur_params.dot11MeshHWMPperrMinInterval) || 8217 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 8218 cur_params.dot11MeshHWMPnetDiameterTraversalTime) || 8219 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE, 8220 cur_params.dot11MeshHWMPRootMode) || 8221 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL, 8222 cur_params.dot11MeshHWMPRannInterval) || 8223 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, 8224 cur_params.dot11MeshGateAnnouncementProtocol) || 8225 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING, 8226 cur_params.dot11MeshForwarding) || 8227 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD, 8228 cur_params.rssi_threshold) || 8229 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE, 8230 cur_params.ht_opmode) || 8231 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, 8232 cur_params.dot11MeshHWMPactivePathToRootTimeout) || 8233 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL, 8234 cur_params.dot11MeshHWMProotInterval) || 8235 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, 8236 cur_params.dot11MeshHWMPconfirmationInterval) || 8237 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE, 8238 cur_params.power_mode) || 8239 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW, 8240 cur_params.dot11MeshAwakeWindowDuration) || 8241 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT, 8242 cur_params.plink_timeout) || 8243 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_GATE, 8244 cur_params.dot11MeshConnectedToMeshGate) || 8245 nla_put_u8(msg, NL80211_MESHCONF_NOLEARN, 8246 cur_params.dot11MeshNolearn) || 8247 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_AS, 8248 cur_params.dot11MeshConnectedToAuthServer)) 8249 goto nla_put_failure; 8250 nla_nest_end(msg, pinfoattr); 8251 genlmsg_end(msg, hdr); 8252 return genlmsg_reply(msg, info); 8253 8254 nla_put_failure: 8255 out: 8256 nlmsg_free(msg); 8257 return -ENOBUFS; 8258 } 8259 8260 static const struct nla_policy 8261 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = { 8262 [NL80211_MESHCONF_RETRY_TIMEOUT] = 8263 NLA_POLICY_RANGE(NLA_U16, 1, 255), 8264 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = 8265 NLA_POLICY_RANGE(NLA_U16, 1, 255), 8266 [NL80211_MESHCONF_HOLDING_TIMEOUT] = 8267 NLA_POLICY_RANGE(NLA_U16, 1, 255), 8268 [NL80211_MESHCONF_MAX_PEER_LINKS] = 8269 NLA_POLICY_RANGE(NLA_U16, 0, 255), 8270 [NL80211_MESHCONF_MAX_RETRIES] = NLA_POLICY_MAX(NLA_U8, 16), 8271 [NL80211_MESHCONF_TTL] = NLA_POLICY_MIN(NLA_U8, 1), 8272 [NL80211_MESHCONF_ELEMENT_TTL] = NLA_POLICY_MIN(NLA_U8, 1), 8273 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = NLA_POLICY_MAX(NLA_U8, 1), 8274 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = 8275 NLA_POLICY_RANGE(NLA_U32, 1, 255), 8276 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 }, 8277 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 }, 8278 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = NLA_POLICY_MIN(NLA_U16, 1), 8279 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 }, 8280 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = 8281 NLA_POLICY_MIN(NLA_U16, 1), 8282 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = 8283 NLA_POLICY_MIN(NLA_U16, 1), 8284 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = 8285 NLA_POLICY_MIN(NLA_U16, 1), 8286 [NL80211_MESHCONF_HWMP_ROOTMODE] = NLA_POLICY_MAX(NLA_U8, 4), 8287 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = 8288 NLA_POLICY_MIN(NLA_U16, 1), 8289 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = NLA_POLICY_MAX(NLA_U8, 1), 8290 [NL80211_MESHCONF_FORWARDING] = NLA_POLICY_MAX(NLA_U8, 1), 8291 [NL80211_MESHCONF_RSSI_THRESHOLD] = 8292 NLA_POLICY_RANGE(NLA_S32, -255, 0), 8293 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 }, 8294 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 }, 8295 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = 8296 NLA_POLICY_MIN(NLA_U16, 1), 8297 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = 8298 NLA_POLICY_MIN(NLA_U16, 1), 8299 [NL80211_MESHCONF_POWER_MODE] = 8300 NLA_POLICY_RANGE(NLA_U32, 8301 NL80211_MESH_POWER_ACTIVE, 8302 NL80211_MESH_POWER_MAX), 8303 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 }, 8304 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 }, 8305 [NL80211_MESHCONF_CONNECTED_TO_GATE] = NLA_POLICY_RANGE(NLA_U8, 0, 1), 8306 [NL80211_MESHCONF_NOLEARN] = NLA_POLICY_RANGE(NLA_U8, 0, 1), 8307 [NL80211_MESHCONF_CONNECTED_TO_AS] = NLA_POLICY_RANGE(NLA_U8, 0, 1), 8308 }; 8309 8310 static const struct nla_policy 8311 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = { 8312 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 }, 8313 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 }, 8314 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 }, 8315 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG }, 8316 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 }, 8317 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG }, 8318 [NL80211_MESH_SETUP_IE] = 8319 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr, 8320 IEEE80211_MAX_DATA_LEN), 8321 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG }, 8322 }; 8323 8324 static int nl80211_parse_mesh_config(struct genl_info *info, 8325 struct mesh_config *cfg, 8326 u32 *mask_out) 8327 { 8328 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1]; 8329 u32 mask = 0; 8330 u16 ht_opmode; 8331 8332 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \ 8333 do { \ 8334 if (tb[attr]) { \ 8335 cfg->param = fn(tb[attr]); \ 8336 mask |= BIT((attr) - 1); \ 8337 } \ 8338 } while (0) 8339 8340 if (!info->attrs[NL80211_ATTR_MESH_CONFIG]) 8341 return -EINVAL; 8342 if (nla_parse_nested_deprecated(tb, NL80211_MESHCONF_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_CONFIG], nl80211_meshconf_params_policy, info->extack)) 8343 return -EINVAL; 8344 8345 /* This makes sure that there aren't more than 32 mesh config 8346 * parameters (otherwise our bitfield scheme would not work.) */ 8347 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32); 8348 8349 /* Fill in the params struct */ 8350 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, mask, 8351 NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16); 8352 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, mask, 8353 NL80211_MESHCONF_CONFIRM_TIMEOUT, 8354 nla_get_u16); 8355 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, mask, 8356 NL80211_MESHCONF_HOLDING_TIMEOUT, 8357 nla_get_u16); 8358 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, mask, 8359 NL80211_MESHCONF_MAX_PEER_LINKS, 8360 nla_get_u16); 8361 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, mask, 8362 NL80211_MESHCONF_MAX_RETRIES, nla_get_u8); 8363 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, mask, 8364 NL80211_MESHCONF_TTL, nla_get_u8); 8365 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, mask, 8366 NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8); 8367 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, mask, 8368 NL80211_MESHCONF_AUTO_OPEN_PLINKS, 8369 nla_get_u8); 8370 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor, 8371 mask, 8372 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR, 8373 nla_get_u32); 8374 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, mask, 8375 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES, 8376 nla_get_u8); 8377 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, mask, 8378 NL80211_MESHCONF_PATH_REFRESH_TIME, 8379 nla_get_u32); 8380 if (mask & BIT(NL80211_MESHCONF_PATH_REFRESH_TIME) && 8381 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535)) 8382 return -EINVAL; 8383 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, mask, 8384 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT, 8385 nla_get_u16); 8386 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout, 8387 mask, 8388 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT, 8389 nla_get_u32); 8390 if (mask & BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT) && 8391 (cfg->dot11MeshHWMPactivePathTimeout < 1 || 8392 cfg->dot11MeshHWMPactivePathTimeout > 65535)) 8393 return -EINVAL; 8394 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, mask, 8395 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL, 8396 nla_get_u16); 8397 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval, mask, 8398 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL, 8399 nla_get_u16); 8400 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, 8401 dot11MeshHWMPnetDiameterTraversalTime, mask, 8402 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME, 8403 nla_get_u16); 8404 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask, 8405 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8); 8406 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask, 8407 NL80211_MESHCONF_HWMP_RANN_INTERVAL, 8408 nla_get_u16); 8409 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshGateAnnouncementProtocol, 8410 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS, 8411 nla_get_u8); 8412 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, mask, 8413 NL80211_MESHCONF_FORWARDING, nla_get_u8); 8414 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, mask, 8415 NL80211_MESHCONF_RSSI_THRESHOLD, 8416 nla_get_s32); 8417 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToMeshGate, mask, 8418 NL80211_MESHCONF_CONNECTED_TO_GATE, 8419 nla_get_u8); 8420 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToAuthServer, mask, 8421 NL80211_MESHCONF_CONNECTED_TO_AS, 8422 nla_get_u8); 8423 /* 8424 * Check HT operation mode based on 8425 * IEEE 802.11-2016 9.4.2.57 HT Operation element. 8426 */ 8427 if (tb[NL80211_MESHCONF_HT_OPMODE]) { 8428 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]); 8429 8430 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION | 8431 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT | 8432 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT)) 8433 return -EINVAL; 8434 8435 /* NON_HT_STA bit is reserved, but some programs set it */ 8436 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT; 8437 8438 cfg->ht_opmode = ht_opmode; 8439 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1)); 8440 } 8441 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, 8442 dot11MeshHWMPactivePathToRootTimeout, mask, 8443 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT, 8444 nla_get_u32); 8445 if (mask & BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT) && 8446 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 || 8447 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535)) 8448 return -EINVAL; 8449 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, mask, 8450 NL80211_MESHCONF_HWMP_ROOT_INTERVAL, 8451 nla_get_u16); 8452 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPconfirmationInterval, 8453 mask, 8454 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL, 8455 nla_get_u16); 8456 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode, mask, 8457 NL80211_MESHCONF_POWER_MODE, nla_get_u32); 8458 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration, mask, 8459 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16); 8460 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, mask, 8461 NL80211_MESHCONF_PLINK_TIMEOUT, nla_get_u32); 8462 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNolearn, mask, 8463 NL80211_MESHCONF_NOLEARN, nla_get_u8); 8464 if (mask_out) 8465 *mask_out = mask; 8466 8467 return 0; 8468 8469 #undef FILL_IN_MESH_PARAM_IF_SET 8470 } 8471 8472 static int nl80211_parse_mesh_setup(struct genl_info *info, 8473 struct mesh_setup *setup) 8474 { 8475 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 8476 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1]; 8477 8478 if (!info->attrs[NL80211_ATTR_MESH_SETUP]) 8479 return -EINVAL; 8480 if (nla_parse_nested_deprecated(tb, NL80211_MESH_SETUP_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_SETUP], nl80211_mesh_setup_params_policy, info->extack)) 8481 return -EINVAL; 8482 8483 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC]) 8484 setup->sync_method = 8485 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ? 8486 IEEE80211_SYNC_METHOD_VENDOR : 8487 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET; 8488 8489 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL]) 8490 setup->path_sel_proto = 8491 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ? 8492 IEEE80211_PATH_PROTOCOL_VENDOR : 8493 IEEE80211_PATH_PROTOCOL_HWMP; 8494 8495 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC]) 8496 setup->path_metric = 8497 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ? 8498 IEEE80211_PATH_METRIC_VENDOR : 8499 IEEE80211_PATH_METRIC_AIRTIME; 8500 8501 if (tb[NL80211_MESH_SETUP_IE]) { 8502 struct nlattr *ieattr = 8503 tb[NL80211_MESH_SETUP_IE]; 8504 setup->ie = nla_data(ieattr); 8505 setup->ie_len = nla_len(ieattr); 8506 } 8507 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] && 8508 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM)) 8509 return -EINVAL; 8510 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]); 8511 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]); 8512 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]); 8513 if (setup->is_secure) 8514 setup->user_mpm = true; 8515 8516 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) { 8517 if (!setup->user_mpm) 8518 return -EINVAL; 8519 setup->auth_id = 8520 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]); 8521 } 8522 8523 return 0; 8524 } 8525 8526 static int nl80211_update_mesh_config(struct sk_buff *skb, 8527 struct genl_info *info) 8528 { 8529 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 8530 struct net_device *dev = info->user_ptr[1]; 8531 struct wireless_dev *wdev = dev->ieee80211_ptr; 8532 struct mesh_config cfg = {}; 8533 u32 mask; 8534 int err; 8535 8536 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) 8537 return -EOPNOTSUPP; 8538 8539 if (!rdev->ops->update_mesh_config) 8540 return -EOPNOTSUPP; 8541 8542 err = nl80211_parse_mesh_config(info, &cfg, &mask); 8543 if (err) 8544 return err; 8545 8546 wdev_lock(wdev); 8547 if (!wdev->u.mesh.id_len) 8548 err = -ENOLINK; 8549 8550 if (!err) 8551 err = rdev_update_mesh_config(rdev, dev, mask, &cfg); 8552 8553 wdev_unlock(wdev); 8554 8555 return err; 8556 } 8557 8558 static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom, 8559 struct sk_buff *msg) 8560 { 8561 struct nlattr *nl_reg_rules; 8562 unsigned int i; 8563 8564 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) || 8565 (regdom->dfs_region && 8566 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region))) 8567 goto nla_put_failure; 8568 8569 nl_reg_rules = nla_nest_start_noflag(msg, NL80211_ATTR_REG_RULES); 8570 if (!nl_reg_rules) 8571 goto nla_put_failure; 8572 8573 for (i = 0; i < regdom->n_reg_rules; i++) { 8574 struct nlattr *nl_reg_rule; 8575 const struct ieee80211_reg_rule *reg_rule; 8576 const struct ieee80211_freq_range *freq_range; 8577 const struct ieee80211_power_rule *power_rule; 8578 unsigned int max_bandwidth_khz; 8579 8580 reg_rule = ®dom->reg_rules[i]; 8581 freq_range = ®_rule->freq_range; 8582 power_rule = ®_rule->power_rule; 8583 8584 nl_reg_rule = nla_nest_start_noflag(msg, i); 8585 if (!nl_reg_rule) 8586 goto nla_put_failure; 8587 8588 max_bandwidth_khz = freq_range->max_bandwidth_khz; 8589 if (!max_bandwidth_khz) 8590 max_bandwidth_khz = reg_get_max_bandwidth(regdom, 8591 reg_rule); 8592 8593 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS, 8594 reg_rule->flags) || 8595 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START, 8596 freq_range->start_freq_khz) || 8597 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END, 8598 freq_range->end_freq_khz) || 8599 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW, 8600 max_bandwidth_khz) || 8601 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN, 8602 power_rule->max_antenna_gain) || 8603 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP, 8604 power_rule->max_eirp) || 8605 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME, 8606 reg_rule->dfs_cac_ms)) 8607 goto nla_put_failure; 8608 8609 nla_nest_end(msg, nl_reg_rule); 8610 } 8611 8612 nla_nest_end(msg, nl_reg_rules); 8613 return 0; 8614 8615 nla_put_failure: 8616 return -EMSGSIZE; 8617 } 8618 8619 static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info) 8620 { 8621 const struct ieee80211_regdomain *regdom = NULL; 8622 struct cfg80211_registered_device *rdev; 8623 struct wiphy *wiphy = NULL; 8624 struct sk_buff *msg; 8625 int err = -EMSGSIZE; 8626 void *hdr; 8627 8628 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 8629 if (!msg) 8630 return -ENOBUFS; 8631 8632 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 8633 NL80211_CMD_GET_REG); 8634 if (!hdr) 8635 goto put_failure; 8636 8637 rtnl_lock(); 8638 8639 if (info->attrs[NL80211_ATTR_WIPHY]) { 8640 bool self_managed; 8641 8642 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info); 8643 if (IS_ERR(rdev)) { 8644 err = PTR_ERR(rdev); 8645 goto nla_put_failure; 8646 } 8647 8648 wiphy = &rdev->wiphy; 8649 self_managed = wiphy->regulatory_flags & 8650 REGULATORY_WIPHY_SELF_MANAGED; 8651 8652 rcu_read_lock(); 8653 8654 regdom = get_wiphy_regdom(wiphy); 8655 8656 /* a self-managed-reg device must have a private regdom */ 8657 if (WARN_ON(!regdom && self_managed)) { 8658 err = -EINVAL; 8659 goto nla_put_failure_rcu; 8660 } 8661 8662 if (regdom && 8663 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy))) 8664 goto nla_put_failure_rcu; 8665 } else { 8666 rcu_read_lock(); 8667 } 8668 8669 if (!wiphy && reg_last_request_cell_base() && 8670 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE, 8671 NL80211_USER_REG_HINT_CELL_BASE)) 8672 goto nla_put_failure_rcu; 8673 8674 if (!regdom) 8675 regdom = rcu_dereference(cfg80211_regdomain); 8676 8677 if (nl80211_put_regdom(regdom, msg)) 8678 goto nla_put_failure_rcu; 8679 8680 rcu_read_unlock(); 8681 8682 genlmsg_end(msg, hdr); 8683 rtnl_unlock(); 8684 return genlmsg_reply(msg, info); 8685 8686 nla_put_failure_rcu: 8687 rcu_read_unlock(); 8688 nla_put_failure: 8689 rtnl_unlock(); 8690 put_failure: 8691 nlmsg_free(msg); 8692 return err; 8693 } 8694 8695 static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb, 8696 u32 seq, int flags, struct wiphy *wiphy, 8697 const struct ieee80211_regdomain *regdom) 8698 { 8699 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags, 8700 NL80211_CMD_GET_REG); 8701 8702 if (!hdr) 8703 return -1; 8704 8705 genl_dump_check_consistent(cb, hdr); 8706 8707 if (nl80211_put_regdom(regdom, msg)) 8708 goto nla_put_failure; 8709 8710 if (!wiphy && reg_last_request_cell_base() && 8711 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE, 8712 NL80211_USER_REG_HINT_CELL_BASE)) 8713 goto nla_put_failure; 8714 8715 if (wiphy && 8716 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy))) 8717 goto nla_put_failure; 8718 8719 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED && 8720 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG)) 8721 goto nla_put_failure; 8722 8723 genlmsg_end(msg, hdr); 8724 return 0; 8725 8726 nla_put_failure: 8727 genlmsg_cancel(msg, hdr); 8728 return -EMSGSIZE; 8729 } 8730 8731 static int nl80211_get_reg_dump(struct sk_buff *skb, 8732 struct netlink_callback *cb) 8733 { 8734 const struct ieee80211_regdomain *regdom = NULL; 8735 struct cfg80211_registered_device *rdev; 8736 int err, reg_idx, start = cb->args[2]; 8737 8738 rcu_read_lock(); 8739 8740 if (cfg80211_regdomain && start == 0) { 8741 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq, 8742 NLM_F_MULTI, NULL, 8743 rcu_dereference(cfg80211_regdomain)); 8744 if (err < 0) 8745 goto out_err; 8746 } 8747 8748 /* the global regdom is idx 0 */ 8749 reg_idx = 1; 8750 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) { 8751 regdom = get_wiphy_regdom(&rdev->wiphy); 8752 if (!regdom) 8753 continue; 8754 8755 if (++reg_idx <= start) 8756 continue; 8757 8758 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq, 8759 NLM_F_MULTI, &rdev->wiphy, regdom); 8760 if (err < 0) { 8761 reg_idx--; 8762 break; 8763 } 8764 } 8765 8766 cb->args[2] = reg_idx; 8767 err = skb->len; 8768 out_err: 8769 rcu_read_unlock(); 8770 return err; 8771 } 8772 8773 #ifdef CONFIG_CFG80211_CRDA_SUPPORT 8774 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = { 8775 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 }, 8776 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 }, 8777 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 }, 8778 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 }, 8779 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 }, 8780 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 }, 8781 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 }, 8782 }; 8783 8784 static int parse_reg_rule(struct nlattr *tb[], 8785 struct ieee80211_reg_rule *reg_rule) 8786 { 8787 struct ieee80211_freq_range *freq_range = ®_rule->freq_range; 8788 struct ieee80211_power_rule *power_rule = ®_rule->power_rule; 8789 8790 if (!tb[NL80211_ATTR_REG_RULE_FLAGS]) 8791 return -EINVAL; 8792 if (!tb[NL80211_ATTR_FREQ_RANGE_START]) 8793 return -EINVAL; 8794 if (!tb[NL80211_ATTR_FREQ_RANGE_END]) 8795 return -EINVAL; 8796 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]) 8797 return -EINVAL; 8798 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]) 8799 return -EINVAL; 8800 8801 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]); 8802 8803 freq_range->start_freq_khz = 8804 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]); 8805 freq_range->end_freq_khz = 8806 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]); 8807 freq_range->max_bandwidth_khz = 8808 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]); 8809 8810 power_rule->max_eirp = 8811 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]); 8812 8813 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]) 8814 power_rule->max_antenna_gain = 8815 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]); 8816 8817 if (tb[NL80211_ATTR_DFS_CAC_TIME]) 8818 reg_rule->dfs_cac_ms = 8819 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]); 8820 8821 return 0; 8822 } 8823 8824 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info) 8825 { 8826 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1]; 8827 struct nlattr *nl_reg_rule; 8828 char *alpha2; 8829 int rem_reg_rules, r; 8830 u32 num_rules = 0, rule_idx = 0; 8831 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET; 8832 struct ieee80211_regdomain *rd; 8833 8834 if (!info->attrs[NL80211_ATTR_REG_ALPHA2]) 8835 return -EINVAL; 8836 8837 if (!info->attrs[NL80211_ATTR_REG_RULES]) 8838 return -EINVAL; 8839 8840 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]); 8841 8842 if (info->attrs[NL80211_ATTR_DFS_REGION]) 8843 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]); 8844 8845 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES], 8846 rem_reg_rules) { 8847 num_rules++; 8848 if (num_rules > NL80211_MAX_SUPP_REG_RULES) 8849 return -EINVAL; 8850 } 8851 8852 rtnl_lock(); 8853 if (!reg_is_valid_request(alpha2)) { 8854 r = -EINVAL; 8855 goto out; 8856 } 8857 8858 rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL); 8859 if (!rd) { 8860 r = -ENOMEM; 8861 goto out; 8862 } 8863 8864 rd->n_reg_rules = num_rules; 8865 rd->alpha2[0] = alpha2[0]; 8866 rd->alpha2[1] = alpha2[1]; 8867 8868 /* 8869 * Disable DFS master mode if the DFS region was 8870 * not supported or known on this kernel. 8871 */ 8872 if (reg_supported_dfs_region(dfs_region)) 8873 rd->dfs_region = dfs_region; 8874 8875 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES], 8876 rem_reg_rules) { 8877 r = nla_parse_nested_deprecated(tb, NL80211_REG_RULE_ATTR_MAX, 8878 nl_reg_rule, reg_rule_policy, 8879 info->extack); 8880 if (r) 8881 goto bad_reg; 8882 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]); 8883 if (r) 8884 goto bad_reg; 8885 8886 rule_idx++; 8887 8888 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) { 8889 r = -EINVAL; 8890 goto bad_reg; 8891 } 8892 } 8893 8894 r = set_regdom(rd, REGD_SOURCE_CRDA); 8895 /* set_regdom takes ownership of rd */ 8896 rd = NULL; 8897 bad_reg: 8898 kfree(rd); 8899 out: 8900 rtnl_unlock(); 8901 return r; 8902 } 8903 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */ 8904 8905 static int validate_scan_freqs(struct nlattr *freqs) 8906 { 8907 struct nlattr *attr1, *attr2; 8908 int n_channels = 0, tmp1, tmp2; 8909 8910 nla_for_each_nested(attr1, freqs, tmp1) 8911 if (nla_len(attr1) != sizeof(u32)) 8912 return 0; 8913 8914 nla_for_each_nested(attr1, freqs, tmp1) { 8915 n_channels++; 8916 /* 8917 * Some hardware has a limited channel list for 8918 * scanning, and it is pretty much nonsensical 8919 * to scan for a channel twice, so disallow that 8920 * and don't require drivers to check that the 8921 * channel list they get isn't longer than what 8922 * they can scan, as long as they can scan all 8923 * the channels they registered at once. 8924 */ 8925 nla_for_each_nested(attr2, freqs, tmp2) 8926 if (attr1 != attr2 && 8927 nla_get_u32(attr1) == nla_get_u32(attr2)) 8928 return 0; 8929 } 8930 8931 return n_channels; 8932 } 8933 8934 static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b) 8935 { 8936 return b < NUM_NL80211_BANDS && wiphy->bands[b]; 8937 } 8938 8939 static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy, 8940 struct cfg80211_bss_selection *bss_select) 8941 { 8942 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1]; 8943 struct nlattr *nest; 8944 int err; 8945 bool found = false; 8946 int i; 8947 8948 /* only process one nested attribute */ 8949 nest = nla_data(nla); 8950 if (!nla_ok(nest, nla_len(nest))) 8951 return -EINVAL; 8952 8953 err = nla_parse_nested_deprecated(attr, NL80211_BSS_SELECT_ATTR_MAX, 8954 nest, nl80211_bss_select_policy, 8955 NULL); 8956 if (err) 8957 return err; 8958 8959 /* only one attribute may be given */ 8960 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) { 8961 if (attr[i]) { 8962 if (found) 8963 return -EINVAL; 8964 found = true; 8965 } 8966 } 8967 8968 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID; 8969 8970 if (attr[NL80211_BSS_SELECT_ATTR_RSSI]) 8971 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI; 8972 8973 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) { 8974 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF; 8975 bss_select->param.band_pref = 8976 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]); 8977 if (!is_band_valid(wiphy, bss_select->param.band_pref)) 8978 return -EINVAL; 8979 } 8980 8981 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) { 8982 struct nl80211_bss_select_rssi_adjust *adj_param; 8983 8984 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]); 8985 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST; 8986 bss_select->param.adjust.band = adj_param->band; 8987 bss_select->param.adjust.delta = adj_param->delta; 8988 if (!is_band_valid(wiphy, bss_select->param.adjust.band)) 8989 return -EINVAL; 8990 } 8991 8992 /* user-space did not provide behaviour attribute */ 8993 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID) 8994 return -EINVAL; 8995 8996 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour))) 8997 return -EINVAL; 8998 8999 return 0; 9000 } 9001 9002 int nl80211_parse_random_mac(struct nlattr **attrs, 9003 u8 *mac_addr, u8 *mac_addr_mask) 9004 { 9005 int i; 9006 9007 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) { 9008 eth_zero_addr(mac_addr); 9009 eth_zero_addr(mac_addr_mask); 9010 mac_addr[0] = 0x2; 9011 mac_addr_mask[0] = 0x3; 9012 9013 return 0; 9014 } 9015 9016 /* need both or none */ 9017 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK]) 9018 return -EINVAL; 9019 9020 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN); 9021 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN); 9022 9023 /* don't allow or configure an mcast address */ 9024 if (!is_multicast_ether_addr(mac_addr_mask) || 9025 is_multicast_ether_addr(mac_addr)) 9026 return -EINVAL; 9027 9028 /* 9029 * allow users to pass a MAC address that has bits set outside 9030 * of the mask, but don't bother drivers with having to deal 9031 * with such bits 9032 */ 9033 for (i = 0; i < ETH_ALEN; i++) 9034 mac_addr[i] &= mac_addr_mask[i]; 9035 9036 return 0; 9037 } 9038 9039 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev, 9040 struct ieee80211_channel *chan) 9041 { 9042 unsigned int link_id; 9043 bool all_ok = true; 9044 9045 ASSERT_WDEV_LOCK(wdev); 9046 9047 if (!cfg80211_beaconing_iface_active(wdev)) 9048 return true; 9049 9050 /* 9051 * FIXME: check if we have a free HW resource/link for chan 9052 * 9053 * This, as well as the FIXME below, requires knowing the link 9054 * capabilities of the hardware. 9055 */ 9056 9057 /* we cannot leave radar channels */ 9058 for_each_valid_link(wdev, link_id) { 9059 struct cfg80211_chan_def *chandef; 9060 9061 chandef = wdev_chandef(wdev, link_id); 9062 if (!chandef || !chandef->chan) 9063 continue; 9064 9065 /* 9066 * FIXME: don't require all_ok, but rather check only the 9067 * correct HW resource/link onto which 'chan' falls, 9068 * as only that link leaves the channel for doing 9069 * the off-channel operation. 9070 */ 9071 9072 if (chandef->chan->flags & IEEE80211_CHAN_RADAR) 9073 all_ok = false; 9074 } 9075 9076 if (all_ok) 9077 return true; 9078 9079 return regulatory_pre_cac_allowed(wdev->wiphy); 9080 } 9081 9082 static bool nl80211_check_scan_feat(struct wiphy *wiphy, u32 flags, u32 flag, 9083 enum nl80211_ext_feature_index feat) 9084 { 9085 if (!(flags & flag)) 9086 return true; 9087 if (wiphy_ext_feature_isset(wiphy, feat)) 9088 return true; 9089 return false; 9090 } 9091 9092 static int 9093 nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev, 9094 void *request, struct nlattr **attrs, 9095 bool is_sched_scan) 9096 { 9097 u8 *mac_addr, *mac_addr_mask; 9098 u32 *flags; 9099 enum nl80211_feature_flags randomness_flag; 9100 9101 if (!attrs[NL80211_ATTR_SCAN_FLAGS]) 9102 return 0; 9103 9104 if (is_sched_scan) { 9105 struct cfg80211_sched_scan_request *req = request; 9106 9107 randomness_flag = wdev ? 9108 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR : 9109 NL80211_FEATURE_ND_RANDOM_MAC_ADDR; 9110 flags = &req->flags; 9111 mac_addr = req->mac_addr; 9112 mac_addr_mask = req->mac_addr_mask; 9113 } else { 9114 struct cfg80211_scan_request *req = request; 9115 9116 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 9117 flags = &req->flags; 9118 mac_addr = req->mac_addr; 9119 mac_addr_mask = req->mac_addr_mask; 9120 } 9121 9122 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]); 9123 9124 if (((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) && 9125 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) || 9126 !nl80211_check_scan_feat(wiphy, *flags, 9127 NL80211_SCAN_FLAG_LOW_SPAN, 9128 NL80211_EXT_FEATURE_LOW_SPAN_SCAN) || 9129 !nl80211_check_scan_feat(wiphy, *flags, 9130 NL80211_SCAN_FLAG_LOW_POWER, 9131 NL80211_EXT_FEATURE_LOW_POWER_SCAN) || 9132 !nl80211_check_scan_feat(wiphy, *flags, 9133 NL80211_SCAN_FLAG_HIGH_ACCURACY, 9134 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN) || 9135 !nl80211_check_scan_feat(wiphy, *flags, 9136 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME, 9137 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) || 9138 !nl80211_check_scan_feat(wiphy, *flags, 9139 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP, 9140 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) || 9141 !nl80211_check_scan_feat(wiphy, *flags, 9142 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION, 9143 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) || 9144 !nl80211_check_scan_feat(wiphy, *flags, 9145 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE, 9146 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) || 9147 !nl80211_check_scan_feat(wiphy, *flags, 9148 NL80211_SCAN_FLAG_RANDOM_SN, 9149 NL80211_EXT_FEATURE_SCAN_RANDOM_SN) || 9150 !nl80211_check_scan_feat(wiphy, *flags, 9151 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT, 9152 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT)) 9153 return -EOPNOTSUPP; 9154 9155 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) { 9156 int err; 9157 9158 if (!(wiphy->features & randomness_flag) || 9159 (wdev && wdev->connected)) 9160 return -EOPNOTSUPP; 9161 9162 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask); 9163 if (err) 9164 return err; 9165 } 9166 9167 return 0; 9168 } 9169 9170 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info) 9171 { 9172 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 9173 struct wireless_dev *wdev = info->user_ptr[1]; 9174 struct cfg80211_scan_request *request; 9175 struct nlattr *scan_freqs = NULL; 9176 bool scan_freqs_khz = false; 9177 struct nlattr *attr; 9178 struct wiphy *wiphy; 9179 int err, tmp, n_ssids = 0, n_channels, i; 9180 size_t ie_len, size; 9181 size_t ssids_offset, ie_offset; 9182 9183 wiphy = &rdev->wiphy; 9184 9185 if (wdev->iftype == NL80211_IFTYPE_NAN) 9186 return -EOPNOTSUPP; 9187 9188 if (!rdev->ops->scan) 9189 return -EOPNOTSUPP; 9190 9191 if (rdev->scan_req || rdev->scan_msg) 9192 return -EBUSY; 9193 9194 if (info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ]) { 9195 if (!wiphy_ext_feature_isset(wiphy, 9196 NL80211_EXT_FEATURE_SCAN_FREQ_KHZ)) 9197 return -EOPNOTSUPP; 9198 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQ_KHZ]; 9199 scan_freqs_khz = true; 9200 } else if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) 9201 scan_freqs = info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]; 9202 9203 if (scan_freqs) { 9204 n_channels = validate_scan_freqs(scan_freqs); 9205 if (!n_channels) 9206 return -EINVAL; 9207 } else { 9208 n_channels = ieee80211_get_num_supported_channels(wiphy); 9209 } 9210 9211 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) 9212 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) 9213 n_ssids++; 9214 9215 if (n_ssids > wiphy->max_scan_ssids) 9216 return -EINVAL; 9217 9218 if (info->attrs[NL80211_ATTR_IE]) 9219 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 9220 else 9221 ie_len = 0; 9222 9223 if (ie_len > wiphy->max_scan_ie_len) 9224 return -EINVAL; 9225 9226 size = struct_size(request, channels, n_channels); 9227 ssids_offset = size; 9228 size = size_add(size, array_size(sizeof(*request->ssids), n_ssids)); 9229 ie_offset = size; 9230 size = size_add(size, ie_len); 9231 request = kzalloc(size, GFP_KERNEL); 9232 if (!request) 9233 return -ENOMEM; 9234 request->n_channels = n_channels; 9235 9236 if (n_ssids) 9237 request->ssids = (void *)request + ssids_offset; 9238 request->n_ssids = n_ssids; 9239 if (ie_len) 9240 request->ie = (void *)request + ie_offset; 9241 9242 i = 0; 9243 if (scan_freqs) { 9244 /* user specified, bail out if channel not found */ 9245 nla_for_each_nested(attr, scan_freqs, tmp) { 9246 struct ieee80211_channel *chan; 9247 int freq = nla_get_u32(attr); 9248 9249 if (!scan_freqs_khz) 9250 freq = MHZ_TO_KHZ(freq); 9251 9252 chan = ieee80211_get_channel_khz(wiphy, freq); 9253 if (!chan) { 9254 err = -EINVAL; 9255 goto out_free; 9256 } 9257 9258 /* ignore disabled channels */ 9259 if (chan->flags & IEEE80211_CHAN_DISABLED) 9260 continue; 9261 9262 request->channels[i] = chan; 9263 i++; 9264 } 9265 } else { 9266 enum nl80211_band band; 9267 9268 /* all channels */ 9269 for (band = 0; band < NUM_NL80211_BANDS; band++) { 9270 int j; 9271 9272 if (!wiphy->bands[band]) 9273 continue; 9274 for (j = 0; j < wiphy->bands[band]->n_channels; j++) { 9275 struct ieee80211_channel *chan; 9276 9277 chan = &wiphy->bands[band]->channels[j]; 9278 9279 if (chan->flags & IEEE80211_CHAN_DISABLED) 9280 continue; 9281 9282 request->channels[i] = chan; 9283 i++; 9284 } 9285 } 9286 } 9287 9288 if (!i) { 9289 err = -EINVAL; 9290 goto out_free; 9291 } 9292 9293 request->n_channels = i; 9294 9295 wdev_lock(wdev); 9296 for (i = 0; i < request->n_channels; i++) { 9297 struct ieee80211_channel *chan = request->channels[i]; 9298 9299 /* if we can go off-channel to the target channel we're good */ 9300 if (cfg80211_off_channel_oper_allowed(wdev, chan)) 9301 continue; 9302 9303 if (!cfg80211_wdev_on_sub_chan(wdev, chan, true)) { 9304 wdev_unlock(wdev); 9305 err = -EBUSY; 9306 goto out_free; 9307 } 9308 } 9309 wdev_unlock(wdev); 9310 9311 i = 0; 9312 if (n_ssids) { 9313 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) { 9314 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) { 9315 err = -EINVAL; 9316 goto out_free; 9317 } 9318 request->ssids[i].ssid_len = nla_len(attr); 9319 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr)); 9320 i++; 9321 } 9322 } 9323 9324 if (info->attrs[NL80211_ATTR_IE]) { 9325 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 9326 memcpy((void *)request->ie, 9327 nla_data(info->attrs[NL80211_ATTR_IE]), 9328 request->ie_len); 9329 } 9330 9331 for (i = 0; i < NUM_NL80211_BANDS; i++) 9332 if (wiphy->bands[i]) 9333 request->rates[i] = 9334 (1 << wiphy->bands[i]->n_bitrates) - 1; 9335 9336 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) { 9337 nla_for_each_nested(attr, 9338 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES], 9339 tmp) { 9340 enum nl80211_band band = nla_type(attr); 9341 9342 if (band < 0 || band >= NUM_NL80211_BANDS) { 9343 err = -EINVAL; 9344 goto out_free; 9345 } 9346 9347 if (!wiphy->bands[band]) 9348 continue; 9349 9350 err = ieee80211_get_ratemask(wiphy->bands[band], 9351 nla_data(attr), 9352 nla_len(attr), 9353 &request->rates[band]); 9354 if (err) 9355 goto out_free; 9356 } 9357 } 9358 9359 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) { 9360 request->duration = 9361 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]); 9362 request->duration_mandatory = 9363 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]); 9364 } 9365 9366 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs, 9367 false); 9368 if (err) 9369 goto out_free; 9370 9371 request->no_cck = 9372 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]); 9373 9374 /* Initial implementation used NL80211_ATTR_MAC to set the specific 9375 * BSSID to scan for. This was problematic because that same attribute 9376 * was already used for another purpose (local random MAC address). The 9377 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards 9378 * compatibility with older userspace components, also use the 9379 * NL80211_ATTR_MAC value here if it can be determined to be used for 9380 * the specific BSSID use case instead of the random MAC address 9381 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use). 9382 */ 9383 if (info->attrs[NL80211_ATTR_BSSID]) 9384 memcpy(request->bssid, 9385 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN); 9386 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) && 9387 info->attrs[NL80211_ATTR_MAC]) 9388 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]), 9389 ETH_ALEN); 9390 else 9391 eth_broadcast_addr(request->bssid); 9392 9393 request->wdev = wdev; 9394 request->wiphy = &rdev->wiphy; 9395 request->scan_start = jiffies; 9396 9397 rdev->scan_req = request; 9398 err = cfg80211_scan(rdev); 9399 9400 if (err) 9401 goto out_free; 9402 9403 nl80211_send_scan_start(rdev, wdev); 9404 dev_hold(wdev->netdev); 9405 9406 return 0; 9407 9408 out_free: 9409 rdev->scan_req = NULL; 9410 kfree(request); 9411 9412 return err; 9413 } 9414 9415 static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info) 9416 { 9417 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 9418 struct wireless_dev *wdev = info->user_ptr[1]; 9419 9420 if (!rdev->ops->abort_scan) 9421 return -EOPNOTSUPP; 9422 9423 if (rdev->scan_msg) 9424 return 0; 9425 9426 if (!rdev->scan_req) 9427 return -ENOENT; 9428 9429 rdev_abort_scan(rdev, wdev); 9430 return 0; 9431 } 9432 9433 static int 9434 nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans, 9435 struct cfg80211_sched_scan_request *request, 9436 struct nlattr **attrs) 9437 { 9438 int tmp, err, i = 0; 9439 struct nlattr *attr; 9440 9441 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) { 9442 u32 interval; 9443 9444 /* 9445 * If scan plans are not specified, 9446 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this 9447 * case one scan plan will be set with the specified scan 9448 * interval and infinite number of iterations. 9449 */ 9450 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]); 9451 if (!interval) 9452 return -EINVAL; 9453 9454 request->scan_plans[0].interval = 9455 DIV_ROUND_UP(interval, MSEC_PER_SEC); 9456 if (!request->scan_plans[0].interval) 9457 return -EINVAL; 9458 9459 if (request->scan_plans[0].interval > 9460 wiphy->max_sched_scan_plan_interval) 9461 request->scan_plans[0].interval = 9462 wiphy->max_sched_scan_plan_interval; 9463 9464 return 0; 9465 } 9466 9467 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) { 9468 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1]; 9469 9470 if (WARN_ON(i >= n_plans)) 9471 return -EINVAL; 9472 9473 err = nla_parse_nested_deprecated(plan, 9474 NL80211_SCHED_SCAN_PLAN_MAX, 9475 attr, nl80211_plan_policy, 9476 NULL); 9477 if (err) 9478 return err; 9479 9480 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]) 9481 return -EINVAL; 9482 9483 request->scan_plans[i].interval = 9484 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]); 9485 if (!request->scan_plans[i].interval || 9486 request->scan_plans[i].interval > 9487 wiphy->max_sched_scan_plan_interval) 9488 return -EINVAL; 9489 9490 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) { 9491 request->scan_plans[i].iterations = 9492 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]); 9493 if (!request->scan_plans[i].iterations || 9494 (request->scan_plans[i].iterations > 9495 wiphy->max_sched_scan_plan_iterations)) 9496 return -EINVAL; 9497 } else if (i < n_plans - 1) { 9498 /* 9499 * All scan plans but the last one must specify 9500 * a finite number of iterations 9501 */ 9502 return -EINVAL; 9503 } 9504 9505 i++; 9506 } 9507 9508 /* 9509 * The last scan plan must not specify the number of 9510 * iterations, it is supposed to run infinitely 9511 */ 9512 if (request->scan_plans[n_plans - 1].iterations) 9513 return -EINVAL; 9514 9515 return 0; 9516 } 9517 9518 static int 9519 nl80211_parse_sched_scan_per_band_rssi(struct wiphy *wiphy, 9520 struct cfg80211_match_set *match_sets, 9521 struct nlattr *tb_band_rssi, 9522 s32 rssi_thold) 9523 { 9524 struct nlattr *attr; 9525 int i, tmp, ret = 0; 9526 9527 if (!wiphy_ext_feature_isset(wiphy, 9528 NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD)) { 9529 if (tb_band_rssi) 9530 ret = -EOPNOTSUPP; 9531 else 9532 for (i = 0; i < NUM_NL80211_BANDS; i++) 9533 match_sets->per_band_rssi_thold[i] = 9534 NL80211_SCAN_RSSI_THOLD_OFF; 9535 return ret; 9536 } 9537 9538 for (i = 0; i < NUM_NL80211_BANDS; i++) 9539 match_sets->per_band_rssi_thold[i] = rssi_thold; 9540 9541 nla_for_each_nested(attr, tb_band_rssi, tmp) { 9542 enum nl80211_band band = nla_type(attr); 9543 9544 if (band < 0 || band >= NUM_NL80211_BANDS) 9545 return -EINVAL; 9546 9547 match_sets->per_band_rssi_thold[band] = nla_get_s32(attr); 9548 } 9549 9550 return 0; 9551 } 9552 9553 static struct cfg80211_sched_scan_request * 9554 nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev, 9555 struct nlattr **attrs, int max_match_sets) 9556 { 9557 struct cfg80211_sched_scan_request *request; 9558 struct nlattr *attr; 9559 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0; 9560 enum nl80211_band band; 9561 size_t ie_len, size; 9562 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1]; 9563 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF; 9564 9565 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) { 9566 n_channels = validate_scan_freqs( 9567 attrs[NL80211_ATTR_SCAN_FREQUENCIES]); 9568 if (!n_channels) 9569 return ERR_PTR(-EINVAL); 9570 } else { 9571 n_channels = ieee80211_get_num_supported_channels(wiphy); 9572 } 9573 9574 if (attrs[NL80211_ATTR_SCAN_SSIDS]) 9575 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS], 9576 tmp) 9577 n_ssids++; 9578 9579 if (n_ssids > wiphy->max_sched_scan_ssids) 9580 return ERR_PTR(-EINVAL); 9581 9582 /* 9583 * First, count the number of 'real' matchsets. Due to an issue with 9584 * the old implementation, matchsets containing only the RSSI attribute 9585 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default' 9586 * RSSI for all matchsets, rather than their own matchset for reporting 9587 * all APs with a strong RSSI. This is needed to be compatible with 9588 * older userspace that treated a matchset with only the RSSI as the 9589 * global RSSI for all other matchsets - if there are other matchsets. 9590 */ 9591 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) { 9592 nla_for_each_nested(attr, 9593 attrs[NL80211_ATTR_SCHED_SCAN_MATCH], 9594 tmp) { 9595 struct nlattr *rssi; 9596 9597 err = nla_parse_nested_deprecated(tb, 9598 NL80211_SCHED_SCAN_MATCH_ATTR_MAX, 9599 attr, 9600 nl80211_match_policy, 9601 NULL); 9602 if (err) 9603 return ERR_PTR(err); 9604 9605 /* SSID and BSSID are mutually exclusive */ 9606 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] && 9607 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) 9608 return ERR_PTR(-EINVAL); 9609 9610 /* add other standalone attributes here */ 9611 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] || 9612 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) { 9613 n_match_sets++; 9614 continue; 9615 } 9616 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI]; 9617 if (rssi) 9618 default_match_rssi = nla_get_s32(rssi); 9619 } 9620 } 9621 9622 /* However, if there's no other matchset, add the RSSI one */ 9623 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF) 9624 n_match_sets = 1; 9625 9626 if (n_match_sets > max_match_sets) 9627 return ERR_PTR(-EINVAL); 9628 9629 if (attrs[NL80211_ATTR_IE]) 9630 ie_len = nla_len(attrs[NL80211_ATTR_IE]); 9631 else 9632 ie_len = 0; 9633 9634 if (ie_len > wiphy->max_sched_scan_ie_len) 9635 return ERR_PTR(-EINVAL); 9636 9637 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) { 9638 /* 9639 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since 9640 * each scan plan already specifies its own interval 9641 */ 9642 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]) 9643 return ERR_PTR(-EINVAL); 9644 9645 nla_for_each_nested(attr, 9646 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) 9647 n_plans++; 9648 } else { 9649 /* 9650 * The scan interval attribute is kept for backward 9651 * compatibility. If no scan plans are specified and sched scan 9652 * interval is specified, one scan plan will be set with this 9653 * scan interval and infinite number of iterations. 9654 */ 9655 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]) 9656 return ERR_PTR(-EINVAL); 9657 9658 n_plans = 1; 9659 } 9660 9661 if (!n_plans || n_plans > wiphy->max_sched_scan_plans) 9662 return ERR_PTR(-EINVAL); 9663 9664 if (!wiphy_ext_feature_isset( 9665 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) && 9666 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] || 9667 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST])) 9668 return ERR_PTR(-EINVAL); 9669 9670 size = struct_size(request, channels, n_channels); 9671 size = size_add(size, array_size(sizeof(*request->ssids), n_ssids)); 9672 size = size_add(size, array_size(sizeof(*request->match_sets), 9673 n_match_sets)); 9674 size = size_add(size, array_size(sizeof(*request->scan_plans), 9675 n_plans)); 9676 size = size_add(size, ie_len); 9677 request = kzalloc(size, GFP_KERNEL); 9678 if (!request) 9679 return ERR_PTR(-ENOMEM); 9680 9681 if (n_ssids) 9682 request->ssids = (void *)request + 9683 struct_size(request, channels, n_channels); 9684 request->n_ssids = n_ssids; 9685 if (ie_len) { 9686 if (n_ssids) 9687 request->ie = (void *)(request->ssids + n_ssids); 9688 else 9689 request->ie = (void *)(request->channels + n_channels); 9690 } 9691 9692 if (n_match_sets) { 9693 if (request->ie) 9694 request->match_sets = (void *)(request->ie + ie_len); 9695 else if (n_ssids) 9696 request->match_sets = 9697 (void *)(request->ssids + n_ssids); 9698 else 9699 request->match_sets = 9700 (void *)(request->channels + n_channels); 9701 } 9702 request->n_match_sets = n_match_sets; 9703 9704 if (n_match_sets) 9705 request->scan_plans = (void *)(request->match_sets + 9706 n_match_sets); 9707 else if (request->ie) 9708 request->scan_plans = (void *)(request->ie + ie_len); 9709 else if (n_ssids) 9710 request->scan_plans = (void *)(request->ssids + n_ssids); 9711 else 9712 request->scan_plans = (void *)(request->channels + n_channels); 9713 9714 request->n_scan_plans = n_plans; 9715 9716 i = 0; 9717 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) { 9718 /* user specified, bail out if channel not found */ 9719 nla_for_each_nested(attr, 9720 attrs[NL80211_ATTR_SCAN_FREQUENCIES], 9721 tmp) { 9722 struct ieee80211_channel *chan; 9723 9724 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr)); 9725 9726 if (!chan) { 9727 err = -EINVAL; 9728 goto out_free; 9729 } 9730 9731 /* ignore disabled channels */ 9732 if (chan->flags & IEEE80211_CHAN_DISABLED) 9733 continue; 9734 9735 request->channels[i] = chan; 9736 i++; 9737 } 9738 } else { 9739 /* all channels */ 9740 for (band = 0; band < NUM_NL80211_BANDS; band++) { 9741 int j; 9742 9743 if (!wiphy->bands[band]) 9744 continue; 9745 for (j = 0; j < wiphy->bands[band]->n_channels; j++) { 9746 struct ieee80211_channel *chan; 9747 9748 chan = &wiphy->bands[band]->channels[j]; 9749 9750 if (chan->flags & IEEE80211_CHAN_DISABLED) 9751 continue; 9752 9753 request->channels[i] = chan; 9754 i++; 9755 } 9756 } 9757 } 9758 9759 if (!i) { 9760 err = -EINVAL; 9761 goto out_free; 9762 } 9763 9764 request->n_channels = i; 9765 9766 i = 0; 9767 if (n_ssids) { 9768 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS], 9769 tmp) { 9770 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) { 9771 err = -EINVAL; 9772 goto out_free; 9773 } 9774 request->ssids[i].ssid_len = nla_len(attr); 9775 memcpy(request->ssids[i].ssid, nla_data(attr), 9776 nla_len(attr)); 9777 i++; 9778 } 9779 } 9780 9781 i = 0; 9782 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) { 9783 nla_for_each_nested(attr, 9784 attrs[NL80211_ATTR_SCHED_SCAN_MATCH], 9785 tmp) { 9786 struct nlattr *ssid, *bssid, *rssi; 9787 9788 err = nla_parse_nested_deprecated(tb, 9789 NL80211_SCHED_SCAN_MATCH_ATTR_MAX, 9790 attr, 9791 nl80211_match_policy, 9792 NULL); 9793 if (err) 9794 goto out_free; 9795 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID]; 9796 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]; 9797 9798 if (!ssid && !bssid) { 9799 i++; 9800 continue; 9801 } 9802 9803 if (WARN_ON(i >= n_match_sets)) { 9804 /* this indicates a programming error, 9805 * the loop above should have verified 9806 * things properly 9807 */ 9808 err = -EINVAL; 9809 goto out_free; 9810 } 9811 9812 if (ssid) { 9813 memcpy(request->match_sets[i].ssid.ssid, 9814 nla_data(ssid), nla_len(ssid)); 9815 request->match_sets[i].ssid.ssid_len = 9816 nla_len(ssid); 9817 } 9818 if (bssid) 9819 memcpy(request->match_sets[i].bssid, 9820 nla_data(bssid), ETH_ALEN); 9821 9822 /* special attribute - old implementation w/a */ 9823 request->match_sets[i].rssi_thold = default_match_rssi; 9824 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI]; 9825 if (rssi) 9826 request->match_sets[i].rssi_thold = 9827 nla_get_s32(rssi); 9828 9829 /* Parse per band RSSI attribute */ 9830 err = nl80211_parse_sched_scan_per_band_rssi(wiphy, 9831 &request->match_sets[i], 9832 tb[NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI], 9833 request->match_sets[i].rssi_thold); 9834 if (err) 9835 goto out_free; 9836 9837 i++; 9838 } 9839 9840 /* there was no other matchset, so the RSSI one is alone */ 9841 if (i == 0 && n_match_sets) 9842 request->match_sets[0].rssi_thold = default_match_rssi; 9843 9844 request->min_rssi_thold = INT_MAX; 9845 for (i = 0; i < n_match_sets; i++) 9846 request->min_rssi_thold = 9847 min(request->match_sets[i].rssi_thold, 9848 request->min_rssi_thold); 9849 } else { 9850 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF; 9851 } 9852 9853 if (ie_len) { 9854 request->ie_len = ie_len; 9855 memcpy((void *)request->ie, 9856 nla_data(attrs[NL80211_ATTR_IE]), 9857 request->ie_len); 9858 } 9859 9860 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true); 9861 if (err) 9862 goto out_free; 9863 9864 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY]) 9865 request->delay = 9866 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]); 9867 9868 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) { 9869 request->relative_rssi = nla_get_s8( 9870 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]); 9871 request->relative_rssi_set = true; 9872 } 9873 9874 if (request->relative_rssi_set && 9875 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) { 9876 struct nl80211_bss_select_rssi_adjust *rssi_adjust; 9877 9878 rssi_adjust = nla_data( 9879 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]); 9880 request->rssi_adjust.band = rssi_adjust->band; 9881 request->rssi_adjust.delta = rssi_adjust->delta; 9882 if (!is_band_valid(wiphy, request->rssi_adjust.band)) { 9883 err = -EINVAL; 9884 goto out_free; 9885 } 9886 } 9887 9888 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs); 9889 if (err) 9890 goto out_free; 9891 9892 request->scan_start = jiffies; 9893 9894 return request; 9895 9896 out_free: 9897 kfree(request); 9898 return ERR_PTR(err); 9899 } 9900 9901 static int nl80211_start_sched_scan(struct sk_buff *skb, 9902 struct genl_info *info) 9903 { 9904 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 9905 struct net_device *dev = info->user_ptr[1]; 9906 struct wireless_dev *wdev = dev->ieee80211_ptr; 9907 struct cfg80211_sched_scan_request *sched_scan_req; 9908 bool want_multi; 9909 int err; 9910 9911 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start) 9912 return -EOPNOTSUPP; 9913 9914 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI]; 9915 err = cfg80211_sched_scan_req_possible(rdev, want_multi); 9916 if (err) 9917 return err; 9918 9919 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev, 9920 info->attrs, 9921 rdev->wiphy.max_match_sets); 9922 9923 err = PTR_ERR_OR_ZERO(sched_scan_req); 9924 if (err) 9925 goto out_err; 9926 9927 /* leave request id zero for legacy request 9928 * or if driver does not support multi-scheduled scan 9929 */ 9930 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) 9931 sched_scan_req->reqid = cfg80211_assign_cookie(rdev); 9932 9933 err = rdev_sched_scan_start(rdev, dev, sched_scan_req); 9934 if (err) 9935 goto out_free; 9936 9937 sched_scan_req->dev = dev; 9938 sched_scan_req->wiphy = &rdev->wiphy; 9939 9940 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) 9941 sched_scan_req->owner_nlportid = info->snd_portid; 9942 9943 cfg80211_add_sched_scan_req(rdev, sched_scan_req); 9944 9945 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN); 9946 return 0; 9947 9948 out_free: 9949 kfree(sched_scan_req); 9950 out_err: 9951 return err; 9952 } 9953 9954 static int nl80211_stop_sched_scan(struct sk_buff *skb, 9955 struct genl_info *info) 9956 { 9957 struct cfg80211_sched_scan_request *req; 9958 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 9959 u64 cookie; 9960 9961 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop) 9962 return -EOPNOTSUPP; 9963 9964 if (info->attrs[NL80211_ATTR_COOKIE]) { 9965 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]); 9966 return __cfg80211_stop_sched_scan(rdev, cookie, false); 9967 } 9968 9969 req = list_first_or_null_rcu(&rdev->sched_scan_req_list, 9970 struct cfg80211_sched_scan_request, 9971 list); 9972 if (!req || req->reqid || 9973 (req->owner_nlportid && 9974 req->owner_nlportid != info->snd_portid)) 9975 return -ENOENT; 9976 9977 return cfg80211_stop_sched_scan_req(rdev, req, false); 9978 } 9979 9980 static int nl80211_start_radar_detection(struct sk_buff *skb, 9981 struct genl_info *info) 9982 { 9983 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 9984 struct net_device *dev = info->user_ptr[1]; 9985 struct wireless_dev *wdev = dev->ieee80211_ptr; 9986 struct wiphy *wiphy = wdev->wiphy; 9987 struct cfg80211_chan_def chandef; 9988 enum nl80211_dfs_regions dfs_region; 9989 unsigned int cac_time_ms; 9990 int err = -EINVAL; 9991 9992 flush_delayed_work(&rdev->dfs_update_channels_wk); 9993 9994 wiphy_lock(wiphy); 9995 9996 dfs_region = reg_get_dfs_region(wiphy); 9997 if (dfs_region == NL80211_DFS_UNSET) 9998 goto unlock; 9999 10000 err = nl80211_parse_chandef(rdev, info, &chandef); 10001 if (err) 10002 goto unlock; 10003 10004 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype); 10005 if (err < 0) 10006 goto unlock; 10007 10008 if (err == 0) { 10009 err = -EINVAL; 10010 goto unlock; 10011 } 10012 10013 if (!cfg80211_chandef_dfs_usable(wiphy, &chandef)) { 10014 err = -EINVAL; 10015 goto unlock; 10016 } 10017 10018 if (nla_get_flag(info->attrs[NL80211_ATTR_RADAR_BACKGROUND])) { 10019 err = cfg80211_start_background_radar_detection(rdev, wdev, 10020 &chandef); 10021 goto unlock; 10022 } 10023 10024 if (netif_carrier_ok(dev)) { 10025 err = -EBUSY; 10026 goto unlock; 10027 } 10028 10029 if (wdev->cac_started) { 10030 err = -EBUSY; 10031 goto unlock; 10032 } 10033 10034 /* CAC start is offloaded to HW and can't be started manually */ 10035 if (wiphy_ext_feature_isset(wiphy, NL80211_EXT_FEATURE_DFS_OFFLOAD)) { 10036 err = -EOPNOTSUPP; 10037 goto unlock; 10038 } 10039 10040 if (!rdev->ops->start_radar_detection) { 10041 err = -EOPNOTSUPP; 10042 goto unlock; 10043 } 10044 10045 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef); 10046 if (WARN_ON(!cac_time_ms)) 10047 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS; 10048 10049 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms); 10050 if (!err) { 10051 wdev->links[0].ap.chandef = chandef; 10052 wdev->cac_started = true; 10053 wdev->cac_start_time = jiffies; 10054 wdev->cac_time_ms = cac_time_ms; 10055 } 10056 unlock: 10057 wiphy_unlock(wiphy); 10058 10059 return err; 10060 } 10061 10062 static int nl80211_notify_radar_detection(struct sk_buff *skb, 10063 struct genl_info *info) 10064 { 10065 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 10066 struct net_device *dev = info->user_ptr[1]; 10067 struct wireless_dev *wdev = dev->ieee80211_ptr; 10068 struct wiphy *wiphy = wdev->wiphy; 10069 struct cfg80211_chan_def chandef; 10070 enum nl80211_dfs_regions dfs_region; 10071 int err; 10072 10073 dfs_region = reg_get_dfs_region(wiphy); 10074 if (dfs_region == NL80211_DFS_UNSET) { 10075 GENL_SET_ERR_MSG(info, 10076 "DFS Region is not set. Unexpected Radar indication"); 10077 return -EINVAL; 10078 } 10079 10080 err = nl80211_parse_chandef(rdev, info, &chandef); 10081 if (err) { 10082 GENL_SET_ERR_MSG(info, "Unable to extract chandef info"); 10083 return err; 10084 } 10085 10086 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype); 10087 if (err < 0) { 10088 GENL_SET_ERR_MSG(info, "chandef is invalid"); 10089 return err; 10090 } 10091 10092 if (err == 0) { 10093 GENL_SET_ERR_MSG(info, 10094 "Unexpected Radar indication for chandef/iftype"); 10095 return -EINVAL; 10096 } 10097 10098 /* Do not process this notification if radar is already detected 10099 * by kernel on this channel, and return success. 10100 */ 10101 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE) 10102 return 0; 10103 10104 cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_UNAVAILABLE); 10105 10106 cfg80211_sched_dfs_chan_update(rdev); 10107 10108 rdev->radar_chandef = chandef; 10109 10110 /* Propagate this notification to other radios as well */ 10111 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk); 10112 10113 return 0; 10114 } 10115 10116 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info) 10117 { 10118 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 10119 unsigned int link_id = nl80211_link_id(info->attrs); 10120 struct net_device *dev = info->user_ptr[1]; 10121 struct wireless_dev *wdev = dev->ieee80211_ptr; 10122 struct cfg80211_csa_settings params; 10123 struct nlattr **csa_attrs = NULL; 10124 int err; 10125 bool need_new_beacon = false; 10126 bool need_handle_dfs_flag = true; 10127 int len, i; 10128 u32 cs_count; 10129 10130 if (!rdev->ops->channel_switch || 10131 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)) 10132 return -EOPNOTSUPP; 10133 10134 switch (dev->ieee80211_ptr->iftype) { 10135 case NL80211_IFTYPE_AP: 10136 case NL80211_IFTYPE_P2P_GO: 10137 need_new_beacon = true; 10138 /* For all modes except AP the handle_dfs flag needs to be 10139 * supplied to tell the kernel that userspace will handle radar 10140 * events when they happen. Otherwise a switch to a channel 10141 * requiring DFS will be rejected. 10142 */ 10143 need_handle_dfs_flag = false; 10144 10145 /* useless if AP is not running */ 10146 if (!wdev->links[link_id].ap.beacon_interval) 10147 return -ENOTCONN; 10148 break; 10149 case NL80211_IFTYPE_ADHOC: 10150 if (!wdev->u.ibss.ssid_len) 10151 return -ENOTCONN; 10152 break; 10153 case NL80211_IFTYPE_MESH_POINT: 10154 if (!wdev->u.mesh.id_len) 10155 return -ENOTCONN; 10156 break; 10157 default: 10158 return -EOPNOTSUPP; 10159 } 10160 10161 memset(¶ms, 0, sizeof(params)); 10162 params.beacon_csa.ftm_responder = -1; 10163 10164 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] || 10165 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]) 10166 return -EINVAL; 10167 10168 /* only important for AP, IBSS and mesh create IEs internally */ 10169 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES]) 10170 return -EINVAL; 10171 10172 /* Even though the attribute is u32, the specification says 10173 * u8, so let's make sure we don't overflow. 10174 */ 10175 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]); 10176 if (cs_count > 255) 10177 return -EINVAL; 10178 10179 params.count = cs_count; 10180 10181 if (!need_new_beacon) 10182 goto skip_beacons; 10183 10184 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after, 10185 info->extack); 10186 if (err) 10187 goto free; 10188 10189 csa_attrs = kcalloc(NL80211_ATTR_MAX + 1, sizeof(*csa_attrs), 10190 GFP_KERNEL); 10191 if (!csa_attrs) { 10192 err = -ENOMEM; 10193 goto free; 10194 } 10195 10196 err = nla_parse_nested_deprecated(csa_attrs, NL80211_ATTR_MAX, 10197 info->attrs[NL80211_ATTR_CSA_IES], 10198 nl80211_policy, info->extack); 10199 if (err) 10200 goto free; 10201 10202 err = nl80211_parse_beacon(rdev, csa_attrs, ¶ms.beacon_csa, 10203 info->extack); 10204 if (err) 10205 goto free; 10206 10207 if (!csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]) { 10208 err = -EINVAL; 10209 goto free; 10210 } 10211 10212 len = nla_len(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]); 10213 if (!len || (len % sizeof(u16))) { 10214 err = -EINVAL; 10215 goto free; 10216 } 10217 10218 params.n_counter_offsets_beacon = len / sizeof(u16); 10219 if (rdev->wiphy.max_num_csa_counters && 10220 (params.n_counter_offsets_beacon > 10221 rdev->wiphy.max_num_csa_counters)) { 10222 err = -EINVAL; 10223 goto free; 10224 } 10225 10226 params.counter_offsets_beacon = 10227 nla_data(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_BEACON]); 10228 10229 /* sanity checks - counters should fit and be the same */ 10230 for (i = 0; i < params.n_counter_offsets_beacon; i++) { 10231 u16 offset = params.counter_offsets_beacon[i]; 10232 10233 if (offset >= params.beacon_csa.tail_len) { 10234 err = -EINVAL; 10235 goto free; 10236 } 10237 10238 if (params.beacon_csa.tail[offset] != params.count) { 10239 err = -EINVAL; 10240 goto free; 10241 } 10242 } 10243 10244 if (csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]) { 10245 len = nla_len(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]); 10246 if (!len || (len % sizeof(u16))) { 10247 err = -EINVAL; 10248 goto free; 10249 } 10250 10251 params.n_counter_offsets_presp = len / sizeof(u16); 10252 if (rdev->wiphy.max_num_csa_counters && 10253 (params.n_counter_offsets_presp > 10254 rdev->wiphy.max_num_csa_counters)) { 10255 err = -EINVAL; 10256 goto free; 10257 } 10258 10259 params.counter_offsets_presp = 10260 nla_data(csa_attrs[NL80211_ATTR_CNTDWN_OFFS_PRESP]); 10261 10262 /* sanity checks - counters should fit and be the same */ 10263 for (i = 0; i < params.n_counter_offsets_presp; i++) { 10264 u16 offset = params.counter_offsets_presp[i]; 10265 10266 if (offset >= params.beacon_csa.probe_resp_len) { 10267 err = -EINVAL; 10268 goto free; 10269 } 10270 10271 if (params.beacon_csa.probe_resp[offset] != 10272 params.count) { 10273 err = -EINVAL; 10274 goto free; 10275 } 10276 } 10277 } 10278 10279 skip_beacons: 10280 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef); 10281 if (err) 10282 goto free; 10283 10284 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef, 10285 wdev->iftype)) { 10286 err = -EINVAL; 10287 goto free; 10288 } 10289 10290 err = cfg80211_chandef_dfs_required(wdev->wiphy, 10291 ¶ms.chandef, 10292 wdev->iftype); 10293 if (err < 0) 10294 goto free; 10295 10296 if (err > 0) { 10297 params.radar_required = true; 10298 if (need_handle_dfs_flag && 10299 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) { 10300 err = -EINVAL; 10301 goto free; 10302 } 10303 } 10304 10305 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX]) 10306 params.block_tx = true; 10307 10308 if (info->attrs[NL80211_ATTR_PUNCT_BITMAP]) { 10309 err = nl80211_parse_punct_bitmap(rdev, info, 10310 ¶ms.chandef, 10311 ¶ms.punct_bitmap); 10312 if (err) 10313 goto free; 10314 } 10315 10316 wdev_lock(wdev); 10317 err = rdev_channel_switch(rdev, dev, ¶ms); 10318 wdev_unlock(wdev); 10319 10320 free: 10321 kfree(params.beacon_after.mbssid_ies); 10322 kfree(params.beacon_csa.mbssid_ies); 10323 kfree(params.beacon_after.rnr_ies); 10324 kfree(params.beacon_csa.rnr_ies); 10325 kfree(csa_attrs); 10326 return err; 10327 } 10328 10329 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb, 10330 u32 seq, int flags, 10331 struct cfg80211_registered_device *rdev, 10332 struct wireless_dev *wdev, 10333 struct cfg80211_internal_bss *intbss) 10334 { 10335 struct cfg80211_bss *res = &intbss->pub; 10336 const struct cfg80211_bss_ies *ies; 10337 unsigned int link_id; 10338 void *hdr; 10339 struct nlattr *bss; 10340 10341 ASSERT_WDEV_LOCK(wdev); 10342 10343 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags, 10344 NL80211_CMD_NEW_SCAN_RESULTS); 10345 if (!hdr) 10346 return -1; 10347 10348 genl_dump_check_consistent(cb, hdr); 10349 10350 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation)) 10351 goto nla_put_failure; 10352 if (wdev->netdev && 10353 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex)) 10354 goto nla_put_failure; 10355 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 10356 NL80211_ATTR_PAD)) 10357 goto nla_put_failure; 10358 10359 bss = nla_nest_start_noflag(msg, NL80211_ATTR_BSS); 10360 if (!bss) 10361 goto nla_put_failure; 10362 if ((!is_zero_ether_addr(res->bssid) && 10363 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid))) 10364 goto nla_put_failure; 10365 10366 rcu_read_lock(); 10367 /* indicate whether we have probe response data or not */ 10368 if (rcu_access_pointer(res->proberesp_ies) && 10369 nla_put_flag(msg, NL80211_BSS_PRESP_DATA)) 10370 goto fail_unlock_rcu; 10371 10372 /* this pointer prefers to be pointed to probe response data 10373 * but is always valid 10374 */ 10375 ies = rcu_dereference(res->ies); 10376 if (ies) { 10377 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf, 10378 NL80211_BSS_PAD)) 10379 goto fail_unlock_rcu; 10380 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS, 10381 ies->len, ies->data)) 10382 goto fail_unlock_rcu; 10383 } 10384 10385 /* and this pointer is always (unless driver didn't know) beacon data */ 10386 ies = rcu_dereference(res->beacon_ies); 10387 if (ies && ies->from_beacon) { 10388 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf, 10389 NL80211_BSS_PAD)) 10390 goto fail_unlock_rcu; 10391 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES, 10392 ies->len, ies->data)) 10393 goto fail_unlock_rcu; 10394 } 10395 rcu_read_unlock(); 10396 10397 if (res->beacon_interval && 10398 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval)) 10399 goto nla_put_failure; 10400 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) || 10401 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) || 10402 nla_put_u32(msg, NL80211_BSS_FREQUENCY_OFFSET, 10403 res->channel->freq_offset) || 10404 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) || 10405 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO, 10406 jiffies_to_msecs(jiffies - intbss->ts))) 10407 goto nla_put_failure; 10408 10409 if (intbss->parent_tsf && 10410 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF, 10411 intbss->parent_tsf, NL80211_BSS_PAD) || 10412 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN, 10413 intbss->parent_bssid))) 10414 goto nla_put_failure; 10415 10416 if (intbss->ts_boottime && 10417 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME, 10418 intbss->ts_boottime, NL80211_BSS_PAD)) 10419 goto nla_put_failure; 10420 10421 if (!nl80211_put_signal(msg, intbss->pub.chains, 10422 intbss->pub.chain_signal, 10423 NL80211_BSS_CHAIN_SIGNAL)) 10424 goto nla_put_failure; 10425 10426 switch (rdev->wiphy.signal_type) { 10427 case CFG80211_SIGNAL_TYPE_MBM: 10428 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal)) 10429 goto nla_put_failure; 10430 break; 10431 case CFG80211_SIGNAL_TYPE_UNSPEC: 10432 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal)) 10433 goto nla_put_failure; 10434 break; 10435 default: 10436 break; 10437 } 10438 10439 switch (wdev->iftype) { 10440 case NL80211_IFTYPE_P2P_CLIENT: 10441 case NL80211_IFTYPE_STATION: 10442 for_each_valid_link(wdev, link_id) { 10443 if (intbss == wdev->links[link_id].client.current_bss && 10444 (nla_put_u32(msg, NL80211_BSS_STATUS, 10445 NL80211_BSS_STATUS_ASSOCIATED) || 10446 (wdev->valid_links && 10447 (nla_put_u8(msg, NL80211_BSS_MLO_LINK_ID, 10448 link_id) || 10449 nla_put(msg, NL80211_BSS_MLD_ADDR, ETH_ALEN, 10450 wdev->u.client.connected_addr))))) 10451 goto nla_put_failure; 10452 } 10453 break; 10454 case NL80211_IFTYPE_ADHOC: 10455 if (intbss == wdev->u.ibss.current_bss && 10456 nla_put_u32(msg, NL80211_BSS_STATUS, 10457 NL80211_BSS_STATUS_IBSS_JOINED)) 10458 goto nla_put_failure; 10459 break; 10460 default: 10461 break; 10462 } 10463 10464 nla_nest_end(msg, bss); 10465 10466 genlmsg_end(msg, hdr); 10467 return 0; 10468 10469 fail_unlock_rcu: 10470 rcu_read_unlock(); 10471 nla_put_failure: 10472 genlmsg_cancel(msg, hdr); 10473 return -EMSGSIZE; 10474 } 10475 10476 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb) 10477 { 10478 struct cfg80211_registered_device *rdev; 10479 struct cfg80211_internal_bss *scan; 10480 struct wireless_dev *wdev; 10481 int start = cb->args[2], idx = 0; 10482 int err; 10483 10484 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, NULL); 10485 if (err) 10486 return err; 10487 /* nl80211_prepare_wdev_dump acquired it in the successful case */ 10488 __acquire(&rdev->wiphy.mtx); 10489 10490 wdev_lock(wdev); 10491 spin_lock_bh(&rdev->bss_lock); 10492 10493 /* 10494 * dump_scan will be called multiple times to break up the scan results 10495 * into multiple messages. It is unlikely that any more bss-es will be 10496 * expired after the first call, so only call only call this on the 10497 * first dump_scan invocation. 10498 */ 10499 if (start == 0) 10500 cfg80211_bss_expire(rdev); 10501 10502 cb->seq = rdev->bss_generation; 10503 10504 list_for_each_entry(scan, &rdev->bss_list, list) { 10505 if (++idx <= start) 10506 continue; 10507 if (nl80211_send_bss(skb, cb, 10508 cb->nlh->nlmsg_seq, NLM_F_MULTI, 10509 rdev, wdev, scan) < 0) { 10510 idx--; 10511 break; 10512 } 10513 } 10514 10515 spin_unlock_bh(&rdev->bss_lock); 10516 wdev_unlock(wdev); 10517 10518 cb->args[2] = idx; 10519 wiphy_unlock(&rdev->wiphy); 10520 10521 return skb->len; 10522 } 10523 10524 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq, 10525 int flags, struct net_device *dev, 10526 bool allow_radio_stats, 10527 struct survey_info *survey) 10528 { 10529 void *hdr; 10530 struct nlattr *infoattr; 10531 10532 /* skip radio stats if userspace didn't request them */ 10533 if (!survey->channel && !allow_radio_stats) 10534 return 0; 10535 10536 hdr = nl80211hdr_put(msg, portid, seq, flags, 10537 NL80211_CMD_NEW_SURVEY_RESULTS); 10538 if (!hdr) 10539 return -ENOMEM; 10540 10541 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex)) 10542 goto nla_put_failure; 10543 10544 infoattr = nla_nest_start_noflag(msg, NL80211_ATTR_SURVEY_INFO); 10545 if (!infoattr) 10546 goto nla_put_failure; 10547 10548 if (survey->channel && 10549 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY, 10550 survey->channel->center_freq)) 10551 goto nla_put_failure; 10552 10553 if (survey->channel && survey->channel->freq_offset && 10554 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY_OFFSET, 10555 survey->channel->freq_offset)) 10556 goto nla_put_failure; 10557 10558 if ((survey->filled & SURVEY_INFO_NOISE_DBM) && 10559 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise)) 10560 goto nla_put_failure; 10561 if ((survey->filled & SURVEY_INFO_IN_USE) && 10562 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE)) 10563 goto nla_put_failure; 10564 if ((survey->filled & SURVEY_INFO_TIME) && 10565 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME, 10566 survey->time, NL80211_SURVEY_INFO_PAD)) 10567 goto nla_put_failure; 10568 if ((survey->filled & SURVEY_INFO_TIME_BUSY) && 10569 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY, 10570 survey->time_busy, NL80211_SURVEY_INFO_PAD)) 10571 goto nla_put_failure; 10572 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) && 10573 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY, 10574 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD)) 10575 goto nla_put_failure; 10576 if ((survey->filled & SURVEY_INFO_TIME_RX) && 10577 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX, 10578 survey->time_rx, NL80211_SURVEY_INFO_PAD)) 10579 goto nla_put_failure; 10580 if ((survey->filled & SURVEY_INFO_TIME_TX) && 10581 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX, 10582 survey->time_tx, NL80211_SURVEY_INFO_PAD)) 10583 goto nla_put_failure; 10584 if ((survey->filled & SURVEY_INFO_TIME_SCAN) && 10585 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN, 10586 survey->time_scan, NL80211_SURVEY_INFO_PAD)) 10587 goto nla_put_failure; 10588 if ((survey->filled & SURVEY_INFO_TIME_BSS_RX) && 10589 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BSS_RX, 10590 survey->time_bss_rx, NL80211_SURVEY_INFO_PAD)) 10591 goto nla_put_failure; 10592 10593 nla_nest_end(msg, infoattr); 10594 10595 genlmsg_end(msg, hdr); 10596 return 0; 10597 10598 nla_put_failure: 10599 genlmsg_cancel(msg, hdr); 10600 return -EMSGSIZE; 10601 } 10602 10603 static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb) 10604 { 10605 struct nlattr **attrbuf; 10606 struct survey_info survey; 10607 struct cfg80211_registered_device *rdev; 10608 struct wireless_dev *wdev; 10609 int survey_idx = cb->args[2]; 10610 int res; 10611 bool radio_stats; 10612 10613 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL); 10614 if (!attrbuf) 10615 return -ENOMEM; 10616 10617 res = nl80211_prepare_wdev_dump(cb, &rdev, &wdev, attrbuf); 10618 if (res) { 10619 kfree(attrbuf); 10620 return res; 10621 } 10622 /* nl80211_prepare_wdev_dump acquired it in the successful case */ 10623 __acquire(&rdev->wiphy.mtx); 10624 10625 /* prepare_wdev_dump parsed the attributes */ 10626 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS]; 10627 10628 if (!wdev->netdev) { 10629 res = -EINVAL; 10630 goto out_err; 10631 } 10632 10633 if (!rdev->ops->dump_survey) { 10634 res = -EOPNOTSUPP; 10635 goto out_err; 10636 } 10637 10638 while (1) { 10639 wdev_lock(wdev); 10640 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey); 10641 wdev_unlock(wdev); 10642 if (res == -ENOENT) 10643 break; 10644 if (res) 10645 goto out_err; 10646 10647 /* don't send disabled channels, but do send non-channel data */ 10648 if (survey.channel && 10649 survey.channel->flags & IEEE80211_CHAN_DISABLED) { 10650 survey_idx++; 10651 continue; 10652 } 10653 10654 if (nl80211_send_survey(skb, 10655 NETLINK_CB(cb->skb).portid, 10656 cb->nlh->nlmsg_seq, NLM_F_MULTI, 10657 wdev->netdev, radio_stats, &survey) < 0) 10658 goto out; 10659 survey_idx++; 10660 } 10661 10662 out: 10663 cb->args[2] = survey_idx; 10664 res = skb->len; 10665 out_err: 10666 kfree(attrbuf); 10667 wiphy_unlock(&rdev->wiphy); 10668 return res; 10669 } 10670 10671 static bool nl80211_valid_wpa_versions(u32 wpa_versions) 10672 { 10673 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 | 10674 NL80211_WPA_VERSION_2 | 10675 NL80211_WPA_VERSION_3)); 10676 } 10677 10678 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info) 10679 { 10680 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 10681 struct net_device *dev = info->user_ptr[1]; 10682 struct ieee80211_channel *chan; 10683 const u8 *bssid, *ssid; 10684 int err, ssid_len; 10685 enum nl80211_auth_type auth_type; 10686 struct key_parse key; 10687 bool local_state_change; 10688 struct cfg80211_auth_request req = {}; 10689 u32 freq; 10690 10691 if (!info->attrs[NL80211_ATTR_MAC]) 10692 return -EINVAL; 10693 10694 if (!info->attrs[NL80211_ATTR_AUTH_TYPE]) 10695 return -EINVAL; 10696 10697 if (!info->attrs[NL80211_ATTR_SSID]) 10698 return -EINVAL; 10699 10700 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ]) 10701 return -EINVAL; 10702 10703 err = nl80211_parse_key(info, &key); 10704 if (err) 10705 return err; 10706 10707 if (key.idx >= 0) { 10708 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP) 10709 return -EINVAL; 10710 if (!key.p.key || !key.p.key_len) 10711 return -EINVAL; 10712 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 || 10713 key.p.key_len != WLAN_KEY_LEN_WEP40) && 10714 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 || 10715 key.p.key_len != WLAN_KEY_LEN_WEP104)) 10716 return -EINVAL; 10717 if (key.idx > 3) 10718 return -EINVAL; 10719 } else { 10720 key.p.key_len = 0; 10721 key.p.key = NULL; 10722 } 10723 10724 if (key.idx >= 0) { 10725 int i; 10726 bool ok = false; 10727 10728 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) { 10729 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) { 10730 ok = true; 10731 break; 10732 } 10733 } 10734 if (!ok) 10735 return -EINVAL; 10736 } 10737 10738 if (!rdev->ops->auth) 10739 return -EOPNOTSUPP; 10740 10741 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 10742 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 10743 return -EOPNOTSUPP; 10744 10745 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 10746 freq = MHZ_TO_KHZ(nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ])); 10747 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]) 10748 freq += 10749 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]); 10750 10751 chan = nl80211_get_valid_chan(&rdev->wiphy, freq); 10752 if (!chan) 10753 return -EINVAL; 10754 10755 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 10756 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 10757 10758 if (info->attrs[NL80211_ATTR_IE]) { 10759 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 10760 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 10761 } 10762 10763 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]); 10764 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE)) 10765 return -EINVAL; 10766 10767 if ((auth_type == NL80211_AUTHTYPE_SAE || 10768 auth_type == NL80211_AUTHTYPE_FILS_SK || 10769 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS || 10770 auth_type == NL80211_AUTHTYPE_FILS_PK) && 10771 !info->attrs[NL80211_ATTR_AUTH_DATA]) 10772 return -EINVAL; 10773 10774 if (info->attrs[NL80211_ATTR_AUTH_DATA]) { 10775 if (auth_type != NL80211_AUTHTYPE_SAE && 10776 auth_type != NL80211_AUTHTYPE_FILS_SK && 10777 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS && 10778 auth_type != NL80211_AUTHTYPE_FILS_PK) 10779 return -EINVAL; 10780 req.auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]); 10781 req.auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]); 10782 } 10783 10784 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE]; 10785 10786 /* 10787 * Since we no longer track auth state, ignore 10788 * requests to only change local state. 10789 */ 10790 if (local_state_change) 10791 return 0; 10792 10793 req.auth_type = auth_type; 10794 req.key = key.p.key; 10795 req.key_len = key.p.key_len; 10796 req.key_idx = key.idx; 10797 req.link_id = nl80211_link_id_or_invalid(info->attrs); 10798 if (req.link_id >= 0) { 10799 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO)) 10800 return -EINVAL; 10801 if (!info->attrs[NL80211_ATTR_MLD_ADDR]) 10802 return -EINVAL; 10803 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 10804 if (!is_valid_ether_addr(req.ap_mld_addr)) 10805 return -EINVAL; 10806 } 10807 10808 req.bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, ssid, ssid_len, 10809 IEEE80211_BSS_TYPE_ESS, 10810 IEEE80211_PRIVACY_ANY); 10811 if (!req.bss) 10812 return -ENOENT; 10813 10814 wdev_lock(dev->ieee80211_ptr); 10815 err = cfg80211_mlme_auth(rdev, dev, &req); 10816 wdev_unlock(dev->ieee80211_ptr); 10817 10818 cfg80211_put_bss(&rdev->wiphy, req.bss); 10819 10820 return err; 10821 } 10822 10823 static int validate_pae_over_nl80211(struct cfg80211_registered_device *rdev, 10824 struct genl_info *info) 10825 { 10826 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) { 10827 GENL_SET_ERR_MSG(info, "SOCKET_OWNER not set"); 10828 return -EINVAL; 10829 } 10830 10831 if (!rdev->ops->tx_control_port || 10832 !wiphy_ext_feature_isset(&rdev->wiphy, 10833 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211)) 10834 return -EOPNOTSUPP; 10835 10836 return 0; 10837 } 10838 10839 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev, 10840 struct genl_info *info, 10841 struct cfg80211_crypto_settings *settings, 10842 int cipher_limit) 10843 { 10844 memset(settings, 0, sizeof(*settings)); 10845 10846 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT]; 10847 10848 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) { 10849 u16 proto; 10850 10851 proto = nla_get_u16( 10852 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]); 10853 settings->control_port_ethertype = cpu_to_be16(proto); 10854 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) && 10855 proto != ETH_P_PAE) 10856 return -EINVAL; 10857 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]) 10858 settings->control_port_no_encrypt = true; 10859 } else 10860 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE); 10861 10862 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) { 10863 int r = validate_pae_over_nl80211(rdev, info); 10864 10865 if (r < 0) 10866 return r; 10867 10868 settings->control_port_over_nl80211 = true; 10869 10870 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_PREAUTH]) 10871 settings->control_port_no_preauth = true; 10872 } 10873 10874 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) { 10875 void *data; 10876 int len, i; 10877 10878 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]); 10879 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]); 10880 settings->n_ciphers_pairwise = len / sizeof(u32); 10881 10882 if (len % sizeof(u32)) 10883 return -EINVAL; 10884 10885 if (settings->n_ciphers_pairwise > cipher_limit) 10886 return -EINVAL; 10887 10888 memcpy(settings->ciphers_pairwise, data, len); 10889 10890 for (i = 0; i < settings->n_ciphers_pairwise; i++) 10891 if (!cfg80211_supported_cipher_suite( 10892 &rdev->wiphy, 10893 settings->ciphers_pairwise[i])) 10894 return -EINVAL; 10895 } 10896 10897 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) { 10898 settings->cipher_group = 10899 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]); 10900 if (!cfg80211_supported_cipher_suite(&rdev->wiphy, 10901 settings->cipher_group)) 10902 return -EINVAL; 10903 } 10904 10905 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) { 10906 settings->wpa_versions = 10907 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]); 10908 if (!nl80211_valid_wpa_versions(settings->wpa_versions)) 10909 return -EINVAL; 10910 } 10911 10912 if (info->attrs[NL80211_ATTR_AKM_SUITES]) { 10913 void *data; 10914 int len; 10915 10916 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]); 10917 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]); 10918 settings->n_akm_suites = len / sizeof(u32); 10919 10920 if (len % sizeof(u32)) 10921 return -EINVAL; 10922 10923 if (settings->n_akm_suites > rdev->wiphy.max_num_akm_suites) 10924 return -EINVAL; 10925 10926 memcpy(settings->akm_suites, data, len); 10927 } 10928 10929 if (info->attrs[NL80211_ATTR_PMK]) { 10930 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN) 10931 return -EINVAL; 10932 if (!wiphy_ext_feature_isset(&rdev->wiphy, 10933 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK) && 10934 !wiphy_ext_feature_isset(&rdev->wiphy, 10935 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK)) 10936 return -EINVAL; 10937 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]); 10938 } 10939 10940 if (info->attrs[NL80211_ATTR_SAE_PASSWORD]) { 10941 if (!wiphy_ext_feature_isset(&rdev->wiphy, 10942 NL80211_EXT_FEATURE_SAE_OFFLOAD) && 10943 !wiphy_ext_feature_isset(&rdev->wiphy, 10944 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP)) 10945 return -EINVAL; 10946 settings->sae_pwd = 10947 nla_data(info->attrs[NL80211_ATTR_SAE_PASSWORD]); 10948 settings->sae_pwd_len = 10949 nla_len(info->attrs[NL80211_ATTR_SAE_PASSWORD]); 10950 } 10951 10952 if (info->attrs[NL80211_ATTR_SAE_PWE]) 10953 settings->sae_pwe = 10954 nla_get_u8(info->attrs[NL80211_ATTR_SAE_PWE]); 10955 else 10956 settings->sae_pwe = NL80211_SAE_PWE_UNSPECIFIED; 10957 10958 return 0; 10959 } 10960 10961 static struct cfg80211_bss *nl80211_assoc_bss(struct cfg80211_registered_device *rdev, 10962 const u8 *ssid, int ssid_len, 10963 struct nlattr **attrs) 10964 { 10965 struct ieee80211_channel *chan; 10966 struct cfg80211_bss *bss; 10967 const u8 *bssid; 10968 u32 freq; 10969 10970 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_WIPHY_FREQ]) 10971 return ERR_PTR(-EINVAL); 10972 10973 bssid = nla_data(attrs[NL80211_ATTR_MAC]); 10974 10975 freq = MHZ_TO_KHZ(nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ])); 10976 if (attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]) 10977 freq += nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]); 10978 10979 chan = nl80211_get_valid_chan(&rdev->wiphy, freq); 10980 if (!chan) 10981 return ERR_PTR(-EINVAL); 10982 10983 bss = cfg80211_get_bss(&rdev->wiphy, chan, bssid, 10984 ssid, ssid_len, 10985 IEEE80211_BSS_TYPE_ESS, 10986 IEEE80211_PRIVACY_ANY); 10987 if (!bss) 10988 return ERR_PTR(-ENOENT); 10989 10990 return bss; 10991 } 10992 10993 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info) 10994 { 10995 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 10996 struct net_device *dev = info->user_ptr[1]; 10997 struct cfg80211_assoc_request req = {}; 10998 struct nlattr **attrs = NULL; 10999 const u8 *ap_addr, *ssid; 11000 unsigned int link_id; 11001 int err, ssid_len; 11002 11003 if (dev->ieee80211_ptr->conn_owner_nlportid && 11004 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid) 11005 return -EPERM; 11006 11007 if (!info->attrs[NL80211_ATTR_SSID]) 11008 return -EINVAL; 11009 11010 if (!rdev->ops->assoc) 11011 return -EOPNOTSUPP; 11012 11013 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 11014 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 11015 return -EOPNOTSUPP; 11016 11017 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 11018 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 11019 11020 if (info->attrs[NL80211_ATTR_IE]) { 11021 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 11022 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 11023 11024 if (cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE, 11025 req.ie, req.ie_len)) { 11026 GENL_SET_ERR_MSG(info, 11027 "non-inheritance makes no sense"); 11028 return -EINVAL; 11029 } 11030 } 11031 11032 if (info->attrs[NL80211_ATTR_USE_MFP]) { 11033 enum nl80211_mfp mfp = 11034 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]); 11035 if (mfp == NL80211_MFP_REQUIRED) 11036 req.use_mfp = true; 11037 else if (mfp != NL80211_MFP_NO) 11038 return -EINVAL; 11039 } 11040 11041 if (info->attrs[NL80211_ATTR_PREV_BSSID]) 11042 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]); 11043 11044 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT])) 11045 req.flags |= ASSOC_REQ_DISABLE_HT; 11046 11047 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) 11048 memcpy(&req.ht_capa_mask, 11049 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]), 11050 sizeof(req.ht_capa_mask)); 11051 11052 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) { 11053 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) 11054 return -EINVAL; 11055 memcpy(&req.ht_capa, 11056 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]), 11057 sizeof(req.ht_capa)); 11058 } 11059 11060 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT])) 11061 req.flags |= ASSOC_REQ_DISABLE_VHT; 11062 11063 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE])) 11064 req.flags |= ASSOC_REQ_DISABLE_HE; 11065 11066 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_EHT])) 11067 req.flags |= ASSOC_REQ_DISABLE_EHT; 11068 11069 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) 11070 memcpy(&req.vht_capa_mask, 11071 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]), 11072 sizeof(req.vht_capa_mask)); 11073 11074 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) { 11075 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) 11076 return -EINVAL; 11077 memcpy(&req.vht_capa, 11078 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]), 11079 sizeof(req.vht_capa)); 11080 } 11081 11082 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) { 11083 if (!((rdev->wiphy.features & 11084 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) && 11085 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) && 11086 !wiphy_ext_feature_isset(&rdev->wiphy, 11087 NL80211_EXT_FEATURE_RRM)) 11088 return -EINVAL; 11089 req.flags |= ASSOC_REQ_USE_RRM; 11090 } 11091 11092 if (info->attrs[NL80211_ATTR_FILS_KEK]) { 11093 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]); 11094 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]); 11095 if (!info->attrs[NL80211_ATTR_FILS_NONCES]) 11096 return -EINVAL; 11097 req.fils_nonces = 11098 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]); 11099 } 11100 11101 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]) { 11102 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY]) 11103 return -EINVAL; 11104 memcpy(&req.s1g_capa_mask, 11105 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]), 11106 sizeof(req.s1g_capa_mask)); 11107 } 11108 11109 if (info->attrs[NL80211_ATTR_S1G_CAPABILITY]) { 11110 if (!info->attrs[NL80211_ATTR_S1G_CAPABILITY_MASK]) 11111 return -EINVAL; 11112 memcpy(&req.s1g_capa, 11113 nla_data(info->attrs[NL80211_ATTR_S1G_CAPABILITY]), 11114 sizeof(req.s1g_capa)); 11115 } 11116 11117 req.link_id = nl80211_link_id_or_invalid(info->attrs); 11118 11119 if (info->attrs[NL80211_ATTR_MLO_LINKS]) { 11120 unsigned int attrsize = NUM_NL80211_ATTR * sizeof(*attrs); 11121 struct nlattr *link; 11122 int rem = 0; 11123 11124 if (req.link_id < 0) 11125 return -EINVAL; 11126 11127 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_MLO)) 11128 return -EINVAL; 11129 11130 if (info->attrs[NL80211_ATTR_MAC] || 11131 info->attrs[NL80211_ATTR_WIPHY_FREQ] || 11132 !info->attrs[NL80211_ATTR_MLD_ADDR]) 11133 return -EINVAL; 11134 11135 req.ap_mld_addr = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 11136 ap_addr = req.ap_mld_addr; 11137 11138 attrs = kzalloc(attrsize, GFP_KERNEL); 11139 if (!attrs) 11140 return -ENOMEM; 11141 11142 nla_for_each_nested(link, 11143 info->attrs[NL80211_ATTR_MLO_LINKS], 11144 rem) { 11145 memset(attrs, 0, attrsize); 11146 11147 nla_parse_nested(attrs, NL80211_ATTR_MAX, 11148 link, NULL, NULL); 11149 11150 if (!attrs[NL80211_ATTR_MLO_LINK_ID]) { 11151 err = -EINVAL; 11152 goto free; 11153 } 11154 11155 link_id = nla_get_u8(attrs[NL80211_ATTR_MLO_LINK_ID]); 11156 /* cannot use the same link ID again */ 11157 if (req.links[link_id].bss) { 11158 err = -EINVAL; 11159 goto free; 11160 } 11161 req.links[link_id].bss = 11162 nl80211_assoc_bss(rdev, ssid, ssid_len, attrs); 11163 if (IS_ERR(req.links[link_id].bss)) { 11164 err = PTR_ERR(req.links[link_id].bss); 11165 req.links[link_id].bss = NULL; 11166 goto free; 11167 } 11168 11169 if (attrs[NL80211_ATTR_IE]) { 11170 req.links[link_id].elems = 11171 nla_data(attrs[NL80211_ATTR_IE]); 11172 req.links[link_id].elems_len = 11173 nla_len(attrs[NL80211_ATTR_IE]); 11174 11175 if (cfg80211_find_elem(WLAN_EID_FRAGMENT, 11176 req.links[link_id].elems, 11177 req.links[link_id].elems_len)) { 11178 GENL_SET_ERR_MSG(info, 11179 "cannot deal with fragmentation"); 11180 err = -EINVAL; 11181 goto free; 11182 } 11183 11184 if (cfg80211_find_ext_elem(WLAN_EID_EXT_NON_INHERITANCE, 11185 req.links[link_id].elems, 11186 req.links[link_id].elems_len)) { 11187 GENL_SET_ERR_MSG(info, 11188 "cannot deal with non-inheritance"); 11189 err = -EINVAL; 11190 goto free; 11191 } 11192 } 11193 11194 req.links[link_id].disabled = 11195 nla_get_flag(attrs[NL80211_ATTR_MLO_LINK_DISABLED]); 11196 } 11197 11198 if (!req.links[req.link_id].bss) { 11199 err = -EINVAL; 11200 goto free; 11201 } 11202 11203 if (req.links[req.link_id].elems_len) { 11204 GENL_SET_ERR_MSG(info, 11205 "cannot have per-link elems on assoc link"); 11206 err = -EINVAL; 11207 goto free; 11208 } 11209 11210 if (req.links[req.link_id].disabled) { 11211 GENL_SET_ERR_MSG(info, 11212 "cannot have assoc link disabled"); 11213 err = -EINVAL; 11214 goto free; 11215 } 11216 11217 kfree(attrs); 11218 attrs = NULL; 11219 } else { 11220 if (req.link_id >= 0) 11221 return -EINVAL; 11222 11223 req.bss = nl80211_assoc_bss(rdev, ssid, ssid_len, info->attrs); 11224 if (IS_ERR(req.bss)) 11225 return PTR_ERR(req.bss); 11226 ap_addr = req.bss->bssid; 11227 } 11228 11229 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1); 11230 if (!err) { 11231 wdev_lock(dev->ieee80211_ptr); 11232 11233 err = cfg80211_mlme_assoc(rdev, dev, &req); 11234 11235 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) { 11236 dev->ieee80211_ptr->conn_owner_nlportid = 11237 info->snd_portid; 11238 memcpy(dev->ieee80211_ptr->disconnect_bssid, 11239 ap_addr, ETH_ALEN); 11240 } 11241 11242 wdev_unlock(dev->ieee80211_ptr); 11243 } 11244 11245 free: 11246 for (link_id = 0; link_id < ARRAY_SIZE(req.links); link_id++) 11247 cfg80211_put_bss(&rdev->wiphy, req.links[link_id].bss); 11248 cfg80211_put_bss(&rdev->wiphy, req.bss); 11249 kfree(attrs); 11250 11251 return err; 11252 } 11253 11254 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info) 11255 { 11256 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11257 struct net_device *dev = info->user_ptr[1]; 11258 const u8 *ie = NULL, *bssid; 11259 int ie_len = 0, err; 11260 u16 reason_code; 11261 bool local_state_change; 11262 11263 if (dev->ieee80211_ptr->conn_owner_nlportid && 11264 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid) 11265 return -EPERM; 11266 11267 if (!info->attrs[NL80211_ATTR_MAC]) 11268 return -EINVAL; 11269 11270 if (!info->attrs[NL80211_ATTR_REASON_CODE]) 11271 return -EINVAL; 11272 11273 if (!rdev->ops->deauth) 11274 return -EOPNOTSUPP; 11275 11276 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 11277 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 11278 return -EOPNOTSUPP; 11279 11280 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 11281 11282 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 11283 if (reason_code == 0) { 11284 /* Reason Code 0 is reserved */ 11285 return -EINVAL; 11286 } 11287 11288 if (info->attrs[NL80211_ATTR_IE]) { 11289 ie = nla_data(info->attrs[NL80211_ATTR_IE]); 11290 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 11291 } 11292 11293 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE]; 11294 11295 wdev_lock(dev->ieee80211_ptr); 11296 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code, 11297 local_state_change); 11298 wdev_unlock(dev->ieee80211_ptr); 11299 return err; 11300 } 11301 11302 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info) 11303 { 11304 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11305 struct net_device *dev = info->user_ptr[1]; 11306 const u8 *ie = NULL, *bssid; 11307 int ie_len = 0, err; 11308 u16 reason_code; 11309 bool local_state_change; 11310 11311 if (dev->ieee80211_ptr->conn_owner_nlportid && 11312 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid) 11313 return -EPERM; 11314 11315 if (!info->attrs[NL80211_ATTR_MAC]) 11316 return -EINVAL; 11317 11318 if (!info->attrs[NL80211_ATTR_REASON_CODE]) 11319 return -EINVAL; 11320 11321 if (!rdev->ops->disassoc) 11322 return -EOPNOTSUPP; 11323 11324 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 11325 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 11326 return -EOPNOTSUPP; 11327 11328 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 11329 11330 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 11331 if (reason_code == 0) { 11332 /* Reason Code 0 is reserved */ 11333 return -EINVAL; 11334 } 11335 11336 if (info->attrs[NL80211_ATTR_IE]) { 11337 ie = nla_data(info->attrs[NL80211_ATTR_IE]); 11338 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 11339 } 11340 11341 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE]; 11342 11343 wdev_lock(dev->ieee80211_ptr); 11344 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code, 11345 local_state_change); 11346 wdev_unlock(dev->ieee80211_ptr); 11347 return err; 11348 } 11349 11350 static bool 11351 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev, 11352 int mcast_rate[NUM_NL80211_BANDS], 11353 int rateval) 11354 { 11355 struct wiphy *wiphy = &rdev->wiphy; 11356 bool found = false; 11357 int band, i; 11358 11359 for (band = 0; band < NUM_NL80211_BANDS; band++) { 11360 struct ieee80211_supported_band *sband; 11361 11362 sband = wiphy->bands[band]; 11363 if (!sband) 11364 continue; 11365 11366 for (i = 0; i < sband->n_bitrates; i++) { 11367 if (sband->bitrates[i].bitrate == rateval) { 11368 mcast_rate[band] = i + 1; 11369 found = true; 11370 break; 11371 } 11372 } 11373 } 11374 11375 return found; 11376 } 11377 11378 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info) 11379 { 11380 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11381 struct net_device *dev = info->user_ptr[1]; 11382 struct cfg80211_ibss_params ibss; 11383 struct wiphy *wiphy; 11384 struct cfg80211_cached_keys *connkeys = NULL; 11385 int err; 11386 11387 memset(&ibss, 0, sizeof(ibss)); 11388 11389 if (!info->attrs[NL80211_ATTR_SSID] || 11390 !nla_len(info->attrs[NL80211_ATTR_SSID])) 11391 return -EINVAL; 11392 11393 ibss.beacon_interval = 100; 11394 11395 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) 11396 ibss.beacon_interval = 11397 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]); 11398 11399 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC, 11400 ibss.beacon_interval); 11401 if (err) 11402 return err; 11403 11404 if (!rdev->ops->join_ibss) 11405 return -EOPNOTSUPP; 11406 11407 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) 11408 return -EOPNOTSUPP; 11409 11410 wiphy = &rdev->wiphy; 11411 11412 if (info->attrs[NL80211_ATTR_MAC]) { 11413 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 11414 11415 if (!is_valid_ether_addr(ibss.bssid)) 11416 return -EINVAL; 11417 } 11418 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 11419 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 11420 11421 if (info->attrs[NL80211_ATTR_IE]) { 11422 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 11423 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 11424 } 11425 11426 err = nl80211_parse_chandef(rdev, info, &ibss.chandef); 11427 if (err) 11428 return err; 11429 11430 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef, 11431 NL80211_IFTYPE_ADHOC)) 11432 return -EINVAL; 11433 11434 switch (ibss.chandef.width) { 11435 case NL80211_CHAN_WIDTH_5: 11436 case NL80211_CHAN_WIDTH_10: 11437 case NL80211_CHAN_WIDTH_20_NOHT: 11438 break; 11439 case NL80211_CHAN_WIDTH_20: 11440 case NL80211_CHAN_WIDTH_40: 11441 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS)) 11442 return -EINVAL; 11443 break; 11444 case NL80211_CHAN_WIDTH_80: 11445 case NL80211_CHAN_WIDTH_80P80: 11446 case NL80211_CHAN_WIDTH_160: 11447 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS)) 11448 return -EINVAL; 11449 if (!wiphy_ext_feature_isset(&rdev->wiphy, 11450 NL80211_EXT_FEATURE_VHT_IBSS)) 11451 return -EINVAL; 11452 break; 11453 case NL80211_CHAN_WIDTH_320: 11454 return -EINVAL; 11455 default: 11456 return -EINVAL; 11457 } 11458 11459 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED]; 11460 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY]; 11461 11462 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) { 11463 u8 *rates = 11464 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 11465 int n_rates = 11466 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 11467 struct ieee80211_supported_band *sband = 11468 wiphy->bands[ibss.chandef.chan->band]; 11469 11470 err = ieee80211_get_ratemask(sband, rates, n_rates, 11471 &ibss.basic_rates); 11472 if (err) 11473 return err; 11474 } 11475 11476 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) 11477 memcpy(&ibss.ht_capa_mask, 11478 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]), 11479 sizeof(ibss.ht_capa_mask)); 11480 11481 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) { 11482 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) 11483 return -EINVAL; 11484 memcpy(&ibss.ht_capa, 11485 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]), 11486 sizeof(ibss.ht_capa)); 11487 } 11488 11489 if (info->attrs[NL80211_ATTR_MCAST_RATE] && 11490 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate, 11491 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]))) 11492 return -EINVAL; 11493 11494 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) { 11495 bool no_ht = false; 11496 11497 connkeys = nl80211_parse_connkeys(rdev, info, &no_ht); 11498 if (IS_ERR(connkeys)) 11499 return PTR_ERR(connkeys); 11500 11501 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) && 11502 no_ht) { 11503 kfree_sensitive(connkeys); 11504 return -EINVAL; 11505 } 11506 } 11507 11508 ibss.control_port = 11509 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]); 11510 11511 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) { 11512 int r = validate_pae_over_nl80211(rdev, info); 11513 11514 if (r < 0) { 11515 kfree_sensitive(connkeys); 11516 return r; 11517 } 11518 11519 ibss.control_port_over_nl80211 = true; 11520 } 11521 11522 ibss.userspace_handles_dfs = 11523 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]); 11524 11525 wdev_lock(dev->ieee80211_ptr); 11526 err = __cfg80211_join_ibss(rdev, dev, &ibss, connkeys); 11527 if (err) 11528 kfree_sensitive(connkeys); 11529 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) 11530 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid; 11531 wdev_unlock(dev->ieee80211_ptr); 11532 11533 return err; 11534 } 11535 11536 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info) 11537 { 11538 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11539 struct net_device *dev = info->user_ptr[1]; 11540 11541 if (!rdev->ops->leave_ibss) 11542 return -EOPNOTSUPP; 11543 11544 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) 11545 return -EOPNOTSUPP; 11546 11547 return cfg80211_leave_ibss(rdev, dev, false); 11548 } 11549 11550 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info) 11551 { 11552 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11553 struct net_device *dev = info->user_ptr[1]; 11554 int mcast_rate[NUM_NL80211_BANDS]; 11555 u32 nla_rate; 11556 11557 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC && 11558 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT && 11559 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB) 11560 return -EOPNOTSUPP; 11561 11562 if (!rdev->ops->set_mcast_rate) 11563 return -EOPNOTSUPP; 11564 11565 memset(mcast_rate, 0, sizeof(mcast_rate)); 11566 11567 if (!info->attrs[NL80211_ATTR_MCAST_RATE]) 11568 return -EINVAL; 11569 11570 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]); 11571 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate)) 11572 return -EINVAL; 11573 11574 return rdev_set_mcast_rate(rdev, dev, mcast_rate); 11575 } 11576 11577 static struct sk_buff * 11578 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev, 11579 struct wireless_dev *wdev, int approxlen, 11580 u32 portid, u32 seq, enum nl80211_commands cmd, 11581 enum nl80211_attrs attr, 11582 const struct nl80211_vendor_cmd_info *info, 11583 gfp_t gfp) 11584 { 11585 struct sk_buff *skb; 11586 void *hdr; 11587 struct nlattr *data; 11588 11589 skb = nlmsg_new(approxlen + 100, gfp); 11590 if (!skb) 11591 return NULL; 11592 11593 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd); 11594 if (!hdr) { 11595 kfree_skb(skb); 11596 return NULL; 11597 } 11598 11599 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx)) 11600 goto nla_put_failure; 11601 11602 if (info) { 11603 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID, 11604 info->vendor_id)) 11605 goto nla_put_failure; 11606 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD, 11607 info->subcmd)) 11608 goto nla_put_failure; 11609 } 11610 11611 if (wdev) { 11612 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV, 11613 wdev_id(wdev), NL80211_ATTR_PAD)) 11614 goto nla_put_failure; 11615 if (wdev->netdev && 11616 nla_put_u32(skb, NL80211_ATTR_IFINDEX, 11617 wdev->netdev->ifindex)) 11618 goto nla_put_failure; 11619 } 11620 11621 data = nla_nest_start_noflag(skb, attr); 11622 if (!data) 11623 goto nla_put_failure; 11624 11625 ((void **)skb->cb)[0] = rdev; 11626 ((void **)skb->cb)[1] = hdr; 11627 ((void **)skb->cb)[2] = data; 11628 11629 return skb; 11630 11631 nla_put_failure: 11632 kfree_skb(skb); 11633 return NULL; 11634 } 11635 11636 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy, 11637 struct wireless_dev *wdev, 11638 enum nl80211_commands cmd, 11639 enum nl80211_attrs attr, 11640 unsigned int portid, 11641 int vendor_event_idx, 11642 int approxlen, gfp_t gfp) 11643 { 11644 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 11645 const struct nl80211_vendor_cmd_info *info; 11646 11647 switch (cmd) { 11648 case NL80211_CMD_TESTMODE: 11649 if (WARN_ON(vendor_event_idx != -1)) 11650 return NULL; 11651 info = NULL; 11652 break; 11653 case NL80211_CMD_VENDOR: 11654 if (WARN_ON(vendor_event_idx < 0 || 11655 vendor_event_idx >= wiphy->n_vendor_events)) 11656 return NULL; 11657 info = &wiphy->vendor_events[vendor_event_idx]; 11658 break; 11659 default: 11660 WARN_ON(1); 11661 return NULL; 11662 } 11663 11664 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, portid, 0, 11665 cmd, attr, info, gfp); 11666 } 11667 EXPORT_SYMBOL(__cfg80211_alloc_event_skb); 11668 11669 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp) 11670 { 11671 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0]; 11672 void *hdr = ((void **)skb->cb)[1]; 11673 struct nlmsghdr *nlhdr = nlmsg_hdr(skb); 11674 struct nlattr *data = ((void **)skb->cb)[2]; 11675 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE; 11676 11677 /* clear CB data for netlink core to own from now on */ 11678 memset(skb->cb, 0, sizeof(skb->cb)); 11679 11680 nla_nest_end(skb, data); 11681 genlmsg_end(skb, hdr); 11682 11683 if (nlhdr->nlmsg_pid) { 11684 genlmsg_unicast(wiphy_net(&rdev->wiphy), skb, 11685 nlhdr->nlmsg_pid); 11686 } else { 11687 if (data->nla_type == NL80211_ATTR_VENDOR_DATA) 11688 mcgrp = NL80211_MCGRP_VENDOR; 11689 11690 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), 11691 skb, 0, mcgrp, gfp); 11692 } 11693 } 11694 EXPORT_SYMBOL(__cfg80211_send_event_skb); 11695 11696 #ifdef CONFIG_NL80211_TESTMODE 11697 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info) 11698 { 11699 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11700 struct wireless_dev *wdev; 11701 int err; 11702 11703 lockdep_assert_held(&rdev->wiphy.mtx); 11704 11705 wdev = __cfg80211_wdev_from_attrs(rdev, genl_info_net(info), 11706 info->attrs); 11707 11708 if (!rdev->ops->testmode_cmd) 11709 return -EOPNOTSUPP; 11710 11711 if (IS_ERR(wdev)) { 11712 err = PTR_ERR(wdev); 11713 if (err != -EINVAL) 11714 return err; 11715 wdev = NULL; 11716 } else if (wdev->wiphy != &rdev->wiphy) { 11717 return -EINVAL; 11718 } 11719 11720 if (!info->attrs[NL80211_ATTR_TESTDATA]) 11721 return -EINVAL; 11722 11723 rdev->cur_cmd_info = info; 11724 err = rdev_testmode_cmd(rdev, wdev, 11725 nla_data(info->attrs[NL80211_ATTR_TESTDATA]), 11726 nla_len(info->attrs[NL80211_ATTR_TESTDATA])); 11727 rdev->cur_cmd_info = NULL; 11728 11729 return err; 11730 } 11731 11732 static int nl80211_testmode_dump(struct sk_buff *skb, 11733 struct netlink_callback *cb) 11734 { 11735 struct cfg80211_registered_device *rdev; 11736 struct nlattr **attrbuf = NULL; 11737 int err; 11738 long phy_idx; 11739 void *data = NULL; 11740 int data_len = 0; 11741 11742 rtnl_lock(); 11743 11744 if (cb->args[0]) { 11745 /* 11746 * 0 is a valid index, but not valid for args[0], 11747 * so we need to offset by 1. 11748 */ 11749 phy_idx = cb->args[0] - 1; 11750 11751 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx); 11752 if (!rdev) { 11753 err = -ENOENT; 11754 goto out_err; 11755 } 11756 } else { 11757 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), 11758 GFP_KERNEL); 11759 if (!attrbuf) { 11760 err = -ENOMEM; 11761 goto out_err; 11762 } 11763 11764 err = nlmsg_parse_deprecated(cb->nlh, 11765 GENL_HDRLEN + nl80211_fam.hdrsize, 11766 attrbuf, nl80211_fam.maxattr, 11767 nl80211_policy, NULL); 11768 if (err) 11769 goto out_err; 11770 11771 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf); 11772 if (IS_ERR(rdev)) { 11773 err = PTR_ERR(rdev); 11774 goto out_err; 11775 } 11776 phy_idx = rdev->wiphy_idx; 11777 11778 if (attrbuf[NL80211_ATTR_TESTDATA]) 11779 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA]; 11780 } 11781 11782 if (cb->args[1]) { 11783 data = nla_data((void *)cb->args[1]); 11784 data_len = nla_len((void *)cb->args[1]); 11785 } 11786 11787 if (!rdev->ops->testmode_dump) { 11788 err = -EOPNOTSUPP; 11789 goto out_err; 11790 } 11791 11792 while (1) { 11793 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid, 11794 cb->nlh->nlmsg_seq, NLM_F_MULTI, 11795 NL80211_CMD_TESTMODE); 11796 struct nlattr *tmdata; 11797 11798 if (!hdr) 11799 break; 11800 11801 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) { 11802 genlmsg_cancel(skb, hdr); 11803 break; 11804 } 11805 11806 tmdata = nla_nest_start_noflag(skb, NL80211_ATTR_TESTDATA); 11807 if (!tmdata) { 11808 genlmsg_cancel(skb, hdr); 11809 break; 11810 } 11811 err = rdev_testmode_dump(rdev, skb, cb, data, data_len); 11812 nla_nest_end(skb, tmdata); 11813 11814 if (err == -ENOBUFS || err == -ENOENT) { 11815 genlmsg_cancel(skb, hdr); 11816 break; 11817 } else if (err) { 11818 genlmsg_cancel(skb, hdr); 11819 goto out_err; 11820 } 11821 11822 genlmsg_end(skb, hdr); 11823 } 11824 11825 err = skb->len; 11826 /* see above */ 11827 cb->args[0] = phy_idx + 1; 11828 out_err: 11829 kfree(attrbuf); 11830 rtnl_unlock(); 11831 return err; 11832 } 11833 #endif 11834 11835 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info) 11836 { 11837 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 11838 struct net_device *dev = info->user_ptr[1]; 11839 struct cfg80211_connect_params connect; 11840 struct wiphy *wiphy; 11841 struct cfg80211_cached_keys *connkeys = NULL; 11842 u32 freq = 0; 11843 int err; 11844 11845 memset(&connect, 0, sizeof(connect)); 11846 11847 if (!info->attrs[NL80211_ATTR_SSID] || 11848 !nla_len(info->attrs[NL80211_ATTR_SSID])) 11849 return -EINVAL; 11850 11851 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) { 11852 connect.auth_type = 11853 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]); 11854 if (!nl80211_valid_auth_type(rdev, connect.auth_type, 11855 NL80211_CMD_CONNECT)) 11856 return -EINVAL; 11857 } else 11858 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC; 11859 11860 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY]; 11861 11862 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] && 11863 !wiphy_ext_feature_isset(&rdev->wiphy, 11864 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X)) 11865 return -EINVAL; 11866 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS]; 11867 11868 err = nl80211_crypto_settings(rdev, info, &connect.crypto, 11869 NL80211_MAX_NR_CIPHER_SUITES); 11870 if (err) 11871 return err; 11872 11873 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 11874 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 11875 return -EOPNOTSUPP; 11876 11877 wiphy = &rdev->wiphy; 11878 11879 connect.bg_scan_period = -1; 11880 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] && 11881 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) { 11882 connect.bg_scan_period = 11883 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]); 11884 } 11885 11886 if (info->attrs[NL80211_ATTR_MAC]) 11887 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 11888 else if (info->attrs[NL80211_ATTR_MAC_HINT]) 11889 connect.bssid_hint = 11890 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]); 11891 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 11892 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 11893 11894 if (info->attrs[NL80211_ATTR_IE]) { 11895 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 11896 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 11897 } 11898 11899 if (info->attrs[NL80211_ATTR_USE_MFP]) { 11900 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]); 11901 if (connect.mfp == NL80211_MFP_OPTIONAL && 11902 !wiphy_ext_feature_isset(&rdev->wiphy, 11903 NL80211_EXT_FEATURE_MFP_OPTIONAL)) 11904 return -EOPNOTSUPP; 11905 } else { 11906 connect.mfp = NL80211_MFP_NO; 11907 } 11908 11909 if (info->attrs[NL80211_ATTR_PREV_BSSID]) 11910 connect.prev_bssid = 11911 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]); 11912 11913 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) 11914 freq = MHZ_TO_KHZ(nla_get_u32( 11915 info->attrs[NL80211_ATTR_WIPHY_FREQ])); 11916 if (info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]) 11917 freq += 11918 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_OFFSET]); 11919 11920 if (freq) { 11921 connect.channel = nl80211_get_valid_chan(wiphy, freq); 11922 if (!connect.channel) 11923 return -EINVAL; 11924 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) { 11925 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]); 11926 freq = MHZ_TO_KHZ(freq); 11927 connect.channel_hint = nl80211_get_valid_chan(wiphy, freq); 11928 if (!connect.channel_hint) 11929 return -EINVAL; 11930 } 11931 11932 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) { 11933 connect.edmg.channels = 11934 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]); 11935 11936 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]) 11937 connect.edmg.bw_config = 11938 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]); 11939 } 11940 11941 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) { 11942 connkeys = nl80211_parse_connkeys(rdev, info, NULL); 11943 if (IS_ERR(connkeys)) 11944 return PTR_ERR(connkeys); 11945 } 11946 11947 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT])) 11948 connect.flags |= ASSOC_REQ_DISABLE_HT; 11949 11950 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) 11951 memcpy(&connect.ht_capa_mask, 11952 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]), 11953 sizeof(connect.ht_capa_mask)); 11954 11955 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) { 11956 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) { 11957 kfree_sensitive(connkeys); 11958 return -EINVAL; 11959 } 11960 memcpy(&connect.ht_capa, 11961 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]), 11962 sizeof(connect.ht_capa)); 11963 } 11964 11965 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT])) 11966 connect.flags |= ASSOC_REQ_DISABLE_VHT; 11967 11968 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HE])) 11969 connect.flags |= ASSOC_REQ_DISABLE_HE; 11970 11971 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_EHT])) 11972 connect.flags |= ASSOC_REQ_DISABLE_EHT; 11973 11974 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) 11975 memcpy(&connect.vht_capa_mask, 11976 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]), 11977 sizeof(connect.vht_capa_mask)); 11978 11979 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) { 11980 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) { 11981 kfree_sensitive(connkeys); 11982 return -EINVAL; 11983 } 11984 memcpy(&connect.vht_capa, 11985 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]), 11986 sizeof(connect.vht_capa)); 11987 } 11988 11989 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) { 11990 if (!((rdev->wiphy.features & 11991 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) && 11992 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) && 11993 !wiphy_ext_feature_isset(&rdev->wiphy, 11994 NL80211_EXT_FEATURE_RRM)) { 11995 kfree_sensitive(connkeys); 11996 return -EINVAL; 11997 } 11998 connect.flags |= ASSOC_REQ_USE_RRM; 11999 } 12000 12001 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]); 12002 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) { 12003 kfree_sensitive(connkeys); 12004 return -EOPNOTSUPP; 12005 } 12006 12007 if (info->attrs[NL80211_ATTR_BSS_SELECT]) { 12008 /* bss selection makes no sense if bssid is set */ 12009 if (connect.bssid) { 12010 kfree_sensitive(connkeys); 12011 return -EINVAL; 12012 } 12013 12014 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT], 12015 wiphy, &connect.bss_select); 12016 if (err) { 12017 kfree_sensitive(connkeys); 12018 return err; 12019 } 12020 } 12021 12022 if (wiphy_ext_feature_isset(&rdev->wiphy, 12023 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) && 12024 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] && 12025 info->attrs[NL80211_ATTR_FILS_ERP_REALM] && 12026 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] && 12027 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) { 12028 connect.fils_erp_username = 12029 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]); 12030 connect.fils_erp_username_len = 12031 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]); 12032 connect.fils_erp_realm = 12033 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]); 12034 connect.fils_erp_realm_len = 12035 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]); 12036 connect.fils_erp_next_seq_num = 12037 nla_get_u16( 12038 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]); 12039 connect.fils_erp_rrk = 12040 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]); 12041 connect.fils_erp_rrk_len = 12042 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]); 12043 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] || 12044 info->attrs[NL80211_ATTR_FILS_ERP_REALM] || 12045 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] || 12046 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) { 12047 kfree_sensitive(connkeys); 12048 return -EINVAL; 12049 } 12050 12051 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) { 12052 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) { 12053 kfree_sensitive(connkeys); 12054 GENL_SET_ERR_MSG(info, 12055 "external auth requires connection ownership"); 12056 return -EINVAL; 12057 } 12058 connect.flags |= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT; 12059 } 12060 12061 if (nla_get_flag(info->attrs[NL80211_ATTR_MLO_SUPPORT])) 12062 connect.flags |= CONNECT_REQ_MLO_SUPPORT; 12063 12064 wdev_lock(dev->ieee80211_ptr); 12065 12066 err = cfg80211_connect(rdev, dev, &connect, connkeys, 12067 connect.prev_bssid); 12068 if (err) 12069 kfree_sensitive(connkeys); 12070 12071 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) { 12072 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid; 12073 if (connect.bssid) 12074 memcpy(dev->ieee80211_ptr->disconnect_bssid, 12075 connect.bssid, ETH_ALEN); 12076 else 12077 eth_zero_addr(dev->ieee80211_ptr->disconnect_bssid); 12078 } 12079 12080 wdev_unlock(dev->ieee80211_ptr); 12081 12082 return err; 12083 } 12084 12085 static int nl80211_update_connect_params(struct sk_buff *skb, 12086 struct genl_info *info) 12087 { 12088 struct cfg80211_connect_params connect = {}; 12089 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12090 struct net_device *dev = info->user_ptr[1]; 12091 struct wireless_dev *wdev = dev->ieee80211_ptr; 12092 bool fils_sk_offload; 12093 u32 auth_type; 12094 u32 changed = 0; 12095 int ret; 12096 12097 if (!rdev->ops->update_connect_params) 12098 return -EOPNOTSUPP; 12099 12100 if (info->attrs[NL80211_ATTR_IE]) { 12101 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 12102 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 12103 changed |= UPDATE_ASSOC_IES; 12104 } 12105 12106 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy, 12107 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD); 12108 12109 /* 12110 * when driver supports fils-sk offload all attributes must be 12111 * provided. So the else covers "fils-sk-not-all" and 12112 * "no-fils-sk-any". 12113 */ 12114 if (fils_sk_offload && 12115 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] && 12116 info->attrs[NL80211_ATTR_FILS_ERP_REALM] && 12117 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] && 12118 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) { 12119 connect.fils_erp_username = 12120 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]); 12121 connect.fils_erp_username_len = 12122 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]); 12123 connect.fils_erp_realm = 12124 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]); 12125 connect.fils_erp_realm_len = 12126 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]); 12127 connect.fils_erp_next_seq_num = 12128 nla_get_u16( 12129 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]); 12130 connect.fils_erp_rrk = 12131 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]); 12132 connect.fils_erp_rrk_len = 12133 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]); 12134 changed |= UPDATE_FILS_ERP_INFO; 12135 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] || 12136 info->attrs[NL80211_ATTR_FILS_ERP_REALM] || 12137 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] || 12138 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) { 12139 return -EINVAL; 12140 } 12141 12142 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) { 12143 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]); 12144 if (!nl80211_valid_auth_type(rdev, auth_type, 12145 NL80211_CMD_CONNECT)) 12146 return -EINVAL; 12147 12148 if (auth_type == NL80211_AUTHTYPE_FILS_SK && 12149 fils_sk_offload && !(changed & UPDATE_FILS_ERP_INFO)) 12150 return -EINVAL; 12151 12152 connect.auth_type = auth_type; 12153 changed |= UPDATE_AUTH_TYPE; 12154 } 12155 12156 wdev_lock(dev->ieee80211_ptr); 12157 if (!wdev->connected) 12158 ret = -ENOLINK; 12159 else 12160 ret = rdev_update_connect_params(rdev, dev, &connect, changed); 12161 wdev_unlock(dev->ieee80211_ptr); 12162 12163 return ret; 12164 } 12165 12166 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info) 12167 { 12168 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12169 struct net_device *dev = info->user_ptr[1]; 12170 u16 reason; 12171 int ret; 12172 12173 if (dev->ieee80211_ptr->conn_owner_nlportid && 12174 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid) 12175 return -EPERM; 12176 12177 if (!info->attrs[NL80211_ATTR_REASON_CODE]) 12178 reason = WLAN_REASON_DEAUTH_LEAVING; 12179 else 12180 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]); 12181 12182 if (reason == 0) 12183 return -EINVAL; 12184 12185 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 12186 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 12187 return -EOPNOTSUPP; 12188 12189 wdev_lock(dev->ieee80211_ptr); 12190 ret = cfg80211_disconnect(rdev, dev, reason, true); 12191 wdev_unlock(dev->ieee80211_ptr); 12192 return ret; 12193 } 12194 12195 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info) 12196 { 12197 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12198 struct net *net; 12199 int err; 12200 12201 if (info->attrs[NL80211_ATTR_PID]) { 12202 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]); 12203 12204 net = get_net_ns_by_pid(pid); 12205 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) { 12206 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]); 12207 12208 net = get_net_ns_by_fd(fd); 12209 } else { 12210 return -EINVAL; 12211 } 12212 12213 if (IS_ERR(net)) 12214 return PTR_ERR(net); 12215 12216 err = 0; 12217 12218 /* check if anything to do */ 12219 if (!net_eq(wiphy_net(&rdev->wiphy), net)) 12220 err = cfg80211_switch_netns(rdev, net); 12221 12222 put_net(net); 12223 return err; 12224 } 12225 12226 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info) 12227 { 12228 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12229 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev, 12230 struct cfg80211_pmksa *pmksa) = NULL; 12231 struct net_device *dev = info->user_ptr[1]; 12232 struct cfg80211_pmksa pmksa; 12233 12234 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa)); 12235 12236 if (!info->attrs[NL80211_ATTR_PMKID]) 12237 return -EINVAL; 12238 12239 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]); 12240 12241 if (info->attrs[NL80211_ATTR_MAC]) { 12242 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]); 12243 } else if (info->attrs[NL80211_ATTR_SSID] && 12244 info->attrs[NL80211_ATTR_FILS_CACHE_ID] && 12245 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA || 12246 info->attrs[NL80211_ATTR_PMK])) { 12247 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]); 12248 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 12249 pmksa.cache_id = 12250 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]); 12251 } else { 12252 return -EINVAL; 12253 } 12254 if (info->attrs[NL80211_ATTR_PMK]) { 12255 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]); 12256 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]); 12257 } 12258 12259 if (info->attrs[NL80211_ATTR_PMK_LIFETIME]) 12260 pmksa.pmk_lifetime = 12261 nla_get_u32(info->attrs[NL80211_ATTR_PMK_LIFETIME]); 12262 12263 if (info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD]) 12264 pmksa.pmk_reauth_threshold = 12265 nla_get_u8( 12266 info->attrs[NL80211_ATTR_PMK_REAUTH_THRESHOLD]); 12267 12268 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 12269 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT && 12270 !(dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP && 12271 wiphy_ext_feature_isset(&rdev->wiphy, 12272 NL80211_EXT_FEATURE_AP_PMKSA_CACHING))) 12273 return -EOPNOTSUPP; 12274 12275 switch (info->genlhdr->cmd) { 12276 case NL80211_CMD_SET_PMKSA: 12277 rdev_ops = rdev->ops->set_pmksa; 12278 break; 12279 case NL80211_CMD_DEL_PMKSA: 12280 rdev_ops = rdev->ops->del_pmksa; 12281 break; 12282 default: 12283 WARN_ON(1); 12284 break; 12285 } 12286 12287 if (!rdev_ops) 12288 return -EOPNOTSUPP; 12289 12290 return rdev_ops(&rdev->wiphy, dev, &pmksa); 12291 } 12292 12293 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info) 12294 { 12295 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12296 struct net_device *dev = info->user_ptr[1]; 12297 12298 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION && 12299 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT) 12300 return -EOPNOTSUPP; 12301 12302 if (!rdev->ops->flush_pmksa) 12303 return -EOPNOTSUPP; 12304 12305 return rdev_flush_pmksa(rdev, dev); 12306 } 12307 12308 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info) 12309 { 12310 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12311 struct net_device *dev = info->user_ptr[1]; 12312 u8 action_code, dialog_token; 12313 u32 peer_capability = 0; 12314 u16 status_code; 12315 u8 *peer; 12316 int link_id; 12317 bool initiator; 12318 12319 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) || 12320 !rdev->ops->tdls_mgmt) 12321 return -EOPNOTSUPP; 12322 12323 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] || 12324 !info->attrs[NL80211_ATTR_STATUS_CODE] || 12325 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] || 12326 !info->attrs[NL80211_ATTR_IE] || 12327 !info->attrs[NL80211_ATTR_MAC]) 12328 return -EINVAL; 12329 12330 peer = nla_data(info->attrs[NL80211_ATTR_MAC]); 12331 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]); 12332 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]); 12333 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]); 12334 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]); 12335 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]) 12336 peer_capability = 12337 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]); 12338 link_id = nl80211_link_id_or_invalid(info->attrs); 12339 12340 return rdev_tdls_mgmt(rdev, dev, peer, link_id, action_code, 12341 dialog_token, status_code, peer_capability, 12342 initiator, 12343 nla_data(info->attrs[NL80211_ATTR_IE]), 12344 nla_len(info->attrs[NL80211_ATTR_IE])); 12345 } 12346 12347 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info) 12348 { 12349 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12350 struct net_device *dev = info->user_ptr[1]; 12351 enum nl80211_tdls_operation operation; 12352 u8 *peer; 12353 12354 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) || 12355 !rdev->ops->tdls_oper) 12356 return -EOPNOTSUPP; 12357 12358 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] || 12359 !info->attrs[NL80211_ATTR_MAC]) 12360 return -EINVAL; 12361 12362 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]); 12363 peer = nla_data(info->attrs[NL80211_ATTR_MAC]); 12364 12365 return rdev_tdls_oper(rdev, dev, peer, operation); 12366 } 12367 12368 static int nl80211_remain_on_channel(struct sk_buff *skb, 12369 struct genl_info *info) 12370 { 12371 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12372 unsigned int link_id = nl80211_link_id(info->attrs); 12373 struct wireless_dev *wdev = info->user_ptr[1]; 12374 struct cfg80211_chan_def chandef; 12375 struct sk_buff *msg; 12376 void *hdr; 12377 u64 cookie; 12378 u32 duration; 12379 int err; 12380 12381 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] || 12382 !info->attrs[NL80211_ATTR_DURATION]) 12383 return -EINVAL; 12384 12385 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]); 12386 12387 if (!rdev->ops->remain_on_channel || 12388 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)) 12389 return -EOPNOTSUPP; 12390 12391 /* 12392 * We should be on that channel for at least a minimum amount of 12393 * time (10ms) but no longer than the driver supports. 12394 */ 12395 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME || 12396 duration > rdev->wiphy.max_remain_on_channel_duration) 12397 return -EINVAL; 12398 12399 err = nl80211_parse_chandef(rdev, info, &chandef); 12400 if (err) 12401 return err; 12402 12403 wdev_lock(wdev); 12404 if (!cfg80211_off_channel_oper_allowed(wdev, chandef.chan)) { 12405 const struct cfg80211_chan_def *oper_chandef, *compat_chandef; 12406 12407 oper_chandef = wdev_chandef(wdev, link_id); 12408 12409 if (WARN_ON(!oper_chandef)) { 12410 /* cannot happen since we must beacon to get here */ 12411 WARN_ON(1); 12412 wdev_unlock(wdev); 12413 return -EBUSY; 12414 } 12415 12416 /* note: returns first one if identical chandefs */ 12417 compat_chandef = cfg80211_chandef_compatible(&chandef, 12418 oper_chandef); 12419 12420 if (compat_chandef != &chandef) { 12421 wdev_unlock(wdev); 12422 return -EBUSY; 12423 } 12424 } 12425 wdev_unlock(wdev); 12426 12427 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 12428 if (!msg) 12429 return -ENOMEM; 12430 12431 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 12432 NL80211_CMD_REMAIN_ON_CHANNEL); 12433 if (!hdr) { 12434 err = -ENOBUFS; 12435 goto free_msg; 12436 } 12437 12438 err = rdev_remain_on_channel(rdev, wdev, chandef.chan, 12439 duration, &cookie); 12440 12441 if (err) 12442 goto free_msg; 12443 12444 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie, 12445 NL80211_ATTR_PAD)) 12446 goto nla_put_failure; 12447 12448 genlmsg_end(msg, hdr); 12449 12450 return genlmsg_reply(msg, info); 12451 12452 nla_put_failure: 12453 err = -ENOBUFS; 12454 free_msg: 12455 nlmsg_free(msg); 12456 return err; 12457 } 12458 12459 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb, 12460 struct genl_info *info) 12461 { 12462 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12463 struct wireless_dev *wdev = info->user_ptr[1]; 12464 u64 cookie; 12465 12466 if (!info->attrs[NL80211_ATTR_COOKIE]) 12467 return -EINVAL; 12468 12469 if (!rdev->ops->cancel_remain_on_channel) 12470 return -EOPNOTSUPP; 12471 12472 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]); 12473 12474 return rdev_cancel_remain_on_channel(rdev, wdev, cookie); 12475 } 12476 12477 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb, 12478 struct genl_info *info) 12479 { 12480 struct cfg80211_bitrate_mask mask; 12481 unsigned int link_id = nl80211_link_id(info->attrs); 12482 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12483 struct net_device *dev = info->user_ptr[1]; 12484 struct wireless_dev *wdev = dev->ieee80211_ptr; 12485 int err; 12486 12487 if (!rdev->ops->set_bitrate_mask) 12488 return -EOPNOTSUPP; 12489 12490 wdev_lock(wdev); 12491 err = nl80211_parse_tx_bitrate_mask(info, info->attrs, 12492 NL80211_ATTR_TX_RATES, &mask, 12493 dev, true, link_id); 12494 if (err) 12495 goto out; 12496 12497 err = rdev_set_bitrate_mask(rdev, dev, link_id, NULL, &mask); 12498 out: 12499 wdev_unlock(wdev); 12500 return err; 12501 } 12502 12503 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info) 12504 { 12505 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12506 struct wireless_dev *wdev = info->user_ptr[1]; 12507 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION; 12508 12509 if (!info->attrs[NL80211_ATTR_FRAME_MATCH]) 12510 return -EINVAL; 12511 12512 if (info->attrs[NL80211_ATTR_FRAME_TYPE]) 12513 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]); 12514 12515 switch (wdev->iftype) { 12516 case NL80211_IFTYPE_STATION: 12517 case NL80211_IFTYPE_ADHOC: 12518 case NL80211_IFTYPE_P2P_CLIENT: 12519 case NL80211_IFTYPE_AP: 12520 case NL80211_IFTYPE_AP_VLAN: 12521 case NL80211_IFTYPE_MESH_POINT: 12522 case NL80211_IFTYPE_P2P_GO: 12523 case NL80211_IFTYPE_P2P_DEVICE: 12524 break; 12525 case NL80211_IFTYPE_NAN: 12526 if (!wiphy_ext_feature_isset(wdev->wiphy, 12527 NL80211_EXT_FEATURE_SECURE_NAN)) 12528 return -EOPNOTSUPP; 12529 break; 12530 default: 12531 return -EOPNOTSUPP; 12532 } 12533 12534 /* not much point in registering if we can't reply */ 12535 if (!rdev->ops->mgmt_tx) 12536 return -EOPNOTSUPP; 12537 12538 if (info->attrs[NL80211_ATTR_RECEIVE_MULTICAST] && 12539 !wiphy_ext_feature_isset(&rdev->wiphy, 12540 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS)) { 12541 GENL_SET_ERR_MSG(info, 12542 "multicast RX registrations are not supported"); 12543 return -EOPNOTSUPP; 12544 } 12545 12546 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type, 12547 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]), 12548 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]), 12549 info->attrs[NL80211_ATTR_RECEIVE_MULTICAST], 12550 info->extack); 12551 } 12552 12553 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info) 12554 { 12555 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12556 struct wireless_dev *wdev = info->user_ptr[1]; 12557 struct cfg80211_chan_def chandef; 12558 int err; 12559 void *hdr = NULL; 12560 u64 cookie; 12561 struct sk_buff *msg = NULL; 12562 struct cfg80211_mgmt_tx_params params = { 12563 .dont_wait_for_ack = 12564 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK], 12565 }; 12566 12567 if (!info->attrs[NL80211_ATTR_FRAME]) 12568 return -EINVAL; 12569 12570 if (!rdev->ops->mgmt_tx) 12571 return -EOPNOTSUPP; 12572 12573 switch (wdev->iftype) { 12574 case NL80211_IFTYPE_P2P_DEVICE: 12575 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ]) 12576 return -EINVAL; 12577 break; 12578 case NL80211_IFTYPE_STATION: 12579 case NL80211_IFTYPE_ADHOC: 12580 case NL80211_IFTYPE_P2P_CLIENT: 12581 case NL80211_IFTYPE_AP: 12582 case NL80211_IFTYPE_AP_VLAN: 12583 case NL80211_IFTYPE_MESH_POINT: 12584 case NL80211_IFTYPE_P2P_GO: 12585 break; 12586 case NL80211_IFTYPE_NAN: 12587 if (!wiphy_ext_feature_isset(wdev->wiphy, 12588 NL80211_EXT_FEATURE_SECURE_NAN)) 12589 return -EOPNOTSUPP; 12590 break; 12591 default: 12592 return -EOPNOTSUPP; 12593 } 12594 12595 if (info->attrs[NL80211_ATTR_DURATION]) { 12596 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX)) 12597 return -EINVAL; 12598 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]); 12599 12600 /* 12601 * We should wait on the channel for at least a minimum amount 12602 * of time (10ms) but no longer than the driver supports. 12603 */ 12604 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME || 12605 params.wait > rdev->wiphy.max_remain_on_channel_duration) 12606 return -EINVAL; 12607 } 12608 12609 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK]; 12610 12611 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX)) 12612 return -EINVAL; 12613 12614 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]); 12615 12616 /* get the channel if any has been specified, otherwise pass NULL to 12617 * the driver. The latter will use the current one 12618 */ 12619 chandef.chan = NULL; 12620 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) { 12621 err = nl80211_parse_chandef(rdev, info, &chandef); 12622 if (err) 12623 return err; 12624 } 12625 12626 if (!chandef.chan && params.offchan) 12627 return -EINVAL; 12628 12629 wdev_lock(wdev); 12630 if (params.offchan && 12631 !cfg80211_off_channel_oper_allowed(wdev, chandef.chan)) { 12632 wdev_unlock(wdev); 12633 return -EBUSY; 12634 } 12635 12636 params.link_id = nl80211_link_id_or_invalid(info->attrs); 12637 /* 12638 * This now races due to the unlock, but we cannot check 12639 * the valid links for the _station_ anyway, so that's up 12640 * to the driver. 12641 */ 12642 if (params.link_id >= 0 && 12643 !(wdev->valid_links & BIT(params.link_id))) { 12644 wdev_unlock(wdev); 12645 return -EINVAL; 12646 } 12647 wdev_unlock(wdev); 12648 12649 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]); 12650 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]); 12651 12652 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) { 12653 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]); 12654 int i; 12655 12656 if (len % sizeof(u16)) 12657 return -EINVAL; 12658 12659 params.n_csa_offsets = len / sizeof(u16); 12660 params.csa_offsets = 12661 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]); 12662 12663 /* check that all the offsets fit the frame */ 12664 for (i = 0; i < params.n_csa_offsets; i++) { 12665 if (params.csa_offsets[i] >= params.len) 12666 return -EINVAL; 12667 } 12668 } 12669 12670 if (!params.dont_wait_for_ack) { 12671 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 12672 if (!msg) 12673 return -ENOMEM; 12674 12675 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 12676 NL80211_CMD_FRAME); 12677 if (!hdr) { 12678 err = -ENOBUFS; 12679 goto free_msg; 12680 } 12681 } 12682 12683 params.chan = chandef.chan; 12684 err = cfg80211_mlme_mgmt_tx(rdev, wdev, ¶ms, &cookie); 12685 if (err) 12686 goto free_msg; 12687 12688 if (msg) { 12689 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie, 12690 NL80211_ATTR_PAD)) 12691 goto nla_put_failure; 12692 12693 genlmsg_end(msg, hdr); 12694 return genlmsg_reply(msg, info); 12695 } 12696 12697 return 0; 12698 12699 nla_put_failure: 12700 err = -ENOBUFS; 12701 free_msg: 12702 nlmsg_free(msg); 12703 return err; 12704 } 12705 12706 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info) 12707 { 12708 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12709 struct wireless_dev *wdev = info->user_ptr[1]; 12710 u64 cookie; 12711 12712 if (!info->attrs[NL80211_ATTR_COOKIE]) 12713 return -EINVAL; 12714 12715 if (!rdev->ops->mgmt_tx_cancel_wait) 12716 return -EOPNOTSUPP; 12717 12718 switch (wdev->iftype) { 12719 case NL80211_IFTYPE_STATION: 12720 case NL80211_IFTYPE_ADHOC: 12721 case NL80211_IFTYPE_P2P_CLIENT: 12722 case NL80211_IFTYPE_AP: 12723 case NL80211_IFTYPE_AP_VLAN: 12724 case NL80211_IFTYPE_P2P_GO: 12725 case NL80211_IFTYPE_P2P_DEVICE: 12726 break; 12727 case NL80211_IFTYPE_NAN: 12728 if (!wiphy_ext_feature_isset(wdev->wiphy, 12729 NL80211_EXT_FEATURE_SECURE_NAN)) 12730 return -EOPNOTSUPP; 12731 break; 12732 default: 12733 return -EOPNOTSUPP; 12734 } 12735 12736 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]); 12737 12738 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie); 12739 } 12740 12741 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info) 12742 { 12743 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12744 struct wireless_dev *wdev; 12745 struct net_device *dev = info->user_ptr[1]; 12746 u8 ps_state; 12747 bool state; 12748 int err; 12749 12750 if (!info->attrs[NL80211_ATTR_PS_STATE]) 12751 return -EINVAL; 12752 12753 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]); 12754 12755 wdev = dev->ieee80211_ptr; 12756 12757 if (!rdev->ops->set_power_mgmt) 12758 return -EOPNOTSUPP; 12759 12760 state = (ps_state == NL80211_PS_ENABLED) ? true : false; 12761 12762 if (state == wdev->ps) 12763 return 0; 12764 12765 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout); 12766 if (!err) 12767 wdev->ps = state; 12768 return err; 12769 } 12770 12771 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info) 12772 { 12773 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12774 enum nl80211_ps_state ps_state; 12775 struct wireless_dev *wdev; 12776 struct net_device *dev = info->user_ptr[1]; 12777 struct sk_buff *msg; 12778 void *hdr; 12779 int err; 12780 12781 wdev = dev->ieee80211_ptr; 12782 12783 if (!rdev->ops->set_power_mgmt) 12784 return -EOPNOTSUPP; 12785 12786 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 12787 if (!msg) 12788 return -ENOMEM; 12789 12790 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 12791 NL80211_CMD_GET_POWER_SAVE); 12792 if (!hdr) { 12793 err = -ENOBUFS; 12794 goto free_msg; 12795 } 12796 12797 if (wdev->ps) 12798 ps_state = NL80211_PS_ENABLED; 12799 else 12800 ps_state = NL80211_PS_DISABLED; 12801 12802 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state)) 12803 goto nla_put_failure; 12804 12805 genlmsg_end(msg, hdr); 12806 return genlmsg_reply(msg, info); 12807 12808 nla_put_failure: 12809 err = -ENOBUFS; 12810 free_msg: 12811 nlmsg_free(msg); 12812 return err; 12813 } 12814 12815 static const struct nla_policy 12816 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = { 12817 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY }, 12818 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 }, 12819 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 }, 12820 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 }, 12821 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 }, 12822 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 }, 12823 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 }, 12824 }; 12825 12826 static int nl80211_set_cqm_txe(struct genl_info *info, 12827 u32 rate, u32 pkts, u32 intvl) 12828 { 12829 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12830 struct net_device *dev = info->user_ptr[1]; 12831 struct wireless_dev *wdev = dev->ieee80211_ptr; 12832 12833 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL) 12834 return -EINVAL; 12835 12836 if (!rdev->ops->set_cqm_txe_config) 12837 return -EOPNOTSUPP; 12838 12839 if (wdev->iftype != NL80211_IFTYPE_STATION && 12840 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT) 12841 return -EOPNOTSUPP; 12842 12843 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl); 12844 } 12845 12846 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev, 12847 struct net_device *dev, 12848 struct cfg80211_cqm_config *cqm_config) 12849 { 12850 struct wireless_dev *wdev = dev->ieee80211_ptr; 12851 s32 last, low, high; 12852 u32 hyst; 12853 int i, n, low_index; 12854 int err; 12855 12856 /* 12857 * Obtain current RSSI value if possible, if not and no RSSI threshold 12858 * event has been received yet, we should receive an event after a 12859 * connection is established and enough beacons received to calculate 12860 * the average. 12861 */ 12862 if (!cqm_config->last_rssi_event_value && 12863 wdev->links[0].client.current_bss && 12864 rdev->ops->get_station) { 12865 struct station_info sinfo = {}; 12866 u8 *mac_addr; 12867 12868 mac_addr = wdev->links[0].client.current_bss->pub.bssid; 12869 12870 err = rdev_get_station(rdev, dev, mac_addr, &sinfo); 12871 if (err) 12872 return err; 12873 12874 cfg80211_sinfo_release_content(&sinfo); 12875 if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG)) 12876 cqm_config->last_rssi_event_value = 12877 (s8) sinfo.rx_beacon_signal_avg; 12878 } 12879 12880 last = cqm_config->last_rssi_event_value; 12881 hyst = cqm_config->rssi_hyst; 12882 n = cqm_config->n_rssi_thresholds; 12883 12884 for (i = 0; i < n; i++) { 12885 i = array_index_nospec(i, n); 12886 if (last < cqm_config->rssi_thresholds[i]) 12887 break; 12888 } 12889 12890 low_index = i - 1; 12891 if (low_index >= 0) { 12892 low_index = array_index_nospec(low_index, n); 12893 low = cqm_config->rssi_thresholds[low_index] - hyst; 12894 } else { 12895 low = S32_MIN; 12896 } 12897 if (i < n) { 12898 i = array_index_nospec(i, n); 12899 high = cqm_config->rssi_thresholds[i] + hyst - 1; 12900 } else { 12901 high = S32_MAX; 12902 } 12903 12904 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high); 12905 } 12906 12907 static int nl80211_set_cqm_rssi(struct genl_info *info, 12908 const s32 *thresholds, int n_thresholds, 12909 u32 hysteresis) 12910 { 12911 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 12912 struct cfg80211_cqm_config *cqm_config = NULL, *old; 12913 struct net_device *dev = info->user_ptr[1]; 12914 struct wireless_dev *wdev = dev->ieee80211_ptr; 12915 int i, err; 12916 s32 prev = S32_MIN; 12917 12918 /* Check all values negative and sorted */ 12919 for (i = 0; i < n_thresholds; i++) { 12920 if (thresholds[i] > 0 || thresholds[i] <= prev) 12921 return -EINVAL; 12922 12923 prev = thresholds[i]; 12924 } 12925 12926 if (wdev->iftype != NL80211_IFTYPE_STATION && 12927 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT) 12928 return -EOPNOTSUPP; 12929 12930 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */ 12931 n_thresholds = 0; 12932 12933 wdev_lock(wdev); 12934 old = rcu_dereference_protected(wdev->cqm_config, 12935 lockdep_is_held(&wdev->mtx)); 12936 12937 /* if already disabled just succeed */ 12938 if (!n_thresholds && !old) { 12939 err = 0; 12940 goto unlock; 12941 } 12942 12943 if (n_thresholds > 1) { 12944 if (!wiphy_ext_feature_isset(&rdev->wiphy, 12945 NL80211_EXT_FEATURE_CQM_RSSI_LIST) || 12946 !rdev->ops->set_cqm_rssi_range_config) { 12947 err = -EOPNOTSUPP; 12948 goto unlock; 12949 } 12950 } else { 12951 if (!rdev->ops->set_cqm_rssi_config) { 12952 err = -EOPNOTSUPP; 12953 goto unlock; 12954 } 12955 } 12956 12957 if (n_thresholds) { 12958 cqm_config = kzalloc(struct_size(cqm_config, rssi_thresholds, 12959 n_thresholds), 12960 GFP_KERNEL); 12961 if (!cqm_config) { 12962 err = -ENOMEM; 12963 goto unlock; 12964 } 12965 12966 cqm_config->rssi_hyst = hysteresis; 12967 cqm_config->n_rssi_thresholds = n_thresholds; 12968 memcpy(cqm_config->rssi_thresholds, thresholds, 12969 flex_array_size(cqm_config, rssi_thresholds, 12970 n_thresholds)); 12971 cqm_config->use_range_api = n_thresholds > 1 || 12972 !rdev->ops->set_cqm_rssi_config; 12973 12974 rcu_assign_pointer(wdev->cqm_config, cqm_config); 12975 12976 if (cqm_config->use_range_api) 12977 err = cfg80211_cqm_rssi_update(rdev, dev, cqm_config); 12978 else 12979 err = rdev_set_cqm_rssi_config(rdev, dev, 12980 thresholds[0], 12981 hysteresis); 12982 } else { 12983 RCU_INIT_POINTER(wdev->cqm_config, NULL); 12984 /* if enabled as range also disable via range */ 12985 if (old->use_range_api) 12986 err = rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0); 12987 else 12988 err = rdev_set_cqm_rssi_config(rdev, dev, 0, 0); 12989 } 12990 12991 if (err) { 12992 rcu_assign_pointer(wdev->cqm_config, old); 12993 kfree_rcu(cqm_config, rcu_head); 12994 } else { 12995 kfree_rcu(old, rcu_head); 12996 } 12997 unlock: 12998 wdev_unlock(wdev); 12999 13000 return err; 13001 } 13002 13003 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info) 13004 { 13005 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1]; 13006 struct nlattr *cqm; 13007 int err; 13008 13009 cqm = info->attrs[NL80211_ATTR_CQM]; 13010 if (!cqm) 13011 return -EINVAL; 13012 13013 err = nla_parse_nested_deprecated(attrs, NL80211_ATTR_CQM_MAX, cqm, 13014 nl80211_attr_cqm_policy, 13015 info->extack); 13016 if (err) 13017 return err; 13018 13019 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] && 13020 attrs[NL80211_ATTR_CQM_RSSI_HYST]) { 13021 const s32 *thresholds = 13022 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]); 13023 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]); 13024 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]); 13025 13026 if (len % 4) 13027 return -EINVAL; 13028 13029 return nl80211_set_cqm_rssi(info, thresholds, len / 4, 13030 hysteresis); 13031 } 13032 13033 if (attrs[NL80211_ATTR_CQM_TXE_RATE] && 13034 attrs[NL80211_ATTR_CQM_TXE_PKTS] && 13035 attrs[NL80211_ATTR_CQM_TXE_INTVL]) { 13036 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]); 13037 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]); 13038 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]); 13039 13040 return nl80211_set_cqm_txe(info, rate, pkts, intvl); 13041 } 13042 13043 return -EINVAL; 13044 } 13045 13046 static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info) 13047 { 13048 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13049 struct net_device *dev = info->user_ptr[1]; 13050 struct ocb_setup setup = {}; 13051 int err; 13052 13053 err = nl80211_parse_chandef(rdev, info, &setup.chandef); 13054 if (err) 13055 return err; 13056 13057 return cfg80211_join_ocb(rdev, dev, &setup); 13058 } 13059 13060 static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info) 13061 { 13062 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13063 struct net_device *dev = info->user_ptr[1]; 13064 13065 return cfg80211_leave_ocb(rdev, dev); 13066 } 13067 13068 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info) 13069 { 13070 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13071 struct net_device *dev = info->user_ptr[1]; 13072 struct mesh_config cfg; 13073 struct mesh_setup setup; 13074 int err; 13075 13076 /* start with default */ 13077 memcpy(&cfg, &default_mesh_config, sizeof(cfg)); 13078 memcpy(&setup, &default_mesh_setup, sizeof(setup)); 13079 13080 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) { 13081 /* and parse parameters if given */ 13082 err = nl80211_parse_mesh_config(info, &cfg, NULL); 13083 if (err) 13084 return err; 13085 } 13086 13087 if (!info->attrs[NL80211_ATTR_MESH_ID] || 13088 !nla_len(info->attrs[NL80211_ATTR_MESH_ID])) 13089 return -EINVAL; 13090 13091 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]); 13092 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]); 13093 13094 if (info->attrs[NL80211_ATTR_MCAST_RATE] && 13095 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate, 13096 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]))) 13097 return -EINVAL; 13098 13099 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) { 13100 setup.beacon_interval = 13101 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]); 13102 13103 err = cfg80211_validate_beacon_int(rdev, 13104 NL80211_IFTYPE_MESH_POINT, 13105 setup.beacon_interval); 13106 if (err) 13107 return err; 13108 } 13109 13110 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) { 13111 setup.dtim_period = 13112 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]); 13113 if (setup.dtim_period < 1 || setup.dtim_period > 100) 13114 return -EINVAL; 13115 } 13116 13117 if (info->attrs[NL80211_ATTR_MESH_SETUP]) { 13118 /* parse additional setup parameters if given */ 13119 err = nl80211_parse_mesh_setup(info, &setup); 13120 if (err) 13121 return err; 13122 } 13123 13124 if (setup.user_mpm) 13125 cfg.auto_open_plinks = false; 13126 13127 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) { 13128 err = nl80211_parse_chandef(rdev, info, &setup.chandef); 13129 if (err) 13130 return err; 13131 } else { 13132 /* __cfg80211_join_mesh() will sort it out */ 13133 setup.chandef.chan = NULL; 13134 } 13135 13136 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) { 13137 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 13138 int n_rates = 13139 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]); 13140 struct ieee80211_supported_band *sband; 13141 13142 if (!setup.chandef.chan) 13143 return -EINVAL; 13144 13145 sband = rdev->wiphy.bands[setup.chandef.chan->band]; 13146 13147 err = ieee80211_get_ratemask(sband, rates, n_rates, 13148 &setup.basic_rates); 13149 if (err) 13150 return err; 13151 } 13152 13153 if (info->attrs[NL80211_ATTR_TX_RATES]) { 13154 err = nl80211_parse_tx_bitrate_mask(info, info->attrs, 13155 NL80211_ATTR_TX_RATES, 13156 &setup.beacon_rate, 13157 dev, false, 0); 13158 if (err) 13159 return err; 13160 13161 if (!setup.chandef.chan) 13162 return -EINVAL; 13163 13164 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band, 13165 &setup.beacon_rate); 13166 if (err) 13167 return err; 13168 } 13169 13170 setup.userspace_handles_dfs = 13171 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]); 13172 13173 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) { 13174 int r = validate_pae_over_nl80211(rdev, info); 13175 13176 if (r < 0) 13177 return r; 13178 13179 setup.control_port_over_nl80211 = true; 13180 } 13181 13182 wdev_lock(dev->ieee80211_ptr); 13183 err = __cfg80211_join_mesh(rdev, dev, &setup, &cfg); 13184 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) 13185 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid; 13186 wdev_unlock(dev->ieee80211_ptr); 13187 13188 return err; 13189 } 13190 13191 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info) 13192 { 13193 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13194 struct net_device *dev = info->user_ptr[1]; 13195 13196 return cfg80211_leave_mesh(rdev, dev); 13197 } 13198 13199 #ifdef CONFIG_PM 13200 static int nl80211_send_wowlan_patterns(struct sk_buff *msg, 13201 struct cfg80211_registered_device *rdev) 13202 { 13203 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config; 13204 struct nlattr *nl_pats, *nl_pat; 13205 int i, pat_len; 13206 13207 if (!wowlan->n_patterns) 13208 return 0; 13209 13210 nl_pats = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN); 13211 if (!nl_pats) 13212 return -ENOBUFS; 13213 13214 for (i = 0; i < wowlan->n_patterns; i++) { 13215 nl_pat = nla_nest_start_noflag(msg, i + 1); 13216 if (!nl_pat) 13217 return -ENOBUFS; 13218 pat_len = wowlan->patterns[i].pattern_len; 13219 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8), 13220 wowlan->patterns[i].mask) || 13221 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len, 13222 wowlan->patterns[i].pattern) || 13223 nla_put_u32(msg, NL80211_PKTPAT_OFFSET, 13224 wowlan->patterns[i].pkt_offset)) 13225 return -ENOBUFS; 13226 nla_nest_end(msg, nl_pat); 13227 } 13228 nla_nest_end(msg, nl_pats); 13229 13230 return 0; 13231 } 13232 13233 static int nl80211_send_wowlan_tcp(struct sk_buff *msg, 13234 struct cfg80211_wowlan_tcp *tcp) 13235 { 13236 struct nlattr *nl_tcp; 13237 13238 if (!tcp) 13239 return 0; 13240 13241 nl_tcp = nla_nest_start_noflag(msg, 13242 NL80211_WOWLAN_TRIG_TCP_CONNECTION); 13243 if (!nl_tcp) 13244 return -ENOBUFS; 13245 13246 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) || 13247 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) || 13248 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) || 13249 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) || 13250 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) || 13251 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD, 13252 tcp->payload_len, tcp->payload) || 13253 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL, 13254 tcp->data_interval) || 13255 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD, 13256 tcp->wake_len, tcp->wake_data) || 13257 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK, 13258 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask)) 13259 return -ENOBUFS; 13260 13261 if (tcp->payload_seq.len && 13262 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ, 13263 sizeof(tcp->payload_seq), &tcp->payload_seq)) 13264 return -ENOBUFS; 13265 13266 if (tcp->payload_tok.len && 13267 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN, 13268 sizeof(tcp->payload_tok) + tcp->tokens_size, 13269 &tcp->payload_tok)) 13270 return -ENOBUFS; 13271 13272 nla_nest_end(msg, nl_tcp); 13273 13274 return 0; 13275 } 13276 13277 static int nl80211_send_wowlan_nd(struct sk_buff *msg, 13278 struct cfg80211_sched_scan_request *req) 13279 { 13280 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan; 13281 int i; 13282 13283 if (!req) 13284 return 0; 13285 13286 nd = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_NET_DETECT); 13287 if (!nd) 13288 return -ENOBUFS; 13289 13290 if (req->n_scan_plans == 1 && 13291 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL, 13292 req->scan_plans[0].interval * 1000)) 13293 return -ENOBUFS; 13294 13295 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay)) 13296 return -ENOBUFS; 13297 13298 if (req->relative_rssi_set) { 13299 struct nl80211_bss_select_rssi_adjust rssi_adjust; 13300 13301 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI, 13302 req->relative_rssi)) 13303 return -ENOBUFS; 13304 13305 rssi_adjust.band = req->rssi_adjust.band; 13306 rssi_adjust.delta = req->rssi_adjust.delta; 13307 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST, 13308 sizeof(rssi_adjust), &rssi_adjust)) 13309 return -ENOBUFS; 13310 } 13311 13312 freqs = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES); 13313 if (!freqs) 13314 return -ENOBUFS; 13315 13316 for (i = 0; i < req->n_channels; i++) { 13317 if (nla_put_u32(msg, i, req->channels[i]->center_freq)) 13318 return -ENOBUFS; 13319 } 13320 13321 nla_nest_end(msg, freqs); 13322 13323 if (req->n_match_sets) { 13324 matches = nla_nest_start_noflag(msg, 13325 NL80211_ATTR_SCHED_SCAN_MATCH); 13326 if (!matches) 13327 return -ENOBUFS; 13328 13329 for (i = 0; i < req->n_match_sets; i++) { 13330 match = nla_nest_start_noflag(msg, i); 13331 if (!match) 13332 return -ENOBUFS; 13333 13334 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID, 13335 req->match_sets[i].ssid.ssid_len, 13336 req->match_sets[i].ssid.ssid)) 13337 return -ENOBUFS; 13338 nla_nest_end(msg, match); 13339 } 13340 nla_nest_end(msg, matches); 13341 } 13342 13343 scan_plans = nla_nest_start_noflag(msg, NL80211_ATTR_SCHED_SCAN_PLANS); 13344 if (!scan_plans) 13345 return -ENOBUFS; 13346 13347 for (i = 0; i < req->n_scan_plans; i++) { 13348 scan_plan = nla_nest_start_noflag(msg, i + 1); 13349 if (!scan_plan) 13350 return -ENOBUFS; 13351 13352 if (nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL, 13353 req->scan_plans[i].interval) || 13354 (req->scan_plans[i].iterations && 13355 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS, 13356 req->scan_plans[i].iterations))) 13357 return -ENOBUFS; 13358 nla_nest_end(msg, scan_plan); 13359 } 13360 nla_nest_end(msg, scan_plans); 13361 13362 nla_nest_end(msg, nd); 13363 13364 return 0; 13365 } 13366 13367 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info) 13368 { 13369 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13370 struct sk_buff *msg; 13371 void *hdr; 13372 u32 size = NLMSG_DEFAULT_SIZE; 13373 13374 if (!rdev->wiphy.wowlan) 13375 return -EOPNOTSUPP; 13376 13377 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) { 13378 /* adjust size to have room for all the data */ 13379 size += rdev->wiphy.wowlan_config->tcp->tokens_size + 13380 rdev->wiphy.wowlan_config->tcp->payload_len + 13381 rdev->wiphy.wowlan_config->tcp->wake_len + 13382 rdev->wiphy.wowlan_config->tcp->wake_len / 8; 13383 } 13384 13385 msg = nlmsg_new(size, GFP_KERNEL); 13386 if (!msg) 13387 return -ENOMEM; 13388 13389 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 13390 NL80211_CMD_GET_WOWLAN); 13391 if (!hdr) 13392 goto nla_put_failure; 13393 13394 if (rdev->wiphy.wowlan_config) { 13395 struct nlattr *nl_wowlan; 13396 13397 nl_wowlan = nla_nest_start_noflag(msg, 13398 NL80211_ATTR_WOWLAN_TRIGGERS); 13399 if (!nl_wowlan) 13400 goto nla_put_failure; 13401 13402 if ((rdev->wiphy.wowlan_config->any && 13403 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) || 13404 (rdev->wiphy.wowlan_config->disconnect && 13405 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) || 13406 (rdev->wiphy.wowlan_config->magic_pkt && 13407 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) || 13408 (rdev->wiphy.wowlan_config->gtk_rekey_failure && 13409 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) || 13410 (rdev->wiphy.wowlan_config->eap_identity_req && 13411 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) || 13412 (rdev->wiphy.wowlan_config->four_way_handshake && 13413 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) || 13414 (rdev->wiphy.wowlan_config->rfkill_release && 13415 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))) 13416 goto nla_put_failure; 13417 13418 if (nl80211_send_wowlan_patterns(msg, rdev)) 13419 goto nla_put_failure; 13420 13421 if (nl80211_send_wowlan_tcp(msg, 13422 rdev->wiphy.wowlan_config->tcp)) 13423 goto nla_put_failure; 13424 13425 if (nl80211_send_wowlan_nd( 13426 msg, 13427 rdev->wiphy.wowlan_config->nd_config)) 13428 goto nla_put_failure; 13429 13430 nla_nest_end(msg, nl_wowlan); 13431 } 13432 13433 genlmsg_end(msg, hdr); 13434 return genlmsg_reply(msg, info); 13435 13436 nla_put_failure: 13437 nlmsg_free(msg); 13438 return -ENOBUFS; 13439 } 13440 13441 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev, 13442 struct nlattr *attr, 13443 struct cfg80211_wowlan *trig) 13444 { 13445 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP]; 13446 struct cfg80211_wowlan_tcp *cfg; 13447 struct nl80211_wowlan_tcp_data_token *tok = NULL; 13448 struct nl80211_wowlan_tcp_data_seq *seq = NULL; 13449 u32 size; 13450 u32 data_size, wake_size, tokens_size = 0, wake_mask_size; 13451 int err, port; 13452 13453 if (!rdev->wiphy.wowlan->tcp) 13454 return -EINVAL; 13455 13456 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TCP, attr, 13457 nl80211_wowlan_tcp_policy, NULL); 13458 if (err) 13459 return err; 13460 13461 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] || 13462 !tb[NL80211_WOWLAN_TCP_DST_IPV4] || 13463 !tb[NL80211_WOWLAN_TCP_DST_MAC] || 13464 !tb[NL80211_WOWLAN_TCP_DST_PORT] || 13465 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] || 13466 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] || 13467 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] || 13468 !tb[NL80211_WOWLAN_TCP_WAKE_MASK]) 13469 return -EINVAL; 13470 13471 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]); 13472 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max) 13473 return -EINVAL; 13474 13475 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) > 13476 rdev->wiphy.wowlan->tcp->data_interval_max || 13477 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0) 13478 return -EINVAL; 13479 13480 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]); 13481 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max) 13482 return -EINVAL; 13483 13484 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]); 13485 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8)) 13486 return -EINVAL; 13487 13488 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) { 13489 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]); 13490 13491 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]); 13492 tokens_size = tokln - sizeof(*tok); 13493 13494 if (!tok->len || tokens_size % tok->len) 13495 return -EINVAL; 13496 if (!rdev->wiphy.wowlan->tcp->tok) 13497 return -EINVAL; 13498 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len) 13499 return -EINVAL; 13500 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len) 13501 return -EINVAL; 13502 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize) 13503 return -EINVAL; 13504 if (tok->offset + tok->len > data_size) 13505 return -EINVAL; 13506 } 13507 13508 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) { 13509 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]); 13510 if (!rdev->wiphy.wowlan->tcp->seq) 13511 return -EINVAL; 13512 if (seq->len == 0 || seq->len > 4) 13513 return -EINVAL; 13514 if (seq->len + seq->offset > data_size) 13515 return -EINVAL; 13516 } 13517 13518 size = sizeof(*cfg); 13519 size += data_size; 13520 size += wake_size + wake_mask_size; 13521 size += tokens_size; 13522 13523 cfg = kzalloc(size, GFP_KERNEL); 13524 if (!cfg) 13525 return -ENOMEM; 13526 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]); 13527 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]); 13528 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]), 13529 ETH_ALEN); 13530 if (tb[NL80211_WOWLAN_TCP_SRC_PORT]) 13531 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]); 13532 else 13533 port = 0; 13534 #ifdef CONFIG_INET 13535 /* allocate a socket and port for it and use it */ 13536 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM, 13537 IPPROTO_TCP, &cfg->sock, 1); 13538 if (err) { 13539 kfree(cfg); 13540 return err; 13541 } 13542 if (inet_csk_get_port(cfg->sock->sk, port)) { 13543 sock_release(cfg->sock); 13544 kfree(cfg); 13545 return -EADDRINUSE; 13546 } 13547 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num; 13548 #else 13549 if (!port) { 13550 kfree(cfg); 13551 return -EINVAL; 13552 } 13553 cfg->src_port = port; 13554 #endif 13555 13556 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]); 13557 cfg->payload_len = data_size; 13558 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size; 13559 memcpy((void *)cfg->payload, 13560 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]), 13561 data_size); 13562 if (seq) 13563 cfg->payload_seq = *seq; 13564 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]); 13565 cfg->wake_len = wake_size; 13566 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size; 13567 memcpy((void *)cfg->wake_data, 13568 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]), 13569 wake_size); 13570 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size + 13571 data_size + wake_size; 13572 memcpy((void *)cfg->wake_mask, 13573 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]), 13574 wake_mask_size); 13575 if (tok) { 13576 cfg->tokens_size = tokens_size; 13577 cfg->payload_tok = *tok; 13578 memcpy(cfg->payload_tok.token_stream, tok->token_stream, 13579 tokens_size); 13580 } 13581 13582 trig->tcp = cfg; 13583 13584 return 0; 13585 } 13586 13587 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev, 13588 const struct wiphy_wowlan_support *wowlan, 13589 struct nlattr *attr, 13590 struct cfg80211_wowlan *trig) 13591 { 13592 struct nlattr **tb; 13593 int err; 13594 13595 tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL); 13596 if (!tb) 13597 return -ENOMEM; 13598 13599 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) { 13600 err = -EOPNOTSUPP; 13601 goto out; 13602 } 13603 13604 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_MAX, attr, 13605 nl80211_policy, NULL); 13606 if (err) 13607 goto out; 13608 13609 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb, 13610 wowlan->max_nd_match_sets); 13611 err = PTR_ERR_OR_ZERO(trig->nd_config); 13612 if (err) 13613 trig->nd_config = NULL; 13614 13615 out: 13616 kfree(tb); 13617 return err; 13618 } 13619 13620 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info) 13621 { 13622 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13623 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG]; 13624 struct cfg80211_wowlan new_triggers = {}; 13625 struct cfg80211_wowlan *ntrig; 13626 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan; 13627 int err, i; 13628 bool prev_enabled = rdev->wiphy.wowlan_config; 13629 bool regular = false; 13630 13631 if (!wowlan) 13632 return -EOPNOTSUPP; 13633 13634 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) { 13635 cfg80211_rdev_free_wowlan(rdev); 13636 rdev->wiphy.wowlan_config = NULL; 13637 goto set_wakeup; 13638 } 13639 13640 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TRIG, 13641 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS], 13642 nl80211_wowlan_policy, info->extack); 13643 if (err) 13644 return err; 13645 13646 if (tb[NL80211_WOWLAN_TRIG_ANY]) { 13647 if (!(wowlan->flags & WIPHY_WOWLAN_ANY)) 13648 return -EINVAL; 13649 new_triggers.any = true; 13650 } 13651 13652 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) { 13653 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT)) 13654 return -EINVAL; 13655 new_triggers.disconnect = true; 13656 regular = true; 13657 } 13658 13659 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) { 13660 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT)) 13661 return -EINVAL; 13662 new_triggers.magic_pkt = true; 13663 regular = true; 13664 } 13665 13666 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED]) 13667 return -EINVAL; 13668 13669 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) { 13670 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE)) 13671 return -EINVAL; 13672 new_triggers.gtk_rekey_failure = true; 13673 regular = true; 13674 } 13675 13676 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) { 13677 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ)) 13678 return -EINVAL; 13679 new_triggers.eap_identity_req = true; 13680 regular = true; 13681 } 13682 13683 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) { 13684 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE)) 13685 return -EINVAL; 13686 new_triggers.four_way_handshake = true; 13687 regular = true; 13688 } 13689 13690 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) { 13691 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE)) 13692 return -EINVAL; 13693 new_triggers.rfkill_release = true; 13694 regular = true; 13695 } 13696 13697 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) { 13698 struct nlattr *pat; 13699 int n_patterns = 0; 13700 int rem, pat_len, mask_len, pkt_offset; 13701 struct nlattr *pat_tb[NUM_NL80211_PKTPAT]; 13702 13703 regular = true; 13704 13705 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN], 13706 rem) 13707 n_patterns++; 13708 if (n_patterns > wowlan->n_patterns) 13709 return -EINVAL; 13710 13711 new_triggers.patterns = kcalloc(n_patterns, 13712 sizeof(new_triggers.patterns[0]), 13713 GFP_KERNEL); 13714 if (!new_triggers.patterns) 13715 return -ENOMEM; 13716 13717 new_triggers.n_patterns = n_patterns; 13718 i = 0; 13719 13720 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN], 13721 rem) { 13722 u8 *mask_pat; 13723 13724 err = nla_parse_nested_deprecated(pat_tb, 13725 MAX_NL80211_PKTPAT, 13726 pat, 13727 nl80211_packet_pattern_policy, 13728 info->extack); 13729 if (err) 13730 goto error; 13731 13732 err = -EINVAL; 13733 if (!pat_tb[NL80211_PKTPAT_MASK] || 13734 !pat_tb[NL80211_PKTPAT_PATTERN]) 13735 goto error; 13736 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]); 13737 mask_len = DIV_ROUND_UP(pat_len, 8); 13738 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len) 13739 goto error; 13740 if (pat_len > wowlan->pattern_max_len || 13741 pat_len < wowlan->pattern_min_len) 13742 goto error; 13743 13744 if (!pat_tb[NL80211_PKTPAT_OFFSET]) 13745 pkt_offset = 0; 13746 else 13747 pkt_offset = nla_get_u32( 13748 pat_tb[NL80211_PKTPAT_OFFSET]); 13749 if (pkt_offset > wowlan->max_pkt_offset) 13750 goto error; 13751 new_triggers.patterns[i].pkt_offset = pkt_offset; 13752 13753 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL); 13754 if (!mask_pat) { 13755 err = -ENOMEM; 13756 goto error; 13757 } 13758 new_triggers.patterns[i].mask = mask_pat; 13759 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]), 13760 mask_len); 13761 mask_pat += mask_len; 13762 new_triggers.patterns[i].pattern = mask_pat; 13763 new_triggers.patterns[i].pattern_len = pat_len; 13764 memcpy(mask_pat, 13765 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]), 13766 pat_len); 13767 i++; 13768 } 13769 } 13770 13771 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) { 13772 regular = true; 13773 err = nl80211_parse_wowlan_tcp( 13774 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION], 13775 &new_triggers); 13776 if (err) 13777 goto error; 13778 } 13779 13780 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) { 13781 regular = true; 13782 err = nl80211_parse_wowlan_nd( 13783 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT], 13784 &new_triggers); 13785 if (err) 13786 goto error; 13787 } 13788 13789 /* The 'any' trigger means the device continues operating more or less 13790 * as in its normal operation mode and wakes up the host on most of the 13791 * normal interrupts (like packet RX, ...) 13792 * It therefore makes little sense to combine with the more constrained 13793 * wakeup trigger modes. 13794 */ 13795 if (new_triggers.any && regular) { 13796 err = -EINVAL; 13797 goto error; 13798 } 13799 13800 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL); 13801 if (!ntrig) { 13802 err = -ENOMEM; 13803 goto error; 13804 } 13805 cfg80211_rdev_free_wowlan(rdev); 13806 rdev->wiphy.wowlan_config = ntrig; 13807 13808 set_wakeup: 13809 if (rdev->ops->set_wakeup && 13810 prev_enabled != !!rdev->wiphy.wowlan_config) 13811 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config); 13812 13813 return 0; 13814 error: 13815 for (i = 0; i < new_triggers.n_patterns; i++) 13816 kfree(new_triggers.patterns[i].mask); 13817 kfree(new_triggers.patterns); 13818 if (new_triggers.tcp && new_triggers.tcp->sock) 13819 sock_release(new_triggers.tcp->sock); 13820 kfree(new_triggers.tcp); 13821 kfree(new_triggers.nd_config); 13822 return err; 13823 } 13824 #endif 13825 13826 static int nl80211_send_coalesce_rules(struct sk_buff *msg, 13827 struct cfg80211_registered_device *rdev) 13828 { 13829 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules; 13830 int i, j, pat_len; 13831 struct cfg80211_coalesce_rules *rule; 13832 13833 if (!rdev->coalesce->n_rules) 13834 return 0; 13835 13836 nl_rules = nla_nest_start_noflag(msg, NL80211_ATTR_COALESCE_RULE); 13837 if (!nl_rules) 13838 return -ENOBUFS; 13839 13840 for (i = 0; i < rdev->coalesce->n_rules; i++) { 13841 nl_rule = nla_nest_start_noflag(msg, i + 1); 13842 if (!nl_rule) 13843 return -ENOBUFS; 13844 13845 rule = &rdev->coalesce->rules[i]; 13846 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY, 13847 rule->delay)) 13848 return -ENOBUFS; 13849 13850 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION, 13851 rule->condition)) 13852 return -ENOBUFS; 13853 13854 nl_pats = nla_nest_start_noflag(msg, 13855 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN); 13856 if (!nl_pats) 13857 return -ENOBUFS; 13858 13859 for (j = 0; j < rule->n_patterns; j++) { 13860 nl_pat = nla_nest_start_noflag(msg, j + 1); 13861 if (!nl_pat) 13862 return -ENOBUFS; 13863 pat_len = rule->patterns[j].pattern_len; 13864 if (nla_put(msg, NL80211_PKTPAT_MASK, 13865 DIV_ROUND_UP(pat_len, 8), 13866 rule->patterns[j].mask) || 13867 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len, 13868 rule->patterns[j].pattern) || 13869 nla_put_u32(msg, NL80211_PKTPAT_OFFSET, 13870 rule->patterns[j].pkt_offset)) 13871 return -ENOBUFS; 13872 nla_nest_end(msg, nl_pat); 13873 } 13874 nla_nest_end(msg, nl_pats); 13875 nla_nest_end(msg, nl_rule); 13876 } 13877 nla_nest_end(msg, nl_rules); 13878 13879 return 0; 13880 } 13881 13882 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info) 13883 { 13884 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 13885 struct sk_buff *msg; 13886 void *hdr; 13887 13888 if (!rdev->wiphy.coalesce) 13889 return -EOPNOTSUPP; 13890 13891 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 13892 if (!msg) 13893 return -ENOMEM; 13894 13895 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 13896 NL80211_CMD_GET_COALESCE); 13897 if (!hdr) 13898 goto nla_put_failure; 13899 13900 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev)) 13901 goto nla_put_failure; 13902 13903 genlmsg_end(msg, hdr); 13904 return genlmsg_reply(msg, info); 13905 13906 nla_put_failure: 13907 nlmsg_free(msg); 13908 return -ENOBUFS; 13909 } 13910 13911 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev) 13912 { 13913 struct cfg80211_coalesce *coalesce = rdev->coalesce; 13914 int i, j; 13915 struct cfg80211_coalesce_rules *rule; 13916 13917 if (!coalesce) 13918 return; 13919 13920 for (i = 0; i < coalesce->n_rules; i++) { 13921 rule = &coalesce->rules[i]; 13922 for (j = 0; j < rule->n_patterns; j++) 13923 kfree(rule->patterns[j].mask); 13924 kfree(rule->patterns); 13925 } 13926 kfree(coalesce->rules); 13927 kfree(coalesce); 13928 rdev->coalesce = NULL; 13929 } 13930 13931 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev, 13932 struct nlattr *rule, 13933 struct cfg80211_coalesce_rules *new_rule) 13934 { 13935 int err, i; 13936 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce; 13937 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat; 13938 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0; 13939 struct nlattr *pat_tb[NUM_NL80211_PKTPAT]; 13940 13941 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_COALESCE_RULE_MAX, 13942 rule, nl80211_coalesce_policy, NULL); 13943 if (err) 13944 return err; 13945 13946 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY]) 13947 new_rule->delay = 13948 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]); 13949 if (new_rule->delay > coalesce->max_delay) 13950 return -EINVAL; 13951 13952 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION]) 13953 new_rule->condition = 13954 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]); 13955 13956 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN]) 13957 return -EINVAL; 13958 13959 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN], 13960 rem) 13961 n_patterns++; 13962 if (n_patterns > coalesce->n_patterns) 13963 return -EINVAL; 13964 13965 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]), 13966 GFP_KERNEL); 13967 if (!new_rule->patterns) 13968 return -ENOMEM; 13969 13970 new_rule->n_patterns = n_patterns; 13971 i = 0; 13972 13973 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN], 13974 rem) { 13975 u8 *mask_pat; 13976 13977 err = nla_parse_nested_deprecated(pat_tb, MAX_NL80211_PKTPAT, 13978 pat, 13979 nl80211_packet_pattern_policy, 13980 NULL); 13981 if (err) 13982 return err; 13983 13984 if (!pat_tb[NL80211_PKTPAT_MASK] || 13985 !pat_tb[NL80211_PKTPAT_PATTERN]) 13986 return -EINVAL; 13987 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]); 13988 mask_len = DIV_ROUND_UP(pat_len, 8); 13989 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len) 13990 return -EINVAL; 13991 if (pat_len > coalesce->pattern_max_len || 13992 pat_len < coalesce->pattern_min_len) 13993 return -EINVAL; 13994 13995 if (!pat_tb[NL80211_PKTPAT_OFFSET]) 13996 pkt_offset = 0; 13997 else 13998 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]); 13999 if (pkt_offset > coalesce->max_pkt_offset) 14000 return -EINVAL; 14001 new_rule->patterns[i].pkt_offset = pkt_offset; 14002 14003 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL); 14004 if (!mask_pat) 14005 return -ENOMEM; 14006 14007 new_rule->patterns[i].mask = mask_pat; 14008 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]), 14009 mask_len); 14010 14011 mask_pat += mask_len; 14012 new_rule->patterns[i].pattern = mask_pat; 14013 new_rule->patterns[i].pattern_len = pat_len; 14014 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]), 14015 pat_len); 14016 i++; 14017 } 14018 14019 return 0; 14020 } 14021 14022 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info) 14023 { 14024 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14025 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce; 14026 struct cfg80211_coalesce new_coalesce = {}; 14027 struct cfg80211_coalesce *n_coalesce; 14028 int err, rem_rule, n_rules = 0, i, j; 14029 struct nlattr *rule; 14030 struct cfg80211_coalesce_rules *tmp_rule; 14031 14032 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce) 14033 return -EOPNOTSUPP; 14034 14035 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) { 14036 cfg80211_rdev_free_coalesce(rdev); 14037 rdev_set_coalesce(rdev, NULL); 14038 return 0; 14039 } 14040 14041 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE], 14042 rem_rule) 14043 n_rules++; 14044 if (n_rules > coalesce->n_rules) 14045 return -EINVAL; 14046 14047 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]), 14048 GFP_KERNEL); 14049 if (!new_coalesce.rules) 14050 return -ENOMEM; 14051 14052 new_coalesce.n_rules = n_rules; 14053 i = 0; 14054 14055 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE], 14056 rem_rule) { 14057 err = nl80211_parse_coalesce_rule(rdev, rule, 14058 &new_coalesce.rules[i]); 14059 if (err) 14060 goto error; 14061 14062 i++; 14063 } 14064 14065 err = rdev_set_coalesce(rdev, &new_coalesce); 14066 if (err) 14067 goto error; 14068 14069 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL); 14070 if (!n_coalesce) { 14071 err = -ENOMEM; 14072 goto error; 14073 } 14074 cfg80211_rdev_free_coalesce(rdev); 14075 rdev->coalesce = n_coalesce; 14076 14077 return 0; 14078 error: 14079 for (i = 0; i < new_coalesce.n_rules; i++) { 14080 tmp_rule = &new_coalesce.rules[i]; 14081 if (!tmp_rule) 14082 continue; 14083 for (j = 0; j < tmp_rule->n_patterns; j++) 14084 kfree(tmp_rule->patterns[j].mask); 14085 kfree(tmp_rule->patterns); 14086 } 14087 kfree(new_coalesce.rules); 14088 14089 return err; 14090 } 14091 14092 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info) 14093 { 14094 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14095 struct net_device *dev = info->user_ptr[1]; 14096 struct wireless_dev *wdev = dev->ieee80211_ptr; 14097 struct nlattr *tb[NUM_NL80211_REKEY_DATA]; 14098 struct cfg80211_gtk_rekey_data rekey_data = {}; 14099 int err; 14100 14101 if (!info->attrs[NL80211_ATTR_REKEY_DATA]) 14102 return -EINVAL; 14103 14104 err = nla_parse_nested_deprecated(tb, MAX_NL80211_REKEY_DATA, 14105 info->attrs[NL80211_ATTR_REKEY_DATA], 14106 nl80211_rekey_policy, info->extack); 14107 if (err) 14108 return err; 14109 14110 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] || 14111 !tb[NL80211_REKEY_DATA_KCK]) 14112 return -EINVAL; 14113 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN && 14114 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK && 14115 nla_len(tb[NL80211_REKEY_DATA_KEK]) == NL80211_KEK_EXT_LEN)) 14116 return -ERANGE; 14117 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN && 14118 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK && 14119 nla_len(tb[NL80211_REKEY_DATA_KCK]) == NL80211_KCK_EXT_LEN) && 14120 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_EXT_KCK_32 && 14121 nla_len(tb[NL80211_REKEY_DATA_KCK]) == NL80211_KCK_EXT_LEN_32)) 14122 return -ERANGE; 14123 14124 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]); 14125 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]); 14126 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]); 14127 rekey_data.kek_len = nla_len(tb[NL80211_REKEY_DATA_KEK]); 14128 rekey_data.kck_len = nla_len(tb[NL80211_REKEY_DATA_KCK]); 14129 if (tb[NL80211_REKEY_DATA_AKM]) 14130 rekey_data.akm = nla_get_u32(tb[NL80211_REKEY_DATA_AKM]); 14131 14132 wdev_lock(wdev); 14133 if (!wdev->connected) { 14134 err = -ENOTCONN; 14135 goto out; 14136 } 14137 14138 if (!rdev->ops->set_rekey_data) { 14139 err = -EOPNOTSUPP; 14140 goto out; 14141 } 14142 14143 err = rdev_set_rekey_data(rdev, dev, &rekey_data); 14144 out: 14145 wdev_unlock(wdev); 14146 return err; 14147 } 14148 14149 static int nl80211_register_unexpected_frame(struct sk_buff *skb, 14150 struct genl_info *info) 14151 { 14152 struct net_device *dev = info->user_ptr[1]; 14153 struct wireless_dev *wdev = dev->ieee80211_ptr; 14154 14155 if (wdev->iftype != NL80211_IFTYPE_AP && 14156 wdev->iftype != NL80211_IFTYPE_P2P_GO) 14157 return -EINVAL; 14158 14159 if (wdev->ap_unexpected_nlportid) 14160 return -EBUSY; 14161 14162 wdev->ap_unexpected_nlportid = info->snd_portid; 14163 return 0; 14164 } 14165 14166 static int nl80211_probe_client(struct sk_buff *skb, 14167 struct genl_info *info) 14168 { 14169 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14170 struct net_device *dev = info->user_ptr[1]; 14171 struct wireless_dev *wdev = dev->ieee80211_ptr; 14172 struct sk_buff *msg; 14173 void *hdr; 14174 const u8 *addr; 14175 u64 cookie; 14176 int err; 14177 14178 if (wdev->iftype != NL80211_IFTYPE_AP && 14179 wdev->iftype != NL80211_IFTYPE_P2P_GO) 14180 return -EOPNOTSUPP; 14181 14182 if (!info->attrs[NL80211_ATTR_MAC]) 14183 return -EINVAL; 14184 14185 if (!rdev->ops->probe_client) 14186 return -EOPNOTSUPP; 14187 14188 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 14189 if (!msg) 14190 return -ENOMEM; 14191 14192 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 14193 NL80211_CMD_PROBE_CLIENT); 14194 if (!hdr) { 14195 err = -ENOBUFS; 14196 goto free_msg; 14197 } 14198 14199 addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 14200 14201 err = rdev_probe_client(rdev, dev, addr, &cookie); 14202 if (err) 14203 goto free_msg; 14204 14205 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie, 14206 NL80211_ATTR_PAD)) 14207 goto nla_put_failure; 14208 14209 genlmsg_end(msg, hdr); 14210 14211 return genlmsg_reply(msg, info); 14212 14213 nla_put_failure: 14214 err = -ENOBUFS; 14215 free_msg: 14216 nlmsg_free(msg); 14217 return err; 14218 } 14219 14220 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info) 14221 { 14222 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14223 struct cfg80211_beacon_registration *reg, *nreg; 14224 int rv; 14225 14226 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS)) 14227 return -EOPNOTSUPP; 14228 14229 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL); 14230 if (!nreg) 14231 return -ENOMEM; 14232 14233 /* First, check if already registered. */ 14234 spin_lock_bh(&rdev->beacon_registrations_lock); 14235 list_for_each_entry(reg, &rdev->beacon_registrations, list) { 14236 if (reg->nlportid == info->snd_portid) { 14237 rv = -EALREADY; 14238 goto out_err; 14239 } 14240 } 14241 /* Add it to the list */ 14242 nreg->nlportid = info->snd_portid; 14243 list_add(&nreg->list, &rdev->beacon_registrations); 14244 14245 spin_unlock_bh(&rdev->beacon_registrations_lock); 14246 14247 return 0; 14248 out_err: 14249 spin_unlock_bh(&rdev->beacon_registrations_lock); 14250 kfree(nreg); 14251 return rv; 14252 } 14253 14254 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info) 14255 { 14256 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14257 struct wireless_dev *wdev = info->user_ptr[1]; 14258 int err; 14259 14260 if (!rdev->ops->start_p2p_device) 14261 return -EOPNOTSUPP; 14262 14263 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE) 14264 return -EOPNOTSUPP; 14265 14266 if (wdev_running(wdev)) 14267 return 0; 14268 14269 if (rfkill_blocked(rdev->wiphy.rfkill)) 14270 return -ERFKILL; 14271 14272 err = rdev_start_p2p_device(rdev, wdev); 14273 if (err) 14274 return err; 14275 14276 wdev->is_running = true; 14277 rdev->opencount++; 14278 14279 return 0; 14280 } 14281 14282 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info) 14283 { 14284 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14285 struct wireless_dev *wdev = info->user_ptr[1]; 14286 14287 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE) 14288 return -EOPNOTSUPP; 14289 14290 if (!rdev->ops->stop_p2p_device) 14291 return -EOPNOTSUPP; 14292 14293 cfg80211_stop_p2p_device(rdev, wdev); 14294 14295 return 0; 14296 } 14297 14298 static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info) 14299 { 14300 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14301 struct wireless_dev *wdev = info->user_ptr[1]; 14302 struct cfg80211_nan_conf conf = {}; 14303 int err; 14304 14305 if (wdev->iftype != NL80211_IFTYPE_NAN) 14306 return -EOPNOTSUPP; 14307 14308 if (wdev_running(wdev)) 14309 return -EEXIST; 14310 14311 if (rfkill_blocked(rdev->wiphy.rfkill)) 14312 return -ERFKILL; 14313 14314 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) 14315 return -EINVAL; 14316 14317 conf.master_pref = 14318 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]); 14319 14320 if (info->attrs[NL80211_ATTR_BANDS]) { 14321 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]); 14322 14323 if (bands & ~(u32)wdev->wiphy->nan_supported_bands) 14324 return -EOPNOTSUPP; 14325 14326 if (bands && !(bands & BIT(NL80211_BAND_2GHZ))) 14327 return -EINVAL; 14328 14329 conf.bands = bands; 14330 } 14331 14332 err = rdev_start_nan(rdev, wdev, &conf); 14333 if (err) 14334 return err; 14335 14336 wdev->is_running = true; 14337 rdev->opencount++; 14338 14339 return 0; 14340 } 14341 14342 static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info) 14343 { 14344 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14345 struct wireless_dev *wdev = info->user_ptr[1]; 14346 14347 if (wdev->iftype != NL80211_IFTYPE_NAN) 14348 return -EOPNOTSUPP; 14349 14350 cfg80211_stop_nan(rdev, wdev); 14351 14352 return 0; 14353 } 14354 14355 static int validate_nan_filter(struct nlattr *filter_attr) 14356 { 14357 struct nlattr *attr; 14358 int len = 0, n_entries = 0, rem; 14359 14360 nla_for_each_nested(attr, filter_attr, rem) { 14361 len += nla_len(attr); 14362 n_entries++; 14363 } 14364 14365 if (len >= U8_MAX) 14366 return -EINVAL; 14367 14368 return n_entries; 14369 } 14370 14371 static int handle_nan_filter(struct nlattr *attr_filter, 14372 struct cfg80211_nan_func *func, 14373 bool tx) 14374 { 14375 struct nlattr *attr; 14376 int n_entries, rem, i; 14377 struct cfg80211_nan_func_filter *filter; 14378 14379 n_entries = validate_nan_filter(attr_filter); 14380 if (n_entries < 0) 14381 return n_entries; 14382 14383 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters)); 14384 14385 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL); 14386 if (!filter) 14387 return -ENOMEM; 14388 14389 i = 0; 14390 nla_for_each_nested(attr, attr_filter, rem) { 14391 filter[i].filter = nla_memdup(attr, GFP_KERNEL); 14392 if (!filter[i].filter) 14393 goto err; 14394 14395 filter[i].len = nla_len(attr); 14396 i++; 14397 } 14398 if (tx) { 14399 func->num_tx_filters = n_entries; 14400 func->tx_filters = filter; 14401 } else { 14402 func->num_rx_filters = n_entries; 14403 func->rx_filters = filter; 14404 } 14405 14406 return 0; 14407 14408 err: 14409 i = 0; 14410 nla_for_each_nested(attr, attr_filter, rem) { 14411 kfree(filter[i].filter); 14412 i++; 14413 } 14414 kfree(filter); 14415 return -ENOMEM; 14416 } 14417 14418 static int nl80211_nan_add_func(struct sk_buff *skb, 14419 struct genl_info *info) 14420 { 14421 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14422 struct wireless_dev *wdev = info->user_ptr[1]; 14423 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr; 14424 struct cfg80211_nan_func *func; 14425 struct sk_buff *msg = NULL; 14426 void *hdr = NULL; 14427 int err = 0; 14428 14429 if (wdev->iftype != NL80211_IFTYPE_NAN) 14430 return -EOPNOTSUPP; 14431 14432 if (!wdev_running(wdev)) 14433 return -ENOTCONN; 14434 14435 if (!info->attrs[NL80211_ATTR_NAN_FUNC]) 14436 return -EINVAL; 14437 14438 err = nla_parse_nested_deprecated(tb, NL80211_NAN_FUNC_ATTR_MAX, 14439 info->attrs[NL80211_ATTR_NAN_FUNC], 14440 nl80211_nan_func_policy, 14441 info->extack); 14442 if (err) 14443 return err; 14444 14445 func = kzalloc(sizeof(*func), GFP_KERNEL); 14446 if (!func) 14447 return -ENOMEM; 14448 14449 func->cookie = cfg80211_assign_cookie(rdev); 14450 14451 if (!tb[NL80211_NAN_FUNC_TYPE]) { 14452 err = -EINVAL; 14453 goto out; 14454 } 14455 14456 14457 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]); 14458 14459 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) { 14460 err = -EINVAL; 14461 goto out; 14462 } 14463 14464 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]), 14465 sizeof(func->service_id)); 14466 14467 func->close_range = 14468 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]); 14469 14470 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) { 14471 func->serv_spec_info_len = 14472 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]); 14473 func->serv_spec_info = 14474 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]), 14475 func->serv_spec_info_len, 14476 GFP_KERNEL); 14477 if (!func->serv_spec_info) { 14478 err = -ENOMEM; 14479 goto out; 14480 } 14481 } 14482 14483 if (tb[NL80211_NAN_FUNC_TTL]) 14484 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]); 14485 14486 switch (func->type) { 14487 case NL80211_NAN_FUNC_PUBLISH: 14488 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) { 14489 err = -EINVAL; 14490 goto out; 14491 } 14492 14493 func->publish_type = 14494 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]); 14495 func->publish_bcast = 14496 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]); 14497 14498 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) && 14499 func->publish_bcast) { 14500 err = -EINVAL; 14501 goto out; 14502 } 14503 break; 14504 case NL80211_NAN_FUNC_SUBSCRIBE: 14505 func->subscribe_active = 14506 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]); 14507 break; 14508 case NL80211_NAN_FUNC_FOLLOW_UP: 14509 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] || 14510 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] || 14511 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) { 14512 err = -EINVAL; 14513 goto out; 14514 } 14515 14516 func->followup_id = 14517 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]); 14518 func->followup_reqid = 14519 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]); 14520 memcpy(func->followup_dest.addr, 14521 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]), 14522 sizeof(func->followup_dest.addr)); 14523 if (func->ttl) { 14524 err = -EINVAL; 14525 goto out; 14526 } 14527 break; 14528 default: 14529 err = -EINVAL; 14530 goto out; 14531 } 14532 14533 if (tb[NL80211_NAN_FUNC_SRF]) { 14534 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR]; 14535 14536 err = nla_parse_nested_deprecated(srf_tb, 14537 NL80211_NAN_SRF_ATTR_MAX, 14538 tb[NL80211_NAN_FUNC_SRF], 14539 nl80211_nan_srf_policy, 14540 info->extack); 14541 if (err) 14542 goto out; 14543 14544 func->srf_include = 14545 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]); 14546 14547 if (srf_tb[NL80211_NAN_SRF_BF]) { 14548 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] || 14549 !srf_tb[NL80211_NAN_SRF_BF_IDX]) { 14550 err = -EINVAL; 14551 goto out; 14552 } 14553 14554 func->srf_bf_len = 14555 nla_len(srf_tb[NL80211_NAN_SRF_BF]); 14556 func->srf_bf = 14557 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]), 14558 func->srf_bf_len, GFP_KERNEL); 14559 if (!func->srf_bf) { 14560 err = -ENOMEM; 14561 goto out; 14562 } 14563 14564 func->srf_bf_idx = 14565 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]); 14566 } else { 14567 struct nlattr *attr, *mac_attr = 14568 srf_tb[NL80211_NAN_SRF_MAC_ADDRS]; 14569 int n_entries, rem, i = 0; 14570 14571 if (!mac_attr) { 14572 err = -EINVAL; 14573 goto out; 14574 } 14575 14576 n_entries = validate_acl_mac_addrs(mac_attr); 14577 if (n_entries <= 0) { 14578 err = -EINVAL; 14579 goto out; 14580 } 14581 14582 func->srf_num_macs = n_entries; 14583 func->srf_macs = 14584 kcalloc(n_entries, sizeof(*func->srf_macs), 14585 GFP_KERNEL); 14586 if (!func->srf_macs) { 14587 err = -ENOMEM; 14588 goto out; 14589 } 14590 14591 nla_for_each_nested(attr, mac_attr, rem) 14592 memcpy(func->srf_macs[i++].addr, nla_data(attr), 14593 sizeof(*func->srf_macs)); 14594 } 14595 } 14596 14597 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) { 14598 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER], 14599 func, true); 14600 if (err) 14601 goto out; 14602 } 14603 14604 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) { 14605 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER], 14606 func, false); 14607 if (err) 14608 goto out; 14609 } 14610 14611 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 14612 if (!msg) { 14613 err = -ENOMEM; 14614 goto out; 14615 } 14616 14617 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 14618 NL80211_CMD_ADD_NAN_FUNCTION); 14619 /* This can't really happen - we just allocated 4KB */ 14620 if (WARN_ON(!hdr)) { 14621 err = -ENOMEM; 14622 goto out; 14623 } 14624 14625 err = rdev_add_nan_func(rdev, wdev, func); 14626 out: 14627 if (err < 0) { 14628 cfg80211_free_nan_func(func); 14629 nlmsg_free(msg); 14630 return err; 14631 } 14632 14633 /* propagate the instance id and cookie to userspace */ 14634 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie, 14635 NL80211_ATTR_PAD)) 14636 goto nla_put_failure; 14637 14638 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC); 14639 if (!func_attr) 14640 goto nla_put_failure; 14641 14642 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, 14643 func->instance_id)) 14644 goto nla_put_failure; 14645 14646 nla_nest_end(msg, func_attr); 14647 14648 genlmsg_end(msg, hdr); 14649 return genlmsg_reply(msg, info); 14650 14651 nla_put_failure: 14652 nlmsg_free(msg); 14653 return -ENOBUFS; 14654 } 14655 14656 static int nl80211_nan_del_func(struct sk_buff *skb, 14657 struct genl_info *info) 14658 { 14659 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14660 struct wireless_dev *wdev = info->user_ptr[1]; 14661 u64 cookie; 14662 14663 if (wdev->iftype != NL80211_IFTYPE_NAN) 14664 return -EOPNOTSUPP; 14665 14666 if (!wdev_running(wdev)) 14667 return -ENOTCONN; 14668 14669 if (!info->attrs[NL80211_ATTR_COOKIE]) 14670 return -EINVAL; 14671 14672 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]); 14673 14674 rdev_del_nan_func(rdev, wdev, cookie); 14675 14676 return 0; 14677 } 14678 14679 static int nl80211_nan_change_config(struct sk_buff *skb, 14680 struct genl_info *info) 14681 { 14682 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14683 struct wireless_dev *wdev = info->user_ptr[1]; 14684 struct cfg80211_nan_conf conf = {}; 14685 u32 changed = 0; 14686 14687 if (wdev->iftype != NL80211_IFTYPE_NAN) 14688 return -EOPNOTSUPP; 14689 14690 if (!wdev_running(wdev)) 14691 return -ENOTCONN; 14692 14693 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) { 14694 conf.master_pref = 14695 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]); 14696 if (conf.master_pref <= 1 || conf.master_pref == 255) 14697 return -EINVAL; 14698 14699 changed |= CFG80211_NAN_CONF_CHANGED_PREF; 14700 } 14701 14702 if (info->attrs[NL80211_ATTR_BANDS]) { 14703 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]); 14704 14705 if (bands & ~(u32)wdev->wiphy->nan_supported_bands) 14706 return -EOPNOTSUPP; 14707 14708 if (bands && !(bands & BIT(NL80211_BAND_2GHZ))) 14709 return -EINVAL; 14710 14711 conf.bands = bands; 14712 changed |= CFG80211_NAN_CONF_CHANGED_BANDS; 14713 } 14714 14715 if (!changed) 14716 return -EINVAL; 14717 14718 return rdev_nan_change_conf(rdev, wdev, &conf, changed); 14719 } 14720 14721 void cfg80211_nan_match(struct wireless_dev *wdev, 14722 struct cfg80211_nan_match_params *match, gfp_t gfp) 14723 { 14724 struct wiphy *wiphy = wdev->wiphy; 14725 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 14726 struct nlattr *match_attr, *local_func_attr, *peer_func_attr; 14727 struct sk_buff *msg; 14728 void *hdr; 14729 14730 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr)) 14731 return; 14732 14733 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 14734 if (!msg) 14735 return; 14736 14737 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH); 14738 if (!hdr) { 14739 nlmsg_free(msg); 14740 return; 14741 } 14742 14743 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 14744 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 14745 wdev->netdev->ifindex)) || 14746 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 14747 NL80211_ATTR_PAD)) 14748 goto nla_put_failure; 14749 14750 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie, 14751 NL80211_ATTR_PAD) || 14752 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr)) 14753 goto nla_put_failure; 14754 14755 match_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_MATCH); 14756 if (!match_attr) 14757 goto nla_put_failure; 14758 14759 local_func_attr = nla_nest_start_noflag(msg, 14760 NL80211_NAN_MATCH_FUNC_LOCAL); 14761 if (!local_func_attr) 14762 goto nla_put_failure; 14763 14764 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id)) 14765 goto nla_put_failure; 14766 14767 nla_nest_end(msg, local_func_attr); 14768 14769 peer_func_attr = nla_nest_start_noflag(msg, 14770 NL80211_NAN_MATCH_FUNC_PEER); 14771 if (!peer_func_attr) 14772 goto nla_put_failure; 14773 14774 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) || 14775 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id)) 14776 goto nla_put_failure; 14777 14778 if (match->info && match->info_len && 14779 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len, 14780 match->info)) 14781 goto nla_put_failure; 14782 14783 nla_nest_end(msg, peer_func_attr); 14784 nla_nest_end(msg, match_attr); 14785 genlmsg_end(msg, hdr); 14786 14787 if (!wdev->owner_nlportid) 14788 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), 14789 msg, 0, NL80211_MCGRP_NAN, gfp); 14790 else 14791 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, 14792 wdev->owner_nlportid); 14793 14794 return; 14795 14796 nla_put_failure: 14797 nlmsg_free(msg); 14798 } 14799 EXPORT_SYMBOL(cfg80211_nan_match); 14800 14801 void cfg80211_nan_func_terminated(struct wireless_dev *wdev, 14802 u8 inst_id, 14803 enum nl80211_nan_func_term_reason reason, 14804 u64 cookie, gfp_t gfp) 14805 { 14806 struct wiphy *wiphy = wdev->wiphy; 14807 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 14808 struct sk_buff *msg; 14809 struct nlattr *func_attr; 14810 void *hdr; 14811 14812 if (WARN_ON(!inst_id)) 14813 return; 14814 14815 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 14816 if (!msg) 14817 return; 14818 14819 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION); 14820 if (!hdr) { 14821 nlmsg_free(msg); 14822 return; 14823 } 14824 14825 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 14826 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 14827 wdev->netdev->ifindex)) || 14828 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 14829 NL80211_ATTR_PAD)) 14830 goto nla_put_failure; 14831 14832 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie, 14833 NL80211_ATTR_PAD)) 14834 goto nla_put_failure; 14835 14836 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC); 14837 if (!func_attr) 14838 goto nla_put_failure; 14839 14840 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) || 14841 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason)) 14842 goto nla_put_failure; 14843 14844 nla_nest_end(msg, func_attr); 14845 genlmsg_end(msg, hdr); 14846 14847 if (!wdev->owner_nlportid) 14848 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), 14849 msg, 0, NL80211_MCGRP_NAN, gfp); 14850 else 14851 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, 14852 wdev->owner_nlportid); 14853 14854 return; 14855 14856 nla_put_failure: 14857 nlmsg_free(msg); 14858 } 14859 EXPORT_SYMBOL(cfg80211_nan_func_terminated); 14860 14861 static int nl80211_get_protocol_features(struct sk_buff *skb, 14862 struct genl_info *info) 14863 { 14864 void *hdr; 14865 struct sk_buff *msg; 14866 14867 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 14868 if (!msg) 14869 return -ENOMEM; 14870 14871 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 14872 NL80211_CMD_GET_PROTOCOL_FEATURES); 14873 if (!hdr) 14874 goto nla_put_failure; 14875 14876 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES, 14877 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP)) 14878 goto nla_put_failure; 14879 14880 genlmsg_end(msg, hdr); 14881 return genlmsg_reply(msg, info); 14882 14883 nla_put_failure: 14884 kfree_skb(msg); 14885 return -ENOBUFS; 14886 } 14887 14888 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info) 14889 { 14890 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14891 struct cfg80211_update_ft_ies_params ft_params; 14892 struct net_device *dev = info->user_ptr[1]; 14893 14894 if (!rdev->ops->update_ft_ies) 14895 return -EOPNOTSUPP; 14896 14897 if (!info->attrs[NL80211_ATTR_MDID] || 14898 !info->attrs[NL80211_ATTR_IE]) 14899 return -EINVAL; 14900 14901 memset(&ft_params, 0, sizeof(ft_params)); 14902 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]); 14903 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 14904 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 14905 14906 return rdev_update_ft_ies(rdev, dev, &ft_params); 14907 } 14908 14909 static int nl80211_crit_protocol_start(struct sk_buff *skb, 14910 struct genl_info *info) 14911 { 14912 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14913 struct wireless_dev *wdev = info->user_ptr[1]; 14914 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC; 14915 u16 duration; 14916 int ret; 14917 14918 if (!rdev->ops->crit_proto_start) 14919 return -EOPNOTSUPP; 14920 14921 if (WARN_ON(!rdev->ops->crit_proto_stop)) 14922 return -EINVAL; 14923 14924 if (rdev->crit_proto_nlportid) 14925 return -EBUSY; 14926 14927 /* determine protocol if provided */ 14928 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID]) 14929 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]); 14930 14931 if (proto >= NUM_NL80211_CRIT_PROTO) 14932 return -EINVAL; 14933 14934 /* timeout must be provided */ 14935 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]) 14936 return -EINVAL; 14937 14938 duration = 14939 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]); 14940 14941 ret = rdev_crit_proto_start(rdev, wdev, proto, duration); 14942 if (!ret) 14943 rdev->crit_proto_nlportid = info->snd_portid; 14944 14945 return ret; 14946 } 14947 14948 static int nl80211_crit_protocol_stop(struct sk_buff *skb, 14949 struct genl_info *info) 14950 { 14951 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14952 struct wireless_dev *wdev = info->user_ptr[1]; 14953 14954 if (!rdev->ops->crit_proto_stop) 14955 return -EOPNOTSUPP; 14956 14957 if (rdev->crit_proto_nlportid) { 14958 rdev->crit_proto_nlportid = 0; 14959 rdev_crit_proto_stop(rdev, wdev); 14960 } 14961 return 0; 14962 } 14963 14964 static int nl80211_vendor_check_policy(const struct wiphy_vendor_command *vcmd, 14965 struct nlattr *attr, 14966 struct netlink_ext_ack *extack) 14967 { 14968 if (vcmd->policy == VENDOR_CMD_RAW_DATA) { 14969 if (attr->nla_type & NLA_F_NESTED) { 14970 NL_SET_ERR_MSG_ATTR(extack, attr, 14971 "unexpected nested data"); 14972 return -EINVAL; 14973 } 14974 14975 return 0; 14976 } 14977 14978 if (!(attr->nla_type & NLA_F_NESTED)) { 14979 NL_SET_ERR_MSG_ATTR(extack, attr, "expected nested data"); 14980 return -EINVAL; 14981 } 14982 14983 return nla_validate_nested(attr, vcmd->maxattr, vcmd->policy, extack); 14984 } 14985 14986 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info) 14987 { 14988 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 14989 struct wireless_dev *wdev = 14990 __cfg80211_wdev_from_attrs(rdev, genl_info_net(info), 14991 info->attrs); 14992 int i, err; 14993 u32 vid, subcmd; 14994 14995 if (!rdev->wiphy.vendor_commands) 14996 return -EOPNOTSUPP; 14997 14998 if (IS_ERR(wdev)) { 14999 err = PTR_ERR(wdev); 15000 if (err != -EINVAL) 15001 return err; 15002 wdev = NULL; 15003 } else if (wdev->wiphy != &rdev->wiphy) { 15004 return -EINVAL; 15005 } 15006 15007 if (!info->attrs[NL80211_ATTR_VENDOR_ID] || 15008 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD]) 15009 return -EINVAL; 15010 15011 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]); 15012 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]); 15013 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) { 15014 const struct wiphy_vendor_command *vcmd; 15015 void *data = NULL; 15016 int len = 0; 15017 15018 vcmd = &rdev->wiphy.vendor_commands[i]; 15019 15020 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd) 15021 continue; 15022 15023 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV | 15024 WIPHY_VENDOR_CMD_NEED_NETDEV)) { 15025 if (!wdev) 15026 return -EINVAL; 15027 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV && 15028 !wdev->netdev) 15029 return -EINVAL; 15030 15031 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) { 15032 if (!wdev_running(wdev)) 15033 return -ENETDOWN; 15034 } 15035 } else { 15036 wdev = NULL; 15037 } 15038 15039 if (!vcmd->doit) 15040 return -EOPNOTSUPP; 15041 15042 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) { 15043 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]); 15044 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]); 15045 15046 err = nl80211_vendor_check_policy(vcmd, 15047 info->attrs[NL80211_ATTR_VENDOR_DATA], 15048 info->extack); 15049 if (err) 15050 return err; 15051 } 15052 15053 rdev->cur_cmd_info = info; 15054 err = vcmd->doit(&rdev->wiphy, wdev, data, len); 15055 rdev->cur_cmd_info = NULL; 15056 return err; 15057 } 15058 15059 return -EOPNOTSUPP; 15060 } 15061 15062 static int nl80211_prepare_vendor_dump(struct sk_buff *skb, 15063 struct netlink_callback *cb, 15064 struct cfg80211_registered_device **rdev, 15065 struct wireless_dev **wdev) 15066 { 15067 struct nlattr **attrbuf; 15068 u32 vid, subcmd; 15069 unsigned int i; 15070 int vcmd_idx = -1; 15071 int err; 15072 void *data = NULL; 15073 unsigned int data_len = 0; 15074 15075 if (cb->args[0]) { 15076 /* subtract the 1 again here */ 15077 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1); 15078 struct wireless_dev *tmp; 15079 15080 if (!wiphy) 15081 return -ENODEV; 15082 *rdev = wiphy_to_rdev(wiphy); 15083 *wdev = NULL; 15084 15085 if (cb->args[1]) { 15086 list_for_each_entry(tmp, &wiphy->wdev_list, list) { 15087 if (tmp->identifier == cb->args[1] - 1) { 15088 *wdev = tmp; 15089 break; 15090 } 15091 } 15092 } 15093 15094 /* keep rtnl locked in successful case */ 15095 return 0; 15096 } 15097 15098 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL); 15099 if (!attrbuf) 15100 return -ENOMEM; 15101 15102 err = nlmsg_parse_deprecated(cb->nlh, 15103 GENL_HDRLEN + nl80211_fam.hdrsize, 15104 attrbuf, nl80211_fam.maxattr, 15105 nl80211_policy, NULL); 15106 if (err) 15107 goto out; 15108 15109 if (!attrbuf[NL80211_ATTR_VENDOR_ID] || 15110 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) { 15111 err = -EINVAL; 15112 goto out; 15113 } 15114 15115 *wdev = __cfg80211_wdev_from_attrs(NULL, sock_net(skb->sk), attrbuf); 15116 if (IS_ERR(*wdev)) 15117 *wdev = NULL; 15118 15119 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf); 15120 if (IS_ERR(*rdev)) { 15121 err = PTR_ERR(*rdev); 15122 goto out; 15123 } 15124 15125 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]); 15126 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]); 15127 15128 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) { 15129 const struct wiphy_vendor_command *vcmd; 15130 15131 vcmd = &(*rdev)->wiphy.vendor_commands[i]; 15132 15133 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd) 15134 continue; 15135 15136 if (!vcmd->dumpit) { 15137 err = -EOPNOTSUPP; 15138 goto out; 15139 } 15140 15141 vcmd_idx = i; 15142 break; 15143 } 15144 15145 if (vcmd_idx < 0) { 15146 err = -EOPNOTSUPP; 15147 goto out; 15148 } 15149 15150 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) { 15151 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]); 15152 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]); 15153 15154 err = nl80211_vendor_check_policy( 15155 &(*rdev)->wiphy.vendor_commands[vcmd_idx], 15156 attrbuf[NL80211_ATTR_VENDOR_DATA], 15157 cb->extack); 15158 if (err) 15159 goto out; 15160 } 15161 15162 /* 0 is the first index - add 1 to parse only once */ 15163 cb->args[0] = (*rdev)->wiphy_idx + 1; 15164 /* add 1 to know if it was NULL */ 15165 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0; 15166 cb->args[2] = vcmd_idx; 15167 cb->args[3] = (unsigned long)data; 15168 cb->args[4] = data_len; 15169 15170 /* keep rtnl locked in successful case */ 15171 err = 0; 15172 out: 15173 kfree(attrbuf); 15174 return err; 15175 } 15176 15177 static int nl80211_vendor_cmd_dump(struct sk_buff *skb, 15178 struct netlink_callback *cb) 15179 { 15180 struct cfg80211_registered_device *rdev; 15181 struct wireless_dev *wdev; 15182 unsigned int vcmd_idx; 15183 const struct wiphy_vendor_command *vcmd; 15184 void *data; 15185 int data_len; 15186 int err; 15187 struct nlattr *vendor_data; 15188 15189 rtnl_lock(); 15190 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev); 15191 if (err) 15192 goto out; 15193 15194 vcmd_idx = cb->args[2]; 15195 data = (void *)cb->args[3]; 15196 data_len = cb->args[4]; 15197 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx]; 15198 15199 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV | 15200 WIPHY_VENDOR_CMD_NEED_NETDEV)) { 15201 if (!wdev) { 15202 err = -EINVAL; 15203 goto out; 15204 } 15205 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV && 15206 !wdev->netdev) { 15207 err = -EINVAL; 15208 goto out; 15209 } 15210 15211 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) { 15212 if (!wdev_running(wdev)) { 15213 err = -ENETDOWN; 15214 goto out; 15215 } 15216 } 15217 } 15218 15219 while (1) { 15220 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid, 15221 cb->nlh->nlmsg_seq, NLM_F_MULTI, 15222 NL80211_CMD_VENDOR); 15223 if (!hdr) 15224 break; 15225 15226 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 15227 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV, 15228 wdev_id(wdev), 15229 NL80211_ATTR_PAD))) { 15230 genlmsg_cancel(skb, hdr); 15231 break; 15232 } 15233 15234 vendor_data = nla_nest_start_noflag(skb, 15235 NL80211_ATTR_VENDOR_DATA); 15236 if (!vendor_data) { 15237 genlmsg_cancel(skb, hdr); 15238 break; 15239 } 15240 15241 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len, 15242 (unsigned long *)&cb->args[5]); 15243 nla_nest_end(skb, vendor_data); 15244 15245 if (err == -ENOBUFS || err == -ENOENT) { 15246 genlmsg_cancel(skb, hdr); 15247 break; 15248 } else if (err <= 0) { 15249 genlmsg_cancel(skb, hdr); 15250 goto out; 15251 } 15252 15253 genlmsg_end(skb, hdr); 15254 } 15255 15256 err = skb->len; 15257 out: 15258 rtnl_unlock(); 15259 return err; 15260 } 15261 15262 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy, 15263 enum nl80211_commands cmd, 15264 enum nl80211_attrs attr, 15265 int approxlen) 15266 { 15267 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 15268 15269 if (WARN_ON(!rdev->cur_cmd_info)) 15270 return NULL; 15271 15272 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen, 15273 rdev->cur_cmd_info->snd_portid, 15274 rdev->cur_cmd_info->snd_seq, 15275 cmd, attr, NULL, GFP_KERNEL); 15276 } 15277 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb); 15278 15279 int cfg80211_vendor_cmd_reply(struct sk_buff *skb) 15280 { 15281 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0]; 15282 void *hdr = ((void **)skb->cb)[1]; 15283 struct nlattr *data = ((void **)skb->cb)[2]; 15284 15285 /* clear CB data for netlink core to own from now on */ 15286 memset(skb->cb, 0, sizeof(skb->cb)); 15287 15288 if (WARN_ON(!rdev->cur_cmd_info)) { 15289 kfree_skb(skb); 15290 return -EINVAL; 15291 } 15292 15293 nla_nest_end(skb, data); 15294 genlmsg_end(skb, hdr); 15295 return genlmsg_reply(skb, rdev->cur_cmd_info); 15296 } 15297 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply); 15298 15299 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy *wiphy) 15300 { 15301 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 15302 15303 if (WARN_ON(!rdev->cur_cmd_info)) 15304 return 0; 15305 15306 return rdev->cur_cmd_info->snd_portid; 15307 } 15308 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_get_sender); 15309 15310 static int nl80211_set_qos_map(struct sk_buff *skb, 15311 struct genl_info *info) 15312 { 15313 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15314 struct cfg80211_qos_map *qos_map = NULL; 15315 struct net_device *dev = info->user_ptr[1]; 15316 u8 *pos, len, num_des, des_len, des; 15317 int ret; 15318 15319 if (!rdev->ops->set_qos_map) 15320 return -EOPNOTSUPP; 15321 15322 if (info->attrs[NL80211_ATTR_QOS_MAP]) { 15323 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]); 15324 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]); 15325 15326 if (len % 2) 15327 return -EINVAL; 15328 15329 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL); 15330 if (!qos_map) 15331 return -ENOMEM; 15332 15333 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1; 15334 if (num_des) { 15335 des_len = num_des * 15336 sizeof(struct cfg80211_dscp_exception); 15337 memcpy(qos_map->dscp_exception, pos, des_len); 15338 qos_map->num_des = num_des; 15339 for (des = 0; des < num_des; des++) { 15340 if (qos_map->dscp_exception[des].up > 7) { 15341 kfree(qos_map); 15342 return -EINVAL; 15343 } 15344 } 15345 pos += des_len; 15346 } 15347 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN); 15348 } 15349 15350 wdev_lock(dev->ieee80211_ptr); 15351 ret = nl80211_key_allowed(dev->ieee80211_ptr); 15352 if (!ret) 15353 ret = rdev_set_qos_map(rdev, dev, qos_map); 15354 wdev_unlock(dev->ieee80211_ptr); 15355 15356 kfree(qos_map); 15357 return ret; 15358 } 15359 15360 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info) 15361 { 15362 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15363 struct net_device *dev = info->user_ptr[1]; 15364 struct wireless_dev *wdev = dev->ieee80211_ptr; 15365 const u8 *peer; 15366 u8 tsid, up; 15367 u16 admitted_time = 0; 15368 int err; 15369 15370 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)) 15371 return -EOPNOTSUPP; 15372 15373 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] || 15374 !info->attrs[NL80211_ATTR_USER_PRIO]) 15375 return -EINVAL; 15376 15377 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]); 15378 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]); 15379 15380 /* WMM uses TIDs 0-7 even for TSPEC */ 15381 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) { 15382 /* TODO: handle 802.11 TSPEC/admission control 15383 * need more attributes for that (e.g. BA session requirement); 15384 * change the WMM adminssion test above to allow both then 15385 */ 15386 return -EINVAL; 15387 } 15388 15389 peer = nla_data(info->attrs[NL80211_ATTR_MAC]); 15390 15391 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) { 15392 admitted_time = 15393 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]); 15394 if (!admitted_time) 15395 return -EINVAL; 15396 } 15397 15398 wdev_lock(wdev); 15399 switch (wdev->iftype) { 15400 case NL80211_IFTYPE_STATION: 15401 case NL80211_IFTYPE_P2P_CLIENT: 15402 if (wdev->connected) 15403 break; 15404 err = -ENOTCONN; 15405 goto out; 15406 default: 15407 err = -EOPNOTSUPP; 15408 goto out; 15409 } 15410 15411 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time); 15412 15413 out: 15414 wdev_unlock(wdev); 15415 return err; 15416 } 15417 15418 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info) 15419 { 15420 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15421 struct net_device *dev = info->user_ptr[1]; 15422 struct wireless_dev *wdev = dev->ieee80211_ptr; 15423 const u8 *peer; 15424 u8 tsid; 15425 int err; 15426 15427 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC]) 15428 return -EINVAL; 15429 15430 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]); 15431 peer = nla_data(info->attrs[NL80211_ATTR_MAC]); 15432 15433 wdev_lock(wdev); 15434 err = rdev_del_tx_ts(rdev, dev, tsid, peer); 15435 wdev_unlock(wdev); 15436 15437 return err; 15438 } 15439 15440 static int nl80211_tdls_channel_switch(struct sk_buff *skb, 15441 struct genl_info *info) 15442 { 15443 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15444 struct net_device *dev = info->user_ptr[1]; 15445 struct wireless_dev *wdev = dev->ieee80211_ptr; 15446 struct cfg80211_chan_def chandef = {}; 15447 const u8 *addr; 15448 u8 oper_class; 15449 int err; 15450 15451 if (!rdev->ops->tdls_channel_switch || 15452 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH)) 15453 return -EOPNOTSUPP; 15454 15455 switch (dev->ieee80211_ptr->iftype) { 15456 case NL80211_IFTYPE_STATION: 15457 case NL80211_IFTYPE_P2P_CLIENT: 15458 break; 15459 default: 15460 return -EOPNOTSUPP; 15461 } 15462 15463 if (!info->attrs[NL80211_ATTR_MAC] || 15464 !info->attrs[NL80211_ATTR_OPER_CLASS]) 15465 return -EINVAL; 15466 15467 err = nl80211_parse_chandef(rdev, info, &chandef); 15468 if (err) 15469 return err; 15470 15471 /* 15472 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012 15473 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the 15474 * specification is not defined for them. 15475 */ 15476 if (chandef.chan->band == NL80211_BAND_2GHZ && 15477 chandef.width != NL80211_CHAN_WIDTH_20_NOHT && 15478 chandef.width != NL80211_CHAN_WIDTH_20) 15479 return -EINVAL; 15480 15481 /* we will be active on the TDLS link */ 15482 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef, 15483 wdev->iftype)) 15484 return -EINVAL; 15485 15486 /* don't allow switching to DFS channels */ 15487 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype)) 15488 return -EINVAL; 15489 15490 addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 15491 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]); 15492 15493 wdev_lock(wdev); 15494 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef); 15495 wdev_unlock(wdev); 15496 15497 return err; 15498 } 15499 15500 static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb, 15501 struct genl_info *info) 15502 { 15503 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15504 struct net_device *dev = info->user_ptr[1]; 15505 struct wireless_dev *wdev = dev->ieee80211_ptr; 15506 const u8 *addr; 15507 15508 if (!rdev->ops->tdls_channel_switch || 15509 !rdev->ops->tdls_cancel_channel_switch || 15510 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH)) 15511 return -EOPNOTSUPP; 15512 15513 switch (dev->ieee80211_ptr->iftype) { 15514 case NL80211_IFTYPE_STATION: 15515 case NL80211_IFTYPE_P2P_CLIENT: 15516 break; 15517 default: 15518 return -EOPNOTSUPP; 15519 } 15520 15521 if (!info->attrs[NL80211_ATTR_MAC]) 15522 return -EINVAL; 15523 15524 addr = nla_data(info->attrs[NL80211_ATTR_MAC]); 15525 15526 wdev_lock(wdev); 15527 rdev_tdls_cancel_channel_switch(rdev, dev, addr); 15528 wdev_unlock(wdev); 15529 15530 return 0; 15531 } 15532 15533 static int nl80211_set_multicast_to_unicast(struct sk_buff *skb, 15534 struct genl_info *info) 15535 { 15536 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15537 struct net_device *dev = info->user_ptr[1]; 15538 struct wireless_dev *wdev = dev->ieee80211_ptr; 15539 const struct nlattr *nla; 15540 bool enabled; 15541 15542 if (!rdev->ops->set_multicast_to_unicast) 15543 return -EOPNOTSUPP; 15544 15545 if (wdev->iftype != NL80211_IFTYPE_AP && 15546 wdev->iftype != NL80211_IFTYPE_P2P_GO) 15547 return -EOPNOTSUPP; 15548 15549 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED]; 15550 enabled = nla_get_flag(nla); 15551 15552 return rdev_set_multicast_to_unicast(rdev, dev, enabled); 15553 } 15554 15555 static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info) 15556 { 15557 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15558 struct net_device *dev = info->user_ptr[1]; 15559 struct wireless_dev *wdev = dev->ieee80211_ptr; 15560 struct cfg80211_pmk_conf pmk_conf = {}; 15561 int ret; 15562 15563 if (wdev->iftype != NL80211_IFTYPE_STATION && 15564 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT) 15565 return -EOPNOTSUPP; 15566 15567 if (!wiphy_ext_feature_isset(&rdev->wiphy, 15568 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X)) 15569 return -EOPNOTSUPP; 15570 15571 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK]) 15572 return -EINVAL; 15573 15574 wdev_lock(wdev); 15575 if (!wdev->connected) { 15576 ret = -ENOTCONN; 15577 goto out; 15578 } 15579 15580 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]); 15581 if (memcmp(pmk_conf.aa, wdev->u.client.connected_addr, ETH_ALEN)) { 15582 ret = -EINVAL; 15583 goto out; 15584 } 15585 15586 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]); 15587 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]); 15588 if (pmk_conf.pmk_len != WLAN_PMK_LEN && 15589 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) { 15590 ret = -EINVAL; 15591 goto out; 15592 } 15593 15594 if (info->attrs[NL80211_ATTR_PMKR0_NAME]) 15595 pmk_conf.pmk_r0_name = 15596 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]); 15597 15598 ret = rdev_set_pmk(rdev, dev, &pmk_conf); 15599 out: 15600 wdev_unlock(wdev); 15601 return ret; 15602 } 15603 15604 static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info) 15605 { 15606 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15607 struct net_device *dev = info->user_ptr[1]; 15608 struct wireless_dev *wdev = dev->ieee80211_ptr; 15609 const u8 *aa; 15610 int ret; 15611 15612 if (wdev->iftype != NL80211_IFTYPE_STATION && 15613 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT) 15614 return -EOPNOTSUPP; 15615 15616 if (!wiphy_ext_feature_isset(&rdev->wiphy, 15617 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X)) 15618 return -EOPNOTSUPP; 15619 15620 if (!info->attrs[NL80211_ATTR_MAC]) 15621 return -EINVAL; 15622 15623 wdev_lock(wdev); 15624 aa = nla_data(info->attrs[NL80211_ATTR_MAC]); 15625 ret = rdev_del_pmk(rdev, dev, aa); 15626 wdev_unlock(wdev); 15627 15628 return ret; 15629 } 15630 15631 static int nl80211_external_auth(struct sk_buff *skb, struct genl_info *info) 15632 { 15633 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15634 struct net_device *dev = info->user_ptr[1]; 15635 struct cfg80211_external_auth_params params; 15636 15637 if (!rdev->ops->external_auth) 15638 return -EOPNOTSUPP; 15639 15640 if (!info->attrs[NL80211_ATTR_SSID] && 15641 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP && 15642 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) 15643 return -EINVAL; 15644 15645 if (!info->attrs[NL80211_ATTR_BSSID]) 15646 return -EINVAL; 15647 15648 if (!info->attrs[NL80211_ATTR_STATUS_CODE]) 15649 return -EINVAL; 15650 15651 memset(¶ms, 0, sizeof(params)); 15652 15653 if (info->attrs[NL80211_ATTR_SSID]) { 15654 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]); 15655 if (params.ssid.ssid_len == 0) 15656 return -EINVAL; 15657 memcpy(params.ssid.ssid, 15658 nla_data(info->attrs[NL80211_ATTR_SSID]), 15659 params.ssid.ssid_len); 15660 } 15661 15662 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]), 15663 ETH_ALEN); 15664 15665 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]); 15666 15667 if (info->attrs[NL80211_ATTR_PMKID]) 15668 params.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]); 15669 15670 return rdev_external_auth(rdev, dev, ¶ms); 15671 } 15672 15673 static int nl80211_tx_control_port(struct sk_buff *skb, struct genl_info *info) 15674 { 15675 bool dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK]; 15676 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15677 struct net_device *dev = info->user_ptr[1]; 15678 struct wireless_dev *wdev = dev->ieee80211_ptr; 15679 const u8 *buf; 15680 size_t len; 15681 u8 *dest; 15682 u16 proto; 15683 bool noencrypt; 15684 u64 cookie = 0; 15685 int link_id; 15686 int err; 15687 15688 if (!wiphy_ext_feature_isset(&rdev->wiphy, 15689 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211)) 15690 return -EOPNOTSUPP; 15691 15692 if (!rdev->ops->tx_control_port) 15693 return -EOPNOTSUPP; 15694 15695 if (!info->attrs[NL80211_ATTR_FRAME] || 15696 !info->attrs[NL80211_ATTR_MAC] || 15697 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) { 15698 GENL_SET_ERR_MSG(info, "Frame, MAC or ethertype missing"); 15699 return -EINVAL; 15700 } 15701 15702 wdev_lock(wdev); 15703 15704 switch (wdev->iftype) { 15705 case NL80211_IFTYPE_AP: 15706 case NL80211_IFTYPE_P2P_GO: 15707 case NL80211_IFTYPE_MESH_POINT: 15708 break; 15709 case NL80211_IFTYPE_ADHOC: 15710 if (wdev->u.ibss.current_bss) 15711 break; 15712 err = -ENOTCONN; 15713 goto out; 15714 case NL80211_IFTYPE_STATION: 15715 case NL80211_IFTYPE_P2P_CLIENT: 15716 if (wdev->connected) 15717 break; 15718 err = -ENOTCONN; 15719 goto out; 15720 default: 15721 err = -EOPNOTSUPP; 15722 goto out; 15723 } 15724 15725 wdev_unlock(wdev); 15726 15727 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]); 15728 len = nla_len(info->attrs[NL80211_ATTR_FRAME]); 15729 dest = nla_data(info->attrs[NL80211_ATTR_MAC]); 15730 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]); 15731 noencrypt = 15732 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]); 15733 15734 link_id = nl80211_link_id_or_invalid(info->attrs); 15735 15736 err = rdev_tx_control_port(rdev, dev, buf, len, 15737 dest, cpu_to_be16(proto), noencrypt, link_id, 15738 dont_wait_for_ack ? NULL : &cookie); 15739 if (!err && !dont_wait_for_ack) 15740 nl_set_extack_cookie_u64(info->extack, cookie); 15741 return err; 15742 out: 15743 wdev_unlock(wdev); 15744 return err; 15745 } 15746 15747 static int nl80211_get_ftm_responder_stats(struct sk_buff *skb, 15748 struct genl_info *info) 15749 { 15750 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15751 struct net_device *dev = info->user_ptr[1]; 15752 struct wireless_dev *wdev = dev->ieee80211_ptr; 15753 struct cfg80211_ftm_responder_stats ftm_stats = {}; 15754 unsigned int link_id = nl80211_link_id(info->attrs); 15755 struct sk_buff *msg; 15756 void *hdr; 15757 struct nlattr *ftm_stats_attr; 15758 int err; 15759 15760 if (wdev->iftype != NL80211_IFTYPE_AP || 15761 !wdev->links[link_id].ap.beacon_interval) 15762 return -EOPNOTSUPP; 15763 15764 err = rdev_get_ftm_responder_stats(rdev, dev, &ftm_stats); 15765 if (err) 15766 return err; 15767 15768 if (!ftm_stats.filled) 15769 return -ENODATA; 15770 15771 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 15772 if (!msg) 15773 return -ENOMEM; 15774 15775 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0, 15776 NL80211_CMD_GET_FTM_RESPONDER_STATS); 15777 if (!hdr) 15778 goto nla_put_failure; 15779 15780 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex)) 15781 goto nla_put_failure; 15782 15783 ftm_stats_attr = nla_nest_start_noflag(msg, 15784 NL80211_ATTR_FTM_RESPONDER_STATS); 15785 if (!ftm_stats_attr) 15786 goto nla_put_failure; 15787 15788 #define SET_FTM(field, name, type) \ 15789 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \ 15790 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \ 15791 ftm_stats.field)) \ 15792 goto nla_put_failure; } while (0) 15793 #define SET_FTM_U64(field, name) \ 15794 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \ 15795 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \ 15796 ftm_stats.field, NL80211_FTM_STATS_PAD)) \ 15797 goto nla_put_failure; } while (0) 15798 15799 SET_FTM(success_num, SUCCESS_NUM, u32); 15800 SET_FTM(partial_num, PARTIAL_NUM, u32); 15801 SET_FTM(failed_num, FAILED_NUM, u32); 15802 SET_FTM(asap_num, ASAP_NUM, u32); 15803 SET_FTM(non_asap_num, NON_ASAP_NUM, u32); 15804 SET_FTM_U64(total_duration_ms, TOTAL_DURATION_MSEC); 15805 SET_FTM(unknown_triggers_num, UNKNOWN_TRIGGERS_NUM, u32); 15806 SET_FTM(reschedule_requests_num, RESCHEDULE_REQUESTS_NUM, u32); 15807 SET_FTM(out_of_window_triggers_num, OUT_OF_WINDOW_TRIGGERS_NUM, u32); 15808 #undef SET_FTM 15809 15810 nla_nest_end(msg, ftm_stats_attr); 15811 15812 genlmsg_end(msg, hdr); 15813 return genlmsg_reply(msg, info); 15814 15815 nla_put_failure: 15816 nlmsg_free(msg); 15817 return -ENOBUFS; 15818 } 15819 15820 static int nl80211_update_owe_info(struct sk_buff *skb, struct genl_info *info) 15821 { 15822 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15823 struct cfg80211_update_owe_info owe_info; 15824 struct net_device *dev = info->user_ptr[1]; 15825 15826 if (!rdev->ops->update_owe_info) 15827 return -EOPNOTSUPP; 15828 15829 if (!info->attrs[NL80211_ATTR_STATUS_CODE] || 15830 !info->attrs[NL80211_ATTR_MAC]) 15831 return -EINVAL; 15832 15833 memset(&owe_info, 0, sizeof(owe_info)); 15834 owe_info.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]); 15835 nla_memcpy(owe_info.peer, info->attrs[NL80211_ATTR_MAC], ETH_ALEN); 15836 15837 if (info->attrs[NL80211_ATTR_IE]) { 15838 owe_info.ie = nla_data(info->attrs[NL80211_ATTR_IE]); 15839 owe_info.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]); 15840 } 15841 15842 return rdev_update_owe_info(rdev, dev, &owe_info); 15843 } 15844 15845 static int nl80211_probe_mesh_link(struct sk_buff *skb, struct genl_info *info) 15846 { 15847 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15848 struct net_device *dev = info->user_ptr[1]; 15849 struct wireless_dev *wdev = dev->ieee80211_ptr; 15850 struct station_info sinfo = {}; 15851 const u8 *buf; 15852 size_t len; 15853 u8 *dest; 15854 int err; 15855 15856 if (!rdev->ops->probe_mesh_link || !rdev->ops->get_station) 15857 return -EOPNOTSUPP; 15858 15859 if (!info->attrs[NL80211_ATTR_MAC] || 15860 !info->attrs[NL80211_ATTR_FRAME]) { 15861 GENL_SET_ERR_MSG(info, "Frame or MAC missing"); 15862 return -EINVAL; 15863 } 15864 15865 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) 15866 return -EOPNOTSUPP; 15867 15868 dest = nla_data(info->attrs[NL80211_ATTR_MAC]); 15869 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]); 15870 len = nla_len(info->attrs[NL80211_ATTR_FRAME]); 15871 15872 if (len < sizeof(struct ethhdr)) 15873 return -EINVAL; 15874 15875 if (!ether_addr_equal(buf, dest) || is_multicast_ether_addr(buf) || 15876 !ether_addr_equal(buf + ETH_ALEN, dev->dev_addr)) 15877 return -EINVAL; 15878 15879 err = rdev_get_station(rdev, dev, dest, &sinfo); 15880 if (err) 15881 return err; 15882 15883 cfg80211_sinfo_release_content(&sinfo); 15884 15885 return rdev_probe_mesh_link(rdev, dev, dest, buf, len); 15886 } 15887 15888 static int parse_tid_conf(struct cfg80211_registered_device *rdev, 15889 struct nlattr *attrs[], struct net_device *dev, 15890 struct cfg80211_tid_cfg *tid_conf, 15891 struct genl_info *info, const u8 *peer, 15892 unsigned int link_id) 15893 { 15894 struct netlink_ext_ack *extack = info->extack; 15895 u64 mask; 15896 int err; 15897 15898 if (!attrs[NL80211_TID_CONFIG_ATTR_TIDS]) 15899 return -EINVAL; 15900 15901 tid_conf->config_override = 15902 nla_get_flag(attrs[NL80211_TID_CONFIG_ATTR_OVERRIDE]); 15903 tid_conf->tids = nla_get_u16(attrs[NL80211_TID_CONFIG_ATTR_TIDS]); 15904 15905 if (tid_conf->config_override) { 15906 if (rdev->ops->reset_tid_config) { 15907 err = rdev_reset_tid_config(rdev, dev, peer, 15908 tid_conf->tids); 15909 if (err) 15910 return err; 15911 } else { 15912 return -EINVAL; 15913 } 15914 } 15915 15916 if (attrs[NL80211_TID_CONFIG_ATTR_NOACK]) { 15917 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_NOACK); 15918 tid_conf->noack = 15919 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_NOACK]); 15920 } 15921 15922 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]) { 15923 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT); 15924 tid_conf->retry_short = 15925 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]); 15926 15927 if (tid_conf->retry_short > rdev->wiphy.max_data_retry_count) 15928 return -EINVAL; 15929 } 15930 15931 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]) { 15932 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG); 15933 tid_conf->retry_long = 15934 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]); 15935 15936 if (tid_conf->retry_long > rdev->wiphy.max_data_retry_count) 15937 return -EINVAL; 15938 } 15939 15940 if (attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]) { 15941 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL); 15942 tid_conf->ampdu = 15943 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]); 15944 } 15945 15946 if (attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]) { 15947 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL); 15948 tid_conf->rtscts = 15949 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]); 15950 } 15951 15952 if (attrs[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL]) { 15953 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMSDU_CTRL); 15954 tid_conf->amsdu = 15955 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL]); 15956 } 15957 15958 if (attrs[NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE]) { 15959 u32 idx = NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE, attr; 15960 15961 tid_conf->txrate_type = nla_get_u8(attrs[idx]); 15962 15963 if (tid_conf->txrate_type != NL80211_TX_RATE_AUTOMATIC) { 15964 attr = NL80211_TID_CONFIG_ATTR_TX_RATE; 15965 err = nl80211_parse_tx_bitrate_mask(info, attrs, attr, 15966 &tid_conf->txrate_mask, dev, 15967 true, link_id); 15968 if (err) 15969 return err; 15970 15971 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE); 15972 } 15973 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE); 15974 } 15975 15976 if (peer) 15977 mask = rdev->wiphy.tid_config_support.peer; 15978 else 15979 mask = rdev->wiphy.tid_config_support.vif; 15980 15981 if (tid_conf->mask & ~mask) { 15982 NL_SET_ERR_MSG(extack, "unsupported TID configuration"); 15983 return -ENOTSUPP; 15984 } 15985 15986 return 0; 15987 } 15988 15989 static int nl80211_set_tid_config(struct sk_buff *skb, 15990 struct genl_info *info) 15991 { 15992 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 15993 struct nlattr *attrs[NL80211_TID_CONFIG_ATTR_MAX + 1]; 15994 unsigned int link_id = nl80211_link_id(info->attrs); 15995 struct net_device *dev = info->user_ptr[1]; 15996 struct cfg80211_tid_config *tid_config; 15997 struct nlattr *tid; 15998 int conf_idx = 0, rem_conf; 15999 int ret = -EINVAL; 16000 u32 num_conf = 0; 16001 16002 if (!info->attrs[NL80211_ATTR_TID_CONFIG]) 16003 return -EINVAL; 16004 16005 if (!rdev->ops->set_tid_config) 16006 return -EOPNOTSUPP; 16007 16008 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG], 16009 rem_conf) 16010 num_conf++; 16011 16012 tid_config = kzalloc(struct_size(tid_config, tid_conf, num_conf), 16013 GFP_KERNEL); 16014 if (!tid_config) 16015 return -ENOMEM; 16016 16017 tid_config->n_tid_conf = num_conf; 16018 16019 if (info->attrs[NL80211_ATTR_MAC]) 16020 tid_config->peer = nla_data(info->attrs[NL80211_ATTR_MAC]); 16021 16022 wdev_lock(dev->ieee80211_ptr); 16023 16024 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG], 16025 rem_conf) { 16026 ret = nla_parse_nested(attrs, NL80211_TID_CONFIG_ATTR_MAX, 16027 tid, NULL, NULL); 16028 16029 if (ret) 16030 goto bad_tid_conf; 16031 16032 ret = parse_tid_conf(rdev, attrs, dev, 16033 &tid_config->tid_conf[conf_idx], 16034 info, tid_config->peer, link_id); 16035 if (ret) 16036 goto bad_tid_conf; 16037 16038 conf_idx++; 16039 } 16040 16041 ret = rdev_set_tid_config(rdev, dev, tid_config); 16042 16043 bad_tid_conf: 16044 kfree(tid_config); 16045 wdev_unlock(dev->ieee80211_ptr); 16046 return ret; 16047 } 16048 16049 static int nl80211_color_change(struct sk_buff *skb, struct genl_info *info) 16050 { 16051 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16052 struct cfg80211_color_change_settings params = {}; 16053 struct net_device *dev = info->user_ptr[1]; 16054 struct wireless_dev *wdev = dev->ieee80211_ptr; 16055 struct nlattr **tb; 16056 u16 offset; 16057 int err; 16058 16059 if (!rdev->ops->color_change) 16060 return -EOPNOTSUPP; 16061 16062 if (!wiphy_ext_feature_isset(&rdev->wiphy, 16063 NL80211_EXT_FEATURE_BSS_COLOR)) 16064 return -EOPNOTSUPP; 16065 16066 if (wdev->iftype != NL80211_IFTYPE_AP) 16067 return -EOPNOTSUPP; 16068 16069 if (!info->attrs[NL80211_ATTR_COLOR_CHANGE_COUNT] || 16070 !info->attrs[NL80211_ATTR_COLOR_CHANGE_COLOR] || 16071 !info->attrs[NL80211_ATTR_COLOR_CHANGE_ELEMS]) 16072 return -EINVAL; 16073 16074 params.count = nla_get_u8(info->attrs[NL80211_ATTR_COLOR_CHANGE_COUNT]); 16075 params.color = nla_get_u8(info->attrs[NL80211_ATTR_COLOR_CHANGE_COLOR]); 16076 16077 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_next, 16078 info->extack); 16079 if (err) 16080 return err; 16081 16082 tb = kcalloc(NL80211_ATTR_MAX + 1, sizeof(*tb), GFP_KERNEL); 16083 if (!tb) 16084 return -ENOMEM; 16085 16086 err = nla_parse_nested(tb, NL80211_ATTR_MAX, 16087 info->attrs[NL80211_ATTR_COLOR_CHANGE_ELEMS], 16088 nl80211_policy, info->extack); 16089 if (err) 16090 goto out; 16091 16092 err = nl80211_parse_beacon(rdev, tb, ¶ms.beacon_color_change, 16093 info->extack); 16094 if (err) 16095 goto out; 16096 16097 if (!tb[NL80211_ATTR_CNTDWN_OFFS_BEACON]) { 16098 err = -EINVAL; 16099 goto out; 16100 } 16101 16102 if (nla_len(tb[NL80211_ATTR_CNTDWN_OFFS_BEACON]) != sizeof(u16)) { 16103 err = -EINVAL; 16104 goto out; 16105 } 16106 16107 offset = nla_get_u16(tb[NL80211_ATTR_CNTDWN_OFFS_BEACON]); 16108 if (offset >= params.beacon_color_change.tail_len) { 16109 err = -EINVAL; 16110 goto out; 16111 } 16112 16113 if (params.beacon_color_change.tail[offset] != params.count) { 16114 err = -EINVAL; 16115 goto out; 16116 } 16117 16118 params.counter_offset_beacon = offset; 16119 16120 if (tb[NL80211_ATTR_CNTDWN_OFFS_PRESP]) { 16121 if (nla_len(tb[NL80211_ATTR_CNTDWN_OFFS_PRESP]) != 16122 sizeof(u16)) { 16123 err = -EINVAL; 16124 goto out; 16125 } 16126 16127 offset = nla_get_u16(tb[NL80211_ATTR_CNTDWN_OFFS_PRESP]); 16128 if (offset >= params.beacon_color_change.probe_resp_len) { 16129 err = -EINVAL; 16130 goto out; 16131 } 16132 16133 if (params.beacon_color_change.probe_resp[offset] != 16134 params.count) { 16135 err = -EINVAL; 16136 goto out; 16137 } 16138 16139 params.counter_offset_presp = offset; 16140 } 16141 16142 wdev_lock(wdev); 16143 err = rdev_color_change(rdev, dev, ¶ms); 16144 wdev_unlock(wdev); 16145 16146 out: 16147 kfree(params.beacon_next.mbssid_ies); 16148 kfree(params.beacon_color_change.mbssid_ies); 16149 kfree(params.beacon_next.rnr_ies); 16150 kfree(params.beacon_color_change.rnr_ies); 16151 kfree(tb); 16152 return err; 16153 } 16154 16155 static int nl80211_set_fils_aad(struct sk_buff *skb, 16156 struct genl_info *info) 16157 { 16158 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16159 struct net_device *dev = info->user_ptr[1]; 16160 struct cfg80211_fils_aad fils_aad = {}; 16161 u8 *nonces; 16162 16163 if (!info->attrs[NL80211_ATTR_MAC] || 16164 !info->attrs[NL80211_ATTR_FILS_KEK] || 16165 !info->attrs[NL80211_ATTR_FILS_NONCES]) 16166 return -EINVAL; 16167 16168 fils_aad.macaddr = nla_data(info->attrs[NL80211_ATTR_MAC]); 16169 fils_aad.kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]); 16170 fils_aad.kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]); 16171 nonces = nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]); 16172 fils_aad.snonce = nonces; 16173 fils_aad.anonce = nonces + FILS_NONCE_LEN; 16174 16175 return rdev_set_fils_aad(rdev, dev, &fils_aad); 16176 } 16177 16178 static int nl80211_add_link(struct sk_buff *skb, struct genl_info *info) 16179 { 16180 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16181 unsigned int link_id = nl80211_link_id(info->attrs); 16182 struct net_device *dev = info->user_ptr[1]; 16183 struct wireless_dev *wdev = dev->ieee80211_ptr; 16184 int ret; 16185 16186 if (!(wdev->wiphy->flags & WIPHY_FLAG_SUPPORTS_MLO)) 16187 return -EINVAL; 16188 16189 switch (wdev->iftype) { 16190 case NL80211_IFTYPE_AP: 16191 break; 16192 default: 16193 return -EINVAL; 16194 } 16195 16196 if (!info->attrs[NL80211_ATTR_MAC] || 16197 !is_valid_ether_addr(nla_data(info->attrs[NL80211_ATTR_MAC]))) 16198 return -EINVAL; 16199 16200 wdev_lock(wdev); 16201 wdev->valid_links |= BIT(link_id); 16202 ether_addr_copy(wdev->links[link_id].addr, 16203 nla_data(info->attrs[NL80211_ATTR_MAC])); 16204 16205 ret = rdev_add_intf_link(rdev, wdev, link_id); 16206 if (ret) { 16207 wdev->valid_links &= ~BIT(link_id); 16208 eth_zero_addr(wdev->links[link_id].addr); 16209 } 16210 wdev_unlock(wdev); 16211 16212 return ret; 16213 } 16214 16215 static int nl80211_remove_link(struct sk_buff *skb, struct genl_info *info) 16216 { 16217 unsigned int link_id = nl80211_link_id(info->attrs); 16218 struct net_device *dev = info->user_ptr[1]; 16219 struct wireless_dev *wdev = dev->ieee80211_ptr; 16220 16221 /* cannot remove if there's no link */ 16222 if (!info->attrs[NL80211_ATTR_MLO_LINK_ID]) 16223 return -EINVAL; 16224 16225 switch (wdev->iftype) { 16226 case NL80211_IFTYPE_AP: 16227 break; 16228 default: 16229 return -EINVAL; 16230 } 16231 16232 wdev_lock(wdev); 16233 cfg80211_remove_link(wdev, link_id); 16234 wdev_unlock(wdev); 16235 16236 return 0; 16237 } 16238 16239 static int 16240 nl80211_add_mod_link_station(struct sk_buff *skb, struct genl_info *info, 16241 bool add) 16242 { 16243 struct link_station_parameters params = {}; 16244 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16245 struct net_device *dev = info->user_ptr[1]; 16246 int err; 16247 16248 if ((add && !rdev->ops->add_link_station) || 16249 (!add && !rdev->ops->mod_link_station)) 16250 return -EOPNOTSUPP; 16251 16252 if (add && !info->attrs[NL80211_ATTR_MAC]) 16253 return -EINVAL; 16254 16255 if (!info->attrs[NL80211_ATTR_MLD_ADDR]) 16256 return -EINVAL; 16257 16258 if (add && !info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) 16259 return -EINVAL; 16260 16261 params.mld_mac = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 16262 16263 if (info->attrs[NL80211_ATTR_MAC]) { 16264 params.link_mac = nla_data(info->attrs[NL80211_ATTR_MAC]); 16265 if (!is_valid_ether_addr(params.link_mac)) 16266 return -EINVAL; 16267 } 16268 16269 if (!info->attrs[NL80211_ATTR_MLO_LINK_ID]) 16270 return -EINVAL; 16271 16272 params.link_id = nla_get_u8(info->attrs[NL80211_ATTR_MLO_LINK_ID]); 16273 16274 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) { 16275 params.supported_rates = 16276 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 16277 params.supported_rates_len = 16278 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]); 16279 } 16280 16281 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) 16282 params.ht_capa = 16283 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]); 16284 16285 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) 16286 params.vht_capa = 16287 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]); 16288 16289 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) { 16290 params.he_capa = 16291 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]); 16292 params.he_capa_len = 16293 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]); 16294 16295 if (info->attrs[NL80211_ATTR_EHT_CAPABILITY]) { 16296 params.eht_capa = 16297 nla_data(info->attrs[NL80211_ATTR_EHT_CAPABILITY]); 16298 params.eht_capa_len = 16299 nla_len(info->attrs[NL80211_ATTR_EHT_CAPABILITY]); 16300 16301 if (!ieee80211_eht_capa_size_ok((const u8 *)params.he_capa, 16302 (const u8 *)params.eht_capa, 16303 params.eht_capa_len, 16304 false)) 16305 return -EINVAL; 16306 } 16307 } 16308 16309 if (info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]) 16310 params.he_6ghz_capa = 16311 nla_data(info->attrs[NL80211_ATTR_HE_6GHZ_CAPABILITY]); 16312 16313 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) { 16314 params.opmode_notif_used = true; 16315 params.opmode_notif = 16316 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]); 16317 } 16318 16319 err = nl80211_parse_sta_txpower_setting(info, ¶ms.txpwr, 16320 ¶ms.txpwr_set); 16321 if (err) 16322 return err; 16323 16324 wdev_lock(dev->ieee80211_ptr); 16325 if (add) 16326 err = rdev_add_link_station(rdev, dev, ¶ms); 16327 else 16328 err = rdev_mod_link_station(rdev, dev, ¶ms); 16329 wdev_unlock(dev->ieee80211_ptr); 16330 16331 return err; 16332 } 16333 16334 static int 16335 nl80211_add_link_station(struct sk_buff *skb, struct genl_info *info) 16336 { 16337 return nl80211_add_mod_link_station(skb, info, true); 16338 } 16339 16340 static int 16341 nl80211_modify_link_station(struct sk_buff *skb, struct genl_info *info) 16342 { 16343 return nl80211_add_mod_link_station(skb, info, false); 16344 } 16345 16346 static int 16347 nl80211_remove_link_station(struct sk_buff *skb, struct genl_info *info) 16348 { 16349 struct link_station_del_parameters params = {}; 16350 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16351 struct net_device *dev = info->user_ptr[1]; 16352 int ret; 16353 16354 if (!rdev->ops->del_link_station) 16355 return -EOPNOTSUPP; 16356 16357 if (!info->attrs[NL80211_ATTR_MLD_ADDR] || 16358 !info->attrs[NL80211_ATTR_MLO_LINK_ID]) 16359 return -EINVAL; 16360 16361 params.mld_mac = nla_data(info->attrs[NL80211_ATTR_MLD_ADDR]); 16362 params.link_id = nla_get_u8(info->attrs[NL80211_ATTR_MLO_LINK_ID]); 16363 16364 wdev_lock(dev->ieee80211_ptr); 16365 ret = rdev_del_link_station(rdev, dev, ¶ms); 16366 wdev_unlock(dev->ieee80211_ptr); 16367 16368 return ret; 16369 } 16370 16371 static int nl80211_set_hw_timestamp(struct sk_buff *skb, 16372 struct genl_info *info) 16373 { 16374 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16375 struct net_device *dev = info->user_ptr[1]; 16376 struct cfg80211_set_hw_timestamp hwts = {}; 16377 16378 if (!rdev->wiphy.hw_timestamp_max_peers) 16379 return -EOPNOTSUPP; 16380 16381 if (!info->attrs[NL80211_ATTR_MAC] && 16382 rdev->wiphy.hw_timestamp_max_peers != CFG80211_HW_TIMESTAMP_ALL_PEERS) 16383 return -EOPNOTSUPP; 16384 16385 if (info->attrs[NL80211_ATTR_MAC]) 16386 hwts.macaddr = nla_data(info->attrs[NL80211_ATTR_MAC]); 16387 16388 hwts.enable = 16389 nla_get_flag(info->attrs[NL80211_ATTR_HW_TIMESTAMP_ENABLED]); 16390 16391 return rdev_set_hw_timestamp(rdev, dev, &hwts); 16392 } 16393 16394 #define NL80211_FLAG_NEED_WIPHY 0x01 16395 #define NL80211_FLAG_NEED_NETDEV 0x02 16396 #define NL80211_FLAG_NEED_RTNL 0x04 16397 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08 16398 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\ 16399 NL80211_FLAG_CHECK_NETDEV_UP) 16400 #define NL80211_FLAG_NEED_WDEV 0x10 16401 /* If a netdev is associated, it must be UP, P2P must be started */ 16402 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\ 16403 NL80211_FLAG_CHECK_NETDEV_UP) 16404 #define NL80211_FLAG_CLEAR_SKB 0x20 16405 #define NL80211_FLAG_NO_WIPHY_MTX 0x40 16406 #define NL80211_FLAG_MLO_VALID_LINK_ID 0x80 16407 #define NL80211_FLAG_MLO_UNSUPPORTED 0x100 16408 16409 #define INTERNAL_FLAG_SELECTORS(__sel) \ 16410 SELECTOR(__sel, NONE, 0) /* must be first */ \ 16411 SELECTOR(__sel, WIPHY, \ 16412 NL80211_FLAG_NEED_WIPHY) \ 16413 SELECTOR(__sel, WDEV, \ 16414 NL80211_FLAG_NEED_WDEV) \ 16415 SELECTOR(__sel, NETDEV, \ 16416 NL80211_FLAG_NEED_NETDEV) \ 16417 SELECTOR(__sel, NETDEV_LINK, \ 16418 NL80211_FLAG_NEED_NETDEV | \ 16419 NL80211_FLAG_MLO_VALID_LINK_ID) \ 16420 SELECTOR(__sel, NETDEV_NO_MLO, \ 16421 NL80211_FLAG_NEED_NETDEV | \ 16422 NL80211_FLAG_MLO_UNSUPPORTED) \ 16423 SELECTOR(__sel, WIPHY_RTNL, \ 16424 NL80211_FLAG_NEED_WIPHY | \ 16425 NL80211_FLAG_NEED_RTNL) \ 16426 SELECTOR(__sel, WIPHY_RTNL_NOMTX, \ 16427 NL80211_FLAG_NEED_WIPHY | \ 16428 NL80211_FLAG_NEED_RTNL | \ 16429 NL80211_FLAG_NO_WIPHY_MTX) \ 16430 SELECTOR(__sel, WDEV_RTNL, \ 16431 NL80211_FLAG_NEED_WDEV | \ 16432 NL80211_FLAG_NEED_RTNL) \ 16433 SELECTOR(__sel, NETDEV_RTNL, \ 16434 NL80211_FLAG_NEED_NETDEV | \ 16435 NL80211_FLAG_NEED_RTNL) \ 16436 SELECTOR(__sel, NETDEV_UP, \ 16437 NL80211_FLAG_NEED_NETDEV_UP) \ 16438 SELECTOR(__sel, NETDEV_UP_LINK, \ 16439 NL80211_FLAG_NEED_NETDEV_UP | \ 16440 NL80211_FLAG_MLO_VALID_LINK_ID) \ 16441 SELECTOR(__sel, NETDEV_UP_NO_MLO, \ 16442 NL80211_FLAG_NEED_NETDEV_UP | \ 16443 NL80211_FLAG_MLO_UNSUPPORTED) \ 16444 SELECTOR(__sel, NETDEV_UP_NO_MLO_CLEAR, \ 16445 NL80211_FLAG_NEED_NETDEV_UP | \ 16446 NL80211_FLAG_CLEAR_SKB | \ 16447 NL80211_FLAG_MLO_UNSUPPORTED) \ 16448 SELECTOR(__sel, NETDEV_UP_NOTMX, \ 16449 NL80211_FLAG_NEED_NETDEV_UP | \ 16450 NL80211_FLAG_NO_WIPHY_MTX) \ 16451 SELECTOR(__sel, NETDEV_UP_NOTMX_NOMLO, \ 16452 NL80211_FLAG_NEED_NETDEV_UP | \ 16453 NL80211_FLAG_NO_WIPHY_MTX | \ 16454 NL80211_FLAG_MLO_UNSUPPORTED) \ 16455 SELECTOR(__sel, NETDEV_UP_CLEAR, \ 16456 NL80211_FLAG_NEED_NETDEV_UP | \ 16457 NL80211_FLAG_CLEAR_SKB) \ 16458 SELECTOR(__sel, WDEV_UP, \ 16459 NL80211_FLAG_NEED_WDEV_UP) \ 16460 SELECTOR(__sel, WDEV_UP_LINK, \ 16461 NL80211_FLAG_NEED_WDEV_UP | \ 16462 NL80211_FLAG_MLO_VALID_LINK_ID) \ 16463 SELECTOR(__sel, WDEV_UP_RTNL, \ 16464 NL80211_FLAG_NEED_WDEV_UP | \ 16465 NL80211_FLAG_NEED_RTNL) \ 16466 SELECTOR(__sel, WIPHY_CLEAR, \ 16467 NL80211_FLAG_NEED_WIPHY | \ 16468 NL80211_FLAG_CLEAR_SKB) 16469 16470 enum nl80211_internal_flags_selector { 16471 #define SELECTOR(_, name, value) NL80211_IFL_SEL_##name, 16472 INTERNAL_FLAG_SELECTORS(_) 16473 #undef SELECTOR 16474 }; 16475 16476 static u32 nl80211_internal_flags[] = { 16477 #define SELECTOR(_, name, value) [NL80211_IFL_SEL_##name] = value, 16478 INTERNAL_FLAG_SELECTORS(_) 16479 #undef SELECTOR 16480 }; 16481 16482 static int nl80211_pre_doit(const struct genl_split_ops *ops, 16483 struct sk_buff *skb, 16484 struct genl_info *info) 16485 { 16486 struct cfg80211_registered_device *rdev = NULL; 16487 struct wireless_dev *wdev = NULL; 16488 struct net_device *dev = NULL; 16489 u32 internal_flags; 16490 int err; 16491 16492 if (WARN_ON(ops->internal_flags >= ARRAY_SIZE(nl80211_internal_flags))) 16493 return -EINVAL; 16494 16495 internal_flags = nl80211_internal_flags[ops->internal_flags]; 16496 16497 rtnl_lock(); 16498 if (internal_flags & NL80211_FLAG_NEED_WIPHY) { 16499 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info); 16500 if (IS_ERR(rdev)) { 16501 err = PTR_ERR(rdev); 16502 goto out_unlock; 16503 } 16504 info->user_ptr[0] = rdev; 16505 } else if (internal_flags & NL80211_FLAG_NEED_NETDEV || 16506 internal_flags & NL80211_FLAG_NEED_WDEV) { 16507 wdev = __cfg80211_wdev_from_attrs(NULL, genl_info_net(info), 16508 info->attrs); 16509 if (IS_ERR(wdev)) { 16510 err = PTR_ERR(wdev); 16511 goto out_unlock; 16512 } 16513 16514 dev = wdev->netdev; 16515 dev_hold(dev); 16516 rdev = wiphy_to_rdev(wdev->wiphy); 16517 16518 if (internal_flags & NL80211_FLAG_NEED_NETDEV) { 16519 if (!dev) { 16520 err = -EINVAL; 16521 goto out_unlock; 16522 } 16523 16524 info->user_ptr[1] = dev; 16525 } else { 16526 info->user_ptr[1] = wdev; 16527 } 16528 16529 if (internal_flags & NL80211_FLAG_CHECK_NETDEV_UP && 16530 !wdev_running(wdev)) { 16531 err = -ENETDOWN; 16532 goto out_unlock; 16533 } 16534 16535 info->user_ptr[0] = rdev; 16536 } 16537 16538 if (internal_flags & NL80211_FLAG_MLO_VALID_LINK_ID) { 16539 struct nlattr *link_id = info->attrs[NL80211_ATTR_MLO_LINK_ID]; 16540 16541 if (!wdev) { 16542 err = -EINVAL; 16543 goto out_unlock; 16544 } 16545 16546 /* MLO -> require valid link ID */ 16547 if (wdev->valid_links && 16548 (!link_id || 16549 !(wdev->valid_links & BIT(nla_get_u8(link_id))))) { 16550 err = -EINVAL; 16551 goto out_unlock; 16552 } 16553 16554 /* non-MLO -> no link ID attribute accepted */ 16555 if (!wdev->valid_links && link_id) { 16556 err = -EINVAL; 16557 goto out_unlock; 16558 } 16559 } 16560 16561 if (internal_flags & NL80211_FLAG_MLO_UNSUPPORTED) { 16562 if (info->attrs[NL80211_ATTR_MLO_LINK_ID] || 16563 (wdev && wdev->valid_links)) { 16564 err = -EINVAL; 16565 goto out_unlock; 16566 } 16567 } 16568 16569 if (rdev && !(internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) { 16570 wiphy_lock(&rdev->wiphy); 16571 /* we keep the mutex locked until post_doit */ 16572 __release(&rdev->wiphy.mtx); 16573 } 16574 if (!(internal_flags & NL80211_FLAG_NEED_RTNL)) 16575 rtnl_unlock(); 16576 16577 return 0; 16578 out_unlock: 16579 rtnl_unlock(); 16580 dev_put(dev); 16581 return err; 16582 } 16583 16584 static void nl80211_post_doit(const struct genl_split_ops *ops, 16585 struct sk_buff *skb, 16586 struct genl_info *info) 16587 { 16588 u32 internal_flags = nl80211_internal_flags[ops->internal_flags]; 16589 16590 if (info->user_ptr[1]) { 16591 if (internal_flags & NL80211_FLAG_NEED_WDEV) { 16592 struct wireless_dev *wdev = info->user_ptr[1]; 16593 16594 dev_put(wdev->netdev); 16595 } else { 16596 dev_put(info->user_ptr[1]); 16597 } 16598 } 16599 16600 if (info->user_ptr[0] && 16601 !(internal_flags & NL80211_FLAG_NO_WIPHY_MTX)) { 16602 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16603 16604 /* we kept the mutex locked since pre_doit */ 16605 __acquire(&rdev->wiphy.mtx); 16606 wiphy_unlock(&rdev->wiphy); 16607 } 16608 16609 if (internal_flags & NL80211_FLAG_NEED_RTNL) 16610 rtnl_unlock(); 16611 16612 /* If needed, clear the netlink message payload from the SKB 16613 * as it might contain key data that shouldn't stick around on 16614 * the heap after the SKB is freed. The netlink message header 16615 * is still needed for further processing, so leave it intact. 16616 */ 16617 if (internal_flags & NL80211_FLAG_CLEAR_SKB) { 16618 struct nlmsghdr *nlh = nlmsg_hdr(skb); 16619 16620 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh)); 16621 } 16622 } 16623 16624 static int nl80211_set_sar_sub_specs(struct cfg80211_registered_device *rdev, 16625 struct cfg80211_sar_specs *sar_specs, 16626 struct nlattr *spec[], int index) 16627 { 16628 u32 range_index, i; 16629 16630 if (!sar_specs || !spec) 16631 return -EINVAL; 16632 16633 if (!spec[NL80211_SAR_ATTR_SPECS_POWER] || 16634 !spec[NL80211_SAR_ATTR_SPECS_RANGE_INDEX]) 16635 return -EINVAL; 16636 16637 range_index = nla_get_u32(spec[NL80211_SAR_ATTR_SPECS_RANGE_INDEX]); 16638 16639 /* check if range_index exceeds num_freq_ranges */ 16640 if (range_index >= rdev->wiphy.sar_capa->num_freq_ranges) 16641 return -EINVAL; 16642 16643 /* check if range_index duplicates */ 16644 for (i = 0; i < index; i++) { 16645 if (sar_specs->sub_specs[i].freq_range_index == range_index) 16646 return -EINVAL; 16647 } 16648 16649 sar_specs->sub_specs[index].power = 16650 nla_get_s32(spec[NL80211_SAR_ATTR_SPECS_POWER]); 16651 16652 sar_specs->sub_specs[index].freq_range_index = range_index; 16653 16654 return 0; 16655 } 16656 16657 static int nl80211_set_sar_specs(struct sk_buff *skb, struct genl_info *info) 16658 { 16659 struct cfg80211_registered_device *rdev = info->user_ptr[0]; 16660 struct nlattr *spec[NL80211_SAR_ATTR_SPECS_MAX + 1]; 16661 struct nlattr *tb[NL80211_SAR_ATTR_MAX + 1]; 16662 struct cfg80211_sar_specs *sar_spec; 16663 enum nl80211_sar_type type; 16664 struct nlattr *spec_list; 16665 u32 specs; 16666 int rem, err; 16667 16668 if (!rdev->wiphy.sar_capa || !rdev->ops->set_sar_specs) 16669 return -EOPNOTSUPP; 16670 16671 if (!info->attrs[NL80211_ATTR_SAR_SPEC]) 16672 return -EINVAL; 16673 16674 nla_parse_nested(tb, NL80211_SAR_ATTR_MAX, 16675 info->attrs[NL80211_ATTR_SAR_SPEC], 16676 NULL, NULL); 16677 16678 if (!tb[NL80211_SAR_ATTR_TYPE] || !tb[NL80211_SAR_ATTR_SPECS]) 16679 return -EINVAL; 16680 16681 type = nla_get_u32(tb[NL80211_SAR_ATTR_TYPE]); 16682 if (type != rdev->wiphy.sar_capa->type) 16683 return -EINVAL; 16684 16685 specs = 0; 16686 nla_for_each_nested(spec_list, tb[NL80211_SAR_ATTR_SPECS], rem) 16687 specs++; 16688 16689 if (specs > rdev->wiphy.sar_capa->num_freq_ranges) 16690 return -EINVAL; 16691 16692 sar_spec = kzalloc(struct_size(sar_spec, sub_specs, specs), GFP_KERNEL); 16693 if (!sar_spec) 16694 return -ENOMEM; 16695 16696 sar_spec->type = type; 16697 specs = 0; 16698 nla_for_each_nested(spec_list, tb[NL80211_SAR_ATTR_SPECS], rem) { 16699 nla_parse_nested(spec, NL80211_SAR_ATTR_SPECS_MAX, 16700 spec_list, NULL, NULL); 16701 16702 switch (type) { 16703 case NL80211_SAR_TYPE_POWER: 16704 if (nl80211_set_sar_sub_specs(rdev, sar_spec, 16705 spec, specs)) { 16706 err = -EINVAL; 16707 goto error; 16708 } 16709 break; 16710 default: 16711 err = -EINVAL; 16712 goto error; 16713 } 16714 specs++; 16715 } 16716 16717 sar_spec->num_sub_specs = specs; 16718 16719 rdev->cur_cmd_info = info; 16720 err = rdev_set_sar_specs(rdev, sar_spec); 16721 rdev->cur_cmd_info = NULL; 16722 error: 16723 kfree(sar_spec); 16724 return err; 16725 } 16726 16727 #define SELECTOR(__sel, name, value) \ 16728 ((__sel) == (value)) ? NL80211_IFL_SEL_##name : 16729 int __missing_selector(void); 16730 #define IFLAGS(__val) INTERNAL_FLAG_SELECTORS(__val) __missing_selector() 16731 16732 static const struct genl_ops nl80211_ops[] = { 16733 { 16734 .cmd = NL80211_CMD_GET_WIPHY, 16735 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16736 .doit = nl80211_get_wiphy, 16737 .dumpit = nl80211_dump_wiphy, 16738 .done = nl80211_dump_wiphy_done, 16739 /* can be retrieved by unprivileged users */ 16740 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 16741 }, 16742 }; 16743 16744 static const struct genl_small_ops nl80211_small_ops[] = { 16745 { 16746 .cmd = NL80211_CMD_SET_WIPHY, 16747 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16748 .doit = nl80211_set_wiphy, 16749 .flags = GENL_UNS_ADMIN_PERM, 16750 }, 16751 { 16752 .cmd = NL80211_CMD_GET_INTERFACE, 16753 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16754 .doit = nl80211_get_interface, 16755 .dumpit = nl80211_dump_interface, 16756 /* can be retrieved by unprivileged users */ 16757 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV), 16758 }, 16759 { 16760 .cmd = NL80211_CMD_SET_INTERFACE, 16761 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16762 .doit = nl80211_set_interface, 16763 .flags = GENL_UNS_ADMIN_PERM, 16764 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV | 16765 NL80211_FLAG_NEED_RTNL), 16766 }, 16767 { 16768 .cmd = NL80211_CMD_NEW_INTERFACE, 16769 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16770 .doit = nl80211_new_interface, 16771 .flags = GENL_UNS_ADMIN_PERM, 16772 .internal_flags = 16773 IFLAGS(NL80211_FLAG_NEED_WIPHY | 16774 NL80211_FLAG_NEED_RTNL | 16775 /* we take the wiphy mutex later ourselves */ 16776 NL80211_FLAG_NO_WIPHY_MTX), 16777 }, 16778 { 16779 .cmd = NL80211_CMD_DEL_INTERFACE, 16780 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16781 .doit = nl80211_del_interface, 16782 .flags = GENL_UNS_ADMIN_PERM, 16783 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV | 16784 NL80211_FLAG_NEED_RTNL), 16785 }, 16786 { 16787 .cmd = NL80211_CMD_GET_KEY, 16788 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16789 .doit = nl80211_get_key, 16790 .flags = GENL_UNS_ADMIN_PERM, 16791 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16792 }, 16793 { 16794 .cmd = NL80211_CMD_SET_KEY, 16795 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16796 .doit = nl80211_set_key, 16797 .flags = GENL_UNS_ADMIN_PERM, 16798 /* cannot use NL80211_FLAG_MLO_VALID_LINK_ID, depends on key */ 16799 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16800 NL80211_FLAG_CLEAR_SKB), 16801 }, 16802 { 16803 .cmd = NL80211_CMD_NEW_KEY, 16804 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16805 .doit = nl80211_new_key, 16806 .flags = GENL_UNS_ADMIN_PERM, 16807 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16808 NL80211_FLAG_CLEAR_SKB), 16809 }, 16810 { 16811 .cmd = NL80211_CMD_DEL_KEY, 16812 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16813 .doit = nl80211_del_key, 16814 .flags = GENL_UNS_ADMIN_PERM, 16815 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16816 }, 16817 { 16818 .cmd = NL80211_CMD_SET_BEACON, 16819 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16820 .flags = GENL_UNS_ADMIN_PERM, 16821 .doit = nl80211_set_beacon, 16822 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16823 NL80211_FLAG_MLO_VALID_LINK_ID), 16824 }, 16825 { 16826 .cmd = NL80211_CMD_START_AP, 16827 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16828 .flags = GENL_UNS_ADMIN_PERM, 16829 .doit = nl80211_start_ap, 16830 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16831 NL80211_FLAG_MLO_VALID_LINK_ID), 16832 }, 16833 { 16834 .cmd = NL80211_CMD_STOP_AP, 16835 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16836 .flags = GENL_UNS_ADMIN_PERM, 16837 .doit = nl80211_stop_ap, 16838 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16839 NL80211_FLAG_MLO_VALID_LINK_ID), 16840 }, 16841 { 16842 .cmd = NL80211_CMD_GET_STATION, 16843 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16844 .doit = nl80211_get_station, 16845 .dumpit = nl80211_dump_station, 16846 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 16847 }, 16848 { 16849 .cmd = NL80211_CMD_SET_STATION, 16850 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16851 .doit = nl80211_set_station, 16852 .flags = GENL_UNS_ADMIN_PERM, 16853 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16854 }, 16855 { 16856 .cmd = NL80211_CMD_NEW_STATION, 16857 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16858 .doit = nl80211_new_station, 16859 .flags = GENL_UNS_ADMIN_PERM, 16860 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16861 }, 16862 { 16863 .cmd = NL80211_CMD_DEL_STATION, 16864 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16865 .doit = nl80211_del_station, 16866 .flags = GENL_UNS_ADMIN_PERM, 16867 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16868 }, 16869 { 16870 .cmd = NL80211_CMD_GET_MPATH, 16871 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16872 .doit = nl80211_get_mpath, 16873 .dumpit = nl80211_dump_mpath, 16874 .flags = GENL_UNS_ADMIN_PERM, 16875 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16876 }, 16877 { 16878 .cmd = NL80211_CMD_GET_MPP, 16879 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16880 .doit = nl80211_get_mpp, 16881 .dumpit = nl80211_dump_mpp, 16882 .flags = GENL_UNS_ADMIN_PERM, 16883 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16884 }, 16885 { 16886 .cmd = NL80211_CMD_SET_MPATH, 16887 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16888 .doit = nl80211_set_mpath, 16889 .flags = GENL_UNS_ADMIN_PERM, 16890 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16891 }, 16892 { 16893 .cmd = NL80211_CMD_NEW_MPATH, 16894 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16895 .doit = nl80211_new_mpath, 16896 .flags = GENL_UNS_ADMIN_PERM, 16897 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16898 }, 16899 { 16900 .cmd = NL80211_CMD_DEL_MPATH, 16901 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16902 .doit = nl80211_del_mpath, 16903 .flags = GENL_UNS_ADMIN_PERM, 16904 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16905 }, 16906 { 16907 .cmd = NL80211_CMD_SET_BSS, 16908 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16909 .doit = nl80211_set_bss, 16910 .flags = GENL_UNS_ADMIN_PERM, 16911 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16912 NL80211_FLAG_MLO_VALID_LINK_ID), 16913 }, 16914 { 16915 .cmd = NL80211_CMD_GET_REG, 16916 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16917 .doit = nl80211_get_reg_do, 16918 .dumpit = nl80211_get_reg_dump, 16919 /* can be retrieved by unprivileged users */ 16920 }, 16921 #ifdef CONFIG_CFG80211_CRDA_SUPPORT 16922 { 16923 .cmd = NL80211_CMD_SET_REG, 16924 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16925 .doit = nl80211_set_reg, 16926 .flags = GENL_ADMIN_PERM, 16927 }, 16928 #endif 16929 { 16930 .cmd = NL80211_CMD_REQ_SET_REG, 16931 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16932 .doit = nl80211_req_set_reg, 16933 .flags = GENL_ADMIN_PERM, 16934 }, 16935 { 16936 .cmd = NL80211_CMD_RELOAD_REGDB, 16937 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16938 .doit = nl80211_reload_regdb, 16939 .flags = GENL_ADMIN_PERM, 16940 }, 16941 { 16942 .cmd = NL80211_CMD_GET_MESH_CONFIG, 16943 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16944 .doit = nl80211_get_mesh_config, 16945 /* can be retrieved by unprivileged users */ 16946 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16947 }, 16948 { 16949 .cmd = NL80211_CMD_SET_MESH_CONFIG, 16950 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16951 .doit = nl80211_update_mesh_config, 16952 .flags = GENL_UNS_ADMIN_PERM, 16953 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16954 }, 16955 { 16956 .cmd = NL80211_CMD_TRIGGER_SCAN, 16957 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16958 .doit = nl80211_trigger_scan, 16959 .flags = GENL_UNS_ADMIN_PERM, 16960 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 16961 }, 16962 { 16963 .cmd = NL80211_CMD_ABORT_SCAN, 16964 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16965 .doit = nl80211_abort_scan, 16966 .flags = GENL_UNS_ADMIN_PERM, 16967 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 16968 }, 16969 { 16970 .cmd = NL80211_CMD_GET_SCAN, 16971 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16972 .dumpit = nl80211_dump_scan, 16973 }, 16974 { 16975 .cmd = NL80211_CMD_START_SCHED_SCAN, 16976 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16977 .doit = nl80211_start_sched_scan, 16978 .flags = GENL_UNS_ADMIN_PERM, 16979 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16980 }, 16981 { 16982 .cmd = NL80211_CMD_STOP_SCHED_SCAN, 16983 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16984 .doit = nl80211_stop_sched_scan, 16985 .flags = GENL_UNS_ADMIN_PERM, 16986 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 16987 }, 16988 { 16989 .cmd = NL80211_CMD_AUTHENTICATE, 16990 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16991 .doit = nl80211_authenticate, 16992 .flags = GENL_UNS_ADMIN_PERM, 16993 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 16994 NL80211_FLAG_CLEAR_SKB), 16995 }, 16996 { 16997 .cmd = NL80211_CMD_ASSOCIATE, 16998 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 16999 .doit = nl80211_associate, 17000 .flags = GENL_UNS_ADMIN_PERM, 17001 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17002 NL80211_FLAG_CLEAR_SKB), 17003 }, 17004 { 17005 .cmd = NL80211_CMD_DEAUTHENTICATE, 17006 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17007 .doit = nl80211_deauthenticate, 17008 .flags = GENL_UNS_ADMIN_PERM, 17009 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17010 }, 17011 { 17012 .cmd = NL80211_CMD_DISASSOCIATE, 17013 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17014 .doit = nl80211_disassociate, 17015 .flags = GENL_UNS_ADMIN_PERM, 17016 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17017 }, 17018 { 17019 .cmd = NL80211_CMD_JOIN_IBSS, 17020 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17021 .doit = nl80211_join_ibss, 17022 .flags = GENL_UNS_ADMIN_PERM, 17023 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17024 }, 17025 { 17026 .cmd = NL80211_CMD_LEAVE_IBSS, 17027 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17028 .doit = nl80211_leave_ibss, 17029 .flags = GENL_UNS_ADMIN_PERM, 17030 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17031 }, 17032 #ifdef CONFIG_NL80211_TESTMODE 17033 { 17034 .cmd = NL80211_CMD_TESTMODE, 17035 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17036 .doit = nl80211_testmode_do, 17037 .dumpit = nl80211_testmode_dump, 17038 .flags = GENL_UNS_ADMIN_PERM, 17039 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 17040 }, 17041 #endif 17042 { 17043 .cmd = NL80211_CMD_CONNECT, 17044 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17045 .doit = nl80211_connect, 17046 .flags = GENL_UNS_ADMIN_PERM, 17047 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17048 NL80211_FLAG_CLEAR_SKB), 17049 }, 17050 { 17051 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS, 17052 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17053 .doit = nl80211_update_connect_params, 17054 .flags = GENL_ADMIN_PERM, 17055 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17056 NL80211_FLAG_CLEAR_SKB), 17057 }, 17058 { 17059 .cmd = NL80211_CMD_DISCONNECT, 17060 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17061 .doit = nl80211_disconnect, 17062 .flags = GENL_UNS_ADMIN_PERM, 17063 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17064 }, 17065 { 17066 .cmd = NL80211_CMD_SET_WIPHY_NETNS, 17067 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17068 .doit = nl80211_wiphy_netns, 17069 .flags = GENL_UNS_ADMIN_PERM, 17070 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY | 17071 NL80211_FLAG_NEED_RTNL | 17072 NL80211_FLAG_NO_WIPHY_MTX), 17073 }, 17074 { 17075 .cmd = NL80211_CMD_GET_SURVEY, 17076 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17077 .dumpit = nl80211_dump_survey, 17078 }, 17079 { 17080 .cmd = NL80211_CMD_SET_PMKSA, 17081 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17082 .doit = nl80211_setdel_pmksa, 17083 .flags = GENL_UNS_ADMIN_PERM, 17084 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17085 NL80211_FLAG_CLEAR_SKB), 17086 }, 17087 { 17088 .cmd = NL80211_CMD_DEL_PMKSA, 17089 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17090 .doit = nl80211_setdel_pmksa, 17091 .flags = GENL_UNS_ADMIN_PERM, 17092 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17093 }, 17094 { 17095 .cmd = NL80211_CMD_FLUSH_PMKSA, 17096 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17097 .doit = nl80211_flush_pmksa, 17098 .flags = GENL_UNS_ADMIN_PERM, 17099 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17100 }, 17101 { 17102 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL, 17103 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17104 .doit = nl80211_remain_on_channel, 17105 .flags = GENL_UNS_ADMIN_PERM, 17106 /* FIXME: requiring a link ID here is probably not good */ 17107 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP | 17108 NL80211_FLAG_MLO_VALID_LINK_ID), 17109 }, 17110 { 17111 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL, 17112 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17113 .doit = nl80211_cancel_remain_on_channel, 17114 .flags = GENL_UNS_ADMIN_PERM, 17115 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17116 }, 17117 { 17118 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK, 17119 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17120 .doit = nl80211_set_tx_bitrate_mask, 17121 .flags = GENL_UNS_ADMIN_PERM, 17122 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV | 17123 NL80211_FLAG_MLO_VALID_LINK_ID), 17124 }, 17125 { 17126 .cmd = NL80211_CMD_REGISTER_FRAME, 17127 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17128 .doit = nl80211_register_mgmt, 17129 .flags = GENL_UNS_ADMIN_PERM, 17130 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV), 17131 }, 17132 { 17133 .cmd = NL80211_CMD_FRAME, 17134 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17135 .doit = nl80211_tx_mgmt, 17136 .flags = GENL_UNS_ADMIN_PERM, 17137 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17138 }, 17139 { 17140 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL, 17141 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17142 .doit = nl80211_tx_mgmt_cancel_wait, 17143 .flags = GENL_UNS_ADMIN_PERM, 17144 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17145 }, 17146 { 17147 .cmd = NL80211_CMD_SET_POWER_SAVE, 17148 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17149 .doit = nl80211_set_power_save, 17150 .flags = GENL_UNS_ADMIN_PERM, 17151 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17152 }, 17153 { 17154 .cmd = NL80211_CMD_GET_POWER_SAVE, 17155 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17156 .doit = nl80211_get_power_save, 17157 /* can be retrieved by unprivileged users */ 17158 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17159 }, 17160 { 17161 .cmd = NL80211_CMD_SET_CQM, 17162 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17163 .doit = nl80211_set_cqm, 17164 .flags = GENL_UNS_ADMIN_PERM, 17165 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17166 }, 17167 { 17168 .cmd = NL80211_CMD_SET_CHANNEL, 17169 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17170 .doit = nl80211_set_channel, 17171 .flags = GENL_UNS_ADMIN_PERM, 17172 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV | 17173 NL80211_FLAG_MLO_VALID_LINK_ID), 17174 }, 17175 { 17176 .cmd = NL80211_CMD_JOIN_MESH, 17177 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17178 .doit = nl80211_join_mesh, 17179 .flags = GENL_UNS_ADMIN_PERM, 17180 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17181 }, 17182 { 17183 .cmd = NL80211_CMD_LEAVE_MESH, 17184 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17185 .doit = nl80211_leave_mesh, 17186 .flags = GENL_UNS_ADMIN_PERM, 17187 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17188 }, 17189 { 17190 .cmd = NL80211_CMD_JOIN_OCB, 17191 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17192 .doit = nl80211_join_ocb, 17193 .flags = GENL_UNS_ADMIN_PERM, 17194 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17195 }, 17196 { 17197 .cmd = NL80211_CMD_LEAVE_OCB, 17198 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17199 .doit = nl80211_leave_ocb, 17200 .flags = GENL_UNS_ADMIN_PERM, 17201 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17202 }, 17203 #ifdef CONFIG_PM 17204 { 17205 .cmd = NL80211_CMD_GET_WOWLAN, 17206 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17207 .doit = nl80211_get_wowlan, 17208 /* can be retrieved by unprivileged users */ 17209 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 17210 }, 17211 { 17212 .cmd = NL80211_CMD_SET_WOWLAN, 17213 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17214 .doit = nl80211_set_wowlan, 17215 .flags = GENL_UNS_ADMIN_PERM, 17216 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 17217 }, 17218 #endif 17219 { 17220 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD, 17221 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17222 .doit = nl80211_set_rekey_data, 17223 .flags = GENL_UNS_ADMIN_PERM, 17224 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17225 NL80211_FLAG_CLEAR_SKB), 17226 }, 17227 { 17228 .cmd = NL80211_CMD_TDLS_MGMT, 17229 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17230 .doit = nl80211_tdls_mgmt, 17231 .flags = GENL_UNS_ADMIN_PERM, 17232 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17233 NL80211_FLAG_MLO_VALID_LINK_ID), 17234 }, 17235 { 17236 .cmd = NL80211_CMD_TDLS_OPER, 17237 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17238 .doit = nl80211_tdls_oper, 17239 .flags = GENL_UNS_ADMIN_PERM, 17240 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17241 }, 17242 { 17243 .cmd = NL80211_CMD_UNEXPECTED_FRAME, 17244 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17245 .doit = nl80211_register_unexpected_frame, 17246 .flags = GENL_UNS_ADMIN_PERM, 17247 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17248 }, 17249 { 17250 .cmd = NL80211_CMD_PROBE_CLIENT, 17251 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17252 .doit = nl80211_probe_client, 17253 .flags = GENL_UNS_ADMIN_PERM, 17254 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17255 }, 17256 { 17257 .cmd = NL80211_CMD_REGISTER_BEACONS, 17258 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17259 .doit = nl80211_register_beacons, 17260 .flags = GENL_UNS_ADMIN_PERM, 17261 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 17262 }, 17263 { 17264 .cmd = NL80211_CMD_SET_NOACK_MAP, 17265 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17266 .doit = nl80211_set_noack_map, 17267 .flags = GENL_UNS_ADMIN_PERM, 17268 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17269 }, 17270 { 17271 .cmd = NL80211_CMD_START_P2P_DEVICE, 17272 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17273 .doit = nl80211_start_p2p_device, 17274 .flags = GENL_UNS_ADMIN_PERM, 17275 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV | 17276 NL80211_FLAG_NEED_RTNL), 17277 }, 17278 { 17279 .cmd = NL80211_CMD_STOP_P2P_DEVICE, 17280 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17281 .doit = nl80211_stop_p2p_device, 17282 .flags = GENL_UNS_ADMIN_PERM, 17283 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP | 17284 NL80211_FLAG_NEED_RTNL), 17285 }, 17286 { 17287 .cmd = NL80211_CMD_START_NAN, 17288 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17289 .doit = nl80211_start_nan, 17290 .flags = GENL_ADMIN_PERM, 17291 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV | 17292 NL80211_FLAG_NEED_RTNL), 17293 }, 17294 { 17295 .cmd = NL80211_CMD_STOP_NAN, 17296 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17297 .doit = nl80211_stop_nan, 17298 .flags = GENL_ADMIN_PERM, 17299 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP | 17300 NL80211_FLAG_NEED_RTNL), 17301 }, 17302 { 17303 .cmd = NL80211_CMD_ADD_NAN_FUNCTION, 17304 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17305 .doit = nl80211_nan_add_func, 17306 .flags = GENL_ADMIN_PERM, 17307 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17308 }, 17309 { 17310 .cmd = NL80211_CMD_DEL_NAN_FUNCTION, 17311 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17312 .doit = nl80211_nan_del_func, 17313 .flags = GENL_ADMIN_PERM, 17314 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17315 }, 17316 { 17317 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG, 17318 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17319 .doit = nl80211_nan_change_config, 17320 .flags = GENL_ADMIN_PERM, 17321 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17322 }, 17323 { 17324 .cmd = NL80211_CMD_SET_MCAST_RATE, 17325 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17326 .doit = nl80211_set_mcast_rate, 17327 .flags = GENL_UNS_ADMIN_PERM, 17328 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17329 }, 17330 { 17331 .cmd = NL80211_CMD_SET_MAC_ACL, 17332 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17333 .doit = nl80211_set_mac_acl, 17334 .flags = GENL_UNS_ADMIN_PERM, 17335 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV | 17336 NL80211_FLAG_MLO_UNSUPPORTED), 17337 }, 17338 { 17339 .cmd = NL80211_CMD_RADAR_DETECT, 17340 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17341 .doit = nl80211_start_radar_detection, 17342 .flags = GENL_UNS_ADMIN_PERM, 17343 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17344 NL80211_FLAG_NO_WIPHY_MTX | 17345 NL80211_FLAG_MLO_UNSUPPORTED), 17346 }, 17347 { 17348 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES, 17349 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17350 .doit = nl80211_get_protocol_features, 17351 }, 17352 { 17353 .cmd = NL80211_CMD_UPDATE_FT_IES, 17354 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17355 .doit = nl80211_update_ft_ies, 17356 .flags = GENL_UNS_ADMIN_PERM, 17357 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17358 }, 17359 { 17360 .cmd = NL80211_CMD_CRIT_PROTOCOL_START, 17361 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17362 .doit = nl80211_crit_protocol_start, 17363 .flags = GENL_UNS_ADMIN_PERM, 17364 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17365 }, 17366 { 17367 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP, 17368 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17369 .doit = nl80211_crit_protocol_stop, 17370 .flags = GENL_UNS_ADMIN_PERM, 17371 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17372 }, 17373 { 17374 .cmd = NL80211_CMD_GET_COALESCE, 17375 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17376 .doit = nl80211_get_coalesce, 17377 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 17378 }, 17379 { 17380 .cmd = NL80211_CMD_SET_COALESCE, 17381 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17382 .doit = nl80211_set_coalesce, 17383 .flags = GENL_UNS_ADMIN_PERM, 17384 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY), 17385 }, 17386 { 17387 .cmd = NL80211_CMD_CHANNEL_SWITCH, 17388 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17389 .doit = nl80211_channel_switch, 17390 .flags = GENL_UNS_ADMIN_PERM, 17391 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17392 NL80211_FLAG_MLO_VALID_LINK_ID), 17393 }, 17394 { 17395 .cmd = NL80211_CMD_VENDOR, 17396 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17397 .doit = nl80211_vendor_cmd, 17398 .dumpit = nl80211_vendor_cmd_dump, 17399 .flags = GENL_UNS_ADMIN_PERM, 17400 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY | 17401 NL80211_FLAG_CLEAR_SKB), 17402 }, 17403 { 17404 .cmd = NL80211_CMD_SET_QOS_MAP, 17405 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17406 .doit = nl80211_set_qos_map, 17407 .flags = GENL_UNS_ADMIN_PERM, 17408 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17409 }, 17410 { 17411 .cmd = NL80211_CMD_ADD_TX_TS, 17412 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17413 .doit = nl80211_add_tx_ts, 17414 .flags = GENL_UNS_ADMIN_PERM, 17415 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17416 NL80211_FLAG_MLO_UNSUPPORTED), 17417 }, 17418 { 17419 .cmd = NL80211_CMD_DEL_TX_TS, 17420 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17421 .doit = nl80211_del_tx_ts, 17422 .flags = GENL_UNS_ADMIN_PERM, 17423 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17424 }, 17425 { 17426 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH, 17427 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17428 .doit = nl80211_tdls_channel_switch, 17429 .flags = GENL_UNS_ADMIN_PERM, 17430 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17431 }, 17432 { 17433 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH, 17434 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17435 .doit = nl80211_tdls_cancel_channel_switch, 17436 .flags = GENL_UNS_ADMIN_PERM, 17437 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17438 }, 17439 { 17440 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST, 17441 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17442 .doit = nl80211_set_multicast_to_unicast, 17443 .flags = GENL_UNS_ADMIN_PERM, 17444 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV), 17445 }, 17446 { 17447 .cmd = NL80211_CMD_SET_PMK, 17448 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17449 .doit = nl80211_set_pmk, 17450 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17451 NL80211_FLAG_CLEAR_SKB), 17452 }, 17453 { 17454 .cmd = NL80211_CMD_DEL_PMK, 17455 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17456 .doit = nl80211_del_pmk, 17457 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17458 }, 17459 { 17460 .cmd = NL80211_CMD_EXTERNAL_AUTH, 17461 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17462 .doit = nl80211_external_auth, 17463 .flags = GENL_ADMIN_PERM, 17464 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17465 }, 17466 { 17467 .cmd = NL80211_CMD_CONTROL_PORT_FRAME, 17468 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17469 .doit = nl80211_tx_control_port, 17470 .flags = GENL_UNS_ADMIN_PERM, 17471 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17472 }, 17473 { 17474 .cmd = NL80211_CMD_GET_FTM_RESPONDER_STATS, 17475 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17476 .doit = nl80211_get_ftm_responder_stats, 17477 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV | 17478 NL80211_FLAG_MLO_VALID_LINK_ID), 17479 }, 17480 { 17481 .cmd = NL80211_CMD_PEER_MEASUREMENT_START, 17482 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17483 .doit = nl80211_pmsr_start, 17484 .flags = GENL_UNS_ADMIN_PERM, 17485 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WDEV_UP), 17486 }, 17487 { 17488 .cmd = NL80211_CMD_NOTIFY_RADAR, 17489 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17490 .doit = nl80211_notify_radar_detection, 17491 .flags = GENL_UNS_ADMIN_PERM, 17492 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17493 }, 17494 { 17495 .cmd = NL80211_CMD_UPDATE_OWE_INFO, 17496 .doit = nl80211_update_owe_info, 17497 .flags = GENL_ADMIN_PERM, 17498 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17499 }, 17500 { 17501 .cmd = NL80211_CMD_PROBE_MESH_LINK, 17502 .doit = nl80211_probe_mesh_link, 17503 .flags = GENL_UNS_ADMIN_PERM, 17504 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17505 }, 17506 { 17507 .cmd = NL80211_CMD_SET_TID_CONFIG, 17508 .doit = nl80211_set_tid_config, 17509 .flags = GENL_UNS_ADMIN_PERM, 17510 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV | 17511 NL80211_FLAG_MLO_VALID_LINK_ID), 17512 }, 17513 { 17514 .cmd = NL80211_CMD_SET_SAR_SPECS, 17515 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17516 .doit = nl80211_set_sar_specs, 17517 .flags = GENL_UNS_ADMIN_PERM, 17518 .internal_flags = IFLAGS(NL80211_FLAG_NEED_WIPHY | 17519 NL80211_FLAG_NEED_RTNL), 17520 }, 17521 { 17522 .cmd = NL80211_CMD_COLOR_CHANGE_REQUEST, 17523 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17524 .doit = nl80211_color_change, 17525 .flags = GENL_UNS_ADMIN_PERM, 17526 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17527 }, 17528 { 17529 .cmd = NL80211_CMD_SET_FILS_AAD, 17530 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP, 17531 .doit = nl80211_set_fils_aad, 17532 .flags = GENL_UNS_ADMIN_PERM, 17533 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17534 }, 17535 { 17536 .cmd = NL80211_CMD_ADD_LINK, 17537 .doit = nl80211_add_link, 17538 .flags = GENL_UNS_ADMIN_PERM, 17539 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17540 }, 17541 { 17542 .cmd = NL80211_CMD_REMOVE_LINK, 17543 .doit = nl80211_remove_link, 17544 .flags = GENL_UNS_ADMIN_PERM, 17545 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17546 NL80211_FLAG_MLO_VALID_LINK_ID), 17547 }, 17548 { 17549 .cmd = NL80211_CMD_ADD_LINK_STA, 17550 .doit = nl80211_add_link_station, 17551 .flags = GENL_UNS_ADMIN_PERM, 17552 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17553 NL80211_FLAG_MLO_VALID_LINK_ID), 17554 }, 17555 { 17556 .cmd = NL80211_CMD_MODIFY_LINK_STA, 17557 .doit = nl80211_modify_link_station, 17558 .flags = GENL_UNS_ADMIN_PERM, 17559 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17560 NL80211_FLAG_MLO_VALID_LINK_ID), 17561 }, 17562 { 17563 .cmd = NL80211_CMD_REMOVE_LINK_STA, 17564 .doit = nl80211_remove_link_station, 17565 .flags = GENL_UNS_ADMIN_PERM, 17566 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP | 17567 NL80211_FLAG_MLO_VALID_LINK_ID), 17568 }, 17569 { 17570 .cmd = NL80211_CMD_SET_HW_TIMESTAMP, 17571 .doit = nl80211_set_hw_timestamp, 17572 .flags = GENL_UNS_ADMIN_PERM, 17573 .internal_flags = IFLAGS(NL80211_FLAG_NEED_NETDEV_UP), 17574 }, 17575 }; 17576 17577 static struct genl_family nl80211_fam __ro_after_init = { 17578 .name = NL80211_GENL_NAME, /* have users key off the name instead */ 17579 .hdrsize = 0, /* no private header */ 17580 .version = 1, /* no particular meaning now */ 17581 .maxattr = NL80211_ATTR_MAX, 17582 .policy = nl80211_policy, 17583 .netnsok = true, 17584 .pre_doit = nl80211_pre_doit, 17585 .post_doit = nl80211_post_doit, 17586 .module = THIS_MODULE, 17587 .ops = nl80211_ops, 17588 .n_ops = ARRAY_SIZE(nl80211_ops), 17589 .small_ops = nl80211_small_ops, 17590 .n_small_ops = ARRAY_SIZE(nl80211_small_ops), 17591 .resv_start_op = NL80211_CMD_REMOVE_LINK_STA + 1, 17592 .mcgrps = nl80211_mcgrps, 17593 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps), 17594 .parallel_ops = true, 17595 }; 17596 17597 /* notification functions */ 17598 17599 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev, 17600 enum nl80211_commands cmd) 17601 { 17602 struct sk_buff *msg; 17603 struct nl80211_dump_wiphy_state state = {}; 17604 17605 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY && 17606 cmd != NL80211_CMD_DEL_WIPHY); 17607 17608 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 17609 if (!msg) 17610 return; 17611 17612 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) { 17613 nlmsg_free(msg); 17614 return; 17615 } 17616 17617 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 17618 NL80211_MCGRP_CONFIG, GFP_KERNEL); 17619 } 17620 17621 void nl80211_notify_iface(struct cfg80211_registered_device *rdev, 17622 struct wireless_dev *wdev, 17623 enum nl80211_commands cmd) 17624 { 17625 struct sk_buff *msg; 17626 17627 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 17628 if (!msg) 17629 return; 17630 17631 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, cmd) < 0) { 17632 nlmsg_free(msg); 17633 return; 17634 } 17635 17636 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 17637 NL80211_MCGRP_CONFIG, GFP_KERNEL); 17638 } 17639 17640 static int nl80211_add_scan_req(struct sk_buff *msg, 17641 struct cfg80211_registered_device *rdev) 17642 { 17643 struct cfg80211_scan_request *req = rdev->scan_req; 17644 struct nlattr *nest; 17645 int i; 17646 struct cfg80211_scan_info *info; 17647 17648 if (WARN_ON(!req)) 17649 return 0; 17650 17651 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_SSIDS); 17652 if (!nest) 17653 goto nla_put_failure; 17654 for (i = 0; i < req->n_ssids; i++) { 17655 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid)) 17656 goto nla_put_failure; 17657 } 17658 nla_nest_end(msg, nest); 17659 17660 if (req->flags & NL80211_SCAN_FLAG_FREQ_KHZ) { 17661 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQ_KHZ); 17662 if (!nest) 17663 goto nla_put_failure; 17664 for (i = 0; i < req->n_channels; i++) { 17665 if (nla_put_u32(msg, i, 17666 ieee80211_channel_to_khz(req->channels[i]))) 17667 goto nla_put_failure; 17668 } 17669 nla_nest_end(msg, nest); 17670 } else { 17671 nest = nla_nest_start_noflag(msg, 17672 NL80211_ATTR_SCAN_FREQUENCIES); 17673 if (!nest) 17674 goto nla_put_failure; 17675 for (i = 0; i < req->n_channels; i++) { 17676 if (nla_put_u32(msg, i, req->channels[i]->center_freq)) 17677 goto nla_put_failure; 17678 } 17679 nla_nest_end(msg, nest); 17680 } 17681 17682 if (req->ie && 17683 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie)) 17684 goto nla_put_failure; 17685 17686 if (req->flags && 17687 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags)) 17688 goto nla_put_failure; 17689 17690 info = rdev->int_scan_req ? &rdev->int_scan_req->info : 17691 &rdev->scan_req->info; 17692 if (info->scan_start_tsf && 17693 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF, 17694 info->scan_start_tsf, NL80211_BSS_PAD) || 17695 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN, 17696 info->tsf_bssid))) 17697 goto nla_put_failure; 17698 17699 return 0; 17700 nla_put_failure: 17701 return -ENOBUFS; 17702 } 17703 17704 static int nl80211_prep_scan_msg(struct sk_buff *msg, 17705 struct cfg80211_registered_device *rdev, 17706 struct wireless_dev *wdev, 17707 u32 portid, u32 seq, int flags, 17708 u32 cmd) 17709 { 17710 void *hdr; 17711 17712 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd); 17713 if (!hdr) 17714 return -1; 17715 17716 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 17717 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 17718 wdev->netdev->ifindex)) || 17719 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 17720 NL80211_ATTR_PAD)) 17721 goto nla_put_failure; 17722 17723 /* ignore errors and send incomplete event anyway */ 17724 nl80211_add_scan_req(msg, rdev); 17725 17726 genlmsg_end(msg, hdr); 17727 return 0; 17728 17729 nla_put_failure: 17730 genlmsg_cancel(msg, hdr); 17731 return -EMSGSIZE; 17732 } 17733 17734 static int 17735 nl80211_prep_sched_scan_msg(struct sk_buff *msg, 17736 struct cfg80211_sched_scan_request *req, u32 cmd) 17737 { 17738 void *hdr; 17739 17740 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 17741 if (!hdr) 17742 return -1; 17743 17744 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, 17745 wiphy_to_rdev(req->wiphy)->wiphy_idx) || 17746 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) || 17747 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid, 17748 NL80211_ATTR_PAD)) 17749 goto nla_put_failure; 17750 17751 genlmsg_end(msg, hdr); 17752 return 0; 17753 17754 nla_put_failure: 17755 genlmsg_cancel(msg, hdr); 17756 return -EMSGSIZE; 17757 } 17758 17759 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev, 17760 struct wireless_dev *wdev) 17761 { 17762 struct sk_buff *msg; 17763 17764 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 17765 if (!msg) 17766 return; 17767 17768 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0, 17769 NL80211_CMD_TRIGGER_SCAN) < 0) { 17770 nlmsg_free(msg); 17771 return; 17772 } 17773 17774 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 17775 NL80211_MCGRP_SCAN, GFP_KERNEL); 17776 } 17777 17778 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev, 17779 struct wireless_dev *wdev, bool aborted) 17780 { 17781 struct sk_buff *msg; 17782 17783 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 17784 if (!msg) 17785 return NULL; 17786 17787 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0, 17788 aborted ? NL80211_CMD_SCAN_ABORTED : 17789 NL80211_CMD_NEW_SCAN_RESULTS) < 0) { 17790 nlmsg_free(msg); 17791 return NULL; 17792 } 17793 17794 return msg; 17795 } 17796 17797 /* send message created by nl80211_build_scan_msg() */ 17798 void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev, 17799 struct sk_buff *msg) 17800 { 17801 if (!msg) 17802 return; 17803 17804 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 17805 NL80211_MCGRP_SCAN, GFP_KERNEL); 17806 } 17807 17808 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd) 17809 { 17810 struct sk_buff *msg; 17811 17812 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 17813 if (!msg) 17814 return; 17815 17816 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) { 17817 nlmsg_free(msg); 17818 return; 17819 } 17820 17821 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0, 17822 NL80211_MCGRP_SCAN, GFP_KERNEL); 17823 } 17824 17825 static bool nl80211_reg_change_event_fill(struct sk_buff *msg, 17826 struct regulatory_request *request) 17827 { 17828 /* Userspace can always count this one always being set */ 17829 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator)) 17830 goto nla_put_failure; 17831 17832 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') { 17833 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE, 17834 NL80211_REGDOM_TYPE_WORLD)) 17835 goto nla_put_failure; 17836 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') { 17837 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE, 17838 NL80211_REGDOM_TYPE_CUSTOM_WORLD)) 17839 goto nla_put_failure; 17840 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') || 17841 request->intersect) { 17842 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE, 17843 NL80211_REGDOM_TYPE_INTERSECTION)) 17844 goto nla_put_failure; 17845 } else { 17846 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE, 17847 NL80211_REGDOM_TYPE_COUNTRY) || 17848 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, 17849 request->alpha2)) 17850 goto nla_put_failure; 17851 } 17852 17853 if (request->wiphy_idx != WIPHY_IDX_INVALID) { 17854 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx); 17855 17856 if (wiphy && 17857 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx)) 17858 goto nla_put_failure; 17859 17860 if (wiphy && 17861 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED && 17862 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG)) 17863 goto nla_put_failure; 17864 } 17865 17866 return true; 17867 17868 nla_put_failure: 17869 return false; 17870 } 17871 17872 /* 17873 * This can happen on global regulatory changes or device specific settings 17874 * based on custom regulatory domains. 17875 */ 17876 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id, 17877 struct regulatory_request *request) 17878 { 17879 struct sk_buff *msg; 17880 void *hdr; 17881 17882 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 17883 if (!msg) 17884 return; 17885 17886 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id); 17887 if (!hdr) 17888 goto nla_put_failure; 17889 17890 if (!nl80211_reg_change_event_fill(msg, request)) 17891 goto nla_put_failure; 17892 17893 genlmsg_end(msg, hdr); 17894 17895 rcu_read_lock(); 17896 genlmsg_multicast_allns(&nl80211_fam, msg, 0, 17897 NL80211_MCGRP_REGULATORY, GFP_ATOMIC); 17898 rcu_read_unlock(); 17899 17900 return; 17901 17902 nla_put_failure: 17903 nlmsg_free(msg); 17904 } 17905 17906 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev, 17907 struct net_device *netdev, 17908 const u8 *buf, size_t len, 17909 enum nl80211_commands cmd, gfp_t gfp, 17910 int uapsd_queues, const u8 *req_ies, 17911 size_t req_ies_len, bool reconnect) 17912 { 17913 struct sk_buff *msg; 17914 void *hdr; 17915 17916 msg = nlmsg_new(100 + len + req_ies_len, gfp); 17917 if (!msg) 17918 return; 17919 17920 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 17921 if (!hdr) { 17922 nlmsg_free(msg); 17923 return; 17924 } 17925 17926 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 17927 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 17928 nla_put(msg, NL80211_ATTR_FRAME, len, buf) || 17929 (req_ies && 17930 nla_put(msg, NL80211_ATTR_REQ_IE, req_ies_len, req_ies))) 17931 goto nla_put_failure; 17932 17933 if (reconnect && nla_put_flag(msg, NL80211_ATTR_RECONNECT_REQUESTED)) 17934 goto nla_put_failure; 17935 17936 if (uapsd_queues >= 0) { 17937 struct nlattr *nla_wmm = 17938 nla_nest_start_noflag(msg, NL80211_ATTR_STA_WME); 17939 if (!nla_wmm) 17940 goto nla_put_failure; 17941 17942 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES, 17943 uapsd_queues)) 17944 goto nla_put_failure; 17945 17946 nla_nest_end(msg, nla_wmm); 17947 } 17948 17949 genlmsg_end(msg, hdr); 17950 17951 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 17952 NL80211_MCGRP_MLME, gfp); 17953 return; 17954 17955 nla_put_failure: 17956 nlmsg_free(msg); 17957 } 17958 17959 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev, 17960 struct net_device *netdev, const u8 *buf, 17961 size_t len, gfp_t gfp) 17962 { 17963 nl80211_send_mlme_event(rdev, netdev, buf, len, 17964 NL80211_CMD_AUTHENTICATE, gfp, -1, NULL, 0, 17965 false); 17966 } 17967 17968 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev, 17969 struct net_device *netdev, 17970 struct cfg80211_rx_assoc_resp *data) 17971 { 17972 nl80211_send_mlme_event(rdev, netdev, data->buf, data->len, 17973 NL80211_CMD_ASSOCIATE, GFP_KERNEL, 17974 data->uapsd_queues, 17975 data->req_ies, data->req_ies_len, false); 17976 } 17977 17978 void nl80211_send_deauth(struct cfg80211_registered_device *rdev, 17979 struct net_device *netdev, const u8 *buf, 17980 size_t len, bool reconnect, gfp_t gfp) 17981 { 17982 nl80211_send_mlme_event(rdev, netdev, buf, len, 17983 NL80211_CMD_DEAUTHENTICATE, gfp, -1, NULL, 0, 17984 reconnect); 17985 } 17986 17987 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev, 17988 struct net_device *netdev, const u8 *buf, 17989 size_t len, bool reconnect, gfp_t gfp) 17990 { 17991 nl80211_send_mlme_event(rdev, netdev, buf, len, 17992 NL80211_CMD_DISASSOCIATE, gfp, -1, NULL, 0, 17993 reconnect); 17994 } 17995 17996 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf, 17997 size_t len) 17998 { 17999 struct wireless_dev *wdev = dev->ieee80211_ptr; 18000 struct wiphy *wiphy = wdev->wiphy; 18001 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18002 const struct ieee80211_mgmt *mgmt = (void *)buf; 18003 u32 cmd; 18004 18005 if (WARN_ON(len < 2)) 18006 return; 18007 18008 if (ieee80211_is_deauth(mgmt->frame_control)) { 18009 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE; 18010 } else if (ieee80211_is_disassoc(mgmt->frame_control)) { 18011 cmd = NL80211_CMD_UNPROT_DISASSOCIATE; 18012 } else if (ieee80211_is_beacon(mgmt->frame_control)) { 18013 if (wdev->unprot_beacon_reported && 18014 elapsed_jiffies_msecs(wdev->unprot_beacon_reported) < 10000) 18015 return; 18016 cmd = NL80211_CMD_UNPROT_BEACON; 18017 wdev->unprot_beacon_reported = jiffies; 18018 } else { 18019 return; 18020 } 18021 18022 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len); 18023 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1, 18024 NULL, 0, false); 18025 } 18026 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt); 18027 18028 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev, 18029 struct net_device *netdev, int cmd, 18030 const u8 *addr, gfp_t gfp) 18031 { 18032 struct sk_buff *msg; 18033 void *hdr; 18034 18035 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 18036 if (!msg) 18037 return; 18038 18039 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 18040 if (!hdr) { 18041 nlmsg_free(msg); 18042 return; 18043 } 18044 18045 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18046 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18047 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) || 18048 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) 18049 goto nla_put_failure; 18050 18051 genlmsg_end(msg, hdr); 18052 18053 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18054 NL80211_MCGRP_MLME, gfp); 18055 return; 18056 18057 nla_put_failure: 18058 nlmsg_free(msg); 18059 } 18060 18061 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev, 18062 struct net_device *netdev, const u8 *addr, 18063 gfp_t gfp) 18064 { 18065 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE, 18066 addr, gfp); 18067 } 18068 18069 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev, 18070 struct net_device *netdev, const u8 *addr, 18071 gfp_t gfp) 18072 { 18073 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE, 18074 addr, gfp); 18075 } 18076 18077 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev, 18078 struct net_device *netdev, 18079 struct cfg80211_connect_resp_params *cr, 18080 gfp_t gfp) 18081 { 18082 struct sk_buff *msg; 18083 void *hdr; 18084 unsigned int link; 18085 size_t link_info_size = 0; 18086 const u8 *connected_addr = cr->valid_links ? 18087 cr->ap_mld_addr : cr->links[0].bssid; 18088 18089 if (cr->valid_links) { 18090 for_each_valid_link(cr, link) { 18091 /* Nested attribute header */ 18092 link_info_size += NLA_HDRLEN; 18093 /* Link ID */ 18094 link_info_size += nla_total_size(sizeof(u8)); 18095 link_info_size += cr->links[link].addr ? 18096 nla_total_size(ETH_ALEN) : 0; 18097 link_info_size += (cr->links[link].bssid || 18098 cr->links[link].bss) ? 18099 nla_total_size(ETH_ALEN) : 0; 18100 link_info_size += nla_total_size(sizeof(u16)); 18101 } 18102 } 18103 18104 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len + 18105 cr->fils.kek_len + cr->fils.pmk_len + 18106 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0) + link_info_size, 18107 gfp); 18108 if (!msg) 18109 return; 18110 18111 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT); 18112 if (!hdr) { 18113 nlmsg_free(msg); 18114 return; 18115 } 18116 18117 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18118 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18119 (connected_addr && 18120 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, connected_addr)) || 18121 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, 18122 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE : 18123 cr->status) || 18124 (cr->status < 0 && 18125 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) || 18126 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON, 18127 cr->timeout_reason))) || 18128 (cr->req_ie && 18129 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) || 18130 (cr->resp_ie && 18131 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len, 18132 cr->resp_ie)) || 18133 (cr->fils.update_erp_next_seq_num && 18134 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM, 18135 cr->fils.erp_next_seq_num)) || 18136 (cr->status == WLAN_STATUS_SUCCESS && 18137 ((cr->fils.kek && 18138 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len, 18139 cr->fils.kek)) || 18140 (cr->fils.pmk && 18141 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) || 18142 (cr->fils.pmkid && 18143 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid))))) 18144 goto nla_put_failure; 18145 18146 if (cr->valid_links) { 18147 int i = 1; 18148 struct nlattr *nested; 18149 18150 nested = nla_nest_start(msg, NL80211_ATTR_MLO_LINKS); 18151 if (!nested) 18152 goto nla_put_failure; 18153 18154 for_each_valid_link(cr, link) { 18155 struct nlattr *nested_mlo_links; 18156 const u8 *bssid = cr->links[link].bss ? 18157 cr->links[link].bss->bssid : 18158 cr->links[link].bssid; 18159 18160 nested_mlo_links = nla_nest_start(msg, i); 18161 if (!nested_mlo_links) 18162 goto nla_put_failure; 18163 18164 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link) || 18165 (bssid && 18166 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, bssid)) || 18167 (cr->links[link].addr && 18168 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, 18169 cr->links[link].addr)) || 18170 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, 18171 cr->links[link].status)) 18172 goto nla_put_failure; 18173 18174 nla_nest_end(msg, nested_mlo_links); 18175 i++; 18176 } 18177 nla_nest_end(msg, nested); 18178 } 18179 18180 genlmsg_end(msg, hdr); 18181 18182 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18183 NL80211_MCGRP_MLME, gfp); 18184 return; 18185 18186 nla_put_failure: 18187 nlmsg_free(msg); 18188 } 18189 18190 void nl80211_send_roamed(struct cfg80211_registered_device *rdev, 18191 struct net_device *netdev, 18192 struct cfg80211_roam_info *info, gfp_t gfp) 18193 { 18194 struct sk_buff *msg; 18195 void *hdr; 18196 size_t link_info_size = 0; 18197 unsigned int link; 18198 const u8 *connected_addr = info->ap_mld_addr ? 18199 info->ap_mld_addr : 18200 (info->links[0].bss ? 18201 info->links[0].bss->bssid : 18202 info->links[0].bssid); 18203 18204 if (info->valid_links) { 18205 for_each_valid_link(info, link) { 18206 /* Nested attribute header */ 18207 link_info_size += NLA_HDRLEN; 18208 /* Link ID */ 18209 link_info_size += nla_total_size(sizeof(u8)); 18210 link_info_size += info->links[link].addr ? 18211 nla_total_size(ETH_ALEN) : 0; 18212 link_info_size += (info->links[link].bssid || 18213 info->links[link].bss) ? 18214 nla_total_size(ETH_ALEN) : 0; 18215 } 18216 } 18217 18218 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len + 18219 info->fils.kek_len + info->fils.pmk_len + 18220 (info->fils.pmkid ? WLAN_PMKID_LEN : 0) + 18221 link_info_size, gfp); 18222 if (!msg) 18223 return; 18224 18225 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM); 18226 if (!hdr) { 18227 nlmsg_free(msg); 18228 return; 18229 } 18230 18231 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18232 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18233 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, connected_addr) || 18234 (info->req_ie && 18235 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len, 18236 info->req_ie)) || 18237 (info->resp_ie && 18238 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len, 18239 info->resp_ie)) || 18240 (info->fils.update_erp_next_seq_num && 18241 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM, 18242 info->fils.erp_next_seq_num)) || 18243 (info->fils.kek && 18244 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len, 18245 info->fils.kek)) || 18246 (info->fils.pmk && 18247 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) || 18248 (info->fils.pmkid && 18249 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid))) 18250 goto nla_put_failure; 18251 18252 if (info->valid_links) { 18253 int i = 1; 18254 struct nlattr *nested; 18255 18256 nested = nla_nest_start(msg, NL80211_ATTR_MLO_LINKS); 18257 if (!nested) 18258 goto nla_put_failure; 18259 18260 for_each_valid_link(info, link) { 18261 struct nlattr *nested_mlo_links; 18262 const u8 *bssid = info->links[link].bss ? 18263 info->links[link].bss->bssid : 18264 info->links[link].bssid; 18265 18266 nested_mlo_links = nla_nest_start(msg, i); 18267 if (!nested_mlo_links) 18268 goto nla_put_failure; 18269 18270 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link) || 18271 (bssid && 18272 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, bssid)) || 18273 (info->links[link].addr && 18274 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, 18275 info->links[link].addr))) 18276 goto nla_put_failure; 18277 18278 nla_nest_end(msg, nested_mlo_links); 18279 i++; 18280 } 18281 nla_nest_end(msg, nested); 18282 } 18283 18284 genlmsg_end(msg, hdr); 18285 18286 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18287 NL80211_MCGRP_MLME, gfp); 18288 return; 18289 18290 nla_put_failure: 18291 nlmsg_free(msg); 18292 } 18293 18294 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev, 18295 struct net_device *netdev, const u8 *bssid, 18296 const u8 *td_bitmap, u8 td_bitmap_len) 18297 { 18298 struct sk_buff *msg; 18299 void *hdr; 18300 18301 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 18302 if (!msg) 18303 return; 18304 18305 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED); 18306 if (!hdr) { 18307 nlmsg_free(msg); 18308 return; 18309 } 18310 18311 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18312 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18313 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) 18314 goto nla_put_failure; 18315 18316 if ((td_bitmap_len > 0) && td_bitmap) 18317 if (nla_put(msg, NL80211_ATTR_TD_BITMAP, 18318 td_bitmap_len, td_bitmap)) 18319 goto nla_put_failure; 18320 18321 genlmsg_end(msg, hdr); 18322 18323 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18324 NL80211_MCGRP_MLME, GFP_KERNEL); 18325 return; 18326 18327 nla_put_failure: 18328 nlmsg_free(msg); 18329 } 18330 18331 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev, 18332 struct net_device *netdev, u16 reason, 18333 const u8 *ie, size_t ie_len, bool from_ap) 18334 { 18335 struct sk_buff *msg; 18336 void *hdr; 18337 18338 msg = nlmsg_new(100 + ie_len, GFP_KERNEL); 18339 if (!msg) 18340 return; 18341 18342 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT); 18343 if (!hdr) { 18344 nlmsg_free(msg); 18345 return; 18346 } 18347 18348 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18349 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18350 (reason && 18351 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) || 18352 (from_ap && 18353 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) || 18354 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie))) 18355 goto nla_put_failure; 18356 18357 genlmsg_end(msg, hdr); 18358 18359 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18360 NL80211_MCGRP_MLME, GFP_KERNEL); 18361 return; 18362 18363 nla_put_failure: 18364 nlmsg_free(msg); 18365 } 18366 18367 void cfg80211_links_removed(struct net_device *dev, u16 link_mask) 18368 { 18369 struct wireless_dev *wdev = dev->ieee80211_ptr; 18370 struct wiphy *wiphy = wdev->wiphy; 18371 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18372 struct sk_buff *msg; 18373 struct nlattr *links; 18374 void *hdr; 18375 18376 ASSERT_WDEV_LOCK(wdev); 18377 trace_cfg80211_links_removed(dev, link_mask); 18378 18379 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_STATION && 18380 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)) 18381 return; 18382 18383 if (WARN_ON(!wdev->valid_links || !link_mask || 18384 (wdev->valid_links & link_mask) != link_mask || 18385 wdev->valid_links == link_mask)) 18386 return; 18387 18388 cfg80211_wdev_release_link_bsses(wdev, link_mask); 18389 wdev->valid_links &= ~link_mask; 18390 18391 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 18392 if (!msg) 18393 return; 18394 18395 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_LINKS_REMOVED); 18396 if (!hdr) { 18397 nlmsg_free(msg); 18398 return; 18399 } 18400 18401 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18402 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex)) 18403 goto nla_put_failure; 18404 18405 links = nla_nest_start(msg, NL80211_ATTR_MLO_LINKS); 18406 if (!links) 18407 goto nla_put_failure; 18408 18409 while (link_mask) { 18410 struct nlattr *link; 18411 int link_id = __ffs(link_mask); 18412 18413 link = nla_nest_start(msg, link_id + 1); 18414 if (!link) 18415 goto nla_put_failure; 18416 18417 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)) 18418 goto nla_put_failure; 18419 18420 nla_nest_end(msg, link); 18421 link_mask &= ~(1 << link_id); 18422 } 18423 18424 nla_nest_end(msg, links); 18425 18426 genlmsg_end(msg, hdr); 18427 18428 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18429 NL80211_MCGRP_MLME, GFP_KERNEL); 18430 return; 18431 18432 nla_put_failure: 18433 nlmsg_free(msg); 18434 } 18435 EXPORT_SYMBOL(cfg80211_links_removed); 18436 18437 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev, 18438 struct net_device *netdev, const u8 *bssid, 18439 gfp_t gfp) 18440 { 18441 struct sk_buff *msg; 18442 void *hdr; 18443 18444 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 18445 if (!msg) 18446 return; 18447 18448 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS); 18449 if (!hdr) { 18450 nlmsg_free(msg); 18451 return; 18452 } 18453 18454 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18455 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18456 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) 18457 goto nla_put_failure; 18458 18459 genlmsg_end(msg, hdr); 18460 18461 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18462 NL80211_MCGRP_MLME, gfp); 18463 return; 18464 18465 nla_put_failure: 18466 nlmsg_free(msg); 18467 } 18468 18469 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr, 18470 const u8 *ie, u8 ie_len, 18471 int sig_dbm, gfp_t gfp) 18472 { 18473 struct wireless_dev *wdev = dev->ieee80211_ptr; 18474 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 18475 struct sk_buff *msg; 18476 void *hdr; 18477 18478 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT)) 18479 return; 18480 18481 trace_cfg80211_notify_new_peer_candidate(dev, addr); 18482 18483 msg = nlmsg_new(100 + ie_len, gfp); 18484 if (!msg) 18485 return; 18486 18487 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE); 18488 if (!hdr) { 18489 nlmsg_free(msg); 18490 return; 18491 } 18492 18493 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18494 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 18495 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) || 18496 (ie_len && ie && 18497 nla_put(msg, NL80211_ATTR_IE, ie_len, ie)) || 18498 (sig_dbm && 18499 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm))) 18500 goto nla_put_failure; 18501 18502 genlmsg_end(msg, hdr); 18503 18504 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18505 NL80211_MCGRP_MLME, gfp); 18506 return; 18507 18508 nla_put_failure: 18509 nlmsg_free(msg); 18510 } 18511 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate); 18512 18513 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev, 18514 struct net_device *netdev, const u8 *addr, 18515 enum nl80211_key_type key_type, int key_id, 18516 const u8 *tsc, gfp_t gfp) 18517 { 18518 struct sk_buff *msg; 18519 void *hdr; 18520 18521 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 18522 if (!msg) 18523 return; 18524 18525 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE); 18526 if (!hdr) { 18527 nlmsg_free(msg); 18528 return; 18529 } 18530 18531 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18532 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18533 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) || 18534 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) || 18535 (key_id != -1 && 18536 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) || 18537 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc))) 18538 goto nla_put_failure; 18539 18540 genlmsg_end(msg, hdr); 18541 18542 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18543 NL80211_MCGRP_MLME, gfp); 18544 return; 18545 18546 nla_put_failure: 18547 nlmsg_free(msg); 18548 } 18549 18550 void nl80211_send_beacon_hint_event(struct wiphy *wiphy, 18551 struct ieee80211_channel *channel_before, 18552 struct ieee80211_channel *channel_after) 18553 { 18554 struct sk_buff *msg; 18555 void *hdr; 18556 struct nlattr *nl_freq; 18557 18558 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC); 18559 if (!msg) 18560 return; 18561 18562 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT); 18563 if (!hdr) { 18564 nlmsg_free(msg); 18565 return; 18566 } 18567 18568 /* 18569 * Since we are applying the beacon hint to a wiphy we know its 18570 * wiphy_idx is valid 18571 */ 18572 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy))) 18573 goto nla_put_failure; 18574 18575 /* Before */ 18576 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_BEFORE); 18577 if (!nl_freq) 18578 goto nla_put_failure; 18579 18580 if (nl80211_msg_put_channel(msg, wiphy, channel_before, false)) 18581 goto nla_put_failure; 18582 nla_nest_end(msg, nl_freq); 18583 18584 /* After */ 18585 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_AFTER); 18586 if (!nl_freq) 18587 goto nla_put_failure; 18588 18589 if (nl80211_msg_put_channel(msg, wiphy, channel_after, false)) 18590 goto nla_put_failure; 18591 nla_nest_end(msg, nl_freq); 18592 18593 genlmsg_end(msg, hdr); 18594 18595 rcu_read_lock(); 18596 genlmsg_multicast_allns(&nl80211_fam, msg, 0, 18597 NL80211_MCGRP_REGULATORY, GFP_ATOMIC); 18598 rcu_read_unlock(); 18599 18600 return; 18601 18602 nla_put_failure: 18603 nlmsg_free(msg); 18604 } 18605 18606 static void nl80211_send_remain_on_chan_event( 18607 int cmd, struct cfg80211_registered_device *rdev, 18608 struct wireless_dev *wdev, u64 cookie, 18609 struct ieee80211_channel *chan, 18610 unsigned int duration, gfp_t gfp) 18611 { 18612 struct sk_buff *msg; 18613 void *hdr; 18614 18615 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 18616 if (!msg) 18617 return; 18618 18619 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 18620 if (!hdr) { 18621 nlmsg_free(msg); 18622 return; 18623 } 18624 18625 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18626 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 18627 wdev->netdev->ifindex)) || 18628 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 18629 NL80211_ATTR_PAD) || 18630 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) || 18631 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE, 18632 NL80211_CHAN_NO_HT) || 18633 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie, 18634 NL80211_ATTR_PAD)) 18635 goto nla_put_failure; 18636 18637 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL && 18638 nla_put_u32(msg, NL80211_ATTR_DURATION, duration)) 18639 goto nla_put_failure; 18640 18641 genlmsg_end(msg, hdr); 18642 18643 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18644 NL80211_MCGRP_MLME, gfp); 18645 return; 18646 18647 nla_put_failure: 18648 nlmsg_free(msg); 18649 } 18650 18651 void cfg80211_assoc_comeback(struct net_device *netdev, 18652 const u8 *ap_addr, u32 timeout) 18653 { 18654 struct wireless_dev *wdev = netdev->ieee80211_ptr; 18655 struct wiphy *wiphy = wdev->wiphy; 18656 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18657 struct sk_buff *msg; 18658 void *hdr; 18659 18660 trace_cfg80211_assoc_comeback(wdev, ap_addr, timeout); 18661 18662 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 18663 if (!msg) 18664 return; 18665 18666 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ASSOC_COMEBACK); 18667 if (!hdr) { 18668 nlmsg_free(msg); 18669 return; 18670 } 18671 18672 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18673 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 18674 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ap_addr) || 18675 nla_put_u32(msg, NL80211_ATTR_TIMEOUT, timeout)) 18676 goto nla_put_failure; 18677 18678 genlmsg_end(msg, hdr); 18679 18680 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18681 NL80211_MCGRP_MLME, GFP_KERNEL); 18682 return; 18683 18684 nla_put_failure: 18685 nlmsg_free(msg); 18686 } 18687 EXPORT_SYMBOL(cfg80211_assoc_comeback); 18688 18689 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie, 18690 struct ieee80211_channel *chan, 18691 unsigned int duration, gfp_t gfp) 18692 { 18693 struct wiphy *wiphy = wdev->wiphy; 18694 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18695 18696 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration); 18697 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL, 18698 rdev, wdev, cookie, chan, 18699 duration, gfp); 18700 } 18701 EXPORT_SYMBOL(cfg80211_ready_on_channel); 18702 18703 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie, 18704 struct ieee80211_channel *chan, 18705 gfp_t gfp) 18706 { 18707 struct wiphy *wiphy = wdev->wiphy; 18708 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18709 18710 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan); 18711 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL, 18712 rdev, wdev, cookie, chan, 0, gfp); 18713 } 18714 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired); 18715 18716 void cfg80211_tx_mgmt_expired(struct wireless_dev *wdev, u64 cookie, 18717 struct ieee80211_channel *chan, 18718 gfp_t gfp) 18719 { 18720 struct wiphy *wiphy = wdev->wiphy; 18721 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18722 18723 trace_cfg80211_tx_mgmt_expired(wdev, cookie, chan); 18724 nl80211_send_remain_on_chan_event(NL80211_CMD_FRAME_WAIT_CANCEL, 18725 rdev, wdev, cookie, chan, 0, gfp); 18726 } 18727 EXPORT_SYMBOL(cfg80211_tx_mgmt_expired); 18728 18729 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr, 18730 struct station_info *sinfo, gfp_t gfp) 18731 { 18732 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy; 18733 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18734 struct sk_buff *msg; 18735 18736 trace_cfg80211_new_sta(dev, mac_addr, sinfo); 18737 18738 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 18739 if (!msg) 18740 return; 18741 18742 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0, 18743 rdev, dev, mac_addr, sinfo) < 0) { 18744 nlmsg_free(msg); 18745 return; 18746 } 18747 18748 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18749 NL80211_MCGRP_MLME, gfp); 18750 } 18751 EXPORT_SYMBOL(cfg80211_new_sta); 18752 18753 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr, 18754 struct station_info *sinfo, gfp_t gfp) 18755 { 18756 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy; 18757 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18758 struct sk_buff *msg; 18759 struct station_info empty_sinfo = {}; 18760 18761 if (!sinfo) 18762 sinfo = &empty_sinfo; 18763 18764 trace_cfg80211_del_sta(dev, mac_addr); 18765 18766 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 18767 if (!msg) { 18768 cfg80211_sinfo_release_content(sinfo); 18769 return; 18770 } 18771 18772 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0, 18773 rdev, dev, mac_addr, sinfo) < 0) { 18774 nlmsg_free(msg); 18775 return; 18776 } 18777 18778 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18779 NL80211_MCGRP_MLME, gfp); 18780 } 18781 EXPORT_SYMBOL(cfg80211_del_sta_sinfo); 18782 18783 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr, 18784 enum nl80211_connect_failed_reason reason, 18785 gfp_t gfp) 18786 { 18787 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy; 18788 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18789 struct sk_buff *msg; 18790 void *hdr; 18791 18792 msg = nlmsg_new(NLMSG_GOODSIZE, gfp); 18793 if (!msg) 18794 return; 18795 18796 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED); 18797 if (!hdr) { 18798 nlmsg_free(msg); 18799 return; 18800 } 18801 18802 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 18803 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) || 18804 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason)) 18805 goto nla_put_failure; 18806 18807 genlmsg_end(msg, hdr); 18808 18809 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18810 NL80211_MCGRP_MLME, gfp); 18811 return; 18812 18813 nla_put_failure: 18814 nlmsg_free(msg); 18815 } 18816 EXPORT_SYMBOL(cfg80211_conn_failed); 18817 18818 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd, 18819 const u8 *addr, gfp_t gfp) 18820 { 18821 struct wireless_dev *wdev = dev->ieee80211_ptr; 18822 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 18823 struct sk_buff *msg; 18824 void *hdr; 18825 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid); 18826 18827 if (!nlportid) 18828 return false; 18829 18830 msg = nlmsg_new(100, gfp); 18831 if (!msg) 18832 return true; 18833 18834 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 18835 if (!hdr) { 18836 nlmsg_free(msg); 18837 return true; 18838 } 18839 18840 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18841 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 18842 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) 18843 goto nla_put_failure; 18844 18845 genlmsg_end(msg, hdr); 18846 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid); 18847 return true; 18848 18849 nla_put_failure: 18850 nlmsg_free(msg); 18851 return true; 18852 } 18853 18854 bool cfg80211_rx_spurious_frame(struct net_device *dev, 18855 const u8 *addr, gfp_t gfp) 18856 { 18857 struct wireless_dev *wdev = dev->ieee80211_ptr; 18858 bool ret; 18859 18860 trace_cfg80211_rx_spurious_frame(dev, addr); 18861 18862 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP && 18863 wdev->iftype != NL80211_IFTYPE_P2P_GO)) { 18864 trace_cfg80211_return_bool(false); 18865 return false; 18866 } 18867 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME, 18868 addr, gfp); 18869 trace_cfg80211_return_bool(ret); 18870 return ret; 18871 } 18872 EXPORT_SYMBOL(cfg80211_rx_spurious_frame); 18873 18874 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev, 18875 const u8 *addr, gfp_t gfp) 18876 { 18877 struct wireless_dev *wdev = dev->ieee80211_ptr; 18878 bool ret; 18879 18880 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr); 18881 18882 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP && 18883 wdev->iftype != NL80211_IFTYPE_P2P_GO && 18884 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) { 18885 trace_cfg80211_return_bool(false); 18886 return false; 18887 } 18888 ret = __nl80211_unexpected_frame(dev, 18889 NL80211_CMD_UNEXPECTED_4ADDR_FRAME, 18890 addr, gfp); 18891 trace_cfg80211_return_bool(ret); 18892 return ret; 18893 } 18894 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame); 18895 18896 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev, 18897 struct wireless_dev *wdev, u32 nlportid, 18898 struct cfg80211_rx_info *info, gfp_t gfp) 18899 { 18900 struct net_device *netdev = wdev->netdev; 18901 struct sk_buff *msg; 18902 void *hdr; 18903 18904 msg = nlmsg_new(100 + info->len, gfp); 18905 if (!msg) 18906 return -ENOMEM; 18907 18908 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME); 18909 if (!hdr) { 18910 nlmsg_free(msg); 18911 return -ENOMEM; 18912 } 18913 18914 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18915 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 18916 netdev->ifindex)) || 18917 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 18918 NL80211_ATTR_PAD) || 18919 (info->have_link_id && 18920 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, info->link_id)) || 18921 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, KHZ_TO_MHZ(info->freq)) || 18922 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET, info->freq % 1000) || 18923 (info->sig_dbm && 18924 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, info->sig_dbm)) || 18925 nla_put(msg, NL80211_ATTR_FRAME, info->len, info->buf) || 18926 (info->flags && 18927 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, info->flags)) || 18928 (info->rx_tstamp && nla_put_u64_64bit(msg, 18929 NL80211_ATTR_RX_HW_TIMESTAMP, 18930 info->rx_tstamp, 18931 NL80211_ATTR_PAD)) || 18932 (info->ack_tstamp && nla_put_u64_64bit(msg, 18933 NL80211_ATTR_TX_HW_TIMESTAMP, 18934 info->ack_tstamp, 18935 NL80211_ATTR_PAD))) 18936 goto nla_put_failure; 18937 18938 genlmsg_end(msg, hdr); 18939 18940 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid); 18941 18942 nla_put_failure: 18943 nlmsg_free(msg); 18944 return -ENOBUFS; 18945 } 18946 18947 static void nl80211_frame_tx_status(struct wireless_dev *wdev, 18948 struct cfg80211_tx_status *status, 18949 gfp_t gfp, enum nl80211_commands command) 18950 { 18951 struct wiphy *wiphy = wdev->wiphy; 18952 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 18953 struct net_device *netdev = wdev->netdev; 18954 struct sk_buff *msg; 18955 void *hdr; 18956 18957 if (command == NL80211_CMD_FRAME_TX_STATUS) 18958 trace_cfg80211_mgmt_tx_status(wdev, status->cookie, 18959 status->ack); 18960 else 18961 trace_cfg80211_control_port_tx_status(wdev, status->cookie, 18962 status->ack); 18963 18964 msg = nlmsg_new(100 + status->len, gfp); 18965 if (!msg) 18966 return; 18967 18968 hdr = nl80211hdr_put(msg, 0, 0, 0, command); 18969 if (!hdr) { 18970 nlmsg_free(msg); 18971 return; 18972 } 18973 18974 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 18975 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 18976 netdev->ifindex)) || 18977 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 18978 NL80211_ATTR_PAD) || 18979 nla_put(msg, NL80211_ATTR_FRAME, status->len, status->buf) || 18980 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, status->cookie, 18981 NL80211_ATTR_PAD) || 18982 (status->ack && nla_put_flag(msg, NL80211_ATTR_ACK)) || 18983 (status->tx_tstamp && 18984 nla_put_u64_64bit(msg, NL80211_ATTR_TX_HW_TIMESTAMP, 18985 status->tx_tstamp, NL80211_ATTR_PAD)) || 18986 (status->ack_tstamp && 18987 nla_put_u64_64bit(msg, NL80211_ATTR_RX_HW_TIMESTAMP, 18988 status->ack_tstamp, NL80211_ATTR_PAD))) 18989 goto nla_put_failure; 18990 18991 genlmsg_end(msg, hdr); 18992 18993 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 18994 NL80211_MCGRP_MLME, gfp); 18995 return; 18996 18997 nla_put_failure: 18998 nlmsg_free(msg); 18999 } 19000 19001 void cfg80211_control_port_tx_status(struct wireless_dev *wdev, u64 cookie, 19002 const u8 *buf, size_t len, bool ack, 19003 gfp_t gfp) 19004 { 19005 struct cfg80211_tx_status status = { 19006 .cookie = cookie, 19007 .buf = buf, 19008 .len = len, 19009 .ack = ack 19010 }; 19011 19012 nl80211_frame_tx_status(wdev, &status, gfp, 19013 NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS); 19014 } 19015 EXPORT_SYMBOL(cfg80211_control_port_tx_status); 19016 19017 void cfg80211_mgmt_tx_status_ext(struct wireless_dev *wdev, 19018 struct cfg80211_tx_status *status, gfp_t gfp) 19019 { 19020 nl80211_frame_tx_status(wdev, status, gfp, NL80211_CMD_FRAME_TX_STATUS); 19021 } 19022 EXPORT_SYMBOL(cfg80211_mgmt_tx_status_ext); 19023 19024 static int __nl80211_rx_control_port(struct net_device *dev, 19025 struct sk_buff *skb, 19026 bool unencrypted, 19027 int link_id, 19028 gfp_t gfp) 19029 { 19030 struct wireless_dev *wdev = dev->ieee80211_ptr; 19031 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 19032 struct ethhdr *ehdr = eth_hdr(skb); 19033 const u8 *addr = ehdr->h_source; 19034 u16 proto = be16_to_cpu(skb->protocol); 19035 struct sk_buff *msg; 19036 void *hdr; 19037 struct nlattr *frame; 19038 19039 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid); 19040 19041 if (!nlportid) 19042 return -ENOENT; 19043 19044 msg = nlmsg_new(100 + skb->len, gfp); 19045 if (!msg) 19046 return -ENOMEM; 19047 19048 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME); 19049 if (!hdr) { 19050 nlmsg_free(msg); 19051 return -ENOBUFS; 19052 } 19053 19054 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19055 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 19056 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 19057 NL80211_ATTR_PAD) || 19058 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) || 19059 nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) || 19060 (link_id >= 0 && 19061 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)) || 19062 (unencrypted && nla_put_flag(msg, 19063 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT))) 19064 goto nla_put_failure; 19065 19066 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len); 19067 if (!frame) 19068 goto nla_put_failure; 19069 19070 skb_copy_bits(skb, 0, nla_data(frame), skb->len); 19071 genlmsg_end(msg, hdr); 19072 19073 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid); 19074 19075 nla_put_failure: 19076 nlmsg_free(msg); 19077 return -ENOBUFS; 19078 } 19079 19080 bool cfg80211_rx_control_port(struct net_device *dev, struct sk_buff *skb, 19081 bool unencrypted, int link_id) 19082 { 19083 int ret; 19084 19085 trace_cfg80211_rx_control_port(dev, skb, unencrypted, link_id); 19086 ret = __nl80211_rx_control_port(dev, skb, unencrypted, link_id, 19087 GFP_ATOMIC); 19088 trace_cfg80211_return_bool(ret == 0); 19089 return ret == 0; 19090 } 19091 EXPORT_SYMBOL(cfg80211_rx_control_port); 19092 19093 static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev, 19094 const char *mac, gfp_t gfp) 19095 { 19096 struct wireless_dev *wdev = dev->ieee80211_ptr; 19097 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 19098 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19099 void **cb; 19100 19101 if (!msg) 19102 return NULL; 19103 19104 cb = (void **)msg->cb; 19105 19106 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM); 19107 if (!cb[0]) { 19108 nlmsg_free(msg); 19109 return NULL; 19110 } 19111 19112 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19113 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex)) 19114 goto nla_put_failure; 19115 19116 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac)) 19117 goto nla_put_failure; 19118 19119 cb[1] = nla_nest_start_noflag(msg, NL80211_ATTR_CQM); 19120 if (!cb[1]) 19121 goto nla_put_failure; 19122 19123 cb[2] = rdev; 19124 19125 return msg; 19126 nla_put_failure: 19127 nlmsg_free(msg); 19128 return NULL; 19129 } 19130 19131 static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp) 19132 { 19133 void **cb = (void **)msg->cb; 19134 struct cfg80211_registered_device *rdev = cb[2]; 19135 19136 nla_nest_end(msg, cb[1]); 19137 genlmsg_end(msg, cb[0]); 19138 19139 memset(msg->cb, 0, sizeof(msg->cb)); 19140 19141 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19142 NL80211_MCGRP_MLME, gfp); 19143 } 19144 19145 void cfg80211_cqm_rssi_notify(struct net_device *dev, 19146 enum nl80211_cqm_rssi_threshold_event rssi_event, 19147 s32 rssi_level, gfp_t gfp) 19148 { 19149 struct wireless_dev *wdev = dev->ieee80211_ptr; 19150 struct cfg80211_cqm_config *cqm_config; 19151 19152 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level); 19153 19154 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW && 19155 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH)) 19156 return; 19157 19158 rcu_read_lock(); 19159 cqm_config = rcu_dereference(wdev->cqm_config); 19160 if (cqm_config) { 19161 cqm_config->last_rssi_event_value = rssi_level; 19162 cqm_config->last_rssi_event_type = rssi_event; 19163 wiphy_work_queue(wdev->wiphy, &wdev->cqm_rssi_work); 19164 } 19165 rcu_read_unlock(); 19166 } 19167 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify); 19168 19169 void cfg80211_cqm_rssi_notify_work(struct wiphy *wiphy, struct wiphy_work *work) 19170 { 19171 struct wireless_dev *wdev = container_of(work, struct wireless_dev, 19172 cqm_rssi_work); 19173 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19174 enum nl80211_cqm_rssi_threshold_event rssi_event; 19175 struct cfg80211_cqm_config *cqm_config; 19176 struct sk_buff *msg; 19177 s32 rssi_level; 19178 19179 wdev_lock(wdev); 19180 cqm_config = rcu_dereference_protected(wdev->cqm_config, 19181 lockdep_is_held(&wdev->mtx)); 19182 if (!cqm_config) 19183 goto unlock; 19184 19185 if (cqm_config->use_range_api) 19186 cfg80211_cqm_rssi_update(rdev, wdev->netdev, cqm_config); 19187 19188 rssi_level = cqm_config->last_rssi_event_value; 19189 rssi_event = cqm_config->last_rssi_event_type; 19190 19191 msg = cfg80211_prepare_cqm(wdev->netdev, NULL, GFP_KERNEL); 19192 if (!msg) 19193 goto unlock; 19194 19195 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT, 19196 rssi_event)) 19197 goto nla_put_failure; 19198 19199 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL, 19200 rssi_level)) 19201 goto nla_put_failure; 19202 19203 cfg80211_send_cqm(msg, GFP_KERNEL); 19204 19205 goto unlock; 19206 19207 nla_put_failure: 19208 nlmsg_free(msg); 19209 unlock: 19210 wdev_unlock(wdev); 19211 } 19212 19213 void cfg80211_cqm_txe_notify(struct net_device *dev, 19214 const u8 *peer, u32 num_packets, 19215 u32 rate, u32 intvl, gfp_t gfp) 19216 { 19217 struct sk_buff *msg; 19218 19219 msg = cfg80211_prepare_cqm(dev, peer, gfp); 19220 if (!msg) 19221 return; 19222 19223 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets)) 19224 goto nla_put_failure; 19225 19226 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate)) 19227 goto nla_put_failure; 19228 19229 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl)) 19230 goto nla_put_failure; 19231 19232 cfg80211_send_cqm(msg, gfp); 19233 return; 19234 19235 nla_put_failure: 19236 nlmsg_free(msg); 19237 } 19238 EXPORT_SYMBOL(cfg80211_cqm_txe_notify); 19239 19240 void cfg80211_cqm_pktloss_notify(struct net_device *dev, 19241 const u8 *peer, u32 num_packets, gfp_t gfp) 19242 { 19243 struct sk_buff *msg; 19244 19245 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets); 19246 19247 msg = cfg80211_prepare_cqm(dev, peer, gfp); 19248 if (!msg) 19249 return; 19250 19251 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets)) 19252 goto nla_put_failure; 19253 19254 cfg80211_send_cqm(msg, gfp); 19255 return; 19256 19257 nla_put_failure: 19258 nlmsg_free(msg); 19259 } 19260 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify); 19261 19262 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp) 19263 { 19264 struct sk_buff *msg; 19265 19266 msg = cfg80211_prepare_cqm(dev, NULL, gfp); 19267 if (!msg) 19268 return; 19269 19270 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT)) 19271 goto nla_put_failure; 19272 19273 cfg80211_send_cqm(msg, gfp); 19274 return; 19275 19276 nla_put_failure: 19277 nlmsg_free(msg); 19278 } 19279 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify); 19280 19281 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev, 19282 struct net_device *netdev, const u8 *bssid, 19283 const u8 *replay_ctr, gfp_t gfp) 19284 { 19285 struct sk_buff *msg; 19286 struct nlattr *rekey_attr; 19287 void *hdr; 19288 19289 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19290 if (!msg) 19291 return; 19292 19293 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD); 19294 if (!hdr) { 19295 nlmsg_free(msg); 19296 return; 19297 } 19298 19299 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19300 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 19301 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) 19302 goto nla_put_failure; 19303 19304 rekey_attr = nla_nest_start_noflag(msg, NL80211_ATTR_REKEY_DATA); 19305 if (!rekey_attr) 19306 goto nla_put_failure; 19307 19308 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR, 19309 NL80211_REPLAY_CTR_LEN, replay_ctr)) 19310 goto nla_put_failure; 19311 19312 nla_nest_end(msg, rekey_attr); 19313 19314 genlmsg_end(msg, hdr); 19315 19316 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19317 NL80211_MCGRP_MLME, gfp); 19318 return; 19319 19320 nla_put_failure: 19321 nlmsg_free(msg); 19322 } 19323 19324 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid, 19325 const u8 *replay_ctr, gfp_t gfp) 19326 { 19327 struct wireless_dev *wdev = dev->ieee80211_ptr; 19328 struct wiphy *wiphy = wdev->wiphy; 19329 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19330 19331 trace_cfg80211_gtk_rekey_notify(dev, bssid); 19332 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp); 19333 } 19334 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify); 19335 19336 static void 19337 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev, 19338 struct net_device *netdev, int index, 19339 const u8 *bssid, bool preauth, gfp_t gfp) 19340 { 19341 struct sk_buff *msg; 19342 struct nlattr *attr; 19343 void *hdr; 19344 19345 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19346 if (!msg) 19347 return; 19348 19349 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE); 19350 if (!hdr) { 19351 nlmsg_free(msg); 19352 return; 19353 } 19354 19355 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19356 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex)) 19357 goto nla_put_failure; 19358 19359 attr = nla_nest_start_noflag(msg, NL80211_ATTR_PMKSA_CANDIDATE); 19360 if (!attr) 19361 goto nla_put_failure; 19362 19363 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) || 19364 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) || 19365 (preauth && 19366 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH))) 19367 goto nla_put_failure; 19368 19369 nla_nest_end(msg, attr); 19370 19371 genlmsg_end(msg, hdr); 19372 19373 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19374 NL80211_MCGRP_MLME, gfp); 19375 return; 19376 19377 nla_put_failure: 19378 nlmsg_free(msg); 19379 } 19380 19381 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index, 19382 const u8 *bssid, bool preauth, gfp_t gfp) 19383 { 19384 struct wireless_dev *wdev = dev->ieee80211_ptr; 19385 struct wiphy *wiphy = wdev->wiphy; 19386 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19387 19388 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth); 19389 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp); 19390 } 19391 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify); 19392 19393 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev, 19394 struct net_device *netdev, 19395 unsigned int link_id, 19396 struct cfg80211_chan_def *chandef, 19397 gfp_t gfp, 19398 enum nl80211_commands notif, 19399 u8 count, bool quiet, u16 punct_bitmap) 19400 { 19401 struct wireless_dev *wdev = netdev->ieee80211_ptr; 19402 struct sk_buff *msg; 19403 void *hdr; 19404 19405 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19406 if (!msg) 19407 return; 19408 19409 hdr = nl80211hdr_put(msg, 0, 0, 0, notif); 19410 if (!hdr) { 19411 nlmsg_free(msg); 19412 return; 19413 } 19414 19415 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex)) 19416 goto nla_put_failure; 19417 19418 if (wdev->valid_links && 19419 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id)) 19420 goto nla_put_failure; 19421 19422 if (nl80211_send_chandef(msg, chandef)) 19423 goto nla_put_failure; 19424 19425 if (notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) { 19426 if (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)) 19427 goto nla_put_failure; 19428 if (quiet && 19429 nla_put_flag(msg, NL80211_ATTR_CH_SWITCH_BLOCK_TX)) 19430 goto nla_put_failure; 19431 } 19432 19433 if (nla_put_u32(msg, NL80211_ATTR_PUNCT_BITMAP, punct_bitmap)) 19434 goto nla_put_failure; 19435 19436 genlmsg_end(msg, hdr); 19437 19438 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19439 NL80211_MCGRP_MLME, gfp); 19440 return; 19441 19442 nla_put_failure: 19443 nlmsg_free(msg); 19444 } 19445 19446 void cfg80211_ch_switch_notify(struct net_device *dev, 19447 struct cfg80211_chan_def *chandef, 19448 unsigned int link_id, u16 punct_bitmap) 19449 { 19450 struct wireless_dev *wdev = dev->ieee80211_ptr; 19451 struct wiphy *wiphy = wdev->wiphy; 19452 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19453 19454 ASSERT_WDEV_LOCK(wdev); 19455 WARN_INVALID_LINK_ID(wdev, link_id); 19456 19457 trace_cfg80211_ch_switch_notify(dev, chandef, link_id, punct_bitmap); 19458 19459 switch (wdev->iftype) { 19460 case NL80211_IFTYPE_STATION: 19461 case NL80211_IFTYPE_P2P_CLIENT: 19462 if (!WARN_ON(!wdev->links[link_id].client.current_bss)) 19463 cfg80211_update_assoc_bss_entry(wdev, link_id, 19464 chandef->chan); 19465 break; 19466 case NL80211_IFTYPE_MESH_POINT: 19467 wdev->u.mesh.chandef = *chandef; 19468 wdev->u.mesh.preset_chandef = *chandef; 19469 break; 19470 case NL80211_IFTYPE_AP: 19471 case NL80211_IFTYPE_P2P_GO: 19472 wdev->links[link_id].ap.chandef = *chandef; 19473 break; 19474 case NL80211_IFTYPE_ADHOC: 19475 wdev->u.ibss.chandef = *chandef; 19476 break; 19477 default: 19478 WARN_ON(1); 19479 break; 19480 } 19481 19482 cfg80211_sched_dfs_chan_update(rdev); 19483 19484 nl80211_ch_switch_notify(rdev, dev, link_id, chandef, GFP_KERNEL, 19485 NL80211_CMD_CH_SWITCH_NOTIFY, 0, false, 19486 punct_bitmap); 19487 } 19488 EXPORT_SYMBOL(cfg80211_ch_switch_notify); 19489 19490 void cfg80211_ch_switch_started_notify(struct net_device *dev, 19491 struct cfg80211_chan_def *chandef, 19492 unsigned int link_id, u8 count, 19493 bool quiet, u16 punct_bitmap) 19494 { 19495 struct wireless_dev *wdev = dev->ieee80211_ptr; 19496 struct wiphy *wiphy = wdev->wiphy; 19497 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19498 19499 ASSERT_WDEV_LOCK(wdev); 19500 WARN_INVALID_LINK_ID(wdev, link_id); 19501 19502 trace_cfg80211_ch_switch_started_notify(dev, chandef, link_id, 19503 punct_bitmap); 19504 19505 19506 nl80211_ch_switch_notify(rdev, dev, link_id, chandef, GFP_KERNEL, 19507 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, 19508 count, quiet, punct_bitmap); 19509 } 19510 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify); 19511 19512 int cfg80211_bss_color_notify(struct net_device *dev, 19513 enum nl80211_commands cmd, u8 count, 19514 u64 color_bitmap) 19515 { 19516 struct wireless_dev *wdev = dev->ieee80211_ptr; 19517 struct wiphy *wiphy = wdev->wiphy; 19518 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19519 struct sk_buff *msg; 19520 void *hdr; 19521 19522 ASSERT_WDEV_LOCK(wdev); 19523 19524 trace_cfg80211_bss_color_notify(dev, cmd, count, color_bitmap); 19525 19526 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 19527 if (!msg) 19528 return -ENOMEM; 19529 19530 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd); 19531 if (!hdr) 19532 goto nla_put_failure; 19533 19534 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex)) 19535 goto nla_put_failure; 19536 19537 if (cmd == NL80211_CMD_COLOR_CHANGE_STARTED && 19538 nla_put_u32(msg, NL80211_ATTR_COLOR_CHANGE_COUNT, count)) 19539 goto nla_put_failure; 19540 19541 if (cmd == NL80211_CMD_OBSS_COLOR_COLLISION && 19542 nla_put_u64_64bit(msg, NL80211_ATTR_OBSS_COLOR_BITMAP, 19543 color_bitmap, NL80211_ATTR_PAD)) 19544 goto nla_put_failure; 19545 19546 genlmsg_end(msg, hdr); 19547 19548 return genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), 19549 msg, 0, NL80211_MCGRP_MLME, GFP_KERNEL); 19550 19551 nla_put_failure: 19552 nlmsg_free(msg); 19553 return -EINVAL; 19554 } 19555 EXPORT_SYMBOL(cfg80211_bss_color_notify); 19556 19557 void 19558 nl80211_radar_notify(struct cfg80211_registered_device *rdev, 19559 const struct cfg80211_chan_def *chandef, 19560 enum nl80211_radar_event event, 19561 struct net_device *netdev, gfp_t gfp) 19562 { 19563 struct sk_buff *msg; 19564 void *hdr; 19565 19566 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19567 if (!msg) 19568 return; 19569 19570 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT); 19571 if (!hdr) { 19572 nlmsg_free(msg); 19573 return; 19574 } 19575 19576 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx)) 19577 goto nla_put_failure; 19578 19579 /* NOP and radar events don't need a netdev parameter */ 19580 if (netdev) { 19581 struct wireless_dev *wdev = netdev->ieee80211_ptr; 19582 19583 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 19584 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 19585 NL80211_ATTR_PAD)) 19586 goto nla_put_failure; 19587 } 19588 19589 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event)) 19590 goto nla_put_failure; 19591 19592 if (nl80211_send_chandef(msg, chandef)) 19593 goto nla_put_failure; 19594 19595 genlmsg_end(msg, hdr); 19596 19597 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19598 NL80211_MCGRP_MLME, gfp); 19599 return; 19600 19601 nla_put_failure: 19602 nlmsg_free(msg); 19603 } 19604 19605 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac, 19606 struct sta_opmode_info *sta_opmode, 19607 gfp_t gfp) 19608 { 19609 struct sk_buff *msg; 19610 struct wireless_dev *wdev = dev->ieee80211_ptr; 19611 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 19612 void *hdr; 19613 19614 if (WARN_ON(!mac)) 19615 return; 19616 19617 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19618 if (!msg) 19619 return; 19620 19621 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED); 19622 if (!hdr) { 19623 nlmsg_free(msg); 19624 return; 19625 } 19626 19627 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx)) 19628 goto nla_put_failure; 19629 19630 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex)) 19631 goto nla_put_failure; 19632 19633 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac)) 19634 goto nla_put_failure; 19635 19636 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) && 19637 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode)) 19638 goto nla_put_failure; 19639 19640 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) && 19641 nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw)) 19642 goto nla_put_failure; 19643 19644 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) && 19645 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss)) 19646 goto nla_put_failure; 19647 19648 genlmsg_end(msg, hdr); 19649 19650 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19651 NL80211_MCGRP_MLME, gfp); 19652 19653 return; 19654 19655 nla_put_failure: 19656 nlmsg_free(msg); 19657 } 19658 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify); 19659 19660 void cfg80211_probe_status(struct net_device *dev, const u8 *addr, 19661 u64 cookie, bool acked, s32 ack_signal, 19662 bool is_valid_ack_signal, gfp_t gfp) 19663 { 19664 struct wireless_dev *wdev = dev->ieee80211_ptr; 19665 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 19666 struct sk_buff *msg; 19667 void *hdr; 19668 19669 trace_cfg80211_probe_status(dev, addr, cookie, acked); 19670 19671 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19672 19673 if (!msg) 19674 return; 19675 19676 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT); 19677 if (!hdr) { 19678 nlmsg_free(msg); 19679 return; 19680 } 19681 19682 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19683 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 19684 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) || 19685 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie, 19686 NL80211_ATTR_PAD) || 19687 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)) || 19688 (is_valid_ack_signal && nla_put_s32(msg, NL80211_ATTR_ACK_SIGNAL, 19689 ack_signal))) 19690 goto nla_put_failure; 19691 19692 genlmsg_end(msg, hdr); 19693 19694 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19695 NL80211_MCGRP_MLME, gfp); 19696 return; 19697 19698 nla_put_failure: 19699 nlmsg_free(msg); 19700 } 19701 EXPORT_SYMBOL(cfg80211_probe_status); 19702 19703 void cfg80211_report_obss_beacon_khz(struct wiphy *wiphy, const u8 *frame, 19704 size_t len, int freq, int sig_dbm) 19705 { 19706 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 19707 struct sk_buff *msg; 19708 void *hdr; 19709 struct cfg80211_beacon_registration *reg; 19710 19711 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm); 19712 19713 spin_lock_bh(&rdev->beacon_registrations_lock); 19714 list_for_each_entry(reg, &rdev->beacon_registrations, list) { 19715 msg = nlmsg_new(len + 100, GFP_ATOMIC); 19716 if (!msg) { 19717 spin_unlock_bh(&rdev->beacon_registrations_lock); 19718 return; 19719 } 19720 19721 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME); 19722 if (!hdr) 19723 goto nla_put_failure; 19724 19725 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19726 (freq && 19727 (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, 19728 KHZ_TO_MHZ(freq)) || 19729 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ_OFFSET, 19730 freq % 1000))) || 19731 (sig_dbm && 19732 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) || 19733 nla_put(msg, NL80211_ATTR_FRAME, len, frame)) 19734 goto nla_put_failure; 19735 19736 genlmsg_end(msg, hdr); 19737 19738 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid); 19739 } 19740 spin_unlock_bh(&rdev->beacon_registrations_lock); 19741 return; 19742 19743 nla_put_failure: 19744 spin_unlock_bh(&rdev->beacon_registrations_lock); 19745 nlmsg_free(msg); 19746 } 19747 EXPORT_SYMBOL(cfg80211_report_obss_beacon_khz); 19748 19749 #ifdef CONFIG_PM 19750 static int cfg80211_net_detect_results(struct sk_buff *msg, 19751 struct cfg80211_wowlan_wakeup *wakeup) 19752 { 19753 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect; 19754 struct nlattr *nl_results, *nl_match, *nl_freqs; 19755 int i, j; 19756 19757 nl_results = nla_nest_start_noflag(msg, 19758 NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS); 19759 if (!nl_results) 19760 return -EMSGSIZE; 19761 19762 for (i = 0; i < nd->n_matches; i++) { 19763 struct cfg80211_wowlan_nd_match *match = nd->matches[i]; 19764 19765 nl_match = nla_nest_start_noflag(msg, i); 19766 if (!nl_match) 19767 break; 19768 19769 /* The SSID attribute is optional in nl80211, but for 19770 * simplicity reasons it's always present in the 19771 * cfg80211 structure. If a driver can't pass the 19772 * SSID, that needs to be changed. A zero length SSID 19773 * is still a valid SSID (wildcard), so it cannot be 19774 * used for this purpose. 19775 */ 19776 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len, 19777 match->ssid.ssid)) { 19778 nla_nest_cancel(msg, nl_match); 19779 goto out; 19780 } 19781 19782 if (match->n_channels) { 19783 nl_freqs = nla_nest_start_noflag(msg, 19784 NL80211_ATTR_SCAN_FREQUENCIES); 19785 if (!nl_freqs) { 19786 nla_nest_cancel(msg, nl_match); 19787 goto out; 19788 } 19789 19790 for (j = 0; j < match->n_channels; j++) { 19791 if (nla_put_u32(msg, j, match->channels[j])) { 19792 nla_nest_cancel(msg, nl_freqs); 19793 nla_nest_cancel(msg, nl_match); 19794 goto out; 19795 } 19796 } 19797 19798 nla_nest_end(msg, nl_freqs); 19799 } 19800 19801 nla_nest_end(msg, nl_match); 19802 } 19803 19804 out: 19805 nla_nest_end(msg, nl_results); 19806 return 0; 19807 } 19808 19809 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev, 19810 struct cfg80211_wowlan_wakeup *wakeup, 19811 gfp_t gfp) 19812 { 19813 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 19814 struct sk_buff *msg; 19815 void *hdr; 19816 int size = 200; 19817 19818 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup); 19819 19820 if (wakeup) 19821 size += wakeup->packet_present_len; 19822 19823 msg = nlmsg_new(size, gfp); 19824 if (!msg) 19825 return; 19826 19827 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN); 19828 if (!hdr) 19829 goto free_msg; 19830 19831 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19832 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 19833 NL80211_ATTR_PAD)) 19834 goto free_msg; 19835 19836 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX, 19837 wdev->netdev->ifindex)) 19838 goto free_msg; 19839 19840 if (wakeup) { 19841 struct nlattr *reasons; 19842 19843 reasons = nla_nest_start_noflag(msg, 19844 NL80211_ATTR_WOWLAN_TRIGGERS); 19845 if (!reasons) 19846 goto free_msg; 19847 19848 if (wakeup->disconnect && 19849 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) 19850 goto free_msg; 19851 if (wakeup->magic_pkt && 19852 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) 19853 goto free_msg; 19854 if (wakeup->gtk_rekey_failure && 19855 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) 19856 goto free_msg; 19857 if (wakeup->eap_identity_req && 19858 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) 19859 goto free_msg; 19860 if (wakeup->four_way_handshake && 19861 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) 19862 goto free_msg; 19863 if (wakeup->rfkill_release && 19864 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)) 19865 goto free_msg; 19866 19867 if (wakeup->pattern_idx >= 0 && 19868 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN, 19869 wakeup->pattern_idx)) 19870 goto free_msg; 19871 19872 if (wakeup->tcp_match && 19873 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH)) 19874 goto free_msg; 19875 19876 if (wakeup->tcp_connlost && 19877 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST)) 19878 goto free_msg; 19879 19880 if (wakeup->tcp_nomoretokens && 19881 nla_put_flag(msg, 19882 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS)) 19883 goto free_msg; 19884 19885 if (wakeup->packet) { 19886 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211; 19887 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN; 19888 19889 if (!wakeup->packet_80211) { 19890 pkt_attr = 19891 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023; 19892 len_attr = 19893 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN; 19894 } 19895 19896 if (wakeup->packet_len && 19897 nla_put_u32(msg, len_attr, wakeup->packet_len)) 19898 goto free_msg; 19899 19900 if (nla_put(msg, pkt_attr, wakeup->packet_present_len, 19901 wakeup->packet)) 19902 goto free_msg; 19903 } 19904 19905 if (wakeup->net_detect && 19906 cfg80211_net_detect_results(msg, wakeup)) 19907 goto free_msg; 19908 19909 nla_nest_end(msg, reasons); 19910 } 19911 19912 genlmsg_end(msg, hdr); 19913 19914 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19915 NL80211_MCGRP_MLME, gfp); 19916 return; 19917 19918 free_msg: 19919 nlmsg_free(msg); 19920 } 19921 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup); 19922 #endif 19923 19924 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer, 19925 enum nl80211_tdls_operation oper, 19926 u16 reason_code, gfp_t gfp) 19927 { 19928 struct wireless_dev *wdev = dev->ieee80211_ptr; 19929 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 19930 struct sk_buff *msg; 19931 void *hdr; 19932 19933 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper, 19934 reason_code); 19935 19936 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 19937 if (!msg) 19938 return; 19939 19940 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER); 19941 if (!hdr) { 19942 nlmsg_free(msg); 19943 return; 19944 } 19945 19946 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 19947 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 19948 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) || 19949 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) || 19950 (reason_code > 0 && 19951 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code))) 19952 goto nla_put_failure; 19953 19954 genlmsg_end(msg, hdr); 19955 19956 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 19957 NL80211_MCGRP_MLME, gfp); 19958 return; 19959 19960 nla_put_failure: 19961 nlmsg_free(msg); 19962 } 19963 EXPORT_SYMBOL(cfg80211_tdls_oper_request); 19964 19965 static int nl80211_netlink_notify(struct notifier_block * nb, 19966 unsigned long state, 19967 void *_notify) 19968 { 19969 struct netlink_notify *notify = _notify; 19970 struct cfg80211_registered_device *rdev; 19971 struct wireless_dev *wdev; 19972 struct cfg80211_beacon_registration *reg, *tmp; 19973 19974 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC) 19975 return NOTIFY_DONE; 19976 19977 rcu_read_lock(); 19978 19979 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) { 19980 struct cfg80211_sched_scan_request *sched_scan_req; 19981 19982 list_for_each_entry_rcu(sched_scan_req, 19983 &rdev->sched_scan_req_list, 19984 list) { 19985 if (sched_scan_req->owner_nlportid == notify->portid) { 19986 sched_scan_req->nl_owner_dead = true; 19987 wiphy_work_queue(&rdev->wiphy, 19988 &rdev->sched_scan_stop_wk); 19989 } 19990 } 19991 19992 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) { 19993 cfg80211_mlme_unregister_socket(wdev, notify->portid); 19994 19995 if (wdev->owner_nlportid == notify->portid) { 19996 wdev->nl_owner_dead = true; 19997 schedule_work(&rdev->destroy_work); 19998 } else if (wdev->conn_owner_nlportid == notify->portid) { 19999 schedule_work(&wdev->disconnect_wk); 20000 } 20001 20002 cfg80211_release_pmsr(wdev, notify->portid); 20003 } 20004 20005 spin_lock_bh(&rdev->beacon_registrations_lock); 20006 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations, 20007 list) { 20008 if (reg->nlportid == notify->portid) { 20009 list_del(®->list); 20010 kfree(reg); 20011 break; 20012 } 20013 } 20014 spin_unlock_bh(&rdev->beacon_registrations_lock); 20015 } 20016 20017 rcu_read_unlock(); 20018 20019 /* 20020 * It is possible that the user space process that is controlling the 20021 * indoor setting disappeared, so notify the regulatory core. 20022 */ 20023 regulatory_netlink_notify(notify->portid); 20024 return NOTIFY_OK; 20025 } 20026 20027 static struct notifier_block nl80211_netlink_notifier = { 20028 .notifier_call = nl80211_netlink_notify, 20029 }; 20030 20031 void cfg80211_ft_event(struct net_device *netdev, 20032 struct cfg80211_ft_event_params *ft_event) 20033 { 20034 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy; 20035 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 20036 struct sk_buff *msg; 20037 void *hdr; 20038 20039 trace_cfg80211_ft_event(wiphy, netdev, ft_event); 20040 20041 if (!ft_event->target_ap) 20042 return; 20043 20044 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len, 20045 GFP_KERNEL); 20046 if (!msg) 20047 return; 20048 20049 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT); 20050 if (!hdr) 20051 goto out; 20052 20053 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 20054 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 20055 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap)) 20056 goto out; 20057 20058 if (ft_event->ies && 20059 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies)) 20060 goto out; 20061 if (ft_event->ric_ies && 20062 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len, 20063 ft_event->ric_ies)) 20064 goto out; 20065 20066 genlmsg_end(msg, hdr); 20067 20068 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 20069 NL80211_MCGRP_MLME, GFP_KERNEL); 20070 return; 20071 out: 20072 nlmsg_free(msg); 20073 } 20074 EXPORT_SYMBOL(cfg80211_ft_event); 20075 20076 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp) 20077 { 20078 struct cfg80211_registered_device *rdev; 20079 struct sk_buff *msg; 20080 void *hdr; 20081 u32 nlportid; 20082 20083 rdev = wiphy_to_rdev(wdev->wiphy); 20084 if (!rdev->crit_proto_nlportid) 20085 return; 20086 20087 nlportid = rdev->crit_proto_nlportid; 20088 rdev->crit_proto_nlportid = 0; 20089 20090 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 20091 if (!msg) 20092 return; 20093 20094 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP); 20095 if (!hdr) 20096 goto nla_put_failure; 20097 20098 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 20099 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 20100 NL80211_ATTR_PAD)) 20101 goto nla_put_failure; 20102 20103 genlmsg_end(msg, hdr); 20104 20105 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid); 20106 return; 20107 20108 nla_put_failure: 20109 nlmsg_free(msg); 20110 } 20111 EXPORT_SYMBOL(cfg80211_crit_proto_stopped); 20112 20113 void nl80211_send_ap_stopped(struct wireless_dev *wdev, unsigned int link_id) 20114 { 20115 struct wiphy *wiphy = wdev->wiphy; 20116 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 20117 struct sk_buff *msg; 20118 void *hdr; 20119 20120 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 20121 if (!msg) 20122 return; 20123 20124 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP); 20125 if (!hdr) 20126 goto out; 20127 20128 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 20129 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) || 20130 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev), 20131 NL80211_ATTR_PAD) || 20132 (wdev->valid_links && 20133 nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, link_id))) 20134 goto out; 20135 20136 genlmsg_end(msg, hdr); 20137 20138 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0, 20139 NL80211_MCGRP_MLME, GFP_KERNEL); 20140 return; 20141 out: 20142 nlmsg_free(msg); 20143 } 20144 20145 int cfg80211_external_auth_request(struct net_device *dev, 20146 struct cfg80211_external_auth_params *params, 20147 gfp_t gfp) 20148 { 20149 struct wireless_dev *wdev = dev->ieee80211_ptr; 20150 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy); 20151 struct sk_buff *msg; 20152 void *hdr; 20153 20154 if (!wdev->conn_owner_nlportid) 20155 return -EINVAL; 20156 20157 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 20158 if (!msg) 20159 return -ENOMEM; 20160 20161 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH); 20162 if (!hdr) 20163 goto nla_put_failure; 20164 20165 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 20166 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) || 20167 nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, params->key_mgmt_suite) || 20168 nla_put_u32(msg, NL80211_ATTR_EXTERNAL_AUTH_ACTION, 20169 params->action) || 20170 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) || 20171 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len, 20172 params->ssid.ssid) || 20173 (!is_zero_ether_addr(params->mld_addr) && 20174 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN, params->mld_addr))) 20175 goto nla_put_failure; 20176 20177 genlmsg_end(msg, hdr); 20178 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, 20179 wdev->conn_owner_nlportid); 20180 return 0; 20181 20182 nla_put_failure: 20183 nlmsg_free(msg); 20184 return -ENOBUFS; 20185 } 20186 EXPORT_SYMBOL(cfg80211_external_auth_request); 20187 20188 void cfg80211_update_owe_info_event(struct net_device *netdev, 20189 struct cfg80211_update_owe_info *owe_info, 20190 gfp_t gfp) 20191 { 20192 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy; 20193 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy); 20194 struct sk_buff *msg; 20195 void *hdr; 20196 20197 trace_cfg80211_update_owe_info_event(wiphy, netdev, owe_info); 20198 20199 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp); 20200 if (!msg) 20201 return; 20202 20203 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_UPDATE_OWE_INFO); 20204 if (!hdr) 20205 goto nla_put_failure; 20206 20207 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) || 20208 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) || 20209 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, owe_info->peer)) 20210 goto nla_put_failure; 20211 20212 if (!owe_info->ie_len || 20213 nla_put(msg, NL80211_ATTR_IE, owe_info->ie_len, owe_info->ie)) 20214 goto nla_put_failure; 20215 20216 if (owe_info->assoc_link_id != -1) { 20217 if (nla_put_u8(msg, NL80211_ATTR_MLO_LINK_ID, 20218 owe_info->assoc_link_id)) 20219 goto nla_put_failure; 20220 20221 if (!is_zero_ether_addr(owe_info->peer_mld_addr) && 20222 nla_put(msg, NL80211_ATTR_MLD_ADDR, ETH_ALEN, 20223 owe_info->peer_mld_addr)) 20224 goto nla_put_failure; 20225 } 20226 20227 genlmsg_end(msg, hdr); 20228 20229 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0, 20230 NL80211_MCGRP_MLME, gfp); 20231 return; 20232 20233 nla_put_failure: 20234 genlmsg_cancel(msg, hdr); 20235 nlmsg_free(msg); 20236 } 20237 EXPORT_SYMBOL(cfg80211_update_owe_info_event); 20238 20239 /* initialisation/exit functions */ 20240 20241 int __init nl80211_init(void) 20242 { 20243 int err; 20244 20245 err = genl_register_family(&nl80211_fam); 20246 if (err) 20247 return err; 20248 20249 err = netlink_register_notifier(&nl80211_netlink_notifier); 20250 if (err) 20251 goto err_out; 20252 20253 return 0; 20254 err_out: 20255 genl_unregister_family(&nl80211_fam); 20256 return err; 20257 } 20258 20259 void nl80211_exit(void) 20260 { 20261 netlink_unregister_notifier(&nl80211_netlink_notifier); 20262 genl_unregister_family(&nl80211_fam); 20263 } 20264