1 // SPDX-License-Identifier: GPL-2.0-only
3 * This is the new netlink-based wireless configuration interface.
5 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2013-2014 Intel Mobile Communications GmbH
7 * Copyright 2015-2017 Intel Deutschland GmbH
8 * Copyright (C) 2018-2019 Intel Corporation
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/slab.h>
15 #include <linux/list.h>
16 #include <linux/if_ether.h>
17 #include <linux/ieee80211.h>
18 #include <linux/nl80211.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/netlink.h>
21 #include <linux/nospec.h>
22 #include <linux/etherdevice.h>
23 #include <net/net_namespace.h>
24 #include <net/genetlink.h>
25 #include <net/cfg80211.h>
27 #include <net/inet_connection_sock.h>
33 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
34 struct genl_info *info,
35 struct cfg80211_crypto_settings *settings,
38 /* the netlink family */
39 static struct genl_family nl80211_fam;
41 /* multicast groups */
42 enum nl80211_multicast_groups {
45 NL80211_MCGRP_REGULATORY,
49 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
52 static const struct genl_multicast_group nl80211_mcgrps[] = {
53 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
54 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
55 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
56 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
57 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
58 [NL80211_MCGRP_NAN] = { .name = NL80211_MULTICAST_GROUP_NAN },
59 #ifdef CONFIG_NL80211_TESTMODE
60 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
64 /* returns ERR_PTR values */
65 static struct wireless_dev *
66 __cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
68 struct cfg80211_registered_device *rdev;
69 struct wireless_dev *result = NULL;
70 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
71 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
78 if (!have_ifidx && !have_wdev_id)
79 return ERR_PTR(-EINVAL);
82 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
84 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
85 wiphy_idx = wdev_id >> 32;
88 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
89 struct wireless_dev *wdev;
91 if (wiphy_net(&rdev->wiphy) != netns)
94 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
97 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
98 if (have_ifidx && wdev->netdev &&
99 wdev->netdev->ifindex == ifidx) {
103 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
115 return ERR_PTR(-ENODEV);
118 static struct cfg80211_registered_device *
119 __cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
121 struct cfg80211_registered_device *rdev = NULL, *tmp;
122 struct net_device *netdev;
126 if (!attrs[NL80211_ATTR_WIPHY] &&
127 !attrs[NL80211_ATTR_IFINDEX] &&
128 !attrs[NL80211_ATTR_WDEV])
129 return ERR_PTR(-EINVAL);
131 if (attrs[NL80211_ATTR_WIPHY])
132 rdev = cfg80211_rdev_by_wiphy_idx(
133 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
135 if (attrs[NL80211_ATTR_WDEV]) {
136 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
137 struct wireless_dev *wdev;
140 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
142 /* make sure wdev exists */
143 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
144 if (wdev->identifier != (u32)wdev_id)
153 if (rdev && tmp != rdev)
154 return ERR_PTR(-EINVAL);
159 if (attrs[NL80211_ATTR_IFINDEX]) {
160 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
162 netdev = __dev_get_by_index(netns, ifindex);
164 if (netdev->ieee80211_ptr)
166 netdev->ieee80211_ptr->wiphy);
170 /* not wireless device -- return error */
172 return ERR_PTR(-EINVAL);
174 /* mismatch -- return error */
175 if (rdev && tmp != rdev)
176 return ERR_PTR(-EINVAL);
183 return ERR_PTR(-ENODEV);
185 if (netns != wiphy_net(&rdev->wiphy))
186 return ERR_PTR(-ENODEV);
192 * This function returns a pointer to the driver
193 * that the genl_info item that is passed refers to.
195 * The result of this can be a PTR_ERR and hence must
196 * be checked with IS_ERR() for errors.
198 static struct cfg80211_registered_device *
199 cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
201 return __cfg80211_rdev_from_attrs(netns, info->attrs);
204 static int validate_beacon_head(const struct nlattr *attr,
205 struct netlink_ext_ack *extack)
207 const u8 *data = nla_data(attr);
208 unsigned int len = nla_len(attr);
209 const struct element *elem;
210 const struct ieee80211_mgmt *mgmt = (void *)data;
211 unsigned int fixedlen = offsetof(struct ieee80211_mgmt,
217 if (ieee80211_hdrlen(mgmt->frame_control) !=
218 offsetof(struct ieee80211_mgmt, u.beacon))
224 for_each_element(elem, data, len) {
228 if (for_each_element_completed(elem, data, len))
232 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed beacon head");
236 static int validate_ie_attr(const struct nlattr *attr,
237 struct netlink_ext_ack *extack)
239 const u8 *data = nla_data(attr);
240 unsigned int len = nla_len(attr);
241 const struct element *elem;
243 for_each_element(elem, data, len) {
247 if (for_each_element_completed(elem, data, len))
250 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed information elements");
254 /* policy for the attributes */
255 static const struct nla_policy
256 nl80211_ftm_responder_policy[NL80211_FTM_RESP_ATTR_MAX + 1] = {
257 [NL80211_FTM_RESP_ATTR_ENABLED] = { .type = NLA_FLAG, },
258 [NL80211_FTM_RESP_ATTR_LCI] = { .type = NLA_BINARY,
260 [NL80211_FTM_RESP_ATTR_CIVICLOC] = { .type = NLA_BINARY,
264 static const struct nla_policy
265 nl80211_pmsr_ftm_req_attr_policy[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1] = {
266 [NL80211_PMSR_FTM_REQ_ATTR_ASAP] = { .type = NLA_FLAG },
267 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE] = { .type = NLA_U32 },
268 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP] =
269 NLA_POLICY_MAX(NLA_U8, 15),
270 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD] = { .type = NLA_U16 },
271 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION] =
272 NLA_POLICY_MAX(NLA_U8, 15),
273 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST] =
274 NLA_POLICY_MAX(NLA_U8, 31),
275 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES] = { .type = NLA_U8 },
276 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI] = { .type = NLA_FLAG },
277 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC] = { .type = NLA_FLAG },
280 static const struct nla_policy
281 nl80211_pmsr_req_data_policy[NL80211_PMSR_TYPE_MAX + 1] = {
282 [NL80211_PMSR_TYPE_FTM] =
283 NLA_POLICY_NESTED(nl80211_pmsr_ftm_req_attr_policy),
286 static const struct nla_policy
287 nl80211_pmsr_req_attr_policy[NL80211_PMSR_REQ_ATTR_MAX + 1] = {
288 [NL80211_PMSR_REQ_ATTR_DATA] =
289 NLA_POLICY_NESTED(nl80211_pmsr_req_data_policy),
290 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF] = { .type = NLA_FLAG },
293 static const struct nla_policy
294 nl80211_psmr_peer_attr_policy[NL80211_PMSR_PEER_ATTR_MAX + 1] = {
295 [NL80211_PMSR_PEER_ATTR_ADDR] = NLA_POLICY_ETH_ADDR,
297 * we could specify this again to be the top-level policy,
298 * but that would open us up to recursion problems ...
300 [NL80211_PMSR_PEER_ATTR_CHAN] = { .type = NLA_NESTED },
301 [NL80211_PMSR_PEER_ATTR_REQ] =
302 NLA_POLICY_NESTED(nl80211_pmsr_req_attr_policy),
303 [NL80211_PMSR_PEER_ATTR_RESP] = { .type = NLA_REJECT },
306 static const struct nla_policy
307 nl80211_pmsr_attr_policy[NL80211_PMSR_ATTR_MAX + 1] = {
308 [NL80211_PMSR_ATTR_MAX_PEERS] = { .type = NLA_REJECT },
309 [NL80211_PMSR_ATTR_REPORT_AP_TSF] = { .type = NLA_REJECT },
310 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR] = { .type = NLA_REJECT },
311 [NL80211_PMSR_ATTR_TYPE_CAPA] = { .type = NLA_REJECT },
312 [NL80211_PMSR_ATTR_PEERS] =
313 NLA_POLICY_NESTED_ARRAY(nl80211_psmr_peer_attr_policy),
316 static const struct nla_policy
317 he_obss_pd_policy[NL80211_HE_OBSS_PD_ATTR_MAX + 1] = {
318 [NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] =
319 NLA_POLICY_RANGE(NLA_U8, 1, 20),
320 [NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET] =
321 NLA_POLICY_RANGE(NLA_U8, 1, 20),
324 static const struct nla_policy
325 he_bss_color_policy[NL80211_HE_BSS_COLOR_ATTR_MAX + 1] = {
326 [NL80211_HE_BSS_COLOR_ATTR_COLOR] = NLA_POLICY_RANGE(NLA_U8, 1, 63),
327 [NL80211_HE_BSS_COLOR_ATTR_DISABLED] = { .type = NLA_FLAG },
328 [NL80211_HE_BSS_COLOR_ATTR_PARTIAL] = { .type = NLA_FLAG },
331 static const struct nla_policy
332 nl80211_tid_config_attr_policy[NL80211_TID_CONFIG_ATTR_MAX + 1] = {
333 [NL80211_TID_CONFIG_ATTR_VIF_SUPP] = { .type = NLA_U64 },
334 [NL80211_TID_CONFIG_ATTR_PEER_SUPP] = { .type = NLA_U64 },
335 [NL80211_TID_CONFIG_ATTR_OVERRIDE] = { .type = NLA_FLAG },
336 [NL80211_TID_CONFIG_ATTR_TIDS] = NLA_POLICY_RANGE(NLA_U16, 1, 0xff),
337 [NL80211_TID_CONFIG_ATTR_NOACK] =
338 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
339 [NL80211_TID_CONFIG_ATTR_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
340 [NL80211_TID_CONFIG_ATTR_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
341 [NL80211_TID_CONFIG_ATTR_AMPDU_CTRL] =
342 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
343 [NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL] =
344 NLA_POLICY_MAX(NLA_U8, NL80211_TID_CONFIG_DISABLE),
347 const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
348 [0] = { .strict_start_type = NL80211_ATTR_HE_OBSS_PD },
349 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
350 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
352 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
354 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
355 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
356 [NL80211_ATTR_WIPHY_EDMG_CHANNELS] = NLA_POLICY_RANGE(NLA_U8,
357 NL80211_EDMG_CHANNELS_MIN,
358 NL80211_EDMG_CHANNELS_MAX),
359 [NL80211_ATTR_WIPHY_EDMG_BW_CONFIG] = NLA_POLICY_RANGE(NLA_U8,
360 NL80211_EDMG_BW_CONFIG_MIN,
361 NL80211_EDMG_BW_CONFIG_MAX),
363 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
364 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
365 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
367 [NL80211_ATTR_WIPHY_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
368 [NL80211_ATTR_WIPHY_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
369 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
370 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
371 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
372 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
374 [NL80211_ATTR_IFTYPE] = NLA_POLICY_MAX(NLA_U32, NL80211_IFTYPE_MAX),
375 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
376 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
378 [NL80211_ATTR_MAC] = { .type = NLA_EXACT_LEN_WARN, .len = ETH_ALEN },
379 [NL80211_ATTR_PREV_BSSID] = {
380 .type = NLA_EXACT_LEN_WARN,
384 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
385 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
386 .len = WLAN_MAX_KEY_LEN },
387 [NL80211_ATTR_KEY_IDX] = NLA_POLICY_MAX(NLA_U8, 7),
388 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
389 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
390 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
391 [NL80211_ATTR_KEY_TYPE] =
392 NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES),
394 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
395 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
396 [NL80211_ATTR_BEACON_HEAD] =
397 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_beacon_head,
398 IEEE80211_MAX_DATA_LEN),
399 [NL80211_ATTR_BEACON_TAIL] =
400 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
401 IEEE80211_MAX_DATA_LEN),
402 [NL80211_ATTR_STA_AID] =
403 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
404 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
405 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
406 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
407 .len = NL80211_MAX_SUPP_RATES },
408 [NL80211_ATTR_STA_PLINK_ACTION] =
409 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1),
410 [NL80211_ATTR_STA_TX_POWER_SETTING] =
411 NLA_POLICY_RANGE(NLA_U8,
412 NL80211_TX_POWER_AUTOMATIC,
413 NL80211_TX_POWER_FIXED),
414 [NL80211_ATTR_STA_TX_POWER] = { .type = NLA_S16 },
415 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
416 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
417 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
418 .len = IEEE80211_MAX_MESH_ID_LEN },
419 [NL80211_ATTR_MPATH_NEXT_HOP] = NLA_POLICY_ETH_ADDR_COMPAT,
421 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
422 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
424 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
425 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
426 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
427 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
428 .len = NL80211_MAX_SUPP_RATES },
429 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
431 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
432 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
434 [NL80211_ATTR_HT_CAPABILITY] = {
435 .type = NLA_EXACT_LEN_WARN,
436 .len = NL80211_HT_CAPABILITY_LEN
439 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
440 [NL80211_ATTR_IE] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
442 IEEE80211_MAX_DATA_LEN),
443 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
444 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
446 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
447 .len = IEEE80211_MAX_SSID_LEN },
448 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
449 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
450 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
451 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
452 [NL80211_ATTR_USE_MFP] = NLA_POLICY_RANGE(NLA_U32,
454 NL80211_MFP_OPTIONAL),
455 [NL80211_ATTR_STA_FLAGS2] = {
456 .len = sizeof(struct nl80211_sta_flag_update),
458 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
459 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
460 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
461 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211] = { .type = NLA_FLAG },
462 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
463 [NL80211_ATTR_STATUS_CODE] = { .type = NLA_U16 },
464 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
465 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
466 [NL80211_ATTR_PID] = { .type = NLA_U32 },
467 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
468 [NL80211_ATTR_PMKID] = {
469 .type = NLA_EXACT_LEN_WARN,
470 .len = WLAN_PMKID_LEN
472 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
473 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
474 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
475 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
476 .len = IEEE80211_MAX_DATA_LEN },
477 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
478 [NL80211_ATTR_PS_STATE] = NLA_POLICY_RANGE(NLA_U32,
481 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
482 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
483 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
484 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
485 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
486 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
487 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
488 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
489 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
490 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
491 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
492 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
493 [NL80211_ATTR_STA_PLINK_STATE] =
494 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
495 [NL80211_ATTR_MESH_PEER_AID] =
496 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
497 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
498 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
499 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
500 [NL80211_ATTR_HIDDEN_SSID] =
501 NLA_POLICY_RANGE(NLA_U32,
502 NL80211_HIDDEN_SSID_NOT_IN_USE,
503 NL80211_HIDDEN_SSID_ZERO_CONTENTS),
504 [NL80211_ATTR_IE_PROBE_RESP] =
505 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
506 IEEE80211_MAX_DATA_LEN),
507 [NL80211_ATTR_IE_ASSOC_RESP] =
508 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
509 IEEE80211_MAX_DATA_LEN),
510 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
511 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
512 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
513 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
514 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
515 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
516 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
517 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
518 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
519 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
520 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
521 .len = IEEE80211_MAX_DATA_LEN },
522 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
523 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
524 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
525 .len = NL80211_HT_CAPABILITY_LEN
527 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
528 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
529 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
530 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
531 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
532 [NL80211_ATTR_AUTH_DATA] = { .type = NLA_BINARY, },
533 [NL80211_ATTR_VHT_CAPABILITY] = {
534 .type = NLA_EXACT_LEN_WARN,
535 .len = NL80211_VHT_CAPABILITY_LEN
537 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
538 [NL80211_ATTR_P2P_CTWINDOW] = NLA_POLICY_MAX(NLA_U8, 127),
539 [NL80211_ATTR_P2P_OPPPS] = NLA_POLICY_MAX(NLA_U8, 1),
540 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] =
541 NLA_POLICY_RANGE(NLA_U32,
542 NL80211_MESH_POWER_UNKNOWN + 1,
543 NL80211_MESH_POWER_MAX),
544 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
545 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
546 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
547 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
548 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
549 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
550 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
551 .len = NL80211_VHT_CAPABILITY_LEN,
553 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
554 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
555 .len = IEEE80211_MAX_DATA_LEN },
556 [NL80211_ATTR_PEER_AID] =
557 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
558 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
559 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
560 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
561 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
562 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
563 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
564 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
565 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
566 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
567 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
568 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
569 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
570 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
571 .len = IEEE80211_QOS_MAP_LEN_MAX },
572 [NL80211_ATTR_MAC_HINT] = {
573 .type = NLA_EXACT_LEN_WARN,
576 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
577 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
578 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
579 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
580 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
581 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1),
582 [NL80211_ATTR_USER_PRIO] =
583 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
584 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
585 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
586 [NL80211_ATTR_MAC_MASK] = {
587 .type = NLA_EXACT_LEN_WARN,
590 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
591 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
592 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
593 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
594 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
595 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
596 [NL80211_ATTR_STA_SUPPORT_P2P_PS] =
597 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1),
598 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
599 .len = VHT_MUMIMO_GROUPS_DATA_LEN
601 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = {
602 .type = NLA_EXACT_LEN_WARN,
605 [NL80211_ATTR_NAN_MASTER_PREF] = NLA_POLICY_MIN(NLA_U8, 1),
606 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
607 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
608 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
609 .len = FILS_MAX_KEK_LEN },
610 [NL80211_ATTR_FILS_NONCES] = {
611 .type = NLA_EXACT_LEN_WARN,
612 .len = 2 * FILS_NONCE_LEN
614 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
615 [NL80211_ATTR_BSSID] = { .type = NLA_EXACT_LEN_WARN, .len = ETH_ALEN },
616 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
617 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
618 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
620 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
621 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
622 .len = FILS_ERP_MAX_USERNAME_LEN },
623 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
624 .len = FILS_ERP_MAX_REALM_LEN },
625 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
626 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
627 .len = FILS_ERP_MAX_RRK_LEN },
628 [NL80211_ATTR_FILS_CACHE_ID] = { .type = NLA_EXACT_LEN_WARN, .len = 2 },
629 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
630 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
631 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT] = { .type = NLA_FLAG },
633 [NL80211_ATTR_TXQ_LIMIT] = { .type = NLA_U32 },
634 [NL80211_ATTR_TXQ_MEMORY_LIMIT] = { .type = NLA_U32 },
635 [NL80211_ATTR_TXQ_QUANTUM] = { .type = NLA_U32 },
636 [NL80211_ATTR_HE_CAPABILITY] = { .type = NLA_BINARY,
637 .len = NL80211_HE_MAX_CAPABILITY_LEN },
639 [NL80211_ATTR_FTM_RESPONDER] = {
641 .validation_data = nl80211_ftm_responder_policy,
643 [NL80211_ATTR_TIMEOUT] = NLA_POLICY_MIN(NLA_U32, 1),
644 [NL80211_ATTR_PEER_MEASUREMENTS] =
645 NLA_POLICY_NESTED(nl80211_pmsr_attr_policy),
646 [NL80211_ATTR_AIRTIME_WEIGHT] = NLA_POLICY_MIN(NLA_U16, 1),
647 [NL80211_ATTR_SAE_PASSWORD] = { .type = NLA_BINARY,
648 .len = SAE_PASSWORD_MAX_LEN },
649 [NL80211_ATTR_TWT_RESPONDER] = { .type = NLA_FLAG },
650 [NL80211_ATTR_HE_OBSS_PD] = NLA_POLICY_NESTED(he_obss_pd_policy),
651 [NL80211_ATTR_VLAN_ID] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
652 [NL80211_ATTR_HE_BSS_COLOR] = NLA_POLICY_NESTED(he_bss_color_policy),
653 [NL80211_ATTR_TID_CONFIG] =
654 NLA_POLICY_NESTED_ARRAY(nl80211_tid_config_attr_policy),
657 /* policy for the key attributes */
658 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
659 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
660 [NL80211_KEY_IDX] = { .type = NLA_U8 },
661 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
662 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
663 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
664 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
665 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1),
666 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
667 [NL80211_KEY_MODE] = NLA_POLICY_RANGE(NLA_U8, 0, NL80211_KEY_SET_TX),
670 /* policy for the key default flags */
671 static const struct nla_policy
672 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
673 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
674 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
678 /* policy for WoWLAN attributes */
679 static const struct nla_policy
680 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
681 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
682 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
683 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
684 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
685 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
686 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
687 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
688 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
689 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
690 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
693 static const struct nla_policy
694 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
695 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
696 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
697 [NL80211_WOWLAN_TCP_DST_MAC] = {
698 .type = NLA_EXACT_LEN_WARN,
701 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
702 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
703 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .type = NLA_MIN_LEN, .len = 1 },
704 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
705 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
707 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
708 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
710 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
711 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .type = NLA_MIN_LEN, .len = 1 },
712 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .type = NLA_MIN_LEN, .len = 1 },
714 #endif /* CONFIG_PM */
716 /* policy for coalesce rule attributes */
717 static const struct nla_policy
718 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
719 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
720 [NL80211_ATTR_COALESCE_RULE_CONDITION] =
721 NLA_POLICY_RANGE(NLA_U32,
722 NL80211_COALESCE_CONDITION_MATCH,
723 NL80211_COALESCE_CONDITION_NO_MATCH),
724 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
727 /* policy for GTK rekey offload attributes */
728 static const struct nla_policy
729 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
730 [NL80211_REKEY_DATA_KEK] = {
731 .type = NLA_EXACT_LEN_WARN,
732 .len = NL80211_KEK_LEN,
734 [NL80211_REKEY_DATA_KCK] = {
735 .type = NLA_EXACT_LEN_WARN,
736 .len = NL80211_KCK_LEN,
738 [NL80211_REKEY_DATA_REPLAY_CTR] = {
739 .type = NLA_EXACT_LEN_WARN,
740 .len = NL80211_REPLAY_CTR_LEN
744 static const struct nla_policy
745 nl80211_match_band_rssi_policy[NUM_NL80211_BANDS] = {
746 [NL80211_BAND_2GHZ] = { .type = NLA_S32 },
747 [NL80211_BAND_5GHZ] = { .type = NLA_S32 },
748 [NL80211_BAND_6GHZ] = { .type = NLA_S32 },
749 [NL80211_BAND_60GHZ] = { .type = NLA_S32 },
752 static const struct nla_policy
753 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
754 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
755 .len = IEEE80211_MAX_SSID_LEN },
756 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = {
757 .type = NLA_EXACT_LEN_WARN,
760 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
761 [NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI] =
762 NLA_POLICY_NESTED(nl80211_match_band_rssi_policy),
765 static const struct nla_policy
766 nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
767 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
768 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
771 static const struct nla_policy
772 nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
773 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
774 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
775 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
776 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
780 /* policy for NAN function attributes */
781 static const struct nla_policy
782 nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
783 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
784 [NL80211_NAN_FUNC_SERVICE_ID] = {
785 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
786 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
787 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
788 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
789 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
790 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
791 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = {
792 .type = NLA_EXACT_LEN_WARN,
795 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
796 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
797 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
798 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
799 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
800 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
801 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
802 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
803 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
806 /* policy for Service Response Filter attributes */
807 static const struct nla_policy
808 nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
809 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
810 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
811 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
812 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
813 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
816 /* policy for packet pattern attributes */
817 static const struct nla_policy
818 nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
819 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
820 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
821 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
824 int nl80211_prepare_wdev_dump(struct netlink_callback *cb,
825 struct cfg80211_registered_device **rdev,
826 struct wireless_dev **wdev)
831 struct nlattr **attrbuf;
833 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
838 err = nlmsg_parse_deprecated(cb->nlh,
839 GENL_HDRLEN + nl80211_fam.hdrsize,
840 attrbuf, nl80211_fam.maxattr,
841 nl80211_policy, NULL);
847 *wdev = __cfg80211_wdev_from_attrs(sock_net(cb->skb->sk),
851 return PTR_ERR(*wdev);
852 *rdev = wiphy_to_rdev((*wdev)->wiphy);
853 /* 0 is the first index - add 1 to parse only once */
854 cb->args[0] = (*rdev)->wiphy_idx + 1;
855 cb->args[1] = (*wdev)->identifier;
857 /* subtract the 1 again here */
858 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
859 struct wireless_dev *tmp;
863 *rdev = wiphy_to_rdev(wiphy);
866 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
867 if (tmp->identifier == cb->args[1]) {
880 /* message building helper */
881 void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
884 /* since there is no private header just add the generic one */
885 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
888 static int nl80211_msg_put_wmm_rules(struct sk_buff *msg,
889 const struct ieee80211_reg_rule *rule)
892 struct nlattr *nl_wmm_rules =
893 nla_nest_start_noflag(msg, NL80211_FREQUENCY_ATTR_WMM);
896 goto nla_put_failure;
898 for (j = 0; j < IEEE80211_NUM_ACS; j++) {
899 struct nlattr *nl_wmm_rule = nla_nest_start_noflag(msg, j);
902 goto nla_put_failure;
904 if (nla_put_u16(msg, NL80211_WMMR_CW_MIN,
905 rule->wmm_rule.client[j].cw_min) ||
906 nla_put_u16(msg, NL80211_WMMR_CW_MAX,
907 rule->wmm_rule.client[j].cw_max) ||
908 nla_put_u8(msg, NL80211_WMMR_AIFSN,
909 rule->wmm_rule.client[j].aifsn) ||
910 nla_put_u16(msg, NL80211_WMMR_TXOP,
911 rule->wmm_rule.client[j].cot))
912 goto nla_put_failure;
914 nla_nest_end(msg, nl_wmm_rule);
916 nla_nest_end(msg, nl_wmm_rules);
924 static int nl80211_msg_put_channel(struct sk_buff *msg, struct wiphy *wiphy,
925 struct ieee80211_channel *chan,
928 /* Some channels must be completely excluded from the
929 * list to protect old user-space tools from breaking
931 if (!large && chan->flags &
932 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
935 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
937 goto nla_put_failure;
939 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
940 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
941 goto nla_put_failure;
942 if (chan->flags & IEEE80211_CHAN_NO_IR) {
943 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
944 goto nla_put_failure;
945 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
946 goto nla_put_failure;
948 if (chan->flags & IEEE80211_CHAN_RADAR) {
949 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
950 goto nla_put_failure;
954 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
956 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
958 goto nla_put_failure;
959 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
961 goto nla_put_failure;
963 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
965 goto nla_put_failure;
970 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
971 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
972 goto nla_put_failure;
973 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
974 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
975 goto nla_put_failure;
976 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
977 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
978 goto nla_put_failure;
979 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
980 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
981 goto nla_put_failure;
982 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
983 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
984 goto nla_put_failure;
985 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
986 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
987 goto nla_put_failure;
988 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
989 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
990 goto nla_put_failure;
991 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
992 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
993 goto nla_put_failure;
994 if ((chan->flags & IEEE80211_CHAN_NO_HE) &&
995 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HE))
996 goto nla_put_failure;
999 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
1000 DBM_TO_MBM(chan->max_power)))
1001 goto nla_put_failure;
1004 const struct ieee80211_reg_rule *rule =
1005 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
1007 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) {
1008 if (nl80211_msg_put_wmm_rules(msg, rule))
1009 goto nla_put_failure;
1019 static bool nl80211_put_txq_stats(struct sk_buff *msg,
1020 struct cfg80211_txq_stats *txqstats,
1023 struct nlattr *txqattr;
1025 #define PUT_TXQVAL_U32(attr, memb) do { \
1026 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
1027 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
1031 txqattr = nla_nest_start_noflag(msg, attrtype);
1035 PUT_TXQVAL_U32(BACKLOG_BYTES, backlog_bytes);
1036 PUT_TXQVAL_U32(BACKLOG_PACKETS, backlog_packets);
1037 PUT_TXQVAL_U32(FLOWS, flows);
1038 PUT_TXQVAL_U32(DROPS, drops);
1039 PUT_TXQVAL_U32(ECN_MARKS, ecn_marks);
1040 PUT_TXQVAL_U32(OVERLIMIT, overlimit);
1041 PUT_TXQVAL_U32(OVERMEMORY, overmemory);
1042 PUT_TXQVAL_U32(COLLISIONS, collisions);
1043 PUT_TXQVAL_U32(TX_BYTES, tx_bytes);
1044 PUT_TXQVAL_U32(TX_PACKETS, tx_packets);
1045 PUT_TXQVAL_U32(MAX_FLOWS, max_flows);
1046 nla_nest_end(msg, txqattr);
1048 #undef PUT_TXQVAL_U32
1052 /* netlink command implementations */
1055 struct key_params p;
1058 bool def, defmgmt, defbeacon;
1059 bool def_uni, def_multi;
1062 static int nl80211_parse_key_new(struct genl_info *info, struct nlattr *key,
1063 struct key_parse *k)
1065 struct nlattr *tb[NL80211_KEY_MAX + 1];
1066 int err = nla_parse_nested_deprecated(tb, NL80211_KEY_MAX, key,
1072 k->def = !!tb[NL80211_KEY_DEFAULT];
1073 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
1074 k->defbeacon = !!tb[NL80211_KEY_DEFAULT_BEACON];
1078 k->def_multi = true;
1080 if (k->defmgmt || k->defbeacon)
1081 k->def_multi = true;
1083 if (tb[NL80211_KEY_IDX])
1084 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
1086 if (tb[NL80211_KEY_DATA]) {
1087 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
1088 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
1091 if (tb[NL80211_KEY_SEQ]) {
1092 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
1093 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
1096 if (tb[NL80211_KEY_CIPHER])
1097 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
1099 if (tb[NL80211_KEY_TYPE])
1100 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
1102 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
1103 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1105 err = nla_parse_nested_deprecated(kdt,
1106 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1107 tb[NL80211_KEY_DEFAULT_TYPES],
1108 nl80211_key_default_policy,
1113 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1114 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1117 if (tb[NL80211_KEY_MODE])
1118 k->p.mode = nla_get_u8(tb[NL80211_KEY_MODE]);
1123 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
1125 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
1126 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
1127 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
1130 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
1131 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
1132 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
1135 if (info->attrs[NL80211_ATTR_KEY_IDX])
1136 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1138 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
1139 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
1141 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
1142 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
1146 k->def_multi = true;
1149 k->def_multi = true;
1151 if (info->attrs[NL80211_ATTR_KEY_TYPE])
1152 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1154 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
1155 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1156 int err = nla_parse_nested_deprecated(kdt,
1157 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1158 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
1159 nl80211_key_default_policy,
1164 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1165 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1171 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
1175 memset(k, 0, sizeof(*k));
1179 if (info->attrs[NL80211_ATTR_KEY])
1180 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k);
1182 err = nl80211_parse_key_old(info, k);
1187 if ((k->def ? 1 : 0) + (k->defmgmt ? 1 : 0) +
1188 (k->defbeacon ? 1 : 0) > 1) {
1189 GENL_SET_ERR_MSG(info,
1190 "key with multiple default flags is invalid");
1194 if (k->defmgmt || k->defbeacon) {
1195 if (k->def_uni || !k->def_multi) {
1196 GENL_SET_ERR_MSG(info,
1197 "defmgmt/defbeacon key must be mcast");
1204 if (k->idx < 4 || k->idx > 5) {
1205 GENL_SET_ERR_MSG(info,
1206 "defmgmt key idx not 4 or 5");
1209 } else if (k->defbeacon) {
1210 if (k->idx < 6 || k->idx > 7) {
1211 GENL_SET_ERR_MSG(info,
1212 "defbeacon key idx not 6 or 7");
1215 } else if (k->def) {
1216 if (k->idx < 0 || k->idx > 3) {
1217 GENL_SET_ERR_MSG(info, "def key idx not 0-3");
1221 if (k->idx < 0 || k->idx > 7) {
1222 GENL_SET_ERR_MSG(info, "key idx not 0-7");
1231 static struct cfg80211_cached_keys *
1232 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
1233 struct genl_info *info, bool *no_ht)
1235 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS];
1236 struct key_parse parse;
1238 struct cfg80211_cached_keys *result;
1239 int rem, err, def = 0;
1240 bool have_key = false;
1242 nla_for_each_nested(key, keys, rem) {
1250 result = kzalloc(sizeof(*result), GFP_KERNEL);
1252 return ERR_PTR(-ENOMEM);
1256 nla_for_each_nested(key, keys, rem) {
1257 memset(&parse, 0, sizeof(parse));
1260 err = nl80211_parse_key_new(info, key, &parse);
1266 if (parse.idx < 0 || parse.idx > 3) {
1267 GENL_SET_ERR_MSG(info, "key index out of range [0-3]");
1272 GENL_SET_ERR_MSG(info,
1273 "only one key can be default");
1277 result->def = parse.idx;
1278 if (!parse.def_uni || !parse.def_multi)
1280 } else if (parse.defmgmt)
1282 err = cfg80211_validate_key_settings(rdev, &parse.p,
1283 parse.idx, false, NULL);
1286 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1287 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
1288 GENL_SET_ERR_MSG(info, "connect key must be WEP");
1292 result->params[parse.idx].cipher = parse.p.cipher;
1293 result->params[parse.idx].key_len = parse.p.key_len;
1294 result->params[parse.idx].key = result->data[parse.idx];
1295 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
1297 /* must be WEP key if we got here */
1302 if (result->def < 0) {
1304 GENL_SET_ERR_MSG(info, "need a default/TX key");
1311 return ERR_PTR(err);
1314 static int nl80211_key_allowed(struct wireless_dev *wdev)
1316 ASSERT_WDEV_LOCK(wdev);
1318 switch (wdev->iftype) {
1319 case NL80211_IFTYPE_AP:
1320 case NL80211_IFTYPE_AP_VLAN:
1321 case NL80211_IFTYPE_P2P_GO:
1322 case NL80211_IFTYPE_MESH_POINT:
1324 case NL80211_IFTYPE_ADHOC:
1325 case NL80211_IFTYPE_STATION:
1326 case NL80211_IFTYPE_P2P_CLIENT:
1327 if (!wdev->current_bss)
1330 case NL80211_IFTYPE_UNSPECIFIED:
1331 case NL80211_IFTYPE_OCB:
1332 case NL80211_IFTYPE_MONITOR:
1333 case NL80211_IFTYPE_NAN:
1334 case NL80211_IFTYPE_P2P_DEVICE:
1335 case NL80211_IFTYPE_WDS:
1336 case NUM_NL80211_IFTYPES:
1343 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
1346 struct ieee80211_channel *chan;
1350 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
1351 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1356 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1358 struct nlattr *nl_modes = nla_nest_start_noflag(msg, attr);
1362 goto nla_put_failure;
1366 if ((ifmodes & 1) && nla_put_flag(msg, i))
1367 goto nla_put_failure;
1372 nla_nest_end(msg, nl_modes);
1379 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
1380 struct sk_buff *msg,
1383 struct nlattr *nl_combis;
1386 nl_combis = nla_nest_start_noflag(msg,
1387 NL80211_ATTR_INTERFACE_COMBINATIONS);
1389 goto nla_put_failure;
1391 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1392 const struct ieee80211_iface_combination *c;
1393 struct nlattr *nl_combi, *nl_limits;
1395 c = &wiphy->iface_combinations[i];
1397 nl_combi = nla_nest_start_noflag(msg, i + 1);
1399 goto nla_put_failure;
1401 nl_limits = nla_nest_start_noflag(msg,
1402 NL80211_IFACE_COMB_LIMITS);
1404 goto nla_put_failure;
1406 for (j = 0; j < c->n_limits; j++) {
1407 struct nlattr *nl_limit;
1409 nl_limit = nla_nest_start_noflag(msg, j + 1);
1411 goto nla_put_failure;
1412 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1414 goto nla_put_failure;
1415 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1416 c->limits[j].types))
1417 goto nla_put_failure;
1418 nla_nest_end(msg, nl_limit);
1421 nla_nest_end(msg, nl_limits);
1423 if (c->beacon_int_infra_match &&
1424 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1425 goto nla_put_failure;
1426 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1427 c->num_different_channels) ||
1428 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1430 goto nla_put_failure;
1432 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1433 c->radar_detect_widths) ||
1434 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1435 c->radar_detect_regions)))
1436 goto nla_put_failure;
1437 if (c->beacon_int_min_gcd &&
1438 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1439 c->beacon_int_min_gcd))
1440 goto nla_put_failure;
1442 nla_nest_end(msg, nl_combi);
1445 nla_nest_end(msg, nl_combis);
1453 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1454 struct sk_buff *msg)
1456 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1457 struct nlattr *nl_tcp;
1462 nl_tcp = nla_nest_start_noflag(msg,
1463 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1467 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1468 tcp->data_payload_max))
1471 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1472 tcp->data_payload_max))
1475 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1478 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1479 sizeof(*tcp->tok), tcp->tok))
1482 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1483 tcp->data_interval_max))
1486 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1487 tcp->wake_payload_max))
1490 nla_nest_end(msg, nl_tcp);
1494 static int nl80211_send_wowlan(struct sk_buff *msg,
1495 struct cfg80211_registered_device *rdev,
1498 struct nlattr *nl_wowlan;
1500 if (!rdev->wiphy.wowlan)
1503 nl_wowlan = nla_nest_start_noflag(msg,
1504 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1508 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1509 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1510 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1511 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1512 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1513 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1514 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1515 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1516 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1517 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1518 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1519 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1520 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1521 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1522 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1523 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1526 if (rdev->wiphy.wowlan->n_patterns) {
1527 struct nl80211_pattern_support pat = {
1528 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1529 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1530 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1531 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1534 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1539 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1540 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1541 rdev->wiphy.wowlan->max_nd_match_sets))
1544 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
1547 nla_nest_end(msg, nl_wowlan);
1553 static int nl80211_send_coalesce(struct sk_buff *msg,
1554 struct cfg80211_registered_device *rdev)
1556 struct nl80211_coalesce_rule_support rule;
1558 if (!rdev->wiphy.coalesce)
1561 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1562 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1563 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1564 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1565 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1566 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1568 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1575 nl80211_send_iftype_data(struct sk_buff *msg,
1576 const struct ieee80211_sband_iftype_data *iftdata)
1578 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap;
1580 if (nl80211_put_iftypes(msg, NL80211_BAND_IFTYPE_ATTR_IFTYPES,
1581 iftdata->types_mask))
1584 if (he_cap->has_he) {
1585 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC,
1586 sizeof(he_cap->he_cap_elem.mac_cap_info),
1587 he_cap->he_cap_elem.mac_cap_info) ||
1588 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY,
1589 sizeof(he_cap->he_cap_elem.phy_cap_info),
1590 he_cap->he_cap_elem.phy_cap_info) ||
1591 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET,
1592 sizeof(he_cap->he_mcs_nss_supp),
1593 &he_cap->he_mcs_nss_supp) ||
1594 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE,
1595 sizeof(he_cap->ppe_thres), he_cap->ppe_thres))
1602 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1603 struct ieee80211_supported_band *sband)
1605 struct nlattr *nl_rates, *nl_rate;
1606 struct ieee80211_rate *rate;
1610 if (sband->ht_cap.ht_supported &&
1611 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1612 sizeof(sband->ht_cap.mcs),
1613 &sband->ht_cap.mcs) ||
1614 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1615 sband->ht_cap.cap) ||
1616 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1617 sband->ht_cap.ampdu_factor) ||
1618 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1619 sband->ht_cap.ampdu_density)))
1623 if (sband->vht_cap.vht_supported &&
1624 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1625 sizeof(sband->vht_cap.vht_mcs),
1626 &sband->vht_cap.vht_mcs) ||
1627 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1628 sband->vht_cap.cap)))
1631 if (sband->n_iftype_data) {
1632 struct nlattr *nl_iftype_data =
1633 nla_nest_start_noflag(msg,
1634 NL80211_BAND_ATTR_IFTYPE_DATA);
1637 if (!nl_iftype_data)
1640 for (i = 0; i < sband->n_iftype_data; i++) {
1641 struct nlattr *iftdata;
1643 iftdata = nla_nest_start_noflag(msg, i + 1);
1647 err = nl80211_send_iftype_data(msg,
1648 &sband->iftype_data[i]);
1652 nla_nest_end(msg, iftdata);
1655 nla_nest_end(msg, nl_iftype_data);
1659 if (sband->edmg_cap.channels &&
1660 (nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_CHANNELS,
1661 sband->edmg_cap.channels) ||
1662 nla_put_u8(msg, NL80211_BAND_ATTR_EDMG_BW_CONFIG,
1663 sband->edmg_cap.bw_config)))
1668 nl_rates = nla_nest_start_noflag(msg, NL80211_BAND_ATTR_RATES);
1672 for (i = 0; i < sband->n_bitrates; i++) {
1673 nl_rate = nla_nest_start_noflag(msg, i);
1677 rate = &sband->bitrates[i];
1678 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1681 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1683 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1686 nla_nest_end(msg, nl_rate);
1689 nla_nest_end(msg, nl_rates);
1695 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1696 const struct ieee80211_txrx_stypes *mgmt_stypes)
1699 struct nlattr *nl_ftypes, *nl_ifs;
1700 enum nl80211_iftype ift;
1706 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_TX_FRAME_TYPES);
1710 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1711 nl_ftypes = nla_nest_start_noflag(msg, ift);
1715 stypes = mgmt_stypes[ift].tx;
1718 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1719 (i << 4) | IEEE80211_FTYPE_MGMT))
1724 nla_nest_end(msg, nl_ftypes);
1727 nla_nest_end(msg, nl_ifs);
1729 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_RX_FRAME_TYPES);
1733 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1734 nl_ftypes = nla_nest_start_noflag(msg, ift);
1738 stypes = mgmt_stypes[ift].rx;
1741 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1742 (i << 4) | IEEE80211_FTYPE_MGMT))
1747 nla_nest_end(msg, nl_ftypes);
1749 nla_nest_end(msg, nl_ifs);
1754 #define CMD(op, n) \
1756 if (rdev->ops->op) { \
1758 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1759 goto nla_put_failure; \
1763 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1764 struct sk_buff *msg)
1769 * do *NOT* add anything into this function, new things need to be
1770 * advertised only to new versions of userspace that can deal with
1771 * the split (and they can't possibly care about new features...
1773 CMD(add_virtual_intf, NEW_INTERFACE);
1774 CMD(change_virtual_intf, SET_INTERFACE);
1775 CMD(add_key, NEW_KEY);
1776 CMD(start_ap, START_AP);
1777 CMD(add_station, NEW_STATION);
1778 CMD(add_mpath, NEW_MPATH);
1779 CMD(update_mesh_config, SET_MESH_CONFIG);
1780 CMD(change_bss, SET_BSS);
1781 CMD(auth, AUTHENTICATE);
1782 CMD(assoc, ASSOCIATE);
1783 CMD(deauth, DEAUTHENTICATE);
1784 CMD(disassoc, DISASSOCIATE);
1785 CMD(join_ibss, JOIN_IBSS);
1786 CMD(join_mesh, JOIN_MESH);
1787 CMD(set_pmksa, SET_PMKSA);
1788 CMD(del_pmksa, DEL_PMKSA);
1789 CMD(flush_pmksa, FLUSH_PMKSA);
1790 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1791 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1792 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1793 CMD(mgmt_tx, FRAME);
1794 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1795 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1797 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1798 goto nla_put_failure;
1800 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1801 rdev->ops->join_mesh) {
1803 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1804 goto nla_put_failure;
1806 CMD(set_wds_peer, SET_WDS_PEER);
1807 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1808 CMD(tdls_mgmt, TDLS_MGMT);
1809 CMD(tdls_oper, TDLS_OPER);
1811 if (rdev->wiphy.max_sched_scan_reqs)
1812 CMD(sched_scan_start, START_SCHED_SCAN);
1813 CMD(probe_client, PROBE_CLIENT);
1814 CMD(set_noack_map, SET_NOACK_MAP);
1815 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1817 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1818 goto nla_put_failure;
1820 CMD(start_p2p_device, START_P2P_DEVICE);
1821 CMD(set_mcast_rate, SET_MCAST_RATE);
1822 #ifdef CONFIG_NL80211_TESTMODE
1823 CMD(testmode_cmd, TESTMODE);
1826 if (rdev->ops->connect || rdev->ops->auth) {
1828 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1829 goto nla_put_failure;
1832 if (rdev->ops->disconnect || rdev->ops->deauth) {
1834 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1835 goto nla_put_failure;
1844 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities *cap,
1845 struct sk_buff *msg)
1849 if (!cap->ftm.supported)
1852 ftm = nla_nest_start_noflag(msg, NL80211_PMSR_TYPE_FTM);
1856 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP))
1858 if (cap->ftm.non_asap &&
1859 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP))
1861 if (cap->ftm.request_lci &&
1862 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI))
1864 if (cap->ftm.request_civicloc &&
1865 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC))
1867 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES,
1868 cap->ftm.preambles))
1870 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS,
1871 cap->ftm.bandwidths))
1873 if (cap->ftm.max_bursts_exponent >= 0 &&
1874 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT,
1875 cap->ftm.max_bursts_exponent))
1877 if (cap->ftm.max_ftms_per_burst &&
1878 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST,
1879 cap->ftm.max_ftms_per_burst))
1882 nla_nest_end(msg, ftm);
1886 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device *rdev,
1887 struct sk_buff *msg)
1889 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa;
1890 struct nlattr *pmsr, *caps;
1896 * we don't need to clean up anything here since the caller
1897 * will genlmsg_cancel() if we fail
1900 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS);
1904 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers))
1907 if (cap->report_ap_tsf &&
1908 nla_put_flag(msg, NL80211_PMSR_ATTR_REPORT_AP_TSF))
1911 if (cap->randomize_mac_addr &&
1912 nla_put_flag(msg, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR))
1915 caps = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_TYPE_CAPA);
1919 if (nl80211_send_pmsr_ftm_capa(cap, msg))
1922 nla_nest_end(msg, caps);
1923 nla_nest_end(msg, pmsr);
1929 nl80211_put_iftype_akm_suites(struct cfg80211_registered_device *rdev,
1930 struct sk_buff *msg)
1933 struct nlattr *nested, *nested_akms;
1934 const struct wiphy_iftype_akm_suites *iftype_akms;
1936 if (!rdev->wiphy.num_iftype_akm_suites ||
1937 !rdev->wiphy.iftype_akm_suites)
1940 nested = nla_nest_start(msg, NL80211_ATTR_IFTYPE_AKM_SUITES);
1944 for (i = 0; i < rdev->wiphy.num_iftype_akm_suites; i++) {
1945 nested_akms = nla_nest_start(msg, i + 1);
1949 iftype_akms = &rdev->wiphy.iftype_akm_suites[i];
1951 if (nl80211_put_iftypes(msg, NL80211_IFTYPE_AKM_ATTR_IFTYPES,
1952 iftype_akms->iftypes_mask))
1955 if (nla_put(msg, NL80211_IFTYPE_AKM_ATTR_SUITES,
1956 sizeof(u32) * iftype_akms->n_akm_suites,
1957 iftype_akms->akm_suites)) {
1960 nla_nest_end(msg, nested_akms);
1963 nla_nest_end(msg, nested);
1969 nl80211_put_tid_config_support(struct cfg80211_registered_device *rdev,
1970 struct sk_buff *msg)
1972 struct nlattr *supp;
1974 if (!rdev->wiphy.tid_config_support.vif &&
1975 !rdev->wiphy.tid_config_support.peer)
1978 supp = nla_nest_start(msg, NL80211_ATTR_TID_CONFIG);
1982 if (rdev->wiphy.tid_config_support.vif &&
1983 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_VIF_SUPP,
1984 rdev->wiphy.tid_config_support.vif,
1985 NL80211_TID_CONFIG_ATTR_PAD))
1988 if (rdev->wiphy.tid_config_support.peer &&
1989 nla_put_u64_64bit(msg, NL80211_TID_CONFIG_ATTR_PEER_SUPP,
1990 rdev->wiphy.tid_config_support.peer,
1991 NL80211_TID_CONFIG_ATTR_PAD))
1994 /* for now we just use the same value ... makes more sense */
1995 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_SHORT,
1996 rdev->wiphy.tid_config_support.max_retry))
1998 if (nla_put_u8(msg, NL80211_TID_CONFIG_ATTR_RETRY_LONG,
1999 rdev->wiphy.tid_config_support.max_retry))
2002 nla_nest_end(msg, supp);
2006 nla_nest_cancel(msg, supp);
2010 struct nl80211_dump_wiphy_state {
2013 long split_start, band_start, chan_start, capa_start;
2017 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
2018 enum nl80211_commands cmd,
2019 struct sk_buff *msg, u32 portid, u32 seq,
2020 int flags, struct nl80211_dump_wiphy_state *state)
2023 struct nlattr *nl_bands, *nl_band;
2024 struct nlattr *nl_freqs, *nl_freq;
2025 struct nlattr *nl_cmds;
2026 enum nl80211_band band;
2027 struct ieee80211_channel *chan;
2029 const struct ieee80211_txrx_stypes *mgmt_stypes =
2030 rdev->wiphy.mgmt_stypes;
2033 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
2037 if (WARN_ON(!state))
2040 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2041 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
2042 wiphy_name(&rdev->wiphy)) ||
2043 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2044 cfg80211_rdev_list_generation))
2045 goto nla_put_failure;
2047 if (cmd != NL80211_CMD_NEW_WIPHY)
2050 switch (state->split_start) {
2052 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
2053 rdev->wiphy.retry_short) ||
2054 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
2055 rdev->wiphy.retry_long) ||
2056 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
2057 rdev->wiphy.frag_threshold) ||
2058 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
2059 rdev->wiphy.rts_threshold) ||
2060 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
2061 rdev->wiphy.coverage_class) ||
2062 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
2063 rdev->wiphy.max_scan_ssids) ||
2064 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
2065 rdev->wiphy.max_sched_scan_ssids) ||
2066 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
2067 rdev->wiphy.max_scan_ie_len) ||
2068 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
2069 rdev->wiphy.max_sched_scan_ie_len) ||
2070 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
2071 rdev->wiphy.max_match_sets) ||
2072 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
2073 rdev->wiphy.max_sched_scan_plans) ||
2074 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
2075 rdev->wiphy.max_sched_scan_plan_interval) ||
2076 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
2077 rdev->wiphy.max_sched_scan_plan_iterations))
2078 goto nla_put_failure;
2080 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
2081 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
2082 goto nla_put_failure;
2083 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
2084 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
2085 goto nla_put_failure;
2086 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
2087 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
2088 goto nla_put_failure;
2089 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
2090 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
2091 goto nla_put_failure;
2092 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
2093 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
2094 goto nla_put_failure;
2095 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
2096 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
2097 goto nla_put_failure;
2098 state->split_start++;
2103 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
2104 sizeof(u32) * rdev->wiphy.n_cipher_suites,
2105 rdev->wiphy.cipher_suites))
2106 goto nla_put_failure;
2108 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
2109 rdev->wiphy.max_num_pmkids))
2110 goto nla_put_failure;
2112 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
2113 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
2114 goto nla_put_failure;
2116 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
2117 rdev->wiphy.available_antennas_tx) ||
2118 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
2119 rdev->wiphy.available_antennas_rx))
2120 goto nla_put_failure;
2122 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
2123 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
2124 rdev->wiphy.probe_resp_offload))
2125 goto nla_put_failure;
2127 if ((rdev->wiphy.available_antennas_tx ||
2128 rdev->wiphy.available_antennas_rx) &&
2129 rdev->ops->get_antenna) {
2130 u32 tx_ant = 0, rx_ant = 0;
2133 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
2135 if (nla_put_u32(msg,
2136 NL80211_ATTR_WIPHY_ANTENNA_TX,
2139 NL80211_ATTR_WIPHY_ANTENNA_RX,
2141 goto nla_put_failure;
2145 state->split_start++;
2150 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
2151 rdev->wiphy.interface_modes))
2152 goto nla_put_failure;
2153 state->split_start++;
2158 nl_bands = nla_nest_start_noflag(msg,
2159 NL80211_ATTR_WIPHY_BANDS);
2161 goto nla_put_failure;
2163 for (band = state->band_start;
2164 band < NUM_NL80211_BANDS; band++) {
2165 struct ieee80211_supported_band *sband;
2167 sband = rdev->wiphy.bands[band];
2172 nl_band = nla_nest_start_noflag(msg, band);
2174 goto nla_put_failure;
2176 switch (state->chan_start) {
2178 if (nl80211_send_band_rateinfo(msg, sband))
2179 goto nla_put_failure;
2180 state->chan_start++;
2185 /* add frequencies */
2186 nl_freqs = nla_nest_start_noflag(msg,
2187 NL80211_BAND_ATTR_FREQS);
2189 goto nla_put_failure;
2191 for (i = state->chan_start - 1;
2192 i < sband->n_channels;
2194 nl_freq = nla_nest_start_noflag(msg,
2197 goto nla_put_failure;
2199 chan = &sband->channels[i];
2201 if (nl80211_msg_put_channel(
2202 msg, &rdev->wiphy, chan,
2204 goto nla_put_failure;
2206 nla_nest_end(msg, nl_freq);
2210 if (i < sband->n_channels)
2211 state->chan_start = i + 2;
2213 state->chan_start = 0;
2214 nla_nest_end(msg, nl_freqs);
2217 nla_nest_end(msg, nl_band);
2220 /* start again here */
2221 if (state->chan_start)
2226 nla_nest_end(msg, nl_bands);
2228 if (band < NUM_NL80211_BANDS)
2229 state->band_start = band + 1;
2231 state->band_start = 0;
2233 /* if bands & channels are done, continue outside */
2234 if (state->band_start == 0 && state->chan_start == 0)
2235 state->split_start++;
2240 nl_cmds = nla_nest_start_noflag(msg,
2241 NL80211_ATTR_SUPPORTED_COMMANDS);
2243 goto nla_put_failure;
2245 i = nl80211_add_commands_unsplit(rdev, msg);
2247 goto nla_put_failure;
2249 CMD(crit_proto_start, CRIT_PROTOCOL_START);
2250 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
2251 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
2252 CMD(channel_switch, CHANNEL_SWITCH);
2253 CMD(set_qos_map, SET_QOS_MAP);
2254 if (rdev->wiphy.features &
2255 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
2256 CMD(add_tx_ts, ADD_TX_TS);
2257 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
2258 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
2259 CMD(update_ft_ies, UPDATE_FT_IES);
2263 nla_nest_end(msg, nl_cmds);
2264 state->split_start++;
2269 if (rdev->ops->remain_on_channel &&
2270 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
2272 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
2273 rdev->wiphy.max_remain_on_channel_duration))
2274 goto nla_put_failure;
2276 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
2277 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
2278 goto nla_put_failure;
2280 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
2281 goto nla_put_failure;
2282 state->split_start++;
2288 if (nl80211_send_wowlan(msg, rdev, state->split))
2289 goto nla_put_failure;
2290 state->split_start++;
2294 state->split_start++;
2298 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
2299 rdev->wiphy.software_iftypes))
2300 goto nla_put_failure;
2302 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
2304 goto nla_put_failure;
2306 state->split_start++;
2311 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
2312 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
2313 rdev->wiphy.ap_sme_capa))
2314 goto nla_put_failure;
2316 features = rdev->wiphy.features;
2318 * We can only add the per-channel limit information if the
2319 * dump is split, otherwise it makes it too big. Therefore
2320 * only advertise it in that case.
2323 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
2324 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
2325 goto nla_put_failure;
2327 if (rdev->wiphy.ht_capa_mod_mask &&
2328 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
2329 sizeof(*rdev->wiphy.ht_capa_mod_mask),
2330 rdev->wiphy.ht_capa_mod_mask))
2331 goto nla_put_failure;
2333 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
2334 rdev->wiphy.max_acl_mac_addrs &&
2335 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
2336 rdev->wiphy.max_acl_mac_addrs))
2337 goto nla_put_failure;
2340 * Any information below this point is only available to
2341 * applications that can deal with it being split. This
2342 * helps ensure that newly added capabilities don't break
2343 * older tools by overrunning their buffers.
2345 * We still increment split_start so that in the split
2346 * case we'll continue with more data in the next round,
2347 * but break unconditionally so unsplit data stops here.
2349 state->split_start++;
2352 if (rdev->wiphy.extended_capabilities &&
2353 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
2354 rdev->wiphy.extended_capabilities_len,
2355 rdev->wiphy.extended_capabilities) ||
2356 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2357 rdev->wiphy.extended_capabilities_len,
2358 rdev->wiphy.extended_capabilities_mask)))
2359 goto nla_put_failure;
2361 if (rdev->wiphy.vht_capa_mod_mask &&
2362 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
2363 sizeof(*rdev->wiphy.vht_capa_mod_mask),
2364 rdev->wiphy.vht_capa_mod_mask))
2365 goto nla_put_failure;
2367 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
2368 rdev->wiphy.perm_addr))
2369 goto nla_put_failure;
2371 if (!is_zero_ether_addr(rdev->wiphy.addr_mask) &&
2372 nla_put(msg, NL80211_ATTR_MAC_MASK, ETH_ALEN,
2373 rdev->wiphy.addr_mask))
2374 goto nla_put_failure;
2376 if (rdev->wiphy.n_addresses > 1) {
2379 attr = nla_nest_start(msg, NL80211_ATTR_MAC_ADDRS);
2381 goto nla_put_failure;
2383 for (i = 0; i < rdev->wiphy.n_addresses; i++)
2384 if (nla_put(msg, i + 1, ETH_ALEN,
2385 rdev->wiphy.addresses[i].addr))
2386 goto nla_put_failure;
2388 nla_nest_end(msg, attr);
2391 state->split_start++;
2394 if (nl80211_send_coalesce(msg, rdev))
2395 goto nla_put_failure;
2397 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
2398 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
2399 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
2400 goto nla_put_failure;
2402 if (rdev->wiphy.max_ap_assoc_sta &&
2403 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
2404 rdev->wiphy.max_ap_assoc_sta))
2405 goto nla_put_failure;
2407 state->split_start++;
2410 if (rdev->wiphy.n_vendor_commands) {
2411 const struct nl80211_vendor_cmd_info *info;
2412 struct nlattr *nested;
2414 nested = nla_nest_start_noflag(msg,
2415 NL80211_ATTR_VENDOR_DATA);
2417 goto nla_put_failure;
2419 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
2420 info = &rdev->wiphy.vendor_commands[i].info;
2421 if (nla_put(msg, i + 1, sizeof(*info), info))
2422 goto nla_put_failure;
2424 nla_nest_end(msg, nested);
2427 if (rdev->wiphy.n_vendor_events) {
2428 const struct nl80211_vendor_cmd_info *info;
2429 struct nlattr *nested;
2431 nested = nla_nest_start_noflag(msg,
2432 NL80211_ATTR_VENDOR_EVENTS);
2434 goto nla_put_failure;
2436 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
2437 info = &rdev->wiphy.vendor_events[i];
2438 if (nla_put(msg, i + 1, sizeof(*info), info))
2439 goto nla_put_failure;
2441 nla_nest_end(msg, nested);
2443 state->split_start++;
2446 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
2447 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
2448 rdev->wiphy.max_num_csa_counters))
2449 goto nla_put_failure;
2451 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2452 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
2453 goto nla_put_failure;
2455 if (rdev->wiphy.max_sched_scan_reqs &&
2456 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
2457 rdev->wiphy.max_sched_scan_reqs))
2458 goto nla_put_failure;
2460 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
2461 sizeof(rdev->wiphy.ext_features),
2462 rdev->wiphy.ext_features))
2463 goto nla_put_failure;
2465 if (rdev->wiphy.bss_select_support) {
2466 struct nlattr *nested;
2467 u32 bss_select_support = rdev->wiphy.bss_select_support;
2469 nested = nla_nest_start_noflag(msg,
2470 NL80211_ATTR_BSS_SELECT);
2472 goto nla_put_failure;
2475 while (bss_select_support) {
2476 if ((bss_select_support & 1) &&
2477 nla_put_flag(msg, i))
2478 goto nla_put_failure;
2480 bss_select_support >>= 1;
2482 nla_nest_end(msg, nested);
2485 state->split_start++;
2488 if (rdev->wiphy.num_iftype_ext_capab &&
2489 rdev->wiphy.iftype_ext_capab) {
2490 struct nlattr *nested_ext_capab, *nested;
2492 nested = nla_nest_start_noflag(msg,
2493 NL80211_ATTR_IFTYPE_EXT_CAPA);
2495 goto nla_put_failure;
2497 for (i = state->capa_start;
2498 i < rdev->wiphy.num_iftype_ext_capab; i++) {
2499 const struct wiphy_iftype_ext_capab *capab;
2501 capab = &rdev->wiphy.iftype_ext_capab[i];
2503 nested_ext_capab = nla_nest_start_noflag(msg,
2505 if (!nested_ext_capab ||
2506 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
2508 nla_put(msg, NL80211_ATTR_EXT_CAPA,
2509 capab->extended_capabilities_len,
2510 capab->extended_capabilities) ||
2511 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2512 capab->extended_capabilities_len,
2513 capab->extended_capabilities_mask))
2514 goto nla_put_failure;
2516 nla_nest_end(msg, nested_ext_capab);
2520 nla_nest_end(msg, nested);
2521 if (i < rdev->wiphy.num_iftype_ext_capab) {
2522 state->capa_start = i + 1;
2527 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
2528 rdev->wiphy.nan_supported_bands))
2529 goto nla_put_failure;
2531 if (wiphy_ext_feature_isset(&rdev->wiphy,
2532 NL80211_EXT_FEATURE_TXQS)) {
2533 struct cfg80211_txq_stats txqstats = {};
2536 res = rdev_get_txq_stats(rdev, NULL, &txqstats);
2538 !nl80211_put_txq_stats(msg, &txqstats,
2539 NL80211_ATTR_TXQ_STATS))
2540 goto nla_put_failure;
2542 if (nla_put_u32(msg, NL80211_ATTR_TXQ_LIMIT,
2543 rdev->wiphy.txq_limit))
2544 goto nla_put_failure;
2545 if (nla_put_u32(msg, NL80211_ATTR_TXQ_MEMORY_LIMIT,
2546 rdev->wiphy.txq_memory_limit))
2547 goto nla_put_failure;
2548 if (nla_put_u32(msg, NL80211_ATTR_TXQ_QUANTUM,
2549 rdev->wiphy.txq_quantum))
2550 goto nla_put_failure;
2553 state->split_start++;
2556 if (nl80211_send_pmsr_capa(rdev, msg))
2557 goto nla_put_failure;
2559 state->split_start++;
2562 if (rdev->wiphy.akm_suites &&
2563 nla_put(msg, NL80211_ATTR_AKM_SUITES,
2564 sizeof(u32) * rdev->wiphy.n_akm_suites,
2565 rdev->wiphy.akm_suites))
2566 goto nla_put_failure;
2568 if (nl80211_put_iftype_akm_suites(rdev, msg))
2569 goto nla_put_failure;
2571 if (nl80211_put_tid_config_support(rdev, msg))
2572 goto nla_put_failure;
2575 state->split_start = 0;
2579 genlmsg_end(msg, hdr);
2583 genlmsg_cancel(msg, hdr);
2587 static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
2588 struct netlink_callback *cb,
2589 struct nl80211_dump_wiphy_state *state)
2591 struct nlattr **tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
2597 ret = nlmsg_parse_deprecated(cb->nlh,
2598 GENL_HDRLEN + nl80211_fam.hdrsize,
2599 tb, nl80211_fam.maxattr,
2600 nl80211_policy, NULL);
2601 /* ignore parse errors for backward compatibility */
2607 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
2608 if (tb[NL80211_ATTR_WIPHY])
2609 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2610 if (tb[NL80211_ATTR_WDEV])
2611 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
2612 if (tb[NL80211_ATTR_IFINDEX]) {
2613 struct net_device *netdev;
2614 struct cfg80211_registered_device *rdev;
2615 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
2617 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
2622 if (netdev->ieee80211_ptr) {
2623 rdev = wiphy_to_rdev(
2624 netdev->ieee80211_ptr->wiphy);
2625 state->filter_wiphy = rdev->wiphy_idx;
2635 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
2638 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
2639 struct cfg80211_registered_device *rdev;
2643 state = kzalloc(sizeof(*state), GFP_KERNEL);
2648 state->filter_wiphy = -1;
2649 ret = nl80211_dump_wiphy_parse(skb, cb, state);
2655 cb->args[0] = (long)state;
2658 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2659 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2661 if (++idx <= state->start)
2663 if (state->filter_wiphy != -1 &&
2664 state->filter_wiphy != rdev->wiphy_idx)
2666 /* attempt to fit multiple wiphy data chunks into the skb */
2668 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
2670 NETLINK_CB(cb->skb).portid,
2672 NLM_F_MULTI, state);
2675 * If sending the wiphy data didn't fit (ENOBUFS
2676 * or EMSGSIZE returned), this SKB is still
2677 * empty (so it's not too big because another
2678 * wiphy dataset is already in the skb) and
2679 * we've not tried to adjust the dump allocation
2680 * yet ... then adjust the alloc size to be
2681 * bigger, and return 1 but with the empty skb.
2682 * This results in an empty message being RX'ed
2683 * in userspace, but that is ignored.
2685 * We can then retry with the larger buffer.
2687 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
2688 !skb->len && !state->split &&
2689 cb->min_dump_alloc < 4096) {
2690 cb->min_dump_alloc = 4096;
2691 state->split_start = 0;
2698 } while (state->split_start > 0);
2708 static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2710 kfree((void *)cb->args[0]);
2714 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2716 struct sk_buff *msg;
2717 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2718 struct nl80211_dump_wiphy_state state = {};
2720 msg = nlmsg_new(4096, GFP_KERNEL);
2724 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2725 info->snd_portid, info->snd_seq, 0,
2731 return genlmsg_reply(msg, info);
2734 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2735 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2736 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2737 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2738 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2739 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2742 static int parse_txq_params(struct nlattr *tb[],
2743 struct ieee80211_txq_params *txq_params)
2747 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
2748 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2749 !tb[NL80211_TXQ_ATTR_AIFS])
2752 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
2753 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2754 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2755 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2756 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2758 if (ac >= NL80211_NUM_ACS)
2760 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
2764 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2767 * You can only set the channel explicitly for WDS interfaces,
2768 * all others have their channel managed via their respective
2769 * "establish a connection" command (connect, join, ...)
2771 * For AP/GO and mesh mode, the channel can be set with the
2772 * channel userspace API, but is only stored and passed to the
2773 * low-level driver when the AP starts or the mesh is joined.
2774 * This is for backward compatibility, userspace can also give
2775 * the channel in the start-ap or join-mesh commands instead.
2777 * Monitors are special as they are normally slaved to
2778 * whatever else is going on, so they have their own special
2779 * operation to set the monitor channel if possible.
2782 wdev->iftype == NL80211_IFTYPE_AP ||
2783 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
2784 wdev->iftype == NL80211_IFTYPE_MONITOR ||
2785 wdev->iftype == NL80211_IFTYPE_P2P_GO;
2788 int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
2789 struct genl_info *info,
2790 struct cfg80211_chan_def *chandef)
2792 struct netlink_ext_ack *extack = info->extack;
2793 struct nlattr **attrs = info->attrs;
2796 if (!attrs[NL80211_ATTR_WIPHY_FREQ])
2799 control_freq = nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]);
2801 memset(chandef, 0, sizeof(*chandef));
2803 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
2804 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2805 chandef->center_freq1 = control_freq;
2806 chandef->center_freq2 = 0;
2808 /* Primary channel not allowed */
2809 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED) {
2810 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ],
2811 "Channel is disabled");
2815 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2816 enum nl80211_channel_type chantype;
2818 chantype = nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
2821 case NL80211_CHAN_NO_HT:
2822 case NL80211_CHAN_HT20:
2823 case NL80211_CHAN_HT40PLUS:
2824 case NL80211_CHAN_HT40MINUS:
2825 cfg80211_chandef_create(chandef, chandef->chan,
2827 /* user input for center_freq is incorrect */
2828 if (attrs[NL80211_ATTR_CENTER_FREQ1] &&
2829 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) {
2830 NL_SET_ERR_MSG_ATTR(extack,
2831 attrs[NL80211_ATTR_CENTER_FREQ1],
2832 "bad center frequency 1");
2835 /* center_freq2 must be zero */
2836 if (attrs[NL80211_ATTR_CENTER_FREQ2] &&
2837 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2])) {
2838 NL_SET_ERR_MSG_ATTR(extack,
2839 attrs[NL80211_ATTR_CENTER_FREQ2],
2840 "center frequency 2 can't be used");
2845 NL_SET_ERR_MSG_ATTR(extack,
2846 attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
2847 "invalid channel type");
2850 } else if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
2852 nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]);
2853 if (attrs[NL80211_ATTR_CENTER_FREQ1])
2854 chandef->center_freq1 =
2855 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]);
2856 if (attrs[NL80211_ATTR_CENTER_FREQ2])
2857 chandef->center_freq2 =
2858 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]);
2861 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
2862 chandef->edmg.channels =
2863 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
2865 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
2866 chandef->edmg.bw_config =
2867 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
2869 chandef->edmg.bw_config = 0;
2870 chandef->edmg.channels = 0;
2873 if (!cfg80211_chandef_valid(chandef)) {
2874 NL_SET_ERR_MSG(extack, "invalid channel definition");
2878 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
2879 IEEE80211_CHAN_DISABLED)) {
2880 NL_SET_ERR_MSG(extack, "(extension) channel is disabled");
2884 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
2885 chandef->width == NL80211_CHAN_WIDTH_10) &&
2886 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) {
2887 NL_SET_ERR_MSG(extack, "5/10 MHz not supported");
2894 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
2895 struct net_device *dev,
2896 struct genl_info *info)
2898 struct cfg80211_chan_def chandef;
2900 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
2901 struct wireless_dev *wdev = NULL;
2904 wdev = dev->ieee80211_ptr;
2905 if (!nl80211_can_set_dev_channel(wdev))
2908 iftype = wdev->iftype;
2910 result = nl80211_parse_chandef(rdev, info, &chandef);
2915 case NL80211_IFTYPE_AP:
2916 case NL80211_IFTYPE_P2P_GO:
2917 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
2922 if (wdev->beacon_interval) {
2923 if (!dev || !rdev->ops->set_ap_chanwidth ||
2924 !(rdev->wiphy.features &
2925 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2930 /* Only allow dynamic channel width changes */
2931 if (chandef.chan != wdev->preset_chandef.chan) {
2935 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2939 wdev->preset_chandef = chandef;
2942 case NL80211_IFTYPE_MESH_POINT:
2943 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
2945 case NL80211_IFTYPE_MONITOR:
2946 result = cfg80211_set_monitor_channel(rdev, &chandef);
2955 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2957 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2958 struct net_device *netdev = info->user_ptr[1];
2960 return __nl80211_set_channel(rdev, netdev, info);
2963 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2965 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2966 struct net_device *dev = info->user_ptr[1];
2967 struct wireless_dev *wdev = dev->ieee80211_ptr;
2970 if (!info->attrs[NL80211_ATTR_MAC])
2973 if (netif_running(dev))
2976 if (!rdev->ops->set_wds_peer)
2979 if (wdev->iftype != NL80211_IFTYPE_WDS)
2982 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
2983 return rdev_set_wds_peer(rdev, dev, bssid);
2986 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2988 struct cfg80211_registered_device *rdev;
2989 struct net_device *netdev = NULL;
2990 struct wireless_dev *wdev;
2991 int result = 0, rem_txq_params = 0;
2992 struct nlattr *nl_txq_params;
2994 u8 retry_short = 0, retry_long = 0;
2995 u32 frag_threshold = 0, rts_threshold = 0;
2996 u8 coverage_class = 0;
2997 u32 txq_limit = 0, txq_memory_limit = 0, txq_quantum = 0;
3002 * Try to find the wiphy and netdev. Normally this
3003 * function shouldn't need the netdev, but this is
3004 * done for backward compatibility -- previously
3005 * setting the channel was done per wiphy, but now
3006 * it is per netdev. Previous userland like hostapd
3007 * also passed a netdev to set_wiphy, so that it is
3008 * possible to let that go to the right netdev!
3011 if (info->attrs[NL80211_ATTR_IFINDEX]) {
3012 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
3014 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
3015 if (netdev && netdev->ieee80211_ptr)
3016 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
3022 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
3025 return PTR_ERR(rdev);
3030 wdev = netdev->ieee80211_ptr;
3033 * end workaround code, by now the rdev is available
3034 * and locked, and wdev may or may not be NULL.
3037 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
3038 result = cfg80211_dev_rename(
3039 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
3044 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
3045 struct ieee80211_txq_params txq_params;
3046 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
3048 if (!rdev->ops->set_txq_params)
3054 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3055 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3058 if (!netif_running(netdev))
3061 nla_for_each_nested(nl_txq_params,
3062 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
3064 result = nla_parse_nested_deprecated(tb,
3065 NL80211_TXQ_ATTR_MAX,
3071 result = parse_txq_params(tb, &txq_params);
3075 result = rdev_set_txq_params(rdev, netdev,
3082 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3083 result = __nl80211_set_channel(
3085 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
3091 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
3092 struct wireless_dev *txp_wdev = wdev;
3093 enum nl80211_tx_power_setting type;
3096 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
3099 if (!rdev->ops->set_tx_power)
3102 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
3103 type = nla_get_u32(info->attrs[idx]);
3105 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
3106 (type != NL80211_TX_POWER_AUTOMATIC))
3109 if (type != NL80211_TX_POWER_AUTOMATIC) {
3110 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
3111 mbm = nla_get_u32(info->attrs[idx]);
3114 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
3119 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
3120 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
3123 if ((!rdev->wiphy.available_antennas_tx &&
3124 !rdev->wiphy.available_antennas_rx) ||
3125 !rdev->ops->set_antenna)
3128 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
3129 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
3131 /* reject antenna configurations which don't match the
3132 * available antenna masks, except for the "all" mask */
3133 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
3134 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
3137 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
3138 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
3140 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
3147 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
3148 retry_short = nla_get_u8(
3149 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
3151 changed |= WIPHY_PARAM_RETRY_SHORT;
3154 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
3155 retry_long = nla_get_u8(
3156 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
3158 changed |= WIPHY_PARAM_RETRY_LONG;
3161 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
3162 frag_threshold = nla_get_u32(
3163 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
3164 if (frag_threshold < 256)
3167 if (frag_threshold != (u32) -1) {
3169 * Fragments (apart from the last one) are required to
3170 * have even length. Make the fragmentation code
3171 * simpler by stripping LSB should someone try to use
3172 * odd threshold value.
3174 frag_threshold &= ~0x1;
3176 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
3179 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
3180 rts_threshold = nla_get_u32(
3181 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
3182 changed |= WIPHY_PARAM_RTS_THRESHOLD;
3185 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
3186 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
3189 coverage_class = nla_get_u8(
3190 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
3191 changed |= WIPHY_PARAM_COVERAGE_CLASS;
3194 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
3195 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
3198 changed |= WIPHY_PARAM_DYN_ACK;
3201 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) {
3202 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3203 NL80211_EXT_FEATURE_TXQS))
3205 txq_limit = nla_get_u32(
3206 info->attrs[NL80211_ATTR_TXQ_LIMIT]);
3207 changed |= WIPHY_PARAM_TXQ_LIMIT;
3210 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) {
3211 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3212 NL80211_EXT_FEATURE_TXQS))
3214 txq_memory_limit = nla_get_u32(
3215 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]);
3216 changed |= WIPHY_PARAM_TXQ_MEMORY_LIMIT;
3219 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) {
3220 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3221 NL80211_EXT_FEATURE_TXQS))
3223 txq_quantum = nla_get_u32(
3224 info->attrs[NL80211_ATTR_TXQ_QUANTUM]);
3225 changed |= WIPHY_PARAM_TXQ_QUANTUM;
3229 u8 old_retry_short, old_retry_long;
3230 u32 old_frag_threshold, old_rts_threshold;
3231 u8 old_coverage_class;
3232 u32 old_txq_limit, old_txq_memory_limit, old_txq_quantum;
3234 if (!rdev->ops->set_wiphy_params)
3237 old_retry_short = rdev->wiphy.retry_short;
3238 old_retry_long = rdev->wiphy.retry_long;
3239 old_frag_threshold = rdev->wiphy.frag_threshold;
3240 old_rts_threshold = rdev->wiphy.rts_threshold;
3241 old_coverage_class = rdev->wiphy.coverage_class;
3242 old_txq_limit = rdev->wiphy.txq_limit;
3243 old_txq_memory_limit = rdev->wiphy.txq_memory_limit;
3244 old_txq_quantum = rdev->wiphy.txq_quantum;
3246 if (changed & WIPHY_PARAM_RETRY_SHORT)
3247 rdev->wiphy.retry_short = retry_short;
3248 if (changed & WIPHY_PARAM_RETRY_LONG)
3249 rdev->wiphy.retry_long = retry_long;
3250 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
3251 rdev->wiphy.frag_threshold = frag_threshold;
3252 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
3253 rdev->wiphy.rts_threshold = rts_threshold;
3254 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
3255 rdev->wiphy.coverage_class = coverage_class;
3256 if (changed & WIPHY_PARAM_TXQ_LIMIT)
3257 rdev->wiphy.txq_limit = txq_limit;
3258 if (changed & WIPHY_PARAM_TXQ_MEMORY_LIMIT)
3259 rdev->wiphy.txq_memory_limit = txq_memory_limit;
3260 if (changed & WIPHY_PARAM_TXQ_QUANTUM)
3261 rdev->wiphy.txq_quantum = txq_quantum;
3263 result = rdev_set_wiphy_params(rdev, changed);
3265 rdev->wiphy.retry_short = old_retry_short;
3266 rdev->wiphy.retry_long = old_retry_long;
3267 rdev->wiphy.frag_threshold = old_frag_threshold;
3268 rdev->wiphy.rts_threshold = old_rts_threshold;
3269 rdev->wiphy.coverage_class = old_coverage_class;
3270 rdev->wiphy.txq_limit = old_txq_limit;
3271 rdev->wiphy.txq_memory_limit = old_txq_memory_limit;
3272 rdev->wiphy.txq_quantum = old_txq_quantum;
3279 static int nl80211_send_chandef(struct sk_buff *msg,
3280 const struct cfg80211_chan_def *chandef)
3282 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3285 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
3286 chandef->chan->center_freq))
3288 switch (chandef->width) {
3289 case NL80211_CHAN_WIDTH_20_NOHT:
3290 case NL80211_CHAN_WIDTH_20:
3291 case NL80211_CHAN_WIDTH_40:
3292 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
3293 cfg80211_get_chandef_type(chandef)))
3299 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
3301 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
3303 if (chandef->center_freq2 &&
3304 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
3309 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
3310 struct cfg80211_registered_device *rdev,
3311 struct wireless_dev *wdev,
3312 enum nl80211_commands cmd)
3314 struct net_device *dev = wdev->netdev;
3317 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
3318 cmd != NL80211_CMD_DEL_INTERFACE &&
3319 cmd != NL80211_CMD_SET_INTERFACE);
3321 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3326 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3327 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
3328 goto nla_put_failure;
3330 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3331 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
3332 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
3333 NL80211_ATTR_PAD) ||
3334 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
3335 nla_put_u32(msg, NL80211_ATTR_GENERATION,
3336 rdev->devlist_generation ^
3337 (cfg80211_rdev_list_generation << 2)) ||
3338 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr))
3339 goto nla_put_failure;
3341 if (rdev->ops->get_channel) {
3343 struct cfg80211_chan_def chandef = {};
3345 ret = rdev_get_channel(rdev, wdev, &chandef);
3347 if (nl80211_send_chandef(msg, &chandef))
3348 goto nla_put_failure;
3352 if (rdev->ops->get_tx_power) {
3355 ret = rdev_get_tx_power(rdev, wdev, &dbm);
3357 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
3359 goto nla_put_failure;
3363 switch (wdev->iftype) {
3364 case NL80211_IFTYPE_AP:
3365 if (wdev->ssid_len &&
3366 nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
3367 goto nla_put_failure_locked;
3369 case NL80211_IFTYPE_STATION:
3370 case NL80211_IFTYPE_P2P_CLIENT:
3371 case NL80211_IFTYPE_ADHOC: {
3373 if (!wdev->current_bss)
3376 ssid_ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
3379 nla_put(msg, NL80211_ATTR_SSID, ssid_ie[1], ssid_ie + 2))
3380 goto nla_put_failure_rcu_locked;
3390 if (rdev->ops->get_txq_stats) {
3391 struct cfg80211_txq_stats txqstats = {};
3392 int ret = rdev_get_txq_stats(rdev, wdev, &txqstats);
3395 !nl80211_put_txq_stats(msg, &txqstats,
3396 NL80211_ATTR_TXQ_STATS))
3397 goto nla_put_failure;
3400 genlmsg_end(msg, hdr);
3403 nla_put_failure_rcu_locked:
3405 nla_put_failure_locked:
3408 genlmsg_cancel(msg, hdr);
3412 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
3416 int wp_start = cb->args[0];
3417 int if_start = cb->args[1];
3418 int filter_wiphy = -1;
3419 struct cfg80211_registered_device *rdev;
3420 struct wireless_dev *wdev;
3425 struct nl80211_dump_wiphy_state state = {
3429 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
3433 filter_wiphy = state.filter_wiphy;
3436 * if filtering, set cb->args[2] to +1 since 0 is the default
3437 * value needed to determine that parsing is necessary.
3439 if (filter_wiphy >= 0)
3440 cb->args[2] = filter_wiphy + 1;
3443 } else if (cb->args[2] > 0) {
3444 filter_wiphy = cb->args[2] - 1;
3447 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3448 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3450 if (wp_idx < wp_start) {
3455 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
3460 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3461 if (if_idx < if_start) {
3465 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
3466 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3468 NL80211_CMD_NEW_INTERFACE) < 0) {
3477 cb->args[0] = wp_idx;
3478 cb->args[1] = if_idx;
3487 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
3489 struct sk_buff *msg;
3490 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3491 struct wireless_dev *wdev = info->user_ptr[1];
3493 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3497 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3498 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3503 return genlmsg_reply(msg, info);
3506 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
3507 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
3508 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
3509 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
3510 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
3511 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
3512 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
3515 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
3517 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
3525 if (nla_parse_nested_deprecated(flags, NL80211_MNTR_FLAG_MAX, nla, mntr_flags_policy, NULL))
3528 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
3530 *mntrflags |= (1<<flag);
3532 *mntrflags |= MONITOR_FLAG_CHANGED;
3537 static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
3538 enum nl80211_iftype type,
3539 struct genl_info *info,
3540 struct vif_params *params)
3542 bool change = false;
3545 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
3546 if (type != NL80211_IFTYPE_MONITOR)
3549 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
3557 if (params->flags & MONITOR_FLAG_ACTIVE &&
3558 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
3561 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
3562 const u8 *mumimo_groups;
3563 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3565 if (type != NL80211_IFTYPE_MONITOR)
3568 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3572 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
3574 /* bits 0 and 63 are reserved and must be zero */
3575 if ((mumimo_groups[0] & BIT(0)) ||
3576 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
3579 params->vht_mumimo_groups = mumimo_groups;
3583 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
3584 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3586 if (type != NL80211_IFTYPE_MONITOR)
3589 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3592 params->vht_mumimo_follow_addr =
3593 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
3597 return change ? 1 : 0;
3600 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
3601 struct net_device *netdev, u8 use_4addr,
3602 enum nl80211_iftype iftype)
3605 if (netdev && netif_is_bridge_port(netdev))
3611 case NL80211_IFTYPE_AP_VLAN:
3612 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
3615 case NL80211_IFTYPE_STATION:
3616 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
3626 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
3628 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3629 struct vif_params params;
3631 enum nl80211_iftype otype, ntype;
3632 struct net_device *dev = info->user_ptr[1];
3633 bool change = false;
3635 memset(¶ms, 0, sizeof(params));
3637 otype = ntype = dev->ieee80211_ptr->iftype;
3639 if (info->attrs[NL80211_ATTR_IFTYPE]) {
3640 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3645 if (info->attrs[NL80211_ATTR_MESH_ID]) {
3646 struct wireless_dev *wdev = dev->ieee80211_ptr;
3648 if (ntype != NL80211_IFTYPE_MESH_POINT)
3650 if (netif_running(dev))
3654 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3655 IEEE80211_MAX_MESH_ID_LEN);
3656 wdev->mesh_id_up_len =
3657 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3658 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3659 wdev->mesh_id_up_len);
3663 if (info->attrs[NL80211_ATTR_4ADDR]) {
3664 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3666 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
3670 params.use_4addr = -1;
3673 err = nl80211_parse_mon_options(rdev, ntype, info, ¶ms);
3680 err = cfg80211_change_iface(rdev, dev, ntype, ¶ms);
3684 if (!err && params.use_4addr != -1)
3685 dev->ieee80211_ptr->use_4addr = params.use_4addr;
3687 if (change && !err) {
3688 struct wireless_dev *wdev = dev->ieee80211_ptr;
3690 nl80211_notify_iface(rdev, wdev, NL80211_CMD_SET_INTERFACE);
3696 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
3698 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3699 struct vif_params params;
3700 struct wireless_dev *wdev;
3701 struct sk_buff *msg;
3703 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
3705 /* to avoid failing a new interface creation due to pending removal */
3706 cfg80211_destroy_ifaces(rdev);
3708 memset(¶ms, 0, sizeof(params));
3710 if (!info->attrs[NL80211_ATTR_IFNAME])
3713 if (info->attrs[NL80211_ATTR_IFTYPE])
3714 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3716 if (!rdev->ops->add_virtual_intf)
3719 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
3720 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
3721 info->attrs[NL80211_ATTR_MAC]) {
3722 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
3724 if (!is_valid_ether_addr(params.macaddr))
3725 return -EADDRNOTAVAIL;
3728 if (info->attrs[NL80211_ATTR_4ADDR]) {
3729 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3730 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
3735 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0))
3738 err = nl80211_parse_mon_options(rdev, type, info, ¶ms);
3742 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3746 wdev = rdev_add_virtual_intf(rdev,
3747 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
3748 NET_NAME_USER, type, ¶ms);
3749 if (WARN_ON(!wdev)) {
3752 } else if (IS_ERR(wdev)) {
3754 return PTR_ERR(wdev);
3757 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
3758 wdev->owner_nlportid = info->snd_portid;
3761 case NL80211_IFTYPE_MESH_POINT:
3762 if (!info->attrs[NL80211_ATTR_MESH_ID])
3765 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3766 IEEE80211_MAX_MESH_ID_LEN);
3767 wdev->mesh_id_up_len =
3768 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3769 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3770 wdev->mesh_id_up_len);
3773 case NL80211_IFTYPE_NAN:
3774 case NL80211_IFTYPE_P2P_DEVICE:
3776 * P2P Device and NAN do not have a netdev, so don't go
3777 * through the netdev notifier and must be added here
3779 cfg80211_init_wdev(rdev, wdev);
3785 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3786 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3791 return genlmsg_reply(msg, info);
3794 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3796 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3797 struct wireless_dev *wdev = info->user_ptr[1];
3799 if (!rdev->ops->del_virtual_intf)
3803 * If we remove a wireless device without a netdev then clear
3804 * user_ptr[1] so that nl80211_post_doit won't dereference it
3805 * to check if it needs to do dev_put(). Otherwise it crashes
3806 * since the wdev has been freed, unlike with a netdev where
3807 * we need the dev_put() for the netdev to really be freed.
3810 info->user_ptr[1] = NULL;
3812 return rdev_del_virtual_intf(rdev, wdev);
3815 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3817 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3818 struct net_device *dev = info->user_ptr[1];
3821 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3824 if (!rdev->ops->set_noack_map)
3827 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3829 return rdev_set_noack_map(rdev, dev, noack_map);
3832 struct get_key_cookie {
3833 struct sk_buff *msg;
3838 static void get_key_callback(void *c, struct key_params *params)
3841 struct get_key_cookie *cookie = c;
3844 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3845 params->key_len, params->key)) ||
3847 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3848 params->seq_len, params->seq)) ||
3850 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3852 goto nla_put_failure;
3854 key = nla_nest_start_noflag(cookie->msg, NL80211_ATTR_KEY);
3856 goto nla_put_failure;
3859 nla_put(cookie->msg, NL80211_KEY_DATA,
3860 params->key_len, params->key)) ||
3862 nla_put(cookie->msg, NL80211_KEY_SEQ,
3863 params->seq_len, params->seq)) ||
3865 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3867 goto nla_put_failure;
3869 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
3870 goto nla_put_failure;
3872 nla_nest_end(cookie->msg, key);
3879 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3881 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3883 struct net_device *dev = info->user_ptr[1];
3885 const u8 *mac_addr = NULL;
3887 struct get_key_cookie cookie = {
3891 struct sk_buff *msg;
3893 if (info->attrs[NL80211_ATTR_KEY_IDX]) {
3894 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3896 !wiphy_ext_feature_isset(
3898 NL80211_EXT_FEATURE_BEACON_PROTECTION))
3902 if (info->attrs[NL80211_ATTR_MAC])
3903 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3905 pairwise = !!mac_addr;
3906 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3907 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
3909 if (kt != NL80211_KEYTYPE_GROUP &&
3910 kt != NL80211_KEYTYPE_PAIRWISE)
3912 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3915 if (!rdev->ops->get_key)
3918 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3921 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3925 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
3926 NL80211_CMD_NEW_KEY);
3928 goto nla_put_failure;
3931 cookie.idx = key_idx;
3933 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3934 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3935 goto nla_put_failure;
3937 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3938 goto nla_put_failure;
3940 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3947 goto nla_put_failure;
3949 genlmsg_end(msg, hdr);
3950 return genlmsg_reply(msg, info);
3959 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3961 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3962 struct key_parse key;
3964 struct net_device *dev = info->user_ptr[1];
3966 err = nl80211_parse_key(info, &key);
3973 /* Only support setting default key and
3974 * Extended Key ID action NL80211_KEY_SET_TX.
3976 if (!key.def && !key.defmgmt && !key.defbeacon &&
3977 !(key.p.mode == NL80211_KEY_SET_TX))
3980 wdev_lock(dev->ieee80211_ptr);
3983 if (!rdev->ops->set_default_key) {
3988 err = nl80211_key_allowed(dev->ieee80211_ptr);
3992 err = rdev_set_default_key(rdev, dev, key.idx,
3993 key.def_uni, key.def_multi);
3998 #ifdef CONFIG_CFG80211_WEXT
3999 dev->ieee80211_ptr->wext.default_key = key.idx;
4001 } else if (key.defmgmt) {
4002 if (key.def_uni || !key.def_multi) {
4007 if (!rdev->ops->set_default_mgmt_key) {
4012 err = nl80211_key_allowed(dev->ieee80211_ptr);
4016 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
4020 #ifdef CONFIG_CFG80211_WEXT
4021 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
4023 } else if (key.defbeacon) {
4024 if (key.def_uni || !key.def_multi) {
4029 if (!rdev->ops->set_default_beacon_key) {
4034 err = nl80211_key_allowed(dev->ieee80211_ptr);
4038 err = rdev_set_default_beacon_key(rdev, dev, key.idx);
4041 } else if (key.p.mode == NL80211_KEY_SET_TX &&
4042 wiphy_ext_feature_isset(&rdev->wiphy,
4043 NL80211_EXT_FEATURE_EXT_KEY_ID)) {
4044 u8 *mac_addr = NULL;
4046 if (info->attrs[NL80211_ATTR_MAC])
4047 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4049 if (!mac_addr || key.idx < 0 || key.idx > 1) {
4054 err = rdev_add_key(rdev, dev, key.idx,
4055 NL80211_KEYTYPE_PAIRWISE,
4061 wdev_unlock(dev->ieee80211_ptr);
4066 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
4068 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4070 struct net_device *dev = info->user_ptr[1];
4071 struct key_parse key;
4072 const u8 *mac_addr = NULL;
4074 err = nl80211_parse_key(info, &key);
4079 GENL_SET_ERR_MSG(info, "no key");
4083 if (info->attrs[NL80211_ATTR_MAC])
4084 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4086 if (key.type == -1) {
4088 key.type = NL80211_KEYTYPE_PAIRWISE;
4090 key.type = NL80211_KEYTYPE_GROUP;
4094 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
4095 key.type != NL80211_KEYTYPE_GROUP) {
4096 GENL_SET_ERR_MSG(info, "key type not pairwise or group");
4100 if (key.type == NL80211_KEYTYPE_GROUP &&
4101 info->attrs[NL80211_ATTR_VLAN_ID])
4102 key.p.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
4104 if (!rdev->ops->add_key)
4107 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
4108 key.type == NL80211_KEYTYPE_PAIRWISE,
4110 GENL_SET_ERR_MSG(info, "key setting validation failed");
4114 wdev_lock(dev->ieee80211_ptr);
4115 err = nl80211_key_allowed(dev->ieee80211_ptr);
4117 GENL_SET_ERR_MSG(info, "key not allowed");
4119 err = rdev_add_key(rdev, dev, key.idx,
4120 key.type == NL80211_KEYTYPE_PAIRWISE,
4123 GENL_SET_ERR_MSG(info, "key addition failed");
4125 wdev_unlock(dev->ieee80211_ptr);
4130 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
4132 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4134 struct net_device *dev = info->user_ptr[1];
4135 u8 *mac_addr = NULL;
4136 struct key_parse key;
4138 err = nl80211_parse_key(info, &key);
4142 if (info->attrs[NL80211_ATTR_MAC])
4143 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4145 if (key.type == -1) {
4147 key.type = NL80211_KEYTYPE_PAIRWISE;
4149 key.type = NL80211_KEYTYPE_GROUP;
4153 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
4154 key.type != NL80211_KEYTYPE_GROUP)
4157 if (!rdev->ops->del_key)
4160 wdev_lock(dev->ieee80211_ptr);
4161 err = nl80211_key_allowed(dev->ieee80211_ptr);
4163 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
4164 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
4168 err = rdev_del_key(rdev, dev, key.idx,
4169 key.type == NL80211_KEYTYPE_PAIRWISE,
4172 #ifdef CONFIG_CFG80211_WEXT
4174 if (key.idx == dev->ieee80211_ptr->wext.default_key)
4175 dev->ieee80211_ptr->wext.default_key = -1;
4176 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
4177 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
4180 wdev_unlock(dev->ieee80211_ptr);
4185 /* This function returns an error or the number of nested attributes */
4186 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
4188 struct nlattr *attr;
4189 int n_entries = 0, tmp;
4191 nla_for_each_nested(attr, nl_attr, tmp) {
4192 if (nla_len(attr) != ETH_ALEN)
4202 * This function parses ACL information and allocates memory for ACL data.
4203 * On successful return, the calling function is responsible to free the
4204 * ACL buffer returned by this function.
4206 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
4207 struct genl_info *info)
4209 enum nl80211_acl_policy acl_policy;
4210 struct nlattr *attr;
4211 struct cfg80211_acl_data *acl;
4212 int i = 0, n_entries, tmp;
4214 if (!wiphy->max_acl_mac_addrs)
4215 return ERR_PTR(-EOPNOTSUPP);
4217 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
4218 return ERR_PTR(-EINVAL);
4220 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
4221 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
4222 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
4223 return ERR_PTR(-EINVAL);
4225 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
4226 return ERR_PTR(-EINVAL);
4228 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
4230 return ERR_PTR(n_entries);
4232 if (n_entries > wiphy->max_acl_mac_addrs)
4233 return ERR_PTR(-ENOTSUPP);
4235 acl = kzalloc(struct_size(acl, mac_addrs, n_entries), GFP_KERNEL);
4237 return ERR_PTR(-ENOMEM);
4239 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
4240 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
4244 acl->n_acl_entries = n_entries;
4245 acl->acl_policy = acl_policy;
4250 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
4252 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4253 struct net_device *dev = info->user_ptr[1];
4254 struct cfg80211_acl_data *acl;
4257 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4258 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4261 if (!dev->ieee80211_ptr->beacon_interval)
4264 acl = parse_acl_data(&rdev->wiphy, info);
4266 return PTR_ERR(acl);
4268 err = rdev_set_mac_acl(rdev, dev, acl);
4275 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
4276 u8 *rates, u8 rates_len)
4281 for (i = 0; i < rates_len; i++) {
4282 int rate = (rates[i] & 0x7f) * 5;
4285 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
4286 struct ieee80211_rate *srate =
4287 &sband->bitrates[ridx];
4288 if (rate == srate->bitrate) {
4293 if (ridx == sband->n_bitrates)
4294 return 0; /* rate not found */
4300 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
4301 u8 *rates, u8 rates_len,
4302 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
4306 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
4308 for (i = 0; i < rates_len; i++) {
4311 ridx = rates[i] / 8;
4312 rbit = BIT(rates[i] % 8);
4314 /* check validity */
4315 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
4318 /* check availability */
4319 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN);
4320 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
4329 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
4333 switch (vht_mcs_map) {
4334 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
4336 case IEEE80211_VHT_MCS_SUPPORT_0_7:
4339 case IEEE80211_VHT_MCS_SUPPORT_0_8:
4342 case IEEE80211_VHT_MCS_SUPPORT_0_9:
4352 static void vht_build_mcs_mask(u16 vht_mcs_map,
4353 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
4357 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
4358 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
4363 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
4364 struct nl80211_txrate_vht *txrate,
4365 u16 mcs[NL80211_VHT_NSS_MAX])
4367 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4368 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
4371 if (!sband->vht_cap.vht_supported)
4374 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
4376 /* Build vht_mcs_mask from VHT capabilities */
4377 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
4379 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4380 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
4381 mcs[i] = txrate->mcs[i];
4389 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
4390 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
4391 .len = NL80211_MAX_SUPP_RATES },
4392 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
4393 .len = NL80211_MAX_SUPP_HT_RATES },
4394 [NL80211_TXRATE_VHT] = {
4395 .type = NLA_EXACT_LEN_WARN,
4396 .len = sizeof(struct nl80211_txrate_vht),
4398 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
4401 static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
4402 struct cfg80211_bitrate_mask *mask)
4404 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
4405 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4407 struct nlattr *tx_rates;
4408 struct ieee80211_supported_band *sband;
4411 memset(mask, 0, sizeof(*mask));
4412 /* Default to all rates enabled */
4413 for (i = 0; i < NUM_NL80211_BANDS; i++) {
4414 sband = rdev->wiphy.bands[i];
4419 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
4420 memcpy(mask->control[i].ht_mcs,
4421 sband->ht_cap.mcs.rx_mask,
4422 sizeof(mask->control[i].ht_mcs));
4424 if (!sband->vht_cap.vht_supported)
4427 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4428 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
4431 /* if no rates are given set it back to the defaults */
4432 if (!info->attrs[NL80211_ATTR_TX_RATES])
4435 /* The nested attribute uses enum nl80211_band as the index. This maps
4436 * directly to the enum nl80211_band values used in cfg80211.
4438 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
4439 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
4440 enum nl80211_band band = nla_type(tx_rates);
4443 if (band < 0 || band >= NUM_NL80211_BANDS)
4445 sband = rdev->wiphy.bands[band];
4448 err = nla_parse_nested_deprecated(tb, NL80211_TXRATE_MAX,
4450 nl80211_txattr_policy,
4454 if (tb[NL80211_TXRATE_LEGACY]) {
4455 mask->control[band].legacy = rateset_to_mask(
4457 nla_data(tb[NL80211_TXRATE_LEGACY]),
4458 nla_len(tb[NL80211_TXRATE_LEGACY]));
4459 if ((mask->control[band].legacy == 0) &&
4460 nla_len(tb[NL80211_TXRATE_LEGACY]))
4463 if (tb[NL80211_TXRATE_HT]) {
4464 if (!ht_rateset_to_mask(
4466 nla_data(tb[NL80211_TXRATE_HT]),
4467 nla_len(tb[NL80211_TXRATE_HT]),
4468 mask->control[band].ht_mcs))
4471 if (tb[NL80211_TXRATE_VHT]) {
4472 if (!vht_set_mcs_mask(
4474 nla_data(tb[NL80211_TXRATE_VHT]),
4475 mask->control[band].vht_mcs))
4478 if (tb[NL80211_TXRATE_GI]) {
4479 mask->control[band].gi =
4480 nla_get_u8(tb[NL80211_TXRATE_GI]);
4481 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
4485 if (mask->control[band].legacy == 0) {
4486 /* don't allow empty legacy rates if HT or VHT
4487 * are not even supported.
4489 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
4490 rdev->wiphy.bands[band]->vht_cap.vht_supported))
4493 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4494 if (mask->control[band].ht_mcs[i])
4497 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4498 if (mask->control[band].vht_mcs[i])
4501 /* legacy and mcs rates may not be both empty */
4510 static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
4511 enum nl80211_band band,
4512 struct cfg80211_bitrate_mask *beacon_rate)
4514 u32 count_ht, count_vht, i;
4515 u32 rate = beacon_rate->control[band].legacy;
4517 /* Allow only one rate */
4518 if (hweight32(rate) > 1)
4522 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4523 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
4525 } else if (beacon_rate->control[band].ht_mcs[i]) {
4530 if (count_ht && rate)
4535 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4536 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
4538 } else if (beacon_rate->control[band].vht_mcs[i]) {
4543 if (count_vht && rate)
4547 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
4551 !wiphy_ext_feature_isset(&rdev->wiphy,
4552 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
4555 !wiphy_ext_feature_isset(&rdev->wiphy,
4556 NL80211_EXT_FEATURE_BEACON_RATE_HT))
4559 !wiphy_ext_feature_isset(&rdev->wiphy,
4560 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
4566 static int nl80211_parse_beacon(struct cfg80211_registered_device *rdev,
4567 struct nlattr *attrs[],
4568 struct cfg80211_beacon_data *bcn)
4570 bool haveinfo = false;
4573 memset(bcn, 0, sizeof(*bcn));
4575 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
4576 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
4577 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
4583 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
4584 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
4585 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
4592 if (attrs[NL80211_ATTR_IE]) {
4593 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
4594 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
4597 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
4598 bcn->proberesp_ies =
4599 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
4600 bcn->proberesp_ies_len =
4601 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
4604 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
4605 bcn->assocresp_ies =
4606 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
4607 bcn->assocresp_ies_len =
4608 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
4611 if (attrs[NL80211_ATTR_PROBE_RESP]) {
4612 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
4613 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
4616 if (attrs[NL80211_ATTR_FTM_RESPONDER]) {
4617 struct nlattr *tb[NL80211_FTM_RESP_ATTR_MAX + 1];
4619 err = nla_parse_nested_deprecated(tb,
4620 NL80211_FTM_RESP_ATTR_MAX,
4621 attrs[NL80211_ATTR_FTM_RESPONDER],
4626 if (tb[NL80211_FTM_RESP_ATTR_ENABLED] &&
4627 wiphy_ext_feature_isset(&rdev->wiphy,
4628 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
4629 bcn->ftm_responder = 1;
4633 if (tb[NL80211_FTM_RESP_ATTR_LCI]) {
4634 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]);
4635 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]);
4638 if (tb[NL80211_FTM_RESP_ATTR_CIVICLOC]) {
4639 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
4640 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
4643 bcn->ftm_responder = -1;
4649 static int nl80211_parse_he_obss_pd(struct nlattr *attrs,
4650 struct ieee80211_he_obss_pd *he_obss_pd)
4652 struct nlattr *tb[NL80211_HE_OBSS_PD_ATTR_MAX + 1];
4655 err = nla_parse_nested(tb, NL80211_HE_OBSS_PD_ATTR_MAX, attrs,
4656 he_obss_pd_policy, NULL);
4660 if (!tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] ||
4661 !tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET])
4664 he_obss_pd->min_offset =
4665 nla_get_u32(tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET]);
4666 he_obss_pd->max_offset =
4667 nla_get_u32(tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET]);
4669 if (he_obss_pd->min_offset >= he_obss_pd->max_offset)
4672 he_obss_pd->enable = true;
4677 static int nl80211_parse_he_bss_color(struct nlattr *attrs,
4678 struct cfg80211_he_bss_color *he_bss_color)
4680 struct nlattr *tb[NL80211_HE_BSS_COLOR_ATTR_MAX + 1];
4683 err = nla_parse_nested(tb, NL80211_HE_BSS_COLOR_ATTR_MAX, attrs,
4684 he_bss_color_policy, NULL);
4688 if (!tb[NL80211_HE_BSS_COLOR_ATTR_COLOR])
4691 he_bss_color->color =
4692 nla_get_u8(tb[NL80211_HE_BSS_COLOR_ATTR_COLOR]);
4693 he_bss_color->disabled =
4694 nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_DISABLED]);
4695 he_bss_color->partial =
4696 nla_get_flag(tb[NL80211_HE_BSS_COLOR_ATTR_PARTIAL]);
4701 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
4709 for (i = 0; i < rates[1]; i++) {
4710 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
4711 params->ht_required = true;
4712 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
4713 params->vht_required = true;
4718 * Since the nl80211 API didn't include, from the beginning, attributes about
4719 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
4720 * benefit of drivers that rebuild IEs in the firmware.
4722 static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
4724 const struct cfg80211_beacon_data *bcn = ¶ms->beacon;
4725 size_t ies_len = bcn->tail_len;
4726 const u8 *ies = bcn->tail;
4730 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
4731 nl80211_check_ap_rate_selectors(params, rates);
4733 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
4734 nl80211_check_ap_rate_selectors(params, rates);
4736 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
4737 if (cap && cap[1] >= sizeof(*params->ht_cap))
4738 params->ht_cap = (void *)(cap + 2);
4739 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
4740 if (cap && cap[1] >= sizeof(*params->vht_cap))
4741 params->vht_cap = (void *)(cap + 2);
4742 cap = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY, ies, ies_len);
4743 if (cap && cap[1] >= sizeof(*params->he_cap) + 1)
4744 params->he_cap = (void *)(cap + 3);
4747 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
4748 struct cfg80211_ap_settings *params)
4750 struct wireless_dev *wdev;
4753 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4754 if (wdev->iftype != NL80211_IFTYPE_AP &&
4755 wdev->iftype != NL80211_IFTYPE_P2P_GO)
4758 if (!wdev->preset_chandef.chan)
4761 params->chandef = wdev->preset_chandef;
4769 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
4770 enum nl80211_auth_type auth_type,
4771 enum nl80211_commands cmd)
4773 if (auth_type > NL80211_AUTHTYPE_MAX)
4777 case NL80211_CMD_AUTHENTICATE:
4778 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
4779 auth_type == NL80211_AUTHTYPE_SAE)
4781 if (!wiphy_ext_feature_isset(&rdev->wiphy,
4782 NL80211_EXT_FEATURE_FILS_STA) &&
4783 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
4784 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4785 auth_type == NL80211_AUTHTYPE_FILS_PK))
4788 case NL80211_CMD_CONNECT:
4789 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
4790 !wiphy_ext_feature_isset(&rdev->wiphy,
4791 NL80211_EXT_FEATURE_SAE_OFFLOAD) &&
4792 auth_type == NL80211_AUTHTYPE_SAE)
4795 /* FILS with SK PFS or PK not supported yet */
4796 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4797 auth_type == NL80211_AUTHTYPE_FILS_PK)
4799 if (!wiphy_ext_feature_isset(
4801 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
4802 auth_type == NL80211_AUTHTYPE_FILS_SK)
4805 case NL80211_CMD_START_AP:
4806 /* SAE not supported yet */
4807 if (auth_type == NL80211_AUTHTYPE_SAE)
4809 /* FILS not supported yet */
4810 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
4811 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4812 auth_type == NL80211_AUTHTYPE_FILS_PK)
4820 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
4822 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4823 struct net_device *dev = info->user_ptr[1];
4824 struct wireless_dev *wdev = dev->ieee80211_ptr;
4825 struct cfg80211_ap_settings params;
4828 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4829 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4832 if (!rdev->ops->start_ap)
4835 if (wdev->beacon_interval)
4838 memset(¶ms, 0, sizeof(params));
4840 /* these are required for START_AP */
4841 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
4842 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
4843 !info->attrs[NL80211_ATTR_BEACON_HEAD])
4846 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon);
4850 params.beacon_interval =
4851 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
4852 params.dtim_period =
4853 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
4855 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
4856 params.beacon_interval);
4861 * In theory, some of these attributes should be required here
4862 * but since they were not used when the command was originally
4863 * added, keep them optional for old user space programs to let
4864 * them continue to work with drivers that do not need the
4865 * additional information -- drivers must check!
4867 if (info->attrs[NL80211_ATTR_SSID]) {
4868 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4870 nla_len(info->attrs[NL80211_ATTR_SSID]);
4871 if (params.ssid_len == 0 ||
4872 params.ssid_len > IEEE80211_MAX_SSID_LEN)
4876 if (info->attrs[NL80211_ATTR_HIDDEN_SSID])
4877 params.hidden_ssid = nla_get_u32(
4878 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
4880 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
4882 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
4883 params.auth_type = nla_get_u32(
4884 info->attrs[NL80211_ATTR_AUTH_TYPE]);
4885 if (!nl80211_valid_auth_type(rdev, params.auth_type,
4886 NL80211_CMD_START_AP))
4889 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
4891 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
4892 NL80211_MAX_NR_CIPHER_SUITES);
4896 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
4897 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
4899 params.inactivity_timeout = nla_get_u16(
4900 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
4903 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4904 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4906 params.p2p_ctwindow =
4907 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4908 if (params.p2p_ctwindow != 0 &&
4909 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4913 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4916 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4918 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4919 params.p2p_opp_ps = tmp;
4920 if (params.p2p_opp_ps != 0 &&
4921 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4925 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
4926 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
4929 } else if (wdev->preset_chandef.chan) {
4930 params.chandef = wdev->preset_chandef;
4931 } else if (!nl80211_get_ap_channel(rdev, ¶ms))
4934 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
4938 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4939 err = nl80211_parse_tx_bitrate_mask(info, ¶ms.beacon_rate);
4943 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4944 ¶ms.beacon_rate);
4949 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4951 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4952 switch (params.smps_mode) {
4953 case NL80211_SMPS_OFF:
4955 case NL80211_SMPS_STATIC:
4956 if (!(rdev->wiphy.features &
4957 NL80211_FEATURE_STATIC_SMPS))
4960 case NL80211_SMPS_DYNAMIC:
4961 if (!(rdev->wiphy.features &
4962 NL80211_FEATURE_DYNAMIC_SMPS))
4969 params.smps_mode = NL80211_SMPS_OFF;
4972 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4973 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4976 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4977 params.acl = parse_acl_data(&rdev->wiphy, info);
4978 if (IS_ERR(params.acl))
4979 return PTR_ERR(params.acl);
4982 params.twt_responder =
4983 nla_get_flag(info->attrs[NL80211_ATTR_TWT_RESPONDER]);
4985 if (info->attrs[NL80211_ATTR_HE_OBSS_PD]) {
4986 err = nl80211_parse_he_obss_pd(
4987 info->attrs[NL80211_ATTR_HE_OBSS_PD],
4988 ¶ms.he_obss_pd);
4993 if (info->attrs[NL80211_ATTR_HE_BSS_COLOR]) {
4994 err = nl80211_parse_he_bss_color(
4995 info->attrs[NL80211_ATTR_HE_BSS_COLOR],
4996 ¶ms.he_bss_color);
5001 nl80211_calculate_ap_params(¶ms);
5003 if (info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])
5004 params.flags |= AP_SETTINGS_EXTERNAL_AUTH_SUPPORT;
5007 err = rdev_start_ap(rdev, dev, ¶ms);
5009 wdev->preset_chandef = params.chandef;
5010 wdev->beacon_interval = params.beacon_interval;
5011 wdev->chandef = params.chandef;
5012 wdev->ssid_len = params.ssid_len;
5013 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
5015 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
5016 wdev->conn_owner_nlportid = info->snd_portid;
5025 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
5027 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5028 struct net_device *dev = info->user_ptr[1];
5029 struct wireless_dev *wdev = dev->ieee80211_ptr;
5030 struct cfg80211_beacon_data params;
5033 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5034 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5037 if (!rdev->ops->change_beacon)
5040 if (!wdev->beacon_interval)
5043 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms);
5048 err = rdev_change_beacon(rdev, dev, ¶ms);
5054 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
5056 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5057 struct net_device *dev = info->user_ptr[1];
5059 return cfg80211_stop_ap(rdev, dev, false);
5062 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
5063 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
5064 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
5065 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
5066 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
5067 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
5068 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
5071 static int parse_station_flags(struct genl_info *info,
5072 enum nl80211_iftype iftype,
5073 struct station_parameters *params)
5075 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
5080 * Try parsing the new attribute first so userspace
5081 * can specify both for older kernels.
5083 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
5085 struct nl80211_sta_flag_update *sta_flags;
5087 sta_flags = nla_data(nla);
5088 params->sta_flags_mask = sta_flags->mask;
5089 params->sta_flags_set = sta_flags->set;
5090 params->sta_flags_set &= params->sta_flags_mask;
5091 if ((params->sta_flags_mask |
5092 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
5097 /* if present, parse the old attribute */
5099 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5103 if (nla_parse_nested_deprecated(flags, NL80211_STA_FLAG_MAX, nla, sta_flags_policy, info->extack))
5107 * Only allow certain flags for interface types so that
5108 * other attributes are silently ignored. Remember that
5109 * this is backward compatibility code with old userspace
5110 * and shouldn't be hit in other cases anyway.
5113 case NL80211_IFTYPE_AP:
5114 case NL80211_IFTYPE_AP_VLAN:
5115 case NL80211_IFTYPE_P2P_GO:
5116 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
5117 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
5118 BIT(NL80211_STA_FLAG_WME) |
5119 BIT(NL80211_STA_FLAG_MFP);
5121 case NL80211_IFTYPE_P2P_CLIENT:
5122 case NL80211_IFTYPE_STATION:
5123 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
5124 BIT(NL80211_STA_FLAG_TDLS_PEER);
5126 case NL80211_IFTYPE_MESH_POINT:
5127 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5128 BIT(NL80211_STA_FLAG_MFP) |
5129 BIT(NL80211_STA_FLAG_AUTHORIZED);
5135 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
5137 params->sta_flags_set |= (1<<flag);
5139 /* no longer support new API additions in old API */
5140 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
5148 bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info, int attr)
5150 struct nlattr *rate;
5153 enum nl80211_rate_info rate_flg;
5155 rate = nla_nest_start_noflag(msg, attr);
5159 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
5160 bitrate = cfg80211_calculate_bitrate(info);
5161 /* report 16-bit bitrate only if we can */
5162 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
5164 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
5166 if (bitrate_compat > 0 &&
5167 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
5171 case RATE_INFO_BW_5:
5172 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
5174 case RATE_INFO_BW_10:
5175 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
5180 case RATE_INFO_BW_20:
5183 case RATE_INFO_BW_40:
5184 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
5186 case RATE_INFO_BW_80:
5187 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
5189 case RATE_INFO_BW_160:
5190 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
5192 case RATE_INFO_BW_HE_RU:
5194 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS));
5197 if (rate_flg && nla_put_flag(msg, rate_flg))
5200 if (info->flags & RATE_INFO_FLAGS_MCS) {
5201 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
5203 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
5204 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
5206 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
5207 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
5209 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
5211 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
5212 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
5214 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) {
5215 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs))
5217 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss))
5219 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi))
5221 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm))
5223 if (info->bw == RATE_INFO_BW_HE_RU &&
5224 nla_put_u8(msg, NL80211_RATE_INFO_HE_RU_ALLOC,
5229 nla_nest_end(msg, rate);
5233 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
5242 attr = nla_nest_start_noflag(msg, id);
5246 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
5247 if (!(mask & BIT(i)))
5250 if (nla_put_u8(msg, i, signal[i]))
5254 nla_nest_end(msg, attr);
5259 static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
5261 struct cfg80211_registered_device *rdev,
5262 struct net_device *dev,
5263 const u8 *mac_addr, struct station_info *sinfo)
5266 struct nlattr *sinfoattr, *bss_param;
5268 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
5270 cfg80211_sinfo_release_content(sinfo);
5274 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5275 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
5276 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
5277 goto nla_put_failure;
5279 sinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_STA_INFO);
5281 goto nla_put_failure;
5283 #define PUT_SINFO(attr, memb, type) do { \
5284 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
5285 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5286 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
5288 goto nla_put_failure; \
5290 #define PUT_SINFO_U64(attr, memb) do { \
5291 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5292 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
5293 sinfo->memb, NL80211_STA_INFO_PAD)) \
5294 goto nla_put_failure; \
5297 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
5298 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
5299 PUT_SINFO_U64(ASSOC_AT_BOOTTIME, assoc_at);
5301 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
5302 BIT_ULL(NL80211_STA_INFO_RX_BYTES64)) &&
5303 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
5304 (u32)sinfo->rx_bytes))
5305 goto nla_put_failure;
5307 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
5308 BIT_ULL(NL80211_STA_INFO_TX_BYTES64)) &&
5309 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
5310 (u32)sinfo->tx_bytes))
5311 goto nla_put_failure;
5313 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
5314 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
5315 PUT_SINFO(LLID, llid, u16);
5316 PUT_SINFO(PLID, plid, u16);
5317 PUT_SINFO(PLINK_STATE, plink_state, u8);
5318 PUT_SINFO_U64(RX_DURATION, rx_duration);
5319 PUT_SINFO_U64(TX_DURATION, tx_duration);
5321 if (wiphy_ext_feature_isset(&rdev->wiphy,
5322 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
5323 PUT_SINFO(AIRTIME_WEIGHT, airtime_weight, u16);
5325 switch (rdev->wiphy.signal_type) {
5326 case CFG80211_SIGNAL_TYPE_MBM:
5327 PUT_SINFO(SIGNAL, signal, u8);
5328 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
5333 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
5334 if (!nl80211_put_signal(msg, sinfo->chains,
5335 sinfo->chain_signal,
5336 NL80211_STA_INFO_CHAIN_SIGNAL))
5337 goto nla_put_failure;
5339 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
5340 if (!nl80211_put_signal(msg, sinfo->chains,
5341 sinfo->chain_signal_avg,
5342 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
5343 goto nla_put_failure;
5345 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
5346 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
5347 NL80211_STA_INFO_TX_BITRATE))
5348 goto nla_put_failure;
5350 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
5351 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
5352 NL80211_STA_INFO_RX_BITRATE))
5353 goto nla_put_failure;
5356 PUT_SINFO(RX_PACKETS, rx_packets, u32);
5357 PUT_SINFO(TX_PACKETS, tx_packets, u32);
5358 PUT_SINFO(TX_RETRIES, tx_retries, u32);
5359 PUT_SINFO(TX_FAILED, tx_failed, u32);
5360 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
5361 PUT_SINFO(AIRTIME_LINK_METRIC, airtime_link_metric, u32);
5362 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
5363 PUT_SINFO(LOCAL_PM, local_pm, u32);
5364 PUT_SINFO(PEER_PM, peer_pm, u32);
5365 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
5366 PUT_SINFO(CONNECTED_TO_GATE, connected_to_gate, u8);
5368 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
5369 bss_param = nla_nest_start_noflag(msg,
5370 NL80211_STA_INFO_BSS_PARAM);
5372 goto nla_put_failure;
5374 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
5375 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
5376 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
5377 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
5378 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
5379 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
5380 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
5381 sinfo->bss_param.dtim_period) ||
5382 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
5383 sinfo->bss_param.beacon_interval))
5384 goto nla_put_failure;
5386 nla_nest_end(msg, bss_param);
5388 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) &&
5389 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
5390 sizeof(struct nl80211_sta_flag_update),
5392 goto nla_put_failure;
5394 PUT_SINFO_U64(T_OFFSET, t_offset);
5395 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
5396 PUT_SINFO_U64(BEACON_RX, rx_beacon);
5397 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
5398 PUT_SINFO(RX_MPDUS, rx_mpdu_count, u32);
5399 PUT_SINFO(FCS_ERROR_COUNT, fcs_err_count, u32);
5400 if (wiphy_ext_feature_isset(&rdev->wiphy,
5401 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT)) {
5402 PUT_SINFO(ACK_SIGNAL, ack_signal, u8);
5403 PUT_SINFO(ACK_SIGNAL_AVG, avg_ack_signal, s8);
5407 #undef PUT_SINFO_U64
5409 if (sinfo->pertid) {
5410 struct nlattr *tidsattr;
5413 tidsattr = nla_nest_start_noflag(msg,
5414 NL80211_STA_INFO_TID_STATS);
5416 goto nla_put_failure;
5418 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
5419 struct cfg80211_tid_stats *tidstats;
5420 struct nlattr *tidattr;
5422 tidstats = &sinfo->pertid[tid];
5424 if (!tidstats->filled)
5427 tidattr = nla_nest_start_noflag(msg, tid + 1);
5429 goto nla_put_failure;
5431 #define PUT_TIDVAL_U64(attr, memb) do { \
5432 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
5433 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
5434 tidstats->memb, NL80211_TID_STATS_PAD)) \
5435 goto nla_put_failure; \
5438 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
5439 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
5440 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
5441 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
5443 #undef PUT_TIDVAL_U64
5444 if ((tidstats->filled &
5445 BIT(NL80211_TID_STATS_TXQ_STATS)) &&
5446 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
5447 NL80211_TID_STATS_TXQ_STATS))
5448 goto nla_put_failure;
5450 nla_nest_end(msg, tidattr);
5453 nla_nest_end(msg, tidsattr);
5456 nla_nest_end(msg, sinfoattr);
5458 if (sinfo->assoc_req_ies_len &&
5459 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
5460 sinfo->assoc_req_ies))
5461 goto nla_put_failure;
5463 cfg80211_sinfo_release_content(sinfo);
5464 genlmsg_end(msg, hdr);
5468 cfg80211_sinfo_release_content(sinfo);
5469 genlmsg_cancel(msg, hdr);
5473 static int nl80211_dump_station(struct sk_buff *skb,
5474 struct netlink_callback *cb)
5476 struct station_info sinfo;
5477 struct cfg80211_registered_device *rdev;
5478 struct wireless_dev *wdev;
5479 u8 mac_addr[ETH_ALEN];
5480 int sta_idx = cb->args[2];
5484 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
5488 if (!wdev->netdev) {
5493 if (!rdev->ops->dump_station) {
5499 memset(&sinfo, 0, sizeof(sinfo));
5500 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
5507 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
5508 NETLINK_CB(cb->skb).portid,
5509 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5510 rdev, wdev->netdev, mac_addr,
5518 cb->args[2] = sta_idx;
5526 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
5528 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5529 struct net_device *dev = info->user_ptr[1];
5530 struct station_info sinfo;
5531 struct sk_buff *msg;
5532 u8 *mac_addr = NULL;
5535 memset(&sinfo, 0, sizeof(sinfo));
5537 if (!info->attrs[NL80211_ATTR_MAC])
5540 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5542 if (!rdev->ops->get_station)
5545 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
5549 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5551 cfg80211_sinfo_release_content(&sinfo);
5555 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
5556 info->snd_portid, info->snd_seq, 0,
5557 rdev, dev, mac_addr, &sinfo) < 0) {
5562 return genlmsg_reply(msg, info);
5565 int cfg80211_check_station_change(struct wiphy *wiphy,
5566 struct station_parameters *params,
5567 enum cfg80211_station_type statype)
5569 if (params->listen_interval != -1 &&
5570 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5573 if (params->support_p2p_ps != -1 &&
5574 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5578 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
5579 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5582 /* When you run into this, adjust the code below for the new flag */
5583 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5586 case CFG80211_STA_MESH_PEER_KERNEL:
5587 case CFG80211_STA_MESH_PEER_USER:
5589 * No ignoring the TDLS flag here -- the userspace mesh
5590 * code doesn't have the bug of including TDLS in the
5593 if (params->sta_flags_mask &
5594 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5595 BIT(NL80211_STA_FLAG_MFP) |
5596 BIT(NL80211_STA_FLAG_AUTHORIZED)))
5599 case CFG80211_STA_TDLS_PEER_SETUP:
5600 case CFG80211_STA_TDLS_PEER_ACTIVE:
5601 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5603 /* ignore since it can't change */
5604 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5607 /* disallow mesh-specific things */
5608 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
5610 if (params->local_pm)
5612 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
5616 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
5617 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
5618 /* TDLS can't be set, ... */
5619 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
5622 * ... but don't bother the driver with it. This works around
5623 * a hostapd/wpa_supplicant issue -- it always includes the
5624 * TLDS_PEER flag in the mask even for AP mode.
5626 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5629 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
5630 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
5631 /* reject other things that can't change */
5632 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
5634 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
5636 if (params->supported_rates)
5638 if (params->ext_capab || params->ht_capa || params->vht_capa ||
5643 if (statype != CFG80211_STA_AP_CLIENT &&
5644 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
5650 case CFG80211_STA_AP_MLME_CLIENT:
5651 /* Use this only for authorizing/unauthorizing a station */
5652 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
5655 case CFG80211_STA_AP_CLIENT:
5656 case CFG80211_STA_AP_CLIENT_UNASSOC:
5657 /* accept only the listed bits */
5658 if (params->sta_flags_mask &
5659 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
5660 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5661 BIT(NL80211_STA_FLAG_ASSOCIATED) |
5662 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
5663 BIT(NL80211_STA_FLAG_WME) |
5664 BIT(NL80211_STA_FLAG_MFP)))
5667 /* but authenticated/associated only if driver handles it */
5668 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
5669 params->sta_flags_mask &
5670 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5671 BIT(NL80211_STA_FLAG_ASSOCIATED)))
5674 case CFG80211_STA_IBSS:
5675 case CFG80211_STA_AP_STA:
5676 /* reject any changes other than AUTHORIZED */
5677 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
5680 case CFG80211_STA_TDLS_PEER_SETUP:
5681 /* reject any changes other than AUTHORIZED or WME */
5682 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
5683 BIT(NL80211_STA_FLAG_WME)))
5685 /* force (at least) rates when authorizing */
5686 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
5687 !params->supported_rates)
5690 case CFG80211_STA_TDLS_PEER_ACTIVE:
5691 /* reject any changes */
5693 case CFG80211_STA_MESH_PEER_KERNEL:
5694 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
5697 case CFG80211_STA_MESH_PEER_USER:
5698 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
5699 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
5705 * Older kernel versions ignored this attribute entirely, so don't
5706 * reject attempts to update it but mark it as unused instead so the
5707 * driver won't look at the data.
5709 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
5710 statype != CFG80211_STA_TDLS_PEER_SETUP)
5711 params->opmode_notif_used = false;
5715 EXPORT_SYMBOL(cfg80211_check_station_change);
5718 * Get vlan interface making sure it is running and on the right wiphy.
5720 static struct net_device *get_vlan(struct genl_info *info,
5721 struct cfg80211_registered_device *rdev)
5723 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
5724 struct net_device *v;
5730 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
5732 return ERR_PTR(-ENODEV);
5734 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
5739 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5740 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5741 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
5746 if (!netif_running(v)) {
5754 return ERR_PTR(ret);
5757 static const struct nla_policy
5758 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
5759 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
5760 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
5763 static int nl80211_parse_sta_wme(struct genl_info *info,
5764 struct station_parameters *params)
5766 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
5770 /* parse WME attributes if present */
5771 if (!info->attrs[NL80211_ATTR_STA_WME])
5774 nla = info->attrs[NL80211_ATTR_STA_WME];
5775 err = nla_parse_nested_deprecated(tb, NL80211_STA_WME_MAX, nla,
5776 nl80211_sta_wme_policy,
5781 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
5782 params->uapsd_queues = nla_get_u8(
5783 tb[NL80211_STA_WME_UAPSD_QUEUES]);
5784 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
5787 if (tb[NL80211_STA_WME_MAX_SP])
5788 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
5790 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
5793 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
5798 static int nl80211_parse_sta_channel_info(struct genl_info *info,
5799 struct station_parameters *params)
5801 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
5802 params->supported_channels =
5803 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
5804 params->supported_channels_len =
5805 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
5807 * Need to include at least one (first channel, number of
5808 * channels) tuple for each subband, and must have proper
5809 * tuples for the rest of the data as well.
5811 if (params->supported_channels_len < 2)
5813 if (params->supported_channels_len % 2)
5817 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
5818 params->supported_oper_classes =
5819 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
5820 params->supported_oper_classes_len =
5821 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
5823 * The value of the Length field of the Supported Operating
5824 * Classes element is between 2 and 253.
5826 if (params->supported_oper_classes_len < 2 ||
5827 params->supported_oper_classes_len > 253)
5833 static int nl80211_set_station_tdls(struct genl_info *info,
5834 struct station_parameters *params)
5837 /* Dummy STA entry gets updated once the peer capabilities are known */
5838 if (info->attrs[NL80211_ATTR_PEER_AID])
5839 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
5840 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5842 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5843 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5845 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5846 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
5848 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5849 params->he_capa_len =
5850 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5852 if (params->he_capa_len < NL80211_HE_MIN_CAPABILITY_LEN)
5856 err = nl80211_parse_sta_channel_info(info, params);
5860 return nl80211_parse_sta_wme(info, params);
5863 static int nl80211_parse_sta_txpower_setting(struct genl_info *info,
5864 struct station_parameters *params)
5866 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5869 if (info->attrs[NL80211_ATTR_STA_TX_POWER_SETTING]) {
5870 if (!rdev->ops->set_tx_power ||
5871 !wiphy_ext_feature_isset(&rdev->wiphy,
5872 NL80211_EXT_FEATURE_STA_TX_PWR))
5875 idx = NL80211_ATTR_STA_TX_POWER_SETTING;
5876 params->txpwr.type = nla_get_u8(info->attrs[idx]);
5878 if (params->txpwr.type == NL80211_TX_POWER_LIMITED) {
5879 idx = NL80211_ATTR_STA_TX_POWER;
5881 if (info->attrs[idx])
5882 params->txpwr.power =
5883 nla_get_s16(info->attrs[idx]);
5887 params->sta_modify_mask |= STATION_PARAM_APPLY_STA_TXPOWER;
5893 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
5895 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5896 struct net_device *dev = info->user_ptr[1];
5897 struct station_parameters params;
5901 memset(¶ms, 0, sizeof(params));
5903 if (!rdev->ops->change_station)
5907 * AID and listen_interval properties can be set only for unassociated
5908 * station. Include these parameters here and will check them in
5909 * cfg80211_check_station_change().
5911 if (info->attrs[NL80211_ATTR_STA_AID])
5912 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
5914 if (info->attrs[NL80211_ATTR_VLAN_ID])
5915 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
5917 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5918 params.listen_interval =
5919 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
5921 params.listen_interval = -1;
5923 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS])
5924 params.support_p2p_ps =
5925 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5927 params.support_p2p_ps = -1;
5929 if (!info->attrs[NL80211_ATTR_MAC])
5932 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5934 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
5935 params.supported_rates =
5936 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5937 params.supported_rates_len =
5938 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5941 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5943 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5944 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5947 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5949 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5950 params.ext_capab_len =
5951 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5954 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
5957 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
5958 params.plink_action =
5959 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5961 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
5962 params.plink_state =
5963 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
5964 if (info->attrs[NL80211_ATTR_MESH_PEER_AID])
5965 params.peer_aid = nla_get_u16(
5966 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
5967 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
5970 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE])
5971 params.local_pm = nla_get_u32(
5972 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
5974 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5975 params.opmode_notif_used = true;
5976 params.opmode_notif =
5977 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5980 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
5981 params.airtime_weight =
5982 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
5984 if (params.airtime_weight &&
5985 !wiphy_ext_feature_isset(&rdev->wiphy,
5986 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
5989 err = nl80211_parse_sta_txpower_setting(info, ¶ms);
5993 /* Include parameters for TDLS peer (will check later) */
5994 err = nl80211_set_station_tdls(info, ¶ms);
5998 params.vlan = get_vlan(info, rdev);
5999 if (IS_ERR(params.vlan))
6000 return PTR_ERR(params.vlan);
6002 switch (dev->ieee80211_ptr->iftype) {
6003 case NL80211_IFTYPE_AP:
6004 case NL80211_IFTYPE_AP_VLAN:
6005 case NL80211_IFTYPE_P2P_GO:
6006 case NL80211_IFTYPE_P2P_CLIENT:
6007 case NL80211_IFTYPE_STATION:
6008 case NL80211_IFTYPE_ADHOC:
6009 case NL80211_IFTYPE_MESH_POINT:
6016 /* driver will call cfg80211_check_station_change() */
6017 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
6021 dev_put(params.vlan);
6026 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
6028 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6030 struct net_device *dev = info->user_ptr[1];
6031 struct station_parameters params;
6032 u8 *mac_addr = NULL;
6033 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
6034 BIT(NL80211_STA_FLAG_ASSOCIATED);
6036 memset(¶ms, 0, sizeof(params));
6038 if (!rdev->ops->add_station)
6041 if (!info->attrs[NL80211_ATTR_MAC])
6044 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
6047 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
6050 if (!info->attrs[NL80211_ATTR_STA_AID] &&
6051 !info->attrs[NL80211_ATTR_PEER_AID])
6054 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
6055 params.supported_rates =
6056 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
6057 params.supported_rates_len =
6058 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
6059 params.listen_interval =
6060 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
6062 if (info->attrs[NL80211_ATTR_VLAN_ID])
6063 params.vlan_id = nla_get_u16(info->attrs[NL80211_ATTR_VLAN_ID]);
6065 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
6066 params.support_p2p_ps =
6067 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
6070 * if not specified, assume it's supported for P2P GO interface,
6071 * and is NOT supported for AP interface
6073 params.support_p2p_ps =
6074 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
6077 if (info->attrs[NL80211_ATTR_PEER_AID])
6078 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
6080 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
6082 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
6084 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
6085 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
6088 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
6090 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
6091 params.ext_capab_len =
6092 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
6095 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
6097 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
6099 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
6101 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
6103 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
6105 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
6106 params.he_capa_len =
6107 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
6109 /* max len is validated in nla policy */
6110 if (params.he_capa_len < NL80211_HE_MIN_CAPABILITY_LEN)
6114 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
6115 params.opmode_notif_used = true;
6116 params.opmode_notif =
6117 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
6120 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
6121 params.plink_action =
6122 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
6124 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
6125 params.airtime_weight =
6126 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
6128 if (params.airtime_weight &&
6129 !wiphy_ext_feature_isset(&rdev->wiphy,
6130 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
6133 err = nl80211_parse_sta_txpower_setting(info, ¶ms);
6137 err = nl80211_parse_sta_channel_info(info, ¶ms);
6141 err = nl80211_parse_sta_wme(info, ¶ms);
6145 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
6148 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
6149 * as userspace might just pass through the capabilities from the IEs
6150 * directly, rather than enforcing this restriction and returning an
6151 * error in this case.
6153 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
6154 params.ht_capa = NULL;
6155 params.vht_capa = NULL;
6157 /* HE requires WME */
6158 if (params.he_capa_len)
6162 /* When you run into this, adjust the code below for the new flag */
6163 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
6165 switch (dev->ieee80211_ptr->iftype) {
6166 case NL80211_IFTYPE_AP:
6167 case NL80211_IFTYPE_AP_VLAN:
6168 case NL80211_IFTYPE_P2P_GO:
6169 /* ignore WME attributes if iface/sta is not capable */
6170 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
6171 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
6172 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
6174 /* TDLS peers cannot be added */
6175 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
6176 info->attrs[NL80211_ATTR_PEER_AID])
6178 /* but don't bother the driver with it */
6179 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
6181 /* allow authenticated/associated only if driver handles it */
6182 if (!(rdev->wiphy.features &
6183 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
6184 params.sta_flags_mask & auth_assoc)
6187 /* Older userspace, or userspace wanting to be compatible with
6188 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
6189 * and assoc flags in the mask, but assumes the station will be
6190 * added as associated anyway since this was the required driver
6191 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
6193 * In order to not bother drivers with this quirk in the API
6194 * set the flags in both the mask and set for new stations in
6197 if (!(params.sta_flags_mask & auth_assoc)) {
6198 params.sta_flags_mask |= auth_assoc;
6199 params.sta_flags_set |= auth_assoc;
6202 /* must be last in here for error handling */
6203 params.vlan = get_vlan(info, rdev);
6204 if (IS_ERR(params.vlan))
6205 return PTR_ERR(params.vlan);
6207 case NL80211_IFTYPE_MESH_POINT:
6208 /* ignore uAPSD data */
6209 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
6211 /* associated is disallowed */
6212 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
6214 /* TDLS peers cannot be added */
6215 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
6216 info->attrs[NL80211_ATTR_PEER_AID])
6219 case NL80211_IFTYPE_STATION:
6220 case NL80211_IFTYPE_P2P_CLIENT:
6221 /* ignore uAPSD data */
6222 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
6224 /* these are disallowed */
6225 if (params.sta_flags_mask &
6226 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
6227 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
6229 /* Only TDLS peers can be added */
6230 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
6232 /* Can only add if TDLS ... */
6233 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
6235 /* ... with external setup is supported */
6236 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
6239 * Older wpa_supplicant versions always mark the TDLS peer
6240 * as authorized, but it shouldn't yet be.
6242 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
6248 /* be aware of params.vlan when changing code here */
6250 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
6253 dev_put(params.vlan);
6257 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
6259 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6260 struct net_device *dev = info->user_ptr[1];
6261 struct station_del_parameters params;
6263 memset(¶ms, 0, sizeof(params));
6265 if (info->attrs[NL80211_ATTR_MAC])
6266 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
6268 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6269 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
6270 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
6271 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6274 if (!rdev->ops->del_station)
6277 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
6279 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
6280 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
6281 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
6284 /* Default to Deauthentication frame */
6285 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
6288 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
6289 params.reason_code =
6290 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6291 if (params.reason_code == 0)
6292 return -EINVAL; /* 0 is reserved */
6294 /* Default to reason code 2 */
6295 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
6298 return rdev_del_station(rdev, dev, ¶ms);
6301 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
6302 int flags, struct net_device *dev,
6303 u8 *dst, u8 *next_hop,
6304 struct mpath_info *pinfo)
6307 struct nlattr *pinfoattr;
6309 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
6313 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6314 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
6315 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
6316 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
6317 goto nla_put_failure;
6319 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MPATH_INFO);
6321 goto nla_put_failure;
6322 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
6323 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
6325 goto nla_put_failure;
6326 if (((pinfo->filled & MPATH_INFO_SN) &&
6327 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
6328 ((pinfo->filled & MPATH_INFO_METRIC) &&
6329 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
6331 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
6332 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
6334 ((pinfo->filled & MPATH_INFO_FLAGS) &&
6335 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
6337 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
6338 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
6339 pinfo->discovery_timeout)) ||
6340 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
6341 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
6342 pinfo->discovery_retries)) ||
6343 ((pinfo->filled & MPATH_INFO_HOP_COUNT) &&
6344 nla_put_u8(msg, NL80211_MPATH_INFO_HOP_COUNT,
6345 pinfo->hop_count)) ||
6346 ((pinfo->filled & MPATH_INFO_PATH_CHANGE) &&
6347 nla_put_u32(msg, NL80211_MPATH_INFO_PATH_CHANGE,
6348 pinfo->path_change_count)))
6349 goto nla_put_failure;
6351 nla_nest_end(msg, pinfoattr);
6353 genlmsg_end(msg, hdr);
6357 genlmsg_cancel(msg, hdr);
6361 static int nl80211_dump_mpath(struct sk_buff *skb,
6362 struct netlink_callback *cb)
6364 struct mpath_info pinfo;
6365 struct cfg80211_registered_device *rdev;
6366 struct wireless_dev *wdev;
6368 u8 next_hop[ETH_ALEN];
6369 int path_idx = cb->args[2];
6373 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6377 if (!rdev->ops->dump_mpath) {
6382 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
6388 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
6395 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
6396 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6397 wdev->netdev, dst, next_hop,
6405 cb->args[2] = path_idx;
6412 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
6414 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6416 struct net_device *dev = info->user_ptr[1];
6417 struct mpath_info pinfo;
6418 struct sk_buff *msg;
6420 u8 next_hop[ETH_ALEN];
6422 memset(&pinfo, 0, sizeof(pinfo));
6424 if (!info->attrs[NL80211_ATTR_MAC])
6427 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6429 if (!rdev->ops->get_mpath)
6432 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6435 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
6439 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6443 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
6444 dev, dst, next_hop, &pinfo) < 0) {
6449 return genlmsg_reply(msg, info);
6452 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
6454 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6455 struct net_device *dev = info->user_ptr[1];
6457 u8 *next_hop = NULL;
6459 if (!info->attrs[NL80211_ATTR_MAC])
6462 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
6465 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6466 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
6468 if (!rdev->ops->change_mpath)
6471 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6474 return rdev_change_mpath(rdev, dev, dst, next_hop);
6477 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
6479 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6480 struct net_device *dev = info->user_ptr[1];
6482 u8 *next_hop = NULL;
6484 if (!info->attrs[NL80211_ATTR_MAC])
6487 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
6490 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6491 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
6493 if (!rdev->ops->add_mpath)
6496 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6499 return rdev_add_mpath(rdev, dev, dst, next_hop);
6502 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
6504 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6505 struct net_device *dev = info->user_ptr[1];
6508 if (info->attrs[NL80211_ATTR_MAC])
6509 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6511 if (!rdev->ops->del_mpath)
6514 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6517 return rdev_del_mpath(rdev, dev, dst);
6520 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
6522 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6524 struct net_device *dev = info->user_ptr[1];
6525 struct mpath_info pinfo;
6526 struct sk_buff *msg;
6530 memset(&pinfo, 0, sizeof(pinfo));
6532 if (!info->attrs[NL80211_ATTR_MAC])
6535 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6537 if (!rdev->ops->get_mpp)
6540 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6543 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
6547 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6551 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
6552 dev, dst, mpp, &pinfo) < 0) {
6557 return genlmsg_reply(msg, info);
6560 static int nl80211_dump_mpp(struct sk_buff *skb,
6561 struct netlink_callback *cb)
6563 struct mpath_info pinfo;
6564 struct cfg80211_registered_device *rdev;
6565 struct wireless_dev *wdev;
6568 int path_idx = cb->args[2];
6572 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6576 if (!rdev->ops->dump_mpp) {
6581 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
6587 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
6594 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
6595 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6596 wdev->netdev, dst, mpp,
6604 cb->args[2] = path_idx;
6611 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
6613 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6614 struct net_device *dev = info->user_ptr[1];
6615 struct wireless_dev *wdev = dev->ieee80211_ptr;
6616 struct bss_parameters params;
6619 memset(¶ms, 0, sizeof(params));
6620 /* default to not changing parameters */
6621 params.use_cts_prot = -1;
6622 params.use_short_preamble = -1;
6623 params.use_short_slot_time = -1;
6624 params.ap_isolate = -1;
6625 params.ht_opmode = -1;
6626 params.p2p_ctwindow = -1;
6627 params.p2p_opp_ps = -1;
6629 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
6630 params.use_cts_prot =
6631 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
6632 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
6633 params.use_short_preamble =
6634 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
6635 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
6636 params.use_short_slot_time =
6637 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
6638 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6639 params.basic_rates =
6640 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6641 params.basic_rates_len =
6642 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6644 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
6645 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
6646 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
6648 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
6650 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
6651 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6653 params.p2p_ctwindow =
6654 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
6655 if (params.p2p_ctwindow != 0 &&
6656 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
6660 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
6663 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6665 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
6666 params.p2p_opp_ps = tmp;
6667 if (params.p2p_opp_ps &&
6668 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
6672 if (!rdev->ops->change_bss)
6675 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6676 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6680 err = rdev_change_bss(rdev, dev, ¶ms);
6686 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
6690 enum nl80211_user_reg_hint_type user_reg_hint_type;
6694 * You should only get this when cfg80211 hasn't yet initialized
6695 * completely when built-in to the kernel right between the time
6696 * window between nl80211_init() and regulatory_init(), if that is
6699 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
6700 return -EINPROGRESS;
6702 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
6703 user_reg_hint_type =
6704 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
6706 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
6708 switch (user_reg_hint_type) {
6709 case NL80211_USER_REG_HINT_USER:
6710 case NL80211_USER_REG_HINT_CELL_BASE:
6711 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6714 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6715 return regulatory_hint_user(data, user_reg_hint_type);
6716 case NL80211_USER_REG_HINT_INDOOR:
6717 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
6718 owner_nlportid = info->snd_portid;
6719 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
6725 return regulatory_hint_indoor(is_indoor, owner_nlportid);
6731 static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info)
6733 return reg_reload_regdb();
6736 static int nl80211_get_mesh_config(struct sk_buff *skb,
6737 struct genl_info *info)
6739 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6740 struct net_device *dev = info->user_ptr[1];
6741 struct wireless_dev *wdev = dev->ieee80211_ptr;
6742 struct mesh_config cur_params;
6745 struct nlattr *pinfoattr;
6746 struct sk_buff *msg;
6748 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6751 if (!rdev->ops->get_mesh_config)
6755 /* If not connected, get default parameters */
6756 if (!wdev->mesh_id_len)
6757 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
6759 err = rdev_get_mesh_config(rdev, dev, &cur_params);
6765 /* Draw up a netlink message to send back */
6766 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6769 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6770 NL80211_CMD_GET_MESH_CONFIG);
6773 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MESH_CONFIG);
6775 goto nla_put_failure;
6776 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6777 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
6778 cur_params.dot11MeshRetryTimeout) ||
6779 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
6780 cur_params.dot11MeshConfirmTimeout) ||
6781 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
6782 cur_params.dot11MeshHoldingTimeout) ||
6783 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
6784 cur_params.dot11MeshMaxPeerLinks) ||
6785 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
6786 cur_params.dot11MeshMaxRetries) ||
6787 nla_put_u8(msg, NL80211_MESHCONF_TTL,
6788 cur_params.dot11MeshTTL) ||
6789 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
6790 cur_params.element_ttl) ||
6791 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
6792 cur_params.auto_open_plinks) ||
6793 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
6794 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
6795 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
6796 cur_params.dot11MeshHWMPmaxPREQretries) ||
6797 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
6798 cur_params.path_refresh_time) ||
6799 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
6800 cur_params.min_discovery_timeout) ||
6801 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
6802 cur_params.dot11MeshHWMPactivePathTimeout) ||
6803 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
6804 cur_params.dot11MeshHWMPpreqMinInterval) ||
6805 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
6806 cur_params.dot11MeshHWMPperrMinInterval) ||
6807 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
6808 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
6809 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
6810 cur_params.dot11MeshHWMPRootMode) ||
6811 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
6812 cur_params.dot11MeshHWMPRannInterval) ||
6813 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
6814 cur_params.dot11MeshGateAnnouncementProtocol) ||
6815 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
6816 cur_params.dot11MeshForwarding) ||
6817 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
6818 cur_params.rssi_threshold) ||
6819 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
6820 cur_params.ht_opmode) ||
6821 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
6822 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
6823 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
6824 cur_params.dot11MeshHWMProotInterval) ||
6825 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
6826 cur_params.dot11MeshHWMPconfirmationInterval) ||
6827 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
6828 cur_params.power_mode) ||
6829 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
6830 cur_params.dot11MeshAwakeWindowDuration) ||
6831 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
6832 cur_params.plink_timeout) ||
6833 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_GATE,
6834 cur_params.dot11MeshConnectedToMeshGate))
6835 goto nla_put_failure;
6836 nla_nest_end(msg, pinfoattr);
6837 genlmsg_end(msg, hdr);
6838 return genlmsg_reply(msg, info);
6846 static const struct nla_policy
6847 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
6848 [NL80211_MESHCONF_RETRY_TIMEOUT] =
6849 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6850 [NL80211_MESHCONF_CONFIRM_TIMEOUT] =
6851 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6852 [NL80211_MESHCONF_HOLDING_TIMEOUT] =
6853 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6854 [NL80211_MESHCONF_MAX_PEER_LINKS] =
6855 NLA_POLICY_RANGE(NLA_U16, 0, 255),
6856 [NL80211_MESHCONF_MAX_RETRIES] = NLA_POLICY_MAX(NLA_U8, 16),
6857 [NL80211_MESHCONF_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
6858 [NL80211_MESHCONF_ELEMENT_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
6859 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = NLA_POLICY_MAX(NLA_U8, 1),
6860 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] =
6861 NLA_POLICY_RANGE(NLA_U32, 1, 255),
6862 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
6863 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
6864 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = NLA_POLICY_MIN(NLA_U16, 1),
6865 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
6866 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] =
6867 NLA_POLICY_MIN(NLA_U16, 1),
6868 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] =
6869 NLA_POLICY_MIN(NLA_U16, 1),
6870 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] =
6871 NLA_POLICY_MIN(NLA_U16, 1),
6872 [NL80211_MESHCONF_HWMP_ROOTMODE] = NLA_POLICY_MAX(NLA_U8, 4),
6873 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] =
6874 NLA_POLICY_MIN(NLA_U16, 1),
6875 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = NLA_POLICY_MAX(NLA_U8, 1),
6876 [NL80211_MESHCONF_FORWARDING] = NLA_POLICY_MAX(NLA_U8, 1),
6877 [NL80211_MESHCONF_RSSI_THRESHOLD] =
6878 NLA_POLICY_RANGE(NLA_S32, -255, 0),
6879 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
6880 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
6881 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] =
6882 NLA_POLICY_MIN(NLA_U16, 1),
6883 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] =
6884 NLA_POLICY_MIN(NLA_U16, 1),
6885 [NL80211_MESHCONF_POWER_MODE] =
6886 NLA_POLICY_RANGE(NLA_U32,
6887 NL80211_MESH_POWER_ACTIVE,
6888 NL80211_MESH_POWER_MAX),
6889 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
6890 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
6891 [NL80211_MESHCONF_CONNECTED_TO_GATE] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
6894 static const struct nla_policy
6895 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
6896 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
6897 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
6898 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
6899 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6900 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
6901 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
6902 [NL80211_MESH_SETUP_IE] =
6903 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
6904 IEEE80211_MAX_DATA_LEN),
6905 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
6908 static int nl80211_parse_mesh_config(struct genl_info *info,
6909 struct mesh_config *cfg,
6912 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
6916 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \
6919 cfg->param = fn(tb[attr]); \
6920 mask |= BIT((attr) - 1); \
6924 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
6926 if (nla_parse_nested_deprecated(tb, NL80211_MESHCONF_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_CONFIG], nl80211_meshconf_params_policy, info->extack))
6929 /* This makes sure that there aren't more than 32 mesh config
6930 * parameters (otherwise our bitfield scheme would not work.) */
6931 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
6933 /* Fill in the params struct */
6934 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, mask,
6935 NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
6936 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, mask,
6937 NL80211_MESHCONF_CONFIRM_TIMEOUT,
6939 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, mask,
6940 NL80211_MESHCONF_HOLDING_TIMEOUT,
6942 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, mask,
6943 NL80211_MESHCONF_MAX_PEER_LINKS,
6945 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, mask,
6946 NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
6947 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, mask,
6948 NL80211_MESHCONF_TTL, nla_get_u8);
6949 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, mask,
6950 NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
6951 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, mask,
6952 NL80211_MESHCONF_AUTO_OPEN_PLINKS,
6954 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
6956 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
6958 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, mask,
6959 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
6961 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, mask,
6962 NL80211_MESHCONF_PATH_REFRESH_TIME,
6964 if (mask & BIT(NL80211_MESHCONF_PATH_REFRESH_TIME) &&
6965 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535))
6967 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, mask,
6968 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
6970 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
6972 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
6974 if (mask & BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT) &&
6975 (cfg->dot11MeshHWMPactivePathTimeout < 1 ||
6976 cfg->dot11MeshHWMPactivePathTimeout > 65535))
6978 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, mask,
6979 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
6981 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval, mask,
6982 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
6984 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
6985 dot11MeshHWMPnetDiameterTraversalTime, mask,
6986 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
6988 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask,
6989 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8);
6990 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask,
6991 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
6993 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshGateAnnouncementProtocol,
6994 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
6996 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, mask,
6997 NL80211_MESHCONF_FORWARDING, nla_get_u8);
6998 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, mask,
6999 NL80211_MESHCONF_RSSI_THRESHOLD,
7001 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToMeshGate, mask,
7002 NL80211_MESHCONF_CONNECTED_TO_GATE,
7005 * Check HT operation mode based on
7006 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
7008 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
7009 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
7011 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
7012 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
7013 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
7016 /* NON_HT_STA bit is reserved, but some programs set it */
7017 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
7019 cfg->ht_opmode = ht_opmode;
7020 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
7022 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
7023 dot11MeshHWMPactivePathToRootTimeout, mask,
7024 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
7026 if (mask & BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT) &&
7027 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 ||
7028 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535))
7030 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, mask,
7031 NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
7033 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPconfirmationInterval,
7035 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
7037 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode, mask,
7038 NL80211_MESHCONF_POWER_MODE, nla_get_u32);
7039 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration, mask,
7040 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
7041 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, mask,
7042 NL80211_MESHCONF_PLINK_TIMEOUT, nla_get_u32);
7048 #undef FILL_IN_MESH_PARAM_IF_SET
7051 static int nl80211_parse_mesh_setup(struct genl_info *info,
7052 struct mesh_setup *setup)
7054 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7055 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
7057 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
7059 if (nla_parse_nested_deprecated(tb, NL80211_MESH_SETUP_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_SETUP], nl80211_mesh_setup_params_policy, info->extack))
7062 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
7063 setup->sync_method =
7064 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
7065 IEEE80211_SYNC_METHOD_VENDOR :
7066 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
7068 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
7069 setup->path_sel_proto =
7070 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
7071 IEEE80211_PATH_PROTOCOL_VENDOR :
7072 IEEE80211_PATH_PROTOCOL_HWMP;
7074 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
7075 setup->path_metric =
7076 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
7077 IEEE80211_PATH_METRIC_VENDOR :
7078 IEEE80211_PATH_METRIC_AIRTIME;
7080 if (tb[NL80211_MESH_SETUP_IE]) {
7081 struct nlattr *ieattr =
7082 tb[NL80211_MESH_SETUP_IE];
7083 setup->ie = nla_data(ieattr);
7084 setup->ie_len = nla_len(ieattr);
7086 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
7087 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
7089 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
7090 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
7091 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
7092 if (setup->is_secure)
7093 setup->user_mpm = true;
7095 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
7096 if (!setup->user_mpm)
7099 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
7105 static int nl80211_update_mesh_config(struct sk_buff *skb,
7106 struct genl_info *info)
7108 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7109 struct net_device *dev = info->user_ptr[1];
7110 struct wireless_dev *wdev = dev->ieee80211_ptr;
7111 struct mesh_config cfg;
7115 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
7118 if (!rdev->ops->update_mesh_config)
7121 err = nl80211_parse_mesh_config(info, &cfg, &mask);
7126 if (!wdev->mesh_id_len)
7130 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
7137 static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
7138 struct sk_buff *msg)
7140 struct nlattr *nl_reg_rules;
7143 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
7144 (regdom->dfs_region &&
7145 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
7146 goto nla_put_failure;
7148 nl_reg_rules = nla_nest_start_noflag(msg, NL80211_ATTR_REG_RULES);
7150 goto nla_put_failure;
7152 for (i = 0; i < regdom->n_reg_rules; i++) {
7153 struct nlattr *nl_reg_rule;
7154 const struct ieee80211_reg_rule *reg_rule;
7155 const struct ieee80211_freq_range *freq_range;
7156 const struct ieee80211_power_rule *power_rule;
7157 unsigned int max_bandwidth_khz;
7159 reg_rule = ®dom->reg_rules[i];
7160 freq_range = ®_rule->freq_range;
7161 power_rule = ®_rule->power_rule;
7163 nl_reg_rule = nla_nest_start_noflag(msg, i);
7165 goto nla_put_failure;
7167 max_bandwidth_khz = freq_range->max_bandwidth_khz;
7168 if (!max_bandwidth_khz)
7169 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
7172 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
7174 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
7175 freq_range->start_freq_khz) ||
7176 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
7177 freq_range->end_freq_khz) ||
7178 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
7179 max_bandwidth_khz) ||
7180 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
7181 power_rule->max_antenna_gain) ||
7182 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
7183 power_rule->max_eirp) ||
7184 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
7185 reg_rule->dfs_cac_ms))
7186 goto nla_put_failure;
7188 nla_nest_end(msg, nl_reg_rule);
7191 nla_nest_end(msg, nl_reg_rules);
7198 static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
7200 const struct ieee80211_regdomain *regdom = NULL;
7201 struct cfg80211_registered_device *rdev;
7202 struct wiphy *wiphy = NULL;
7203 struct sk_buff *msg;
7206 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7210 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7211 NL80211_CMD_GET_REG);
7215 if (info->attrs[NL80211_ATTR_WIPHY]) {
7218 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
7221 return PTR_ERR(rdev);
7224 wiphy = &rdev->wiphy;
7225 self_managed = wiphy->regulatory_flags &
7226 REGULATORY_WIPHY_SELF_MANAGED;
7227 regdom = get_wiphy_regdom(wiphy);
7229 /* a self-managed-reg device must have a private regdom */
7230 if (WARN_ON(!regdom && self_managed)) {
7236 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7237 goto nla_put_failure;
7240 if (!wiphy && reg_last_request_cell_base() &&
7241 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
7242 NL80211_USER_REG_HINT_CELL_BASE))
7243 goto nla_put_failure;
7248 regdom = rcu_dereference(cfg80211_regdomain);
7250 if (nl80211_put_regdom(regdom, msg))
7251 goto nla_put_failure_rcu;
7255 genlmsg_end(msg, hdr);
7256 return genlmsg_reply(msg, info);
7258 nla_put_failure_rcu:
7266 static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
7267 u32 seq, int flags, struct wiphy *wiphy,
7268 const struct ieee80211_regdomain *regdom)
7270 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
7271 NL80211_CMD_GET_REG);
7276 genl_dump_check_consistent(cb, hdr);
7278 if (nl80211_put_regdom(regdom, msg))
7279 goto nla_put_failure;
7281 if (!wiphy && reg_last_request_cell_base() &&
7282 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
7283 NL80211_USER_REG_HINT_CELL_BASE))
7284 goto nla_put_failure;
7287 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7288 goto nla_put_failure;
7290 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
7291 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
7292 goto nla_put_failure;
7294 genlmsg_end(msg, hdr);
7298 genlmsg_cancel(msg, hdr);
7302 static int nl80211_get_reg_dump(struct sk_buff *skb,
7303 struct netlink_callback *cb)
7305 const struct ieee80211_regdomain *regdom = NULL;
7306 struct cfg80211_registered_device *rdev;
7307 int err, reg_idx, start = cb->args[2];
7311 if (cfg80211_regdomain && start == 0) {
7312 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
7314 rtnl_dereference(cfg80211_regdomain));
7319 /* the global regdom is idx 0 */
7321 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
7322 regdom = get_wiphy_regdom(&rdev->wiphy);
7326 if (++reg_idx <= start)
7329 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
7330 NLM_F_MULTI, &rdev->wiphy, regdom);
7337 cb->args[2] = reg_idx;
7344 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
7345 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
7346 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
7347 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
7348 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
7349 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
7350 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
7351 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
7352 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
7355 static int parse_reg_rule(struct nlattr *tb[],
7356 struct ieee80211_reg_rule *reg_rule)
7358 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
7359 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
7361 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
7363 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
7365 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
7367 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
7369 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
7372 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
7374 freq_range->start_freq_khz =
7375 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
7376 freq_range->end_freq_khz =
7377 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
7378 freq_range->max_bandwidth_khz =
7379 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
7381 power_rule->max_eirp =
7382 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
7384 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
7385 power_rule->max_antenna_gain =
7386 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
7388 if (tb[NL80211_ATTR_DFS_CAC_TIME])
7389 reg_rule->dfs_cac_ms =
7390 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
7395 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
7397 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
7398 struct nlattr *nl_reg_rule;
7400 int rem_reg_rules, r;
7401 u32 num_rules = 0, rule_idx = 0;
7402 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
7403 struct ieee80211_regdomain *rd;
7405 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
7408 if (!info->attrs[NL80211_ATTR_REG_RULES])
7411 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
7413 if (info->attrs[NL80211_ATTR_DFS_REGION])
7414 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
7416 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
7419 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
7423 if (!reg_is_valid_request(alpha2))
7426 rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL);
7430 rd->n_reg_rules = num_rules;
7431 rd->alpha2[0] = alpha2[0];
7432 rd->alpha2[1] = alpha2[1];
7435 * Disable DFS master mode if the DFS region was
7436 * not supported or known on this kernel.
7438 if (reg_supported_dfs_region(dfs_region))
7439 rd->dfs_region = dfs_region;
7441 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
7443 r = nla_parse_nested_deprecated(tb, NL80211_REG_RULE_ATTR_MAX,
7444 nl_reg_rule, reg_rule_policy,
7448 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
7454 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
7460 /* set_regdom takes ownership of rd */
7461 return set_regdom(rd, REGD_SOURCE_CRDA);
7466 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
7468 static int validate_scan_freqs(struct nlattr *freqs)
7470 struct nlattr *attr1, *attr2;
7471 int n_channels = 0, tmp1, tmp2;
7473 nla_for_each_nested(attr1, freqs, tmp1)
7474 if (nla_len(attr1) != sizeof(u32))
7477 nla_for_each_nested(attr1, freqs, tmp1) {
7480 * Some hardware has a limited channel list for
7481 * scanning, and it is pretty much nonsensical
7482 * to scan for a channel twice, so disallow that
7483 * and don't require drivers to check that the
7484 * channel list they get isn't longer than what
7485 * they can scan, as long as they can scan all
7486 * the channels they registered at once.
7488 nla_for_each_nested(attr2, freqs, tmp2)
7489 if (attr1 != attr2 &&
7490 nla_get_u32(attr1) == nla_get_u32(attr2))
7497 static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
7499 return b < NUM_NL80211_BANDS && wiphy->bands[b];
7502 static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
7503 struct cfg80211_bss_selection *bss_select)
7505 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
7506 struct nlattr *nest;
7511 /* only process one nested attribute */
7512 nest = nla_data(nla);
7513 if (!nla_ok(nest, nla_len(nest)))
7516 err = nla_parse_nested_deprecated(attr, NL80211_BSS_SELECT_ATTR_MAX,
7517 nest, nl80211_bss_select_policy,
7522 /* only one attribute may be given */
7523 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
7531 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
7533 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
7534 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
7536 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
7537 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
7538 bss_select->param.band_pref =
7539 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
7540 if (!is_band_valid(wiphy, bss_select->param.band_pref))
7544 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
7545 struct nl80211_bss_select_rssi_adjust *adj_param;
7547 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
7548 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
7549 bss_select->param.adjust.band = adj_param->band;
7550 bss_select->param.adjust.delta = adj_param->delta;
7551 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
7555 /* user-space did not provide behaviour attribute */
7556 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
7559 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
7565 int nl80211_parse_random_mac(struct nlattr **attrs,
7566 u8 *mac_addr, u8 *mac_addr_mask)
7570 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
7571 eth_zero_addr(mac_addr);
7572 eth_zero_addr(mac_addr_mask);
7574 mac_addr_mask[0] = 0x3;
7579 /* need both or none */
7580 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
7583 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
7584 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
7586 /* don't allow or configure an mcast address */
7587 if (!is_multicast_ether_addr(mac_addr_mask) ||
7588 is_multicast_ether_addr(mac_addr))
7592 * allow users to pass a MAC address that has bits set outside
7593 * of the mask, but don't bother drivers with having to deal
7596 for (i = 0; i < ETH_ALEN; i++)
7597 mac_addr[i] &= mac_addr_mask[i];
7602 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
7604 ASSERT_WDEV_LOCK(wdev);
7606 if (!cfg80211_beaconing_iface_active(wdev))
7609 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
7612 return regulatory_pre_cac_allowed(wdev->wiphy);
7615 static bool nl80211_check_scan_feat(struct wiphy *wiphy, u32 flags, u32 flag,
7616 enum nl80211_ext_feature_index feat)
7618 if (!(flags & flag))
7620 if (wiphy_ext_feature_isset(wiphy, feat))
7626 nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
7627 void *request, struct nlattr **attrs,
7630 u8 *mac_addr, *mac_addr_mask;
7632 enum nl80211_feature_flags randomness_flag;
7634 if (!attrs[NL80211_ATTR_SCAN_FLAGS])
7637 if (is_sched_scan) {
7638 struct cfg80211_sched_scan_request *req = request;
7640 randomness_flag = wdev ?
7641 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR :
7642 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7643 flags = &req->flags;
7644 mac_addr = req->mac_addr;
7645 mac_addr_mask = req->mac_addr_mask;
7647 struct cfg80211_scan_request *req = request;
7649 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
7650 flags = &req->flags;
7651 mac_addr = req->mac_addr;
7652 mac_addr_mask = req->mac_addr_mask;
7655 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
7657 if (((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
7658 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
7659 !nl80211_check_scan_feat(wiphy, *flags,
7660 NL80211_SCAN_FLAG_LOW_SPAN,
7661 NL80211_EXT_FEATURE_LOW_SPAN_SCAN) ||
7662 !nl80211_check_scan_feat(wiphy, *flags,
7663 NL80211_SCAN_FLAG_LOW_POWER,
7664 NL80211_EXT_FEATURE_LOW_POWER_SCAN) ||
7665 !nl80211_check_scan_feat(wiphy, *flags,
7666 NL80211_SCAN_FLAG_HIGH_ACCURACY,
7667 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN) ||
7668 !nl80211_check_scan_feat(wiphy, *flags,
7669 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME,
7670 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) ||
7671 !nl80211_check_scan_feat(wiphy, *flags,
7672 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP,
7673 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) ||
7674 !nl80211_check_scan_feat(wiphy, *flags,
7675 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION,
7676 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) ||
7677 !nl80211_check_scan_feat(wiphy, *flags,
7678 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE,
7679 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) ||
7680 !nl80211_check_scan_feat(wiphy, *flags,
7681 NL80211_SCAN_FLAG_RANDOM_SN,
7682 NL80211_EXT_FEATURE_SCAN_RANDOM_SN) ||
7683 !nl80211_check_scan_feat(wiphy, *flags,
7684 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT,
7685 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
7688 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
7691 if (!(wiphy->features & randomness_flag) ||
7692 (wdev && wdev->current_bss))
7695 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask);
7703 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
7705 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7706 struct wireless_dev *wdev = info->user_ptr[1];
7707 struct cfg80211_scan_request *request;
7708 struct nlattr *attr;
7709 struct wiphy *wiphy;
7710 int err, tmp, n_ssids = 0, n_channels, i;
7713 wiphy = &rdev->wiphy;
7715 if (wdev->iftype == NL80211_IFTYPE_NAN)
7718 if (!rdev->ops->scan)
7721 if (rdev->scan_req || rdev->scan_msg) {
7726 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7727 n_channels = validate_scan_freqs(
7728 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
7734 n_channels = ieee80211_get_num_supported_channels(wiphy);
7737 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
7738 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
7741 if (n_ssids > wiphy->max_scan_ssids) {
7746 if (info->attrs[NL80211_ATTR_IE])
7747 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7751 if (ie_len > wiphy->max_scan_ie_len) {
7756 request = kzalloc(sizeof(*request)
7757 + sizeof(*request->ssids) * n_ssids
7758 + sizeof(*request->channels) * n_channels
7759 + ie_len, GFP_KERNEL);
7766 request->ssids = (void *)&request->channels[n_channels];
7767 request->n_ssids = n_ssids;
7770 request->ie = (void *)(request->ssids + n_ssids);
7772 request->ie = (void *)(request->channels + n_channels);
7776 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7777 /* user specified, bail out if channel not found */
7778 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
7779 struct ieee80211_channel *chan;
7781 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7788 /* ignore disabled channels */
7789 if (chan->flags & IEEE80211_CHAN_DISABLED)
7792 request->channels[i] = chan;
7796 enum nl80211_band band;
7799 for (band = 0; band < NUM_NL80211_BANDS; band++) {
7802 if (!wiphy->bands[band])
7804 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7805 struct ieee80211_channel *chan;
7807 chan = &wiphy->bands[band]->channels[j];
7809 if (chan->flags & IEEE80211_CHAN_DISABLED)
7812 request->channels[i] = chan;
7823 request->n_channels = i;
7826 if (!cfg80211_off_channel_oper_allowed(wdev)) {
7827 struct ieee80211_channel *chan;
7829 if (request->n_channels != 1) {
7835 chan = request->channels[0];
7836 if (chan->center_freq != wdev->chandef.chan->center_freq) {
7846 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
7847 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
7851 request->ssids[i].ssid_len = nla_len(attr);
7852 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
7857 if (info->attrs[NL80211_ATTR_IE]) {
7858 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7859 memcpy((void *)request->ie,
7860 nla_data(info->attrs[NL80211_ATTR_IE]),
7864 for (i = 0; i < NUM_NL80211_BANDS; i++)
7865 if (wiphy->bands[i])
7867 (1 << wiphy->bands[i]->n_bitrates) - 1;
7869 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
7870 nla_for_each_nested(attr,
7871 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
7873 enum nl80211_band band = nla_type(attr);
7875 if (band < 0 || band >= NUM_NL80211_BANDS) {
7880 if (!wiphy->bands[band])
7883 err = ieee80211_get_ratemask(wiphy->bands[band],
7886 &request->rates[band]);
7892 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
7893 if (!wiphy_ext_feature_isset(wiphy,
7894 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
7900 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
7901 request->duration_mandatory =
7902 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
7905 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
7911 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
7913 /* Initial implementation used NL80211_ATTR_MAC to set the specific
7914 * BSSID to scan for. This was problematic because that same attribute
7915 * was already used for another purpose (local random MAC address). The
7916 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
7917 * compatibility with older userspace components, also use the
7918 * NL80211_ATTR_MAC value here if it can be determined to be used for
7919 * the specific BSSID use case instead of the random MAC address
7920 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
7922 if (info->attrs[NL80211_ATTR_BSSID])
7923 memcpy(request->bssid,
7924 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
7925 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
7926 info->attrs[NL80211_ATTR_MAC])
7927 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
7930 eth_broadcast_addr(request->bssid);
7932 request->wdev = wdev;
7933 request->wiphy = &rdev->wiphy;
7934 request->scan_start = jiffies;
7936 rdev->scan_req = request;
7937 err = rdev_scan(rdev, request);
7940 nl80211_send_scan_start(rdev, wdev);
7942 dev_hold(wdev->netdev);
7945 rdev->scan_req = NULL;
7953 static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
7955 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7956 struct wireless_dev *wdev = info->user_ptr[1];
7958 if (!rdev->ops->abort_scan)
7964 if (!rdev->scan_req)
7967 rdev_abort_scan(rdev, wdev);
7972 nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
7973 struct cfg80211_sched_scan_request *request,
7974 struct nlattr **attrs)
7976 int tmp, err, i = 0;
7977 struct nlattr *attr;
7979 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7983 * If scan plans are not specified,
7984 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
7985 * case one scan plan will be set with the specified scan
7986 * interval and infinite number of iterations.
7988 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
7992 request->scan_plans[0].interval =
7993 DIV_ROUND_UP(interval, MSEC_PER_SEC);
7994 if (!request->scan_plans[0].interval)
7997 if (request->scan_plans[0].interval >
7998 wiphy->max_sched_scan_plan_interval)
7999 request->scan_plans[0].interval =
8000 wiphy->max_sched_scan_plan_interval;
8005 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
8006 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
8008 if (WARN_ON(i >= n_plans))
8011 err = nla_parse_nested_deprecated(plan,
8012 NL80211_SCHED_SCAN_PLAN_MAX,
8013 attr, nl80211_plan_policy,
8018 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
8021 request->scan_plans[i].interval =
8022 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
8023 if (!request->scan_plans[i].interval ||
8024 request->scan_plans[i].interval >
8025 wiphy->max_sched_scan_plan_interval)
8028 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
8029 request->scan_plans[i].iterations =
8030 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
8031 if (!request->scan_plans[i].iterations ||
8032 (request->scan_plans[i].iterations >
8033 wiphy->max_sched_scan_plan_iterations))
8035 } else if (i < n_plans - 1) {
8037 * All scan plans but the last one must specify
8038 * a finite number of iterations
8047 * The last scan plan must not specify the number of
8048 * iterations, it is supposed to run infinitely
8050 if (request->scan_plans[n_plans - 1].iterations)
8057 nl80211_parse_sched_scan_per_band_rssi(struct wiphy *wiphy,
8058 struct cfg80211_match_set *match_sets,
8059 struct nlattr *tb_band_rssi,
8062 struct nlattr *attr;
8063 int i, tmp, ret = 0;
8065 if (!wiphy_ext_feature_isset(wiphy,
8066 NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD)) {
8070 for (i = 0; i < NUM_NL80211_BANDS; i++)
8071 match_sets->per_band_rssi_thold[i] =
8072 NL80211_SCAN_RSSI_THOLD_OFF;
8076 for (i = 0; i < NUM_NL80211_BANDS; i++)
8077 match_sets->per_band_rssi_thold[i] = rssi_thold;
8079 nla_for_each_nested(attr, tb_band_rssi, tmp) {
8080 enum nl80211_band band = nla_type(attr);
8082 if (band < 0 || band >= NUM_NL80211_BANDS)
8085 match_sets->per_band_rssi_thold[band] = nla_get_s32(attr);
8091 static struct cfg80211_sched_scan_request *
8092 nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
8093 struct nlattr **attrs, int max_match_sets)
8095 struct cfg80211_sched_scan_request *request;
8096 struct nlattr *attr;
8097 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
8098 enum nl80211_band band;
8100 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
8101 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
8103 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
8104 n_channels = validate_scan_freqs(
8105 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
8107 return ERR_PTR(-EINVAL);
8109 n_channels = ieee80211_get_num_supported_channels(wiphy);
8112 if (attrs[NL80211_ATTR_SCAN_SSIDS])
8113 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
8117 if (n_ssids > wiphy->max_sched_scan_ssids)
8118 return ERR_PTR(-EINVAL);
8121 * First, count the number of 'real' matchsets. Due to an issue with
8122 * the old implementation, matchsets containing only the RSSI attribute
8123 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
8124 * RSSI for all matchsets, rather than their own matchset for reporting
8125 * all APs with a strong RSSI. This is needed to be compatible with
8126 * older userspace that treated a matchset with only the RSSI as the
8127 * global RSSI for all other matchsets - if there are other matchsets.
8129 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
8130 nla_for_each_nested(attr,
8131 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
8133 struct nlattr *rssi;
8135 err = nla_parse_nested_deprecated(tb,
8136 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
8138 nl80211_match_policy,
8141 return ERR_PTR(err);
8143 /* SSID and BSSID are mutually exclusive */
8144 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
8145 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
8146 return ERR_PTR(-EINVAL);
8148 /* add other standalone attributes here */
8149 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
8150 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
8154 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
8156 default_match_rssi = nla_get_s32(rssi);
8160 /* However, if there's no other matchset, add the RSSI one */
8161 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
8164 if (n_match_sets > max_match_sets)
8165 return ERR_PTR(-EINVAL);
8167 if (attrs[NL80211_ATTR_IE])
8168 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
8172 if (ie_len > wiphy->max_sched_scan_ie_len)
8173 return ERR_PTR(-EINVAL);
8175 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
8177 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
8178 * each scan plan already specifies its own interval
8180 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
8181 return ERR_PTR(-EINVAL);
8183 nla_for_each_nested(attr,
8184 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
8188 * The scan interval attribute is kept for backward
8189 * compatibility. If no scan plans are specified and sched scan
8190 * interval is specified, one scan plan will be set with this
8191 * scan interval and infinite number of iterations.
8193 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
8194 return ERR_PTR(-EINVAL);
8199 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
8200 return ERR_PTR(-EINVAL);
8202 if (!wiphy_ext_feature_isset(
8203 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
8204 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
8205 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
8206 return ERR_PTR(-EINVAL);
8208 request = kzalloc(sizeof(*request)
8209 + sizeof(*request->ssids) * n_ssids
8210 + sizeof(*request->match_sets) * n_match_sets
8211 + sizeof(*request->scan_plans) * n_plans
8212 + sizeof(*request->channels) * n_channels
8213 + ie_len, GFP_KERNEL);
8215 return ERR_PTR(-ENOMEM);
8218 request->ssids = (void *)&request->channels[n_channels];
8219 request->n_ssids = n_ssids;
8222 request->ie = (void *)(request->ssids + n_ssids);
8224 request->ie = (void *)(request->channels + n_channels);
8229 request->match_sets = (void *)(request->ie + ie_len);
8231 request->match_sets =
8232 (void *)(request->ssids + n_ssids);
8234 request->match_sets =
8235 (void *)(request->channels + n_channels);
8237 request->n_match_sets = n_match_sets;
8240 request->scan_plans = (void *)(request->match_sets +
8242 else if (request->ie)
8243 request->scan_plans = (void *)(request->ie + ie_len);
8245 request->scan_plans = (void *)(request->ssids + n_ssids);
8247 request->scan_plans = (void *)(request->channels + n_channels);
8249 request->n_scan_plans = n_plans;
8252 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
8253 /* user specified, bail out if channel not found */
8254 nla_for_each_nested(attr,
8255 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
8257 struct ieee80211_channel *chan;
8259 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
8266 /* ignore disabled channels */
8267 if (chan->flags & IEEE80211_CHAN_DISABLED)
8270 request->channels[i] = chan;
8275 for (band = 0; band < NUM_NL80211_BANDS; band++) {
8278 if (!wiphy->bands[band])
8280 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
8281 struct ieee80211_channel *chan;
8283 chan = &wiphy->bands[band]->channels[j];
8285 if (chan->flags & IEEE80211_CHAN_DISABLED)
8288 request->channels[i] = chan;
8299 request->n_channels = i;
8303 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
8305 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
8309 request->ssids[i].ssid_len = nla_len(attr);
8310 memcpy(request->ssids[i].ssid, nla_data(attr),
8317 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
8318 nla_for_each_nested(attr,
8319 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
8321 struct nlattr *ssid, *bssid, *rssi;
8323 err = nla_parse_nested_deprecated(tb,
8324 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
8326 nl80211_match_policy,
8330 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
8331 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
8333 if (!ssid && !bssid) {
8338 if (WARN_ON(i >= n_match_sets)) {
8339 /* this indicates a programming error,
8340 * the loop above should have verified
8348 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
8352 memcpy(request->match_sets[i].ssid.ssid,
8353 nla_data(ssid), nla_len(ssid));
8354 request->match_sets[i].ssid.ssid_len =
8358 if (nla_len(bssid) != ETH_ALEN) {
8362 memcpy(request->match_sets[i].bssid,
8363 nla_data(bssid), ETH_ALEN);
8366 /* special attribute - old implementation w/a */
8367 request->match_sets[i].rssi_thold = default_match_rssi;
8368 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
8370 request->match_sets[i].rssi_thold =
8373 /* Parse per band RSSI attribute */
8374 err = nl80211_parse_sched_scan_per_band_rssi(wiphy,
8375 &request->match_sets[i],
8376 tb[NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI],
8377 request->match_sets[i].rssi_thold);
8384 /* there was no other matchset, so the RSSI one is alone */
8385 if (i == 0 && n_match_sets)
8386 request->match_sets[0].rssi_thold = default_match_rssi;
8388 request->min_rssi_thold = INT_MAX;
8389 for (i = 0; i < n_match_sets; i++)
8390 request->min_rssi_thold =
8391 min(request->match_sets[i].rssi_thold,
8392 request->min_rssi_thold);
8394 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
8398 request->ie_len = ie_len;
8399 memcpy((void *)request->ie,
8400 nla_data(attrs[NL80211_ATTR_IE]),
8404 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true);
8408 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
8410 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
8412 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
8413 request->relative_rssi = nla_get_s8(
8414 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
8415 request->relative_rssi_set = true;
8418 if (request->relative_rssi_set &&
8419 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
8420 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
8422 rssi_adjust = nla_data(
8423 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
8424 request->rssi_adjust.band = rssi_adjust->band;
8425 request->rssi_adjust.delta = rssi_adjust->delta;
8426 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
8432 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
8436 request->scan_start = jiffies;
8442 return ERR_PTR(err);
8445 static int nl80211_start_sched_scan(struct sk_buff *skb,
8446 struct genl_info *info)
8448 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8449 struct net_device *dev = info->user_ptr[1];
8450 struct wireless_dev *wdev = dev->ieee80211_ptr;
8451 struct cfg80211_sched_scan_request *sched_scan_req;
8455 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
8458 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
8459 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
8463 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
8465 rdev->wiphy.max_match_sets);
8467 err = PTR_ERR_OR_ZERO(sched_scan_req);
8471 /* leave request id zero for legacy request
8472 * or if driver does not support multi-scheduled scan
8474 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1)
8475 sched_scan_req->reqid = cfg80211_assign_cookie(rdev);
8477 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
8481 sched_scan_req->dev = dev;
8482 sched_scan_req->wiphy = &rdev->wiphy;
8484 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
8485 sched_scan_req->owner_nlportid = info->snd_portid;
8487 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
8489 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
8493 kfree(sched_scan_req);
8498 static int nl80211_stop_sched_scan(struct sk_buff *skb,
8499 struct genl_info *info)
8501 struct cfg80211_sched_scan_request *req;
8502 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8505 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
8508 if (info->attrs[NL80211_ATTR_COOKIE]) {
8509 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
8510 return __cfg80211_stop_sched_scan(rdev, cookie, false);
8513 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
8514 struct cfg80211_sched_scan_request,
8516 if (!req || req->reqid ||
8517 (req->owner_nlportid &&
8518 req->owner_nlportid != info->snd_portid))
8521 return cfg80211_stop_sched_scan_req(rdev, req, false);
8524 static int nl80211_start_radar_detection(struct sk_buff *skb,
8525 struct genl_info *info)
8527 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8528 struct net_device *dev = info->user_ptr[1];
8529 struct wireless_dev *wdev = dev->ieee80211_ptr;
8530 struct wiphy *wiphy = wdev->wiphy;
8531 struct cfg80211_chan_def chandef;
8532 enum nl80211_dfs_regions dfs_region;
8533 unsigned int cac_time_ms;
8536 dfs_region = reg_get_dfs_region(wiphy);
8537 if (dfs_region == NL80211_DFS_UNSET)
8540 err = nl80211_parse_chandef(rdev, info, &chandef);
8544 if (netif_carrier_ok(dev))
8547 if (wdev->cac_started)
8550 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
8557 if (!cfg80211_chandef_dfs_usable(wiphy, &chandef))
8560 /* CAC start is offloaded to HW and can't be started manually */
8561 if (wiphy_ext_feature_isset(wiphy, NL80211_EXT_FEATURE_DFS_OFFLOAD))
8564 if (!rdev->ops->start_radar_detection)
8567 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
8568 if (WARN_ON(!cac_time_ms))
8569 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
8571 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
8573 wdev->chandef = chandef;
8574 wdev->cac_started = true;
8575 wdev->cac_start_time = jiffies;
8576 wdev->cac_time_ms = cac_time_ms;
8581 static int nl80211_notify_radar_detection(struct sk_buff *skb,
8582 struct genl_info *info)
8584 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8585 struct net_device *dev = info->user_ptr[1];
8586 struct wireless_dev *wdev = dev->ieee80211_ptr;
8587 struct wiphy *wiphy = wdev->wiphy;
8588 struct cfg80211_chan_def chandef;
8589 enum nl80211_dfs_regions dfs_region;
8592 dfs_region = reg_get_dfs_region(wiphy);
8593 if (dfs_region == NL80211_DFS_UNSET) {
8594 GENL_SET_ERR_MSG(info,
8595 "DFS Region is not set. Unexpected Radar indication");
8599 err = nl80211_parse_chandef(rdev, info, &chandef);
8601 GENL_SET_ERR_MSG(info, "Unable to extract chandef info");
8605 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
8607 GENL_SET_ERR_MSG(info, "chandef is invalid");
8612 GENL_SET_ERR_MSG(info,
8613 "Unexpected Radar indication for chandef/iftype");
8617 /* Do not process this notification if radar is already detected
8618 * by kernel on this channel, and return success.
8620 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE)
8623 cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_UNAVAILABLE);
8625 cfg80211_sched_dfs_chan_update(rdev);
8627 rdev->radar_chandef = chandef;
8629 /* Propagate this notification to other radios as well */
8630 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
8635 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
8637 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8638 struct net_device *dev = info->user_ptr[1];
8639 struct wireless_dev *wdev = dev->ieee80211_ptr;
8640 struct cfg80211_csa_settings params;
8641 /* csa_attrs is defined static to avoid waste of stack size - this
8642 * function is called under RTNL lock, so this should not be a problem.
8644 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
8646 bool need_new_beacon = false;
8647 bool need_handle_dfs_flag = true;
8651 if (!rdev->ops->channel_switch ||
8652 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
8655 switch (dev->ieee80211_ptr->iftype) {
8656 case NL80211_IFTYPE_AP:
8657 case NL80211_IFTYPE_P2P_GO:
8658 need_new_beacon = true;
8659 /* For all modes except AP the handle_dfs flag needs to be
8660 * supplied to tell the kernel that userspace will handle radar
8661 * events when they happen. Otherwise a switch to a channel
8662 * requiring DFS will be rejected.
8664 need_handle_dfs_flag = false;
8666 /* useless if AP is not running */
8667 if (!wdev->beacon_interval)
8670 case NL80211_IFTYPE_ADHOC:
8671 if (!wdev->ssid_len)
8674 case NL80211_IFTYPE_MESH_POINT:
8675 if (!wdev->mesh_id_len)
8682 memset(¶ms, 0, sizeof(params));
8683 params.beacon_csa.ftm_responder = -1;
8685 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
8686 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
8689 /* only important for AP, IBSS and mesh create IEs internally */
8690 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
8693 /* Even though the attribute is u32, the specification says
8694 * u8, so let's make sure we don't overflow.
8696 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
8700 params.count = cs_count;
8702 if (!need_new_beacon)
8705 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after);
8709 err = nla_parse_nested_deprecated(csa_attrs, NL80211_ATTR_MAX,
8710 info->attrs[NL80211_ATTR_CSA_IES],
8711 nl80211_policy, info->extack);
8715 err = nl80211_parse_beacon(rdev, csa_attrs, ¶ms.beacon_csa);
8719 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
8722 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
8723 if (!len || (len % sizeof(u16)))
8726 params.n_counter_offsets_beacon = len / sizeof(u16);
8727 if (rdev->wiphy.max_num_csa_counters &&
8728 (params.n_counter_offsets_beacon >
8729 rdev->wiphy.max_num_csa_counters))
8732 params.counter_offsets_beacon =
8733 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
8735 /* sanity checks - counters should fit and be the same */
8736 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
8737 u16 offset = params.counter_offsets_beacon[i];
8739 if (offset >= params.beacon_csa.tail_len)
8742 if (params.beacon_csa.tail[offset] != params.count)
8746 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
8747 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
8748 if (!len || (len % sizeof(u16)))
8751 params.n_counter_offsets_presp = len / sizeof(u16);
8752 if (rdev->wiphy.max_num_csa_counters &&
8753 (params.n_counter_offsets_presp >
8754 rdev->wiphy.max_num_csa_counters))
8757 params.counter_offsets_presp =
8758 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
8760 /* sanity checks - counters should fit and be the same */
8761 for (i = 0; i < params.n_counter_offsets_presp; i++) {
8762 u16 offset = params.counter_offsets_presp[i];
8764 if (offset >= params.beacon_csa.probe_resp_len)
8767 if (params.beacon_csa.probe_resp[offset] !=
8774 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
8778 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
8782 err = cfg80211_chandef_dfs_required(wdev->wiphy,
8789 params.radar_required = true;
8790 if (need_handle_dfs_flag &&
8791 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
8796 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
8797 params.block_tx = true;
8800 err = rdev_channel_switch(rdev, dev, ¶ms);
8806 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
8808 struct cfg80211_registered_device *rdev,
8809 struct wireless_dev *wdev,
8810 struct cfg80211_internal_bss *intbss)
8812 struct cfg80211_bss *res = &intbss->pub;
8813 const struct cfg80211_bss_ies *ies;
8817 ASSERT_WDEV_LOCK(wdev);
8819 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
8820 NL80211_CMD_NEW_SCAN_RESULTS);
8824 genl_dump_check_consistent(cb, hdr);
8826 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
8827 goto nla_put_failure;
8829 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
8830 goto nla_put_failure;
8831 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
8833 goto nla_put_failure;
8835 bss = nla_nest_start_noflag(msg, NL80211_ATTR_BSS);
8837 goto nla_put_failure;
8838 if ((!is_zero_ether_addr(res->bssid) &&
8839 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
8840 goto nla_put_failure;
8843 /* indicate whether we have probe response data or not */
8844 if (rcu_access_pointer(res->proberesp_ies) &&
8845 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
8846 goto fail_unlock_rcu;
8848 /* this pointer prefers to be pointed to probe response data
8849 * but is always valid
8851 ies = rcu_dereference(res->ies);
8853 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
8855 goto fail_unlock_rcu;
8856 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
8857 ies->len, ies->data))
8858 goto fail_unlock_rcu;
8861 /* and this pointer is always (unless driver didn't know) beacon data */
8862 ies = rcu_dereference(res->beacon_ies);
8863 if (ies && ies->from_beacon) {
8864 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
8866 goto fail_unlock_rcu;
8867 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
8868 ies->len, ies->data))
8869 goto fail_unlock_rcu;
8873 if (res->beacon_interval &&
8874 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
8875 goto nla_put_failure;
8876 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
8877 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
8878 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
8879 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
8880 jiffies_to_msecs(jiffies - intbss->ts)))
8881 goto nla_put_failure;
8883 if (intbss->parent_tsf &&
8884 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
8885 intbss->parent_tsf, NL80211_BSS_PAD) ||
8886 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
8887 intbss->parent_bssid)))
8888 goto nla_put_failure;
8890 if (intbss->ts_boottime &&
8891 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
8892 intbss->ts_boottime, NL80211_BSS_PAD))
8893 goto nla_put_failure;
8895 if (!nl80211_put_signal(msg, intbss->pub.chains,
8896 intbss->pub.chain_signal,
8897 NL80211_BSS_CHAIN_SIGNAL))
8898 goto nla_put_failure;
8900 switch (rdev->wiphy.signal_type) {
8901 case CFG80211_SIGNAL_TYPE_MBM:
8902 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
8903 goto nla_put_failure;
8905 case CFG80211_SIGNAL_TYPE_UNSPEC:
8906 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
8907 goto nla_put_failure;
8913 switch (wdev->iftype) {
8914 case NL80211_IFTYPE_P2P_CLIENT:
8915 case NL80211_IFTYPE_STATION:
8916 if (intbss == wdev->current_bss &&
8917 nla_put_u32(msg, NL80211_BSS_STATUS,
8918 NL80211_BSS_STATUS_ASSOCIATED))
8919 goto nla_put_failure;
8921 case NL80211_IFTYPE_ADHOC:
8922 if (intbss == wdev->current_bss &&
8923 nla_put_u32(msg, NL80211_BSS_STATUS,
8924 NL80211_BSS_STATUS_IBSS_JOINED))
8925 goto nla_put_failure;
8931 nla_nest_end(msg, bss);
8933 genlmsg_end(msg, hdr);
8939 genlmsg_cancel(msg, hdr);
8943 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
8945 struct cfg80211_registered_device *rdev;
8946 struct cfg80211_internal_bss *scan;
8947 struct wireless_dev *wdev;
8948 int start = cb->args[2], idx = 0;
8952 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
8959 spin_lock_bh(&rdev->bss_lock);
8962 * dump_scan will be called multiple times to break up the scan results
8963 * into multiple messages. It is unlikely that any more bss-es will be
8964 * expired after the first call, so only call only call this on the
8965 * first dump_scan invocation.
8968 cfg80211_bss_expire(rdev);
8970 cb->seq = rdev->bss_generation;
8972 list_for_each_entry(scan, &rdev->bss_list, list) {
8975 if (nl80211_send_bss(skb, cb,
8976 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8977 rdev, wdev, scan) < 0) {
8983 spin_unlock_bh(&rdev->bss_lock);
8992 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
8993 int flags, struct net_device *dev,
8994 bool allow_radio_stats,
8995 struct survey_info *survey)
8998 struct nlattr *infoattr;
9000 /* skip radio stats if userspace didn't request them */
9001 if (!survey->channel && !allow_radio_stats)
9004 hdr = nl80211hdr_put(msg, portid, seq, flags,
9005 NL80211_CMD_NEW_SURVEY_RESULTS);
9009 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
9010 goto nla_put_failure;
9012 infoattr = nla_nest_start_noflag(msg, NL80211_ATTR_SURVEY_INFO);
9014 goto nla_put_failure;
9016 if (survey->channel &&
9017 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
9018 survey->channel->center_freq))
9019 goto nla_put_failure;
9021 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
9022 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
9023 goto nla_put_failure;
9024 if ((survey->filled & SURVEY_INFO_IN_USE) &&
9025 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
9026 goto nla_put_failure;
9027 if ((survey->filled & SURVEY_INFO_TIME) &&
9028 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
9029 survey->time, NL80211_SURVEY_INFO_PAD))
9030 goto nla_put_failure;
9031 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
9032 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
9033 survey->time_busy, NL80211_SURVEY_INFO_PAD))
9034 goto nla_put_failure;
9035 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
9036 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
9037 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
9038 goto nla_put_failure;
9039 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
9040 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
9041 survey->time_rx, NL80211_SURVEY_INFO_PAD))
9042 goto nla_put_failure;
9043 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
9044 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
9045 survey->time_tx, NL80211_SURVEY_INFO_PAD))
9046 goto nla_put_failure;
9047 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
9048 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
9049 survey->time_scan, NL80211_SURVEY_INFO_PAD))
9050 goto nla_put_failure;
9051 if ((survey->filled & SURVEY_INFO_TIME_BSS_RX) &&
9052 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BSS_RX,
9053 survey->time_bss_rx, NL80211_SURVEY_INFO_PAD))
9054 goto nla_put_failure;
9056 nla_nest_end(msg, infoattr);
9058 genlmsg_end(msg, hdr);
9062 genlmsg_cancel(msg, hdr);
9066 static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
9068 struct nlattr **attrbuf;
9069 struct survey_info survey;
9070 struct cfg80211_registered_device *rdev;
9071 struct wireless_dev *wdev;
9072 int survey_idx = cb->args[2];
9076 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
9081 res = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
9085 /* prepare_wdev_dump parsed the attributes */
9086 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
9088 if (!wdev->netdev) {
9093 if (!rdev->ops->dump_survey) {
9099 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
9105 /* don't send disabled channels, but do send non-channel data */
9106 if (survey.channel &&
9107 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
9112 if (nl80211_send_survey(skb,
9113 NETLINK_CB(cb->skb).portid,
9114 cb->nlh->nlmsg_seq, NLM_F_MULTI,
9115 wdev->netdev, radio_stats, &survey) < 0)
9121 cb->args[2] = survey_idx;
9129 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
9131 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
9132 NL80211_WPA_VERSION_2 |
9133 NL80211_WPA_VERSION_3));
9136 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
9138 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9139 struct net_device *dev = info->user_ptr[1];
9140 struct ieee80211_channel *chan;
9141 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
9142 int err, ssid_len, ie_len = 0, auth_data_len = 0;
9143 enum nl80211_auth_type auth_type;
9144 struct key_parse key;
9145 bool local_state_change;
9147 if (!info->attrs[NL80211_ATTR_MAC])
9150 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
9153 if (!info->attrs[NL80211_ATTR_SSID])
9156 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
9159 err = nl80211_parse_key(info, &key);
9164 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
9166 if (!key.p.key || !key.p.key_len)
9168 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
9169 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
9170 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
9171 key.p.key_len != WLAN_KEY_LEN_WEP104))
9184 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
9185 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
9194 if (!rdev->ops->auth)
9197 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9198 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9201 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9202 chan = nl80211_get_valid_chan(&rdev->wiphy,
9203 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
9207 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9208 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9210 if (info->attrs[NL80211_ATTR_IE]) {
9211 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9212 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9215 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
9216 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
9219 if ((auth_type == NL80211_AUTHTYPE_SAE ||
9220 auth_type == NL80211_AUTHTYPE_FILS_SK ||
9221 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
9222 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
9223 !info->attrs[NL80211_ATTR_AUTH_DATA])
9226 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
9227 if (auth_type != NL80211_AUTHTYPE_SAE &&
9228 auth_type != NL80211_AUTHTYPE_FILS_SK &&
9229 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
9230 auth_type != NL80211_AUTHTYPE_FILS_PK)
9232 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
9233 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
9234 /* need to include at least Auth Transaction and Status Code */
9235 if (auth_data_len < 4)
9239 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
9242 * Since we no longer track auth state, ignore
9243 * requests to only change local state.
9245 if (local_state_change)
9248 wdev_lock(dev->ieee80211_ptr);
9249 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
9250 ssid, ssid_len, ie, ie_len,
9251 key.p.key, key.p.key_len, key.idx,
9252 auth_data, auth_data_len);
9253 wdev_unlock(dev->ieee80211_ptr);
9257 static int validate_pae_over_nl80211(struct cfg80211_registered_device *rdev,
9258 struct genl_info *info)
9260 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9261 GENL_SET_ERR_MSG(info, "SOCKET_OWNER not set");
9265 if (!rdev->ops->tx_control_port ||
9266 !wiphy_ext_feature_isset(&rdev->wiphy,
9267 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
9273 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
9274 struct genl_info *info,
9275 struct cfg80211_crypto_settings *settings,
9278 memset(settings, 0, sizeof(*settings));
9280 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
9282 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
9285 proto = nla_get_u16(
9286 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
9287 settings->control_port_ethertype = cpu_to_be16(proto);
9288 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
9291 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
9292 settings->control_port_no_encrypt = true;
9294 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
9296 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
9297 int r = validate_pae_over_nl80211(rdev, info);
9302 settings->control_port_over_nl80211 = true;
9305 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
9309 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
9310 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
9311 settings->n_ciphers_pairwise = len / sizeof(u32);
9313 if (len % sizeof(u32))
9316 if (settings->n_ciphers_pairwise > cipher_limit)
9319 memcpy(settings->ciphers_pairwise, data, len);
9321 for (i = 0; i < settings->n_ciphers_pairwise; i++)
9322 if (!cfg80211_supported_cipher_suite(
9324 settings->ciphers_pairwise[i]))
9328 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
9329 settings->cipher_group =
9330 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
9331 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
9332 settings->cipher_group))
9336 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
9337 settings->wpa_versions =
9338 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
9339 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
9343 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
9347 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
9348 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
9349 settings->n_akm_suites = len / sizeof(u32);
9351 if (len % sizeof(u32))
9354 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
9357 memcpy(settings->akm_suites, data, len);
9360 if (info->attrs[NL80211_ATTR_PMK]) {
9361 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
9363 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9364 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
9366 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9369 if (info->attrs[NL80211_ATTR_SAE_PASSWORD]) {
9370 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9371 NL80211_EXT_FEATURE_SAE_OFFLOAD))
9374 nla_data(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
9375 settings->sae_pwd_len =
9376 nla_len(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
9382 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
9384 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9385 struct net_device *dev = info->user_ptr[1];
9386 struct ieee80211_channel *chan;
9387 struct cfg80211_assoc_request req = {};
9388 const u8 *bssid, *ssid;
9389 int err, ssid_len = 0;
9391 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9392 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9395 if (!info->attrs[NL80211_ATTR_MAC] ||
9396 !info->attrs[NL80211_ATTR_SSID] ||
9397 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
9400 if (!rdev->ops->assoc)
9403 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9404 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9407 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9409 chan = nl80211_get_valid_chan(&rdev->wiphy,
9410 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
9414 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9415 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9417 if (info->attrs[NL80211_ATTR_IE]) {
9418 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9419 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9422 if (info->attrs[NL80211_ATTR_USE_MFP]) {
9423 enum nl80211_mfp mfp =
9424 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
9425 if (mfp == NL80211_MFP_REQUIRED)
9427 else if (mfp != NL80211_MFP_NO)
9431 if (info->attrs[NL80211_ATTR_PREV_BSSID])
9432 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
9434 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
9435 req.flags |= ASSOC_REQ_DISABLE_HT;
9437 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9438 memcpy(&req.ht_capa_mask,
9439 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9440 sizeof(req.ht_capa_mask));
9442 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9443 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9445 memcpy(&req.ht_capa,
9446 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9447 sizeof(req.ht_capa));
9450 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
9451 req.flags |= ASSOC_REQ_DISABLE_VHT;
9453 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9454 memcpy(&req.vht_capa_mask,
9455 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
9456 sizeof(req.vht_capa_mask));
9458 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
9459 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9461 memcpy(&req.vht_capa,
9462 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
9463 sizeof(req.vht_capa));
9466 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
9467 if (!((rdev->wiphy.features &
9468 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
9469 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
9470 !wiphy_ext_feature_isset(&rdev->wiphy,
9471 NL80211_EXT_FEATURE_RRM))
9473 req.flags |= ASSOC_REQ_USE_RRM;
9476 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
9477 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
9478 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
9479 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
9482 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
9485 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
9487 wdev_lock(dev->ieee80211_ptr);
9489 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
9490 ssid, ssid_len, &req);
9492 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9493 dev->ieee80211_ptr->conn_owner_nlportid =
9495 memcpy(dev->ieee80211_ptr->disconnect_bssid,
9499 wdev_unlock(dev->ieee80211_ptr);
9505 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
9507 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9508 struct net_device *dev = info->user_ptr[1];
9509 const u8 *ie = NULL, *bssid;
9510 int ie_len = 0, err;
9512 bool local_state_change;
9514 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9515 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9518 if (!info->attrs[NL80211_ATTR_MAC])
9521 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9524 if (!rdev->ops->deauth)
9527 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9528 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9531 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9533 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9534 if (reason_code == 0) {
9535 /* Reason Code 0 is reserved */
9539 if (info->attrs[NL80211_ATTR_IE]) {
9540 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9541 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9544 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
9546 wdev_lock(dev->ieee80211_ptr);
9547 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
9548 local_state_change);
9549 wdev_unlock(dev->ieee80211_ptr);
9553 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
9555 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9556 struct net_device *dev = info->user_ptr[1];
9557 const u8 *ie = NULL, *bssid;
9558 int ie_len = 0, err;
9560 bool local_state_change;
9562 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9563 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9566 if (!info->attrs[NL80211_ATTR_MAC])
9569 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9572 if (!rdev->ops->disassoc)
9575 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9576 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9579 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9581 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9582 if (reason_code == 0) {
9583 /* Reason Code 0 is reserved */
9587 if (info->attrs[NL80211_ATTR_IE]) {
9588 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9589 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9592 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
9594 wdev_lock(dev->ieee80211_ptr);
9595 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
9596 local_state_change);
9597 wdev_unlock(dev->ieee80211_ptr);
9602 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
9603 int mcast_rate[NUM_NL80211_BANDS],
9606 struct wiphy *wiphy = &rdev->wiphy;
9610 for (band = 0; band < NUM_NL80211_BANDS; band++) {
9611 struct ieee80211_supported_band *sband;
9613 sband = wiphy->bands[band];
9617 for (i = 0; i < sband->n_bitrates; i++) {
9618 if (sband->bitrates[i].bitrate == rateval) {
9619 mcast_rate[band] = i + 1;
9629 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
9631 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9632 struct net_device *dev = info->user_ptr[1];
9633 struct cfg80211_ibss_params ibss;
9634 struct wiphy *wiphy;
9635 struct cfg80211_cached_keys *connkeys = NULL;
9638 memset(&ibss, 0, sizeof(ibss));
9640 if (!info->attrs[NL80211_ATTR_SSID] ||
9641 !nla_len(info->attrs[NL80211_ATTR_SSID]))
9644 ibss.beacon_interval = 100;
9646 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
9647 ibss.beacon_interval =
9648 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
9650 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
9651 ibss.beacon_interval);
9655 if (!rdev->ops->join_ibss)
9658 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
9661 wiphy = &rdev->wiphy;
9663 if (info->attrs[NL80211_ATTR_MAC]) {
9664 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9666 if (!is_valid_ether_addr(ibss.bssid))
9669 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9670 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9672 if (info->attrs[NL80211_ATTR_IE]) {
9673 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9674 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9677 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
9681 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
9682 NL80211_IFTYPE_ADHOC))
9685 switch (ibss.chandef.width) {
9686 case NL80211_CHAN_WIDTH_5:
9687 case NL80211_CHAN_WIDTH_10:
9688 case NL80211_CHAN_WIDTH_20_NOHT:
9690 case NL80211_CHAN_WIDTH_20:
9691 case NL80211_CHAN_WIDTH_40:
9692 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
9695 case NL80211_CHAN_WIDTH_80:
9696 case NL80211_CHAN_WIDTH_80P80:
9697 case NL80211_CHAN_WIDTH_160:
9698 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
9700 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9701 NL80211_EXT_FEATURE_VHT_IBSS))
9708 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
9709 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
9711 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9713 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9715 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9716 struct ieee80211_supported_band *sband =
9717 wiphy->bands[ibss.chandef.chan->band];
9719 err = ieee80211_get_ratemask(sband, rates, n_rates,
9725 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9726 memcpy(&ibss.ht_capa_mask,
9727 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9728 sizeof(ibss.ht_capa_mask));
9730 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9731 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9733 memcpy(&ibss.ht_capa,
9734 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9735 sizeof(ibss.ht_capa));
9738 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
9739 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
9740 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
9743 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
9746 connkeys = nl80211_parse_connkeys(rdev, info, &no_ht);
9747 if (IS_ERR(connkeys))
9748 return PTR_ERR(connkeys);
9750 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
9758 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
9760 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
9761 int r = validate_pae_over_nl80211(rdev, info);
9768 ibss.control_port_over_nl80211 = true;
9771 ibss.userspace_handles_dfs =
9772 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
9774 wdev_lock(dev->ieee80211_ptr);
9775 err = __cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
9778 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
9779 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9780 wdev_unlock(dev->ieee80211_ptr);
9785 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
9787 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9788 struct net_device *dev = info->user_ptr[1];
9790 if (!rdev->ops->leave_ibss)
9793 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
9796 return cfg80211_leave_ibss(rdev, dev, false);
9799 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
9801 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9802 struct net_device *dev = info->user_ptr[1];
9803 int mcast_rate[NUM_NL80211_BANDS];
9807 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
9808 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
9809 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
9812 if (!rdev->ops->set_mcast_rate)
9815 memset(mcast_rate, 0, sizeof(mcast_rate));
9817 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
9820 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
9821 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
9824 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
9829 static struct sk_buff *
9830 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
9831 struct wireless_dev *wdev, int approxlen,
9832 u32 portid, u32 seq, enum nl80211_commands cmd,
9833 enum nl80211_attrs attr,
9834 const struct nl80211_vendor_cmd_info *info,
9837 struct sk_buff *skb;
9839 struct nlattr *data;
9841 skb = nlmsg_new(approxlen + 100, gfp);
9845 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
9851 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
9852 goto nla_put_failure;
9855 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
9857 goto nla_put_failure;
9858 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
9860 goto nla_put_failure;
9864 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
9865 wdev_id(wdev), NL80211_ATTR_PAD))
9866 goto nla_put_failure;
9868 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
9869 wdev->netdev->ifindex))
9870 goto nla_put_failure;
9873 data = nla_nest_start_noflag(skb, attr);
9875 goto nla_put_failure;
9877 ((void **)skb->cb)[0] = rdev;
9878 ((void **)skb->cb)[1] = hdr;
9879 ((void **)skb->cb)[2] = data;
9888 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
9889 struct wireless_dev *wdev,
9890 enum nl80211_commands cmd,
9891 enum nl80211_attrs attr,
9892 unsigned int portid,
9893 int vendor_event_idx,
9894 int approxlen, gfp_t gfp)
9896 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
9897 const struct nl80211_vendor_cmd_info *info;
9900 case NL80211_CMD_TESTMODE:
9901 if (WARN_ON(vendor_event_idx != -1))
9905 case NL80211_CMD_VENDOR:
9906 if (WARN_ON(vendor_event_idx < 0 ||
9907 vendor_event_idx >= wiphy->n_vendor_events))
9909 info = &wiphy->vendor_events[vendor_event_idx];
9916 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, portid, 0,
9917 cmd, attr, info, gfp);
9919 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
9921 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
9923 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
9924 void *hdr = ((void **)skb->cb)[1];
9925 struct nlmsghdr *nlhdr = nlmsg_hdr(skb);
9926 struct nlattr *data = ((void **)skb->cb)[2];
9927 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
9929 /* clear CB data for netlink core to own from now on */
9930 memset(skb->cb, 0, sizeof(skb->cb));
9932 nla_nest_end(skb, data);
9933 genlmsg_end(skb, hdr);
9935 if (nlhdr->nlmsg_pid) {
9936 genlmsg_unicast(wiphy_net(&rdev->wiphy), skb,
9939 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
9940 mcgrp = NL80211_MCGRP_VENDOR;
9942 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
9943 skb, 0, mcgrp, gfp);
9946 EXPORT_SYMBOL(__cfg80211_send_event_skb);
9948 #ifdef CONFIG_NL80211_TESTMODE
9949 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
9951 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9952 struct wireless_dev *wdev =
9953 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
9956 if (!rdev->ops->testmode_cmd)
9960 err = PTR_ERR(wdev);
9964 } else if (wdev->wiphy != &rdev->wiphy) {
9968 if (!info->attrs[NL80211_ATTR_TESTDATA])
9971 rdev->cur_cmd_info = info;
9972 err = rdev_testmode_cmd(rdev, wdev,
9973 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
9974 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
9975 rdev->cur_cmd_info = NULL;
9980 static int nl80211_testmode_dump(struct sk_buff *skb,
9981 struct netlink_callback *cb)
9983 struct cfg80211_registered_device *rdev;
9984 struct nlattr **attrbuf = NULL;
9994 * 0 is a valid index, but not valid for args[0],
9995 * so we need to offset by 1.
9997 phy_idx = cb->args[0] - 1;
9999 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
10005 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
10012 err = nlmsg_parse_deprecated(cb->nlh,
10013 GENL_HDRLEN + nl80211_fam.hdrsize,
10014 attrbuf, nl80211_fam.maxattr,
10015 nl80211_policy, NULL);
10019 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
10020 if (IS_ERR(rdev)) {
10021 err = PTR_ERR(rdev);
10024 phy_idx = rdev->wiphy_idx;
10026 if (attrbuf[NL80211_ATTR_TESTDATA])
10027 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
10031 data = nla_data((void *)cb->args[1]);
10032 data_len = nla_len((void *)cb->args[1]);
10035 if (!rdev->ops->testmode_dump) {
10041 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
10042 cb->nlh->nlmsg_seq, NLM_F_MULTI,
10043 NL80211_CMD_TESTMODE);
10044 struct nlattr *tmdata;
10049 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
10050 genlmsg_cancel(skb, hdr);
10054 tmdata = nla_nest_start_noflag(skb, NL80211_ATTR_TESTDATA);
10056 genlmsg_cancel(skb, hdr);
10059 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
10060 nla_nest_end(skb, tmdata);
10062 if (err == -ENOBUFS || err == -ENOENT) {
10063 genlmsg_cancel(skb, hdr);
10066 genlmsg_cancel(skb, hdr);
10070 genlmsg_end(skb, hdr);
10075 cb->args[0] = phy_idx + 1;
10083 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
10085 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10086 struct net_device *dev = info->user_ptr[1];
10087 struct cfg80211_connect_params connect;
10088 struct wiphy *wiphy;
10089 struct cfg80211_cached_keys *connkeys = NULL;
10092 memset(&connect, 0, sizeof(connect));
10094 if (!info->attrs[NL80211_ATTR_SSID] ||
10095 !nla_len(info->attrs[NL80211_ATTR_SSID]))
10098 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
10099 connect.auth_type =
10100 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
10101 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
10102 NL80211_CMD_CONNECT))
10105 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
10107 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
10109 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
10110 !wiphy_ext_feature_isset(&rdev->wiphy,
10111 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
10113 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
10115 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
10116 NL80211_MAX_NR_CIPHER_SUITES);
10120 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10121 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10122 return -EOPNOTSUPP;
10124 wiphy = &rdev->wiphy;
10126 connect.bg_scan_period = -1;
10127 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
10128 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
10129 connect.bg_scan_period =
10130 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
10133 if (info->attrs[NL80211_ATTR_MAC])
10134 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10135 else if (info->attrs[NL80211_ATTR_MAC_HINT])
10136 connect.bssid_hint =
10137 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
10138 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10139 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10141 if (info->attrs[NL80211_ATTR_IE]) {
10142 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10143 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10146 if (info->attrs[NL80211_ATTR_USE_MFP]) {
10147 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
10148 if (connect.mfp == NL80211_MFP_OPTIONAL &&
10149 !wiphy_ext_feature_isset(&rdev->wiphy,
10150 NL80211_EXT_FEATURE_MFP_OPTIONAL))
10151 return -EOPNOTSUPP;
10153 connect.mfp = NL80211_MFP_NO;
10156 if (info->attrs[NL80211_ATTR_PREV_BSSID])
10157 connect.prev_bssid =
10158 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
10160 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
10161 connect.channel = nl80211_get_valid_chan(
10162 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
10163 if (!connect.channel)
10165 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
10166 connect.channel_hint = nl80211_get_valid_chan(
10167 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
10168 if (!connect.channel_hint)
10172 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]) {
10173 connect.edmg.channels =
10174 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_CHANNELS]);
10176 if (info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG])
10177 connect.edmg.bw_config =
10178 nla_get_u8(info->attrs[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG]);
10181 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
10182 connkeys = nl80211_parse_connkeys(rdev, info, NULL);
10183 if (IS_ERR(connkeys))
10184 return PTR_ERR(connkeys);
10187 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
10188 connect.flags |= ASSOC_REQ_DISABLE_HT;
10190 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
10191 memcpy(&connect.ht_capa_mask,
10192 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
10193 sizeof(connect.ht_capa_mask));
10195 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
10196 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
10200 memcpy(&connect.ht_capa,
10201 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
10202 sizeof(connect.ht_capa));
10205 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
10206 connect.flags |= ASSOC_REQ_DISABLE_VHT;
10208 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
10209 memcpy(&connect.vht_capa_mask,
10210 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
10211 sizeof(connect.vht_capa_mask));
10213 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
10214 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
10218 memcpy(&connect.vht_capa,
10219 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
10220 sizeof(connect.vht_capa));
10223 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
10224 if (!((rdev->wiphy.features &
10225 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
10226 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
10227 !wiphy_ext_feature_isset(&rdev->wiphy,
10228 NL80211_EXT_FEATURE_RRM)) {
10232 connect.flags |= ASSOC_REQ_USE_RRM;
10235 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
10236 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
10238 return -EOPNOTSUPP;
10241 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
10242 /* bss selection makes no sense if bssid is set */
10243 if (connect.bssid) {
10248 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
10249 wiphy, &connect.bss_select);
10256 if (wiphy_ext_feature_isset(&rdev->wiphy,
10257 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
10258 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
10259 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
10260 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
10261 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10262 connect.fils_erp_username =
10263 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10264 connect.fils_erp_username_len =
10265 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10266 connect.fils_erp_realm =
10267 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10268 connect.fils_erp_realm_len =
10269 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10270 connect.fils_erp_next_seq_num =
10272 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
10273 connect.fils_erp_rrk =
10274 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10275 connect.fils_erp_rrk_len =
10276 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10277 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
10278 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
10279 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
10280 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10285 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
10286 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10288 GENL_SET_ERR_MSG(info,
10289 "external auth requires connection ownership");
10292 connect.flags |= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT;
10295 wdev_lock(dev->ieee80211_ptr);
10297 err = cfg80211_connect(rdev, dev, &connect, connkeys,
10298 connect.prev_bssid);
10302 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10303 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
10305 memcpy(dev->ieee80211_ptr->disconnect_bssid,
10306 connect.bssid, ETH_ALEN);
10308 memset(dev->ieee80211_ptr->disconnect_bssid,
10312 wdev_unlock(dev->ieee80211_ptr);
10317 static int nl80211_update_connect_params(struct sk_buff *skb,
10318 struct genl_info *info)
10320 struct cfg80211_connect_params connect = {};
10321 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10322 struct net_device *dev = info->user_ptr[1];
10323 struct wireless_dev *wdev = dev->ieee80211_ptr;
10324 bool fils_sk_offload;
10329 if (!rdev->ops->update_connect_params)
10330 return -EOPNOTSUPP;
10332 if (info->attrs[NL80211_ATTR_IE]) {
10333 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10334 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10335 changed |= UPDATE_ASSOC_IES;
10338 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy,
10339 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD);
10342 * when driver supports fils-sk offload all attributes must be
10343 * provided. So the else covers "fils-sk-not-all" and
10344 * "no-fils-sk-any".
10346 if (fils_sk_offload &&
10347 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
10348 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
10349 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
10350 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10351 connect.fils_erp_username =
10352 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10353 connect.fils_erp_username_len =
10354 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10355 connect.fils_erp_realm =
10356 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10357 connect.fils_erp_realm_len =
10358 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10359 connect.fils_erp_next_seq_num =
10361 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
10362 connect.fils_erp_rrk =
10363 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10364 connect.fils_erp_rrk_len =
10365 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10366 changed |= UPDATE_FILS_ERP_INFO;
10367 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
10368 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
10369 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
10370 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10374 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
10375 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
10376 if (!nl80211_valid_auth_type(rdev, auth_type,
10377 NL80211_CMD_CONNECT))
10380 if (auth_type == NL80211_AUTHTYPE_FILS_SK &&
10381 fils_sk_offload && !(changed & UPDATE_FILS_ERP_INFO))
10384 connect.auth_type = auth_type;
10385 changed |= UPDATE_AUTH_TYPE;
10388 wdev_lock(dev->ieee80211_ptr);
10389 if (!wdev->current_bss)
10392 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
10393 wdev_unlock(dev->ieee80211_ptr);
10398 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
10400 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10401 struct net_device *dev = info->user_ptr[1];
10405 if (dev->ieee80211_ptr->conn_owner_nlportid &&
10406 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
10409 if (!info->attrs[NL80211_ATTR_REASON_CODE])
10410 reason = WLAN_REASON_DEAUTH_LEAVING;
10412 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
10417 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10418 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10419 return -EOPNOTSUPP;
10421 wdev_lock(dev->ieee80211_ptr);
10422 ret = cfg80211_disconnect(rdev, dev, reason, true);
10423 wdev_unlock(dev->ieee80211_ptr);
10427 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
10429 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10433 if (info->attrs[NL80211_ATTR_PID]) {
10434 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
10436 net = get_net_ns_by_pid(pid);
10437 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
10438 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
10440 net = get_net_ns_by_fd(fd);
10446 return PTR_ERR(net);
10450 /* check if anything to do */
10451 if (!net_eq(wiphy_net(&rdev->wiphy), net))
10452 err = cfg80211_switch_netns(rdev, net);
10458 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
10460 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10461 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
10462 struct cfg80211_pmksa *pmksa) = NULL;
10463 struct net_device *dev = info->user_ptr[1];
10464 struct cfg80211_pmksa pmksa;
10466 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
10468 if (!info->attrs[NL80211_ATTR_PMKID])
10471 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
10473 if (info->attrs[NL80211_ATTR_MAC]) {
10474 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10475 } else if (info->attrs[NL80211_ATTR_SSID] &&
10476 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
10477 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
10478 info->attrs[NL80211_ATTR_PMK])) {
10479 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10480 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10482 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
10486 if (info->attrs[NL80211_ATTR_PMK]) {
10487 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
10488 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
10491 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10492 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
10493 !(dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP &&
10494 wiphy_ext_feature_isset(&rdev->wiphy,
10495 NL80211_EXT_FEATURE_AP_PMKSA_CACHING)))
10496 return -EOPNOTSUPP;
10498 switch (info->genlhdr->cmd) {
10499 case NL80211_CMD_SET_PMKSA:
10500 rdev_ops = rdev->ops->set_pmksa;
10502 case NL80211_CMD_DEL_PMKSA:
10503 rdev_ops = rdev->ops->del_pmksa;
10511 return -EOPNOTSUPP;
10513 return rdev_ops(&rdev->wiphy, dev, &pmksa);
10516 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
10518 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10519 struct net_device *dev = info->user_ptr[1];
10521 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10522 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10523 return -EOPNOTSUPP;
10525 if (!rdev->ops->flush_pmksa)
10526 return -EOPNOTSUPP;
10528 return rdev_flush_pmksa(rdev, dev);
10531 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
10533 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10534 struct net_device *dev = info->user_ptr[1];
10535 u8 action_code, dialog_token;
10536 u32 peer_capability = 0;
10541 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
10542 !rdev->ops->tdls_mgmt)
10543 return -EOPNOTSUPP;
10545 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
10546 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
10547 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
10548 !info->attrs[NL80211_ATTR_IE] ||
10549 !info->attrs[NL80211_ATTR_MAC])
10552 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
10553 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
10554 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
10555 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
10556 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
10557 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
10559 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
10561 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
10562 dialog_token, status_code, peer_capability,
10564 nla_data(info->attrs[NL80211_ATTR_IE]),
10565 nla_len(info->attrs[NL80211_ATTR_IE]));
10568 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
10570 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10571 struct net_device *dev = info->user_ptr[1];
10572 enum nl80211_tdls_operation operation;
10575 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
10576 !rdev->ops->tdls_oper)
10577 return -EOPNOTSUPP;
10579 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
10580 !info->attrs[NL80211_ATTR_MAC])
10583 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
10584 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
10586 return rdev_tdls_oper(rdev, dev, peer, operation);
10589 static int nl80211_remain_on_channel(struct sk_buff *skb,
10590 struct genl_info *info)
10592 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10593 struct wireless_dev *wdev = info->user_ptr[1];
10594 struct cfg80211_chan_def chandef;
10595 const struct cfg80211_chan_def *compat_chandef;
10596 struct sk_buff *msg;
10602 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
10603 !info->attrs[NL80211_ATTR_DURATION])
10606 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
10608 if (!rdev->ops->remain_on_channel ||
10609 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
10610 return -EOPNOTSUPP;
10613 * We should be on that channel for at least a minimum amount of
10614 * time (10ms) but no longer than the driver supports.
10616 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
10617 duration > rdev->wiphy.max_remain_on_channel_duration)
10620 err = nl80211_parse_chandef(rdev, info, &chandef);
10625 if (!cfg80211_off_channel_oper_allowed(wdev) &&
10626 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
10627 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
10629 if (compat_chandef != &chandef) {
10636 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10640 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10641 NL80211_CMD_REMAIN_ON_CHANNEL);
10647 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
10648 duration, &cookie);
10653 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10655 goto nla_put_failure;
10657 genlmsg_end(msg, hdr);
10659 return genlmsg_reply(msg, info);
10668 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
10669 struct genl_info *info)
10671 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10672 struct wireless_dev *wdev = info->user_ptr[1];
10675 if (!info->attrs[NL80211_ATTR_COOKIE])
10678 if (!rdev->ops->cancel_remain_on_channel)
10679 return -EOPNOTSUPP;
10681 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
10683 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
10686 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
10687 struct genl_info *info)
10689 struct cfg80211_bitrate_mask mask;
10690 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10691 struct net_device *dev = info->user_ptr[1];
10694 if (!rdev->ops->set_bitrate_mask)
10695 return -EOPNOTSUPP;
10697 err = nl80211_parse_tx_bitrate_mask(info, &mask);
10701 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
10704 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
10706 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10707 struct wireless_dev *wdev = info->user_ptr[1];
10708 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
10710 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
10713 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
10714 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
10716 switch (wdev->iftype) {
10717 case NL80211_IFTYPE_STATION:
10718 case NL80211_IFTYPE_ADHOC:
10719 case NL80211_IFTYPE_P2P_CLIENT:
10720 case NL80211_IFTYPE_AP:
10721 case NL80211_IFTYPE_AP_VLAN:
10722 case NL80211_IFTYPE_MESH_POINT:
10723 case NL80211_IFTYPE_P2P_GO:
10724 case NL80211_IFTYPE_P2P_DEVICE:
10726 case NL80211_IFTYPE_NAN:
10728 return -EOPNOTSUPP;
10731 /* not much point in registering if we can't reply */
10732 if (!rdev->ops->mgmt_tx)
10733 return -EOPNOTSUPP;
10735 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
10736 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
10737 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]),
10741 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
10743 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10744 struct wireless_dev *wdev = info->user_ptr[1];
10745 struct cfg80211_chan_def chandef;
10749 struct sk_buff *msg = NULL;
10750 struct cfg80211_mgmt_tx_params params = {
10751 .dont_wait_for_ack =
10752 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
10755 if (!info->attrs[NL80211_ATTR_FRAME])
10758 if (!rdev->ops->mgmt_tx)
10759 return -EOPNOTSUPP;
10761 switch (wdev->iftype) {
10762 case NL80211_IFTYPE_P2P_DEVICE:
10763 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
10765 case NL80211_IFTYPE_STATION:
10766 case NL80211_IFTYPE_ADHOC:
10767 case NL80211_IFTYPE_P2P_CLIENT:
10768 case NL80211_IFTYPE_AP:
10769 case NL80211_IFTYPE_AP_VLAN:
10770 case NL80211_IFTYPE_MESH_POINT:
10771 case NL80211_IFTYPE_P2P_GO:
10773 case NL80211_IFTYPE_NAN:
10775 return -EOPNOTSUPP;
10778 if (info->attrs[NL80211_ATTR_DURATION]) {
10779 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
10781 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
10784 * We should wait on the channel for at least a minimum amount
10785 * of time (10ms) but no longer than the driver supports.
10787 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
10788 params.wait > rdev->wiphy.max_remain_on_channel_duration)
10792 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
10794 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
10797 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
10799 /* get the channel if any has been specified, otherwise pass NULL to
10800 * the driver. The latter will use the current one
10802 chandef.chan = NULL;
10803 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
10804 err = nl80211_parse_chandef(rdev, info, &chandef);
10809 if (!chandef.chan && params.offchan)
10813 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
10819 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
10820 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
10822 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
10823 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
10826 if (len % sizeof(u16))
10829 params.n_csa_offsets = len / sizeof(u16);
10830 params.csa_offsets =
10831 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
10833 /* check that all the offsets fit the frame */
10834 for (i = 0; i < params.n_csa_offsets; i++) {
10835 if (params.csa_offsets[i] >= params.len)
10840 if (!params.dont_wait_for_ack) {
10841 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10845 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10846 NL80211_CMD_FRAME);
10853 params.chan = chandef.chan;
10854 err = cfg80211_mlme_mgmt_tx(rdev, wdev, ¶ms, &cookie);
10859 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10861 goto nla_put_failure;
10863 genlmsg_end(msg, hdr);
10864 return genlmsg_reply(msg, info);
10876 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
10878 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10879 struct wireless_dev *wdev = info->user_ptr[1];
10882 if (!info->attrs[NL80211_ATTR_COOKIE])
10885 if (!rdev->ops->mgmt_tx_cancel_wait)
10886 return -EOPNOTSUPP;
10888 switch (wdev->iftype) {
10889 case NL80211_IFTYPE_STATION:
10890 case NL80211_IFTYPE_ADHOC:
10891 case NL80211_IFTYPE_P2P_CLIENT:
10892 case NL80211_IFTYPE_AP:
10893 case NL80211_IFTYPE_AP_VLAN:
10894 case NL80211_IFTYPE_P2P_GO:
10895 case NL80211_IFTYPE_P2P_DEVICE:
10897 case NL80211_IFTYPE_NAN:
10899 return -EOPNOTSUPP;
10902 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
10904 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
10907 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
10909 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10910 struct wireless_dev *wdev;
10911 struct net_device *dev = info->user_ptr[1];
10916 if (!info->attrs[NL80211_ATTR_PS_STATE])
10919 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
10921 wdev = dev->ieee80211_ptr;
10923 if (!rdev->ops->set_power_mgmt)
10924 return -EOPNOTSUPP;
10926 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
10928 if (state == wdev->ps)
10931 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
10937 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
10939 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10940 enum nl80211_ps_state ps_state;
10941 struct wireless_dev *wdev;
10942 struct net_device *dev = info->user_ptr[1];
10943 struct sk_buff *msg;
10947 wdev = dev->ieee80211_ptr;
10949 if (!rdev->ops->set_power_mgmt)
10950 return -EOPNOTSUPP;
10952 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10956 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10957 NL80211_CMD_GET_POWER_SAVE);
10964 ps_state = NL80211_PS_ENABLED;
10966 ps_state = NL80211_PS_DISABLED;
10968 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
10969 goto nla_put_failure;
10971 genlmsg_end(msg, hdr);
10972 return genlmsg_reply(msg, info);
10981 static const struct nla_policy
10982 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
10983 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
10984 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
10985 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
10986 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
10987 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
10988 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
10989 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
10992 static int nl80211_set_cqm_txe(struct genl_info *info,
10993 u32 rate, u32 pkts, u32 intvl)
10995 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10996 struct net_device *dev = info->user_ptr[1];
10997 struct wireless_dev *wdev = dev->ieee80211_ptr;
10999 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
11002 if (!rdev->ops->set_cqm_txe_config)
11003 return -EOPNOTSUPP;
11005 if (wdev->iftype != NL80211_IFTYPE_STATION &&
11006 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
11007 return -EOPNOTSUPP;
11009 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
11012 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
11013 struct net_device *dev)
11015 struct wireless_dev *wdev = dev->ieee80211_ptr;
11016 s32 last, low, high;
11018 int i, n, low_index;
11021 /* RSSI reporting disabled? */
11022 if (!wdev->cqm_config)
11023 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
11026 * Obtain current RSSI value if possible, if not and no RSSI threshold
11027 * event has been received yet, we should receive an event after a
11028 * connection is established and enough beacons received to calculate
11031 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
11032 rdev->ops->get_station) {
11033 struct station_info sinfo = {};
11036 mac_addr = wdev->current_bss->pub.bssid;
11038 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
11042 cfg80211_sinfo_release_content(&sinfo);
11043 if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
11044 wdev->cqm_config->last_rssi_event_value =
11045 (s8) sinfo.rx_beacon_signal_avg;
11048 last = wdev->cqm_config->last_rssi_event_value;
11049 hyst = wdev->cqm_config->rssi_hyst;
11050 n = wdev->cqm_config->n_rssi_thresholds;
11052 for (i = 0; i < n; i++) {
11053 i = array_index_nospec(i, n);
11054 if (last < wdev->cqm_config->rssi_thresholds[i])
11059 if (low_index >= 0) {
11060 low_index = array_index_nospec(low_index, n);
11061 low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;
11066 i = array_index_nospec(i, n);
11067 high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;
11072 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
11075 static int nl80211_set_cqm_rssi(struct genl_info *info,
11076 const s32 *thresholds, int n_thresholds,
11079 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11080 struct net_device *dev = info->user_ptr[1];
11081 struct wireless_dev *wdev = dev->ieee80211_ptr;
11083 s32 prev = S32_MIN;
11085 /* Check all values negative and sorted */
11086 for (i = 0; i < n_thresholds; i++) {
11087 if (thresholds[i] > 0 || thresholds[i] <= prev)
11090 prev = thresholds[i];
11093 if (wdev->iftype != NL80211_IFTYPE_STATION &&
11094 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
11095 return -EOPNOTSUPP;
11098 cfg80211_cqm_config_free(wdev);
11101 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
11102 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
11103 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
11105 return rdev_set_cqm_rssi_config(rdev, dev,
11106 thresholds[0], hysteresis);
11109 if (!wiphy_ext_feature_isset(&rdev->wiphy,
11110 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
11111 return -EOPNOTSUPP;
11113 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
11117 if (n_thresholds) {
11118 struct cfg80211_cqm_config *cqm_config;
11120 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
11121 n_thresholds * sizeof(s32), GFP_KERNEL);
11127 cqm_config->rssi_hyst = hysteresis;
11128 cqm_config->n_rssi_thresholds = n_thresholds;
11129 memcpy(cqm_config->rssi_thresholds, thresholds,
11130 n_thresholds * sizeof(s32));
11132 wdev->cqm_config = cqm_config;
11135 err = cfg80211_cqm_rssi_update(rdev, dev);
11143 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
11145 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
11146 struct nlattr *cqm;
11149 cqm = info->attrs[NL80211_ATTR_CQM];
11153 err = nla_parse_nested_deprecated(attrs, NL80211_ATTR_CQM_MAX, cqm,
11154 nl80211_attr_cqm_policy,
11159 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
11160 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
11161 const s32 *thresholds =
11162 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
11163 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
11164 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
11169 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
11173 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
11174 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
11175 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
11176 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
11177 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
11178 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
11180 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
11186 static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
11188 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11189 struct net_device *dev = info->user_ptr[1];
11190 struct ocb_setup setup = {};
11193 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
11197 return cfg80211_join_ocb(rdev, dev, &setup);
11200 static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
11202 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11203 struct net_device *dev = info->user_ptr[1];
11205 return cfg80211_leave_ocb(rdev, dev);
11208 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
11210 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11211 struct net_device *dev = info->user_ptr[1];
11212 struct mesh_config cfg;
11213 struct mesh_setup setup;
11216 /* start with default */
11217 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
11218 memcpy(&setup, &default_mesh_setup, sizeof(setup));
11220 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
11221 /* and parse parameters if given */
11222 err = nl80211_parse_mesh_config(info, &cfg, NULL);
11227 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
11228 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
11231 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
11232 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
11234 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
11235 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
11236 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
11239 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
11240 setup.beacon_interval =
11241 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
11243 err = cfg80211_validate_beacon_int(rdev,
11244 NL80211_IFTYPE_MESH_POINT,
11245 setup.beacon_interval);
11250 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
11251 setup.dtim_period =
11252 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
11253 if (setup.dtim_period < 1 || setup.dtim_period > 100)
11257 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
11258 /* parse additional setup parameters if given */
11259 err = nl80211_parse_mesh_setup(info, &setup);
11264 if (setup.user_mpm)
11265 cfg.auto_open_plinks = false;
11267 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
11268 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
11272 /* __cfg80211_join_mesh() will sort it out */
11273 setup.chandef.chan = NULL;
11276 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
11277 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
11279 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
11280 struct ieee80211_supported_band *sband;
11282 if (!setup.chandef.chan)
11285 sband = rdev->wiphy.bands[setup.chandef.chan->band];
11287 err = ieee80211_get_ratemask(sband, rates, n_rates,
11288 &setup.basic_rates);
11293 if (info->attrs[NL80211_ATTR_TX_RATES]) {
11294 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
11298 if (!setup.chandef.chan)
11301 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
11302 &setup.beacon_rate);
11307 setup.userspace_handles_dfs =
11308 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
11310 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
11311 int r = validate_pae_over_nl80211(rdev, info);
11316 setup.control_port_over_nl80211 = true;
11319 wdev_lock(dev->ieee80211_ptr);
11320 err = __cfg80211_join_mesh(rdev, dev, &setup, &cfg);
11321 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER])
11322 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
11323 wdev_unlock(dev->ieee80211_ptr);
11328 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
11330 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11331 struct net_device *dev = info->user_ptr[1];
11333 return cfg80211_leave_mesh(rdev, dev);
11337 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
11338 struct cfg80211_registered_device *rdev)
11340 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
11341 struct nlattr *nl_pats, *nl_pat;
11344 if (!wowlan->n_patterns)
11347 nl_pats = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
11351 for (i = 0; i < wowlan->n_patterns; i++) {
11352 nl_pat = nla_nest_start_noflag(msg, i + 1);
11355 pat_len = wowlan->patterns[i].pattern_len;
11356 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
11357 wowlan->patterns[i].mask) ||
11358 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
11359 wowlan->patterns[i].pattern) ||
11360 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
11361 wowlan->patterns[i].pkt_offset))
11363 nla_nest_end(msg, nl_pat);
11365 nla_nest_end(msg, nl_pats);
11370 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
11371 struct cfg80211_wowlan_tcp *tcp)
11373 struct nlattr *nl_tcp;
11378 nl_tcp = nla_nest_start_noflag(msg,
11379 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
11383 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
11384 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
11385 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
11386 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
11387 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
11388 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
11389 tcp->payload_len, tcp->payload) ||
11390 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
11391 tcp->data_interval) ||
11392 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
11393 tcp->wake_len, tcp->wake_data) ||
11394 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
11395 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
11398 if (tcp->payload_seq.len &&
11399 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
11400 sizeof(tcp->payload_seq), &tcp->payload_seq))
11403 if (tcp->payload_tok.len &&
11404 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
11405 sizeof(tcp->payload_tok) + tcp->tokens_size,
11406 &tcp->payload_tok))
11409 nla_nest_end(msg, nl_tcp);
11414 static int nl80211_send_wowlan_nd(struct sk_buff *msg,
11415 struct cfg80211_sched_scan_request *req)
11417 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
11423 nd = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
11427 if (req->n_scan_plans == 1 &&
11428 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
11429 req->scan_plans[0].interval * 1000))
11432 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
11435 if (req->relative_rssi_set) {
11436 struct nl80211_bss_select_rssi_adjust rssi_adjust;
11438 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
11439 req->relative_rssi))
11442 rssi_adjust.band = req->rssi_adjust.band;
11443 rssi_adjust.delta = req->rssi_adjust.delta;
11444 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
11445 sizeof(rssi_adjust), &rssi_adjust))
11449 freqs = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES);
11453 for (i = 0; i < req->n_channels; i++) {
11454 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
11458 nla_nest_end(msg, freqs);
11460 if (req->n_match_sets) {
11461 matches = nla_nest_start_noflag(msg,
11462 NL80211_ATTR_SCHED_SCAN_MATCH);
11466 for (i = 0; i < req->n_match_sets; i++) {
11467 match = nla_nest_start_noflag(msg, i);
11471 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
11472 req->match_sets[i].ssid.ssid_len,
11473 req->match_sets[i].ssid.ssid))
11475 nla_nest_end(msg, match);
11477 nla_nest_end(msg, matches);
11480 scan_plans = nla_nest_start_noflag(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
11484 for (i = 0; i < req->n_scan_plans; i++) {
11485 scan_plan = nla_nest_start_noflag(msg, i + 1);
11489 if (nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
11490 req->scan_plans[i].interval) ||
11491 (req->scan_plans[i].iterations &&
11492 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
11493 req->scan_plans[i].iterations)))
11495 nla_nest_end(msg, scan_plan);
11497 nla_nest_end(msg, scan_plans);
11499 nla_nest_end(msg, nd);
11504 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
11506 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11507 struct sk_buff *msg;
11509 u32 size = NLMSG_DEFAULT_SIZE;
11511 if (!rdev->wiphy.wowlan)
11512 return -EOPNOTSUPP;
11514 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
11515 /* adjust size to have room for all the data */
11516 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
11517 rdev->wiphy.wowlan_config->tcp->payload_len +
11518 rdev->wiphy.wowlan_config->tcp->wake_len +
11519 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
11522 msg = nlmsg_new(size, GFP_KERNEL);
11526 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11527 NL80211_CMD_GET_WOWLAN);
11529 goto nla_put_failure;
11531 if (rdev->wiphy.wowlan_config) {
11532 struct nlattr *nl_wowlan;
11534 nl_wowlan = nla_nest_start_noflag(msg,
11535 NL80211_ATTR_WOWLAN_TRIGGERS);
11537 goto nla_put_failure;
11539 if ((rdev->wiphy.wowlan_config->any &&
11540 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
11541 (rdev->wiphy.wowlan_config->disconnect &&
11542 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
11543 (rdev->wiphy.wowlan_config->magic_pkt &&
11544 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
11545 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
11546 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
11547 (rdev->wiphy.wowlan_config->eap_identity_req &&
11548 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
11549 (rdev->wiphy.wowlan_config->four_way_handshake &&
11550 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
11551 (rdev->wiphy.wowlan_config->rfkill_release &&
11552 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
11553 goto nla_put_failure;
11555 if (nl80211_send_wowlan_patterns(msg, rdev))
11556 goto nla_put_failure;
11558 if (nl80211_send_wowlan_tcp(msg,
11559 rdev->wiphy.wowlan_config->tcp))
11560 goto nla_put_failure;
11562 if (nl80211_send_wowlan_nd(
11564 rdev->wiphy.wowlan_config->nd_config))
11565 goto nla_put_failure;
11567 nla_nest_end(msg, nl_wowlan);
11570 genlmsg_end(msg, hdr);
11571 return genlmsg_reply(msg, info);
11578 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
11579 struct nlattr *attr,
11580 struct cfg80211_wowlan *trig)
11582 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
11583 struct cfg80211_wowlan_tcp *cfg;
11584 struct nl80211_wowlan_tcp_data_token *tok = NULL;
11585 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
11587 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
11590 if (!rdev->wiphy.wowlan->tcp)
11593 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TCP, attr,
11594 nl80211_wowlan_tcp_policy, NULL);
11598 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
11599 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
11600 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
11601 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
11602 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
11603 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
11604 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
11605 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
11608 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
11609 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
11612 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
11613 rdev->wiphy.wowlan->tcp->data_interval_max ||
11614 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
11617 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
11618 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
11621 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
11622 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
11625 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
11626 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
11628 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
11629 tokens_size = tokln - sizeof(*tok);
11631 if (!tok->len || tokens_size % tok->len)
11633 if (!rdev->wiphy.wowlan->tcp->tok)
11635 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
11637 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
11639 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
11641 if (tok->offset + tok->len > data_size)
11645 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
11646 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
11647 if (!rdev->wiphy.wowlan->tcp->seq)
11649 if (seq->len == 0 || seq->len > 4)
11651 if (seq->len + seq->offset > data_size)
11655 size = sizeof(*cfg);
11657 size += wake_size + wake_mask_size;
11658 size += tokens_size;
11660 cfg = kzalloc(size, GFP_KERNEL);
11663 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
11664 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
11665 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
11667 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
11668 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
11672 /* allocate a socket and port for it and use it */
11673 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
11674 IPPROTO_TCP, &cfg->sock, 1);
11679 if (inet_csk_get_port(cfg->sock->sk, port)) {
11680 sock_release(cfg->sock);
11682 return -EADDRINUSE;
11684 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
11690 cfg->src_port = port;
11693 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
11694 cfg->payload_len = data_size;
11695 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
11696 memcpy((void *)cfg->payload,
11697 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
11700 cfg->payload_seq = *seq;
11701 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
11702 cfg->wake_len = wake_size;
11703 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
11704 memcpy((void *)cfg->wake_data,
11705 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
11707 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
11708 data_size + wake_size;
11709 memcpy((void *)cfg->wake_mask,
11710 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
11713 cfg->tokens_size = tokens_size;
11714 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
11722 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
11723 const struct wiphy_wowlan_support *wowlan,
11724 struct nlattr *attr,
11725 struct cfg80211_wowlan *trig)
11727 struct nlattr **tb;
11730 tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
11734 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
11739 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_MAX, attr,
11740 nl80211_policy, NULL);
11744 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
11745 wowlan->max_nd_match_sets);
11746 err = PTR_ERR_OR_ZERO(trig->nd_config);
11748 trig->nd_config = NULL;
11755 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
11757 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11758 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
11759 struct cfg80211_wowlan new_triggers = {};
11760 struct cfg80211_wowlan *ntrig;
11761 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
11763 bool prev_enabled = rdev->wiphy.wowlan_config;
11764 bool regular = false;
11767 return -EOPNOTSUPP;
11769 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
11770 cfg80211_rdev_free_wowlan(rdev);
11771 rdev->wiphy.wowlan_config = NULL;
11775 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TRIG,
11776 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
11777 nl80211_wowlan_policy, info->extack);
11781 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
11782 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
11784 new_triggers.any = true;
11787 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
11788 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
11790 new_triggers.disconnect = true;
11794 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
11795 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
11797 new_triggers.magic_pkt = true;
11801 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
11804 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
11805 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
11807 new_triggers.gtk_rekey_failure = true;
11811 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
11812 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
11814 new_triggers.eap_identity_req = true;
11818 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
11819 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
11821 new_triggers.four_way_handshake = true;
11825 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
11826 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
11828 new_triggers.rfkill_release = true;
11832 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
11833 struct nlattr *pat;
11834 int n_patterns = 0;
11835 int rem, pat_len, mask_len, pkt_offset;
11836 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
11840 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
11843 if (n_patterns > wowlan->n_patterns)
11846 new_triggers.patterns = kcalloc(n_patterns,
11847 sizeof(new_triggers.patterns[0]),
11849 if (!new_triggers.patterns)
11852 new_triggers.n_patterns = n_patterns;
11855 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
11859 err = nla_parse_nested_deprecated(pat_tb,
11860 MAX_NL80211_PKTPAT,
11862 nl80211_packet_pattern_policy,
11868 if (!pat_tb[NL80211_PKTPAT_MASK] ||
11869 !pat_tb[NL80211_PKTPAT_PATTERN])
11871 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
11872 mask_len = DIV_ROUND_UP(pat_len, 8);
11873 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
11875 if (pat_len > wowlan->pattern_max_len ||
11876 pat_len < wowlan->pattern_min_len)
11879 if (!pat_tb[NL80211_PKTPAT_OFFSET])
11882 pkt_offset = nla_get_u32(
11883 pat_tb[NL80211_PKTPAT_OFFSET]);
11884 if (pkt_offset > wowlan->max_pkt_offset)
11886 new_triggers.patterns[i].pkt_offset = pkt_offset;
11888 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
11893 new_triggers.patterns[i].mask = mask_pat;
11894 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
11896 mask_pat += mask_len;
11897 new_triggers.patterns[i].pattern = mask_pat;
11898 new_triggers.patterns[i].pattern_len = pat_len;
11900 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
11906 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
11908 err = nl80211_parse_wowlan_tcp(
11909 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
11915 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
11917 err = nl80211_parse_wowlan_nd(
11918 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
11924 /* The 'any' trigger means the device continues operating more or less
11925 * as in its normal operation mode and wakes up the host on most of the
11926 * normal interrupts (like packet RX, ...)
11927 * It therefore makes little sense to combine with the more constrained
11928 * wakeup trigger modes.
11930 if (new_triggers.any && regular) {
11935 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
11940 cfg80211_rdev_free_wowlan(rdev);
11941 rdev->wiphy.wowlan_config = ntrig;
11944 if (rdev->ops->set_wakeup &&
11945 prev_enabled != !!rdev->wiphy.wowlan_config)
11946 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
11950 for (i = 0; i < new_triggers.n_patterns; i++)
11951 kfree(new_triggers.patterns[i].mask);
11952 kfree(new_triggers.patterns);
11953 if (new_triggers.tcp && new_triggers.tcp->sock)
11954 sock_release(new_triggers.tcp->sock);
11955 kfree(new_triggers.tcp);
11956 kfree(new_triggers.nd_config);
11961 static int nl80211_send_coalesce_rules(struct sk_buff *msg,
11962 struct cfg80211_registered_device *rdev)
11964 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
11966 struct cfg80211_coalesce_rules *rule;
11968 if (!rdev->coalesce->n_rules)
11971 nl_rules = nla_nest_start_noflag(msg, NL80211_ATTR_COALESCE_RULE);
11975 for (i = 0; i < rdev->coalesce->n_rules; i++) {
11976 nl_rule = nla_nest_start_noflag(msg, i + 1);
11980 rule = &rdev->coalesce->rules[i];
11981 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
11985 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
11989 nl_pats = nla_nest_start_noflag(msg,
11990 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
11994 for (j = 0; j < rule->n_patterns; j++) {
11995 nl_pat = nla_nest_start_noflag(msg, j + 1);
11998 pat_len = rule->patterns[j].pattern_len;
11999 if (nla_put(msg, NL80211_PKTPAT_MASK,
12000 DIV_ROUND_UP(pat_len, 8),
12001 rule->patterns[j].mask) ||
12002 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
12003 rule->patterns[j].pattern) ||
12004 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
12005 rule->patterns[j].pkt_offset))
12007 nla_nest_end(msg, nl_pat);
12009 nla_nest_end(msg, nl_pats);
12010 nla_nest_end(msg, nl_rule);
12012 nla_nest_end(msg, nl_rules);
12017 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
12019 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12020 struct sk_buff *msg;
12023 if (!rdev->wiphy.coalesce)
12024 return -EOPNOTSUPP;
12026 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12030 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12031 NL80211_CMD_GET_COALESCE);
12033 goto nla_put_failure;
12035 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
12036 goto nla_put_failure;
12038 genlmsg_end(msg, hdr);
12039 return genlmsg_reply(msg, info);
12046 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
12048 struct cfg80211_coalesce *coalesce = rdev->coalesce;
12050 struct cfg80211_coalesce_rules *rule;
12055 for (i = 0; i < coalesce->n_rules; i++) {
12056 rule = &coalesce->rules[i];
12057 for (j = 0; j < rule->n_patterns; j++)
12058 kfree(rule->patterns[j].mask);
12059 kfree(rule->patterns);
12061 kfree(coalesce->rules);
12063 rdev->coalesce = NULL;
12066 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
12067 struct nlattr *rule,
12068 struct cfg80211_coalesce_rules *new_rule)
12071 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
12072 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
12073 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
12074 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
12076 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_COALESCE_RULE_MAX,
12077 rule, nl80211_coalesce_policy, NULL);
12081 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
12083 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
12084 if (new_rule->delay > coalesce->max_delay)
12087 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
12088 new_rule->condition =
12089 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
12091 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
12094 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
12097 if (n_patterns > coalesce->n_patterns)
12100 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
12102 if (!new_rule->patterns)
12105 new_rule->n_patterns = n_patterns;
12108 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
12112 err = nla_parse_nested_deprecated(pat_tb, MAX_NL80211_PKTPAT,
12114 nl80211_packet_pattern_policy,
12119 if (!pat_tb[NL80211_PKTPAT_MASK] ||
12120 !pat_tb[NL80211_PKTPAT_PATTERN])
12122 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
12123 mask_len = DIV_ROUND_UP(pat_len, 8);
12124 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
12126 if (pat_len > coalesce->pattern_max_len ||
12127 pat_len < coalesce->pattern_min_len)
12130 if (!pat_tb[NL80211_PKTPAT_OFFSET])
12133 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
12134 if (pkt_offset > coalesce->max_pkt_offset)
12136 new_rule->patterns[i].pkt_offset = pkt_offset;
12138 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
12142 new_rule->patterns[i].mask = mask_pat;
12143 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
12146 mask_pat += mask_len;
12147 new_rule->patterns[i].pattern = mask_pat;
12148 new_rule->patterns[i].pattern_len = pat_len;
12149 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
12157 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
12159 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12160 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
12161 struct cfg80211_coalesce new_coalesce = {};
12162 struct cfg80211_coalesce *n_coalesce;
12163 int err, rem_rule, n_rules = 0, i, j;
12164 struct nlattr *rule;
12165 struct cfg80211_coalesce_rules *tmp_rule;
12167 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
12168 return -EOPNOTSUPP;
12170 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
12171 cfg80211_rdev_free_coalesce(rdev);
12172 rdev_set_coalesce(rdev, NULL);
12176 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
12179 if (n_rules > coalesce->n_rules)
12182 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
12184 if (!new_coalesce.rules)
12187 new_coalesce.n_rules = n_rules;
12190 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
12192 err = nl80211_parse_coalesce_rule(rdev, rule,
12193 &new_coalesce.rules[i]);
12200 err = rdev_set_coalesce(rdev, &new_coalesce);
12204 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
12209 cfg80211_rdev_free_coalesce(rdev);
12210 rdev->coalesce = n_coalesce;
12214 for (i = 0; i < new_coalesce.n_rules; i++) {
12215 tmp_rule = &new_coalesce.rules[i];
12216 for (j = 0; j < tmp_rule->n_patterns; j++)
12217 kfree(tmp_rule->patterns[j].mask);
12218 kfree(tmp_rule->patterns);
12220 kfree(new_coalesce.rules);
12225 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
12227 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12228 struct net_device *dev = info->user_ptr[1];
12229 struct wireless_dev *wdev = dev->ieee80211_ptr;
12230 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
12231 struct cfg80211_gtk_rekey_data rekey_data;
12234 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
12237 err = nla_parse_nested_deprecated(tb, MAX_NL80211_REKEY_DATA,
12238 info->attrs[NL80211_ATTR_REKEY_DATA],
12239 nl80211_rekey_policy, info->extack);
12243 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
12244 !tb[NL80211_REKEY_DATA_KCK])
12246 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
12248 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
12250 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
12253 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
12254 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
12255 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
12258 if (!wdev->current_bss) {
12263 if (!rdev->ops->set_rekey_data) {
12268 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
12274 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
12275 struct genl_info *info)
12277 struct net_device *dev = info->user_ptr[1];
12278 struct wireless_dev *wdev = dev->ieee80211_ptr;
12280 if (wdev->iftype != NL80211_IFTYPE_AP &&
12281 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12284 if (wdev->ap_unexpected_nlportid)
12287 wdev->ap_unexpected_nlportid = info->snd_portid;
12291 static int nl80211_probe_client(struct sk_buff *skb,
12292 struct genl_info *info)
12294 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12295 struct net_device *dev = info->user_ptr[1];
12296 struct wireless_dev *wdev = dev->ieee80211_ptr;
12297 struct sk_buff *msg;
12303 if (wdev->iftype != NL80211_IFTYPE_AP &&
12304 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12305 return -EOPNOTSUPP;
12307 if (!info->attrs[NL80211_ATTR_MAC])
12310 if (!rdev->ops->probe_client)
12311 return -EOPNOTSUPP;
12313 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12317 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12318 NL80211_CMD_PROBE_CLIENT);
12324 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12326 err = rdev_probe_client(rdev, dev, addr, &cookie);
12330 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12332 goto nla_put_failure;
12334 genlmsg_end(msg, hdr);
12336 return genlmsg_reply(msg, info);
12345 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
12347 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12348 struct cfg80211_beacon_registration *reg, *nreg;
12351 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
12352 return -EOPNOTSUPP;
12354 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
12358 /* First, check if already registered. */
12359 spin_lock_bh(&rdev->beacon_registrations_lock);
12360 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
12361 if (reg->nlportid == info->snd_portid) {
12366 /* Add it to the list */
12367 nreg->nlportid = info->snd_portid;
12368 list_add(&nreg->list, &rdev->beacon_registrations);
12370 spin_unlock_bh(&rdev->beacon_registrations_lock);
12374 spin_unlock_bh(&rdev->beacon_registrations_lock);
12379 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
12381 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12382 struct wireless_dev *wdev = info->user_ptr[1];
12385 if (!rdev->ops->start_p2p_device)
12386 return -EOPNOTSUPP;
12388 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
12389 return -EOPNOTSUPP;
12391 if (wdev_running(wdev))
12394 if (rfkill_blocked(rdev->rfkill))
12397 err = rdev_start_p2p_device(rdev, wdev);
12401 wdev->is_running = true;
12407 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
12409 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12410 struct wireless_dev *wdev = info->user_ptr[1];
12412 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
12413 return -EOPNOTSUPP;
12415 if (!rdev->ops->stop_p2p_device)
12416 return -EOPNOTSUPP;
12418 cfg80211_stop_p2p_device(rdev, wdev);
12423 static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
12425 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12426 struct wireless_dev *wdev = info->user_ptr[1];
12427 struct cfg80211_nan_conf conf = {};
12430 if (wdev->iftype != NL80211_IFTYPE_NAN)
12431 return -EOPNOTSUPP;
12433 if (wdev_running(wdev))
12436 if (rfkill_blocked(rdev->rfkill))
12439 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
12443 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
12445 if (info->attrs[NL80211_ATTR_BANDS]) {
12446 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
12448 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
12449 return -EOPNOTSUPP;
12451 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
12454 conf.bands = bands;
12457 err = rdev_start_nan(rdev, wdev, &conf);
12461 wdev->is_running = true;
12467 static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
12469 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12470 struct wireless_dev *wdev = info->user_ptr[1];
12472 if (wdev->iftype != NL80211_IFTYPE_NAN)
12473 return -EOPNOTSUPP;
12475 cfg80211_stop_nan(rdev, wdev);
12480 static int validate_nan_filter(struct nlattr *filter_attr)
12482 struct nlattr *attr;
12483 int len = 0, n_entries = 0, rem;
12485 nla_for_each_nested(attr, filter_attr, rem) {
12486 len += nla_len(attr);
12496 static int handle_nan_filter(struct nlattr *attr_filter,
12497 struct cfg80211_nan_func *func,
12500 struct nlattr *attr;
12501 int n_entries, rem, i;
12502 struct cfg80211_nan_func_filter *filter;
12504 n_entries = validate_nan_filter(attr_filter);
12508 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
12510 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
12515 nla_for_each_nested(attr, attr_filter, rem) {
12516 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
12517 filter[i].len = nla_len(attr);
12521 func->num_tx_filters = n_entries;
12522 func->tx_filters = filter;
12524 func->num_rx_filters = n_entries;
12525 func->rx_filters = filter;
12531 static int nl80211_nan_add_func(struct sk_buff *skb,
12532 struct genl_info *info)
12534 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12535 struct wireless_dev *wdev = info->user_ptr[1];
12536 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
12537 struct cfg80211_nan_func *func;
12538 struct sk_buff *msg = NULL;
12542 if (wdev->iftype != NL80211_IFTYPE_NAN)
12543 return -EOPNOTSUPP;
12545 if (!wdev_running(wdev))
12548 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
12551 err = nla_parse_nested_deprecated(tb, NL80211_NAN_FUNC_ATTR_MAX,
12552 info->attrs[NL80211_ATTR_NAN_FUNC],
12553 nl80211_nan_func_policy,
12558 func = kzalloc(sizeof(*func), GFP_KERNEL);
12562 func->cookie = cfg80211_assign_cookie(rdev);
12564 if (!tb[NL80211_NAN_FUNC_TYPE] ||
12565 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
12571 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
12573 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
12578 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
12579 sizeof(func->service_id));
12581 func->close_range =
12582 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
12584 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
12585 func->serv_spec_info_len =
12586 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
12587 func->serv_spec_info =
12588 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
12589 func->serv_spec_info_len,
12591 if (!func->serv_spec_info) {
12597 if (tb[NL80211_NAN_FUNC_TTL])
12598 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
12600 switch (func->type) {
12601 case NL80211_NAN_FUNC_PUBLISH:
12602 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
12607 func->publish_type =
12608 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
12609 func->publish_bcast =
12610 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
12612 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
12613 func->publish_bcast) {
12618 case NL80211_NAN_FUNC_SUBSCRIBE:
12619 func->subscribe_active =
12620 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
12622 case NL80211_NAN_FUNC_FOLLOW_UP:
12623 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
12624 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] ||
12625 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) {
12630 func->followup_id =
12631 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
12632 func->followup_reqid =
12633 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
12634 memcpy(func->followup_dest.addr,
12635 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
12636 sizeof(func->followup_dest.addr));
12647 if (tb[NL80211_NAN_FUNC_SRF]) {
12648 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
12650 err = nla_parse_nested_deprecated(srf_tb,
12651 NL80211_NAN_SRF_ATTR_MAX,
12652 tb[NL80211_NAN_FUNC_SRF],
12653 nl80211_nan_srf_policy,
12658 func->srf_include =
12659 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
12661 if (srf_tb[NL80211_NAN_SRF_BF]) {
12662 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
12663 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
12669 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
12671 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
12672 func->srf_bf_len, GFP_KERNEL);
12673 if (!func->srf_bf) {
12679 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
12681 struct nlattr *attr, *mac_attr =
12682 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
12683 int n_entries, rem, i = 0;
12690 n_entries = validate_acl_mac_addrs(mac_attr);
12691 if (n_entries <= 0) {
12696 func->srf_num_macs = n_entries;
12698 kcalloc(n_entries, sizeof(*func->srf_macs),
12700 if (!func->srf_macs) {
12705 nla_for_each_nested(attr, mac_attr, rem)
12706 memcpy(func->srf_macs[i++].addr, nla_data(attr),
12707 sizeof(*func->srf_macs));
12711 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
12712 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
12718 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
12719 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
12725 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12731 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12732 NL80211_CMD_ADD_NAN_FUNCTION);
12733 /* This can't really happen - we just allocated 4KB */
12734 if (WARN_ON(!hdr)) {
12739 err = rdev_add_nan_func(rdev, wdev, func);
12742 cfg80211_free_nan_func(func);
12747 /* propagate the instance id and cookie to userspace */
12748 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
12750 goto nla_put_failure;
12752 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
12754 goto nla_put_failure;
12756 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
12757 func->instance_id))
12758 goto nla_put_failure;
12760 nla_nest_end(msg, func_attr);
12762 genlmsg_end(msg, hdr);
12763 return genlmsg_reply(msg, info);
12770 static int nl80211_nan_del_func(struct sk_buff *skb,
12771 struct genl_info *info)
12773 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12774 struct wireless_dev *wdev = info->user_ptr[1];
12777 if (wdev->iftype != NL80211_IFTYPE_NAN)
12778 return -EOPNOTSUPP;
12780 if (!wdev_running(wdev))
12783 if (!info->attrs[NL80211_ATTR_COOKIE])
12786 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
12788 rdev_del_nan_func(rdev, wdev, cookie);
12793 static int nl80211_nan_change_config(struct sk_buff *skb,
12794 struct genl_info *info)
12796 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12797 struct wireless_dev *wdev = info->user_ptr[1];
12798 struct cfg80211_nan_conf conf = {};
12801 if (wdev->iftype != NL80211_IFTYPE_NAN)
12802 return -EOPNOTSUPP;
12804 if (!wdev_running(wdev))
12807 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
12809 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
12810 if (conf.master_pref <= 1 || conf.master_pref == 255)
12813 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
12816 if (info->attrs[NL80211_ATTR_BANDS]) {
12817 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
12819 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
12820 return -EOPNOTSUPP;
12822 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
12825 conf.bands = bands;
12826 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
12832 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
12835 void cfg80211_nan_match(struct wireless_dev *wdev,
12836 struct cfg80211_nan_match_params *match, gfp_t gfp)
12838 struct wiphy *wiphy = wdev->wiphy;
12839 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12840 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
12841 struct sk_buff *msg;
12844 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
12847 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12851 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
12857 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12858 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12859 wdev->netdev->ifindex)) ||
12860 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
12862 goto nla_put_failure;
12864 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
12865 NL80211_ATTR_PAD) ||
12866 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
12867 goto nla_put_failure;
12869 match_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_MATCH);
12871 goto nla_put_failure;
12873 local_func_attr = nla_nest_start_noflag(msg,
12874 NL80211_NAN_MATCH_FUNC_LOCAL);
12875 if (!local_func_attr)
12876 goto nla_put_failure;
12878 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
12879 goto nla_put_failure;
12881 nla_nest_end(msg, local_func_attr);
12883 peer_func_attr = nla_nest_start_noflag(msg,
12884 NL80211_NAN_MATCH_FUNC_PEER);
12885 if (!peer_func_attr)
12886 goto nla_put_failure;
12888 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
12889 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
12890 goto nla_put_failure;
12892 if (match->info && match->info_len &&
12893 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
12895 goto nla_put_failure;
12897 nla_nest_end(msg, peer_func_attr);
12898 nla_nest_end(msg, match_attr);
12899 genlmsg_end(msg, hdr);
12901 if (!wdev->owner_nlportid)
12902 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12903 msg, 0, NL80211_MCGRP_NAN, gfp);
12905 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
12906 wdev->owner_nlportid);
12913 EXPORT_SYMBOL(cfg80211_nan_match);
12915 void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
12917 enum nl80211_nan_func_term_reason reason,
12918 u64 cookie, gfp_t gfp)
12920 struct wiphy *wiphy = wdev->wiphy;
12921 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12922 struct sk_buff *msg;
12923 struct nlattr *func_attr;
12926 if (WARN_ON(!inst_id))
12929 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12933 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
12939 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12940 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12941 wdev->netdev->ifindex)) ||
12942 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
12944 goto nla_put_failure;
12946 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12948 goto nla_put_failure;
12950 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
12952 goto nla_put_failure;
12954 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
12955 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
12956 goto nla_put_failure;
12958 nla_nest_end(msg, func_attr);
12959 genlmsg_end(msg, hdr);
12961 if (!wdev->owner_nlportid)
12962 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12963 msg, 0, NL80211_MCGRP_NAN, gfp);
12965 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
12966 wdev->owner_nlportid);
12973 EXPORT_SYMBOL(cfg80211_nan_func_terminated);
12975 static int nl80211_get_protocol_features(struct sk_buff *skb,
12976 struct genl_info *info)
12979 struct sk_buff *msg;
12981 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12985 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12986 NL80211_CMD_GET_PROTOCOL_FEATURES);
12988 goto nla_put_failure;
12990 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
12991 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
12992 goto nla_put_failure;
12994 genlmsg_end(msg, hdr);
12995 return genlmsg_reply(msg, info);
13002 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
13004 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13005 struct cfg80211_update_ft_ies_params ft_params;
13006 struct net_device *dev = info->user_ptr[1];
13008 if (!rdev->ops->update_ft_ies)
13009 return -EOPNOTSUPP;
13011 if (!info->attrs[NL80211_ATTR_MDID] ||
13012 !info->attrs[NL80211_ATTR_IE])
13015 memset(&ft_params, 0, sizeof(ft_params));
13016 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
13017 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
13018 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
13020 return rdev_update_ft_ies(rdev, dev, &ft_params);
13023 static int nl80211_crit_protocol_start(struct sk_buff *skb,
13024 struct genl_info *info)
13026 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13027 struct wireless_dev *wdev = info->user_ptr[1];
13028 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
13032 if (!rdev->ops->crit_proto_start)
13033 return -EOPNOTSUPP;
13035 if (WARN_ON(!rdev->ops->crit_proto_stop))
13038 if (rdev->crit_proto_nlportid)
13041 /* determine protocol if provided */
13042 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
13043 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
13045 if (proto >= NUM_NL80211_CRIT_PROTO)
13048 /* timeout must be provided */
13049 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
13053 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
13055 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
13058 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
13060 rdev->crit_proto_nlportid = info->snd_portid;
13065 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
13066 struct genl_info *info)
13068 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13069 struct wireless_dev *wdev = info->user_ptr[1];
13071 if (!rdev->ops->crit_proto_stop)
13072 return -EOPNOTSUPP;
13074 if (rdev->crit_proto_nlportid) {
13075 rdev->crit_proto_nlportid = 0;
13076 rdev_crit_proto_stop(rdev, wdev);
13081 static int nl80211_vendor_check_policy(const struct wiphy_vendor_command *vcmd,
13082 struct nlattr *attr,
13083 struct netlink_ext_ack *extack)
13085 if (vcmd->policy == VENDOR_CMD_RAW_DATA) {
13086 if (attr->nla_type & NLA_F_NESTED) {
13087 NL_SET_ERR_MSG_ATTR(extack, attr,
13088 "unexpected nested data");
13095 if (!(attr->nla_type & NLA_F_NESTED)) {
13096 NL_SET_ERR_MSG_ATTR(extack, attr, "expected nested data");
13100 return nla_validate_nested(attr, vcmd->maxattr, vcmd->policy, extack);
13103 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
13105 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13106 struct wireless_dev *wdev =
13107 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
13111 if (!rdev->wiphy.vendor_commands)
13112 return -EOPNOTSUPP;
13114 if (IS_ERR(wdev)) {
13115 err = PTR_ERR(wdev);
13116 if (err != -EINVAL)
13119 } else if (wdev->wiphy != &rdev->wiphy) {
13123 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
13124 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
13127 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
13128 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
13129 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
13130 const struct wiphy_vendor_command *vcmd;
13134 vcmd = &rdev->wiphy.vendor_commands[i];
13136 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
13139 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
13140 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
13143 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
13147 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
13148 if (!wdev_running(wdev))
13153 return -EOPNOTSUPP;
13158 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
13159 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
13160 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
13162 err = nl80211_vendor_check_policy(vcmd,
13163 info->attrs[NL80211_ATTR_VENDOR_DATA],
13169 rdev->cur_cmd_info = info;
13170 err = vcmd->doit(&rdev->wiphy, wdev, data, len);
13171 rdev->cur_cmd_info = NULL;
13175 return -EOPNOTSUPP;
13178 static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
13179 struct netlink_callback *cb,
13180 struct cfg80211_registered_device **rdev,
13181 struct wireless_dev **wdev)
13183 struct nlattr **attrbuf;
13189 unsigned int data_len = 0;
13192 /* subtract the 1 again here */
13193 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
13194 struct wireless_dev *tmp;
13198 *rdev = wiphy_to_rdev(wiphy);
13202 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
13203 if (tmp->identifier == cb->args[1] - 1) {
13210 /* keep rtnl locked in successful case */
13214 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
13218 err = nlmsg_parse_deprecated(cb->nlh,
13219 GENL_HDRLEN + nl80211_fam.hdrsize,
13220 attrbuf, nl80211_fam.maxattr,
13221 nl80211_policy, NULL);
13225 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
13226 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) {
13231 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
13235 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
13236 if (IS_ERR(*rdev)) {
13237 err = PTR_ERR(*rdev);
13241 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
13242 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
13244 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
13245 const struct wiphy_vendor_command *vcmd;
13247 vcmd = &(*rdev)->wiphy.vendor_commands[i];
13249 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
13252 if (!vcmd->dumpit) {
13261 if (vcmd_idx < 0) {
13266 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
13267 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
13268 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
13270 err = nl80211_vendor_check_policy(
13271 &(*rdev)->wiphy.vendor_commands[vcmd_idx],
13272 attrbuf[NL80211_ATTR_VENDOR_DATA],
13278 /* 0 is the first index - add 1 to parse only once */
13279 cb->args[0] = (*rdev)->wiphy_idx + 1;
13280 /* add 1 to know if it was NULL */
13281 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
13282 cb->args[2] = vcmd_idx;
13283 cb->args[3] = (unsigned long)data;
13284 cb->args[4] = data_len;
13286 /* keep rtnl locked in successful case */
13293 static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
13294 struct netlink_callback *cb)
13296 struct cfg80211_registered_device *rdev;
13297 struct wireless_dev *wdev;
13298 unsigned int vcmd_idx;
13299 const struct wiphy_vendor_command *vcmd;
13303 struct nlattr *vendor_data;
13306 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
13310 vcmd_idx = cb->args[2];
13311 data = (void *)cb->args[3];
13312 data_len = cb->args[4];
13313 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
13315 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
13316 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
13321 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
13327 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
13328 if (!wdev_running(wdev)) {
13336 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
13337 cb->nlh->nlmsg_seq, NLM_F_MULTI,
13338 NL80211_CMD_VENDOR);
13342 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13343 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
13345 NL80211_ATTR_PAD))) {
13346 genlmsg_cancel(skb, hdr);
13350 vendor_data = nla_nest_start_noflag(skb,
13351 NL80211_ATTR_VENDOR_DATA);
13352 if (!vendor_data) {
13353 genlmsg_cancel(skb, hdr);
13357 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
13358 (unsigned long *)&cb->args[5]);
13359 nla_nest_end(skb, vendor_data);
13361 if (err == -ENOBUFS || err == -ENOENT) {
13362 genlmsg_cancel(skb, hdr);
13365 genlmsg_cancel(skb, hdr);
13369 genlmsg_end(skb, hdr);
13378 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
13379 enum nl80211_commands cmd,
13380 enum nl80211_attrs attr,
13383 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
13385 if (WARN_ON(!rdev->cur_cmd_info))
13388 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
13389 rdev->cur_cmd_info->snd_portid,
13390 rdev->cur_cmd_info->snd_seq,
13391 cmd, attr, NULL, GFP_KERNEL);
13393 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
13395 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
13397 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
13398 void *hdr = ((void **)skb->cb)[1];
13399 struct nlattr *data = ((void **)skb->cb)[2];
13401 /* clear CB data for netlink core to own from now on */
13402 memset(skb->cb, 0, sizeof(skb->cb));
13404 if (WARN_ON(!rdev->cur_cmd_info)) {
13409 nla_nest_end(skb, data);
13410 genlmsg_end(skb, hdr);
13411 return genlmsg_reply(skb, rdev->cur_cmd_info);
13413 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
13415 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy *wiphy)
13417 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
13419 if (WARN_ON(!rdev->cur_cmd_info))
13422 return rdev->cur_cmd_info->snd_portid;
13424 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_get_sender);
13426 static int nl80211_set_qos_map(struct sk_buff *skb,
13427 struct genl_info *info)
13429 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13430 struct cfg80211_qos_map *qos_map = NULL;
13431 struct net_device *dev = info->user_ptr[1];
13432 u8 *pos, len, num_des, des_len, des;
13435 if (!rdev->ops->set_qos_map)
13436 return -EOPNOTSUPP;
13438 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
13439 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
13440 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
13442 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
13443 len > IEEE80211_QOS_MAP_LEN_MAX)
13446 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
13450 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
13452 des_len = num_des *
13453 sizeof(struct cfg80211_dscp_exception);
13454 memcpy(qos_map->dscp_exception, pos, des_len);
13455 qos_map->num_des = num_des;
13456 for (des = 0; des < num_des; des++) {
13457 if (qos_map->dscp_exception[des].up > 7) {
13464 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
13467 wdev_lock(dev->ieee80211_ptr);
13468 ret = nl80211_key_allowed(dev->ieee80211_ptr);
13470 ret = rdev_set_qos_map(rdev, dev, qos_map);
13471 wdev_unlock(dev->ieee80211_ptr);
13477 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
13479 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13480 struct net_device *dev = info->user_ptr[1];
13481 struct wireless_dev *wdev = dev->ieee80211_ptr;
13484 u16 admitted_time = 0;
13487 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
13488 return -EOPNOTSUPP;
13490 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
13491 !info->attrs[NL80211_ATTR_USER_PRIO])
13494 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
13495 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
13497 /* WMM uses TIDs 0-7 even for TSPEC */
13498 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
13499 /* TODO: handle 802.11 TSPEC/admission control
13500 * need more attributes for that (e.g. BA session requirement);
13501 * change the WMM adminssion test above to allow both then
13506 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
13508 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
13510 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
13511 if (!admitted_time)
13516 switch (wdev->iftype) {
13517 case NL80211_IFTYPE_STATION:
13518 case NL80211_IFTYPE_P2P_CLIENT:
13519 if (wdev->current_bss)
13528 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
13535 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
13537 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13538 struct net_device *dev = info->user_ptr[1];
13539 struct wireless_dev *wdev = dev->ieee80211_ptr;
13544 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
13547 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
13548 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
13551 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
13557 static int nl80211_tdls_channel_switch(struct sk_buff *skb,
13558 struct genl_info *info)
13560 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13561 struct net_device *dev = info->user_ptr[1];
13562 struct wireless_dev *wdev = dev->ieee80211_ptr;
13563 struct cfg80211_chan_def chandef = {};
13568 if (!rdev->ops->tdls_channel_switch ||
13569 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
13570 return -EOPNOTSUPP;
13572 switch (dev->ieee80211_ptr->iftype) {
13573 case NL80211_IFTYPE_STATION:
13574 case NL80211_IFTYPE_P2P_CLIENT:
13577 return -EOPNOTSUPP;
13580 if (!info->attrs[NL80211_ATTR_MAC] ||
13581 !info->attrs[NL80211_ATTR_OPER_CLASS])
13584 err = nl80211_parse_chandef(rdev, info, &chandef);
13589 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
13590 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
13591 * specification is not defined for them.
13593 if (chandef.chan->band == NL80211_BAND_2GHZ &&
13594 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
13595 chandef.width != NL80211_CHAN_WIDTH_20)
13598 /* we will be active on the TDLS link */
13599 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
13603 /* don't allow switching to DFS channels */
13604 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
13607 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
13608 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
13611 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
13617 static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
13618 struct genl_info *info)
13620 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13621 struct net_device *dev = info->user_ptr[1];
13622 struct wireless_dev *wdev = dev->ieee80211_ptr;
13625 if (!rdev->ops->tdls_channel_switch ||
13626 !rdev->ops->tdls_cancel_channel_switch ||
13627 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
13628 return -EOPNOTSUPP;
13630 switch (dev->ieee80211_ptr->iftype) {
13631 case NL80211_IFTYPE_STATION:
13632 case NL80211_IFTYPE_P2P_CLIENT:
13635 return -EOPNOTSUPP;
13638 if (!info->attrs[NL80211_ATTR_MAC])
13641 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
13644 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
13650 static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
13651 struct genl_info *info)
13653 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13654 struct net_device *dev = info->user_ptr[1];
13655 struct wireless_dev *wdev = dev->ieee80211_ptr;
13656 const struct nlattr *nla;
13659 if (!rdev->ops->set_multicast_to_unicast)
13660 return -EOPNOTSUPP;
13662 if (wdev->iftype != NL80211_IFTYPE_AP &&
13663 wdev->iftype != NL80211_IFTYPE_P2P_GO)
13664 return -EOPNOTSUPP;
13666 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
13667 enabled = nla_get_flag(nla);
13669 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
13672 static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
13674 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13675 struct net_device *dev = info->user_ptr[1];
13676 struct wireless_dev *wdev = dev->ieee80211_ptr;
13677 struct cfg80211_pmk_conf pmk_conf = {};
13680 if (wdev->iftype != NL80211_IFTYPE_STATION &&
13681 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
13682 return -EOPNOTSUPP;
13684 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13685 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
13686 return -EOPNOTSUPP;
13688 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
13692 if (!wdev->current_bss) {
13697 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
13698 if (memcmp(pmk_conf.aa, wdev->current_bss->pub.bssid, ETH_ALEN)) {
13703 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
13704 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
13705 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
13706 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
13711 if (info->attrs[NL80211_ATTR_PMKR0_NAME]) {
13712 int r0_name_len = nla_len(info->attrs[NL80211_ATTR_PMKR0_NAME]);
13714 if (r0_name_len != WLAN_PMK_NAME_LEN) {
13719 pmk_conf.pmk_r0_name =
13720 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
13723 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
13729 static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
13731 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13732 struct net_device *dev = info->user_ptr[1];
13733 struct wireless_dev *wdev = dev->ieee80211_ptr;
13737 if (wdev->iftype != NL80211_IFTYPE_STATION &&
13738 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
13739 return -EOPNOTSUPP;
13741 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13742 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
13743 return -EOPNOTSUPP;
13745 if (!info->attrs[NL80211_ATTR_MAC])
13749 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
13750 ret = rdev_del_pmk(rdev, dev, aa);
13756 static int nl80211_external_auth(struct sk_buff *skb, struct genl_info *info)
13758 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13759 struct net_device *dev = info->user_ptr[1];
13760 struct cfg80211_external_auth_params params;
13762 if (!rdev->ops->external_auth)
13763 return -EOPNOTSUPP;
13765 if (!info->attrs[NL80211_ATTR_SSID] &&
13766 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
13767 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
13770 if (!info->attrs[NL80211_ATTR_BSSID])
13773 if (!info->attrs[NL80211_ATTR_STATUS_CODE])
13776 memset(¶ms, 0, sizeof(params));
13778 if (info->attrs[NL80211_ATTR_SSID]) {
13779 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
13780 if (params.ssid.ssid_len == 0 ||
13781 params.ssid.ssid_len > IEEE80211_MAX_SSID_LEN)
13783 memcpy(params.ssid.ssid,
13784 nla_data(info->attrs[NL80211_ATTR_SSID]),
13785 params.ssid.ssid_len);
13788 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]),
13791 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
13793 if (info->attrs[NL80211_ATTR_PMKID])
13794 params.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
13796 return rdev_external_auth(rdev, dev, ¶ms);
13799 static int nl80211_tx_control_port(struct sk_buff *skb, struct genl_info *info)
13801 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13802 struct net_device *dev = info->user_ptr[1];
13803 struct wireless_dev *wdev = dev->ieee80211_ptr;
13811 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13812 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
13813 return -EOPNOTSUPP;
13815 if (!rdev->ops->tx_control_port)
13816 return -EOPNOTSUPP;
13818 if (!info->attrs[NL80211_ATTR_FRAME] ||
13819 !info->attrs[NL80211_ATTR_MAC] ||
13820 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
13821 GENL_SET_ERR_MSG(info, "Frame, MAC or ethertype missing");
13827 switch (wdev->iftype) {
13828 case NL80211_IFTYPE_AP:
13829 case NL80211_IFTYPE_P2P_GO:
13830 case NL80211_IFTYPE_MESH_POINT:
13832 case NL80211_IFTYPE_ADHOC:
13833 case NL80211_IFTYPE_STATION:
13834 case NL80211_IFTYPE_P2P_CLIENT:
13835 if (wdev->current_bss)
13846 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
13847 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
13848 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
13849 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
13851 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
13853 return rdev_tx_control_port(rdev, dev, buf, len,
13854 dest, cpu_to_be16(proto), noencrypt);
13861 static int nl80211_get_ftm_responder_stats(struct sk_buff *skb,
13862 struct genl_info *info)
13864 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13865 struct net_device *dev = info->user_ptr[1];
13866 struct wireless_dev *wdev = dev->ieee80211_ptr;
13867 struct cfg80211_ftm_responder_stats ftm_stats = {};
13868 struct sk_buff *msg;
13870 struct nlattr *ftm_stats_attr;
13873 if (wdev->iftype != NL80211_IFTYPE_AP || !wdev->beacon_interval)
13874 return -EOPNOTSUPP;
13876 err = rdev_get_ftm_responder_stats(rdev, dev, &ftm_stats);
13880 if (!ftm_stats.filled)
13883 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13887 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13888 NL80211_CMD_GET_FTM_RESPONDER_STATS);
13890 goto nla_put_failure;
13892 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
13893 goto nla_put_failure;
13895 ftm_stats_attr = nla_nest_start_noflag(msg,
13896 NL80211_ATTR_FTM_RESPONDER_STATS);
13897 if (!ftm_stats_attr)
13898 goto nla_put_failure;
13900 #define SET_FTM(field, name, type) \
13901 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
13902 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \
13903 ftm_stats.field)) \
13904 goto nla_put_failure; } while (0)
13905 #define SET_FTM_U64(field, name) \
13906 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
13907 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \
13908 ftm_stats.field, NL80211_FTM_STATS_PAD)) \
13909 goto nla_put_failure; } while (0)
13911 SET_FTM(success_num, SUCCESS_NUM, u32);
13912 SET_FTM(partial_num, PARTIAL_NUM, u32);
13913 SET_FTM(failed_num, FAILED_NUM, u32);
13914 SET_FTM(asap_num, ASAP_NUM, u32);
13915 SET_FTM(non_asap_num, NON_ASAP_NUM, u32);
13916 SET_FTM_U64(total_duration_ms, TOTAL_DURATION_MSEC);
13917 SET_FTM(unknown_triggers_num, UNKNOWN_TRIGGERS_NUM, u32);
13918 SET_FTM(reschedule_requests_num, RESCHEDULE_REQUESTS_NUM, u32);
13919 SET_FTM(out_of_window_triggers_num, OUT_OF_WINDOW_TRIGGERS_NUM, u32);
13922 nla_nest_end(msg, ftm_stats_attr);
13924 genlmsg_end(msg, hdr);
13925 return genlmsg_reply(msg, info);
13932 static int nl80211_update_owe_info(struct sk_buff *skb, struct genl_info *info)
13934 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13935 struct cfg80211_update_owe_info owe_info;
13936 struct net_device *dev = info->user_ptr[1];
13938 if (!rdev->ops->update_owe_info)
13939 return -EOPNOTSUPP;
13941 if (!info->attrs[NL80211_ATTR_STATUS_CODE] ||
13942 !info->attrs[NL80211_ATTR_MAC])
13945 memset(&owe_info, 0, sizeof(owe_info));
13946 owe_info.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
13947 nla_memcpy(owe_info.peer, info->attrs[NL80211_ATTR_MAC], ETH_ALEN);
13949 if (info->attrs[NL80211_ATTR_IE]) {
13950 owe_info.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
13951 owe_info.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
13954 return rdev_update_owe_info(rdev, dev, &owe_info);
13957 static int nl80211_probe_mesh_link(struct sk_buff *skb, struct genl_info *info)
13959 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13960 struct net_device *dev = info->user_ptr[1];
13961 struct wireless_dev *wdev = dev->ieee80211_ptr;
13962 struct station_info sinfo = {};
13968 if (!rdev->ops->probe_mesh_link || !rdev->ops->get_station)
13969 return -EOPNOTSUPP;
13971 if (!info->attrs[NL80211_ATTR_MAC] ||
13972 !info->attrs[NL80211_ATTR_FRAME]) {
13973 GENL_SET_ERR_MSG(info, "Frame or MAC missing");
13977 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
13978 return -EOPNOTSUPP;
13980 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
13981 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
13982 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
13984 if (len < sizeof(struct ethhdr))
13987 if (!ether_addr_equal(buf, dest) || is_multicast_ether_addr(buf) ||
13988 !ether_addr_equal(buf + ETH_ALEN, dev->dev_addr))
13991 err = rdev_get_station(rdev, dev, dest, &sinfo);
13995 cfg80211_sinfo_release_content(&sinfo);
13997 return rdev_probe_mesh_link(rdev, dev, dest, buf, len);
14000 static int parse_tid_conf(struct cfg80211_registered_device *rdev,
14001 struct nlattr *attrs[], struct net_device *dev,
14002 struct cfg80211_tid_cfg *tid_conf,
14003 struct genl_info *info, const u8 *peer)
14005 struct netlink_ext_ack *extack = info->extack;
14009 if (!attrs[NL80211_TID_CONFIG_ATTR_TIDS])
14012 tid_conf->config_override =
14013 nla_get_flag(attrs[NL80211_TID_CONFIG_ATTR_OVERRIDE]);
14014 tid_conf->tids = nla_get_u16(attrs[NL80211_TID_CONFIG_ATTR_TIDS]);
14016 if (tid_conf->config_override) {
14017 if (rdev->ops->reset_tid_config) {
14018 err = rdev_reset_tid_config(rdev, dev, peer,
14020 /* If peer is there no other configuration will be
14030 if (attrs[NL80211_TID_CONFIG_ATTR_NOACK]) {
14031 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_NOACK);
14033 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_NOACK]);
14036 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]) {
14037 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT);
14038 tid_conf->retry_short =
14039 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_SHORT]);
14041 if (tid_conf->retry_short > rdev->wiphy.max_data_retry_count)
14045 if (attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]) {
14046 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
14047 tid_conf->retry_long =
14048 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RETRY_LONG]);
14050 if (tid_conf->retry_long > rdev->wiphy.max_data_retry_count)
14054 if (attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]) {
14055 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);
14057 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL]);
14060 if (attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]) {
14061 tid_conf->mask |= BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);
14063 nla_get_u8(attrs[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL]);
14067 mask = rdev->wiphy.tid_config_support.peer;
14069 mask = rdev->wiphy.tid_config_support.vif;
14071 if (tid_conf->mask & ~mask) {
14072 NL_SET_ERR_MSG(extack, "unsupported TID configuration");
14079 static int nl80211_set_tid_config(struct sk_buff *skb,
14080 struct genl_info *info)
14082 struct cfg80211_registered_device *rdev = info->user_ptr[0];
14083 struct nlattr *attrs[NL80211_TID_CONFIG_ATTR_MAX + 1];
14084 struct net_device *dev = info->user_ptr[1];
14085 struct cfg80211_tid_config *tid_config;
14086 struct nlattr *tid;
14087 int conf_idx = 0, rem_conf;
14091 if (!info->attrs[NL80211_ATTR_TID_CONFIG])
14094 if (!rdev->ops->set_tid_config)
14095 return -EOPNOTSUPP;
14097 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
14101 tid_config = kzalloc(struct_size(tid_config, tid_conf, num_conf),
14106 tid_config->n_tid_conf = num_conf;
14108 if (info->attrs[NL80211_ATTR_MAC])
14109 tid_config->peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
14111 nla_for_each_nested(tid, info->attrs[NL80211_ATTR_TID_CONFIG],
14113 ret = nla_parse_nested(attrs, NL80211_TID_CONFIG_ATTR_MAX,
14119 ret = parse_tid_conf(rdev, attrs, dev,
14120 &tid_config->tid_conf[conf_idx],
14121 info, tid_config->peer);
14128 ret = rdev_set_tid_config(rdev, dev, tid_config);
14135 #define NL80211_FLAG_NEED_WIPHY 0x01
14136 #define NL80211_FLAG_NEED_NETDEV 0x02
14137 #define NL80211_FLAG_NEED_RTNL 0x04
14138 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
14139 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
14140 NL80211_FLAG_CHECK_NETDEV_UP)
14141 #define NL80211_FLAG_NEED_WDEV 0x10
14142 /* If a netdev is associated, it must be UP, P2P must be started */
14143 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
14144 NL80211_FLAG_CHECK_NETDEV_UP)
14145 #define NL80211_FLAG_CLEAR_SKB 0x20
14147 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
14148 struct genl_info *info)
14150 struct cfg80211_registered_device *rdev;
14151 struct wireless_dev *wdev;
14152 struct net_device *dev;
14153 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
14158 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
14159 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
14160 if (IS_ERR(rdev)) {
14163 return PTR_ERR(rdev);
14165 info->user_ptr[0] = rdev;
14166 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
14167 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
14170 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
14172 if (IS_ERR(wdev)) {
14175 return PTR_ERR(wdev);
14178 dev = wdev->netdev;
14179 rdev = wiphy_to_rdev(wdev->wiphy);
14181 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
14188 info->user_ptr[1] = dev;
14190 info->user_ptr[1] = wdev;
14193 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
14194 !wdev_running(wdev)) {
14203 info->user_ptr[0] = rdev;
14209 static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
14210 struct genl_info *info)
14212 if (info->user_ptr[1]) {
14213 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
14214 struct wireless_dev *wdev = info->user_ptr[1];
14217 dev_put(wdev->netdev);
14219 dev_put(info->user_ptr[1]);
14223 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
14226 /* If needed, clear the netlink message payload from the SKB
14227 * as it might contain key data that shouldn't stick around on
14228 * the heap after the SKB is freed. The netlink message header
14229 * is still needed for further processing, so leave it intact.
14231 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
14232 struct nlmsghdr *nlh = nlmsg_hdr(skb);
14234 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
14238 static const struct genl_ops nl80211_ops[] = {
14240 .cmd = NL80211_CMD_GET_WIPHY,
14241 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14242 .doit = nl80211_get_wiphy,
14243 .dumpit = nl80211_dump_wiphy,
14244 .done = nl80211_dump_wiphy_done,
14245 /* can be retrieved by unprivileged users */
14246 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14247 NL80211_FLAG_NEED_RTNL,
14250 .cmd = NL80211_CMD_SET_WIPHY,
14251 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14252 .doit = nl80211_set_wiphy,
14253 .flags = GENL_UNS_ADMIN_PERM,
14254 .internal_flags = NL80211_FLAG_NEED_RTNL,
14257 .cmd = NL80211_CMD_GET_INTERFACE,
14258 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14259 .doit = nl80211_get_interface,
14260 .dumpit = nl80211_dump_interface,
14261 /* can be retrieved by unprivileged users */
14262 .internal_flags = NL80211_FLAG_NEED_WDEV |
14263 NL80211_FLAG_NEED_RTNL,
14266 .cmd = NL80211_CMD_SET_INTERFACE,
14267 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14268 .doit = nl80211_set_interface,
14269 .flags = GENL_UNS_ADMIN_PERM,
14270 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14271 NL80211_FLAG_NEED_RTNL,
14274 .cmd = NL80211_CMD_NEW_INTERFACE,
14275 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14276 .doit = nl80211_new_interface,
14277 .flags = GENL_UNS_ADMIN_PERM,
14278 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14279 NL80211_FLAG_NEED_RTNL,
14282 .cmd = NL80211_CMD_DEL_INTERFACE,
14283 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14284 .doit = nl80211_del_interface,
14285 .flags = GENL_UNS_ADMIN_PERM,
14286 .internal_flags = NL80211_FLAG_NEED_WDEV |
14287 NL80211_FLAG_NEED_RTNL,
14290 .cmd = NL80211_CMD_GET_KEY,
14291 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14292 .doit = nl80211_get_key,
14293 .flags = GENL_UNS_ADMIN_PERM,
14294 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14295 NL80211_FLAG_NEED_RTNL,
14298 .cmd = NL80211_CMD_SET_KEY,
14299 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14300 .doit = nl80211_set_key,
14301 .flags = GENL_UNS_ADMIN_PERM,
14302 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14303 NL80211_FLAG_NEED_RTNL |
14304 NL80211_FLAG_CLEAR_SKB,
14307 .cmd = NL80211_CMD_NEW_KEY,
14308 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14309 .doit = nl80211_new_key,
14310 .flags = GENL_UNS_ADMIN_PERM,
14311 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14312 NL80211_FLAG_NEED_RTNL |
14313 NL80211_FLAG_CLEAR_SKB,
14316 .cmd = NL80211_CMD_DEL_KEY,
14317 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14318 .doit = nl80211_del_key,
14319 .flags = GENL_UNS_ADMIN_PERM,
14320 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14321 NL80211_FLAG_NEED_RTNL,
14324 .cmd = NL80211_CMD_SET_BEACON,
14325 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14326 .flags = GENL_UNS_ADMIN_PERM,
14327 .doit = nl80211_set_beacon,
14328 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14329 NL80211_FLAG_NEED_RTNL,
14332 .cmd = NL80211_CMD_START_AP,
14333 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14334 .flags = GENL_UNS_ADMIN_PERM,
14335 .doit = nl80211_start_ap,
14336 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14337 NL80211_FLAG_NEED_RTNL,
14340 .cmd = NL80211_CMD_STOP_AP,
14341 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14342 .flags = GENL_UNS_ADMIN_PERM,
14343 .doit = nl80211_stop_ap,
14344 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14345 NL80211_FLAG_NEED_RTNL,
14348 .cmd = NL80211_CMD_GET_STATION,
14349 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14350 .doit = nl80211_get_station,
14351 .dumpit = nl80211_dump_station,
14352 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14353 NL80211_FLAG_NEED_RTNL,
14356 .cmd = NL80211_CMD_SET_STATION,
14357 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14358 .doit = nl80211_set_station,
14359 .flags = GENL_UNS_ADMIN_PERM,
14360 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14361 NL80211_FLAG_NEED_RTNL,
14364 .cmd = NL80211_CMD_NEW_STATION,
14365 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14366 .doit = nl80211_new_station,
14367 .flags = GENL_UNS_ADMIN_PERM,
14368 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14369 NL80211_FLAG_NEED_RTNL,
14372 .cmd = NL80211_CMD_DEL_STATION,
14373 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14374 .doit = nl80211_del_station,
14375 .flags = GENL_UNS_ADMIN_PERM,
14376 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14377 NL80211_FLAG_NEED_RTNL,
14380 .cmd = NL80211_CMD_GET_MPATH,
14381 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14382 .doit = nl80211_get_mpath,
14383 .dumpit = nl80211_dump_mpath,
14384 .flags = GENL_UNS_ADMIN_PERM,
14385 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14386 NL80211_FLAG_NEED_RTNL,
14389 .cmd = NL80211_CMD_GET_MPP,
14390 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14391 .doit = nl80211_get_mpp,
14392 .dumpit = nl80211_dump_mpp,
14393 .flags = GENL_UNS_ADMIN_PERM,
14394 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14395 NL80211_FLAG_NEED_RTNL,
14398 .cmd = NL80211_CMD_SET_MPATH,
14399 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14400 .doit = nl80211_set_mpath,
14401 .flags = GENL_UNS_ADMIN_PERM,
14402 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14403 NL80211_FLAG_NEED_RTNL,
14406 .cmd = NL80211_CMD_NEW_MPATH,
14407 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14408 .doit = nl80211_new_mpath,
14409 .flags = GENL_UNS_ADMIN_PERM,
14410 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14411 NL80211_FLAG_NEED_RTNL,
14414 .cmd = NL80211_CMD_DEL_MPATH,
14415 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14416 .doit = nl80211_del_mpath,
14417 .flags = GENL_UNS_ADMIN_PERM,
14418 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14419 NL80211_FLAG_NEED_RTNL,
14422 .cmd = NL80211_CMD_SET_BSS,
14423 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14424 .doit = nl80211_set_bss,
14425 .flags = GENL_UNS_ADMIN_PERM,
14426 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14427 NL80211_FLAG_NEED_RTNL,
14430 .cmd = NL80211_CMD_GET_REG,
14431 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14432 .doit = nl80211_get_reg_do,
14433 .dumpit = nl80211_get_reg_dump,
14434 .internal_flags = NL80211_FLAG_NEED_RTNL,
14435 /* can be retrieved by unprivileged users */
14437 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
14439 .cmd = NL80211_CMD_SET_REG,
14440 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14441 .doit = nl80211_set_reg,
14442 .flags = GENL_ADMIN_PERM,
14443 .internal_flags = NL80211_FLAG_NEED_RTNL,
14447 .cmd = NL80211_CMD_REQ_SET_REG,
14448 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14449 .doit = nl80211_req_set_reg,
14450 .flags = GENL_ADMIN_PERM,
14453 .cmd = NL80211_CMD_RELOAD_REGDB,
14454 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14455 .doit = nl80211_reload_regdb,
14456 .flags = GENL_ADMIN_PERM,
14459 .cmd = NL80211_CMD_GET_MESH_CONFIG,
14460 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14461 .doit = nl80211_get_mesh_config,
14462 /* can be retrieved by unprivileged users */
14463 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14464 NL80211_FLAG_NEED_RTNL,
14467 .cmd = NL80211_CMD_SET_MESH_CONFIG,
14468 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14469 .doit = nl80211_update_mesh_config,
14470 .flags = GENL_UNS_ADMIN_PERM,
14471 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14472 NL80211_FLAG_NEED_RTNL,
14475 .cmd = NL80211_CMD_TRIGGER_SCAN,
14476 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14477 .doit = nl80211_trigger_scan,
14478 .flags = GENL_UNS_ADMIN_PERM,
14479 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14480 NL80211_FLAG_NEED_RTNL,
14483 .cmd = NL80211_CMD_ABORT_SCAN,
14484 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14485 .doit = nl80211_abort_scan,
14486 .flags = GENL_UNS_ADMIN_PERM,
14487 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14488 NL80211_FLAG_NEED_RTNL,
14491 .cmd = NL80211_CMD_GET_SCAN,
14492 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14493 .dumpit = nl80211_dump_scan,
14496 .cmd = NL80211_CMD_START_SCHED_SCAN,
14497 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14498 .doit = nl80211_start_sched_scan,
14499 .flags = GENL_UNS_ADMIN_PERM,
14500 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14501 NL80211_FLAG_NEED_RTNL,
14504 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
14505 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14506 .doit = nl80211_stop_sched_scan,
14507 .flags = GENL_UNS_ADMIN_PERM,
14508 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14509 NL80211_FLAG_NEED_RTNL,
14512 .cmd = NL80211_CMD_AUTHENTICATE,
14513 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14514 .doit = nl80211_authenticate,
14515 .flags = GENL_UNS_ADMIN_PERM,
14516 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14517 NL80211_FLAG_NEED_RTNL |
14518 NL80211_FLAG_CLEAR_SKB,
14521 .cmd = NL80211_CMD_ASSOCIATE,
14522 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14523 .doit = nl80211_associate,
14524 .flags = GENL_UNS_ADMIN_PERM,
14525 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14526 NL80211_FLAG_NEED_RTNL |
14527 NL80211_FLAG_CLEAR_SKB,
14530 .cmd = NL80211_CMD_DEAUTHENTICATE,
14531 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14532 .doit = nl80211_deauthenticate,
14533 .flags = GENL_UNS_ADMIN_PERM,
14534 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14535 NL80211_FLAG_NEED_RTNL,
14538 .cmd = NL80211_CMD_DISASSOCIATE,
14539 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14540 .doit = nl80211_disassociate,
14541 .flags = GENL_UNS_ADMIN_PERM,
14542 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14543 NL80211_FLAG_NEED_RTNL,
14546 .cmd = NL80211_CMD_JOIN_IBSS,
14547 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14548 .doit = nl80211_join_ibss,
14549 .flags = GENL_UNS_ADMIN_PERM,
14550 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14551 NL80211_FLAG_NEED_RTNL,
14554 .cmd = NL80211_CMD_LEAVE_IBSS,
14555 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14556 .doit = nl80211_leave_ibss,
14557 .flags = GENL_UNS_ADMIN_PERM,
14558 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14559 NL80211_FLAG_NEED_RTNL,
14561 #ifdef CONFIG_NL80211_TESTMODE
14563 .cmd = NL80211_CMD_TESTMODE,
14564 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14565 .doit = nl80211_testmode_do,
14566 .dumpit = nl80211_testmode_dump,
14567 .flags = GENL_UNS_ADMIN_PERM,
14568 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14569 NL80211_FLAG_NEED_RTNL,
14573 .cmd = NL80211_CMD_CONNECT,
14574 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14575 .doit = nl80211_connect,
14576 .flags = GENL_UNS_ADMIN_PERM,
14577 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14578 NL80211_FLAG_NEED_RTNL |
14579 NL80211_FLAG_CLEAR_SKB,
14582 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
14583 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14584 .doit = nl80211_update_connect_params,
14585 .flags = GENL_ADMIN_PERM,
14586 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14587 NL80211_FLAG_NEED_RTNL |
14588 NL80211_FLAG_CLEAR_SKB,
14591 .cmd = NL80211_CMD_DISCONNECT,
14592 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14593 .doit = nl80211_disconnect,
14594 .flags = GENL_UNS_ADMIN_PERM,
14595 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14596 NL80211_FLAG_NEED_RTNL,
14599 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
14600 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14601 .doit = nl80211_wiphy_netns,
14602 .flags = GENL_UNS_ADMIN_PERM,
14603 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14604 NL80211_FLAG_NEED_RTNL,
14607 .cmd = NL80211_CMD_GET_SURVEY,
14608 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14609 .dumpit = nl80211_dump_survey,
14612 .cmd = NL80211_CMD_SET_PMKSA,
14613 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14614 .doit = nl80211_setdel_pmksa,
14615 .flags = GENL_UNS_ADMIN_PERM,
14616 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14617 NL80211_FLAG_NEED_RTNL |
14618 NL80211_FLAG_CLEAR_SKB,
14621 .cmd = NL80211_CMD_DEL_PMKSA,
14622 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14623 .doit = nl80211_setdel_pmksa,
14624 .flags = GENL_UNS_ADMIN_PERM,
14625 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14626 NL80211_FLAG_NEED_RTNL,
14629 .cmd = NL80211_CMD_FLUSH_PMKSA,
14630 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14631 .doit = nl80211_flush_pmksa,
14632 .flags = GENL_UNS_ADMIN_PERM,
14633 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14634 NL80211_FLAG_NEED_RTNL,
14637 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
14638 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14639 .doit = nl80211_remain_on_channel,
14640 .flags = GENL_UNS_ADMIN_PERM,
14641 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14642 NL80211_FLAG_NEED_RTNL,
14645 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
14646 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14647 .doit = nl80211_cancel_remain_on_channel,
14648 .flags = GENL_UNS_ADMIN_PERM,
14649 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14650 NL80211_FLAG_NEED_RTNL,
14653 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
14654 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14655 .doit = nl80211_set_tx_bitrate_mask,
14656 .flags = GENL_UNS_ADMIN_PERM,
14657 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14658 NL80211_FLAG_NEED_RTNL,
14661 .cmd = NL80211_CMD_REGISTER_FRAME,
14662 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14663 .doit = nl80211_register_mgmt,
14664 .flags = GENL_UNS_ADMIN_PERM,
14665 .internal_flags = NL80211_FLAG_NEED_WDEV |
14666 NL80211_FLAG_NEED_RTNL,
14669 .cmd = NL80211_CMD_FRAME,
14670 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14671 .doit = nl80211_tx_mgmt,
14672 .flags = GENL_UNS_ADMIN_PERM,
14673 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14674 NL80211_FLAG_NEED_RTNL,
14677 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
14678 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14679 .doit = nl80211_tx_mgmt_cancel_wait,
14680 .flags = GENL_UNS_ADMIN_PERM,
14681 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14682 NL80211_FLAG_NEED_RTNL,
14685 .cmd = NL80211_CMD_SET_POWER_SAVE,
14686 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14687 .doit = nl80211_set_power_save,
14688 .flags = GENL_UNS_ADMIN_PERM,
14689 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14690 NL80211_FLAG_NEED_RTNL,
14693 .cmd = NL80211_CMD_GET_POWER_SAVE,
14694 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14695 .doit = nl80211_get_power_save,
14696 /* can be retrieved by unprivileged users */
14697 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14698 NL80211_FLAG_NEED_RTNL,
14701 .cmd = NL80211_CMD_SET_CQM,
14702 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14703 .doit = nl80211_set_cqm,
14704 .flags = GENL_UNS_ADMIN_PERM,
14705 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14706 NL80211_FLAG_NEED_RTNL,
14709 .cmd = NL80211_CMD_SET_CHANNEL,
14710 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14711 .doit = nl80211_set_channel,
14712 .flags = GENL_UNS_ADMIN_PERM,
14713 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14714 NL80211_FLAG_NEED_RTNL,
14717 .cmd = NL80211_CMD_SET_WDS_PEER,
14718 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14719 .doit = nl80211_set_wds_peer,
14720 .flags = GENL_UNS_ADMIN_PERM,
14721 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14722 NL80211_FLAG_NEED_RTNL,
14725 .cmd = NL80211_CMD_JOIN_MESH,
14726 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14727 .doit = nl80211_join_mesh,
14728 .flags = GENL_UNS_ADMIN_PERM,
14729 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14730 NL80211_FLAG_NEED_RTNL,
14733 .cmd = NL80211_CMD_LEAVE_MESH,
14734 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14735 .doit = nl80211_leave_mesh,
14736 .flags = GENL_UNS_ADMIN_PERM,
14737 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14738 NL80211_FLAG_NEED_RTNL,
14741 .cmd = NL80211_CMD_JOIN_OCB,
14742 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14743 .doit = nl80211_join_ocb,
14744 .flags = GENL_UNS_ADMIN_PERM,
14745 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14746 NL80211_FLAG_NEED_RTNL,
14749 .cmd = NL80211_CMD_LEAVE_OCB,
14750 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14751 .doit = nl80211_leave_ocb,
14752 .flags = GENL_UNS_ADMIN_PERM,
14753 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14754 NL80211_FLAG_NEED_RTNL,
14758 .cmd = NL80211_CMD_GET_WOWLAN,
14759 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14760 .doit = nl80211_get_wowlan,
14761 /* can be retrieved by unprivileged users */
14762 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14763 NL80211_FLAG_NEED_RTNL,
14766 .cmd = NL80211_CMD_SET_WOWLAN,
14767 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14768 .doit = nl80211_set_wowlan,
14769 .flags = GENL_UNS_ADMIN_PERM,
14770 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14771 NL80211_FLAG_NEED_RTNL,
14775 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
14776 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14777 .doit = nl80211_set_rekey_data,
14778 .flags = GENL_UNS_ADMIN_PERM,
14779 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14780 NL80211_FLAG_NEED_RTNL |
14781 NL80211_FLAG_CLEAR_SKB,
14784 .cmd = NL80211_CMD_TDLS_MGMT,
14785 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14786 .doit = nl80211_tdls_mgmt,
14787 .flags = GENL_UNS_ADMIN_PERM,
14788 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14789 NL80211_FLAG_NEED_RTNL,
14792 .cmd = NL80211_CMD_TDLS_OPER,
14793 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14794 .doit = nl80211_tdls_oper,
14795 .flags = GENL_UNS_ADMIN_PERM,
14796 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14797 NL80211_FLAG_NEED_RTNL,
14800 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
14801 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14802 .doit = nl80211_register_unexpected_frame,
14803 .flags = GENL_UNS_ADMIN_PERM,
14804 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14805 NL80211_FLAG_NEED_RTNL,
14808 .cmd = NL80211_CMD_PROBE_CLIENT,
14809 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14810 .doit = nl80211_probe_client,
14811 .flags = GENL_UNS_ADMIN_PERM,
14812 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14813 NL80211_FLAG_NEED_RTNL,
14816 .cmd = NL80211_CMD_REGISTER_BEACONS,
14817 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14818 .doit = nl80211_register_beacons,
14819 .flags = GENL_UNS_ADMIN_PERM,
14820 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14821 NL80211_FLAG_NEED_RTNL,
14824 .cmd = NL80211_CMD_SET_NOACK_MAP,
14825 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14826 .doit = nl80211_set_noack_map,
14827 .flags = GENL_UNS_ADMIN_PERM,
14828 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14829 NL80211_FLAG_NEED_RTNL,
14832 .cmd = NL80211_CMD_START_P2P_DEVICE,
14833 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14834 .doit = nl80211_start_p2p_device,
14835 .flags = GENL_UNS_ADMIN_PERM,
14836 .internal_flags = NL80211_FLAG_NEED_WDEV |
14837 NL80211_FLAG_NEED_RTNL,
14840 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
14841 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14842 .doit = nl80211_stop_p2p_device,
14843 .flags = GENL_UNS_ADMIN_PERM,
14844 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14845 NL80211_FLAG_NEED_RTNL,
14848 .cmd = NL80211_CMD_START_NAN,
14849 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14850 .doit = nl80211_start_nan,
14851 .flags = GENL_ADMIN_PERM,
14852 .internal_flags = NL80211_FLAG_NEED_WDEV |
14853 NL80211_FLAG_NEED_RTNL,
14856 .cmd = NL80211_CMD_STOP_NAN,
14857 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14858 .doit = nl80211_stop_nan,
14859 .flags = GENL_ADMIN_PERM,
14860 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14861 NL80211_FLAG_NEED_RTNL,
14864 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
14865 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14866 .doit = nl80211_nan_add_func,
14867 .flags = GENL_ADMIN_PERM,
14868 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14869 NL80211_FLAG_NEED_RTNL,
14872 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
14873 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14874 .doit = nl80211_nan_del_func,
14875 .flags = GENL_ADMIN_PERM,
14876 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14877 NL80211_FLAG_NEED_RTNL,
14880 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
14881 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14882 .doit = nl80211_nan_change_config,
14883 .flags = GENL_ADMIN_PERM,
14884 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14885 NL80211_FLAG_NEED_RTNL,
14888 .cmd = NL80211_CMD_SET_MCAST_RATE,
14889 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14890 .doit = nl80211_set_mcast_rate,
14891 .flags = GENL_UNS_ADMIN_PERM,
14892 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14893 NL80211_FLAG_NEED_RTNL,
14896 .cmd = NL80211_CMD_SET_MAC_ACL,
14897 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14898 .doit = nl80211_set_mac_acl,
14899 .flags = GENL_UNS_ADMIN_PERM,
14900 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14901 NL80211_FLAG_NEED_RTNL,
14904 .cmd = NL80211_CMD_RADAR_DETECT,
14905 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14906 .doit = nl80211_start_radar_detection,
14907 .flags = GENL_UNS_ADMIN_PERM,
14908 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14909 NL80211_FLAG_NEED_RTNL,
14912 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
14913 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14914 .doit = nl80211_get_protocol_features,
14917 .cmd = NL80211_CMD_UPDATE_FT_IES,
14918 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14919 .doit = nl80211_update_ft_ies,
14920 .flags = GENL_UNS_ADMIN_PERM,
14921 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14922 NL80211_FLAG_NEED_RTNL,
14925 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
14926 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14927 .doit = nl80211_crit_protocol_start,
14928 .flags = GENL_UNS_ADMIN_PERM,
14929 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14930 NL80211_FLAG_NEED_RTNL,
14933 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
14934 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14935 .doit = nl80211_crit_protocol_stop,
14936 .flags = GENL_UNS_ADMIN_PERM,
14937 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14938 NL80211_FLAG_NEED_RTNL,
14941 .cmd = NL80211_CMD_GET_COALESCE,
14942 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14943 .doit = nl80211_get_coalesce,
14944 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14945 NL80211_FLAG_NEED_RTNL,
14948 .cmd = NL80211_CMD_SET_COALESCE,
14949 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14950 .doit = nl80211_set_coalesce,
14951 .flags = GENL_UNS_ADMIN_PERM,
14952 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14953 NL80211_FLAG_NEED_RTNL,
14956 .cmd = NL80211_CMD_CHANNEL_SWITCH,
14957 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14958 .doit = nl80211_channel_switch,
14959 .flags = GENL_UNS_ADMIN_PERM,
14960 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14961 NL80211_FLAG_NEED_RTNL,
14964 .cmd = NL80211_CMD_VENDOR,
14965 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14966 .doit = nl80211_vendor_cmd,
14967 .dumpit = nl80211_vendor_cmd_dump,
14968 .flags = GENL_UNS_ADMIN_PERM,
14969 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14970 NL80211_FLAG_NEED_RTNL |
14971 NL80211_FLAG_CLEAR_SKB,
14974 .cmd = NL80211_CMD_SET_QOS_MAP,
14975 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14976 .doit = nl80211_set_qos_map,
14977 .flags = GENL_UNS_ADMIN_PERM,
14978 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14979 NL80211_FLAG_NEED_RTNL,
14982 .cmd = NL80211_CMD_ADD_TX_TS,
14983 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14984 .doit = nl80211_add_tx_ts,
14985 .flags = GENL_UNS_ADMIN_PERM,
14986 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14987 NL80211_FLAG_NEED_RTNL,
14990 .cmd = NL80211_CMD_DEL_TX_TS,
14991 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14992 .doit = nl80211_del_tx_ts,
14993 .flags = GENL_UNS_ADMIN_PERM,
14994 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14995 NL80211_FLAG_NEED_RTNL,
14998 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
14999 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15000 .doit = nl80211_tdls_channel_switch,
15001 .flags = GENL_UNS_ADMIN_PERM,
15002 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15003 NL80211_FLAG_NEED_RTNL,
15006 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
15007 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15008 .doit = nl80211_tdls_cancel_channel_switch,
15009 .flags = GENL_UNS_ADMIN_PERM,
15010 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15011 NL80211_FLAG_NEED_RTNL,
15014 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
15015 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15016 .doit = nl80211_set_multicast_to_unicast,
15017 .flags = GENL_UNS_ADMIN_PERM,
15018 .internal_flags = NL80211_FLAG_NEED_NETDEV |
15019 NL80211_FLAG_NEED_RTNL,
15022 .cmd = NL80211_CMD_SET_PMK,
15023 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15024 .doit = nl80211_set_pmk,
15025 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15026 NL80211_FLAG_NEED_RTNL |
15027 NL80211_FLAG_CLEAR_SKB,
15030 .cmd = NL80211_CMD_DEL_PMK,
15031 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15032 .doit = nl80211_del_pmk,
15033 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15034 NL80211_FLAG_NEED_RTNL,
15037 .cmd = NL80211_CMD_EXTERNAL_AUTH,
15038 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15039 .doit = nl80211_external_auth,
15040 .flags = GENL_ADMIN_PERM,
15041 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15042 NL80211_FLAG_NEED_RTNL,
15045 .cmd = NL80211_CMD_CONTROL_PORT_FRAME,
15046 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15047 .doit = nl80211_tx_control_port,
15048 .flags = GENL_UNS_ADMIN_PERM,
15049 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15050 NL80211_FLAG_NEED_RTNL,
15053 .cmd = NL80211_CMD_GET_FTM_RESPONDER_STATS,
15054 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15055 .doit = nl80211_get_ftm_responder_stats,
15056 .internal_flags = NL80211_FLAG_NEED_NETDEV |
15057 NL80211_FLAG_NEED_RTNL,
15060 .cmd = NL80211_CMD_PEER_MEASUREMENT_START,
15061 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15062 .doit = nl80211_pmsr_start,
15063 .flags = GENL_UNS_ADMIN_PERM,
15064 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
15065 NL80211_FLAG_NEED_RTNL,
15068 .cmd = NL80211_CMD_NOTIFY_RADAR,
15069 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
15070 .doit = nl80211_notify_radar_detection,
15071 .flags = GENL_UNS_ADMIN_PERM,
15072 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15073 NL80211_FLAG_NEED_RTNL,
15076 .cmd = NL80211_CMD_UPDATE_OWE_INFO,
15077 .doit = nl80211_update_owe_info,
15078 .flags = GENL_ADMIN_PERM,
15079 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15080 NL80211_FLAG_NEED_RTNL,
15083 .cmd = NL80211_CMD_PROBE_MESH_LINK,
15084 .doit = nl80211_probe_mesh_link,
15085 .flags = GENL_UNS_ADMIN_PERM,
15086 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
15087 NL80211_FLAG_NEED_RTNL,
15090 .cmd = NL80211_CMD_SET_TID_CONFIG,
15091 .doit = nl80211_set_tid_config,
15092 .flags = GENL_UNS_ADMIN_PERM,
15093 .internal_flags = NL80211_FLAG_NEED_NETDEV |
15094 NL80211_FLAG_NEED_RTNL,
15098 static struct genl_family nl80211_fam __ro_after_init = {
15099 .name = NL80211_GENL_NAME, /* have users key off the name instead */
15100 .hdrsize = 0, /* no private header */
15101 .version = 1, /* no particular meaning now */
15102 .maxattr = NL80211_ATTR_MAX,
15103 .policy = nl80211_policy,
15105 .pre_doit = nl80211_pre_doit,
15106 .post_doit = nl80211_post_doit,
15107 .module = THIS_MODULE,
15108 .ops = nl80211_ops,
15109 .n_ops = ARRAY_SIZE(nl80211_ops),
15110 .mcgrps = nl80211_mcgrps,
15111 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
15112 .parallel_ops = true,
15115 /* notification functions */
15117 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
15118 enum nl80211_commands cmd)
15120 struct sk_buff *msg;
15121 struct nl80211_dump_wiphy_state state = {};
15123 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
15124 cmd != NL80211_CMD_DEL_WIPHY);
15126 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15130 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
15135 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15136 NL80211_MCGRP_CONFIG, GFP_KERNEL);
15139 void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
15140 struct wireless_dev *wdev,
15141 enum nl80211_commands cmd)
15143 struct sk_buff *msg;
15145 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15149 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, cmd) < 0) {
15154 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15155 NL80211_MCGRP_CONFIG, GFP_KERNEL);
15158 static int nl80211_add_scan_req(struct sk_buff *msg,
15159 struct cfg80211_registered_device *rdev)
15161 struct cfg80211_scan_request *req = rdev->scan_req;
15162 struct nlattr *nest;
15168 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_SSIDS);
15170 goto nla_put_failure;
15171 for (i = 0; i < req->n_ssids; i++) {
15172 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
15173 goto nla_put_failure;
15175 nla_nest_end(msg, nest);
15177 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES);
15179 goto nla_put_failure;
15180 for (i = 0; i < req->n_channels; i++) {
15181 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
15182 goto nla_put_failure;
15184 nla_nest_end(msg, nest);
15187 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
15188 goto nla_put_failure;
15191 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
15192 goto nla_put_failure;
15194 if (req->info.scan_start_tsf &&
15195 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
15196 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
15197 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
15198 req->info.tsf_bssid)))
15199 goto nla_put_failure;
15206 static int nl80211_prep_scan_msg(struct sk_buff *msg,
15207 struct cfg80211_registered_device *rdev,
15208 struct wireless_dev *wdev,
15209 u32 portid, u32 seq, int flags,
15214 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
15218 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15219 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15220 wdev->netdev->ifindex)) ||
15221 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15223 goto nla_put_failure;
15225 /* ignore errors and send incomplete event anyway */
15226 nl80211_add_scan_req(msg, rdev);
15228 genlmsg_end(msg, hdr);
15232 genlmsg_cancel(msg, hdr);
15237 nl80211_prep_sched_scan_msg(struct sk_buff *msg,
15238 struct cfg80211_sched_scan_request *req, u32 cmd)
15242 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15246 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
15247 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
15248 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
15249 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
15251 goto nla_put_failure;
15253 genlmsg_end(msg, hdr);
15257 genlmsg_cancel(msg, hdr);
15261 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
15262 struct wireless_dev *wdev)
15264 struct sk_buff *msg;
15266 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15270 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
15271 NL80211_CMD_TRIGGER_SCAN) < 0) {
15276 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15277 NL80211_MCGRP_SCAN, GFP_KERNEL);
15280 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
15281 struct wireless_dev *wdev, bool aborted)
15283 struct sk_buff *msg;
15285 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15289 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
15290 aborted ? NL80211_CMD_SCAN_ABORTED :
15291 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
15299 /* send message created by nl80211_build_scan_msg() */
15300 void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
15301 struct sk_buff *msg)
15306 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15307 NL80211_MCGRP_SCAN, GFP_KERNEL);
15310 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
15312 struct sk_buff *msg;
15314 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15318 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
15323 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
15324 NL80211_MCGRP_SCAN, GFP_KERNEL);
15327 static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
15328 struct regulatory_request *request)
15330 /* Userspace can always count this one always being set */
15331 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
15332 goto nla_put_failure;
15334 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
15335 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
15336 NL80211_REGDOM_TYPE_WORLD))
15337 goto nla_put_failure;
15338 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
15339 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
15340 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
15341 goto nla_put_failure;
15342 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
15343 request->intersect) {
15344 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
15345 NL80211_REGDOM_TYPE_INTERSECTION))
15346 goto nla_put_failure;
15348 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
15349 NL80211_REGDOM_TYPE_COUNTRY) ||
15350 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
15352 goto nla_put_failure;
15355 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
15356 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
15359 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
15360 goto nla_put_failure;
15363 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
15364 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
15365 goto nla_put_failure;
15375 * This can happen on global regulatory changes or device specific settings
15376 * based on custom regulatory domains.
15378 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
15379 struct regulatory_request *request)
15381 struct sk_buff *msg;
15384 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15388 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
15390 goto nla_put_failure;
15392 if (!nl80211_reg_change_event_fill(msg, request))
15393 goto nla_put_failure;
15395 genlmsg_end(msg, hdr);
15398 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
15399 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
15408 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
15409 struct net_device *netdev,
15410 const u8 *buf, size_t len,
15411 enum nl80211_commands cmd, gfp_t gfp,
15412 int uapsd_queues, const u8 *req_ies,
15413 size_t req_ies_len)
15415 struct sk_buff *msg;
15418 msg = nlmsg_new(100 + len + req_ies_len, gfp);
15422 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15428 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15429 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15430 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
15432 nla_put(msg, NL80211_ATTR_REQ_IE, req_ies_len, req_ies)))
15433 goto nla_put_failure;
15435 if (uapsd_queues >= 0) {
15436 struct nlattr *nla_wmm =
15437 nla_nest_start_noflag(msg, NL80211_ATTR_STA_WME);
15439 goto nla_put_failure;
15441 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
15443 goto nla_put_failure;
15445 nla_nest_end(msg, nla_wmm);
15448 genlmsg_end(msg, hdr);
15450 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15451 NL80211_MCGRP_MLME, gfp);
15458 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
15459 struct net_device *netdev, const u8 *buf,
15460 size_t len, gfp_t gfp)
15462 nl80211_send_mlme_event(rdev, netdev, buf, len,
15463 NL80211_CMD_AUTHENTICATE, gfp, -1, NULL, 0);
15466 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
15467 struct net_device *netdev, const u8 *buf,
15468 size_t len, gfp_t gfp, int uapsd_queues,
15469 const u8 *req_ies, size_t req_ies_len)
15471 nl80211_send_mlme_event(rdev, netdev, buf, len,
15472 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues,
15473 req_ies, req_ies_len);
15476 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
15477 struct net_device *netdev, const u8 *buf,
15478 size_t len, gfp_t gfp)
15480 nl80211_send_mlme_event(rdev, netdev, buf, len,
15481 NL80211_CMD_DEAUTHENTICATE, gfp, -1, NULL, 0);
15484 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
15485 struct net_device *netdev, const u8 *buf,
15486 size_t len, gfp_t gfp)
15488 nl80211_send_mlme_event(rdev, netdev, buf, len,
15489 NL80211_CMD_DISASSOCIATE, gfp, -1, NULL, 0);
15492 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
15495 struct wireless_dev *wdev = dev->ieee80211_ptr;
15496 struct wiphy *wiphy = wdev->wiphy;
15497 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15498 const struct ieee80211_mgmt *mgmt = (void *)buf;
15501 if (WARN_ON(len < 2))
15504 if (ieee80211_is_deauth(mgmt->frame_control))
15505 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
15507 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
15509 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
15510 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1,
15513 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
15515 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
15516 struct net_device *netdev, int cmd,
15517 const u8 *addr, gfp_t gfp)
15519 struct sk_buff *msg;
15522 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15526 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15532 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15533 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15534 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
15535 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
15536 goto nla_put_failure;
15538 genlmsg_end(msg, hdr);
15540 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15541 NL80211_MCGRP_MLME, gfp);
15548 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
15549 struct net_device *netdev, const u8 *addr,
15552 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
15556 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
15557 struct net_device *netdev, const u8 *addr,
15560 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
15564 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
15565 struct net_device *netdev,
15566 struct cfg80211_connect_resp_params *cr,
15569 struct sk_buff *msg;
15572 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
15573 cr->fils.kek_len + cr->fils.pmk_len +
15574 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
15578 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
15584 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15585 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15587 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
15588 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
15589 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
15592 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
15593 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
15594 cr->timeout_reason))) ||
15596 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
15598 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
15600 (cr->fils.update_erp_next_seq_num &&
15601 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
15602 cr->fils.erp_next_seq_num)) ||
15603 (cr->status == WLAN_STATUS_SUCCESS &&
15605 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len,
15608 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) ||
15610 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid)))))
15611 goto nla_put_failure;
15613 genlmsg_end(msg, hdr);
15615 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15616 NL80211_MCGRP_MLME, gfp);
15623 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
15624 struct net_device *netdev,
15625 struct cfg80211_roam_info *info, gfp_t gfp)
15627 struct sk_buff *msg;
15629 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
15631 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len +
15632 info->fils.kek_len + info->fils.pmk_len +
15633 (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
15637 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
15643 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15644 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15645 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
15647 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
15650 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
15652 (info->fils.update_erp_next_seq_num &&
15653 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
15654 info->fils.erp_next_seq_num)) ||
15656 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len,
15657 info->fils.kek)) ||
15659 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) ||
15660 (info->fils.pmkid &&
15661 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid)))
15662 goto nla_put_failure;
15664 genlmsg_end(msg, hdr);
15666 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15667 NL80211_MCGRP_MLME, gfp);
15674 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
15675 struct net_device *netdev, const u8 *bssid)
15677 struct sk_buff *msg;
15680 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15684 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED);
15690 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15691 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15692 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
15693 goto nla_put_failure;
15695 genlmsg_end(msg, hdr);
15697 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15698 NL80211_MCGRP_MLME, GFP_KERNEL);
15705 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
15706 struct net_device *netdev, u16 reason,
15707 const u8 *ie, size_t ie_len, bool from_ap)
15709 struct sk_buff *msg;
15712 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
15716 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
15722 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15723 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15725 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
15727 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
15728 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
15729 goto nla_put_failure;
15731 genlmsg_end(msg, hdr);
15733 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15734 NL80211_MCGRP_MLME, GFP_KERNEL);
15741 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
15742 struct net_device *netdev, const u8 *bssid,
15745 struct sk_buff *msg;
15748 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15752 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
15758 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15759 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15760 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
15761 goto nla_put_failure;
15763 genlmsg_end(msg, hdr);
15765 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15766 NL80211_MCGRP_MLME, gfp);
15773 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
15774 const u8 *ie, u8 ie_len,
15775 int sig_dbm, gfp_t gfp)
15777 struct wireless_dev *wdev = dev->ieee80211_ptr;
15778 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15779 struct sk_buff *msg;
15782 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
15785 trace_cfg80211_notify_new_peer_candidate(dev, addr);
15787 msg = nlmsg_new(100 + ie_len, gfp);
15791 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
15797 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15798 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15799 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
15801 nla_put(msg, NL80211_ATTR_IE, ie_len, ie)) ||
15803 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)))
15804 goto nla_put_failure;
15806 genlmsg_end(msg, hdr);
15808 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15809 NL80211_MCGRP_MLME, gfp);
15815 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
15817 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
15818 struct net_device *netdev, const u8 *addr,
15819 enum nl80211_key_type key_type, int key_id,
15820 const u8 *tsc, gfp_t gfp)
15822 struct sk_buff *msg;
15825 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15829 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
15835 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15836 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15837 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
15838 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
15840 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
15841 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
15842 goto nla_put_failure;
15844 genlmsg_end(msg, hdr);
15846 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15847 NL80211_MCGRP_MLME, gfp);
15854 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
15855 struct ieee80211_channel *channel_before,
15856 struct ieee80211_channel *channel_after)
15858 struct sk_buff *msg;
15860 struct nlattr *nl_freq;
15862 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
15866 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
15873 * Since we are applying the beacon hint to a wiphy we know its
15874 * wiphy_idx is valid
15876 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
15877 goto nla_put_failure;
15880 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_BEFORE);
15882 goto nla_put_failure;
15884 if (nl80211_msg_put_channel(msg, wiphy, channel_before, false))
15885 goto nla_put_failure;
15886 nla_nest_end(msg, nl_freq);
15889 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_AFTER);
15891 goto nla_put_failure;
15893 if (nl80211_msg_put_channel(msg, wiphy, channel_after, false))
15894 goto nla_put_failure;
15895 nla_nest_end(msg, nl_freq);
15897 genlmsg_end(msg, hdr);
15900 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
15901 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
15910 static void nl80211_send_remain_on_chan_event(
15911 int cmd, struct cfg80211_registered_device *rdev,
15912 struct wireless_dev *wdev, u64 cookie,
15913 struct ieee80211_channel *chan,
15914 unsigned int duration, gfp_t gfp)
15916 struct sk_buff *msg;
15919 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15923 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15929 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15930 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15931 wdev->netdev->ifindex)) ||
15932 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15933 NL80211_ATTR_PAD) ||
15934 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
15935 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
15936 NL80211_CHAN_NO_HT) ||
15937 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
15939 goto nla_put_failure;
15941 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
15942 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
15943 goto nla_put_failure;
15945 genlmsg_end(msg, hdr);
15947 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15948 NL80211_MCGRP_MLME, gfp);
15955 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
15956 struct ieee80211_channel *chan,
15957 unsigned int duration, gfp_t gfp)
15959 struct wiphy *wiphy = wdev->wiphy;
15960 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15962 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
15963 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
15964 rdev, wdev, cookie, chan,
15967 EXPORT_SYMBOL(cfg80211_ready_on_channel);
15969 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
15970 struct ieee80211_channel *chan,
15973 struct wiphy *wiphy = wdev->wiphy;
15974 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15976 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
15977 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
15978 rdev, wdev, cookie, chan, 0, gfp);
15980 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
15982 void cfg80211_tx_mgmt_expired(struct wireless_dev *wdev, u64 cookie,
15983 struct ieee80211_channel *chan,
15986 struct wiphy *wiphy = wdev->wiphy;
15987 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15989 trace_cfg80211_tx_mgmt_expired(wdev, cookie, chan);
15990 nl80211_send_remain_on_chan_event(NL80211_CMD_FRAME_WAIT_CANCEL,
15991 rdev, wdev, cookie, chan, 0, gfp);
15993 EXPORT_SYMBOL(cfg80211_tx_mgmt_expired);
15995 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
15996 struct station_info *sinfo, gfp_t gfp)
15998 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15999 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16000 struct sk_buff *msg;
16002 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
16004 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16008 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
16009 rdev, dev, mac_addr, sinfo) < 0) {
16014 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16015 NL80211_MCGRP_MLME, gfp);
16017 EXPORT_SYMBOL(cfg80211_new_sta);
16019 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
16020 struct station_info *sinfo, gfp_t gfp)
16022 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
16023 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16024 struct sk_buff *msg;
16025 struct station_info empty_sinfo = {};
16028 sinfo = &empty_sinfo;
16030 trace_cfg80211_del_sta(dev, mac_addr);
16032 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16034 cfg80211_sinfo_release_content(sinfo);
16038 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
16039 rdev, dev, mac_addr, sinfo) < 0) {
16044 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16045 NL80211_MCGRP_MLME, gfp);
16047 EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
16049 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
16050 enum nl80211_connect_failed_reason reason,
16053 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
16054 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16055 struct sk_buff *msg;
16058 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
16062 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
16068 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16069 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
16070 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
16071 goto nla_put_failure;
16073 genlmsg_end(msg, hdr);
16075 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16076 NL80211_MCGRP_MLME, gfp);
16082 EXPORT_SYMBOL(cfg80211_conn_failed);
16084 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
16085 const u8 *addr, gfp_t gfp)
16087 struct wireless_dev *wdev = dev->ieee80211_ptr;
16088 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16089 struct sk_buff *msg;
16091 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
16096 msg = nlmsg_new(100, gfp);
16100 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
16106 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16107 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16108 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
16109 goto nla_put_failure;
16111 genlmsg_end(msg, hdr);
16112 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16120 bool cfg80211_rx_spurious_frame(struct net_device *dev,
16121 const u8 *addr, gfp_t gfp)
16123 struct wireless_dev *wdev = dev->ieee80211_ptr;
16126 trace_cfg80211_rx_spurious_frame(dev, addr);
16128 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
16129 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
16130 trace_cfg80211_return_bool(false);
16133 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
16135 trace_cfg80211_return_bool(ret);
16138 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
16140 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
16141 const u8 *addr, gfp_t gfp)
16143 struct wireless_dev *wdev = dev->ieee80211_ptr;
16146 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
16148 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
16149 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
16150 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
16151 trace_cfg80211_return_bool(false);
16154 ret = __nl80211_unexpected_frame(dev,
16155 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
16157 trace_cfg80211_return_bool(ret);
16160 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
16162 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
16163 struct wireless_dev *wdev, u32 nlportid,
16164 int freq, int sig_dbm,
16165 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
16167 struct net_device *netdev = wdev->netdev;
16168 struct sk_buff *msg;
16171 msg = nlmsg_new(100 + len, gfp);
16175 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
16181 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16182 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16183 netdev->ifindex)) ||
16184 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16185 NL80211_ATTR_PAD) ||
16186 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
16188 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
16189 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
16191 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
16192 goto nla_put_failure;
16194 genlmsg_end(msg, hdr);
16196 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16203 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
16204 const u8 *buf, size_t len, bool ack, gfp_t gfp)
16206 struct wiphy *wiphy = wdev->wiphy;
16207 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16208 struct net_device *netdev = wdev->netdev;
16209 struct sk_buff *msg;
16212 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
16214 msg = nlmsg_new(100 + len, gfp);
16218 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
16224 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16225 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16226 netdev->ifindex)) ||
16227 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16228 NL80211_ATTR_PAD) ||
16229 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
16230 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
16231 NL80211_ATTR_PAD) ||
16232 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
16233 goto nla_put_failure;
16235 genlmsg_end(msg, hdr);
16237 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16238 NL80211_MCGRP_MLME, gfp);
16244 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
16246 static int __nl80211_rx_control_port(struct net_device *dev,
16247 struct sk_buff *skb,
16248 bool unencrypted, gfp_t gfp)
16250 struct wireless_dev *wdev = dev->ieee80211_ptr;
16251 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16252 struct ethhdr *ehdr = eth_hdr(skb);
16253 const u8 *addr = ehdr->h_source;
16254 u16 proto = be16_to_cpu(skb->protocol);
16255 struct sk_buff *msg;
16257 struct nlattr *frame;
16259 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid);
16264 msg = nlmsg_new(100 + skb->len, gfp);
16268 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME);
16274 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16275 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16276 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16277 NL80211_ATTR_PAD) ||
16278 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
16279 nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) ||
16280 (unencrypted && nla_put_flag(msg,
16281 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
16282 goto nla_put_failure;
16284 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len);
16286 goto nla_put_failure;
16288 skb_copy_bits(skb, 0, nla_data(frame), skb->len);
16289 genlmsg_end(msg, hdr);
16291 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16298 bool cfg80211_rx_control_port(struct net_device *dev,
16299 struct sk_buff *skb, bool unencrypted)
16303 trace_cfg80211_rx_control_port(dev, skb, unencrypted);
16304 ret = __nl80211_rx_control_port(dev, skb, unencrypted, GFP_ATOMIC);
16305 trace_cfg80211_return_bool(ret == 0);
16308 EXPORT_SYMBOL(cfg80211_rx_control_port);
16310 static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
16311 const char *mac, gfp_t gfp)
16313 struct wireless_dev *wdev = dev->ieee80211_ptr;
16314 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16315 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16321 cb = (void **)msg->cb;
16323 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
16329 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16330 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
16331 goto nla_put_failure;
16333 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
16334 goto nla_put_failure;
16336 cb[1] = nla_nest_start_noflag(msg, NL80211_ATTR_CQM);
16338 goto nla_put_failure;
16348 static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
16350 void **cb = (void **)msg->cb;
16351 struct cfg80211_registered_device *rdev = cb[2];
16353 nla_nest_end(msg, cb[1]);
16354 genlmsg_end(msg, cb[0]);
16356 memset(msg->cb, 0, sizeof(msg->cb));
16358 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16359 NL80211_MCGRP_MLME, gfp);
16362 void cfg80211_cqm_rssi_notify(struct net_device *dev,
16363 enum nl80211_cqm_rssi_threshold_event rssi_event,
16364 s32 rssi_level, gfp_t gfp)
16366 struct sk_buff *msg;
16367 struct wireless_dev *wdev = dev->ieee80211_ptr;
16368 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16370 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
16372 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
16373 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
16376 if (wdev->cqm_config) {
16377 wdev->cqm_config->last_rssi_event_value = rssi_level;
16379 cfg80211_cqm_rssi_update(rdev, dev);
16381 if (rssi_level == 0)
16382 rssi_level = wdev->cqm_config->last_rssi_event_value;
16385 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
16389 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
16391 goto nla_put_failure;
16393 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
16395 goto nla_put_failure;
16397 cfg80211_send_cqm(msg, gfp);
16404 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
16406 void cfg80211_cqm_txe_notify(struct net_device *dev,
16407 const u8 *peer, u32 num_packets,
16408 u32 rate, u32 intvl, gfp_t gfp)
16410 struct sk_buff *msg;
16412 msg = cfg80211_prepare_cqm(dev, peer, gfp);
16416 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
16417 goto nla_put_failure;
16419 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
16420 goto nla_put_failure;
16422 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
16423 goto nla_put_failure;
16425 cfg80211_send_cqm(msg, gfp);
16431 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
16433 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
16434 const u8 *peer, u32 num_packets, gfp_t gfp)
16436 struct sk_buff *msg;
16438 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
16440 msg = cfg80211_prepare_cqm(dev, peer, gfp);
16444 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
16445 goto nla_put_failure;
16447 cfg80211_send_cqm(msg, gfp);
16453 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
16455 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
16457 struct sk_buff *msg;
16459 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
16463 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
16464 goto nla_put_failure;
16466 cfg80211_send_cqm(msg, gfp);
16472 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
16474 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
16475 struct net_device *netdev, const u8 *bssid,
16476 const u8 *replay_ctr, gfp_t gfp)
16478 struct sk_buff *msg;
16479 struct nlattr *rekey_attr;
16482 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16486 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
16492 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16493 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16494 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
16495 goto nla_put_failure;
16497 rekey_attr = nla_nest_start_noflag(msg, NL80211_ATTR_REKEY_DATA);
16499 goto nla_put_failure;
16501 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
16502 NL80211_REPLAY_CTR_LEN, replay_ctr))
16503 goto nla_put_failure;
16505 nla_nest_end(msg, rekey_attr);
16507 genlmsg_end(msg, hdr);
16509 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16510 NL80211_MCGRP_MLME, gfp);
16517 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
16518 const u8 *replay_ctr, gfp_t gfp)
16520 struct wireless_dev *wdev = dev->ieee80211_ptr;
16521 struct wiphy *wiphy = wdev->wiphy;
16522 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16524 trace_cfg80211_gtk_rekey_notify(dev, bssid);
16525 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
16527 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
16530 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
16531 struct net_device *netdev, int index,
16532 const u8 *bssid, bool preauth, gfp_t gfp)
16534 struct sk_buff *msg;
16535 struct nlattr *attr;
16538 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16542 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
16548 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16549 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
16550 goto nla_put_failure;
16552 attr = nla_nest_start_noflag(msg, NL80211_ATTR_PMKSA_CANDIDATE);
16554 goto nla_put_failure;
16556 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
16557 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
16559 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
16560 goto nla_put_failure;
16562 nla_nest_end(msg, attr);
16564 genlmsg_end(msg, hdr);
16566 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16567 NL80211_MCGRP_MLME, gfp);
16574 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
16575 const u8 *bssid, bool preauth, gfp_t gfp)
16577 struct wireless_dev *wdev = dev->ieee80211_ptr;
16578 struct wiphy *wiphy = wdev->wiphy;
16579 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16581 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
16582 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
16584 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
16586 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
16587 struct net_device *netdev,
16588 struct cfg80211_chan_def *chandef,
16590 enum nl80211_commands notif,
16593 struct sk_buff *msg;
16596 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16600 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
16606 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
16607 goto nla_put_failure;
16609 if (nl80211_send_chandef(msg, chandef))
16610 goto nla_put_failure;
16612 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
16613 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
16614 goto nla_put_failure;
16616 genlmsg_end(msg, hdr);
16618 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16619 NL80211_MCGRP_MLME, gfp);
16626 void cfg80211_ch_switch_notify(struct net_device *dev,
16627 struct cfg80211_chan_def *chandef)
16629 struct wireless_dev *wdev = dev->ieee80211_ptr;
16630 struct wiphy *wiphy = wdev->wiphy;
16631 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16633 ASSERT_WDEV_LOCK(wdev);
16635 trace_cfg80211_ch_switch_notify(dev, chandef);
16637 wdev->chandef = *chandef;
16638 wdev->preset_chandef = *chandef;
16640 if (wdev->iftype == NL80211_IFTYPE_STATION &&
16641 !WARN_ON(!wdev->current_bss))
16642 cfg80211_update_assoc_bss_entry(wdev, chandef->chan);
16644 cfg80211_sched_dfs_chan_update(rdev);
16646 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
16647 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
16649 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
16651 void cfg80211_ch_switch_started_notify(struct net_device *dev,
16652 struct cfg80211_chan_def *chandef,
16655 struct wireless_dev *wdev = dev->ieee80211_ptr;
16656 struct wiphy *wiphy = wdev->wiphy;
16657 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16659 trace_cfg80211_ch_switch_started_notify(dev, chandef);
16661 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
16662 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
16664 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
16667 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
16668 const struct cfg80211_chan_def *chandef,
16669 enum nl80211_radar_event event,
16670 struct net_device *netdev, gfp_t gfp)
16672 struct sk_buff *msg;
16675 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16679 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
16685 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
16686 goto nla_put_failure;
16688 /* NOP and radar events don't need a netdev parameter */
16690 struct wireless_dev *wdev = netdev->ieee80211_ptr;
16692 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16693 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16695 goto nla_put_failure;
16698 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
16699 goto nla_put_failure;
16701 if (nl80211_send_chandef(msg, chandef))
16702 goto nla_put_failure;
16704 genlmsg_end(msg, hdr);
16706 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16707 NL80211_MCGRP_MLME, gfp);
16714 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac,
16715 struct sta_opmode_info *sta_opmode,
16718 struct sk_buff *msg;
16719 struct wireless_dev *wdev = dev->ieee80211_ptr;
16720 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16726 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16730 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED);
16736 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
16737 goto nla_put_failure;
16739 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
16740 goto nla_put_failure;
16742 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
16743 goto nla_put_failure;
16745 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) &&
16746 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode))
16747 goto nla_put_failure;
16749 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) &&
16750 nla_put_u8(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw))
16751 goto nla_put_failure;
16753 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) &&
16754 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss))
16755 goto nla_put_failure;
16757 genlmsg_end(msg, hdr);
16759 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16760 NL80211_MCGRP_MLME, gfp);
16767 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify);
16769 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
16770 u64 cookie, bool acked, s32 ack_signal,
16771 bool is_valid_ack_signal, gfp_t gfp)
16773 struct wireless_dev *wdev = dev->ieee80211_ptr;
16774 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16775 struct sk_buff *msg;
16778 trace_cfg80211_probe_status(dev, addr, cookie, acked);
16780 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16785 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
16791 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16792 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16793 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
16794 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
16795 NL80211_ATTR_PAD) ||
16796 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
16797 (is_valid_ack_signal && nla_put_s32(msg, NL80211_ATTR_ACK_SIGNAL,
16799 goto nla_put_failure;
16801 genlmsg_end(msg, hdr);
16803 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16804 NL80211_MCGRP_MLME, gfp);
16810 EXPORT_SYMBOL(cfg80211_probe_status);
16812 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
16813 const u8 *frame, size_t len,
16814 int freq, int sig_dbm)
16816 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16817 struct sk_buff *msg;
16819 struct cfg80211_beacon_registration *reg;
16821 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
16823 spin_lock_bh(&rdev->beacon_registrations_lock);
16824 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
16825 msg = nlmsg_new(len + 100, GFP_ATOMIC);
16827 spin_unlock_bh(&rdev->beacon_registrations_lock);
16831 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
16833 goto nla_put_failure;
16835 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16837 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
16839 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
16840 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
16841 goto nla_put_failure;
16843 genlmsg_end(msg, hdr);
16845 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
16847 spin_unlock_bh(&rdev->beacon_registrations_lock);
16851 spin_unlock_bh(&rdev->beacon_registrations_lock);
16854 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
16857 static int cfg80211_net_detect_results(struct sk_buff *msg,
16858 struct cfg80211_wowlan_wakeup *wakeup)
16860 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
16861 struct nlattr *nl_results, *nl_match, *nl_freqs;
16864 nl_results = nla_nest_start_noflag(msg,
16865 NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
16869 for (i = 0; i < nd->n_matches; i++) {
16870 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
16872 nl_match = nla_nest_start_noflag(msg, i);
16876 /* The SSID attribute is optional in nl80211, but for
16877 * simplicity reasons it's always present in the
16878 * cfg80211 structure. If a driver can't pass the
16879 * SSID, that needs to be changed. A zero length SSID
16880 * is still a valid SSID (wildcard), so it cannot be
16881 * used for this purpose.
16883 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
16884 match->ssid.ssid)) {
16885 nla_nest_cancel(msg, nl_match);
16889 if (match->n_channels) {
16890 nl_freqs = nla_nest_start_noflag(msg,
16891 NL80211_ATTR_SCAN_FREQUENCIES);
16893 nla_nest_cancel(msg, nl_match);
16897 for (j = 0; j < match->n_channels; j++) {
16898 if (nla_put_u32(msg, j, match->channels[j])) {
16899 nla_nest_cancel(msg, nl_freqs);
16900 nla_nest_cancel(msg, nl_match);
16905 nla_nest_end(msg, nl_freqs);
16908 nla_nest_end(msg, nl_match);
16912 nla_nest_end(msg, nl_results);
16916 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
16917 struct cfg80211_wowlan_wakeup *wakeup,
16920 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16921 struct sk_buff *msg;
16925 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
16928 size += wakeup->packet_present_len;
16930 msg = nlmsg_new(size, gfp);
16934 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
16938 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16939 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16943 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16944 wdev->netdev->ifindex))
16948 struct nlattr *reasons;
16950 reasons = nla_nest_start_noflag(msg,
16951 NL80211_ATTR_WOWLAN_TRIGGERS);
16955 if (wakeup->disconnect &&
16956 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
16958 if (wakeup->magic_pkt &&
16959 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
16961 if (wakeup->gtk_rekey_failure &&
16962 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
16964 if (wakeup->eap_identity_req &&
16965 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
16967 if (wakeup->four_way_handshake &&
16968 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
16970 if (wakeup->rfkill_release &&
16971 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
16974 if (wakeup->pattern_idx >= 0 &&
16975 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
16976 wakeup->pattern_idx))
16979 if (wakeup->tcp_match &&
16980 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
16983 if (wakeup->tcp_connlost &&
16984 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
16987 if (wakeup->tcp_nomoretokens &&
16989 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
16992 if (wakeup->packet) {
16993 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
16994 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
16996 if (!wakeup->packet_80211) {
16998 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
17000 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
17003 if (wakeup->packet_len &&
17004 nla_put_u32(msg, len_attr, wakeup->packet_len))
17007 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
17012 if (wakeup->net_detect &&
17013 cfg80211_net_detect_results(msg, wakeup))
17016 nla_nest_end(msg, reasons);
17019 genlmsg_end(msg, hdr);
17021 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17022 NL80211_MCGRP_MLME, gfp);
17028 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
17031 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
17032 enum nl80211_tdls_operation oper,
17033 u16 reason_code, gfp_t gfp)
17035 struct wireless_dev *wdev = dev->ieee80211_ptr;
17036 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17037 struct sk_buff *msg;
17040 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
17043 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17047 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
17053 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17054 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
17055 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
17056 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
17057 (reason_code > 0 &&
17058 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
17059 goto nla_put_failure;
17061 genlmsg_end(msg, hdr);
17063 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17064 NL80211_MCGRP_MLME, gfp);
17070 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
17072 static int nl80211_netlink_notify(struct notifier_block * nb,
17073 unsigned long state,
17076 struct netlink_notify *notify = _notify;
17077 struct cfg80211_registered_device *rdev;
17078 struct wireless_dev *wdev;
17079 struct cfg80211_beacon_registration *reg, *tmp;
17081 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
17082 return NOTIFY_DONE;
17086 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
17087 struct cfg80211_sched_scan_request *sched_scan_req;
17089 list_for_each_entry_rcu(sched_scan_req,
17090 &rdev->sched_scan_req_list,
17092 if (sched_scan_req->owner_nlportid == notify->portid) {
17093 sched_scan_req->nl_owner_dead = true;
17094 schedule_work(&rdev->sched_scan_stop_wk);
17098 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
17099 cfg80211_mlme_unregister_socket(wdev, notify->portid);
17101 if (wdev->owner_nlportid == notify->portid) {
17102 wdev->nl_owner_dead = true;
17103 schedule_work(&rdev->destroy_work);
17104 } else if (wdev->conn_owner_nlportid == notify->portid) {
17105 schedule_work(&wdev->disconnect_wk);
17108 cfg80211_release_pmsr(wdev, notify->portid);
17111 spin_lock_bh(&rdev->beacon_registrations_lock);
17112 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
17114 if (reg->nlportid == notify->portid) {
17115 list_del(®->list);
17120 spin_unlock_bh(&rdev->beacon_registrations_lock);
17126 * It is possible that the user space process that is controlling the
17127 * indoor setting disappeared, so notify the regulatory core.
17129 regulatory_netlink_notify(notify->portid);
17133 static struct notifier_block nl80211_netlink_notifier = {
17134 .notifier_call = nl80211_netlink_notify,
17137 void cfg80211_ft_event(struct net_device *netdev,
17138 struct cfg80211_ft_event_params *ft_event)
17140 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
17141 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17142 struct sk_buff *msg;
17145 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
17147 if (!ft_event->target_ap)
17150 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len,
17155 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
17159 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17160 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17161 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
17164 if (ft_event->ies &&
17165 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
17167 if (ft_event->ric_ies &&
17168 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
17169 ft_event->ric_ies))
17172 genlmsg_end(msg, hdr);
17174 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17175 NL80211_MCGRP_MLME, GFP_KERNEL);
17180 EXPORT_SYMBOL(cfg80211_ft_event);
17182 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
17184 struct cfg80211_registered_device *rdev;
17185 struct sk_buff *msg;
17189 rdev = wiphy_to_rdev(wdev->wiphy);
17190 if (!rdev->crit_proto_nlportid)
17193 nlportid = rdev->crit_proto_nlportid;
17194 rdev->crit_proto_nlportid = 0;
17196 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17200 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
17202 goto nla_put_failure;
17204 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17205 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17207 goto nla_put_failure;
17209 genlmsg_end(msg, hdr);
17211 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
17217 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
17219 void nl80211_send_ap_stopped(struct wireless_dev *wdev)
17221 struct wiphy *wiphy = wdev->wiphy;
17222 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17223 struct sk_buff *msg;
17226 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
17230 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
17234 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17235 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
17236 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
17240 genlmsg_end(msg, hdr);
17242 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
17243 NL80211_MCGRP_MLME, GFP_KERNEL);
17249 int cfg80211_external_auth_request(struct net_device *dev,
17250 struct cfg80211_external_auth_params *params,
17253 struct wireless_dev *wdev = dev->ieee80211_ptr;
17254 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
17255 struct sk_buff *msg;
17258 if (!wdev->conn_owner_nlportid)
17261 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17265 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH);
17267 goto nla_put_failure;
17269 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17270 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
17271 nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, params->key_mgmt_suite) ||
17272 nla_put_u32(msg, NL80211_ATTR_EXTERNAL_AUTH_ACTION,
17274 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) ||
17275 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len,
17276 params->ssid.ssid))
17277 goto nla_put_failure;
17279 genlmsg_end(msg, hdr);
17280 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
17281 wdev->conn_owner_nlportid);
17288 EXPORT_SYMBOL(cfg80211_external_auth_request);
17290 void cfg80211_update_owe_info_event(struct net_device *netdev,
17291 struct cfg80211_update_owe_info *owe_info,
17294 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
17295 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
17296 struct sk_buff *msg;
17299 trace_cfg80211_update_owe_info_event(wiphy, netdev, owe_info);
17301 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
17305 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_UPDATE_OWE_INFO);
17307 goto nla_put_failure;
17309 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
17310 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
17311 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, owe_info->peer))
17312 goto nla_put_failure;
17314 if (!owe_info->ie_len ||
17315 nla_put(msg, NL80211_ATTR_IE, owe_info->ie_len, owe_info->ie))
17316 goto nla_put_failure;
17318 genlmsg_end(msg, hdr);
17320 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
17321 NL80211_MCGRP_MLME, gfp);
17325 genlmsg_cancel(msg, hdr);
17328 EXPORT_SYMBOL(cfg80211_update_owe_info_event);
17330 /* initialisation/exit functions */
17332 int __init nl80211_init(void)
17336 err = genl_register_family(&nl80211_fam);
17340 err = netlink_register_notifier(&nl80211_netlink_notifier);
17346 genl_unregister_family(&nl80211_fam);
17350 void nl80211_exit(void)
17352 netlink_unregister_notifier(&nl80211_netlink_notifier);
17353 genl_unregister_family(&nl80211_fam);