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_ie_attr(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;
211 for_each_element(elem, data, len) {
215 if (for_each_element_completed(elem, data, len))
218 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed information elements");
222 /* policy for the attributes */
223 static const struct nla_policy
224 nl80211_ftm_responder_policy[NL80211_FTM_RESP_ATTR_MAX + 1] = {
225 [NL80211_FTM_RESP_ATTR_ENABLED] = { .type = NLA_FLAG, },
226 [NL80211_FTM_RESP_ATTR_LCI] = { .type = NLA_BINARY,
228 [NL80211_FTM_RESP_ATTR_CIVICLOC] = { .type = NLA_BINARY,
232 static const struct nla_policy
233 nl80211_pmsr_ftm_req_attr_policy[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1] = {
234 [NL80211_PMSR_FTM_REQ_ATTR_ASAP] = { .type = NLA_FLAG },
235 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE] = { .type = NLA_U32 },
236 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP] =
237 NLA_POLICY_MAX(NLA_U8, 15),
238 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD] = { .type = NLA_U16 },
239 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION] =
240 NLA_POLICY_MAX(NLA_U8, 15),
241 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST] =
242 NLA_POLICY_MAX(NLA_U8, 31),
243 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES] = { .type = NLA_U8 },
244 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI] = { .type = NLA_FLAG },
245 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC] = { .type = NLA_FLAG },
248 static const struct nla_policy
249 nl80211_pmsr_req_data_policy[NL80211_PMSR_TYPE_MAX + 1] = {
250 [NL80211_PMSR_TYPE_FTM] =
251 NLA_POLICY_NESTED(nl80211_pmsr_ftm_req_attr_policy),
254 static const struct nla_policy
255 nl80211_pmsr_req_attr_policy[NL80211_PMSR_REQ_ATTR_MAX + 1] = {
256 [NL80211_PMSR_REQ_ATTR_DATA] =
257 NLA_POLICY_NESTED(nl80211_pmsr_req_data_policy),
258 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF] = { .type = NLA_FLAG },
261 static const struct nla_policy
262 nl80211_psmr_peer_attr_policy[NL80211_PMSR_PEER_ATTR_MAX + 1] = {
263 [NL80211_PMSR_PEER_ATTR_ADDR] = NLA_POLICY_ETH_ADDR,
265 * we could specify this again to be the top-level policy,
266 * but that would open us up to recursion problems ...
268 [NL80211_PMSR_PEER_ATTR_CHAN] = { .type = NLA_NESTED },
269 [NL80211_PMSR_PEER_ATTR_REQ] =
270 NLA_POLICY_NESTED(nl80211_pmsr_req_attr_policy),
271 [NL80211_PMSR_PEER_ATTR_RESP] = { .type = NLA_REJECT },
274 static const struct nla_policy
275 nl80211_pmsr_attr_policy[NL80211_PMSR_ATTR_MAX + 1] = {
276 [NL80211_PMSR_ATTR_MAX_PEERS] = { .type = NLA_REJECT },
277 [NL80211_PMSR_ATTR_REPORT_AP_TSF] = { .type = NLA_REJECT },
278 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR] = { .type = NLA_REJECT },
279 [NL80211_PMSR_ATTR_TYPE_CAPA] = { .type = NLA_REJECT },
280 [NL80211_PMSR_ATTR_PEERS] =
281 NLA_POLICY_NESTED_ARRAY(nl80211_psmr_peer_attr_policy),
284 static const struct nla_policy
285 he_obss_pd_policy[NL80211_HE_OBSS_PD_ATTR_MAX + 1] = {
286 [NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] =
287 NLA_POLICY_RANGE(NLA_U8, 1, 20),
288 [NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET] =
289 NLA_POLICY_RANGE(NLA_U8, 1, 20),
292 const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
293 [0] = { .strict_start_type = NL80211_ATTR_HE_OBSS_PD },
294 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
295 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
297 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
299 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
300 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
301 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
302 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
303 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
305 [NL80211_ATTR_WIPHY_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
306 [NL80211_ATTR_WIPHY_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
307 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
308 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
309 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
310 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
312 [NL80211_ATTR_IFTYPE] = NLA_POLICY_MAX(NLA_U32, NL80211_IFTYPE_MAX),
313 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
314 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
316 [NL80211_ATTR_MAC] = { .type = NLA_EXACT_LEN_WARN, .len = ETH_ALEN },
317 [NL80211_ATTR_PREV_BSSID] = {
318 .type = NLA_EXACT_LEN_WARN,
322 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
323 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
324 .len = WLAN_MAX_KEY_LEN },
325 [NL80211_ATTR_KEY_IDX] = NLA_POLICY_MAX(NLA_U8, 5),
326 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
327 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
328 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
329 [NL80211_ATTR_KEY_TYPE] =
330 NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES),
332 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
333 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
334 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
335 .len = IEEE80211_MAX_DATA_LEN },
336 [NL80211_ATTR_BEACON_TAIL] =
337 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
338 IEEE80211_MAX_DATA_LEN),
339 [NL80211_ATTR_STA_AID] =
340 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
341 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
342 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
343 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
344 .len = NL80211_MAX_SUPP_RATES },
345 [NL80211_ATTR_STA_PLINK_ACTION] =
346 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1),
347 [NL80211_ATTR_STA_TX_POWER_SETTING] =
348 NLA_POLICY_RANGE(NLA_U8,
349 NL80211_TX_POWER_AUTOMATIC,
350 NL80211_TX_POWER_FIXED),
351 [NL80211_ATTR_STA_TX_POWER] = { .type = NLA_S16 },
352 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
353 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
354 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
355 .len = IEEE80211_MAX_MESH_ID_LEN },
356 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
358 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
359 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
361 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
362 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
363 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
364 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
365 .len = NL80211_MAX_SUPP_RATES },
366 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
368 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
369 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
371 [NL80211_ATTR_HT_CAPABILITY] = {
372 .type = NLA_EXACT_LEN_WARN,
373 .len = NL80211_HT_CAPABILITY_LEN
376 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
377 [NL80211_ATTR_IE] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
379 IEEE80211_MAX_DATA_LEN),
380 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
381 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
383 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
384 .len = IEEE80211_MAX_SSID_LEN },
385 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
386 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
387 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
388 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
389 [NL80211_ATTR_USE_MFP] = NLA_POLICY_RANGE(NLA_U32,
391 NL80211_MFP_OPTIONAL),
392 [NL80211_ATTR_STA_FLAGS2] = {
393 .len = sizeof(struct nl80211_sta_flag_update),
395 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
396 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
397 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
398 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211] = { .type = NLA_FLAG },
399 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
400 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
401 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
402 [NL80211_ATTR_PID] = { .type = NLA_U32 },
403 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
404 [NL80211_ATTR_PMKID] = {
405 .type = NLA_EXACT_LEN_WARN,
406 .len = WLAN_PMKID_LEN
408 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
409 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
410 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
411 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
412 .len = IEEE80211_MAX_DATA_LEN },
413 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
414 [NL80211_ATTR_PS_STATE] = NLA_POLICY_RANGE(NLA_U32,
417 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
418 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
419 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
420 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
421 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
422 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
423 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
424 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
425 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
426 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
427 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
428 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
429 [NL80211_ATTR_STA_PLINK_STATE] =
430 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
431 [NL80211_ATTR_MESH_PEER_AID] =
432 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
433 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
434 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
435 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
436 [NL80211_ATTR_HIDDEN_SSID] =
437 NLA_POLICY_RANGE(NLA_U32,
438 NL80211_HIDDEN_SSID_NOT_IN_USE,
439 NL80211_HIDDEN_SSID_ZERO_CONTENTS),
440 [NL80211_ATTR_IE_PROBE_RESP] =
441 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
442 IEEE80211_MAX_DATA_LEN),
443 [NL80211_ATTR_IE_ASSOC_RESP] =
444 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
445 IEEE80211_MAX_DATA_LEN),
446 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
447 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
448 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
449 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
450 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
451 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
452 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
453 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
454 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
455 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
456 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
457 .len = IEEE80211_MAX_DATA_LEN },
458 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
459 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
460 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
461 .len = NL80211_HT_CAPABILITY_LEN
463 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
464 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
465 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
466 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
467 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
468 [NL80211_ATTR_AUTH_DATA] = { .type = NLA_BINARY, },
469 [NL80211_ATTR_VHT_CAPABILITY] = {
470 .type = NLA_EXACT_LEN_WARN,
471 .len = NL80211_VHT_CAPABILITY_LEN
473 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
474 [NL80211_ATTR_P2P_CTWINDOW] = NLA_POLICY_MAX(NLA_U8, 127),
475 [NL80211_ATTR_P2P_OPPPS] = NLA_POLICY_MAX(NLA_U8, 1),
476 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] =
477 NLA_POLICY_RANGE(NLA_U32,
478 NL80211_MESH_POWER_UNKNOWN + 1,
479 NL80211_MESH_POWER_MAX),
480 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
481 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
482 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
483 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
484 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
485 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
486 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
487 .len = NL80211_VHT_CAPABILITY_LEN,
489 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
490 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
491 .len = IEEE80211_MAX_DATA_LEN },
492 [NL80211_ATTR_PEER_AID] =
493 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
494 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
495 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
496 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
497 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
498 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
499 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
500 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
501 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
502 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
503 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
504 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
505 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
506 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
507 .len = IEEE80211_QOS_MAP_LEN_MAX },
508 [NL80211_ATTR_MAC_HINT] = {
509 .type = NLA_EXACT_LEN_WARN,
512 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
513 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
514 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
515 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
516 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
517 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1),
518 [NL80211_ATTR_USER_PRIO] =
519 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
520 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
521 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
522 [NL80211_ATTR_MAC_MASK] = {
523 .type = NLA_EXACT_LEN_WARN,
526 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
527 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
528 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
529 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
530 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
531 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
532 [NL80211_ATTR_STA_SUPPORT_P2P_PS] =
533 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1),
534 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
535 .len = VHT_MUMIMO_GROUPS_DATA_LEN
537 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = {
538 .type = NLA_EXACT_LEN_WARN,
541 [NL80211_ATTR_NAN_MASTER_PREF] = NLA_POLICY_MIN(NLA_U8, 1),
542 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
543 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
544 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
545 .len = FILS_MAX_KEK_LEN },
546 [NL80211_ATTR_FILS_NONCES] = {
547 .type = NLA_EXACT_LEN_WARN,
548 .len = 2 * FILS_NONCE_LEN
550 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
551 [NL80211_ATTR_BSSID] = { .type = NLA_EXACT_LEN_WARN, .len = ETH_ALEN },
552 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
553 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
554 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
556 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
557 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
558 .len = FILS_ERP_MAX_USERNAME_LEN },
559 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
560 .len = FILS_ERP_MAX_REALM_LEN },
561 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
562 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
563 .len = FILS_ERP_MAX_RRK_LEN },
564 [NL80211_ATTR_FILS_CACHE_ID] = { .type = NLA_EXACT_LEN_WARN, .len = 2 },
565 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
566 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
567 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT] = { .type = NLA_FLAG },
569 [NL80211_ATTR_TXQ_LIMIT] = { .type = NLA_U32 },
570 [NL80211_ATTR_TXQ_MEMORY_LIMIT] = { .type = NLA_U32 },
571 [NL80211_ATTR_TXQ_QUANTUM] = { .type = NLA_U32 },
572 [NL80211_ATTR_HE_CAPABILITY] = { .type = NLA_BINARY,
573 .len = NL80211_HE_MAX_CAPABILITY_LEN },
575 [NL80211_ATTR_FTM_RESPONDER] = {
577 .validation_data = nl80211_ftm_responder_policy,
579 [NL80211_ATTR_TIMEOUT] = NLA_POLICY_MIN(NLA_U32, 1),
580 [NL80211_ATTR_PEER_MEASUREMENTS] =
581 NLA_POLICY_NESTED(nl80211_pmsr_attr_policy),
582 [NL80211_ATTR_AIRTIME_WEIGHT] = NLA_POLICY_MIN(NLA_U16, 1),
583 [NL80211_ATTR_SAE_PASSWORD] = { .type = NLA_BINARY,
584 .len = SAE_PASSWORD_MAX_LEN },
585 [NL80211_ATTR_TWT_RESPONDER] = { .type = NLA_FLAG },
586 [NL80211_ATTR_HE_OBSS_PD] = NLA_POLICY_NESTED(he_obss_pd_policy),
589 /* policy for the key attributes */
590 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
591 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
592 [NL80211_KEY_IDX] = { .type = NLA_U8 },
593 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
594 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
595 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
596 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
597 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1),
598 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
599 [NL80211_KEY_MODE] = NLA_POLICY_RANGE(NLA_U8, 0, NL80211_KEY_SET_TX),
602 /* policy for the key default flags */
603 static const struct nla_policy
604 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
605 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
606 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
610 /* policy for WoWLAN attributes */
611 static const struct nla_policy
612 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
613 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
614 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
615 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
616 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
617 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
618 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
619 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
620 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
621 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
622 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
625 static const struct nla_policy
626 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
627 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
628 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
629 [NL80211_WOWLAN_TCP_DST_MAC] = {
630 .type = NLA_EXACT_LEN_WARN,
633 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
634 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
635 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .type = NLA_MIN_LEN, .len = 1 },
636 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
637 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
639 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
640 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
642 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
643 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .type = NLA_MIN_LEN, .len = 1 },
644 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .type = NLA_MIN_LEN, .len = 1 },
646 #endif /* CONFIG_PM */
648 /* policy for coalesce rule attributes */
649 static const struct nla_policy
650 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
651 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
652 [NL80211_ATTR_COALESCE_RULE_CONDITION] =
653 NLA_POLICY_RANGE(NLA_U32,
654 NL80211_COALESCE_CONDITION_MATCH,
655 NL80211_COALESCE_CONDITION_NO_MATCH),
656 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
659 /* policy for GTK rekey offload attributes */
660 static const struct nla_policy
661 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
662 [NL80211_REKEY_DATA_KEK] = {
663 .type = NLA_EXACT_LEN_WARN,
664 .len = NL80211_KEK_LEN,
666 [NL80211_REKEY_DATA_KCK] = {
667 .type = NLA_EXACT_LEN_WARN,
668 .len = NL80211_KCK_LEN,
670 [NL80211_REKEY_DATA_REPLAY_CTR] = {
671 .type = NLA_EXACT_LEN_WARN,
672 .len = NL80211_REPLAY_CTR_LEN
676 static const struct nla_policy
677 nl80211_match_band_rssi_policy[NUM_NL80211_BANDS] = {
678 [NL80211_BAND_2GHZ] = { .type = NLA_S32 },
679 [NL80211_BAND_5GHZ] = { .type = NLA_S32 },
680 [NL80211_BAND_60GHZ] = { .type = NLA_S32 },
683 static const struct nla_policy
684 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
685 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
686 .len = IEEE80211_MAX_SSID_LEN },
687 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = {
688 .type = NLA_EXACT_LEN_WARN,
691 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
692 [NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI] =
693 NLA_POLICY_NESTED(nl80211_match_band_rssi_policy),
696 static const struct nla_policy
697 nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
698 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
699 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
702 static const struct nla_policy
703 nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
704 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
705 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
706 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
707 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
711 /* policy for NAN function attributes */
712 static const struct nla_policy
713 nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
714 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
715 [NL80211_NAN_FUNC_SERVICE_ID] = {
716 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
717 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
718 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
719 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
720 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
721 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
722 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = {
723 .type = NLA_EXACT_LEN_WARN,
726 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
727 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
728 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
729 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
730 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
731 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
732 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
733 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
734 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
737 /* policy for Service Response Filter attributes */
738 static const struct nla_policy
739 nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
740 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
741 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
742 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
743 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
744 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
747 /* policy for packet pattern attributes */
748 static const struct nla_policy
749 nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
750 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
751 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
752 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
755 int nl80211_prepare_wdev_dump(struct netlink_callback *cb,
756 struct cfg80211_registered_device **rdev,
757 struct wireless_dev **wdev)
762 struct nlattr **attrbuf;
764 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
769 err = nlmsg_parse_deprecated(cb->nlh,
770 GENL_HDRLEN + nl80211_fam.hdrsize,
771 attrbuf, nl80211_fam.maxattr,
772 nl80211_policy, NULL);
778 *wdev = __cfg80211_wdev_from_attrs(sock_net(cb->skb->sk),
782 return PTR_ERR(*wdev);
783 *rdev = wiphy_to_rdev((*wdev)->wiphy);
784 /* 0 is the first index - add 1 to parse only once */
785 cb->args[0] = (*rdev)->wiphy_idx + 1;
786 cb->args[1] = (*wdev)->identifier;
788 /* subtract the 1 again here */
789 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
790 struct wireless_dev *tmp;
794 *rdev = wiphy_to_rdev(wiphy);
797 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
798 if (tmp->identifier == cb->args[1]) {
811 /* message building helper */
812 void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
815 /* since there is no private header just add the generic one */
816 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
819 static int nl80211_msg_put_wmm_rules(struct sk_buff *msg,
820 const struct ieee80211_reg_rule *rule)
823 struct nlattr *nl_wmm_rules =
824 nla_nest_start_noflag(msg, NL80211_FREQUENCY_ATTR_WMM);
827 goto nla_put_failure;
829 for (j = 0; j < IEEE80211_NUM_ACS; j++) {
830 struct nlattr *nl_wmm_rule = nla_nest_start_noflag(msg, j);
833 goto nla_put_failure;
835 if (nla_put_u16(msg, NL80211_WMMR_CW_MIN,
836 rule->wmm_rule.client[j].cw_min) ||
837 nla_put_u16(msg, NL80211_WMMR_CW_MAX,
838 rule->wmm_rule.client[j].cw_max) ||
839 nla_put_u8(msg, NL80211_WMMR_AIFSN,
840 rule->wmm_rule.client[j].aifsn) ||
841 nla_put_u16(msg, NL80211_WMMR_TXOP,
842 rule->wmm_rule.client[j].cot))
843 goto nla_put_failure;
845 nla_nest_end(msg, nl_wmm_rule);
847 nla_nest_end(msg, nl_wmm_rules);
855 static int nl80211_msg_put_channel(struct sk_buff *msg, struct wiphy *wiphy,
856 struct ieee80211_channel *chan,
859 /* Some channels must be completely excluded from the
860 * list to protect old user-space tools from breaking
862 if (!large && chan->flags &
863 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
866 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
868 goto nla_put_failure;
870 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
871 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
872 goto nla_put_failure;
873 if (chan->flags & IEEE80211_CHAN_NO_IR) {
874 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
875 goto nla_put_failure;
876 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
877 goto nla_put_failure;
879 if (chan->flags & IEEE80211_CHAN_RADAR) {
880 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
881 goto nla_put_failure;
885 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
887 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
889 goto nla_put_failure;
890 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
892 goto nla_put_failure;
894 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
896 goto nla_put_failure;
901 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
902 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
903 goto nla_put_failure;
904 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
905 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
906 goto nla_put_failure;
907 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
908 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
909 goto nla_put_failure;
910 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
911 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
912 goto nla_put_failure;
913 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
914 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
915 goto nla_put_failure;
916 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
917 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
918 goto nla_put_failure;
919 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
920 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
921 goto nla_put_failure;
922 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
923 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
924 goto nla_put_failure;
927 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
928 DBM_TO_MBM(chan->max_power)))
929 goto nla_put_failure;
932 const struct ieee80211_reg_rule *rule =
933 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
935 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) {
936 if (nl80211_msg_put_wmm_rules(msg, rule))
937 goto nla_put_failure;
947 static bool nl80211_put_txq_stats(struct sk_buff *msg,
948 struct cfg80211_txq_stats *txqstats,
951 struct nlattr *txqattr;
953 #define PUT_TXQVAL_U32(attr, memb) do { \
954 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
955 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
959 txqattr = nla_nest_start_noflag(msg, attrtype);
963 PUT_TXQVAL_U32(BACKLOG_BYTES, backlog_bytes);
964 PUT_TXQVAL_U32(BACKLOG_PACKETS, backlog_packets);
965 PUT_TXQVAL_U32(FLOWS, flows);
966 PUT_TXQVAL_U32(DROPS, drops);
967 PUT_TXQVAL_U32(ECN_MARKS, ecn_marks);
968 PUT_TXQVAL_U32(OVERLIMIT, overlimit);
969 PUT_TXQVAL_U32(OVERMEMORY, overmemory);
970 PUT_TXQVAL_U32(COLLISIONS, collisions);
971 PUT_TXQVAL_U32(TX_BYTES, tx_bytes);
972 PUT_TXQVAL_U32(TX_PACKETS, tx_packets);
973 PUT_TXQVAL_U32(MAX_FLOWS, max_flows);
974 nla_nest_end(msg, txqattr);
976 #undef PUT_TXQVAL_U32
980 /* netlink command implementations */
987 bool def_uni, def_multi;
990 static int nl80211_parse_key_new(struct genl_info *info, struct nlattr *key,
993 struct nlattr *tb[NL80211_KEY_MAX + 1];
994 int err = nla_parse_nested_deprecated(tb, NL80211_KEY_MAX, key,
1000 k->def = !!tb[NL80211_KEY_DEFAULT];
1001 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
1005 k->def_multi = true;
1008 k->def_multi = true;
1010 if (tb[NL80211_KEY_IDX])
1011 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
1013 if (tb[NL80211_KEY_DATA]) {
1014 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
1015 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
1018 if (tb[NL80211_KEY_SEQ]) {
1019 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
1020 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
1023 if (tb[NL80211_KEY_CIPHER])
1024 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
1026 if (tb[NL80211_KEY_TYPE])
1027 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
1029 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
1030 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1032 err = nla_parse_nested_deprecated(kdt,
1033 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1034 tb[NL80211_KEY_DEFAULT_TYPES],
1035 nl80211_key_default_policy,
1040 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1041 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1044 if (tb[NL80211_KEY_MODE])
1045 k->p.mode = nla_get_u8(tb[NL80211_KEY_MODE]);
1050 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
1052 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
1053 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
1054 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
1057 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
1058 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
1059 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
1062 if (info->attrs[NL80211_ATTR_KEY_IDX])
1063 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1065 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
1066 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
1068 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
1069 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
1073 k->def_multi = true;
1076 k->def_multi = true;
1078 if (info->attrs[NL80211_ATTR_KEY_TYPE])
1079 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1081 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
1082 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1083 int err = nla_parse_nested_deprecated(kdt,
1084 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1085 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
1086 nl80211_key_default_policy,
1091 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1092 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1098 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
1102 memset(k, 0, sizeof(*k));
1106 if (info->attrs[NL80211_ATTR_KEY])
1107 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k);
1109 err = nl80211_parse_key_old(info, k);
1114 if (k->def && k->defmgmt) {
1115 GENL_SET_ERR_MSG(info, "key with def && defmgmt is invalid");
1120 if (k->def_uni || !k->def_multi) {
1121 GENL_SET_ERR_MSG(info, "defmgmt key must be mcast");
1128 if (k->idx < 4 || k->idx > 5) {
1129 GENL_SET_ERR_MSG(info,
1130 "defmgmt key idx not 4 or 5");
1133 } else if (k->def) {
1134 if (k->idx < 0 || k->idx > 3) {
1135 GENL_SET_ERR_MSG(info, "def key idx not 0-3");
1139 if (k->idx < 0 || k->idx > 5) {
1140 GENL_SET_ERR_MSG(info, "key idx not 0-5");
1149 static struct cfg80211_cached_keys *
1150 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
1151 struct genl_info *info, bool *no_ht)
1153 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS];
1154 struct key_parse parse;
1156 struct cfg80211_cached_keys *result;
1157 int rem, err, def = 0;
1158 bool have_key = false;
1160 nla_for_each_nested(key, keys, rem) {
1168 result = kzalloc(sizeof(*result), GFP_KERNEL);
1170 return ERR_PTR(-ENOMEM);
1174 nla_for_each_nested(key, keys, rem) {
1175 memset(&parse, 0, sizeof(parse));
1178 err = nl80211_parse_key_new(info, key, &parse);
1184 if (parse.idx < 0 || parse.idx > 3) {
1185 GENL_SET_ERR_MSG(info, "key index out of range [0-3]");
1190 GENL_SET_ERR_MSG(info,
1191 "only one key can be default");
1195 result->def = parse.idx;
1196 if (!parse.def_uni || !parse.def_multi)
1198 } else if (parse.defmgmt)
1200 err = cfg80211_validate_key_settings(rdev, &parse.p,
1201 parse.idx, false, NULL);
1204 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1205 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
1206 GENL_SET_ERR_MSG(info, "connect key must be WEP");
1210 result->params[parse.idx].cipher = parse.p.cipher;
1211 result->params[parse.idx].key_len = parse.p.key_len;
1212 result->params[parse.idx].key = result->data[parse.idx];
1213 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
1215 /* must be WEP key if we got here */
1220 if (result->def < 0) {
1222 GENL_SET_ERR_MSG(info, "need a default/TX key");
1229 return ERR_PTR(err);
1232 static int nl80211_key_allowed(struct wireless_dev *wdev)
1234 ASSERT_WDEV_LOCK(wdev);
1236 switch (wdev->iftype) {
1237 case NL80211_IFTYPE_AP:
1238 case NL80211_IFTYPE_AP_VLAN:
1239 case NL80211_IFTYPE_P2P_GO:
1240 case NL80211_IFTYPE_MESH_POINT:
1242 case NL80211_IFTYPE_ADHOC:
1243 case NL80211_IFTYPE_STATION:
1244 case NL80211_IFTYPE_P2P_CLIENT:
1245 if (!wdev->current_bss)
1248 case NL80211_IFTYPE_UNSPECIFIED:
1249 case NL80211_IFTYPE_OCB:
1250 case NL80211_IFTYPE_MONITOR:
1251 case NL80211_IFTYPE_NAN:
1252 case NL80211_IFTYPE_P2P_DEVICE:
1253 case NL80211_IFTYPE_WDS:
1254 case NUM_NL80211_IFTYPES:
1261 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
1264 struct ieee80211_channel *chan;
1268 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
1269 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1274 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1276 struct nlattr *nl_modes = nla_nest_start_noflag(msg, attr);
1280 goto nla_put_failure;
1284 if ((ifmodes & 1) && nla_put_flag(msg, i))
1285 goto nla_put_failure;
1290 nla_nest_end(msg, nl_modes);
1297 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
1298 struct sk_buff *msg,
1301 struct nlattr *nl_combis;
1304 nl_combis = nla_nest_start_noflag(msg,
1305 NL80211_ATTR_INTERFACE_COMBINATIONS);
1307 goto nla_put_failure;
1309 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1310 const struct ieee80211_iface_combination *c;
1311 struct nlattr *nl_combi, *nl_limits;
1313 c = &wiphy->iface_combinations[i];
1315 nl_combi = nla_nest_start_noflag(msg, i + 1);
1317 goto nla_put_failure;
1319 nl_limits = nla_nest_start_noflag(msg,
1320 NL80211_IFACE_COMB_LIMITS);
1322 goto nla_put_failure;
1324 for (j = 0; j < c->n_limits; j++) {
1325 struct nlattr *nl_limit;
1327 nl_limit = nla_nest_start_noflag(msg, j + 1);
1329 goto nla_put_failure;
1330 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1332 goto nla_put_failure;
1333 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1334 c->limits[j].types))
1335 goto nla_put_failure;
1336 nla_nest_end(msg, nl_limit);
1339 nla_nest_end(msg, nl_limits);
1341 if (c->beacon_int_infra_match &&
1342 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1343 goto nla_put_failure;
1344 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1345 c->num_different_channels) ||
1346 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1348 goto nla_put_failure;
1350 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1351 c->radar_detect_widths) ||
1352 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1353 c->radar_detect_regions)))
1354 goto nla_put_failure;
1355 if (c->beacon_int_min_gcd &&
1356 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1357 c->beacon_int_min_gcd))
1358 goto nla_put_failure;
1360 nla_nest_end(msg, nl_combi);
1363 nla_nest_end(msg, nl_combis);
1371 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1372 struct sk_buff *msg)
1374 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1375 struct nlattr *nl_tcp;
1380 nl_tcp = nla_nest_start_noflag(msg,
1381 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1385 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1386 tcp->data_payload_max))
1389 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1390 tcp->data_payload_max))
1393 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1396 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1397 sizeof(*tcp->tok), tcp->tok))
1400 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1401 tcp->data_interval_max))
1404 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1405 tcp->wake_payload_max))
1408 nla_nest_end(msg, nl_tcp);
1412 static int nl80211_send_wowlan(struct sk_buff *msg,
1413 struct cfg80211_registered_device *rdev,
1416 struct nlattr *nl_wowlan;
1418 if (!rdev->wiphy.wowlan)
1421 nl_wowlan = nla_nest_start_noflag(msg,
1422 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1426 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1427 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1428 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1429 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1430 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1431 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1432 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1433 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1434 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1435 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1436 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1437 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1438 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1439 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1440 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1441 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1444 if (rdev->wiphy.wowlan->n_patterns) {
1445 struct nl80211_pattern_support pat = {
1446 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1447 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1448 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1449 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1452 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1457 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1458 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1459 rdev->wiphy.wowlan->max_nd_match_sets))
1462 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
1465 nla_nest_end(msg, nl_wowlan);
1471 static int nl80211_send_coalesce(struct sk_buff *msg,
1472 struct cfg80211_registered_device *rdev)
1474 struct nl80211_coalesce_rule_support rule;
1476 if (!rdev->wiphy.coalesce)
1479 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1480 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1481 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1482 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1483 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1484 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1486 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1493 nl80211_send_iftype_data(struct sk_buff *msg,
1494 const struct ieee80211_sband_iftype_data *iftdata)
1496 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap;
1498 if (nl80211_put_iftypes(msg, NL80211_BAND_IFTYPE_ATTR_IFTYPES,
1499 iftdata->types_mask))
1502 if (he_cap->has_he) {
1503 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC,
1504 sizeof(he_cap->he_cap_elem.mac_cap_info),
1505 he_cap->he_cap_elem.mac_cap_info) ||
1506 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY,
1507 sizeof(he_cap->he_cap_elem.phy_cap_info),
1508 he_cap->he_cap_elem.phy_cap_info) ||
1509 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET,
1510 sizeof(he_cap->he_mcs_nss_supp),
1511 &he_cap->he_mcs_nss_supp) ||
1512 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE,
1513 sizeof(he_cap->ppe_thres), he_cap->ppe_thres))
1520 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1521 struct ieee80211_supported_band *sband)
1523 struct nlattr *nl_rates, *nl_rate;
1524 struct ieee80211_rate *rate;
1528 if (sband->ht_cap.ht_supported &&
1529 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1530 sizeof(sband->ht_cap.mcs),
1531 &sband->ht_cap.mcs) ||
1532 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1533 sband->ht_cap.cap) ||
1534 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1535 sband->ht_cap.ampdu_factor) ||
1536 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1537 sband->ht_cap.ampdu_density)))
1541 if (sband->vht_cap.vht_supported &&
1542 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1543 sizeof(sband->vht_cap.vht_mcs),
1544 &sband->vht_cap.vht_mcs) ||
1545 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1546 sband->vht_cap.cap)))
1549 if (sband->n_iftype_data) {
1550 struct nlattr *nl_iftype_data =
1551 nla_nest_start_noflag(msg,
1552 NL80211_BAND_ATTR_IFTYPE_DATA);
1555 if (!nl_iftype_data)
1558 for (i = 0; i < sband->n_iftype_data; i++) {
1559 struct nlattr *iftdata;
1561 iftdata = nla_nest_start_noflag(msg, i + 1);
1565 err = nl80211_send_iftype_data(msg,
1566 &sband->iftype_data[i]);
1570 nla_nest_end(msg, iftdata);
1573 nla_nest_end(msg, nl_iftype_data);
1577 nl_rates = nla_nest_start_noflag(msg, NL80211_BAND_ATTR_RATES);
1581 for (i = 0; i < sband->n_bitrates; i++) {
1582 nl_rate = nla_nest_start_noflag(msg, i);
1586 rate = &sband->bitrates[i];
1587 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1590 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1592 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1595 nla_nest_end(msg, nl_rate);
1598 nla_nest_end(msg, nl_rates);
1604 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1605 const struct ieee80211_txrx_stypes *mgmt_stypes)
1608 struct nlattr *nl_ftypes, *nl_ifs;
1609 enum nl80211_iftype ift;
1615 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_TX_FRAME_TYPES);
1619 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1620 nl_ftypes = nla_nest_start_noflag(msg, ift);
1624 stypes = mgmt_stypes[ift].tx;
1627 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1628 (i << 4) | IEEE80211_FTYPE_MGMT))
1633 nla_nest_end(msg, nl_ftypes);
1636 nla_nest_end(msg, nl_ifs);
1638 nl_ifs = nla_nest_start_noflag(msg, NL80211_ATTR_RX_FRAME_TYPES);
1642 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1643 nl_ftypes = nla_nest_start_noflag(msg, ift);
1647 stypes = mgmt_stypes[ift].rx;
1650 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1651 (i << 4) | IEEE80211_FTYPE_MGMT))
1656 nla_nest_end(msg, nl_ftypes);
1658 nla_nest_end(msg, nl_ifs);
1663 #define CMD(op, n) \
1665 if (rdev->ops->op) { \
1667 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1668 goto nla_put_failure; \
1672 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1673 struct sk_buff *msg)
1678 * do *NOT* add anything into this function, new things need to be
1679 * advertised only to new versions of userspace that can deal with
1680 * the split (and they can't possibly care about new features...
1682 CMD(add_virtual_intf, NEW_INTERFACE);
1683 CMD(change_virtual_intf, SET_INTERFACE);
1684 CMD(add_key, NEW_KEY);
1685 CMD(start_ap, START_AP);
1686 CMD(add_station, NEW_STATION);
1687 CMD(add_mpath, NEW_MPATH);
1688 CMD(update_mesh_config, SET_MESH_CONFIG);
1689 CMD(change_bss, SET_BSS);
1690 CMD(auth, AUTHENTICATE);
1691 CMD(assoc, ASSOCIATE);
1692 CMD(deauth, DEAUTHENTICATE);
1693 CMD(disassoc, DISASSOCIATE);
1694 CMD(join_ibss, JOIN_IBSS);
1695 CMD(join_mesh, JOIN_MESH);
1696 CMD(set_pmksa, SET_PMKSA);
1697 CMD(del_pmksa, DEL_PMKSA);
1698 CMD(flush_pmksa, FLUSH_PMKSA);
1699 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1700 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1701 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1702 CMD(mgmt_tx, FRAME);
1703 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1704 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1706 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1707 goto nla_put_failure;
1709 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1710 rdev->ops->join_mesh) {
1712 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1713 goto nla_put_failure;
1715 CMD(set_wds_peer, SET_WDS_PEER);
1716 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1717 CMD(tdls_mgmt, TDLS_MGMT);
1718 CMD(tdls_oper, TDLS_OPER);
1720 if (rdev->wiphy.max_sched_scan_reqs)
1721 CMD(sched_scan_start, START_SCHED_SCAN);
1722 CMD(probe_client, PROBE_CLIENT);
1723 CMD(set_noack_map, SET_NOACK_MAP);
1724 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1726 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1727 goto nla_put_failure;
1729 CMD(start_p2p_device, START_P2P_DEVICE);
1730 CMD(set_mcast_rate, SET_MCAST_RATE);
1731 #ifdef CONFIG_NL80211_TESTMODE
1732 CMD(testmode_cmd, TESTMODE);
1735 if (rdev->ops->connect || rdev->ops->auth) {
1737 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1738 goto nla_put_failure;
1741 if (rdev->ops->disconnect || rdev->ops->deauth) {
1743 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1744 goto nla_put_failure;
1753 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities *cap,
1754 struct sk_buff *msg)
1758 if (!cap->ftm.supported)
1761 ftm = nla_nest_start_noflag(msg, NL80211_PMSR_TYPE_FTM);
1765 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP))
1767 if (cap->ftm.non_asap &&
1768 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP))
1770 if (cap->ftm.request_lci &&
1771 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI))
1773 if (cap->ftm.request_civicloc &&
1774 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC))
1776 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES,
1777 cap->ftm.preambles))
1779 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS,
1780 cap->ftm.bandwidths))
1782 if (cap->ftm.max_bursts_exponent >= 0 &&
1783 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT,
1784 cap->ftm.max_bursts_exponent))
1786 if (cap->ftm.max_ftms_per_burst &&
1787 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST,
1788 cap->ftm.max_ftms_per_burst))
1791 nla_nest_end(msg, ftm);
1795 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device *rdev,
1796 struct sk_buff *msg)
1798 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa;
1799 struct nlattr *pmsr, *caps;
1805 * we don't need to clean up anything here since the caller
1806 * will genlmsg_cancel() if we fail
1809 pmsr = nla_nest_start_noflag(msg, NL80211_ATTR_PEER_MEASUREMENTS);
1813 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers))
1816 if (cap->report_ap_tsf &&
1817 nla_put_flag(msg, NL80211_PMSR_ATTR_REPORT_AP_TSF))
1820 if (cap->randomize_mac_addr &&
1821 nla_put_flag(msg, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR))
1824 caps = nla_nest_start_noflag(msg, NL80211_PMSR_ATTR_TYPE_CAPA);
1828 if (nl80211_send_pmsr_ftm_capa(cap, msg))
1831 nla_nest_end(msg, caps);
1832 nla_nest_end(msg, pmsr);
1837 struct nl80211_dump_wiphy_state {
1840 long split_start, band_start, chan_start, capa_start;
1844 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
1845 enum nl80211_commands cmd,
1846 struct sk_buff *msg, u32 portid, u32 seq,
1847 int flags, struct nl80211_dump_wiphy_state *state)
1850 struct nlattr *nl_bands, *nl_band;
1851 struct nlattr *nl_freqs, *nl_freq;
1852 struct nlattr *nl_cmds;
1853 enum nl80211_band band;
1854 struct ieee80211_channel *chan;
1856 const struct ieee80211_txrx_stypes *mgmt_stypes =
1857 rdev->wiphy.mgmt_stypes;
1860 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
1864 if (WARN_ON(!state))
1867 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
1868 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1869 wiphy_name(&rdev->wiphy)) ||
1870 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1871 cfg80211_rdev_list_generation))
1872 goto nla_put_failure;
1874 if (cmd != NL80211_CMD_NEW_WIPHY)
1877 switch (state->split_start) {
1879 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1880 rdev->wiphy.retry_short) ||
1881 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1882 rdev->wiphy.retry_long) ||
1883 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1884 rdev->wiphy.frag_threshold) ||
1885 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1886 rdev->wiphy.rts_threshold) ||
1887 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1888 rdev->wiphy.coverage_class) ||
1889 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1890 rdev->wiphy.max_scan_ssids) ||
1891 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1892 rdev->wiphy.max_sched_scan_ssids) ||
1893 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1894 rdev->wiphy.max_scan_ie_len) ||
1895 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1896 rdev->wiphy.max_sched_scan_ie_len) ||
1897 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
1898 rdev->wiphy.max_match_sets) ||
1899 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
1900 rdev->wiphy.max_sched_scan_plans) ||
1901 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
1902 rdev->wiphy.max_sched_scan_plan_interval) ||
1903 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
1904 rdev->wiphy.max_sched_scan_plan_iterations))
1905 goto nla_put_failure;
1907 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
1908 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
1909 goto nla_put_failure;
1910 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
1911 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1912 goto nla_put_failure;
1913 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
1914 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1915 goto nla_put_failure;
1916 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
1917 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1918 goto nla_put_failure;
1919 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
1920 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1921 goto nla_put_failure;
1922 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
1923 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
1924 goto nla_put_failure;
1925 state->split_start++;
1930 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1931 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1932 rdev->wiphy.cipher_suites))
1933 goto nla_put_failure;
1935 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1936 rdev->wiphy.max_num_pmkids))
1937 goto nla_put_failure;
1939 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
1940 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
1941 goto nla_put_failure;
1943 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1944 rdev->wiphy.available_antennas_tx) ||
1945 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1946 rdev->wiphy.available_antennas_rx))
1947 goto nla_put_failure;
1949 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
1950 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1951 rdev->wiphy.probe_resp_offload))
1952 goto nla_put_failure;
1954 if ((rdev->wiphy.available_antennas_tx ||
1955 rdev->wiphy.available_antennas_rx) &&
1956 rdev->ops->get_antenna) {
1957 u32 tx_ant = 0, rx_ant = 0;
1960 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
1962 if (nla_put_u32(msg,
1963 NL80211_ATTR_WIPHY_ANTENNA_TX,
1966 NL80211_ATTR_WIPHY_ANTENNA_RX,
1968 goto nla_put_failure;
1972 state->split_start++;
1977 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1978 rdev->wiphy.interface_modes))
1979 goto nla_put_failure;
1980 state->split_start++;
1985 nl_bands = nla_nest_start_noflag(msg,
1986 NL80211_ATTR_WIPHY_BANDS);
1988 goto nla_put_failure;
1990 for (band = state->band_start;
1991 band < NUM_NL80211_BANDS; band++) {
1992 struct ieee80211_supported_band *sband;
1994 sband = rdev->wiphy.bands[band];
1999 nl_band = nla_nest_start_noflag(msg, band);
2001 goto nla_put_failure;
2003 switch (state->chan_start) {
2005 if (nl80211_send_band_rateinfo(msg, sband))
2006 goto nla_put_failure;
2007 state->chan_start++;
2012 /* add frequencies */
2013 nl_freqs = nla_nest_start_noflag(msg,
2014 NL80211_BAND_ATTR_FREQS);
2016 goto nla_put_failure;
2018 for (i = state->chan_start - 1;
2019 i < sband->n_channels;
2021 nl_freq = nla_nest_start_noflag(msg,
2024 goto nla_put_failure;
2026 chan = &sband->channels[i];
2028 if (nl80211_msg_put_channel(
2029 msg, &rdev->wiphy, chan,
2031 goto nla_put_failure;
2033 nla_nest_end(msg, nl_freq);
2037 if (i < sband->n_channels)
2038 state->chan_start = i + 2;
2040 state->chan_start = 0;
2041 nla_nest_end(msg, nl_freqs);
2044 nla_nest_end(msg, nl_band);
2047 /* start again here */
2048 if (state->chan_start)
2053 nla_nest_end(msg, nl_bands);
2055 if (band < NUM_NL80211_BANDS)
2056 state->band_start = band + 1;
2058 state->band_start = 0;
2060 /* if bands & channels are done, continue outside */
2061 if (state->band_start == 0 && state->chan_start == 0)
2062 state->split_start++;
2067 nl_cmds = nla_nest_start_noflag(msg,
2068 NL80211_ATTR_SUPPORTED_COMMANDS);
2070 goto nla_put_failure;
2072 i = nl80211_add_commands_unsplit(rdev, msg);
2074 goto nla_put_failure;
2076 CMD(crit_proto_start, CRIT_PROTOCOL_START);
2077 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
2078 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
2079 CMD(channel_switch, CHANNEL_SWITCH);
2080 CMD(set_qos_map, SET_QOS_MAP);
2081 if (rdev->wiphy.features &
2082 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
2083 CMD(add_tx_ts, ADD_TX_TS);
2084 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
2085 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
2089 nla_nest_end(msg, nl_cmds);
2090 state->split_start++;
2095 if (rdev->ops->remain_on_channel &&
2096 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
2098 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
2099 rdev->wiphy.max_remain_on_channel_duration))
2100 goto nla_put_failure;
2102 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
2103 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
2104 goto nla_put_failure;
2106 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
2107 goto nla_put_failure;
2108 state->split_start++;
2114 if (nl80211_send_wowlan(msg, rdev, state->split))
2115 goto nla_put_failure;
2116 state->split_start++;
2120 state->split_start++;
2124 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
2125 rdev->wiphy.software_iftypes))
2126 goto nla_put_failure;
2128 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
2130 goto nla_put_failure;
2132 state->split_start++;
2137 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
2138 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
2139 rdev->wiphy.ap_sme_capa))
2140 goto nla_put_failure;
2142 features = rdev->wiphy.features;
2144 * We can only add the per-channel limit information if the
2145 * dump is split, otherwise it makes it too big. Therefore
2146 * only advertise it in that case.
2149 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
2150 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
2151 goto nla_put_failure;
2153 if (rdev->wiphy.ht_capa_mod_mask &&
2154 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
2155 sizeof(*rdev->wiphy.ht_capa_mod_mask),
2156 rdev->wiphy.ht_capa_mod_mask))
2157 goto nla_put_failure;
2159 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
2160 rdev->wiphy.max_acl_mac_addrs &&
2161 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
2162 rdev->wiphy.max_acl_mac_addrs))
2163 goto nla_put_failure;
2166 * Any information below this point is only available to
2167 * applications that can deal with it being split. This
2168 * helps ensure that newly added capabilities don't break
2169 * older tools by overrunning their buffers.
2171 * We still increment split_start so that in the split
2172 * case we'll continue with more data in the next round,
2173 * but break unconditionally so unsplit data stops here.
2175 state->split_start++;
2178 if (rdev->wiphy.extended_capabilities &&
2179 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
2180 rdev->wiphy.extended_capabilities_len,
2181 rdev->wiphy.extended_capabilities) ||
2182 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2183 rdev->wiphy.extended_capabilities_len,
2184 rdev->wiphy.extended_capabilities_mask)))
2185 goto nla_put_failure;
2187 if (rdev->wiphy.vht_capa_mod_mask &&
2188 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
2189 sizeof(*rdev->wiphy.vht_capa_mod_mask),
2190 rdev->wiphy.vht_capa_mod_mask))
2191 goto nla_put_failure;
2193 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN,
2194 rdev->wiphy.perm_addr))
2195 goto nla_put_failure;
2197 if (!is_zero_ether_addr(rdev->wiphy.addr_mask) &&
2198 nla_put(msg, NL80211_ATTR_MAC_MASK, ETH_ALEN,
2199 rdev->wiphy.addr_mask))
2200 goto nla_put_failure;
2202 if (rdev->wiphy.n_addresses > 1) {
2205 attr = nla_nest_start(msg, NL80211_ATTR_MAC_ADDRS);
2207 goto nla_put_failure;
2209 for (i = 0; i < rdev->wiphy.n_addresses; i++)
2210 if (nla_put(msg, i + 1, ETH_ALEN,
2211 rdev->wiphy.addresses[i].addr))
2212 goto nla_put_failure;
2214 nla_nest_end(msg, attr);
2217 state->split_start++;
2220 if (nl80211_send_coalesce(msg, rdev))
2221 goto nla_put_failure;
2223 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
2224 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
2225 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
2226 goto nla_put_failure;
2228 if (rdev->wiphy.max_ap_assoc_sta &&
2229 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
2230 rdev->wiphy.max_ap_assoc_sta))
2231 goto nla_put_failure;
2233 state->split_start++;
2236 if (rdev->wiphy.n_vendor_commands) {
2237 const struct nl80211_vendor_cmd_info *info;
2238 struct nlattr *nested;
2240 nested = nla_nest_start_noflag(msg,
2241 NL80211_ATTR_VENDOR_DATA);
2243 goto nla_put_failure;
2245 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
2246 info = &rdev->wiphy.vendor_commands[i].info;
2247 if (nla_put(msg, i + 1, sizeof(*info), info))
2248 goto nla_put_failure;
2250 nla_nest_end(msg, nested);
2253 if (rdev->wiphy.n_vendor_events) {
2254 const struct nl80211_vendor_cmd_info *info;
2255 struct nlattr *nested;
2257 nested = nla_nest_start_noflag(msg,
2258 NL80211_ATTR_VENDOR_EVENTS);
2260 goto nla_put_failure;
2262 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
2263 info = &rdev->wiphy.vendor_events[i];
2264 if (nla_put(msg, i + 1, sizeof(*info), info))
2265 goto nla_put_failure;
2267 nla_nest_end(msg, nested);
2269 state->split_start++;
2272 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
2273 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
2274 rdev->wiphy.max_num_csa_counters))
2275 goto nla_put_failure;
2277 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2278 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
2279 goto nla_put_failure;
2281 if (rdev->wiphy.max_sched_scan_reqs &&
2282 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
2283 rdev->wiphy.max_sched_scan_reqs))
2284 goto nla_put_failure;
2286 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
2287 sizeof(rdev->wiphy.ext_features),
2288 rdev->wiphy.ext_features))
2289 goto nla_put_failure;
2291 if (rdev->wiphy.bss_select_support) {
2292 struct nlattr *nested;
2293 u32 bss_select_support = rdev->wiphy.bss_select_support;
2295 nested = nla_nest_start_noflag(msg,
2296 NL80211_ATTR_BSS_SELECT);
2298 goto nla_put_failure;
2301 while (bss_select_support) {
2302 if ((bss_select_support & 1) &&
2303 nla_put_flag(msg, i))
2304 goto nla_put_failure;
2306 bss_select_support >>= 1;
2308 nla_nest_end(msg, nested);
2311 state->split_start++;
2314 if (rdev->wiphy.num_iftype_ext_capab &&
2315 rdev->wiphy.iftype_ext_capab) {
2316 struct nlattr *nested_ext_capab, *nested;
2318 nested = nla_nest_start_noflag(msg,
2319 NL80211_ATTR_IFTYPE_EXT_CAPA);
2321 goto nla_put_failure;
2323 for (i = state->capa_start;
2324 i < rdev->wiphy.num_iftype_ext_capab; i++) {
2325 const struct wiphy_iftype_ext_capab *capab;
2327 capab = &rdev->wiphy.iftype_ext_capab[i];
2329 nested_ext_capab = nla_nest_start_noflag(msg,
2331 if (!nested_ext_capab ||
2332 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
2334 nla_put(msg, NL80211_ATTR_EXT_CAPA,
2335 capab->extended_capabilities_len,
2336 capab->extended_capabilities) ||
2337 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2338 capab->extended_capabilities_len,
2339 capab->extended_capabilities_mask))
2340 goto nla_put_failure;
2342 nla_nest_end(msg, nested_ext_capab);
2346 nla_nest_end(msg, nested);
2347 if (i < rdev->wiphy.num_iftype_ext_capab) {
2348 state->capa_start = i + 1;
2353 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
2354 rdev->wiphy.nan_supported_bands))
2355 goto nla_put_failure;
2357 if (wiphy_ext_feature_isset(&rdev->wiphy,
2358 NL80211_EXT_FEATURE_TXQS)) {
2359 struct cfg80211_txq_stats txqstats = {};
2362 res = rdev_get_txq_stats(rdev, NULL, &txqstats);
2364 !nl80211_put_txq_stats(msg, &txqstats,
2365 NL80211_ATTR_TXQ_STATS))
2366 goto nla_put_failure;
2368 if (nla_put_u32(msg, NL80211_ATTR_TXQ_LIMIT,
2369 rdev->wiphy.txq_limit))
2370 goto nla_put_failure;
2371 if (nla_put_u32(msg, NL80211_ATTR_TXQ_MEMORY_LIMIT,
2372 rdev->wiphy.txq_memory_limit))
2373 goto nla_put_failure;
2374 if (nla_put_u32(msg, NL80211_ATTR_TXQ_QUANTUM,
2375 rdev->wiphy.txq_quantum))
2376 goto nla_put_failure;
2379 state->split_start++;
2382 if (nl80211_send_pmsr_capa(rdev, msg))
2383 goto nla_put_failure;
2385 state->split_start++;
2388 if (rdev->wiphy.akm_suites &&
2389 nla_put(msg, NL80211_ATTR_AKM_SUITES,
2390 sizeof(u32) * rdev->wiphy.n_akm_suites,
2391 rdev->wiphy.akm_suites))
2392 goto nla_put_failure;
2395 state->split_start = 0;
2399 genlmsg_end(msg, hdr);
2403 genlmsg_cancel(msg, hdr);
2407 static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
2408 struct netlink_callback *cb,
2409 struct nl80211_dump_wiphy_state *state)
2411 struct nlattr **tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
2417 ret = nlmsg_parse_deprecated(cb->nlh,
2418 GENL_HDRLEN + nl80211_fam.hdrsize,
2419 tb, nl80211_fam.maxattr,
2420 nl80211_policy, NULL);
2421 /* ignore parse errors for backward compatibility */
2427 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
2428 if (tb[NL80211_ATTR_WIPHY])
2429 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2430 if (tb[NL80211_ATTR_WDEV])
2431 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
2432 if (tb[NL80211_ATTR_IFINDEX]) {
2433 struct net_device *netdev;
2434 struct cfg80211_registered_device *rdev;
2435 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
2437 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
2442 if (netdev->ieee80211_ptr) {
2443 rdev = wiphy_to_rdev(
2444 netdev->ieee80211_ptr->wiphy);
2445 state->filter_wiphy = rdev->wiphy_idx;
2455 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
2458 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
2459 struct cfg80211_registered_device *rdev;
2463 state = kzalloc(sizeof(*state), GFP_KERNEL);
2468 state->filter_wiphy = -1;
2469 ret = nl80211_dump_wiphy_parse(skb, cb, state);
2475 cb->args[0] = (long)state;
2478 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2479 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2481 if (++idx <= state->start)
2483 if (state->filter_wiphy != -1 &&
2484 state->filter_wiphy != rdev->wiphy_idx)
2486 /* attempt to fit multiple wiphy data chunks into the skb */
2488 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
2490 NETLINK_CB(cb->skb).portid,
2492 NLM_F_MULTI, state);
2495 * If sending the wiphy data didn't fit (ENOBUFS
2496 * or EMSGSIZE returned), this SKB is still
2497 * empty (so it's not too big because another
2498 * wiphy dataset is already in the skb) and
2499 * we've not tried to adjust the dump allocation
2500 * yet ... then adjust the alloc size to be
2501 * bigger, and return 1 but with the empty skb.
2502 * This results in an empty message being RX'ed
2503 * in userspace, but that is ignored.
2505 * We can then retry with the larger buffer.
2507 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
2508 !skb->len && !state->split &&
2509 cb->min_dump_alloc < 4096) {
2510 cb->min_dump_alloc = 4096;
2511 state->split_start = 0;
2518 } while (state->split_start > 0);
2528 static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2530 kfree((void *)cb->args[0]);
2534 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2536 struct sk_buff *msg;
2537 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2538 struct nl80211_dump_wiphy_state state = {};
2540 msg = nlmsg_new(4096, GFP_KERNEL);
2544 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2545 info->snd_portid, info->snd_seq, 0,
2551 return genlmsg_reply(msg, info);
2554 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2555 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2556 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2557 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2558 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2559 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2562 static int parse_txq_params(struct nlattr *tb[],
2563 struct ieee80211_txq_params *txq_params)
2567 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
2568 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2569 !tb[NL80211_TXQ_ATTR_AIFS])
2572 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
2573 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2574 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2575 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2576 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2578 if (ac >= NL80211_NUM_ACS)
2580 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
2584 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2587 * You can only set the channel explicitly for WDS interfaces,
2588 * all others have their channel managed via their respective
2589 * "establish a connection" command (connect, join, ...)
2591 * For AP/GO and mesh mode, the channel can be set with the
2592 * channel userspace API, but is only stored and passed to the
2593 * low-level driver when the AP starts or the mesh is joined.
2594 * This is for backward compatibility, userspace can also give
2595 * the channel in the start-ap or join-mesh commands instead.
2597 * Monitors are special as they are normally slaved to
2598 * whatever else is going on, so they have their own special
2599 * operation to set the monitor channel if possible.
2602 wdev->iftype == NL80211_IFTYPE_AP ||
2603 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
2604 wdev->iftype == NL80211_IFTYPE_MONITOR ||
2605 wdev->iftype == NL80211_IFTYPE_P2P_GO;
2608 int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
2609 struct genl_info *info,
2610 struct cfg80211_chan_def *chandef)
2612 struct netlink_ext_ack *extack = info->extack;
2613 struct nlattr **attrs = info->attrs;
2616 if (!attrs[NL80211_ATTR_WIPHY_FREQ])
2619 control_freq = nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]);
2621 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
2622 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2623 chandef->center_freq1 = control_freq;
2624 chandef->center_freq2 = 0;
2626 /* Primary channel not allowed */
2627 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED) {
2628 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ],
2629 "Channel is disabled");
2633 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2634 enum nl80211_channel_type chantype;
2636 chantype = nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
2639 case NL80211_CHAN_NO_HT:
2640 case NL80211_CHAN_HT20:
2641 case NL80211_CHAN_HT40PLUS:
2642 case NL80211_CHAN_HT40MINUS:
2643 cfg80211_chandef_create(chandef, chandef->chan,
2645 /* user input for center_freq is incorrect */
2646 if (attrs[NL80211_ATTR_CENTER_FREQ1] &&
2647 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) {
2648 NL_SET_ERR_MSG_ATTR(extack,
2649 attrs[NL80211_ATTR_CENTER_FREQ1],
2650 "bad center frequency 1");
2653 /* center_freq2 must be zero */
2654 if (attrs[NL80211_ATTR_CENTER_FREQ2] &&
2655 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2])) {
2656 NL_SET_ERR_MSG_ATTR(extack,
2657 attrs[NL80211_ATTR_CENTER_FREQ2],
2658 "center frequency 2 can't be used");
2663 NL_SET_ERR_MSG_ATTR(extack,
2664 attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
2665 "invalid channel type");
2668 } else if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
2670 nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]);
2671 if (attrs[NL80211_ATTR_CENTER_FREQ1])
2672 chandef->center_freq1 =
2673 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]);
2674 if (attrs[NL80211_ATTR_CENTER_FREQ2])
2675 chandef->center_freq2 =
2676 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]);
2679 if (!cfg80211_chandef_valid(chandef)) {
2680 NL_SET_ERR_MSG(extack, "invalid channel definition");
2684 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
2685 IEEE80211_CHAN_DISABLED)) {
2686 NL_SET_ERR_MSG(extack, "(extension) channel is disabled");
2690 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
2691 chandef->width == NL80211_CHAN_WIDTH_10) &&
2692 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) {
2693 NL_SET_ERR_MSG(extack, "5/10 MHz not supported");
2700 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
2701 struct net_device *dev,
2702 struct genl_info *info)
2704 struct cfg80211_chan_def chandef;
2706 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
2707 struct wireless_dev *wdev = NULL;
2710 wdev = dev->ieee80211_ptr;
2711 if (!nl80211_can_set_dev_channel(wdev))
2714 iftype = wdev->iftype;
2716 result = nl80211_parse_chandef(rdev, info, &chandef);
2721 case NL80211_IFTYPE_AP:
2722 case NL80211_IFTYPE_P2P_GO:
2723 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
2728 if (wdev->beacon_interval) {
2729 if (!dev || !rdev->ops->set_ap_chanwidth ||
2730 !(rdev->wiphy.features &
2731 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2736 /* Only allow dynamic channel width changes */
2737 if (chandef.chan != wdev->preset_chandef.chan) {
2741 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2745 wdev->preset_chandef = chandef;
2748 case NL80211_IFTYPE_MESH_POINT:
2749 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
2751 case NL80211_IFTYPE_MONITOR:
2752 result = cfg80211_set_monitor_channel(rdev, &chandef);
2761 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2763 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2764 struct net_device *netdev = info->user_ptr[1];
2766 return __nl80211_set_channel(rdev, netdev, info);
2769 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2771 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2772 struct net_device *dev = info->user_ptr[1];
2773 struct wireless_dev *wdev = dev->ieee80211_ptr;
2776 if (!info->attrs[NL80211_ATTR_MAC])
2779 if (netif_running(dev))
2782 if (!rdev->ops->set_wds_peer)
2785 if (wdev->iftype != NL80211_IFTYPE_WDS)
2788 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
2789 return rdev_set_wds_peer(rdev, dev, bssid);
2792 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2794 struct cfg80211_registered_device *rdev;
2795 struct net_device *netdev = NULL;
2796 struct wireless_dev *wdev;
2797 int result = 0, rem_txq_params = 0;
2798 struct nlattr *nl_txq_params;
2800 u8 retry_short = 0, retry_long = 0;
2801 u32 frag_threshold = 0, rts_threshold = 0;
2802 u8 coverage_class = 0;
2803 u32 txq_limit = 0, txq_memory_limit = 0, txq_quantum = 0;
2808 * Try to find the wiphy and netdev. Normally this
2809 * function shouldn't need the netdev, but this is
2810 * done for backward compatibility -- previously
2811 * setting the channel was done per wiphy, but now
2812 * it is per netdev. Previous userland like hostapd
2813 * also passed a netdev to set_wiphy, so that it is
2814 * possible to let that go to the right netdev!
2817 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2818 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2820 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
2821 if (netdev && netdev->ieee80211_ptr)
2822 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
2828 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2831 return PTR_ERR(rdev);
2836 wdev = netdev->ieee80211_ptr;
2839 * end workaround code, by now the rdev is available
2840 * and locked, and wdev may or may not be NULL.
2843 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
2844 result = cfg80211_dev_rename(
2845 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
2850 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2851 struct ieee80211_txq_params txq_params;
2852 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2854 if (!rdev->ops->set_txq_params)
2860 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2861 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2864 if (!netif_running(netdev))
2867 nla_for_each_nested(nl_txq_params,
2868 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2870 result = nla_parse_nested_deprecated(tb,
2871 NL80211_TXQ_ATTR_MAX,
2877 result = parse_txq_params(tb, &txq_params);
2881 result = rdev_set_txq_params(rdev, netdev,
2888 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2889 result = __nl80211_set_channel(
2891 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2897 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
2898 struct wireless_dev *txp_wdev = wdev;
2899 enum nl80211_tx_power_setting type;
2902 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2905 if (!rdev->ops->set_tx_power)
2908 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2909 type = nla_get_u32(info->attrs[idx]);
2911 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
2912 (type != NL80211_TX_POWER_AUTOMATIC))
2915 if (type != NL80211_TX_POWER_AUTOMATIC) {
2916 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2917 mbm = nla_get_u32(info->attrs[idx]);
2920 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
2925 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2926 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2929 if ((!rdev->wiphy.available_antennas_tx &&
2930 !rdev->wiphy.available_antennas_rx) ||
2931 !rdev->ops->set_antenna)
2934 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2935 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2937 /* reject antenna configurations which don't match the
2938 * available antenna masks, except for the "all" mask */
2939 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
2940 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2943 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2944 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
2946 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
2953 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2954 retry_short = nla_get_u8(
2955 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
2957 changed |= WIPHY_PARAM_RETRY_SHORT;
2960 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2961 retry_long = nla_get_u8(
2962 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
2964 changed |= WIPHY_PARAM_RETRY_LONG;
2967 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2968 frag_threshold = nla_get_u32(
2969 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
2970 if (frag_threshold < 256)
2973 if (frag_threshold != (u32) -1) {
2975 * Fragments (apart from the last one) are required to
2976 * have even length. Make the fragmentation code
2977 * simpler by stripping LSB should someone try to use
2978 * odd threshold value.
2980 frag_threshold &= ~0x1;
2982 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2985 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2986 rts_threshold = nla_get_u32(
2987 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2988 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2991 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
2992 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2995 coverage_class = nla_get_u8(
2996 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2997 changed |= WIPHY_PARAM_COVERAGE_CLASS;
3000 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
3001 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
3004 changed |= WIPHY_PARAM_DYN_ACK;
3007 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) {
3008 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3009 NL80211_EXT_FEATURE_TXQS))
3011 txq_limit = nla_get_u32(
3012 info->attrs[NL80211_ATTR_TXQ_LIMIT]);
3013 changed |= WIPHY_PARAM_TXQ_LIMIT;
3016 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) {
3017 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3018 NL80211_EXT_FEATURE_TXQS))
3020 txq_memory_limit = nla_get_u32(
3021 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]);
3022 changed |= WIPHY_PARAM_TXQ_MEMORY_LIMIT;
3025 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) {
3026 if (!wiphy_ext_feature_isset(&rdev->wiphy,
3027 NL80211_EXT_FEATURE_TXQS))
3029 txq_quantum = nla_get_u32(
3030 info->attrs[NL80211_ATTR_TXQ_QUANTUM]);
3031 changed |= WIPHY_PARAM_TXQ_QUANTUM;
3035 u8 old_retry_short, old_retry_long;
3036 u32 old_frag_threshold, old_rts_threshold;
3037 u8 old_coverage_class;
3038 u32 old_txq_limit, old_txq_memory_limit, old_txq_quantum;
3040 if (!rdev->ops->set_wiphy_params)
3043 old_retry_short = rdev->wiphy.retry_short;
3044 old_retry_long = rdev->wiphy.retry_long;
3045 old_frag_threshold = rdev->wiphy.frag_threshold;
3046 old_rts_threshold = rdev->wiphy.rts_threshold;
3047 old_coverage_class = rdev->wiphy.coverage_class;
3048 old_txq_limit = rdev->wiphy.txq_limit;
3049 old_txq_memory_limit = rdev->wiphy.txq_memory_limit;
3050 old_txq_quantum = rdev->wiphy.txq_quantum;
3052 if (changed & WIPHY_PARAM_RETRY_SHORT)
3053 rdev->wiphy.retry_short = retry_short;
3054 if (changed & WIPHY_PARAM_RETRY_LONG)
3055 rdev->wiphy.retry_long = retry_long;
3056 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
3057 rdev->wiphy.frag_threshold = frag_threshold;
3058 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
3059 rdev->wiphy.rts_threshold = rts_threshold;
3060 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
3061 rdev->wiphy.coverage_class = coverage_class;
3062 if (changed & WIPHY_PARAM_TXQ_LIMIT)
3063 rdev->wiphy.txq_limit = txq_limit;
3064 if (changed & WIPHY_PARAM_TXQ_MEMORY_LIMIT)
3065 rdev->wiphy.txq_memory_limit = txq_memory_limit;
3066 if (changed & WIPHY_PARAM_TXQ_QUANTUM)
3067 rdev->wiphy.txq_quantum = txq_quantum;
3069 result = rdev_set_wiphy_params(rdev, changed);
3071 rdev->wiphy.retry_short = old_retry_short;
3072 rdev->wiphy.retry_long = old_retry_long;
3073 rdev->wiphy.frag_threshold = old_frag_threshold;
3074 rdev->wiphy.rts_threshold = old_rts_threshold;
3075 rdev->wiphy.coverage_class = old_coverage_class;
3076 rdev->wiphy.txq_limit = old_txq_limit;
3077 rdev->wiphy.txq_memory_limit = old_txq_memory_limit;
3078 rdev->wiphy.txq_quantum = old_txq_quantum;
3085 static int nl80211_send_chandef(struct sk_buff *msg,
3086 const struct cfg80211_chan_def *chandef)
3088 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
3091 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
3092 chandef->chan->center_freq))
3094 switch (chandef->width) {
3095 case NL80211_CHAN_WIDTH_20_NOHT:
3096 case NL80211_CHAN_WIDTH_20:
3097 case NL80211_CHAN_WIDTH_40:
3098 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
3099 cfg80211_get_chandef_type(chandef)))
3105 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
3107 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
3109 if (chandef->center_freq2 &&
3110 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
3115 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
3116 struct cfg80211_registered_device *rdev,
3117 struct wireless_dev *wdev,
3118 enum nl80211_commands cmd)
3120 struct net_device *dev = wdev->netdev;
3123 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
3124 cmd != NL80211_CMD_DEL_INTERFACE &&
3125 cmd != NL80211_CMD_SET_INTERFACE);
3127 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3132 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3133 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
3134 goto nla_put_failure;
3136 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3137 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
3138 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
3139 NL80211_ATTR_PAD) ||
3140 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
3141 nla_put_u32(msg, NL80211_ATTR_GENERATION,
3142 rdev->devlist_generation ^
3143 (cfg80211_rdev_list_generation << 2)) ||
3144 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr))
3145 goto nla_put_failure;
3147 if (rdev->ops->get_channel) {
3149 struct cfg80211_chan_def chandef;
3151 ret = rdev_get_channel(rdev, wdev, &chandef);
3153 if (nl80211_send_chandef(msg, &chandef))
3154 goto nla_put_failure;
3158 if (rdev->ops->get_tx_power) {
3161 ret = rdev_get_tx_power(rdev, wdev, &dbm);
3163 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
3165 goto nla_put_failure;
3169 switch (wdev->iftype) {
3170 case NL80211_IFTYPE_AP:
3171 if (wdev->ssid_len &&
3172 nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
3173 goto nla_put_failure_locked;
3175 case NL80211_IFTYPE_STATION:
3176 case NL80211_IFTYPE_P2P_CLIENT:
3177 case NL80211_IFTYPE_ADHOC: {
3179 if (!wdev->current_bss)
3182 ssid_ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
3185 nla_put(msg, NL80211_ATTR_SSID, ssid_ie[1], ssid_ie + 2))
3186 goto nla_put_failure_rcu_locked;
3196 if (rdev->ops->get_txq_stats) {
3197 struct cfg80211_txq_stats txqstats = {};
3198 int ret = rdev_get_txq_stats(rdev, wdev, &txqstats);
3201 !nl80211_put_txq_stats(msg, &txqstats,
3202 NL80211_ATTR_TXQ_STATS))
3203 goto nla_put_failure;
3206 genlmsg_end(msg, hdr);
3209 nla_put_failure_rcu_locked:
3211 nla_put_failure_locked:
3214 genlmsg_cancel(msg, hdr);
3218 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
3222 int wp_start = cb->args[0];
3223 int if_start = cb->args[1];
3224 int filter_wiphy = -1;
3225 struct cfg80211_registered_device *rdev;
3226 struct wireless_dev *wdev;
3231 struct nl80211_dump_wiphy_state state = {
3235 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
3239 filter_wiphy = state.filter_wiphy;
3242 * if filtering, set cb->args[2] to +1 since 0 is the default
3243 * value needed to determine that parsing is necessary.
3245 if (filter_wiphy >= 0)
3246 cb->args[2] = filter_wiphy + 1;
3249 } else if (cb->args[2] > 0) {
3250 filter_wiphy = cb->args[2] - 1;
3253 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3254 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3256 if (wp_idx < wp_start) {
3261 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
3266 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3267 if (if_idx < if_start) {
3271 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
3272 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3274 NL80211_CMD_NEW_INTERFACE) < 0) {
3283 cb->args[0] = wp_idx;
3284 cb->args[1] = if_idx;
3293 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
3295 struct sk_buff *msg;
3296 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3297 struct wireless_dev *wdev = info->user_ptr[1];
3299 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3303 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3304 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3309 return genlmsg_reply(msg, info);
3312 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
3313 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
3314 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
3315 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
3316 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
3317 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
3318 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
3321 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
3323 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
3331 if (nla_parse_nested_deprecated(flags, NL80211_MNTR_FLAG_MAX, nla, mntr_flags_policy, NULL))
3334 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
3336 *mntrflags |= (1<<flag);
3338 *mntrflags |= MONITOR_FLAG_CHANGED;
3343 static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
3344 enum nl80211_iftype type,
3345 struct genl_info *info,
3346 struct vif_params *params)
3348 bool change = false;
3351 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
3352 if (type != NL80211_IFTYPE_MONITOR)
3355 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
3363 if (params->flags & MONITOR_FLAG_ACTIVE &&
3364 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
3367 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
3368 const u8 *mumimo_groups;
3369 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3371 if (type != NL80211_IFTYPE_MONITOR)
3374 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3378 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
3380 /* bits 0 and 63 are reserved and must be zero */
3381 if ((mumimo_groups[0] & BIT(0)) ||
3382 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
3385 params->vht_mumimo_groups = mumimo_groups;
3389 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
3390 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3392 if (type != NL80211_IFTYPE_MONITOR)
3395 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3398 params->vht_mumimo_follow_addr =
3399 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
3403 return change ? 1 : 0;
3406 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
3407 struct net_device *netdev, u8 use_4addr,
3408 enum nl80211_iftype iftype)
3411 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
3417 case NL80211_IFTYPE_AP_VLAN:
3418 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
3421 case NL80211_IFTYPE_STATION:
3422 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
3432 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
3434 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3435 struct vif_params params;
3437 enum nl80211_iftype otype, ntype;
3438 struct net_device *dev = info->user_ptr[1];
3439 bool change = false;
3441 memset(¶ms, 0, sizeof(params));
3443 otype = ntype = dev->ieee80211_ptr->iftype;
3445 if (info->attrs[NL80211_ATTR_IFTYPE]) {
3446 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3451 if (info->attrs[NL80211_ATTR_MESH_ID]) {
3452 struct wireless_dev *wdev = dev->ieee80211_ptr;
3454 if (ntype != NL80211_IFTYPE_MESH_POINT)
3456 if (netif_running(dev))
3460 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3461 IEEE80211_MAX_MESH_ID_LEN);
3462 wdev->mesh_id_up_len =
3463 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3464 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3465 wdev->mesh_id_up_len);
3469 if (info->attrs[NL80211_ATTR_4ADDR]) {
3470 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3472 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
3476 params.use_4addr = -1;
3479 err = nl80211_parse_mon_options(rdev, ntype, info, ¶ms);
3486 err = cfg80211_change_iface(rdev, dev, ntype, ¶ms);
3490 if (!err && params.use_4addr != -1)
3491 dev->ieee80211_ptr->use_4addr = params.use_4addr;
3493 if (change && !err) {
3494 struct wireless_dev *wdev = dev->ieee80211_ptr;
3496 nl80211_notify_iface(rdev, wdev, NL80211_CMD_SET_INTERFACE);
3502 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
3504 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3505 struct vif_params params;
3506 struct wireless_dev *wdev;
3507 struct sk_buff *msg;
3509 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
3511 /* to avoid failing a new interface creation due to pending removal */
3512 cfg80211_destroy_ifaces(rdev);
3514 memset(¶ms, 0, sizeof(params));
3516 if (!info->attrs[NL80211_ATTR_IFNAME])
3519 if (info->attrs[NL80211_ATTR_IFTYPE])
3520 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3522 if (!rdev->ops->add_virtual_intf)
3525 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
3526 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
3527 info->attrs[NL80211_ATTR_MAC]) {
3528 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
3530 if (!is_valid_ether_addr(params.macaddr))
3531 return -EADDRNOTAVAIL;
3534 if (info->attrs[NL80211_ATTR_4ADDR]) {
3535 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3536 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
3541 if (!cfg80211_iftype_allowed(&rdev->wiphy, type, params.use_4addr, 0))
3544 err = nl80211_parse_mon_options(rdev, type, info, ¶ms);
3548 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3552 wdev = rdev_add_virtual_intf(rdev,
3553 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
3554 NET_NAME_USER, type, ¶ms);
3555 if (WARN_ON(!wdev)) {
3558 } else if (IS_ERR(wdev)) {
3560 return PTR_ERR(wdev);
3563 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
3564 wdev->owner_nlportid = info->snd_portid;
3567 case NL80211_IFTYPE_MESH_POINT:
3568 if (!info->attrs[NL80211_ATTR_MESH_ID])
3571 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3572 IEEE80211_MAX_MESH_ID_LEN);
3573 wdev->mesh_id_up_len =
3574 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3575 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3576 wdev->mesh_id_up_len);
3579 case NL80211_IFTYPE_NAN:
3580 case NL80211_IFTYPE_P2P_DEVICE:
3582 * P2P Device and NAN do not have a netdev, so don't go
3583 * through the netdev notifier and must be added here
3585 cfg80211_init_wdev(rdev, wdev);
3591 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3592 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3597 return genlmsg_reply(msg, info);
3600 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3602 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3603 struct wireless_dev *wdev = info->user_ptr[1];
3605 if (!rdev->ops->del_virtual_intf)
3609 * If we remove a wireless device without a netdev then clear
3610 * user_ptr[1] so that nl80211_post_doit won't dereference it
3611 * to check if it needs to do dev_put(). Otherwise it crashes
3612 * since the wdev has been freed, unlike with a netdev where
3613 * we need the dev_put() for the netdev to really be freed.
3616 info->user_ptr[1] = NULL;
3618 return rdev_del_virtual_intf(rdev, wdev);
3621 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3623 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3624 struct net_device *dev = info->user_ptr[1];
3627 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3630 if (!rdev->ops->set_noack_map)
3633 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3635 return rdev_set_noack_map(rdev, dev, noack_map);
3638 struct get_key_cookie {
3639 struct sk_buff *msg;
3644 static void get_key_callback(void *c, struct key_params *params)
3647 struct get_key_cookie *cookie = c;
3650 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3651 params->key_len, params->key)) ||
3653 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3654 params->seq_len, params->seq)) ||
3656 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3658 goto nla_put_failure;
3660 key = nla_nest_start_noflag(cookie->msg, NL80211_ATTR_KEY);
3662 goto nla_put_failure;
3665 nla_put(cookie->msg, NL80211_KEY_DATA,
3666 params->key_len, params->key)) ||
3668 nla_put(cookie->msg, NL80211_KEY_SEQ,
3669 params->seq_len, params->seq)) ||
3671 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3673 goto nla_put_failure;
3675 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
3676 goto nla_put_failure;
3678 nla_nest_end(cookie->msg, key);
3685 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3687 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3689 struct net_device *dev = info->user_ptr[1];
3691 const u8 *mac_addr = NULL;
3693 struct get_key_cookie cookie = {
3697 struct sk_buff *msg;
3699 if (info->attrs[NL80211_ATTR_KEY_IDX])
3700 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3702 if (info->attrs[NL80211_ATTR_MAC])
3703 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3705 pairwise = !!mac_addr;
3706 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3707 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
3709 if (kt != NL80211_KEYTYPE_GROUP &&
3710 kt != NL80211_KEYTYPE_PAIRWISE)
3712 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3715 if (!rdev->ops->get_key)
3718 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3721 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3725 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
3726 NL80211_CMD_NEW_KEY);
3728 goto nla_put_failure;
3731 cookie.idx = key_idx;
3733 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3734 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3735 goto nla_put_failure;
3737 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3738 goto nla_put_failure;
3740 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3747 goto nla_put_failure;
3749 genlmsg_end(msg, hdr);
3750 return genlmsg_reply(msg, info);
3759 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3761 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3762 struct key_parse key;
3764 struct net_device *dev = info->user_ptr[1];
3766 err = nl80211_parse_key(info, &key);
3773 /* Only support setting default key and
3774 * Extended Key ID action NL80211_KEY_SET_TX.
3776 if (!key.def && !key.defmgmt &&
3777 !(key.p.mode == NL80211_KEY_SET_TX))
3780 wdev_lock(dev->ieee80211_ptr);
3783 if (!rdev->ops->set_default_key) {
3788 err = nl80211_key_allowed(dev->ieee80211_ptr);
3792 err = rdev_set_default_key(rdev, dev, key.idx,
3793 key.def_uni, key.def_multi);
3798 #ifdef CONFIG_CFG80211_WEXT
3799 dev->ieee80211_ptr->wext.default_key = key.idx;
3801 } else if (key.defmgmt) {
3802 if (key.def_uni || !key.def_multi) {
3807 if (!rdev->ops->set_default_mgmt_key) {
3812 err = nl80211_key_allowed(dev->ieee80211_ptr);
3816 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
3820 #ifdef CONFIG_CFG80211_WEXT
3821 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
3823 } else if (key.p.mode == NL80211_KEY_SET_TX &&
3824 wiphy_ext_feature_isset(&rdev->wiphy,
3825 NL80211_EXT_FEATURE_EXT_KEY_ID)) {
3826 u8 *mac_addr = NULL;
3828 if (info->attrs[NL80211_ATTR_MAC])
3829 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3831 if (!mac_addr || key.idx < 0 || key.idx > 1) {
3836 err = rdev_add_key(rdev, dev, key.idx,
3837 NL80211_KEYTYPE_PAIRWISE,
3843 wdev_unlock(dev->ieee80211_ptr);
3848 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
3850 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3852 struct net_device *dev = info->user_ptr[1];
3853 struct key_parse key;
3854 const u8 *mac_addr = NULL;
3856 err = nl80211_parse_key(info, &key);
3863 if (info->attrs[NL80211_ATTR_MAC])
3864 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3866 if (key.type == -1) {
3868 key.type = NL80211_KEYTYPE_PAIRWISE;
3870 key.type = NL80211_KEYTYPE_GROUP;
3874 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3875 key.type != NL80211_KEYTYPE_GROUP)
3878 if (!rdev->ops->add_key)
3881 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3882 key.type == NL80211_KEYTYPE_PAIRWISE,
3886 wdev_lock(dev->ieee80211_ptr);
3887 err = nl80211_key_allowed(dev->ieee80211_ptr);
3889 err = rdev_add_key(rdev, dev, key.idx,
3890 key.type == NL80211_KEYTYPE_PAIRWISE,
3892 wdev_unlock(dev->ieee80211_ptr);
3897 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3899 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3901 struct net_device *dev = info->user_ptr[1];
3902 u8 *mac_addr = NULL;
3903 struct key_parse key;
3905 err = nl80211_parse_key(info, &key);
3909 if (info->attrs[NL80211_ATTR_MAC])
3910 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3912 if (key.type == -1) {
3914 key.type = NL80211_KEYTYPE_PAIRWISE;
3916 key.type = NL80211_KEYTYPE_GROUP;
3920 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3921 key.type != NL80211_KEYTYPE_GROUP)
3924 if (!rdev->ops->del_key)
3927 wdev_lock(dev->ieee80211_ptr);
3928 err = nl80211_key_allowed(dev->ieee80211_ptr);
3930 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
3931 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3935 err = rdev_del_key(rdev, dev, key.idx,
3936 key.type == NL80211_KEYTYPE_PAIRWISE,
3939 #ifdef CONFIG_CFG80211_WEXT
3941 if (key.idx == dev->ieee80211_ptr->wext.default_key)
3942 dev->ieee80211_ptr->wext.default_key = -1;
3943 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
3944 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3947 wdev_unlock(dev->ieee80211_ptr);
3952 /* This function returns an error or the number of nested attributes */
3953 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3955 struct nlattr *attr;
3956 int n_entries = 0, tmp;
3958 nla_for_each_nested(attr, nl_attr, tmp) {
3959 if (nla_len(attr) != ETH_ALEN)
3969 * This function parses ACL information and allocates memory for ACL data.
3970 * On successful return, the calling function is responsible to free the
3971 * ACL buffer returned by this function.
3973 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3974 struct genl_info *info)
3976 enum nl80211_acl_policy acl_policy;
3977 struct nlattr *attr;
3978 struct cfg80211_acl_data *acl;
3979 int i = 0, n_entries, tmp;
3981 if (!wiphy->max_acl_mac_addrs)
3982 return ERR_PTR(-EOPNOTSUPP);
3984 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3985 return ERR_PTR(-EINVAL);
3987 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3988 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3989 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3990 return ERR_PTR(-EINVAL);
3992 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3993 return ERR_PTR(-EINVAL);
3995 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3997 return ERR_PTR(n_entries);
3999 if (n_entries > wiphy->max_acl_mac_addrs)
4000 return ERR_PTR(-ENOTSUPP);
4002 acl = kzalloc(struct_size(acl, mac_addrs, n_entries), GFP_KERNEL);
4004 return ERR_PTR(-ENOMEM);
4006 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
4007 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
4011 acl->n_acl_entries = n_entries;
4012 acl->acl_policy = acl_policy;
4017 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
4019 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4020 struct net_device *dev = info->user_ptr[1];
4021 struct cfg80211_acl_data *acl;
4024 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4025 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4028 if (!dev->ieee80211_ptr->beacon_interval)
4031 acl = parse_acl_data(&rdev->wiphy, info);
4033 return PTR_ERR(acl);
4035 err = rdev_set_mac_acl(rdev, dev, acl);
4042 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
4043 u8 *rates, u8 rates_len)
4048 for (i = 0; i < rates_len; i++) {
4049 int rate = (rates[i] & 0x7f) * 5;
4052 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
4053 struct ieee80211_rate *srate =
4054 &sband->bitrates[ridx];
4055 if (rate == srate->bitrate) {
4060 if (ridx == sband->n_bitrates)
4061 return 0; /* rate not found */
4067 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
4068 u8 *rates, u8 rates_len,
4069 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
4073 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
4075 for (i = 0; i < rates_len; i++) {
4078 ridx = rates[i] / 8;
4079 rbit = BIT(rates[i] % 8);
4081 /* check validity */
4082 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
4085 /* check availability */
4086 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN);
4087 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
4096 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
4100 switch (vht_mcs_map) {
4101 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
4103 case IEEE80211_VHT_MCS_SUPPORT_0_7:
4106 case IEEE80211_VHT_MCS_SUPPORT_0_8:
4109 case IEEE80211_VHT_MCS_SUPPORT_0_9:
4119 static void vht_build_mcs_mask(u16 vht_mcs_map,
4120 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
4124 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
4125 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
4130 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
4131 struct nl80211_txrate_vht *txrate,
4132 u16 mcs[NL80211_VHT_NSS_MAX])
4134 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4135 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
4138 if (!sband->vht_cap.vht_supported)
4141 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
4143 /* Build vht_mcs_mask from VHT capabilities */
4144 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
4146 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4147 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
4148 mcs[i] = txrate->mcs[i];
4156 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
4157 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
4158 .len = NL80211_MAX_SUPP_RATES },
4159 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
4160 .len = NL80211_MAX_SUPP_HT_RATES },
4161 [NL80211_TXRATE_VHT] = {
4162 .type = NLA_EXACT_LEN_WARN,
4163 .len = sizeof(struct nl80211_txrate_vht),
4165 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
4168 static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
4169 struct cfg80211_bitrate_mask *mask)
4171 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
4172 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4174 struct nlattr *tx_rates;
4175 struct ieee80211_supported_band *sband;
4178 memset(mask, 0, sizeof(*mask));
4179 /* Default to all rates enabled */
4180 for (i = 0; i < NUM_NL80211_BANDS; i++) {
4181 sband = rdev->wiphy.bands[i];
4186 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
4187 memcpy(mask->control[i].ht_mcs,
4188 sband->ht_cap.mcs.rx_mask,
4189 sizeof(mask->control[i].ht_mcs));
4191 if (!sband->vht_cap.vht_supported)
4194 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4195 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
4198 /* if no rates are given set it back to the defaults */
4199 if (!info->attrs[NL80211_ATTR_TX_RATES])
4202 /* The nested attribute uses enum nl80211_band as the index. This maps
4203 * directly to the enum nl80211_band values used in cfg80211.
4205 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
4206 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
4207 enum nl80211_band band = nla_type(tx_rates);
4210 if (band < 0 || band >= NUM_NL80211_BANDS)
4212 sband = rdev->wiphy.bands[band];
4215 err = nla_parse_nested_deprecated(tb, NL80211_TXRATE_MAX,
4217 nl80211_txattr_policy,
4221 if (tb[NL80211_TXRATE_LEGACY]) {
4222 mask->control[band].legacy = rateset_to_mask(
4224 nla_data(tb[NL80211_TXRATE_LEGACY]),
4225 nla_len(tb[NL80211_TXRATE_LEGACY]));
4226 if ((mask->control[band].legacy == 0) &&
4227 nla_len(tb[NL80211_TXRATE_LEGACY]))
4230 if (tb[NL80211_TXRATE_HT]) {
4231 if (!ht_rateset_to_mask(
4233 nla_data(tb[NL80211_TXRATE_HT]),
4234 nla_len(tb[NL80211_TXRATE_HT]),
4235 mask->control[band].ht_mcs))
4238 if (tb[NL80211_TXRATE_VHT]) {
4239 if (!vht_set_mcs_mask(
4241 nla_data(tb[NL80211_TXRATE_VHT]),
4242 mask->control[band].vht_mcs))
4245 if (tb[NL80211_TXRATE_GI]) {
4246 mask->control[band].gi =
4247 nla_get_u8(tb[NL80211_TXRATE_GI]);
4248 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
4252 if (mask->control[band].legacy == 0) {
4253 /* don't allow empty legacy rates if HT or VHT
4254 * are not even supported.
4256 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
4257 rdev->wiphy.bands[band]->vht_cap.vht_supported))
4260 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4261 if (mask->control[band].ht_mcs[i])
4264 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4265 if (mask->control[band].vht_mcs[i])
4268 /* legacy and mcs rates may not be both empty */
4277 static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
4278 enum nl80211_band band,
4279 struct cfg80211_bitrate_mask *beacon_rate)
4281 u32 count_ht, count_vht, i;
4282 u32 rate = beacon_rate->control[band].legacy;
4284 /* Allow only one rate */
4285 if (hweight32(rate) > 1)
4289 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4290 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
4292 } else if (beacon_rate->control[band].ht_mcs[i]) {
4297 if (count_ht && rate)
4302 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4303 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
4305 } else if (beacon_rate->control[band].vht_mcs[i]) {
4310 if (count_vht && rate)
4314 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
4318 !wiphy_ext_feature_isset(&rdev->wiphy,
4319 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
4322 !wiphy_ext_feature_isset(&rdev->wiphy,
4323 NL80211_EXT_FEATURE_BEACON_RATE_HT))
4326 !wiphy_ext_feature_isset(&rdev->wiphy,
4327 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
4333 static int nl80211_parse_beacon(struct cfg80211_registered_device *rdev,
4334 struct nlattr *attrs[],
4335 struct cfg80211_beacon_data *bcn)
4337 bool haveinfo = false;
4340 memset(bcn, 0, sizeof(*bcn));
4342 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
4343 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
4344 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
4350 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
4351 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
4352 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
4359 if (attrs[NL80211_ATTR_IE]) {
4360 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
4361 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
4364 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
4365 bcn->proberesp_ies =
4366 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
4367 bcn->proberesp_ies_len =
4368 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
4371 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
4372 bcn->assocresp_ies =
4373 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
4374 bcn->assocresp_ies_len =
4375 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
4378 if (attrs[NL80211_ATTR_PROBE_RESP]) {
4379 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
4380 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
4383 if (attrs[NL80211_ATTR_FTM_RESPONDER]) {
4384 struct nlattr *tb[NL80211_FTM_RESP_ATTR_MAX + 1];
4386 err = nla_parse_nested_deprecated(tb,
4387 NL80211_FTM_RESP_ATTR_MAX,
4388 attrs[NL80211_ATTR_FTM_RESPONDER],
4393 if (tb[NL80211_FTM_RESP_ATTR_ENABLED] &&
4394 wiphy_ext_feature_isset(&rdev->wiphy,
4395 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
4396 bcn->ftm_responder = 1;
4400 if (tb[NL80211_FTM_RESP_ATTR_LCI]) {
4401 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]);
4402 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]);
4405 if (tb[NL80211_FTM_RESP_ATTR_CIVICLOC]) {
4406 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
4407 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
4410 bcn->ftm_responder = -1;
4416 static int nl80211_parse_he_obss_pd(struct nlattr *attrs,
4417 struct ieee80211_he_obss_pd *he_obss_pd)
4419 struct nlattr *tb[NL80211_HE_OBSS_PD_ATTR_MAX + 1];
4422 err = nla_parse_nested(tb, NL80211_HE_OBSS_PD_ATTR_MAX, attrs,
4423 he_obss_pd_policy, NULL);
4427 if (!tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET] ||
4428 !tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET])
4431 he_obss_pd->min_offset =
4432 nla_get_u32(tb[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET]);
4433 he_obss_pd->max_offset =
4434 nla_get_u32(tb[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET]);
4436 if (he_obss_pd->min_offset >= he_obss_pd->max_offset)
4439 he_obss_pd->enable = true;
4444 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
4452 for (i = 0; i < rates[1]; i++) {
4453 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
4454 params->ht_required = true;
4455 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
4456 params->vht_required = true;
4461 * Since the nl80211 API didn't include, from the beginning, attributes about
4462 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
4463 * benefit of drivers that rebuild IEs in the firmware.
4465 static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
4467 const struct cfg80211_beacon_data *bcn = ¶ms->beacon;
4468 size_t ies_len = bcn->tail_len;
4469 const u8 *ies = bcn->tail;
4473 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
4474 nl80211_check_ap_rate_selectors(params, rates);
4476 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
4477 nl80211_check_ap_rate_selectors(params, rates);
4479 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
4480 if (cap && cap[1] >= sizeof(*params->ht_cap))
4481 params->ht_cap = (void *)(cap + 2);
4482 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
4483 if (cap && cap[1] >= sizeof(*params->vht_cap))
4484 params->vht_cap = (void *)(cap + 2);
4485 cap = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY, ies, ies_len);
4486 if (cap && cap[1] >= sizeof(*params->he_cap) + 1)
4487 params->he_cap = (void *)(cap + 3);
4490 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
4491 struct cfg80211_ap_settings *params)
4493 struct wireless_dev *wdev;
4496 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4497 if (wdev->iftype != NL80211_IFTYPE_AP &&
4498 wdev->iftype != NL80211_IFTYPE_P2P_GO)
4501 if (!wdev->preset_chandef.chan)
4504 params->chandef = wdev->preset_chandef;
4512 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
4513 enum nl80211_auth_type auth_type,
4514 enum nl80211_commands cmd)
4516 if (auth_type > NL80211_AUTHTYPE_MAX)
4520 case NL80211_CMD_AUTHENTICATE:
4521 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
4522 auth_type == NL80211_AUTHTYPE_SAE)
4524 if (!wiphy_ext_feature_isset(&rdev->wiphy,
4525 NL80211_EXT_FEATURE_FILS_STA) &&
4526 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
4527 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4528 auth_type == NL80211_AUTHTYPE_FILS_PK))
4531 case NL80211_CMD_CONNECT:
4532 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
4533 !wiphy_ext_feature_isset(&rdev->wiphy,
4534 NL80211_EXT_FEATURE_SAE_OFFLOAD) &&
4535 auth_type == NL80211_AUTHTYPE_SAE)
4538 /* FILS with SK PFS or PK not supported yet */
4539 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4540 auth_type == NL80211_AUTHTYPE_FILS_PK)
4542 if (!wiphy_ext_feature_isset(
4544 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
4545 auth_type == NL80211_AUTHTYPE_FILS_SK)
4548 case NL80211_CMD_START_AP:
4549 /* SAE not supported yet */
4550 if (auth_type == NL80211_AUTHTYPE_SAE)
4552 /* FILS not supported yet */
4553 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
4554 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4555 auth_type == NL80211_AUTHTYPE_FILS_PK)
4563 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
4565 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4566 struct net_device *dev = info->user_ptr[1];
4567 struct wireless_dev *wdev = dev->ieee80211_ptr;
4568 struct cfg80211_ap_settings params;
4571 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4572 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4575 if (!rdev->ops->start_ap)
4578 if (wdev->beacon_interval)
4581 memset(¶ms, 0, sizeof(params));
4583 /* these are required for START_AP */
4584 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
4585 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
4586 !info->attrs[NL80211_ATTR_BEACON_HEAD])
4589 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon);
4593 params.beacon_interval =
4594 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
4595 params.dtim_period =
4596 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
4598 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
4599 params.beacon_interval);
4604 * In theory, some of these attributes should be required here
4605 * but since they were not used when the command was originally
4606 * added, keep them optional for old user space programs to let
4607 * them continue to work with drivers that do not need the
4608 * additional information -- drivers must check!
4610 if (info->attrs[NL80211_ATTR_SSID]) {
4611 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4613 nla_len(info->attrs[NL80211_ATTR_SSID]);
4614 if (params.ssid_len == 0 ||
4615 params.ssid_len > IEEE80211_MAX_SSID_LEN)
4619 if (info->attrs[NL80211_ATTR_HIDDEN_SSID])
4620 params.hidden_ssid = nla_get_u32(
4621 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
4623 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
4625 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
4626 params.auth_type = nla_get_u32(
4627 info->attrs[NL80211_ATTR_AUTH_TYPE]);
4628 if (!nl80211_valid_auth_type(rdev, params.auth_type,
4629 NL80211_CMD_START_AP))
4632 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
4634 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
4635 NL80211_MAX_NR_CIPHER_SUITES);
4639 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
4640 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
4642 params.inactivity_timeout = nla_get_u16(
4643 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
4646 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4647 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4649 params.p2p_ctwindow =
4650 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4651 if (params.p2p_ctwindow != 0 &&
4652 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4656 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4659 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4661 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4662 params.p2p_opp_ps = tmp;
4663 if (params.p2p_opp_ps != 0 &&
4664 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4668 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
4669 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
4672 } else if (wdev->preset_chandef.chan) {
4673 params.chandef = wdev->preset_chandef;
4674 } else if (!nl80211_get_ap_channel(rdev, ¶ms))
4677 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
4681 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4682 err = nl80211_parse_tx_bitrate_mask(info, ¶ms.beacon_rate);
4686 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4687 ¶ms.beacon_rate);
4692 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4694 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4695 switch (params.smps_mode) {
4696 case NL80211_SMPS_OFF:
4698 case NL80211_SMPS_STATIC:
4699 if (!(rdev->wiphy.features &
4700 NL80211_FEATURE_STATIC_SMPS))
4703 case NL80211_SMPS_DYNAMIC:
4704 if (!(rdev->wiphy.features &
4705 NL80211_FEATURE_DYNAMIC_SMPS))
4712 params.smps_mode = NL80211_SMPS_OFF;
4715 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4716 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4719 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4720 params.acl = parse_acl_data(&rdev->wiphy, info);
4721 if (IS_ERR(params.acl))
4722 return PTR_ERR(params.acl);
4725 params.twt_responder =
4726 nla_get_flag(info->attrs[NL80211_ATTR_TWT_RESPONDER]);
4728 if (info->attrs[NL80211_ATTR_HE_OBSS_PD]) {
4729 err = nl80211_parse_he_obss_pd(
4730 info->attrs[NL80211_ATTR_HE_OBSS_PD],
4731 ¶ms.he_obss_pd);
4736 nl80211_calculate_ap_params(¶ms);
4738 if (info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])
4739 params.flags |= AP_SETTINGS_EXTERNAL_AUTH_SUPPORT;
4742 err = rdev_start_ap(rdev, dev, ¶ms);
4744 wdev->preset_chandef = params.chandef;
4745 wdev->beacon_interval = params.beacon_interval;
4746 wdev->chandef = params.chandef;
4747 wdev->ssid_len = params.ssid_len;
4748 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
4750 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
4751 wdev->conn_owner_nlportid = info->snd_portid;
4760 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
4762 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4763 struct net_device *dev = info->user_ptr[1];
4764 struct wireless_dev *wdev = dev->ieee80211_ptr;
4765 struct cfg80211_beacon_data params;
4768 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4769 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4772 if (!rdev->ops->change_beacon)
4775 if (!wdev->beacon_interval)
4778 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms);
4783 err = rdev_change_beacon(rdev, dev, ¶ms);
4789 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
4791 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4792 struct net_device *dev = info->user_ptr[1];
4794 return cfg80211_stop_ap(rdev, dev, false);
4797 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
4798 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
4799 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
4800 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
4801 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
4802 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
4803 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
4806 static int parse_station_flags(struct genl_info *info,
4807 enum nl80211_iftype iftype,
4808 struct station_parameters *params)
4810 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
4815 * Try parsing the new attribute first so userspace
4816 * can specify both for older kernels.
4818 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
4820 struct nl80211_sta_flag_update *sta_flags;
4822 sta_flags = nla_data(nla);
4823 params->sta_flags_mask = sta_flags->mask;
4824 params->sta_flags_set = sta_flags->set;
4825 params->sta_flags_set &= params->sta_flags_mask;
4826 if ((params->sta_flags_mask |
4827 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
4832 /* if present, parse the old attribute */
4834 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
4838 if (nla_parse_nested_deprecated(flags, NL80211_STA_FLAG_MAX, nla, sta_flags_policy, info->extack))
4842 * Only allow certain flags for interface types so that
4843 * other attributes are silently ignored. Remember that
4844 * this is backward compatibility code with old userspace
4845 * and shouldn't be hit in other cases anyway.
4848 case NL80211_IFTYPE_AP:
4849 case NL80211_IFTYPE_AP_VLAN:
4850 case NL80211_IFTYPE_P2P_GO:
4851 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4852 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4853 BIT(NL80211_STA_FLAG_WME) |
4854 BIT(NL80211_STA_FLAG_MFP);
4856 case NL80211_IFTYPE_P2P_CLIENT:
4857 case NL80211_IFTYPE_STATION:
4858 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4859 BIT(NL80211_STA_FLAG_TDLS_PEER);
4861 case NL80211_IFTYPE_MESH_POINT:
4862 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4863 BIT(NL80211_STA_FLAG_MFP) |
4864 BIT(NL80211_STA_FLAG_AUTHORIZED);
4870 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
4872 params->sta_flags_set |= (1<<flag);
4874 /* no longer support new API additions in old API */
4875 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
4883 bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info, int attr)
4885 struct nlattr *rate;
4888 enum nl80211_rate_info rate_flg;
4890 rate = nla_nest_start_noflag(msg, attr);
4894 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
4895 bitrate = cfg80211_calculate_bitrate(info);
4896 /* report 16-bit bitrate only if we can */
4897 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
4899 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
4901 if (bitrate_compat > 0 &&
4902 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
4906 case RATE_INFO_BW_5:
4907 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
4909 case RATE_INFO_BW_10:
4910 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
4915 case RATE_INFO_BW_20:
4918 case RATE_INFO_BW_40:
4919 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
4921 case RATE_INFO_BW_80:
4922 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
4924 case RATE_INFO_BW_160:
4925 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
4927 case RATE_INFO_BW_HE_RU:
4929 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS));
4932 if (rate_flg && nla_put_flag(msg, rate_flg))
4935 if (info->flags & RATE_INFO_FLAGS_MCS) {
4936 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
4938 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4939 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4941 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
4942 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
4944 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
4946 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4947 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4949 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) {
4950 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs))
4952 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss))
4954 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi))
4956 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm))
4958 if (info->bw == RATE_INFO_BW_HE_RU &&
4959 nla_put_u8(msg, NL80211_RATE_INFO_HE_RU_ALLOC,
4964 nla_nest_end(msg, rate);
4968 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
4977 attr = nla_nest_start_noflag(msg, id);
4981 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
4982 if (!(mask & BIT(i)))
4985 if (nla_put_u8(msg, i, signal[i]))
4989 nla_nest_end(msg, attr);
4994 static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
4996 struct cfg80211_registered_device *rdev,
4997 struct net_device *dev,
4998 const u8 *mac_addr, struct station_info *sinfo)
5001 struct nlattr *sinfoattr, *bss_param;
5003 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
5005 cfg80211_sinfo_release_content(sinfo);
5009 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5010 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
5011 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
5012 goto nla_put_failure;
5014 sinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_STA_INFO);
5016 goto nla_put_failure;
5018 #define PUT_SINFO(attr, memb, type) do { \
5019 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
5020 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5021 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
5023 goto nla_put_failure; \
5025 #define PUT_SINFO_U64(attr, memb) do { \
5026 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5027 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
5028 sinfo->memb, NL80211_STA_INFO_PAD)) \
5029 goto nla_put_failure; \
5032 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
5033 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
5035 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
5036 BIT_ULL(NL80211_STA_INFO_RX_BYTES64)) &&
5037 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
5038 (u32)sinfo->rx_bytes))
5039 goto nla_put_failure;
5041 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
5042 BIT_ULL(NL80211_STA_INFO_TX_BYTES64)) &&
5043 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
5044 (u32)sinfo->tx_bytes))
5045 goto nla_put_failure;
5047 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
5048 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
5049 PUT_SINFO(LLID, llid, u16);
5050 PUT_SINFO(PLID, plid, u16);
5051 PUT_SINFO(PLINK_STATE, plink_state, u8);
5052 PUT_SINFO_U64(RX_DURATION, rx_duration);
5053 PUT_SINFO_U64(TX_DURATION, tx_duration);
5055 if (wiphy_ext_feature_isset(&rdev->wiphy,
5056 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
5057 PUT_SINFO(AIRTIME_WEIGHT, airtime_weight, u16);
5059 switch (rdev->wiphy.signal_type) {
5060 case CFG80211_SIGNAL_TYPE_MBM:
5061 PUT_SINFO(SIGNAL, signal, u8);
5062 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
5067 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
5068 if (!nl80211_put_signal(msg, sinfo->chains,
5069 sinfo->chain_signal,
5070 NL80211_STA_INFO_CHAIN_SIGNAL))
5071 goto nla_put_failure;
5073 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
5074 if (!nl80211_put_signal(msg, sinfo->chains,
5075 sinfo->chain_signal_avg,
5076 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
5077 goto nla_put_failure;
5079 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
5080 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
5081 NL80211_STA_INFO_TX_BITRATE))
5082 goto nla_put_failure;
5084 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
5085 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
5086 NL80211_STA_INFO_RX_BITRATE))
5087 goto nla_put_failure;
5090 PUT_SINFO(RX_PACKETS, rx_packets, u32);
5091 PUT_SINFO(TX_PACKETS, tx_packets, u32);
5092 PUT_SINFO(TX_RETRIES, tx_retries, u32);
5093 PUT_SINFO(TX_FAILED, tx_failed, u32);
5094 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
5095 PUT_SINFO(AIRTIME_LINK_METRIC, airtime_link_metric, u32);
5096 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
5097 PUT_SINFO(LOCAL_PM, local_pm, u32);
5098 PUT_SINFO(PEER_PM, peer_pm, u32);
5099 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
5100 PUT_SINFO(CONNECTED_TO_GATE, connected_to_gate, u8);
5102 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
5103 bss_param = nla_nest_start_noflag(msg,
5104 NL80211_STA_INFO_BSS_PARAM);
5106 goto nla_put_failure;
5108 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
5109 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
5110 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
5111 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
5112 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
5113 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
5114 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
5115 sinfo->bss_param.dtim_period) ||
5116 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
5117 sinfo->bss_param.beacon_interval))
5118 goto nla_put_failure;
5120 nla_nest_end(msg, bss_param);
5122 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) &&
5123 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
5124 sizeof(struct nl80211_sta_flag_update),
5126 goto nla_put_failure;
5128 PUT_SINFO_U64(T_OFFSET, t_offset);
5129 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
5130 PUT_SINFO_U64(BEACON_RX, rx_beacon);
5131 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
5132 PUT_SINFO(RX_MPDUS, rx_mpdu_count, u32);
5133 PUT_SINFO(FCS_ERROR_COUNT, fcs_err_count, u32);
5134 if (wiphy_ext_feature_isset(&rdev->wiphy,
5135 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT)) {
5136 PUT_SINFO(ACK_SIGNAL, ack_signal, u8);
5137 PUT_SINFO(ACK_SIGNAL_AVG, avg_ack_signal, s8);
5141 #undef PUT_SINFO_U64
5143 if (sinfo->pertid) {
5144 struct nlattr *tidsattr;
5147 tidsattr = nla_nest_start_noflag(msg,
5148 NL80211_STA_INFO_TID_STATS);
5150 goto nla_put_failure;
5152 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
5153 struct cfg80211_tid_stats *tidstats;
5154 struct nlattr *tidattr;
5156 tidstats = &sinfo->pertid[tid];
5158 if (!tidstats->filled)
5161 tidattr = nla_nest_start_noflag(msg, tid + 1);
5163 goto nla_put_failure;
5165 #define PUT_TIDVAL_U64(attr, memb) do { \
5166 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
5167 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
5168 tidstats->memb, NL80211_TID_STATS_PAD)) \
5169 goto nla_put_failure; \
5172 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
5173 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
5174 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
5175 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
5177 #undef PUT_TIDVAL_U64
5178 if ((tidstats->filled &
5179 BIT(NL80211_TID_STATS_TXQ_STATS)) &&
5180 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
5181 NL80211_TID_STATS_TXQ_STATS))
5182 goto nla_put_failure;
5184 nla_nest_end(msg, tidattr);
5187 nla_nest_end(msg, tidsattr);
5190 nla_nest_end(msg, sinfoattr);
5192 if (sinfo->assoc_req_ies_len &&
5193 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
5194 sinfo->assoc_req_ies))
5195 goto nla_put_failure;
5197 cfg80211_sinfo_release_content(sinfo);
5198 genlmsg_end(msg, hdr);
5202 cfg80211_sinfo_release_content(sinfo);
5203 genlmsg_cancel(msg, hdr);
5207 static int nl80211_dump_station(struct sk_buff *skb,
5208 struct netlink_callback *cb)
5210 struct station_info sinfo;
5211 struct cfg80211_registered_device *rdev;
5212 struct wireless_dev *wdev;
5213 u8 mac_addr[ETH_ALEN];
5214 int sta_idx = cb->args[2];
5218 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
5222 if (!wdev->netdev) {
5227 if (!rdev->ops->dump_station) {
5233 memset(&sinfo, 0, sizeof(sinfo));
5234 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
5241 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
5242 NETLINK_CB(cb->skb).portid,
5243 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5244 rdev, wdev->netdev, mac_addr,
5252 cb->args[2] = sta_idx;
5260 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
5262 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5263 struct net_device *dev = info->user_ptr[1];
5264 struct station_info sinfo;
5265 struct sk_buff *msg;
5266 u8 *mac_addr = NULL;
5269 memset(&sinfo, 0, sizeof(sinfo));
5271 if (!info->attrs[NL80211_ATTR_MAC])
5274 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5276 if (!rdev->ops->get_station)
5279 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
5283 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5285 cfg80211_sinfo_release_content(&sinfo);
5289 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
5290 info->snd_portid, info->snd_seq, 0,
5291 rdev, dev, mac_addr, &sinfo) < 0) {
5296 return genlmsg_reply(msg, info);
5299 int cfg80211_check_station_change(struct wiphy *wiphy,
5300 struct station_parameters *params,
5301 enum cfg80211_station_type statype)
5303 if (params->listen_interval != -1 &&
5304 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5307 if (params->support_p2p_ps != -1 &&
5308 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5312 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
5313 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5316 /* When you run into this, adjust the code below for the new flag */
5317 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5320 case CFG80211_STA_MESH_PEER_KERNEL:
5321 case CFG80211_STA_MESH_PEER_USER:
5323 * No ignoring the TDLS flag here -- the userspace mesh
5324 * code doesn't have the bug of including TDLS in the
5327 if (params->sta_flags_mask &
5328 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5329 BIT(NL80211_STA_FLAG_MFP) |
5330 BIT(NL80211_STA_FLAG_AUTHORIZED)))
5333 case CFG80211_STA_TDLS_PEER_SETUP:
5334 case CFG80211_STA_TDLS_PEER_ACTIVE:
5335 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5337 /* ignore since it can't change */
5338 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5341 /* disallow mesh-specific things */
5342 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
5344 if (params->local_pm)
5346 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
5350 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
5351 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
5352 /* TDLS can't be set, ... */
5353 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
5356 * ... but don't bother the driver with it. This works around
5357 * a hostapd/wpa_supplicant issue -- it always includes the
5358 * TLDS_PEER flag in the mask even for AP mode.
5360 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5363 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
5364 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
5365 /* reject other things that can't change */
5366 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
5368 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
5370 if (params->supported_rates)
5372 if (params->ext_capab || params->ht_capa || params->vht_capa ||
5377 if (statype != CFG80211_STA_AP_CLIENT &&
5378 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
5384 case CFG80211_STA_AP_MLME_CLIENT:
5385 /* Use this only for authorizing/unauthorizing a station */
5386 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
5389 case CFG80211_STA_AP_CLIENT:
5390 case CFG80211_STA_AP_CLIENT_UNASSOC:
5391 /* accept only the listed bits */
5392 if (params->sta_flags_mask &
5393 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
5394 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5395 BIT(NL80211_STA_FLAG_ASSOCIATED) |
5396 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
5397 BIT(NL80211_STA_FLAG_WME) |
5398 BIT(NL80211_STA_FLAG_MFP)))
5401 /* but authenticated/associated only if driver handles it */
5402 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
5403 params->sta_flags_mask &
5404 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5405 BIT(NL80211_STA_FLAG_ASSOCIATED)))
5408 case CFG80211_STA_IBSS:
5409 case CFG80211_STA_AP_STA:
5410 /* reject any changes other than AUTHORIZED */
5411 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
5414 case CFG80211_STA_TDLS_PEER_SETUP:
5415 /* reject any changes other than AUTHORIZED or WME */
5416 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
5417 BIT(NL80211_STA_FLAG_WME)))
5419 /* force (at least) rates when authorizing */
5420 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
5421 !params->supported_rates)
5424 case CFG80211_STA_TDLS_PEER_ACTIVE:
5425 /* reject any changes */
5427 case CFG80211_STA_MESH_PEER_KERNEL:
5428 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
5431 case CFG80211_STA_MESH_PEER_USER:
5432 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
5433 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
5439 * Older kernel versions ignored this attribute entirely, so don't
5440 * reject attempts to update it but mark it as unused instead so the
5441 * driver won't look at the data.
5443 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
5444 statype != CFG80211_STA_TDLS_PEER_SETUP)
5445 params->opmode_notif_used = false;
5449 EXPORT_SYMBOL(cfg80211_check_station_change);
5452 * Get vlan interface making sure it is running and on the right wiphy.
5454 static struct net_device *get_vlan(struct genl_info *info,
5455 struct cfg80211_registered_device *rdev)
5457 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
5458 struct net_device *v;
5464 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
5466 return ERR_PTR(-ENODEV);
5468 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
5473 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5474 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5475 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
5480 if (!netif_running(v)) {
5488 return ERR_PTR(ret);
5491 static const struct nla_policy
5492 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
5493 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
5494 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
5497 static int nl80211_parse_sta_wme(struct genl_info *info,
5498 struct station_parameters *params)
5500 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
5504 /* parse WME attributes if present */
5505 if (!info->attrs[NL80211_ATTR_STA_WME])
5508 nla = info->attrs[NL80211_ATTR_STA_WME];
5509 err = nla_parse_nested_deprecated(tb, NL80211_STA_WME_MAX, nla,
5510 nl80211_sta_wme_policy,
5515 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
5516 params->uapsd_queues = nla_get_u8(
5517 tb[NL80211_STA_WME_UAPSD_QUEUES]);
5518 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
5521 if (tb[NL80211_STA_WME_MAX_SP])
5522 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
5524 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
5527 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
5532 static int nl80211_parse_sta_channel_info(struct genl_info *info,
5533 struct station_parameters *params)
5535 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
5536 params->supported_channels =
5537 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
5538 params->supported_channels_len =
5539 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
5541 * Need to include at least one (first channel, number of
5542 * channels) tuple for each subband, and must have proper
5543 * tuples for the rest of the data as well.
5545 if (params->supported_channels_len < 2)
5547 if (params->supported_channels_len % 2)
5551 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
5552 params->supported_oper_classes =
5553 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
5554 params->supported_oper_classes_len =
5555 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
5557 * The value of the Length field of the Supported Operating
5558 * Classes element is between 2 and 253.
5560 if (params->supported_oper_classes_len < 2 ||
5561 params->supported_oper_classes_len > 253)
5567 static int nl80211_set_station_tdls(struct genl_info *info,
5568 struct station_parameters *params)
5571 /* Dummy STA entry gets updated once the peer capabilities are known */
5572 if (info->attrs[NL80211_ATTR_PEER_AID])
5573 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
5574 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5576 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5577 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5579 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5580 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
5582 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5583 params->he_capa_len =
5584 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5586 if (params->he_capa_len < NL80211_HE_MIN_CAPABILITY_LEN)
5590 err = nl80211_parse_sta_channel_info(info, params);
5594 return nl80211_parse_sta_wme(info, params);
5597 static int nl80211_parse_sta_txpower_setting(struct genl_info *info,
5598 struct station_parameters *params)
5600 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5603 if (info->attrs[NL80211_ATTR_STA_TX_POWER_SETTING]) {
5604 if (!rdev->ops->set_tx_power ||
5605 !wiphy_ext_feature_isset(&rdev->wiphy,
5606 NL80211_EXT_FEATURE_STA_TX_PWR))
5609 idx = NL80211_ATTR_STA_TX_POWER_SETTING;
5610 params->txpwr.type = nla_get_u8(info->attrs[idx]);
5612 if (params->txpwr.type == NL80211_TX_POWER_LIMITED) {
5613 idx = NL80211_ATTR_STA_TX_POWER;
5615 if (info->attrs[idx])
5616 params->txpwr.power =
5617 nla_get_s16(info->attrs[idx]);
5621 params->sta_modify_mask |= STATION_PARAM_APPLY_STA_TXPOWER;
5627 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
5629 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5630 struct net_device *dev = info->user_ptr[1];
5631 struct station_parameters params;
5635 memset(¶ms, 0, sizeof(params));
5637 if (!rdev->ops->change_station)
5641 * AID and listen_interval properties can be set only for unassociated
5642 * station. Include these parameters here and will check them in
5643 * cfg80211_check_station_change().
5645 if (info->attrs[NL80211_ATTR_STA_AID])
5646 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
5648 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5649 params.listen_interval =
5650 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
5652 params.listen_interval = -1;
5654 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS])
5655 params.support_p2p_ps =
5656 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5658 params.support_p2p_ps = -1;
5660 if (!info->attrs[NL80211_ATTR_MAC])
5663 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5665 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
5666 params.supported_rates =
5667 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5668 params.supported_rates_len =
5669 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5672 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5674 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5675 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5678 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5680 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5681 params.ext_capab_len =
5682 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5685 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
5688 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
5689 params.plink_action =
5690 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5692 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
5693 params.plink_state =
5694 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
5695 if (info->attrs[NL80211_ATTR_MESH_PEER_AID])
5696 params.peer_aid = nla_get_u16(
5697 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
5698 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
5701 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE])
5702 params.local_pm = nla_get_u32(
5703 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
5705 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5706 params.opmode_notif_used = true;
5707 params.opmode_notif =
5708 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5711 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
5712 params.airtime_weight =
5713 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
5715 if (params.airtime_weight &&
5716 !wiphy_ext_feature_isset(&rdev->wiphy,
5717 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
5720 err = nl80211_parse_sta_txpower_setting(info, ¶ms);
5724 /* Include parameters for TDLS peer (will check later) */
5725 err = nl80211_set_station_tdls(info, ¶ms);
5729 params.vlan = get_vlan(info, rdev);
5730 if (IS_ERR(params.vlan))
5731 return PTR_ERR(params.vlan);
5733 switch (dev->ieee80211_ptr->iftype) {
5734 case NL80211_IFTYPE_AP:
5735 case NL80211_IFTYPE_AP_VLAN:
5736 case NL80211_IFTYPE_P2P_GO:
5737 case NL80211_IFTYPE_P2P_CLIENT:
5738 case NL80211_IFTYPE_STATION:
5739 case NL80211_IFTYPE_ADHOC:
5740 case NL80211_IFTYPE_MESH_POINT:
5747 /* driver will call cfg80211_check_station_change() */
5748 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
5752 dev_put(params.vlan);
5757 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
5759 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5761 struct net_device *dev = info->user_ptr[1];
5762 struct station_parameters params;
5763 u8 *mac_addr = NULL;
5764 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5765 BIT(NL80211_STA_FLAG_ASSOCIATED);
5767 memset(¶ms, 0, sizeof(params));
5769 if (!rdev->ops->add_station)
5772 if (!info->attrs[NL80211_ATTR_MAC])
5775 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5778 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
5781 if (!info->attrs[NL80211_ATTR_STA_AID] &&
5782 !info->attrs[NL80211_ATTR_PEER_AID])
5785 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5786 params.supported_rates =
5787 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5788 params.supported_rates_len =
5789 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5790 params.listen_interval =
5791 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
5793 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
5794 params.support_p2p_ps =
5795 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5798 * if not specified, assume it's supported for P2P GO interface,
5799 * and is NOT supported for AP interface
5801 params.support_p2p_ps =
5802 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
5805 if (info->attrs[NL80211_ATTR_PEER_AID])
5806 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
5808 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
5810 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5812 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5813 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5816 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5818 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5819 params.ext_capab_len =
5820 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5823 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5825 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5827 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5829 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5831 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
5833 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5834 params.he_capa_len =
5835 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5837 /* max len is validated in nla policy */
5838 if (params.he_capa_len < NL80211_HE_MIN_CAPABILITY_LEN)
5842 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5843 params.opmode_notif_used = true;
5844 params.opmode_notif =
5845 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5848 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
5849 params.plink_action =
5850 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5852 if (info->attrs[NL80211_ATTR_AIRTIME_WEIGHT])
5853 params.airtime_weight =
5854 nla_get_u16(info->attrs[NL80211_ATTR_AIRTIME_WEIGHT]);
5856 if (params.airtime_weight &&
5857 !wiphy_ext_feature_isset(&rdev->wiphy,
5858 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS))
5861 err = nl80211_parse_sta_txpower_setting(info, ¶ms);
5865 err = nl80211_parse_sta_channel_info(info, ¶ms);
5869 err = nl80211_parse_sta_wme(info, ¶ms);
5873 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
5876 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
5877 * as userspace might just pass through the capabilities from the IEs
5878 * directly, rather than enforcing this restriction and returning an
5879 * error in this case.
5881 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
5882 params.ht_capa = NULL;
5883 params.vht_capa = NULL;
5885 /* HE requires WME */
5886 if (params.he_capa_len)
5890 /* When you run into this, adjust the code below for the new flag */
5891 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5893 switch (dev->ieee80211_ptr->iftype) {
5894 case NL80211_IFTYPE_AP:
5895 case NL80211_IFTYPE_AP_VLAN:
5896 case NL80211_IFTYPE_P2P_GO:
5897 /* ignore WME attributes if iface/sta is not capable */
5898 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
5899 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
5900 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5902 /* TDLS peers cannot be added */
5903 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5904 info->attrs[NL80211_ATTR_PEER_AID])
5906 /* but don't bother the driver with it */
5907 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5909 /* allow authenticated/associated only if driver handles it */
5910 if (!(rdev->wiphy.features &
5911 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
5912 params.sta_flags_mask & auth_assoc)
5915 /* Older userspace, or userspace wanting to be compatible with
5916 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
5917 * and assoc flags in the mask, but assumes the station will be
5918 * added as associated anyway since this was the required driver
5919 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
5921 * In order to not bother drivers with this quirk in the API
5922 * set the flags in both the mask and set for new stations in
5925 if (!(params.sta_flags_mask & auth_assoc)) {
5926 params.sta_flags_mask |= auth_assoc;
5927 params.sta_flags_set |= auth_assoc;
5930 /* must be last in here for error handling */
5931 params.vlan = get_vlan(info, rdev);
5932 if (IS_ERR(params.vlan))
5933 return PTR_ERR(params.vlan);
5935 case NL80211_IFTYPE_MESH_POINT:
5936 /* ignore uAPSD data */
5937 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5939 /* associated is disallowed */
5940 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
5942 /* TDLS peers cannot be added */
5943 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5944 info->attrs[NL80211_ATTR_PEER_AID])
5947 case NL80211_IFTYPE_STATION:
5948 case NL80211_IFTYPE_P2P_CLIENT:
5949 /* ignore uAPSD data */
5950 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5952 /* these are disallowed */
5953 if (params.sta_flags_mask &
5954 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
5955 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
5957 /* Only TDLS peers can be added */
5958 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5960 /* Can only add if TDLS ... */
5961 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
5963 /* ... with external setup is supported */
5964 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
5967 * Older wpa_supplicant versions always mark the TDLS peer
5968 * as authorized, but it shouldn't yet be.
5970 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
5976 /* be aware of params.vlan when changing code here */
5978 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
5981 dev_put(params.vlan);
5985 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
5987 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5988 struct net_device *dev = info->user_ptr[1];
5989 struct station_del_parameters params;
5991 memset(¶ms, 0, sizeof(params));
5993 if (info->attrs[NL80211_ATTR_MAC])
5994 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5996 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5997 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5998 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
5999 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6002 if (!rdev->ops->del_station)
6005 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
6007 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
6008 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
6009 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
6012 /* Default to Deauthentication frame */
6013 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
6016 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
6017 params.reason_code =
6018 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6019 if (params.reason_code == 0)
6020 return -EINVAL; /* 0 is reserved */
6022 /* Default to reason code 2 */
6023 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
6026 return rdev_del_station(rdev, dev, ¶ms);
6029 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
6030 int flags, struct net_device *dev,
6031 u8 *dst, u8 *next_hop,
6032 struct mpath_info *pinfo)
6035 struct nlattr *pinfoattr;
6037 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
6041 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6042 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
6043 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
6044 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
6045 goto nla_put_failure;
6047 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MPATH_INFO);
6049 goto nla_put_failure;
6050 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
6051 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
6053 goto nla_put_failure;
6054 if (((pinfo->filled & MPATH_INFO_SN) &&
6055 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
6056 ((pinfo->filled & MPATH_INFO_METRIC) &&
6057 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
6059 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
6060 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
6062 ((pinfo->filled & MPATH_INFO_FLAGS) &&
6063 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
6065 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
6066 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
6067 pinfo->discovery_timeout)) ||
6068 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
6069 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
6070 pinfo->discovery_retries)) ||
6071 ((pinfo->filled & MPATH_INFO_HOP_COUNT) &&
6072 nla_put_u8(msg, NL80211_MPATH_INFO_HOP_COUNT,
6073 pinfo->hop_count)) ||
6074 ((pinfo->filled & MPATH_INFO_PATH_CHANGE) &&
6075 nla_put_u32(msg, NL80211_MPATH_INFO_PATH_CHANGE,
6076 pinfo->path_change_count)))
6077 goto nla_put_failure;
6079 nla_nest_end(msg, pinfoattr);
6081 genlmsg_end(msg, hdr);
6085 genlmsg_cancel(msg, hdr);
6089 static int nl80211_dump_mpath(struct sk_buff *skb,
6090 struct netlink_callback *cb)
6092 struct mpath_info pinfo;
6093 struct cfg80211_registered_device *rdev;
6094 struct wireless_dev *wdev;
6096 u8 next_hop[ETH_ALEN];
6097 int path_idx = cb->args[2];
6101 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6105 if (!rdev->ops->dump_mpath) {
6110 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
6116 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
6123 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
6124 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6125 wdev->netdev, dst, next_hop,
6133 cb->args[2] = path_idx;
6140 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
6142 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6144 struct net_device *dev = info->user_ptr[1];
6145 struct mpath_info pinfo;
6146 struct sk_buff *msg;
6148 u8 next_hop[ETH_ALEN];
6150 memset(&pinfo, 0, sizeof(pinfo));
6152 if (!info->attrs[NL80211_ATTR_MAC])
6155 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6157 if (!rdev->ops->get_mpath)
6160 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6163 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
6167 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6171 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
6172 dev, dst, next_hop, &pinfo) < 0) {
6177 return genlmsg_reply(msg, info);
6180 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
6182 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6183 struct net_device *dev = info->user_ptr[1];
6185 u8 *next_hop = NULL;
6187 if (!info->attrs[NL80211_ATTR_MAC])
6190 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
6193 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6194 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
6196 if (!rdev->ops->change_mpath)
6199 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6202 return rdev_change_mpath(rdev, dev, dst, next_hop);
6205 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
6207 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6208 struct net_device *dev = info->user_ptr[1];
6210 u8 *next_hop = NULL;
6212 if (!info->attrs[NL80211_ATTR_MAC])
6215 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
6218 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6219 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
6221 if (!rdev->ops->add_mpath)
6224 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6227 return rdev_add_mpath(rdev, dev, dst, next_hop);
6230 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
6232 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6233 struct net_device *dev = info->user_ptr[1];
6236 if (info->attrs[NL80211_ATTR_MAC])
6237 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6239 if (!rdev->ops->del_mpath)
6242 return rdev_del_mpath(rdev, dev, dst);
6245 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
6247 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6249 struct net_device *dev = info->user_ptr[1];
6250 struct mpath_info pinfo;
6251 struct sk_buff *msg;
6255 memset(&pinfo, 0, sizeof(pinfo));
6257 if (!info->attrs[NL80211_ATTR_MAC])
6260 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
6262 if (!rdev->ops->get_mpp)
6265 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6268 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
6272 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6276 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
6277 dev, dst, mpp, &pinfo) < 0) {
6282 return genlmsg_reply(msg, info);
6285 static int nl80211_dump_mpp(struct sk_buff *skb,
6286 struct netlink_callback *cb)
6288 struct mpath_info pinfo;
6289 struct cfg80211_registered_device *rdev;
6290 struct wireless_dev *wdev;
6293 int path_idx = cb->args[2];
6297 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6301 if (!rdev->ops->dump_mpp) {
6306 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
6312 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
6319 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
6320 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6321 wdev->netdev, dst, mpp,
6329 cb->args[2] = path_idx;
6336 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
6338 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6339 struct net_device *dev = info->user_ptr[1];
6340 struct wireless_dev *wdev = dev->ieee80211_ptr;
6341 struct bss_parameters params;
6344 memset(¶ms, 0, sizeof(params));
6345 /* default to not changing parameters */
6346 params.use_cts_prot = -1;
6347 params.use_short_preamble = -1;
6348 params.use_short_slot_time = -1;
6349 params.ap_isolate = -1;
6350 params.ht_opmode = -1;
6351 params.p2p_ctwindow = -1;
6352 params.p2p_opp_ps = -1;
6354 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
6355 params.use_cts_prot =
6356 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
6357 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
6358 params.use_short_preamble =
6359 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
6360 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
6361 params.use_short_slot_time =
6362 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
6363 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6364 params.basic_rates =
6365 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6366 params.basic_rates_len =
6367 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6369 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
6370 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
6371 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
6373 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
6375 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
6376 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6378 params.p2p_ctwindow =
6379 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
6380 if (params.p2p_ctwindow != 0 &&
6381 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
6385 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
6388 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6390 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
6391 params.p2p_opp_ps = tmp;
6392 if (params.p2p_opp_ps &&
6393 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
6397 if (!rdev->ops->change_bss)
6400 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6401 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6405 err = rdev_change_bss(rdev, dev, ¶ms);
6411 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
6415 enum nl80211_user_reg_hint_type user_reg_hint_type;
6419 * You should only get this when cfg80211 hasn't yet initialized
6420 * completely when built-in to the kernel right between the time
6421 * window between nl80211_init() and regulatory_init(), if that is
6424 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
6425 return -EINPROGRESS;
6427 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
6428 user_reg_hint_type =
6429 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
6431 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
6433 switch (user_reg_hint_type) {
6434 case NL80211_USER_REG_HINT_USER:
6435 case NL80211_USER_REG_HINT_CELL_BASE:
6436 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6439 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6440 return regulatory_hint_user(data, user_reg_hint_type);
6441 case NL80211_USER_REG_HINT_INDOOR:
6442 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
6443 owner_nlportid = info->snd_portid;
6444 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
6450 return regulatory_hint_indoor(is_indoor, owner_nlportid);
6456 static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info)
6458 return reg_reload_regdb();
6461 static int nl80211_get_mesh_config(struct sk_buff *skb,
6462 struct genl_info *info)
6464 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6465 struct net_device *dev = info->user_ptr[1];
6466 struct wireless_dev *wdev = dev->ieee80211_ptr;
6467 struct mesh_config cur_params;
6470 struct nlattr *pinfoattr;
6471 struct sk_buff *msg;
6473 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6476 if (!rdev->ops->get_mesh_config)
6480 /* If not connected, get default parameters */
6481 if (!wdev->mesh_id_len)
6482 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
6484 err = rdev_get_mesh_config(rdev, dev, &cur_params);
6490 /* Draw up a netlink message to send back */
6491 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6494 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6495 NL80211_CMD_GET_MESH_CONFIG);
6498 pinfoattr = nla_nest_start_noflag(msg, NL80211_ATTR_MESH_CONFIG);
6500 goto nla_put_failure;
6501 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6502 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
6503 cur_params.dot11MeshRetryTimeout) ||
6504 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
6505 cur_params.dot11MeshConfirmTimeout) ||
6506 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
6507 cur_params.dot11MeshHoldingTimeout) ||
6508 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
6509 cur_params.dot11MeshMaxPeerLinks) ||
6510 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
6511 cur_params.dot11MeshMaxRetries) ||
6512 nla_put_u8(msg, NL80211_MESHCONF_TTL,
6513 cur_params.dot11MeshTTL) ||
6514 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
6515 cur_params.element_ttl) ||
6516 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
6517 cur_params.auto_open_plinks) ||
6518 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
6519 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
6520 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
6521 cur_params.dot11MeshHWMPmaxPREQretries) ||
6522 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
6523 cur_params.path_refresh_time) ||
6524 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
6525 cur_params.min_discovery_timeout) ||
6526 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
6527 cur_params.dot11MeshHWMPactivePathTimeout) ||
6528 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
6529 cur_params.dot11MeshHWMPpreqMinInterval) ||
6530 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
6531 cur_params.dot11MeshHWMPperrMinInterval) ||
6532 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
6533 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
6534 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
6535 cur_params.dot11MeshHWMPRootMode) ||
6536 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
6537 cur_params.dot11MeshHWMPRannInterval) ||
6538 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
6539 cur_params.dot11MeshGateAnnouncementProtocol) ||
6540 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
6541 cur_params.dot11MeshForwarding) ||
6542 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
6543 cur_params.rssi_threshold) ||
6544 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
6545 cur_params.ht_opmode) ||
6546 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
6547 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
6548 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
6549 cur_params.dot11MeshHWMProotInterval) ||
6550 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
6551 cur_params.dot11MeshHWMPconfirmationInterval) ||
6552 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
6553 cur_params.power_mode) ||
6554 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
6555 cur_params.dot11MeshAwakeWindowDuration) ||
6556 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
6557 cur_params.plink_timeout) ||
6558 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_GATE,
6559 cur_params.dot11MeshConnectedToMeshGate))
6560 goto nla_put_failure;
6561 nla_nest_end(msg, pinfoattr);
6562 genlmsg_end(msg, hdr);
6563 return genlmsg_reply(msg, info);
6571 static const struct nla_policy
6572 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
6573 [NL80211_MESHCONF_RETRY_TIMEOUT] =
6574 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6575 [NL80211_MESHCONF_CONFIRM_TIMEOUT] =
6576 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6577 [NL80211_MESHCONF_HOLDING_TIMEOUT] =
6578 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6579 [NL80211_MESHCONF_MAX_PEER_LINKS] =
6580 NLA_POLICY_RANGE(NLA_U16, 0, 255),
6581 [NL80211_MESHCONF_MAX_RETRIES] = NLA_POLICY_MAX(NLA_U8, 16),
6582 [NL80211_MESHCONF_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
6583 [NL80211_MESHCONF_ELEMENT_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
6584 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = NLA_POLICY_MAX(NLA_U8, 1),
6585 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] =
6586 NLA_POLICY_RANGE(NLA_U32, 1, 255),
6587 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
6588 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
6589 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = NLA_POLICY_MIN(NLA_U16, 1),
6590 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
6591 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] =
6592 NLA_POLICY_MIN(NLA_U16, 1),
6593 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] =
6594 NLA_POLICY_MIN(NLA_U16, 1),
6595 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] =
6596 NLA_POLICY_MIN(NLA_U16, 1),
6597 [NL80211_MESHCONF_HWMP_ROOTMODE] = NLA_POLICY_MAX(NLA_U8, 4),
6598 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] =
6599 NLA_POLICY_MIN(NLA_U16, 1),
6600 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = NLA_POLICY_MAX(NLA_U8, 1),
6601 [NL80211_MESHCONF_FORWARDING] = NLA_POLICY_MAX(NLA_U8, 1),
6602 [NL80211_MESHCONF_RSSI_THRESHOLD] =
6603 NLA_POLICY_RANGE(NLA_S32, -255, 0),
6604 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
6605 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
6606 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] =
6607 NLA_POLICY_MIN(NLA_U16, 1),
6608 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] =
6609 NLA_POLICY_MIN(NLA_U16, 1),
6610 [NL80211_MESHCONF_POWER_MODE] =
6611 NLA_POLICY_RANGE(NLA_U32,
6612 NL80211_MESH_POWER_ACTIVE,
6613 NL80211_MESH_POWER_MAX),
6614 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
6615 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
6616 [NL80211_MESHCONF_CONNECTED_TO_GATE] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
6619 static const struct nla_policy
6620 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
6621 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
6622 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
6623 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
6624 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6625 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
6626 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
6627 [NL80211_MESH_SETUP_IE] =
6628 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
6629 IEEE80211_MAX_DATA_LEN),
6630 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
6633 static int nl80211_parse_mesh_config(struct genl_info *info,
6634 struct mesh_config *cfg,
6637 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
6641 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \
6644 cfg->param = fn(tb[attr]); \
6645 mask |= BIT((attr) - 1); \
6649 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
6651 if (nla_parse_nested_deprecated(tb, NL80211_MESHCONF_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_CONFIG], nl80211_meshconf_params_policy, info->extack))
6654 /* This makes sure that there aren't more than 32 mesh config
6655 * parameters (otherwise our bitfield scheme would not work.) */
6656 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
6658 /* Fill in the params struct */
6659 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, mask,
6660 NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
6661 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, mask,
6662 NL80211_MESHCONF_CONFIRM_TIMEOUT,
6664 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, mask,
6665 NL80211_MESHCONF_HOLDING_TIMEOUT,
6667 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, mask,
6668 NL80211_MESHCONF_MAX_PEER_LINKS,
6670 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, mask,
6671 NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
6672 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, mask,
6673 NL80211_MESHCONF_TTL, nla_get_u8);
6674 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, mask,
6675 NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
6676 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, mask,
6677 NL80211_MESHCONF_AUTO_OPEN_PLINKS,
6679 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
6681 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
6683 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, mask,
6684 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
6686 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, mask,
6687 NL80211_MESHCONF_PATH_REFRESH_TIME,
6689 if (mask & BIT(NL80211_MESHCONF_PATH_REFRESH_TIME) &&
6690 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535))
6692 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, mask,
6693 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
6695 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
6697 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
6699 if (mask & BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT) &&
6700 (cfg->dot11MeshHWMPactivePathTimeout < 1 ||
6701 cfg->dot11MeshHWMPactivePathTimeout > 65535))
6703 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, mask,
6704 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
6706 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval, mask,
6707 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
6709 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
6710 dot11MeshHWMPnetDiameterTraversalTime, mask,
6711 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
6713 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask,
6714 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8);
6715 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask,
6716 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
6718 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshGateAnnouncementProtocol,
6719 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
6721 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, mask,
6722 NL80211_MESHCONF_FORWARDING, nla_get_u8);
6723 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, mask,
6724 NL80211_MESHCONF_RSSI_THRESHOLD,
6726 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToMeshGate, mask,
6727 NL80211_MESHCONF_CONNECTED_TO_GATE,
6730 * Check HT operation mode based on
6731 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
6733 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
6734 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
6736 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
6737 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
6738 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6741 /* NON_HT_STA bit is reserved, but some programs set it */
6742 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
6744 cfg->ht_opmode = ht_opmode;
6745 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
6747 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
6748 dot11MeshHWMPactivePathToRootTimeout, mask,
6749 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
6751 if (mask & BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT) &&
6752 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 ||
6753 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535))
6755 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, mask,
6756 NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
6758 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPconfirmationInterval,
6760 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
6762 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode, mask,
6763 NL80211_MESHCONF_POWER_MODE, nla_get_u32);
6764 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration, mask,
6765 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
6766 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, mask,
6767 NL80211_MESHCONF_PLINK_TIMEOUT, nla_get_u32);
6773 #undef FILL_IN_MESH_PARAM_IF_SET
6776 static int nl80211_parse_mesh_setup(struct genl_info *info,
6777 struct mesh_setup *setup)
6779 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6780 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
6782 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
6784 if (nla_parse_nested_deprecated(tb, NL80211_MESH_SETUP_ATTR_MAX, info->attrs[NL80211_ATTR_MESH_SETUP], nl80211_mesh_setup_params_policy, info->extack))
6787 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
6788 setup->sync_method =
6789 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
6790 IEEE80211_SYNC_METHOD_VENDOR :
6791 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
6793 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
6794 setup->path_sel_proto =
6795 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
6796 IEEE80211_PATH_PROTOCOL_VENDOR :
6797 IEEE80211_PATH_PROTOCOL_HWMP;
6799 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
6800 setup->path_metric =
6801 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
6802 IEEE80211_PATH_METRIC_VENDOR :
6803 IEEE80211_PATH_METRIC_AIRTIME;
6805 if (tb[NL80211_MESH_SETUP_IE]) {
6806 struct nlattr *ieattr =
6807 tb[NL80211_MESH_SETUP_IE];
6808 setup->ie = nla_data(ieattr);
6809 setup->ie_len = nla_len(ieattr);
6811 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
6812 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
6814 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
6815 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
6816 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
6817 if (setup->is_secure)
6818 setup->user_mpm = true;
6820 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
6821 if (!setup->user_mpm)
6824 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
6830 static int nl80211_update_mesh_config(struct sk_buff *skb,
6831 struct genl_info *info)
6833 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6834 struct net_device *dev = info->user_ptr[1];
6835 struct wireless_dev *wdev = dev->ieee80211_ptr;
6836 struct mesh_config cfg;
6840 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6843 if (!rdev->ops->update_mesh_config)
6846 err = nl80211_parse_mesh_config(info, &cfg, &mask);
6851 if (!wdev->mesh_id_len)
6855 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
6862 static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
6863 struct sk_buff *msg)
6865 struct nlattr *nl_reg_rules;
6868 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
6869 (regdom->dfs_region &&
6870 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
6871 goto nla_put_failure;
6873 nl_reg_rules = nla_nest_start_noflag(msg, NL80211_ATTR_REG_RULES);
6875 goto nla_put_failure;
6877 for (i = 0; i < regdom->n_reg_rules; i++) {
6878 struct nlattr *nl_reg_rule;
6879 const struct ieee80211_reg_rule *reg_rule;
6880 const struct ieee80211_freq_range *freq_range;
6881 const struct ieee80211_power_rule *power_rule;
6882 unsigned int max_bandwidth_khz;
6884 reg_rule = ®dom->reg_rules[i];
6885 freq_range = ®_rule->freq_range;
6886 power_rule = ®_rule->power_rule;
6888 nl_reg_rule = nla_nest_start_noflag(msg, i);
6890 goto nla_put_failure;
6892 max_bandwidth_khz = freq_range->max_bandwidth_khz;
6893 if (!max_bandwidth_khz)
6894 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
6897 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
6899 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
6900 freq_range->start_freq_khz) ||
6901 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
6902 freq_range->end_freq_khz) ||
6903 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
6904 max_bandwidth_khz) ||
6905 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
6906 power_rule->max_antenna_gain) ||
6907 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
6908 power_rule->max_eirp) ||
6909 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
6910 reg_rule->dfs_cac_ms))
6911 goto nla_put_failure;
6913 nla_nest_end(msg, nl_reg_rule);
6916 nla_nest_end(msg, nl_reg_rules);
6923 static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
6925 const struct ieee80211_regdomain *regdom = NULL;
6926 struct cfg80211_registered_device *rdev;
6927 struct wiphy *wiphy = NULL;
6928 struct sk_buff *msg;
6931 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6935 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6936 NL80211_CMD_GET_REG);
6940 if (info->attrs[NL80211_ATTR_WIPHY]) {
6943 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
6946 return PTR_ERR(rdev);
6949 wiphy = &rdev->wiphy;
6950 self_managed = wiphy->regulatory_flags &
6951 REGULATORY_WIPHY_SELF_MANAGED;
6952 regdom = get_wiphy_regdom(wiphy);
6954 /* a self-managed-reg device must have a private regdom */
6955 if (WARN_ON(!regdom && self_managed)) {
6961 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6962 goto nla_put_failure;
6965 if (!wiphy && reg_last_request_cell_base() &&
6966 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6967 NL80211_USER_REG_HINT_CELL_BASE))
6968 goto nla_put_failure;
6973 regdom = rcu_dereference(cfg80211_regdomain);
6975 if (nl80211_put_regdom(regdom, msg))
6976 goto nla_put_failure_rcu;
6980 genlmsg_end(msg, hdr);
6981 return genlmsg_reply(msg, info);
6983 nla_put_failure_rcu:
6991 static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
6992 u32 seq, int flags, struct wiphy *wiphy,
6993 const struct ieee80211_regdomain *regdom)
6995 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6996 NL80211_CMD_GET_REG);
7001 genl_dump_check_consistent(cb, hdr);
7003 if (nl80211_put_regdom(regdom, msg))
7004 goto nla_put_failure;
7006 if (!wiphy && reg_last_request_cell_base() &&
7007 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
7008 NL80211_USER_REG_HINT_CELL_BASE))
7009 goto nla_put_failure;
7012 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
7013 goto nla_put_failure;
7015 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
7016 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
7017 goto nla_put_failure;
7019 genlmsg_end(msg, hdr);
7023 genlmsg_cancel(msg, hdr);
7027 static int nl80211_get_reg_dump(struct sk_buff *skb,
7028 struct netlink_callback *cb)
7030 const struct ieee80211_regdomain *regdom = NULL;
7031 struct cfg80211_registered_device *rdev;
7032 int err, reg_idx, start = cb->args[2];
7036 if (cfg80211_regdomain && start == 0) {
7037 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
7039 rtnl_dereference(cfg80211_regdomain));
7044 /* the global regdom is idx 0 */
7046 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
7047 regdom = get_wiphy_regdom(&rdev->wiphy);
7051 if (++reg_idx <= start)
7054 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
7055 NLM_F_MULTI, &rdev->wiphy, regdom);
7062 cb->args[2] = reg_idx;
7069 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
7070 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
7071 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
7072 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
7073 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
7074 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
7075 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
7076 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
7077 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
7080 static int parse_reg_rule(struct nlattr *tb[],
7081 struct ieee80211_reg_rule *reg_rule)
7083 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
7084 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
7086 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
7088 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
7090 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
7092 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
7094 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
7097 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
7099 freq_range->start_freq_khz =
7100 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
7101 freq_range->end_freq_khz =
7102 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
7103 freq_range->max_bandwidth_khz =
7104 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
7106 power_rule->max_eirp =
7107 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
7109 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
7110 power_rule->max_antenna_gain =
7111 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
7113 if (tb[NL80211_ATTR_DFS_CAC_TIME])
7114 reg_rule->dfs_cac_ms =
7115 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
7120 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
7122 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
7123 struct nlattr *nl_reg_rule;
7125 int rem_reg_rules, r;
7126 u32 num_rules = 0, rule_idx = 0;
7127 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
7128 struct ieee80211_regdomain *rd;
7130 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
7133 if (!info->attrs[NL80211_ATTR_REG_RULES])
7136 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
7138 if (info->attrs[NL80211_ATTR_DFS_REGION])
7139 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
7141 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
7144 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
7148 if (!reg_is_valid_request(alpha2))
7151 rd = kzalloc(struct_size(rd, reg_rules, num_rules), GFP_KERNEL);
7155 rd->n_reg_rules = num_rules;
7156 rd->alpha2[0] = alpha2[0];
7157 rd->alpha2[1] = alpha2[1];
7160 * Disable DFS master mode if the DFS region was
7161 * not supported or known on this kernel.
7163 if (reg_supported_dfs_region(dfs_region))
7164 rd->dfs_region = dfs_region;
7166 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
7168 r = nla_parse_nested_deprecated(tb, NL80211_REG_RULE_ATTR_MAX,
7169 nl_reg_rule, reg_rule_policy,
7173 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
7179 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
7185 /* set_regdom takes ownership of rd */
7186 return set_regdom(rd, REGD_SOURCE_CRDA);
7191 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
7193 static int validate_scan_freqs(struct nlattr *freqs)
7195 struct nlattr *attr1, *attr2;
7196 int n_channels = 0, tmp1, tmp2;
7198 nla_for_each_nested(attr1, freqs, tmp1)
7199 if (nla_len(attr1) != sizeof(u32))
7202 nla_for_each_nested(attr1, freqs, tmp1) {
7205 * Some hardware has a limited channel list for
7206 * scanning, and it is pretty much nonsensical
7207 * to scan for a channel twice, so disallow that
7208 * and don't require drivers to check that the
7209 * channel list they get isn't longer than what
7210 * they can scan, as long as they can scan all
7211 * the channels they registered at once.
7213 nla_for_each_nested(attr2, freqs, tmp2)
7214 if (attr1 != attr2 &&
7215 nla_get_u32(attr1) == nla_get_u32(attr2))
7222 static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
7224 return b < NUM_NL80211_BANDS && wiphy->bands[b];
7227 static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
7228 struct cfg80211_bss_selection *bss_select)
7230 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
7231 struct nlattr *nest;
7236 /* only process one nested attribute */
7237 nest = nla_data(nla);
7238 if (!nla_ok(nest, nla_len(nest)))
7241 err = nla_parse_nested_deprecated(attr, NL80211_BSS_SELECT_ATTR_MAX,
7242 nest, nl80211_bss_select_policy,
7247 /* only one attribute may be given */
7248 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
7256 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
7258 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
7259 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
7261 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
7262 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
7263 bss_select->param.band_pref =
7264 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
7265 if (!is_band_valid(wiphy, bss_select->param.band_pref))
7269 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
7270 struct nl80211_bss_select_rssi_adjust *adj_param;
7272 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
7273 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
7274 bss_select->param.adjust.band = adj_param->band;
7275 bss_select->param.adjust.delta = adj_param->delta;
7276 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
7280 /* user-space did not provide behaviour attribute */
7281 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
7284 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
7290 int nl80211_parse_random_mac(struct nlattr **attrs,
7291 u8 *mac_addr, u8 *mac_addr_mask)
7295 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
7296 eth_zero_addr(mac_addr);
7297 eth_zero_addr(mac_addr_mask);
7299 mac_addr_mask[0] = 0x3;
7304 /* need both or none */
7305 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
7308 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
7309 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
7311 /* don't allow or configure an mcast address */
7312 if (!is_multicast_ether_addr(mac_addr_mask) ||
7313 is_multicast_ether_addr(mac_addr))
7317 * allow users to pass a MAC address that has bits set outside
7318 * of the mask, but don't bother drivers with having to deal
7321 for (i = 0; i < ETH_ALEN; i++)
7322 mac_addr[i] &= mac_addr_mask[i];
7327 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
7329 ASSERT_WDEV_LOCK(wdev);
7331 if (!cfg80211_beaconing_iface_active(wdev))
7334 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
7337 return regulatory_pre_cac_allowed(wdev->wiphy);
7340 static bool nl80211_check_scan_feat(struct wiphy *wiphy, u32 flags, u32 flag,
7341 enum nl80211_ext_feature_index feat)
7343 if (!(flags & flag))
7345 if (wiphy_ext_feature_isset(wiphy, feat))
7351 nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
7352 void *request, struct nlattr **attrs,
7355 u8 *mac_addr, *mac_addr_mask;
7357 enum nl80211_feature_flags randomness_flag;
7359 if (!attrs[NL80211_ATTR_SCAN_FLAGS])
7362 if (is_sched_scan) {
7363 struct cfg80211_sched_scan_request *req = request;
7365 randomness_flag = wdev ?
7366 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR :
7367 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7368 flags = &req->flags;
7369 mac_addr = req->mac_addr;
7370 mac_addr_mask = req->mac_addr_mask;
7372 struct cfg80211_scan_request *req = request;
7374 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
7375 flags = &req->flags;
7376 mac_addr = req->mac_addr;
7377 mac_addr_mask = req->mac_addr_mask;
7380 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
7382 if (((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
7383 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
7384 !nl80211_check_scan_feat(wiphy, *flags,
7385 NL80211_SCAN_FLAG_LOW_SPAN,
7386 NL80211_EXT_FEATURE_LOW_SPAN_SCAN) ||
7387 !nl80211_check_scan_feat(wiphy, *flags,
7388 NL80211_SCAN_FLAG_LOW_POWER,
7389 NL80211_EXT_FEATURE_LOW_POWER_SCAN) ||
7390 !nl80211_check_scan_feat(wiphy, *flags,
7391 NL80211_SCAN_FLAG_HIGH_ACCURACY,
7392 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN) ||
7393 !nl80211_check_scan_feat(wiphy, *flags,
7394 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME,
7395 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) ||
7396 !nl80211_check_scan_feat(wiphy, *flags,
7397 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP,
7398 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) ||
7399 !nl80211_check_scan_feat(wiphy, *flags,
7400 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION,
7401 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) ||
7402 !nl80211_check_scan_feat(wiphy, *flags,
7403 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE,
7404 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) ||
7405 !nl80211_check_scan_feat(wiphy, *flags,
7406 NL80211_SCAN_FLAG_RANDOM_SN,
7407 NL80211_EXT_FEATURE_SCAN_RANDOM_SN) ||
7408 !nl80211_check_scan_feat(wiphy, *flags,
7409 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT,
7410 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
7413 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
7416 if (!(wiphy->features & randomness_flag) ||
7417 (wdev && wdev->current_bss))
7420 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask);
7428 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
7430 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7431 struct wireless_dev *wdev = info->user_ptr[1];
7432 struct cfg80211_scan_request *request;
7433 struct nlattr *attr;
7434 struct wiphy *wiphy;
7435 int err, tmp, n_ssids = 0, n_channels, i;
7438 wiphy = &rdev->wiphy;
7440 if (wdev->iftype == NL80211_IFTYPE_NAN)
7443 if (!rdev->ops->scan)
7446 if (rdev->scan_req || rdev->scan_msg) {
7451 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7452 n_channels = validate_scan_freqs(
7453 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
7459 n_channels = ieee80211_get_num_supported_channels(wiphy);
7462 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
7463 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
7466 if (n_ssids > wiphy->max_scan_ssids) {
7471 if (info->attrs[NL80211_ATTR_IE])
7472 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7476 if (ie_len > wiphy->max_scan_ie_len) {
7481 request = kzalloc(sizeof(*request)
7482 + sizeof(*request->ssids) * n_ssids
7483 + sizeof(*request->channels) * n_channels
7484 + ie_len, GFP_KERNEL);
7491 request->ssids = (void *)&request->channels[n_channels];
7492 request->n_ssids = n_ssids;
7495 request->ie = (void *)(request->ssids + n_ssids);
7497 request->ie = (void *)(request->channels + n_channels);
7501 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7502 /* user specified, bail out if channel not found */
7503 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
7504 struct ieee80211_channel *chan;
7506 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7513 /* ignore disabled channels */
7514 if (chan->flags & IEEE80211_CHAN_DISABLED)
7517 request->channels[i] = chan;
7521 enum nl80211_band band;
7524 for (band = 0; band < NUM_NL80211_BANDS; band++) {
7527 if (!wiphy->bands[band])
7529 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7530 struct ieee80211_channel *chan;
7532 chan = &wiphy->bands[band]->channels[j];
7534 if (chan->flags & IEEE80211_CHAN_DISABLED)
7537 request->channels[i] = chan;
7548 request->n_channels = i;
7551 if (!cfg80211_off_channel_oper_allowed(wdev)) {
7552 struct ieee80211_channel *chan;
7554 if (request->n_channels != 1) {
7560 chan = request->channels[0];
7561 if (chan->center_freq != wdev->chandef.chan->center_freq) {
7571 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
7572 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
7576 request->ssids[i].ssid_len = nla_len(attr);
7577 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
7582 if (info->attrs[NL80211_ATTR_IE]) {
7583 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7584 memcpy((void *)request->ie,
7585 nla_data(info->attrs[NL80211_ATTR_IE]),
7589 for (i = 0; i < NUM_NL80211_BANDS; i++)
7590 if (wiphy->bands[i])
7592 (1 << wiphy->bands[i]->n_bitrates) - 1;
7594 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
7595 nla_for_each_nested(attr,
7596 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
7598 enum nl80211_band band = nla_type(attr);
7600 if (band < 0 || band >= NUM_NL80211_BANDS) {
7605 if (!wiphy->bands[band])
7608 err = ieee80211_get_ratemask(wiphy->bands[band],
7611 &request->rates[band]);
7617 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
7618 if (!wiphy_ext_feature_isset(wiphy,
7619 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
7625 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
7626 request->duration_mandatory =
7627 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
7630 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
7636 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
7638 /* Initial implementation used NL80211_ATTR_MAC to set the specific
7639 * BSSID to scan for. This was problematic because that same attribute
7640 * was already used for another purpose (local random MAC address). The
7641 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
7642 * compatibility with older userspace components, also use the
7643 * NL80211_ATTR_MAC value here if it can be determined to be used for
7644 * the specific BSSID use case instead of the random MAC address
7645 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
7647 if (info->attrs[NL80211_ATTR_BSSID])
7648 memcpy(request->bssid,
7649 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
7650 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
7651 info->attrs[NL80211_ATTR_MAC])
7652 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
7655 eth_broadcast_addr(request->bssid);
7657 request->wdev = wdev;
7658 request->wiphy = &rdev->wiphy;
7659 request->scan_start = jiffies;
7661 rdev->scan_req = request;
7662 err = rdev_scan(rdev, request);
7665 nl80211_send_scan_start(rdev, wdev);
7667 dev_hold(wdev->netdev);
7670 rdev->scan_req = NULL;
7678 static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
7680 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7681 struct wireless_dev *wdev = info->user_ptr[1];
7683 if (!rdev->ops->abort_scan)
7689 if (!rdev->scan_req)
7692 rdev_abort_scan(rdev, wdev);
7697 nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
7698 struct cfg80211_sched_scan_request *request,
7699 struct nlattr **attrs)
7701 int tmp, err, i = 0;
7702 struct nlattr *attr;
7704 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7708 * If scan plans are not specified,
7709 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
7710 * case one scan plan will be set with the specified scan
7711 * interval and infinite number of iterations.
7713 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
7717 request->scan_plans[0].interval =
7718 DIV_ROUND_UP(interval, MSEC_PER_SEC);
7719 if (!request->scan_plans[0].interval)
7722 if (request->scan_plans[0].interval >
7723 wiphy->max_sched_scan_plan_interval)
7724 request->scan_plans[0].interval =
7725 wiphy->max_sched_scan_plan_interval;
7730 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
7731 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
7733 if (WARN_ON(i >= n_plans))
7736 err = nla_parse_nested_deprecated(plan,
7737 NL80211_SCHED_SCAN_PLAN_MAX,
7738 attr, nl80211_plan_policy,
7743 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
7746 request->scan_plans[i].interval =
7747 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
7748 if (!request->scan_plans[i].interval ||
7749 request->scan_plans[i].interval >
7750 wiphy->max_sched_scan_plan_interval)
7753 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
7754 request->scan_plans[i].iterations =
7755 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
7756 if (!request->scan_plans[i].iterations ||
7757 (request->scan_plans[i].iterations >
7758 wiphy->max_sched_scan_plan_iterations))
7760 } else if (i < n_plans - 1) {
7762 * All scan plans but the last one must specify
7763 * a finite number of iterations
7772 * The last scan plan must not specify the number of
7773 * iterations, it is supposed to run infinitely
7775 if (request->scan_plans[n_plans - 1].iterations)
7782 nl80211_parse_sched_scan_per_band_rssi(struct wiphy *wiphy,
7783 struct cfg80211_match_set *match_sets,
7784 struct nlattr *tb_band_rssi,
7787 struct nlattr *attr;
7788 int i, tmp, ret = 0;
7790 if (!wiphy_ext_feature_isset(wiphy,
7791 NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD)) {
7795 for (i = 0; i < NUM_NL80211_BANDS; i++)
7796 match_sets->per_band_rssi_thold[i] =
7797 NL80211_SCAN_RSSI_THOLD_OFF;
7801 for (i = 0; i < NUM_NL80211_BANDS; i++)
7802 match_sets->per_band_rssi_thold[i] = rssi_thold;
7804 nla_for_each_nested(attr, tb_band_rssi, tmp) {
7805 enum nl80211_band band = nla_type(attr);
7807 if (band < 0 || band >= NUM_NL80211_BANDS)
7810 match_sets->per_band_rssi_thold[band] = nla_get_s32(attr);
7816 static struct cfg80211_sched_scan_request *
7817 nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
7818 struct nlattr **attrs, int max_match_sets)
7820 struct cfg80211_sched_scan_request *request;
7821 struct nlattr *attr;
7822 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
7823 enum nl80211_band band;
7825 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
7826 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
7828 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7829 n_channels = validate_scan_freqs(
7830 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
7832 return ERR_PTR(-EINVAL);
7834 n_channels = ieee80211_get_num_supported_channels(wiphy);
7837 if (attrs[NL80211_ATTR_SCAN_SSIDS])
7838 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
7842 if (n_ssids > wiphy->max_sched_scan_ssids)
7843 return ERR_PTR(-EINVAL);
7846 * First, count the number of 'real' matchsets. Due to an issue with
7847 * the old implementation, matchsets containing only the RSSI attribute
7848 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
7849 * RSSI for all matchsets, rather than their own matchset for reporting
7850 * all APs with a strong RSSI. This is needed to be compatible with
7851 * older userspace that treated a matchset with only the RSSI as the
7852 * global RSSI for all other matchsets - if there are other matchsets.
7854 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
7855 nla_for_each_nested(attr,
7856 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
7858 struct nlattr *rssi;
7860 err = nla_parse_nested_deprecated(tb,
7861 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
7863 nl80211_match_policy,
7866 return ERR_PTR(err);
7868 /* SSID and BSSID are mutually exclusive */
7869 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
7870 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
7871 return ERR_PTR(-EINVAL);
7873 /* add other standalone attributes here */
7874 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
7875 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
7879 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7881 default_match_rssi = nla_get_s32(rssi);
7885 /* However, if there's no other matchset, add the RSSI one */
7886 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
7889 if (n_match_sets > max_match_sets)
7890 return ERR_PTR(-EINVAL);
7892 if (attrs[NL80211_ATTR_IE])
7893 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
7897 if (ie_len > wiphy->max_sched_scan_ie_len)
7898 return ERR_PTR(-EINVAL);
7900 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7902 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
7903 * each scan plan already specifies its own interval
7905 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7906 return ERR_PTR(-EINVAL);
7908 nla_for_each_nested(attr,
7909 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
7913 * The scan interval attribute is kept for backward
7914 * compatibility. If no scan plans are specified and sched scan
7915 * interval is specified, one scan plan will be set with this
7916 * scan interval and infinite number of iterations.
7918 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7919 return ERR_PTR(-EINVAL);
7924 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
7925 return ERR_PTR(-EINVAL);
7927 if (!wiphy_ext_feature_isset(
7928 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
7929 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
7930 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
7931 return ERR_PTR(-EINVAL);
7933 request = kzalloc(sizeof(*request)
7934 + sizeof(*request->ssids) * n_ssids
7935 + sizeof(*request->match_sets) * n_match_sets
7936 + sizeof(*request->scan_plans) * n_plans
7937 + sizeof(*request->channels) * n_channels
7938 + ie_len, GFP_KERNEL);
7940 return ERR_PTR(-ENOMEM);
7943 request->ssids = (void *)&request->channels[n_channels];
7944 request->n_ssids = n_ssids;
7947 request->ie = (void *)(request->ssids + n_ssids);
7949 request->ie = (void *)(request->channels + n_channels);
7954 request->match_sets = (void *)(request->ie + ie_len);
7956 request->match_sets =
7957 (void *)(request->ssids + n_ssids);
7959 request->match_sets =
7960 (void *)(request->channels + n_channels);
7962 request->n_match_sets = n_match_sets;
7965 request->scan_plans = (void *)(request->match_sets +
7967 else if (request->ie)
7968 request->scan_plans = (void *)(request->ie + ie_len);
7970 request->scan_plans = (void *)(request->ssids + n_ssids);
7972 request->scan_plans = (void *)(request->channels + n_channels);
7974 request->n_scan_plans = n_plans;
7977 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7978 /* user specified, bail out if channel not found */
7979 nla_for_each_nested(attr,
7980 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
7982 struct ieee80211_channel *chan;
7984 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7991 /* ignore disabled channels */
7992 if (chan->flags & IEEE80211_CHAN_DISABLED)
7995 request->channels[i] = chan;
8000 for (band = 0; band < NUM_NL80211_BANDS; band++) {
8003 if (!wiphy->bands[band])
8005 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
8006 struct ieee80211_channel *chan;
8008 chan = &wiphy->bands[band]->channels[j];
8010 if (chan->flags & IEEE80211_CHAN_DISABLED)
8013 request->channels[i] = chan;
8024 request->n_channels = i;
8028 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
8030 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
8034 request->ssids[i].ssid_len = nla_len(attr);
8035 memcpy(request->ssids[i].ssid, nla_data(attr),
8042 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
8043 nla_for_each_nested(attr,
8044 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
8046 struct nlattr *ssid, *bssid, *rssi;
8048 err = nla_parse_nested_deprecated(tb,
8049 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
8051 nl80211_match_policy,
8055 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
8056 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
8058 if (!ssid && !bssid) {
8063 if (WARN_ON(i >= n_match_sets)) {
8064 /* this indicates a programming error,
8065 * the loop above should have verified
8073 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
8077 memcpy(request->match_sets[i].ssid.ssid,
8078 nla_data(ssid), nla_len(ssid));
8079 request->match_sets[i].ssid.ssid_len =
8083 if (nla_len(bssid) != ETH_ALEN) {
8087 memcpy(request->match_sets[i].bssid,
8088 nla_data(bssid), ETH_ALEN);
8091 /* special attribute - old implementation w/a */
8092 request->match_sets[i].rssi_thold = default_match_rssi;
8093 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
8095 request->match_sets[i].rssi_thold =
8098 /* Parse per band RSSI attribute */
8099 err = nl80211_parse_sched_scan_per_band_rssi(wiphy,
8100 &request->match_sets[i],
8101 tb[NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI],
8102 request->match_sets[i].rssi_thold);
8109 /* there was no other matchset, so the RSSI one is alone */
8110 if (i == 0 && n_match_sets)
8111 request->match_sets[0].rssi_thold = default_match_rssi;
8113 request->min_rssi_thold = INT_MAX;
8114 for (i = 0; i < n_match_sets; i++)
8115 request->min_rssi_thold =
8116 min(request->match_sets[i].rssi_thold,
8117 request->min_rssi_thold);
8119 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
8123 request->ie_len = ie_len;
8124 memcpy((void *)request->ie,
8125 nla_data(attrs[NL80211_ATTR_IE]),
8129 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true);
8133 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
8135 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
8137 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
8138 request->relative_rssi = nla_get_s8(
8139 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
8140 request->relative_rssi_set = true;
8143 if (request->relative_rssi_set &&
8144 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
8145 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
8147 rssi_adjust = nla_data(
8148 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
8149 request->rssi_adjust.band = rssi_adjust->band;
8150 request->rssi_adjust.delta = rssi_adjust->delta;
8151 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
8157 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
8161 request->scan_start = jiffies;
8167 return ERR_PTR(err);
8170 static int nl80211_start_sched_scan(struct sk_buff *skb,
8171 struct genl_info *info)
8173 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8174 struct net_device *dev = info->user_ptr[1];
8175 struct wireless_dev *wdev = dev->ieee80211_ptr;
8176 struct cfg80211_sched_scan_request *sched_scan_req;
8180 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
8183 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
8184 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
8188 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
8190 rdev->wiphy.max_match_sets);
8192 err = PTR_ERR_OR_ZERO(sched_scan_req);
8196 /* leave request id zero for legacy request
8197 * or if driver does not support multi-scheduled scan
8199 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) {
8200 while (!sched_scan_req->reqid)
8201 sched_scan_req->reqid = cfg80211_assign_cookie(rdev);
8204 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
8208 sched_scan_req->dev = dev;
8209 sched_scan_req->wiphy = &rdev->wiphy;
8211 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
8212 sched_scan_req->owner_nlportid = info->snd_portid;
8214 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
8216 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
8220 kfree(sched_scan_req);
8225 static int nl80211_stop_sched_scan(struct sk_buff *skb,
8226 struct genl_info *info)
8228 struct cfg80211_sched_scan_request *req;
8229 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8232 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
8235 if (info->attrs[NL80211_ATTR_COOKIE]) {
8236 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
8237 return __cfg80211_stop_sched_scan(rdev, cookie, false);
8240 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
8241 struct cfg80211_sched_scan_request,
8243 if (!req || req->reqid ||
8244 (req->owner_nlportid &&
8245 req->owner_nlportid != info->snd_portid))
8248 return cfg80211_stop_sched_scan_req(rdev, req, false);
8251 static int nl80211_start_radar_detection(struct sk_buff *skb,
8252 struct genl_info *info)
8254 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8255 struct net_device *dev = info->user_ptr[1];
8256 struct wireless_dev *wdev = dev->ieee80211_ptr;
8257 struct wiphy *wiphy = wdev->wiphy;
8258 struct cfg80211_chan_def chandef;
8259 enum nl80211_dfs_regions dfs_region;
8260 unsigned int cac_time_ms;
8263 dfs_region = reg_get_dfs_region(wiphy);
8264 if (dfs_region == NL80211_DFS_UNSET)
8267 err = nl80211_parse_chandef(rdev, info, &chandef);
8271 if (netif_carrier_ok(dev))
8274 if (wdev->cac_started)
8277 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
8284 if (!cfg80211_chandef_dfs_usable(wiphy, &chandef))
8287 /* CAC start is offloaded to HW and can't be started manually */
8288 if (wiphy_ext_feature_isset(wiphy, NL80211_EXT_FEATURE_DFS_OFFLOAD))
8291 if (!rdev->ops->start_radar_detection)
8294 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
8295 if (WARN_ON(!cac_time_ms))
8296 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
8298 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
8300 wdev->chandef = chandef;
8301 wdev->cac_started = true;
8302 wdev->cac_start_time = jiffies;
8303 wdev->cac_time_ms = cac_time_ms;
8308 static int nl80211_notify_radar_detection(struct sk_buff *skb,
8309 struct genl_info *info)
8311 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8312 struct net_device *dev = info->user_ptr[1];
8313 struct wireless_dev *wdev = dev->ieee80211_ptr;
8314 struct wiphy *wiphy = wdev->wiphy;
8315 struct cfg80211_chan_def chandef;
8316 enum nl80211_dfs_regions dfs_region;
8319 dfs_region = reg_get_dfs_region(wiphy);
8320 if (dfs_region == NL80211_DFS_UNSET) {
8321 GENL_SET_ERR_MSG(info,
8322 "DFS Region is not set. Unexpected Radar indication");
8326 err = nl80211_parse_chandef(rdev, info, &chandef);
8328 GENL_SET_ERR_MSG(info, "Unable to extract chandef info");
8332 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
8334 GENL_SET_ERR_MSG(info, "chandef is invalid");
8339 GENL_SET_ERR_MSG(info,
8340 "Unexpected Radar indication for chandef/iftype");
8344 /* Do not process this notification if radar is already detected
8345 * by kernel on this channel, and return success.
8347 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE)
8350 cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_UNAVAILABLE);
8352 cfg80211_sched_dfs_chan_update(rdev);
8354 rdev->radar_chandef = chandef;
8356 /* Propagate this notification to other radios as well */
8357 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
8362 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
8364 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8365 struct net_device *dev = info->user_ptr[1];
8366 struct wireless_dev *wdev = dev->ieee80211_ptr;
8367 struct cfg80211_csa_settings params;
8368 /* csa_attrs is defined static to avoid waste of stack size - this
8369 * function is called under RTNL lock, so this should not be a problem.
8371 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
8373 bool need_new_beacon = false;
8374 bool need_handle_dfs_flag = true;
8378 if (!rdev->ops->channel_switch ||
8379 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
8382 switch (dev->ieee80211_ptr->iftype) {
8383 case NL80211_IFTYPE_AP:
8384 case NL80211_IFTYPE_P2P_GO:
8385 need_new_beacon = true;
8386 /* For all modes except AP the handle_dfs flag needs to be
8387 * supplied to tell the kernel that userspace will handle radar
8388 * events when they happen. Otherwise a switch to a channel
8389 * requiring DFS will be rejected.
8391 need_handle_dfs_flag = false;
8393 /* useless if AP is not running */
8394 if (!wdev->beacon_interval)
8397 case NL80211_IFTYPE_ADHOC:
8398 if (!wdev->ssid_len)
8401 case NL80211_IFTYPE_MESH_POINT:
8402 if (!wdev->mesh_id_len)
8409 memset(¶ms, 0, sizeof(params));
8410 params.beacon_csa.ftm_responder = -1;
8412 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
8413 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
8416 /* only important for AP, IBSS and mesh create IEs internally */
8417 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
8420 /* Even though the attribute is u32, the specification says
8421 * u8, so let's make sure we don't overflow.
8423 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
8427 params.count = cs_count;
8429 if (!need_new_beacon)
8432 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after);
8436 err = nla_parse_nested_deprecated(csa_attrs, NL80211_ATTR_MAX,
8437 info->attrs[NL80211_ATTR_CSA_IES],
8438 nl80211_policy, info->extack);
8442 err = nl80211_parse_beacon(rdev, csa_attrs, ¶ms.beacon_csa);
8446 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
8449 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
8450 if (!len || (len % sizeof(u16)))
8453 params.n_counter_offsets_beacon = len / sizeof(u16);
8454 if (rdev->wiphy.max_num_csa_counters &&
8455 (params.n_counter_offsets_beacon >
8456 rdev->wiphy.max_num_csa_counters))
8459 params.counter_offsets_beacon =
8460 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
8462 /* sanity checks - counters should fit and be the same */
8463 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
8464 u16 offset = params.counter_offsets_beacon[i];
8466 if (offset >= params.beacon_csa.tail_len)
8469 if (params.beacon_csa.tail[offset] != params.count)
8473 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
8474 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
8475 if (!len || (len % sizeof(u16)))
8478 params.n_counter_offsets_presp = len / sizeof(u16);
8479 if (rdev->wiphy.max_num_csa_counters &&
8480 (params.n_counter_offsets_presp >
8481 rdev->wiphy.max_num_csa_counters))
8484 params.counter_offsets_presp =
8485 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
8487 /* sanity checks - counters should fit and be the same */
8488 for (i = 0; i < params.n_counter_offsets_presp; i++) {
8489 u16 offset = params.counter_offsets_presp[i];
8491 if (offset >= params.beacon_csa.probe_resp_len)
8494 if (params.beacon_csa.probe_resp[offset] !=
8501 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
8505 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
8509 err = cfg80211_chandef_dfs_required(wdev->wiphy,
8516 params.radar_required = true;
8517 if (need_handle_dfs_flag &&
8518 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
8523 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
8524 params.block_tx = true;
8527 err = rdev_channel_switch(rdev, dev, ¶ms);
8533 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
8535 struct cfg80211_registered_device *rdev,
8536 struct wireless_dev *wdev,
8537 struct cfg80211_internal_bss *intbss)
8539 struct cfg80211_bss *res = &intbss->pub;
8540 const struct cfg80211_bss_ies *ies;
8544 ASSERT_WDEV_LOCK(wdev);
8546 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
8547 NL80211_CMD_NEW_SCAN_RESULTS);
8551 genl_dump_check_consistent(cb, hdr);
8553 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
8554 goto nla_put_failure;
8556 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
8557 goto nla_put_failure;
8558 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
8560 goto nla_put_failure;
8562 bss = nla_nest_start_noflag(msg, NL80211_ATTR_BSS);
8564 goto nla_put_failure;
8565 if ((!is_zero_ether_addr(res->bssid) &&
8566 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
8567 goto nla_put_failure;
8570 /* indicate whether we have probe response data or not */
8571 if (rcu_access_pointer(res->proberesp_ies) &&
8572 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
8573 goto fail_unlock_rcu;
8575 /* this pointer prefers to be pointed to probe response data
8576 * but is always valid
8578 ies = rcu_dereference(res->ies);
8580 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
8582 goto fail_unlock_rcu;
8583 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
8584 ies->len, ies->data))
8585 goto fail_unlock_rcu;
8588 /* and this pointer is always (unless driver didn't know) beacon data */
8589 ies = rcu_dereference(res->beacon_ies);
8590 if (ies && ies->from_beacon) {
8591 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
8593 goto fail_unlock_rcu;
8594 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
8595 ies->len, ies->data))
8596 goto fail_unlock_rcu;
8600 if (res->beacon_interval &&
8601 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
8602 goto nla_put_failure;
8603 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
8604 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
8605 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
8606 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
8607 jiffies_to_msecs(jiffies - intbss->ts)))
8608 goto nla_put_failure;
8610 if (intbss->parent_tsf &&
8611 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
8612 intbss->parent_tsf, NL80211_BSS_PAD) ||
8613 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
8614 intbss->parent_bssid)))
8615 goto nla_put_failure;
8617 if (intbss->ts_boottime &&
8618 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
8619 intbss->ts_boottime, NL80211_BSS_PAD))
8620 goto nla_put_failure;
8622 if (!nl80211_put_signal(msg, intbss->pub.chains,
8623 intbss->pub.chain_signal,
8624 NL80211_BSS_CHAIN_SIGNAL))
8625 goto nla_put_failure;
8627 switch (rdev->wiphy.signal_type) {
8628 case CFG80211_SIGNAL_TYPE_MBM:
8629 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
8630 goto nla_put_failure;
8632 case CFG80211_SIGNAL_TYPE_UNSPEC:
8633 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
8634 goto nla_put_failure;
8640 switch (wdev->iftype) {
8641 case NL80211_IFTYPE_P2P_CLIENT:
8642 case NL80211_IFTYPE_STATION:
8643 if (intbss == wdev->current_bss &&
8644 nla_put_u32(msg, NL80211_BSS_STATUS,
8645 NL80211_BSS_STATUS_ASSOCIATED))
8646 goto nla_put_failure;
8648 case NL80211_IFTYPE_ADHOC:
8649 if (intbss == wdev->current_bss &&
8650 nla_put_u32(msg, NL80211_BSS_STATUS,
8651 NL80211_BSS_STATUS_IBSS_JOINED))
8652 goto nla_put_failure;
8658 nla_nest_end(msg, bss);
8660 genlmsg_end(msg, hdr);
8666 genlmsg_cancel(msg, hdr);
8670 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
8672 struct cfg80211_registered_device *rdev;
8673 struct cfg80211_internal_bss *scan;
8674 struct wireless_dev *wdev;
8675 int start = cb->args[2], idx = 0;
8679 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
8686 spin_lock_bh(&rdev->bss_lock);
8689 * dump_scan will be called multiple times to break up the scan results
8690 * into multiple messages. It is unlikely that any more bss-es will be
8691 * expired after the first call, so only call only call this on the
8692 * first dump_scan invocation.
8695 cfg80211_bss_expire(rdev);
8697 cb->seq = rdev->bss_generation;
8699 list_for_each_entry(scan, &rdev->bss_list, list) {
8702 if (nl80211_send_bss(skb, cb,
8703 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8704 rdev, wdev, scan) < 0) {
8710 spin_unlock_bh(&rdev->bss_lock);
8719 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
8720 int flags, struct net_device *dev,
8721 bool allow_radio_stats,
8722 struct survey_info *survey)
8725 struct nlattr *infoattr;
8727 /* skip radio stats if userspace didn't request them */
8728 if (!survey->channel && !allow_radio_stats)
8731 hdr = nl80211hdr_put(msg, portid, seq, flags,
8732 NL80211_CMD_NEW_SURVEY_RESULTS);
8736 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
8737 goto nla_put_failure;
8739 infoattr = nla_nest_start_noflag(msg, NL80211_ATTR_SURVEY_INFO);
8741 goto nla_put_failure;
8743 if (survey->channel &&
8744 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
8745 survey->channel->center_freq))
8746 goto nla_put_failure;
8748 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
8749 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
8750 goto nla_put_failure;
8751 if ((survey->filled & SURVEY_INFO_IN_USE) &&
8752 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
8753 goto nla_put_failure;
8754 if ((survey->filled & SURVEY_INFO_TIME) &&
8755 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
8756 survey->time, NL80211_SURVEY_INFO_PAD))
8757 goto nla_put_failure;
8758 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
8759 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
8760 survey->time_busy, NL80211_SURVEY_INFO_PAD))
8761 goto nla_put_failure;
8762 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
8763 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
8764 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
8765 goto nla_put_failure;
8766 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
8767 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
8768 survey->time_rx, NL80211_SURVEY_INFO_PAD))
8769 goto nla_put_failure;
8770 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
8771 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
8772 survey->time_tx, NL80211_SURVEY_INFO_PAD))
8773 goto nla_put_failure;
8774 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
8775 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
8776 survey->time_scan, NL80211_SURVEY_INFO_PAD))
8777 goto nla_put_failure;
8779 nla_nest_end(msg, infoattr);
8781 genlmsg_end(msg, hdr);
8785 genlmsg_cancel(msg, hdr);
8789 static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
8791 struct nlattr **attrbuf;
8792 struct survey_info survey;
8793 struct cfg80211_registered_device *rdev;
8794 struct wireless_dev *wdev;
8795 int survey_idx = cb->args[2];
8799 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
8804 res = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
8808 /* prepare_wdev_dump parsed the attributes */
8809 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
8811 if (!wdev->netdev) {
8816 if (!rdev->ops->dump_survey) {
8822 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
8828 /* don't send disabled channels, but do send non-channel data */
8829 if (survey.channel &&
8830 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
8835 if (nl80211_send_survey(skb,
8836 NETLINK_CB(cb->skb).portid,
8837 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8838 wdev->netdev, radio_stats, &survey) < 0)
8844 cb->args[2] = survey_idx;
8852 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
8854 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
8855 NL80211_WPA_VERSION_2 |
8856 NL80211_WPA_VERSION_3));
8859 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
8861 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8862 struct net_device *dev = info->user_ptr[1];
8863 struct ieee80211_channel *chan;
8864 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
8865 int err, ssid_len, ie_len = 0, auth_data_len = 0;
8866 enum nl80211_auth_type auth_type;
8867 struct key_parse key;
8868 bool local_state_change;
8870 if (!info->attrs[NL80211_ATTR_MAC])
8873 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
8876 if (!info->attrs[NL80211_ATTR_SSID])
8879 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
8882 err = nl80211_parse_key(info, &key);
8887 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
8889 if (!key.p.key || !key.p.key_len)
8891 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
8892 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
8893 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
8894 key.p.key_len != WLAN_KEY_LEN_WEP104))
8907 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
8908 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
8917 if (!rdev->ops->auth)
8920 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
8921 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8924 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
8925 chan = nl80211_get_valid_chan(&rdev->wiphy,
8926 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8930 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8931 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8933 if (info->attrs[NL80211_ATTR_IE]) {
8934 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8935 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8938 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
8939 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
8942 if ((auth_type == NL80211_AUTHTYPE_SAE ||
8943 auth_type == NL80211_AUTHTYPE_FILS_SK ||
8944 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
8945 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
8946 !info->attrs[NL80211_ATTR_AUTH_DATA])
8949 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
8950 if (auth_type != NL80211_AUTHTYPE_SAE &&
8951 auth_type != NL80211_AUTHTYPE_FILS_SK &&
8952 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
8953 auth_type != NL80211_AUTHTYPE_FILS_PK)
8955 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
8956 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
8957 /* need to include at least Auth Transaction and Status Code */
8958 if (auth_data_len < 4)
8962 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8965 * Since we no longer track auth state, ignore
8966 * requests to only change local state.
8968 if (local_state_change)
8971 wdev_lock(dev->ieee80211_ptr);
8972 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
8973 ssid, ssid_len, ie, ie_len,
8974 key.p.key, key.p.key_len, key.idx,
8975 auth_data, auth_data_len);
8976 wdev_unlock(dev->ieee80211_ptr);
8980 static int validate_pae_over_nl80211(struct cfg80211_registered_device *rdev,
8981 struct genl_info *info)
8983 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8984 GENL_SET_ERR_MSG(info, "SOCKET_OWNER not set");
8988 if (!rdev->ops->tx_control_port ||
8989 !wiphy_ext_feature_isset(&rdev->wiphy,
8990 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
8996 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
8997 struct genl_info *info,
8998 struct cfg80211_crypto_settings *settings,
9001 memset(settings, 0, sizeof(*settings));
9003 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
9005 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
9008 proto = nla_get_u16(
9009 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
9010 settings->control_port_ethertype = cpu_to_be16(proto);
9011 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
9014 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
9015 settings->control_port_no_encrypt = true;
9017 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
9019 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
9020 int r = validate_pae_over_nl80211(rdev, info);
9025 settings->control_port_over_nl80211 = true;
9028 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
9032 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
9033 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
9034 settings->n_ciphers_pairwise = len / sizeof(u32);
9036 if (len % sizeof(u32))
9039 if (settings->n_ciphers_pairwise > cipher_limit)
9042 memcpy(settings->ciphers_pairwise, data, len);
9044 for (i = 0; i < settings->n_ciphers_pairwise; i++)
9045 if (!cfg80211_supported_cipher_suite(
9047 settings->ciphers_pairwise[i]))
9051 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
9052 settings->cipher_group =
9053 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
9054 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
9055 settings->cipher_group))
9059 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
9060 settings->wpa_versions =
9061 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
9062 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
9066 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
9070 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
9071 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
9072 settings->n_akm_suites = len / sizeof(u32);
9074 if (len % sizeof(u32))
9077 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
9080 memcpy(settings->akm_suites, data, len);
9083 if (info->attrs[NL80211_ATTR_PMK]) {
9084 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
9086 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9087 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
9089 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9092 if (info->attrs[NL80211_ATTR_SAE_PASSWORD]) {
9093 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9094 NL80211_EXT_FEATURE_SAE_OFFLOAD))
9097 nla_data(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
9098 settings->sae_pwd_len =
9099 nla_len(info->attrs[NL80211_ATTR_SAE_PASSWORD]);
9105 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
9107 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9108 struct net_device *dev = info->user_ptr[1];
9109 struct ieee80211_channel *chan;
9110 struct cfg80211_assoc_request req = {};
9111 const u8 *bssid, *ssid;
9112 int err, ssid_len = 0;
9114 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9115 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9118 if (!info->attrs[NL80211_ATTR_MAC] ||
9119 !info->attrs[NL80211_ATTR_SSID] ||
9120 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
9123 if (!rdev->ops->assoc)
9126 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9127 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9130 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9132 chan = nl80211_get_valid_chan(&rdev->wiphy,
9133 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
9137 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9138 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9140 if (info->attrs[NL80211_ATTR_IE]) {
9141 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9142 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9145 if (info->attrs[NL80211_ATTR_USE_MFP]) {
9146 enum nl80211_mfp mfp =
9147 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
9148 if (mfp == NL80211_MFP_REQUIRED)
9150 else if (mfp != NL80211_MFP_NO)
9154 if (info->attrs[NL80211_ATTR_PREV_BSSID])
9155 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
9157 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
9158 req.flags |= ASSOC_REQ_DISABLE_HT;
9160 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9161 memcpy(&req.ht_capa_mask,
9162 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9163 sizeof(req.ht_capa_mask));
9165 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9166 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9168 memcpy(&req.ht_capa,
9169 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9170 sizeof(req.ht_capa));
9173 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
9174 req.flags |= ASSOC_REQ_DISABLE_VHT;
9176 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9177 memcpy(&req.vht_capa_mask,
9178 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
9179 sizeof(req.vht_capa_mask));
9181 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
9182 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9184 memcpy(&req.vht_capa,
9185 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
9186 sizeof(req.vht_capa));
9189 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
9190 if (!((rdev->wiphy.features &
9191 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
9192 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
9193 !wiphy_ext_feature_isset(&rdev->wiphy,
9194 NL80211_EXT_FEATURE_RRM))
9196 req.flags |= ASSOC_REQ_USE_RRM;
9199 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
9200 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
9201 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
9202 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
9205 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
9208 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
9210 wdev_lock(dev->ieee80211_ptr);
9212 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
9213 ssid, ssid_len, &req);
9215 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9216 dev->ieee80211_ptr->conn_owner_nlportid =
9218 memcpy(dev->ieee80211_ptr->disconnect_bssid,
9222 wdev_unlock(dev->ieee80211_ptr);
9228 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
9230 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9231 struct net_device *dev = info->user_ptr[1];
9232 const u8 *ie = NULL, *bssid;
9233 int ie_len = 0, err;
9235 bool local_state_change;
9237 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9238 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9241 if (!info->attrs[NL80211_ATTR_MAC])
9244 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9247 if (!rdev->ops->deauth)
9250 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9251 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9254 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9256 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9257 if (reason_code == 0) {
9258 /* Reason Code 0 is reserved */
9262 if (info->attrs[NL80211_ATTR_IE]) {
9263 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9264 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9267 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
9269 wdev_lock(dev->ieee80211_ptr);
9270 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
9271 local_state_change);
9272 wdev_unlock(dev->ieee80211_ptr);
9276 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
9278 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9279 struct net_device *dev = info->user_ptr[1];
9280 const u8 *ie = NULL, *bssid;
9281 int ie_len = 0, err;
9283 bool local_state_change;
9285 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9286 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9289 if (!info->attrs[NL80211_ATTR_MAC])
9292 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9295 if (!rdev->ops->disassoc)
9298 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9299 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9302 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9304 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9305 if (reason_code == 0) {
9306 /* Reason Code 0 is reserved */
9310 if (info->attrs[NL80211_ATTR_IE]) {
9311 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9312 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9315 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
9317 wdev_lock(dev->ieee80211_ptr);
9318 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
9319 local_state_change);
9320 wdev_unlock(dev->ieee80211_ptr);
9325 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
9326 int mcast_rate[NUM_NL80211_BANDS],
9329 struct wiphy *wiphy = &rdev->wiphy;
9333 for (band = 0; band < NUM_NL80211_BANDS; band++) {
9334 struct ieee80211_supported_band *sband;
9336 sband = wiphy->bands[band];
9340 for (i = 0; i < sband->n_bitrates; i++) {
9341 if (sband->bitrates[i].bitrate == rateval) {
9342 mcast_rate[band] = i + 1;
9352 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
9354 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9355 struct net_device *dev = info->user_ptr[1];
9356 struct cfg80211_ibss_params ibss;
9357 struct wiphy *wiphy;
9358 struct cfg80211_cached_keys *connkeys = NULL;
9361 memset(&ibss, 0, sizeof(ibss));
9363 if (!info->attrs[NL80211_ATTR_SSID] ||
9364 !nla_len(info->attrs[NL80211_ATTR_SSID]))
9367 ibss.beacon_interval = 100;
9369 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
9370 ibss.beacon_interval =
9371 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
9373 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
9374 ibss.beacon_interval);
9378 if (!rdev->ops->join_ibss)
9381 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
9384 wiphy = &rdev->wiphy;
9386 if (info->attrs[NL80211_ATTR_MAC]) {
9387 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9389 if (!is_valid_ether_addr(ibss.bssid))
9392 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9393 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9395 if (info->attrs[NL80211_ATTR_IE]) {
9396 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9397 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9400 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
9404 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
9405 NL80211_IFTYPE_ADHOC))
9408 switch (ibss.chandef.width) {
9409 case NL80211_CHAN_WIDTH_5:
9410 case NL80211_CHAN_WIDTH_10:
9411 case NL80211_CHAN_WIDTH_20_NOHT:
9413 case NL80211_CHAN_WIDTH_20:
9414 case NL80211_CHAN_WIDTH_40:
9415 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
9418 case NL80211_CHAN_WIDTH_80:
9419 case NL80211_CHAN_WIDTH_80P80:
9420 case NL80211_CHAN_WIDTH_160:
9421 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
9423 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9424 NL80211_EXT_FEATURE_VHT_IBSS))
9431 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
9432 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
9434 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9436 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9438 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9439 struct ieee80211_supported_band *sband =
9440 wiphy->bands[ibss.chandef.chan->band];
9442 err = ieee80211_get_ratemask(sband, rates, n_rates,
9448 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9449 memcpy(&ibss.ht_capa_mask,
9450 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9451 sizeof(ibss.ht_capa_mask));
9453 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9454 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9456 memcpy(&ibss.ht_capa,
9457 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9458 sizeof(ibss.ht_capa));
9461 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
9462 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
9463 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
9466 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
9469 connkeys = nl80211_parse_connkeys(rdev, info, &no_ht);
9470 if (IS_ERR(connkeys))
9471 return PTR_ERR(connkeys);
9473 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
9481 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
9483 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
9484 int r = validate_pae_over_nl80211(rdev, info);
9491 ibss.control_port_over_nl80211 = true;
9494 ibss.userspace_handles_dfs =
9495 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
9497 wdev_lock(dev->ieee80211_ptr);
9498 err = __cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
9501 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
9502 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9503 wdev_unlock(dev->ieee80211_ptr);
9508 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
9510 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9511 struct net_device *dev = info->user_ptr[1];
9513 if (!rdev->ops->leave_ibss)
9516 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
9519 return cfg80211_leave_ibss(rdev, dev, false);
9522 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
9524 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9525 struct net_device *dev = info->user_ptr[1];
9526 int mcast_rate[NUM_NL80211_BANDS];
9530 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
9531 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
9532 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
9535 if (!rdev->ops->set_mcast_rate)
9538 memset(mcast_rate, 0, sizeof(mcast_rate));
9540 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
9543 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
9544 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
9547 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
9552 static struct sk_buff *
9553 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
9554 struct wireless_dev *wdev, int approxlen,
9555 u32 portid, u32 seq, enum nl80211_commands cmd,
9556 enum nl80211_attrs attr,
9557 const struct nl80211_vendor_cmd_info *info,
9560 struct sk_buff *skb;
9562 struct nlattr *data;
9564 skb = nlmsg_new(approxlen + 100, gfp);
9568 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
9574 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
9575 goto nla_put_failure;
9578 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
9580 goto nla_put_failure;
9581 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
9583 goto nla_put_failure;
9587 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
9588 wdev_id(wdev), NL80211_ATTR_PAD))
9589 goto nla_put_failure;
9591 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
9592 wdev->netdev->ifindex))
9593 goto nla_put_failure;
9596 data = nla_nest_start_noflag(skb, attr);
9598 goto nla_put_failure;
9600 ((void **)skb->cb)[0] = rdev;
9601 ((void **)skb->cb)[1] = hdr;
9602 ((void **)skb->cb)[2] = data;
9611 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
9612 struct wireless_dev *wdev,
9613 enum nl80211_commands cmd,
9614 enum nl80211_attrs attr,
9615 unsigned int portid,
9616 int vendor_event_idx,
9617 int approxlen, gfp_t gfp)
9619 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
9620 const struct nl80211_vendor_cmd_info *info;
9623 case NL80211_CMD_TESTMODE:
9624 if (WARN_ON(vendor_event_idx != -1))
9628 case NL80211_CMD_VENDOR:
9629 if (WARN_ON(vendor_event_idx < 0 ||
9630 vendor_event_idx >= wiphy->n_vendor_events))
9632 info = &wiphy->vendor_events[vendor_event_idx];
9639 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, portid, 0,
9640 cmd, attr, info, gfp);
9642 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
9644 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
9646 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
9647 void *hdr = ((void **)skb->cb)[1];
9648 struct nlmsghdr *nlhdr = nlmsg_hdr(skb);
9649 struct nlattr *data = ((void **)skb->cb)[2];
9650 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
9652 /* clear CB data for netlink core to own from now on */
9653 memset(skb->cb, 0, sizeof(skb->cb));
9655 nla_nest_end(skb, data);
9656 genlmsg_end(skb, hdr);
9658 if (nlhdr->nlmsg_pid) {
9659 genlmsg_unicast(wiphy_net(&rdev->wiphy), skb,
9662 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
9663 mcgrp = NL80211_MCGRP_VENDOR;
9665 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
9666 skb, 0, mcgrp, gfp);
9669 EXPORT_SYMBOL(__cfg80211_send_event_skb);
9671 #ifdef CONFIG_NL80211_TESTMODE
9672 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
9674 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9675 struct wireless_dev *wdev =
9676 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
9679 if (!rdev->ops->testmode_cmd)
9683 err = PTR_ERR(wdev);
9687 } else if (wdev->wiphy != &rdev->wiphy) {
9691 if (!info->attrs[NL80211_ATTR_TESTDATA])
9694 rdev->cur_cmd_info = info;
9695 err = rdev_testmode_cmd(rdev, wdev,
9696 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
9697 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
9698 rdev->cur_cmd_info = NULL;
9703 static int nl80211_testmode_dump(struct sk_buff *skb,
9704 struct netlink_callback *cb)
9706 struct cfg80211_registered_device *rdev;
9707 struct nlattr **attrbuf = NULL;
9717 * 0 is a valid index, but not valid for args[0],
9718 * so we need to offset by 1.
9720 phy_idx = cb->args[0] - 1;
9722 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
9728 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf),
9735 err = nlmsg_parse_deprecated(cb->nlh,
9736 GENL_HDRLEN + nl80211_fam.hdrsize,
9737 attrbuf, nl80211_fam.maxattr,
9738 nl80211_policy, NULL);
9742 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
9744 err = PTR_ERR(rdev);
9747 phy_idx = rdev->wiphy_idx;
9749 if (attrbuf[NL80211_ATTR_TESTDATA])
9750 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
9754 data = nla_data((void *)cb->args[1]);
9755 data_len = nla_len((void *)cb->args[1]);
9758 if (!rdev->ops->testmode_dump) {
9764 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
9765 cb->nlh->nlmsg_seq, NLM_F_MULTI,
9766 NL80211_CMD_TESTMODE);
9767 struct nlattr *tmdata;
9772 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
9773 genlmsg_cancel(skb, hdr);
9777 tmdata = nla_nest_start_noflag(skb, NL80211_ATTR_TESTDATA);
9779 genlmsg_cancel(skb, hdr);
9782 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
9783 nla_nest_end(skb, tmdata);
9785 if (err == -ENOBUFS || err == -ENOENT) {
9786 genlmsg_cancel(skb, hdr);
9789 genlmsg_cancel(skb, hdr);
9793 genlmsg_end(skb, hdr);
9798 cb->args[0] = phy_idx + 1;
9806 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
9808 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9809 struct net_device *dev = info->user_ptr[1];
9810 struct cfg80211_connect_params connect;
9811 struct wiphy *wiphy;
9812 struct cfg80211_cached_keys *connkeys = NULL;
9815 memset(&connect, 0, sizeof(connect));
9817 if (!info->attrs[NL80211_ATTR_SSID] ||
9818 !nla_len(info->attrs[NL80211_ATTR_SSID]))
9821 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
9823 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
9824 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
9825 NL80211_CMD_CONNECT))
9828 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
9830 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
9832 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
9833 !wiphy_ext_feature_isset(&rdev->wiphy,
9834 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
9836 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
9838 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
9839 NL80211_MAX_NR_CIPHER_SUITES);
9843 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9844 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9847 wiphy = &rdev->wiphy;
9849 connect.bg_scan_period = -1;
9850 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
9851 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
9852 connect.bg_scan_period =
9853 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
9856 if (info->attrs[NL80211_ATTR_MAC])
9857 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9858 else if (info->attrs[NL80211_ATTR_MAC_HINT])
9859 connect.bssid_hint =
9860 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
9861 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9862 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9864 if (info->attrs[NL80211_ATTR_IE]) {
9865 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9866 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9869 if (info->attrs[NL80211_ATTR_USE_MFP]) {
9870 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
9871 if (connect.mfp == NL80211_MFP_OPTIONAL &&
9872 !wiphy_ext_feature_isset(&rdev->wiphy,
9873 NL80211_EXT_FEATURE_MFP_OPTIONAL))
9876 connect.mfp = NL80211_MFP_NO;
9879 if (info->attrs[NL80211_ATTR_PREV_BSSID])
9880 connect.prev_bssid =
9881 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
9883 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
9884 connect.channel = nl80211_get_valid_chan(
9885 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
9886 if (!connect.channel)
9888 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
9889 connect.channel_hint = nl80211_get_valid_chan(
9890 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
9891 if (!connect.channel_hint)
9895 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
9896 connkeys = nl80211_parse_connkeys(rdev, info, NULL);
9897 if (IS_ERR(connkeys))
9898 return PTR_ERR(connkeys);
9901 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
9902 connect.flags |= ASSOC_REQ_DISABLE_HT;
9904 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9905 memcpy(&connect.ht_capa_mask,
9906 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9907 sizeof(connect.ht_capa_mask));
9909 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9910 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
9914 memcpy(&connect.ht_capa,
9915 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9916 sizeof(connect.ht_capa));
9919 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
9920 connect.flags |= ASSOC_REQ_DISABLE_VHT;
9922 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9923 memcpy(&connect.vht_capa_mask,
9924 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
9925 sizeof(connect.vht_capa_mask));
9927 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
9928 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
9932 memcpy(&connect.vht_capa,
9933 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
9934 sizeof(connect.vht_capa));
9937 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
9938 if (!((rdev->wiphy.features &
9939 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
9940 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
9941 !wiphy_ext_feature_isset(&rdev->wiphy,
9942 NL80211_EXT_FEATURE_RRM)) {
9946 connect.flags |= ASSOC_REQ_USE_RRM;
9949 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
9950 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
9955 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
9956 /* bss selection makes no sense if bssid is set */
9957 if (connect.bssid) {
9962 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
9963 wiphy, &connect.bss_select);
9970 if (wiphy_ext_feature_isset(&rdev->wiphy,
9971 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
9972 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
9973 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
9974 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
9975 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9976 connect.fils_erp_username =
9977 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9978 connect.fils_erp_username_len =
9979 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9980 connect.fils_erp_realm =
9981 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9982 connect.fils_erp_realm_len =
9983 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9984 connect.fils_erp_next_seq_num =
9986 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
9987 connect.fils_erp_rrk =
9988 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9989 connect.fils_erp_rrk_len =
9990 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9991 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
9992 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
9993 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
9994 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9999 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
10000 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10002 GENL_SET_ERR_MSG(info,
10003 "external auth requires connection ownership");
10006 connect.flags |= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT;
10009 wdev_lock(dev->ieee80211_ptr);
10011 err = cfg80211_connect(rdev, dev, &connect, connkeys,
10012 connect.prev_bssid);
10016 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
10017 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
10019 memcpy(dev->ieee80211_ptr->disconnect_bssid,
10020 connect.bssid, ETH_ALEN);
10022 memset(dev->ieee80211_ptr->disconnect_bssid,
10026 wdev_unlock(dev->ieee80211_ptr);
10031 static int nl80211_update_connect_params(struct sk_buff *skb,
10032 struct genl_info *info)
10034 struct cfg80211_connect_params connect = {};
10035 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10036 struct net_device *dev = info->user_ptr[1];
10037 struct wireless_dev *wdev = dev->ieee80211_ptr;
10038 bool fils_sk_offload;
10043 if (!rdev->ops->update_connect_params)
10044 return -EOPNOTSUPP;
10046 if (info->attrs[NL80211_ATTR_IE]) {
10047 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
10048 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
10049 changed |= UPDATE_ASSOC_IES;
10052 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy,
10053 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD);
10056 * when driver supports fils-sk offload all attributes must be
10057 * provided. So the else covers "fils-sk-not-all" and
10058 * "no-fils-sk-any".
10060 if (fils_sk_offload &&
10061 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
10062 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
10063 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
10064 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10065 connect.fils_erp_username =
10066 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10067 connect.fils_erp_username_len =
10068 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
10069 connect.fils_erp_realm =
10070 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10071 connect.fils_erp_realm_len =
10072 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
10073 connect.fils_erp_next_seq_num =
10075 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
10076 connect.fils_erp_rrk =
10077 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10078 connect.fils_erp_rrk_len =
10079 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
10080 changed |= UPDATE_FILS_ERP_INFO;
10081 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
10082 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
10083 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
10084 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
10088 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
10089 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
10090 if (!nl80211_valid_auth_type(rdev, auth_type,
10091 NL80211_CMD_CONNECT))
10094 if (auth_type == NL80211_AUTHTYPE_FILS_SK &&
10095 fils_sk_offload && !(changed & UPDATE_FILS_ERP_INFO))
10098 connect.auth_type = auth_type;
10099 changed |= UPDATE_AUTH_TYPE;
10102 wdev_lock(dev->ieee80211_ptr);
10103 if (!wdev->current_bss)
10106 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
10107 wdev_unlock(dev->ieee80211_ptr);
10112 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
10114 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10115 struct net_device *dev = info->user_ptr[1];
10119 if (dev->ieee80211_ptr->conn_owner_nlportid &&
10120 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
10123 if (!info->attrs[NL80211_ATTR_REASON_CODE])
10124 reason = WLAN_REASON_DEAUTH_LEAVING;
10126 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
10131 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10132 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10133 return -EOPNOTSUPP;
10135 wdev_lock(dev->ieee80211_ptr);
10136 ret = cfg80211_disconnect(rdev, dev, reason, true);
10137 wdev_unlock(dev->ieee80211_ptr);
10141 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
10143 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10147 if (info->attrs[NL80211_ATTR_PID]) {
10148 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
10150 net = get_net_ns_by_pid(pid);
10151 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
10152 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
10154 net = get_net_ns_by_fd(fd);
10160 return PTR_ERR(net);
10164 /* check if anything to do */
10165 if (!net_eq(wiphy_net(&rdev->wiphy), net))
10166 err = cfg80211_switch_netns(rdev, net);
10172 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
10174 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10175 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
10176 struct cfg80211_pmksa *pmksa) = NULL;
10177 struct net_device *dev = info->user_ptr[1];
10178 struct cfg80211_pmksa pmksa;
10180 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
10182 if (!info->attrs[NL80211_ATTR_PMKID])
10185 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
10187 if (info->attrs[NL80211_ATTR_MAC]) {
10188 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
10189 } else if (info->attrs[NL80211_ATTR_SSID] &&
10190 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
10191 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
10192 info->attrs[NL80211_ATTR_PMK])) {
10193 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
10194 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
10196 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
10200 if (info->attrs[NL80211_ATTR_PMK]) {
10201 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
10202 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
10205 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10206 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT &&
10207 !(dev->ieee80211_ptr->iftype == NL80211_IFTYPE_AP &&
10208 wiphy_ext_feature_isset(&rdev->wiphy,
10209 NL80211_EXT_FEATURE_AP_PMKSA_CACHING)))
10210 return -EOPNOTSUPP;
10212 switch (info->genlhdr->cmd) {
10213 case NL80211_CMD_SET_PMKSA:
10214 rdev_ops = rdev->ops->set_pmksa;
10216 case NL80211_CMD_DEL_PMKSA:
10217 rdev_ops = rdev->ops->del_pmksa;
10225 return -EOPNOTSUPP;
10227 return rdev_ops(&rdev->wiphy, dev, &pmksa);
10230 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
10232 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10233 struct net_device *dev = info->user_ptr[1];
10235 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
10236 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
10237 return -EOPNOTSUPP;
10239 if (!rdev->ops->flush_pmksa)
10240 return -EOPNOTSUPP;
10242 return rdev_flush_pmksa(rdev, dev);
10245 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
10247 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10248 struct net_device *dev = info->user_ptr[1];
10249 u8 action_code, dialog_token;
10250 u32 peer_capability = 0;
10255 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
10256 !rdev->ops->tdls_mgmt)
10257 return -EOPNOTSUPP;
10259 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
10260 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
10261 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
10262 !info->attrs[NL80211_ATTR_IE] ||
10263 !info->attrs[NL80211_ATTR_MAC])
10266 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
10267 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
10268 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
10269 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
10270 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
10271 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
10273 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
10275 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
10276 dialog_token, status_code, peer_capability,
10278 nla_data(info->attrs[NL80211_ATTR_IE]),
10279 nla_len(info->attrs[NL80211_ATTR_IE]));
10282 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
10284 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10285 struct net_device *dev = info->user_ptr[1];
10286 enum nl80211_tdls_operation operation;
10289 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
10290 !rdev->ops->tdls_oper)
10291 return -EOPNOTSUPP;
10293 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
10294 !info->attrs[NL80211_ATTR_MAC])
10297 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
10298 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
10300 return rdev_tdls_oper(rdev, dev, peer, operation);
10303 static int nl80211_remain_on_channel(struct sk_buff *skb,
10304 struct genl_info *info)
10306 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10307 struct wireless_dev *wdev = info->user_ptr[1];
10308 struct cfg80211_chan_def chandef;
10309 const struct cfg80211_chan_def *compat_chandef;
10310 struct sk_buff *msg;
10316 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
10317 !info->attrs[NL80211_ATTR_DURATION])
10320 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
10322 if (!rdev->ops->remain_on_channel ||
10323 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
10324 return -EOPNOTSUPP;
10327 * We should be on that channel for at least a minimum amount of
10328 * time (10ms) but no longer than the driver supports.
10330 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
10331 duration > rdev->wiphy.max_remain_on_channel_duration)
10334 err = nl80211_parse_chandef(rdev, info, &chandef);
10339 if (!cfg80211_off_channel_oper_allowed(wdev) &&
10340 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
10341 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
10343 if (compat_chandef != &chandef) {
10350 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10354 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10355 NL80211_CMD_REMAIN_ON_CHANNEL);
10361 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
10362 duration, &cookie);
10367 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10369 goto nla_put_failure;
10371 genlmsg_end(msg, hdr);
10373 return genlmsg_reply(msg, info);
10382 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
10383 struct genl_info *info)
10385 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10386 struct wireless_dev *wdev = info->user_ptr[1];
10389 if (!info->attrs[NL80211_ATTR_COOKIE])
10392 if (!rdev->ops->cancel_remain_on_channel)
10393 return -EOPNOTSUPP;
10395 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
10397 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
10400 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
10401 struct genl_info *info)
10403 struct cfg80211_bitrate_mask mask;
10404 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10405 struct net_device *dev = info->user_ptr[1];
10408 if (!rdev->ops->set_bitrate_mask)
10409 return -EOPNOTSUPP;
10411 err = nl80211_parse_tx_bitrate_mask(info, &mask);
10415 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
10418 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
10420 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10421 struct wireless_dev *wdev = info->user_ptr[1];
10422 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
10424 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
10427 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
10428 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
10430 switch (wdev->iftype) {
10431 case NL80211_IFTYPE_STATION:
10432 case NL80211_IFTYPE_ADHOC:
10433 case NL80211_IFTYPE_P2P_CLIENT:
10434 case NL80211_IFTYPE_AP:
10435 case NL80211_IFTYPE_AP_VLAN:
10436 case NL80211_IFTYPE_MESH_POINT:
10437 case NL80211_IFTYPE_P2P_GO:
10438 case NL80211_IFTYPE_P2P_DEVICE:
10440 case NL80211_IFTYPE_NAN:
10442 return -EOPNOTSUPP;
10445 /* not much point in registering if we can't reply */
10446 if (!rdev->ops->mgmt_tx)
10447 return -EOPNOTSUPP;
10449 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
10450 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
10451 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
10454 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
10456 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10457 struct wireless_dev *wdev = info->user_ptr[1];
10458 struct cfg80211_chan_def chandef;
10462 struct sk_buff *msg = NULL;
10463 struct cfg80211_mgmt_tx_params params = {
10464 .dont_wait_for_ack =
10465 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
10468 if (!info->attrs[NL80211_ATTR_FRAME])
10471 if (!rdev->ops->mgmt_tx)
10472 return -EOPNOTSUPP;
10474 switch (wdev->iftype) {
10475 case NL80211_IFTYPE_P2P_DEVICE:
10476 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
10478 case NL80211_IFTYPE_STATION:
10479 case NL80211_IFTYPE_ADHOC:
10480 case NL80211_IFTYPE_P2P_CLIENT:
10481 case NL80211_IFTYPE_AP:
10482 case NL80211_IFTYPE_AP_VLAN:
10483 case NL80211_IFTYPE_MESH_POINT:
10484 case NL80211_IFTYPE_P2P_GO:
10486 case NL80211_IFTYPE_NAN:
10488 return -EOPNOTSUPP;
10491 if (info->attrs[NL80211_ATTR_DURATION]) {
10492 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
10494 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
10497 * We should wait on the channel for at least a minimum amount
10498 * of time (10ms) but no longer than the driver supports.
10500 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
10501 params.wait > rdev->wiphy.max_remain_on_channel_duration)
10505 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
10507 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
10510 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
10512 /* get the channel if any has been specified, otherwise pass NULL to
10513 * the driver. The latter will use the current one
10515 chandef.chan = NULL;
10516 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
10517 err = nl80211_parse_chandef(rdev, info, &chandef);
10522 if (!chandef.chan && params.offchan)
10526 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
10532 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
10533 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
10535 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
10536 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
10539 if (len % sizeof(u16))
10542 params.n_csa_offsets = len / sizeof(u16);
10543 params.csa_offsets =
10544 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
10546 /* check that all the offsets fit the frame */
10547 for (i = 0; i < params.n_csa_offsets; i++) {
10548 if (params.csa_offsets[i] >= params.len)
10553 if (!params.dont_wait_for_ack) {
10554 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10558 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10559 NL80211_CMD_FRAME);
10566 params.chan = chandef.chan;
10567 err = cfg80211_mlme_mgmt_tx(rdev, wdev, ¶ms, &cookie);
10572 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10574 goto nla_put_failure;
10576 genlmsg_end(msg, hdr);
10577 return genlmsg_reply(msg, info);
10589 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
10591 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10592 struct wireless_dev *wdev = info->user_ptr[1];
10595 if (!info->attrs[NL80211_ATTR_COOKIE])
10598 if (!rdev->ops->mgmt_tx_cancel_wait)
10599 return -EOPNOTSUPP;
10601 switch (wdev->iftype) {
10602 case NL80211_IFTYPE_STATION:
10603 case NL80211_IFTYPE_ADHOC:
10604 case NL80211_IFTYPE_P2P_CLIENT:
10605 case NL80211_IFTYPE_AP:
10606 case NL80211_IFTYPE_AP_VLAN:
10607 case NL80211_IFTYPE_P2P_GO:
10608 case NL80211_IFTYPE_P2P_DEVICE:
10610 case NL80211_IFTYPE_NAN:
10612 return -EOPNOTSUPP;
10615 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
10617 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
10620 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
10622 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10623 struct wireless_dev *wdev;
10624 struct net_device *dev = info->user_ptr[1];
10629 if (!info->attrs[NL80211_ATTR_PS_STATE])
10632 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
10634 wdev = dev->ieee80211_ptr;
10636 if (!rdev->ops->set_power_mgmt)
10637 return -EOPNOTSUPP;
10639 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
10641 if (state == wdev->ps)
10644 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
10650 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
10652 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10653 enum nl80211_ps_state ps_state;
10654 struct wireless_dev *wdev;
10655 struct net_device *dev = info->user_ptr[1];
10656 struct sk_buff *msg;
10660 wdev = dev->ieee80211_ptr;
10662 if (!rdev->ops->set_power_mgmt)
10663 return -EOPNOTSUPP;
10665 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10669 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10670 NL80211_CMD_GET_POWER_SAVE);
10677 ps_state = NL80211_PS_ENABLED;
10679 ps_state = NL80211_PS_DISABLED;
10681 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
10682 goto nla_put_failure;
10684 genlmsg_end(msg, hdr);
10685 return genlmsg_reply(msg, info);
10694 static const struct nla_policy
10695 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
10696 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
10697 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
10698 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
10699 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
10700 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
10701 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
10702 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
10705 static int nl80211_set_cqm_txe(struct genl_info *info,
10706 u32 rate, u32 pkts, u32 intvl)
10708 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10709 struct net_device *dev = info->user_ptr[1];
10710 struct wireless_dev *wdev = dev->ieee80211_ptr;
10712 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
10715 if (!rdev->ops->set_cqm_txe_config)
10716 return -EOPNOTSUPP;
10718 if (wdev->iftype != NL80211_IFTYPE_STATION &&
10719 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
10720 return -EOPNOTSUPP;
10722 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
10725 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
10726 struct net_device *dev)
10728 struct wireless_dev *wdev = dev->ieee80211_ptr;
10729 s32 last, low, high;
10731 int i, n, low_index;
10734 /* RSSI reporting disabled? */
10735 if (!wdev->cqm_config)
10736 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
10739 * Obtain current RSSI value if possible, if not and no RSSI threshold
10740 * event has been received yet, we should receive an event after a
10741 * connection is established and enough beacons received to calculate
10744 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
10745 rdev->ops->get_station) {
10746 struct station_info sinfo = {};
10749 mac_addr = wdev->current_bss->pub.bssid;
10751 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
10755 if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
10756 wdev->cqm_config->last_rssi_event_value =
10757 (s8) sinfo.rx_beacon_signal_avg;
10760 last = wdev->cqm_config->last_rssi_event_value;
10761 hyst = wdev->cqm_config->rssi_hyst;
10762 n = wdev->cqm_config->n_rssi_thresholds;
10764 for (i = 0; i < n; i++)
10765 if (last < wdev->cqm_config->rssi_thresholds[i])
10769 if (low_index >= 0) {
10770 low_index = array_index_nospec(low_index, n);
10771 low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;
10776 i = array_index_nospec(i, n);
10777 high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;
10782 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
10785 static int nl80211_set_cqm_rssi(struct genl_info *info,
10786 const s32 *thresholds, int n_thresholds,
10789 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10790 struct net_device *dev = info->user_ptr[1];
10791 struct wireless_dev *wdev = dev->ieee80211_ptr;
10793 s32 prev = S32_MIN;
10795 /* Check all values negative and sorted */
10796 for (i = 0; i < n_thresholds; i++) {
10797 if (thresholds[i] > 0 || thresholds[i] <= prev)
10800 prev = thresholds[i];
10803 if (wdev->iftype != NL80211_IFTYPE_STATION &&
10804 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
10805 return -EOPNOTSUPP;
10808 cfg80211_cqm_config_free(wdev);
10811 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
10812 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
10813 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
10815 return rdev_set_cqm_rssi_config(rdev, dev,
10816 thresholds[0], hysteresis);
10819 if (!wiphy_ext_feature_isset(&rdev->wiphy,
10820 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
10821 return -EOPNOTSUPP;
10823 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
10827 if (n_thresholds) {
10828 struct cfg80211_cqm_config *cqm_config;
10830 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
10831 n_thresholds * sizeof(s32), GFP_KERNEL);
10837 cqm_config->rssi_hyst = hysteresis;
10838 cqm_config->n_rssi_thresholds = n_thresholds;
10839 memcpy(cqm_config->rssi_thresholds, thresholds,
10840 n_thresholds * sizeof(s32));
10842 wdev->cqm_config = cqm_config;
10845 err = cfg80211_cqm_rssi_update(rdev, dev);
10853 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
10855 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
10856 struct nlattr *cqm;
10859 cqm = info->attrs[NL80211_ATTR_CQM];
10863 err = nla_parse_nested_deprecated(attrs, NL80211_ATTR_CQM_MAX, cqm,
10864 nl80211_attr_cqm_policy,
10869 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
10870 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
10871 const s32 *thresholds =
10872 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
10873 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
10874 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
10879 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
10883 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
10884 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
10885 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
10886 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
10887 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
10888 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
10890 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
10896 static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
10898 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10899 struct net_device *dev = info->user_ptr[1];
10900 struct ocb_setup setup = {};
10903 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
10907 return cfg80211_join_ocb(rdev, dev, &setup);
10910 static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
10912 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10913 struct net_device *dev = info->user_ptr[1];
10915 return cfg80211_leave_ocb(rdev, dev);
10918 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
10920 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10921 struct net_device *dev = info->user_ptr[1];
10922 struct mesh_config cfg;
10923 struct mesh_setup setup;
10926 /* start with default */
10927 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
10928 memcpy(&setup, &default_mesh_setup, sizeof(setup));
10930 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
10931 /* and parse parameters if given */
10932 err = nl80211_parse_mesh_config(info, &cfg, NULL);
10937 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
10938 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
10941 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
10942 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
10944 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
10945 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
10946 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
10949 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
10950 setup.beacon_interval =
10951 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
10953 err = cfg80211_validate_beacon_int(rdev,
10954 NL80211_IFTYPE_MESH_POINT,
10955 setup.beacon_interval);
10960 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
10961 setup.dtim_period =
10962 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
10963 if (setup.dtim_period < 1 || setup.dtim_period > 100)
10967 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
10968 /* parse additional setup parameters if given */
10969 err = nl80211_parse_mesh_setup(info, &setup);
10974 if (setup.user_mpm)
10975 cfg.auto_open_plinks = false;
10977 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
10978 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
10982 /* __cfg80211_join_mesh() will sort it out */
10983 setup.chandef.chan = NULL;
10986 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
10987 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10989 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10990 struct ieee80211_supported_band *sband;
10992 if (!setup.chandef.chan)
10995 sband = rdev->wiphy.bands[setup.chandef.chan->band];
10997 err = ieee80211_get_ratemask(sband, rates, n_rates,
10998 &setup.basic_rates);
11003 if (info->attrs[NL80211_ATTR_TX_RATES]) {
11004 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
11008 if (!setup.chandef.chan)
11011 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
11012 &setup.beacon_rate);
11017 setup.userspace_handles_dfs =
11018 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
11020 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
11021 int r = validate_pae_over_nl80211(rdev, info);
11026 setup.control_port_over_nl80211 = true;
11029 wdev_lock(dev->ieee80211_ptr);
11030 err = __cfg80211_join_mesh(rdev, dev, &setup, &cfg);
11031 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER])
11032 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
11033 wdev_unlock(dev->ieee80211_ptr);
11038 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
11040 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11041 struct net_device *dev = info->user_ptr[1];
11043 return cfg80211_leave_mesh(rdev, dev);
11047 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
11048 struct cfg80211_registered_device *rdev)
11050 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
11051 struct nlattr *nl_pats, *nl_pat;
11054 if (!wowlan->n_patterns)
11057 nl_pats = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
11061 for (i = 0; i < wowlan->n_patterns; i++) {
11062 nl_pat = nla_nest_start_noflag(msg, i + 1);
11065 pat_len = wowlan->patterns[i].pattern_len;
11066 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
11067 wowlan->patterns[i].mask) ||
11068 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
11069 wowlan->patterns[i].pattern) ||
11070 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
11071 wowlan->patterns[i].pkt_offset))
11073 nla_nest_end(msg, nl_pat);
11075 nla_nest_end(msg, nl_pats);
11080 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
11081 struct cfg80211_wowlan_tcp *tcp)
11083 struct nlattr *nl_tcp;
11088 nl_tcp = nla_nest_start_noflag(msg,
11089 NL80211_WOWLAN_TRIG_TCP_CONNECTION);
11093 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
11094 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
11095 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
11096 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
11097 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
11098 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
11099 tcp->payload_len, tcp->payload) ||
11100 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
11101 tcp->data_interval) ||
11102 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
11103 tcp->wake_len, tcp->wake_data) ||
11104 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
11105 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
11108 if (tcp->payload_seq.len &&
11109 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
11110 sizeof(tcp->payload_seq), &tcp->payload_seq))
11113 if (tcp->payload_tok.len &&
11114 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
11115 sizeof(tcp->payload_tok) + tcp->tokens_size,
11116 &tcp->payload_tok))
11119 nla_nest_end(msg, nl_tcp);
11124 static int nl80211_send_wowlan_nd(struct sk_buff *msg,
11125 struct cfg80211_sched_scan_request *req)
11127 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
11133 nd = nla_nest_start_noflag(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
11137 if (req->n_scan_plans == 1 &&
11138 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
11139 req->scan_plans[0].interval * 1000))
11142 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
11145 if (req->relative_rssi_set) {
11146 struct nl80211_bss_select_rssi_adjust rssi_adjust;
11148 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
11149 req->relative_rssi))
11152 rssi_adjust.band = req->rssi_adjust.band;
11153 rssi_adjust.delta = req->rssi_adjust.delta;
11154 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
11155 sizeof(rssi_adjust), &rssi_adjust))
11159 freqs = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES);
11163 for (i = 0; i < req->n_channels; i++) {
11164 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
11168 nla_nest_end(msg, freqs);
11170 if (req->n_match_sets) {
11171 matches = nla_nest_start_noflag(msg,
11172 NL80211_ATTR_SCHED_SCAN_MATCH);
11176 for (i = 0; i < req->n_match_sets; i++) {
11177 match = nla_nest_start_noflag(msg, i);
11181 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
11182 req->match_sets[i].ssid.ssid_len,
11183 req->match_sets[i].ssid.ssid))
11185 nla_nest_end(msg, match);
11187 nla_nest_end(msg, matches);
11190 scan_plans = nla_nest_start_noflag(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
11194 for (i = 0; i < req->n_scan_plans; i++) {
11195 scan_plan = nla_nest_start_noflag(msg, i + 1);
11199 if (nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
11200 req->scan_plans[i].interval) ||
11201 (req->scan_plans[i].iterations &&
11202 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
11203 req->scan_plans[i].iterations)))
11205 nla_nest_end(msg, scan_plan);
11207 nla_nest_end(msg, scan_plans);
11209 nla_nest_end(msg, nd);
11214 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
11216 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11217 struct sk_buff *msg;
11219 u32 size = NLMSG_DEFAULT_SIZE;
11221 if (!rdev->wiphy.wowlan)
11222 return -EOPNOTSUPP;
11224 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
11225 /* adjust size to have room for all the data */
11226 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
11227 rdev->wiphy.wowlan_config->tcp->payload_len +
11228 rdev->wiphy.wowlan_config->tcp->wake_len +
11229 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
11232 msg = nlmsg_new(size, GFP_KERNEL);
11236 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11237 NL80211_CMD_GET_WOWLAN);
11239 goto nla_put_failure;
11241 if (rdev->wiphy.wowlan_config) {
11242 struct nlattr *nl_wowlan;
11244 nl_wowlan = nla_nest_start_noflag(msg,
11245 NL80211_ATTR_WOWLAN_TRIGGERS);
11247 goto nla_put_failure;
11249 if ((rdev->wiphy.wowlan_config->any &&
11250 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
11251 (rdev->wiphy.wowlan_config->disconnect &&
11252 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
11253 (rdev->wiphy.wowlan_config->magic_pkt &&
11254 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
11255 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
11256 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
11257 (rdev->wiphy.wowlan_config->eap_identity_req &&
11258 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
11259 (rdev->wiphy.wowlan_config->four_way_handshake &&
11260 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
11261 (rdev->wiphy.wowlan_config->rfkill_release &&
11262 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
11263 goto nla_put_failure;
11265 if (nl80211_send_wowlan_patterns(msg, rdev))
11266 goto nla_put_failure;
11268 if (nl80211_send_wowlan_tcp(msg,
11269 rdev->wiphy.wowlan_config->tcp))
11270 goto nla_put_failure;
11272 if (nl80211_send_wowlan_nd(
11274 rdev->wiphy.wowlan_config->nd_config))
11275 goto nla_put_failure;
11277 nla_nest_end(msg, nl_wowlan);
11280 genlmsg_end(msg, hdr);
11281 return genlmsg_reply(msg, info);
11288 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
11289 struct nlattr *attr,
11290 struct cfg80211_wowlan *trig)
11292 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
11293 struct cfg80211_wowlan_tcp *cfg;
11294 struct nl80211_wowlan_tcp_data_token *tok = NULL;
11295 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
11297 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
11300 if (!rdev->wiphy.wowlan->tcp)
11303 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TCP, attr,
11304 nl80211_wowlan_tcp_policy, NULL);
11308 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
11309 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
11310 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
11311 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
11312 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
11313 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
11314 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
11315 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
11318 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
11319 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
11322 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
11323 rdev->wiphy.wowlan->tcp->data_interval_max ||
11324 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
11327 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
11328 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
11331 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
11332 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
11335 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
11336 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
11338 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
11339 tokens_size = tokln - sizeof(*tok);
11341 if (!tok->len || tokens_size % tok->len)
11343 if (!rdev->wiphy.wowlan->tcp->tok)
11345 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
11347 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
11349 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
11351 if (tok->offset + tok->len > data_size)
11355 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
11356 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
11357 if (!rdev->wiphy.wowlan->tcp->seq)
11359 if (seq->len == 0 || seq->len > 4)
11361 if (seq->len + seq->offset > data_size)
11365 size = sizeof(*cfg);
11367 size += wake_size + wake_mask_size;
11368 size += tokens_size;
11370 cfg = kzalloc(size, GFP_KERNEL);
11373 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
11374 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
11375 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
11377 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
11378 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
11382 /* allocate a socket and port for it and use it */
11383 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
11384 IPPROTO_TCP, &cfg->sock, 1);
11389 if (inet_csk_get_port(cfg->sock->sk, port)) {
11390 sock_release(cfg->sock);
11392 return -EADDRINUSE;
11394 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
11400 cfg->src_port = port;
11403 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
11404 cfg->payload_len = data_size;
11405 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
11406 memcpy((void *)cfg->payload,
11407 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
11410 cfg->payload_seq = *seq;
11411 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
11412 cfg->wake_len = wake_size;
11413 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
11414 memcpy((void *)cfg->wake_data,
11415 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
11417 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
11418 data_size + wake_size;
11419 memcpy((void *)cfg->wake_mask,
11420 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
11423 cfg->tokens_size = tokens_size;
11424 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
11432 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
11433 const struct wiphy_wowlan_support *wowlan,
11434 struct nlattr *attr,
11435 struct cfg80211_wowlan *trig)
11437 struct nlattr **tb;
11440 tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
11444 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
11449 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_MAX, attr,
11450 nl80211_policy, NULL);
11454 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
11455 wowlan->max_nd_match_sets);
11456 err = PTR_ERR_OR_ZERO(trig->nd_config);
11458 trig->nd_config = NULL;
11465 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
11467 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11468 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
11469 struct cfg80211_wowlan new_triggers = {};
11470 struct cfg80211_wowlan *ntrig;
11471 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
11473 bool prev_enabled = rdev->wiphy.wowlan_config;
11474 bool regular = false;
11477 return -EOPNOTSUPP;
11479 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
11480 cfg80211_rdev_free_wowlan(rdev);
11481 rdev->wiphy.wowlan_config = NULL;
11485 err = nla_parse_nested_deprecated(tb, MAX_NL80211_WOWLAN_TRIG,
11486 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
11487 nl80211_wowlan_policy, info->extack);
11491 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
11492 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
11494 new_triggers.any = true;
11497 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
11498 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
11500 new_triggers.disconnect = true;
11504 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
11505 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
11507 new_triggers.magic_pkt = true;
11511 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
11514 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
11515 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
11517 new_triggers.gtk_rekey_failure = true;
11521 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
11522 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
11524 new_triggers.eap_identity_req = true;
11528 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
11529 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
11531 new_triggers.four_way_handshake = true;
11535 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
11536 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
11538 new_triggers.rfkill_release = true;
11542 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
11543 struct nlattr *pat;
11544 int n_patterns = 0;
11545 int rem, pat_len, mask_len, pkt_offset;
11546 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
11550 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
11553 if (n_patterns > wowlan->n_patterns)
11556 new_triggers.patterns = kcalloc(n_patterns,
11557 sizeof(new_triggers.patterns[0]),
11559 if (!new_triggers.patterns)
11562 new_triggers.n_patterns = n_patterns;
11565 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
11569 err = nla_parse_nested_deprecated(pat_tb,
11570 MAX_NL80211_PKTPAT,
11572 nl80211_packet_pattern_policy,
11578 if (!pat_tb[NL80211_PKTPAT_MASK] ||
11579 !pat_tb[NL80211_PKTPAT_PATTERN])
11581 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
11582 mask_len = DIV_ROUND_UP(pat_len, 8);
11583 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
11585 if (pat_len > wowlan->pattern_max_len ||
11586 pat_len < wowlan->pattern_min_len)
11589 if (!pat_tb[NL80211_PKTPAT_OFFSET])
11592 pkt_offset = nla_get_u32(
11593 pat_tb[NL80211_PKTPAT_OFFSET]);
11594 if (pkt_offset > wowlan->max_pkt_offset)
11596 new_triggers.patterns[i].pkt_offset = pkt_offset;
11598 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
11603 new_triggers.patterns[i].mask = mask_pat;
11604 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
11606 mask_pat += mask_len;
11607 new_triggers.patterns[i].pattern = mask_pat;
11608 new_triggers.patterns[i].pattern_len = pat_len;
11610 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
11616 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
11618 err = nl80211_parse_wowlan_tcp(
11619 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
11625 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
11627 err = nl80211_parse_wowlan_nd(
11628 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
11634 /* The 'any' trigger means the device continues operating more or less
11635 * as in its normal operation mode and wakes up the host on most of the
11636 * normal interrupts (like packet RX, ...)
11637 * It therefore makes little sense to combine with the more constrained
11638 * wakeup trigger modes.
11640 if (new_triggers.any && regular) {
11645 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
11650 cfg80211_rdev_free_wowlan(rdev);
11651 rdev->wiphy.wowlan_config = ntrig;
11654 if (rdev->ops->set_wakeup &&
11655 prev_enabled != !!rdev->wiphy.wowlan_config)
11656 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
11660 for (i = 0; i < new_triggers.n_patterns; i++)
11661 kfree(new_triggers.patterns[i].mask);
11662 kfree(new_triggers.patterns);
11663 if (new_triggers.tcp && new_triggers.tcp->sock)
11664 sock_release(new_triggers.tcp->sock);
11665 kfree(new_triggers.tcp);
11666 kfree(new_triggers.nd_config);
11671 static int nl80211_send_coalesce_rules(struct sk_buff *msg,
11672 struct cfg80211_registered_device *rdev)
11674 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
11676 struct cfg80211_coalesce_rules *rule;
11678 if (!rdev->coalesce->n_rules)
11681 nl_rules = nla_nest_start_noflag(msg, NL80211_ATTR_COALESCE_RULE);
11685 for (i = 0; i < rdev->coalesce->n_rules; i++) {
11686 nl_rule = nla_nest_start_noflag(msg, i + 1);
11690 rule = &rdev->coalesce->rules[i];
11691 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
11695 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
11699 nl_pats = nla_nest_start_noflag(msg,
11700 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
11704 for (j = 0; j < rule->n_patterns; j++) {
11705 nl_pat = nla_nest_start_noflag(msg, j + 1);
11708 pat_len = rule->patterns[j].pattern_len;
11709 if (nla_put(msg, NL80211_PKTPAT_MASK,
11710 DIV_ROUND_UP(pat_len, 8),
11711 rule->patterns[j].mask) ||
11712 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
11713 rule->patterns[j].pattern) ||
11714 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
11715 rule->patterns[j].pkt_offset))
11717 nla_nest_end(msg, nl_pat);
11719 nla_nest_end(msg, nl_pats);
11720 nla_nest_end(msg, nl_rule);
11722 nla_nest_end(msg, nl_rules);
11727 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
11729 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11730 struct sk_buff *msg;
11733 if (!rdev->wiphy.coalesce)
11734 return -EOPNOTSUPP;
11736 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11740 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11741 NL80211_CMD_GET_COALESCE);
11743 goto nla_put_failure;
11745 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
11746 goto nla_put_failure;
11748 genlmsg_end(msg, hdr);
11749 return genlmsg_reply(msg, info);
11756 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
11758 struct cfg80211_coalesce *coalesce = rdev->coalesce;
11760 struct cfg80211_coalesce_rules *rule;
11765 for (i = 0; i < coalesce->n_rules; i++) {
11766 rule = &coalesce->rules[i];
11767 for (j = 0; j < rule->n_patterns; j++)
11768 kfree(rule->patterns[j].mask);
11769 kfree(rule->patterns);
11771 kfree(coalesce->rules);
11773 rdev->coalesce = NULL;
11776 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
11777 struct nlattr *rule,
11778 struct cfg80211_coalesce_rules *new_rule)
11781 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
11782 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
11783 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
11784 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
11786 err = nla_parse_nested_deprecated(tb, NL80211_ATTR_COALESCE_RULE_MAX,
11787 rule, nl80211_coalesce_policy, NULL);
11791 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
11793 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
11794 if (new_rule->delay > coalesce->max_delay)
11797 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
11798 new_rule->condition =
11799 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
11801 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
11804 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
11807 if (n_patterns > coalesce->n_patterns)
11810 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
11812 if (!new_rule->patterns)
11815 new_rule->n_patterns = n_patterns;
11818 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
11822 err = nla_parse_nested_deprecated(pat_tb, MAX_NL80211_PKTPAT,
11824 nl80211_packet_pattern_policy,
11829 if (!pat_tb[NL80211_PKTPAT_MASK] ||
11830 !pat_tb[NL80211_PKTPAT_PATTERN])
11832 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
11833 mask_len = DIV_ROUND_UP(pat_len, 8);
11834 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
11836 if (pat_len > coalesce->pattern_max_len ||
11837 pat_len < coalesce->pattern_min_len)
11840 if (!pat_tb[NL80211_PKTPAT_OFFSET])
11843 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
11844 if (pkt_offset > coalesce->max_pkt_offset)
11846 new_rule->patterns[i].pkt_offset = pkt_offset;
11848 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
11852 new_rule->patterns[i].mask = mask_pat;
11853 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
11856 mask_pat += mask_len;
11857 new_rule->patterns[i].pattern = mask_pat;
11858 new_rule->patterns[i].pattern_len = pat_len;
11859 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
11867 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
11869 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11870 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
11871 struct cfg80211_coalesce new_coalesce = {};
11872 struct cfg80211_coalesce *n_coalesce;
11873 int err, rem_rule, n_rules = 0, i, j;
11874 struct nlattr *rule;
11875 struct cfg80211_coalesce_rules *tmp_rule;
11877 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
11878 return -EOPNOTSUPP;
11880 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
11881 cfg80211_rdev_free_coalesce(rdev);
11882 rdev_set_coalesce(rdev, NULL);
11886 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
11889 if (n_rules > coalesce->n_rules)
11892 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
11894 if (!new_coalesce.rules)
11897 new_coalesce.n_rules = n_rules;
11900 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
11902 err = nl80211_parse_coalesce_rule(rdev, rule,
11903 &new_coalesce.rules[i]);
11910 err = rdev_set_coalesce(rdev, &new_coalesce);
11914 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
11919 cfg80211_rdev_free_coalesce(rdev);
11920 rdev->coalesce = n_coalesce;
11924 for (i = 0; i < new_coalesce.n_rules; i++) {
11925 tmp_rule = &new_coalesce.rules[i];
11926 for (j = 0; j < tmp_rule->n_patterns; j++)
11927 kfree(tmp_rule->patterns[j].mask);
11928 kfree(tmp_rule->patterns);
11930 kfree(new_coalesce.rules);
11935 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
11937 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11938 struct net_device *dev = info->user_ptr[1];
11939 struct wireless_dev *wdev = dev->ieee80211_ptr;
11940 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
11941 struct cfg80211_gtk_rekey_data rekey_data;
11944 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
11947 err = nla_parse_nested_deprecated(tb, MAX_NL80211_REKEY_DATA,
11948 info->attrs[NL80211_ATTR_REKEY_DATA],
11949 nl80211_rekey_policy, info->extack);
11953 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
11954 !tb[NL80211_REKEY_DATA_KCK])
11956 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
11958 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
11960 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
11963 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
11964 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
11965 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
11968 if (!wdev->current_bss) {
11973 if (!rdev->ops->set_rekey_data) {
11978 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
11984 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
11985 struct genl_info *info)
11987 struct net_device *dev = info->user_ptr[1];
11988 struct wireless_dev *wdev = dev->ieee80211_ptr;
11990 if (wdev->iftype != NL80211_IFTYPE_AP &&
11991 wdev->iftype != NL80211_IFTYPE_P2P_GO)
11994 if (wdev->ap_unexpected_nlportid)
11997 wdev->ap_unexpected_nlportid = info->snd_portid;
12001 static int nl80211_probe_client(struct sk_buff *skb,
12002 struct genl_info *info)
12004 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12005 struct net_device *dev = info->user_ptr[1];
12006 struct wireless_dev *wdev = dev->ieee80211_ptr;
12007 struct sk_buff *msg;
12013 if (wdev->iftype != NL80211_IFTYPE_AP &&
12014 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12015 return -EOPNOTSUPP;
12017 if (!info->attrs[NL80211_ATTR_MAC])
12020 if (!rdev->ops->probe_client)
12021 return -EOPNOTSUPP;
12023 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12027 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12028 NL80211_CMD_PROBE_CLIENT);
12034 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12036 err = rdev_probe_client(rdev, dev, addr, &cookie);
12040 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12042 goto nla_put_failure;
12044 genlmsg_end(msg, hdr);
12046 return genlmsg_reply(msg, info);
12055 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
12057 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12058 struct cfg80211_beacon_registration *reg, *nreg;
12061 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
12062 return -EOPNOTSUPP;
12064 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
12068 /* First, check if already registered. */
12069 spin_lock_bh(&rdev->beacon_registrations_lock);
12070 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
12071 if (reg->nlportid == info->snd_portid) {
12076 /* Add it to the list */
12077 nreg->nlportid = info->snd_portid;
12078 list_add(&nreg->list, &rdev->beacon_registrations);
12080 spin_unlock_bh(&rdev->beacon_registrations_lock);
12084 spin_unlock_bh(&rdev->beacon_registrations_lock);
12089 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
12091 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12092 struct wireless_dev *wdev = info->user_ptr[1];
12095 if (!rdev->ops->start_p2p_device)
12096 return -EOPNOTSUPP;
12098 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
12099 return -EOPNOTSUPP;
12101 if (wdev_running(wdev))
12104 if (rfkill_blocked(rdev->rfkill))
12107 err = rdev_start_p2p_device(rdev, wdev);
12111 wdev->is_running = true;
12117 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
12119 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12120 struct wireless_dev *wdev = info->user_ptr[1];
12122 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
12123 return -EOPNOTSUPP;
12125 if (!rdev->ops->stop_p2p_device)
12126 return -EOPNOTSUPP;
12128 cfg80211_stop_p2p_device(rdev, wdev);
12133 static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
12135 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12136 struct wireless_dev *wdev = info->user_ptr[1];
12137 struct cfg80211_nan_conf conf = {};
12140 if (wdev->iftype != NL80211_IFTYPE_NAN)
12141 return -EOPNOTSUPP;
12143 if (wdev_running(wdev))
12146 if (rfkill_blocked(rdev->rfkill))
12149 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
12153 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
12155 if (info->attrs[NL80211_ATTR_BANDS]) {
12156 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
12158 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
12159 return -EOPNOTSUPP;
12161 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
12164 conf.bands = bands;
12167 err = rdev_start_nan(rdev, wdev, &conf);
12171 wdev->is_running = true;
12177 static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
12179 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12180 struct wireless_dev *wdev = info->user_ptr[1];
12182 if (wdev->iftype != NL80211_IFTYPE_NAN)
12183 return -EOPNOTSUPP;
12185 cfg80211_stop_nan(rdev, wdev);
12190 static int validate_nan_filter(struct nlattr *filter_attr)
12192 struct nlattr *attr;
12193 int len = 0, n_entries = 0, rem;
12195 nla_for_each_nested(attr, filter_attr, rem) {
12196 len += nla_len(attr);
12206 static int handle_nan_filter(struct nlattr *attr_filter,
12207 struct cfg80211_nan_func *func,
12210 struct nlattr *attr;
12211 int n_entries, rem, i;
12212 struct cfg80211_nan_func_filter *filter;
12214 n_entries = validate_nan_filter(attr_filter);
12218 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
12220 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
12225 nla_for_each_nested(attr, attr_filter, rem) {
12226 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
12227 filter[i].len = nla_len(attr);
12231 func->num_tx_filters = n_entries;
12232 func->tx_filters = filter;
12234 func->num_rx_filters = n_entries;
12235 func->rx_filters = filter;
12241 static int nl80211_nan_add_func(struct sk_buff *skb,
12242 struct genl_info *info)
12244 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12245 struct wireless_dev *wdev = info->user_ptr[1];
12246 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
12247 struct cfg80211_nan_func *func;
12248 struct sk_buff *msg = NULL;
12252 if (wdev->iftype != NL80211_IFTYPE_NAN)
12253 return -EOPNOTSUPP;
12255 if (!wdev_running(wdev))
12258 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
12261 err = nla_parse_nested_deprecated(tb, NL80211_NAN_FUNC_ATTR_MAX,
12262 info->attrs[NL80211_ATTR_NAN_FUNC],
12263 nl80211_nan_func_policy,
12268 func = kzalloc(sizeof(*func), GFP_KERNEL);
12272 func->cookie = cfg80211_assign_cookie(rdev);
12274 if (!tb[NL80211_NAN_FUNC_TYPE] ||
12275 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
12281 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
12283 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
12288 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
12289 sizeof(func->service_id));
12291 func->close_range =
12292 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
12294 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
12295 func->serv_spec_info_len =
12296 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
12297 func->serv_spec_info =
12298 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
12299 func->serv_spec_info_len,
12301 if (!func->serv_spec_info) {
12307 if (tb[NL80211_NAN_FUNC_TTL])
12308 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
12310 switch (func->type) {
12311 case NL80211_NAN_FUNC_PUBLISH:
12312 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
12317 func->publish_type =
12318 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
12319 func->publish_bcast =
12320 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
12322 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
12323 func->publish_bcast) {
12328 case NL80211_NAN_FUNC_SUBSCRIBE:
12329 func->subscribe_active =
12330 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
12332 case NL80211_NAN_FUNC_FOLLOW_UP:
12333 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
12334 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] ||
12335 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) {
12340 func->followup_id =
12341 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
12342 func->followup_reqid =
12343 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
12344 memcpy(func->followup_dest.addr,
12345 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
12346 sizeof(func->followup_dest.addr));
12357 if (tb[NL80211_NAN_FUNC_SRF]) {
12358 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
12360 err = nla_parse_nested_deprecated(srf_tb,
12361 NL80211_NAN_SRF_ATTR_MAX,
12362 tb[NL80211_NAN_FUNC_SRF],
12363 nl80211_nan_srf_policy,
12368 func->srf_include =
12369 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
12371 if (srf_tb[NL80211_NAN_SRF_BF]) {
12372 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
12373 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
12379 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
12381 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
12382 func->srf_bf_len, GFP_KERNEL);
12383 if (!func->srf_bf) {
12389 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
12391 struct nlattr *attr, *mac_attr =
12392 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
12393 int n_entries, rem, i = 0;
12400 n_entries = validate_acl_mac_addrs(mac_attr);
12401 if (n_entries <= 0) {
12406 func->srf_num_macs = n_entries;
12408 kcalloc(n_entries, sizeof(*func->srf_macs),
12410 if (!func->srf_macs) {
12415 nla_for_each_nested(attr, mac_attr, rem)
12416 memcpy(func->srf_macs[i++].addr, nla_data(attr),
12417 sizeof(*func->srf_macs));
12421 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
12422 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
12428 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
12429 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
12435 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12441 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12442 NL80211_CMD_ADD_NAN_FUNCTION);
12443 /* This can't really happen - we just allocated 4KB */
12444 if (WARN_ON(!hdr)) {
12449 err = rdev_add_nan_func(rdev, wdev, func);
12452 cfg80211_free_nan_func(func);
12457 /* propagate the instance id and cookie to userspace */
12458 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
12460 goto nla_put_failure;
12462 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
12464 goto nla_put_failure;
12466 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
12467 func->instance_id))
12468 goto nla_put_failure;
12470 nla_nest_end(msg, func_attr);
12472 genlmsg_end(msg, hdr);
12473 return genlmsg_reply(msg, info);
12480 static int nl80211_nan_del_func(struct sk_buff *skb,
12481 struct genl_info *info)
12483 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12484 struct wireless_dev *wdev = info->user_ptr[1];
12487 if (wdev->iftype != NL80211_IFTYPE_NAN)
12488 return -EOPNOTSUPP;
12490 if (!wdev_running(wdev))
12493 if (!info->attrs[NL80211_ATTR_COOKIE])
12496 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
12498 rdev_del_nan_func(rdev, wdev, cookie);
12503 static int nl80211_nan_change_config(struct sk_buff *skb,
12504 struct genl_info *info)
12506 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12507 struct wireless_dev *wdev = info->user_ptr[1];
12508 struct cfg80211_nan_conf conf = {};
12511 if (wdev->iftype != NL80211_IFTYPE_NAN)
12512 return -EOPNOTSUPP;
12514 if (!wdev_running(wdev))
12517 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
12519 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
12520 if (conf.master_pref <= 1 || conf.master_pref == 255)
12523 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
12526 if (info->attrs[NL80211_ATTR_BANDS]) {
12527 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
12529 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
12530 return -EOPNOTSUPP;
12532 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
12535 conf.bands = bands;
12536 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
12542 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
12545 void cfg80211_nan_match(struct wireless_dev *wdev,
12546 struct cfg80211_nan_match_params *match, gfp_t gfp)
12548 struct wiphy *wiphy = wdev->wiphy;
12549 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12550 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
12551 struct sk_buff *msg;
12554 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
12557 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12561 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
12567 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12568 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12569 wdev->netdev->ifindex)) ||
12570 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
12572 goto nla_put_failure;
12574 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
12575 NL80211_ATTR_PAD) ||
12576 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
12577 goto nla_put_failure;
12579 match_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_MATCH);
12581 goto nla_put_failure;
12583 local_func_attr = nla_nest_start_noflag(msg,
12584 NL80211_NAN_MATCH_FUNC_LOCAL);
12585 if (!local_func_attr)
12586 goto nla_put_failure;
12588 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
12589 goto nla_put_failure;
12591 nla_nest_end(msg, local_func_attr);
12593 peer_func_attr = nla_nest_start_noflag(msg,
12594 NL80211_NAN_MATCH_FUNC_PEER);
12595 if (!peer_func_attr)
12596 goto nla_put_failure;
12598 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
12599 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
12600 goto nla_put_failure;
12602 if (match->info && match->info_len &&
12603 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
12605 goto nla_put_failure;
12607 nla_nest_end(msg, peer_func_attr);
12608 nla_nest_end(msg, match_attr);
12609 genlmsg_end(msg, hdr);
12611 if (!wdev->owner_nlportid)
12612 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12613 msg, 0, NL80211_MCGRP_NAN, gfp);
12615 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
12616 wdev->owner_nlportid);
12623 EXPORT_SYMBOL(cfg80211_nan_match);
12625 void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
12627 enum nl80211_nan_func_term_reason reason,
12628 u64 cookie, gfp_t gfp)
12630 struct wiphy *wiphy = wdev->wiphy;
12631 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12632 struct sk_buff *msg;
12633 struct nlattr *func_attr;
12636 if (WARN_ON(!inst_id))
12639 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12643 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
12649 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12650 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12651 wdev->netdev->ifindex)) ||
12652 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
12654 goto nla_put_failure;
12656 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12658 goto nla_put_failure;
12660 func_attr = nla_nest_start_noflag(msg, NL80211_ATTR_NAN_FUNC);
12662 goto nla_put_failure;
12664 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
12665 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
12666 goto nla_put_failure;
12668 nla_nest_end(msg, func_attr);
12669 genlmsg_end(msg, hdr);
12671 if (!wdev->owner_nlportid)
12672 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12673 msg, 0, NL80211_MCGRP_NAN, gfp);
12675 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
12676 wdev->owner_nlportid);
12683 EXPORT_SYMBOL(cfg80211_nan_func_terminated);
12685 static int nl80211_get_protocol_features(struct sk_buff *skb,
12686 struct genl_info *info)
12689 struct sk_buff *msg;
12691 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12695 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12696 NL80211_CMD_GET_PROTOCOL_FEATURES);
12698 goto nla_put_failure;
12700 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
12701 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
12702 goto nla_put_failure;
12704 genlmsg_end(msg, hdr);
12705 return genlmsg_reply(msg, info);
12712 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
12714 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12715 struct cfg80211_update_ft_ies_params ft_params;
12716 struct net_device *dev = info->user_ptr[1];
12718 if (!rdev->ops->update_ft_ies)
12719 return -EOPNOTSUPP;
12721 if (!info->attrs[NL80211_ATTR_MDID] ||
12722 !info->attrs[NL80211_ATTR_IE])
12725 memset(&ft_params, 0, sizeof(ft_params));
12726 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
12727 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12728 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12730 return rdev_update_ft_ies(rdev, dev, &ft_params);
12733 static int nl80211_crit_protocol_start(struct sk_buff *skb,
12734 struct genl_info *info)
12736 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12737 struct wireless_dev *wdev = info->user_ptr[1];
12738 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
12742 if (!rdev->ops->crit_proto_start)
12743 return -EOPNOTSUPP;
12745 if (WARN_ON(!rdev->ops->crit_proto_stop))
12748 if (rdev->crit_proto_nlportid)
12751 /* determine protocol if provided */
12752 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
12753 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
12755 if (proto >= NUM_NL80211_CRIT_PROTO)
12758 /* timeout must be provided */
12759 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
12763 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
12765 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
12768 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
12770 rdev->crit_proto_nlportid = info->snd_portid;
12775 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
12776 struct genl_info *info)
12778 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12779 struct wireless_dev *wdev = info->user_ptr[1];
12781 if (!rdev->ops->crit_proto_stop)
12782 return -EOPNOTSUPP;
12784 if (rdev->crit_proto_nlportid) {
12785 rdev->crit_proto_nlportid = 0;
12786 rdev_crit_proto_stop(rdev, wdev);
12791 static int nl80211_vendor_check_policy(const struct wiphy_vendor_command *vcmd,
12792 struct nlattr *attr,
12793 struct netlink_ext_ack *extack)
12795 if (vcmd->policy == VENDOR_CMD_RAW_DATA) {
12796 if (attr->nla_type & NLA_F_NESTED) {
12797 NL_SET_ERR_MSG_ATTR(extack, attr,
12798 "unexpected nested data");
12805 if (!(attr->nla_type & NLA_F_NESTED)) {
12806 NL_SET_ERR_MSG_ATTR(extack, attr, "expected nested data");
12810 return nl80211_validate_nested(attr, vcmd->maxattr, vcmd->policy,
12814 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
12816 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12817 struct wireless_dev *wdev =
12818 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
12822 if (!rdev->wiphy.vendor_commands)
12823 return -EOPNOTSUPP;
12825 if (IS_ERR(wdev)) {
12826 err = PTR_ERR(wdev);
12827 if (err != -EINVAL)
12830 } else if (wdev->wiphy != &rdev->wiphy) {
12834 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
12835 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
12838 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
12839 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
12840 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
12841 const struct wiphy_vendor_command *vcmd;
12845 vcmd = &rdev->wiphy.vendor_commands[i];
12847 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
12850 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
12851 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
12854 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
12858 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
12859 if (!wdev_running(wdev))
12864 return -EOPNOTSUPP;
12869 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
12870 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
12871 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
12873 err = nl80211_vendor_check_policy(vcmd,
12874 info->attrs[NL80211_ATTR_VENDOR_DATA],
12880 rdev->cur_cmd_info = info;
12881 err = vcmd->doit(&rdev->wiphy, wdev, data, len);
12882 rdev->cur_cmd_info = NULL;
12886 return -EOPNOTSUPP;
12889 static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
12890 struct netlink_callback *cb,
12891 struct cfg80211_registered_device **rdev,
12892 struct wireless_dev **wdev)
12894 struct nlattr **attrbuf;
12900 unsigned int data_len = 0;
12903 /* subtract the 1 again here */
12904 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
12905 struct wireless_dev *tmp;
12909 *rdev = wiphy_to_rdev(wiphy);
12913 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
12914 if (tmp->identifier == cb->args[1] - 1) {
12921 /* keep rtnl locked in successful case */
12925 attrbuf = kcalloc(NUM_NL80211_ATTR, sizeof(*attrbuf), GFP_KERNEL);
12929 err = nlmsg_parse_deprecated(cb->nlh,
12930 GENL_HDRLEN + nl80211_fam.hdrsize,
12931 attrbuf, nl80211_fam.maxattr,
12932 nl80211_policy, NULL);
12936 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
12937 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD]) {
12942 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
12946 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
12947 if (IS_ERR(*rdev)) {
12948 err = PTR_ERR(*rdev);
12952 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
12953 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
12955 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
12956 const struct wiphy_vendor_command *vcmd;
12958 vcmd = &(*rdev)->wiphy.vendor_commands[i];
12960 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
12963 if (!vcmd->dumpit) {
12972 if (vcmd_idx < 0) {
12977 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
12978 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
12979 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
12981 err = nl80211_vendor_check_policy(
12982 &(*rdev)->wiphy.vendor_commands[vcmd_idx],
12983 attrbuf[NL80211_ATTR_VENDOR_DATA],
12989 /* 0 is the first index - add 1 to parse only once */
12990 cb->args[0] = (*rdev)->wiphy_idx + 1;
12991 /* add 1 to know if it was NULL */
12992 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
12993 cb->args[2] = vcmd_idx;
12994 cb->args[3] = (unsigned long)data;
12995 cb->args[4] = data_len;
12997 /* keep rtnl locked in successful case */
13004 static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
13005 struct netlink_callback *cb)
13007 struct cfg80211_registered_device *rdev;
13008 struct wireless_dev *wdev;
13009 unsigned int vcmd_idx;
13010 const struct wiphy_vendor_command *vcmd;
13014 struct nlattr *vendor_data;
13017 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
13021 vcmd_idx = cb->args[2];
13022 data = (void *)cb->args[3];
13023 data_len = cb->args[4];
13024 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
13026 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
13027 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
13032 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
13038 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
13039 if (!wdev_running(wdev)) {
13047 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
13048 cb->nlh->nlmsg_seq, NLM_F_MULTI,
13049 NL80211_CMD_VENDOR);
13053 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
13054 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
13056 NL80211_ATTR_PAD))) {
13057 genlmsg_cancel(skb, hdr);
13061 vendor_data = nla_nest_start_noflag(skb,
13062 NL80211_ATTR_VENDOR_DATA);
13063 if (!vendor_data) {
13064 genlmsg_cancel(skb, hdr);
13068 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
13069 (unsigned long *)&cb->args[5]);
13070 nla_nest_end(skb, vendor_data);
13072 if (err == -ENOBUFS || err == -ENOENT) {
13073 genlmsg_cancel(skb, hdr);
13076 genlmsg_cancel(skb, hdr);
13080 genlmsg_end(skb, hdr);
13089 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
13090 enum nl80211_commands cmd,
13091 enum nl80211_attrs attr,
13094 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
13096 if (WARN_ON(!rdev->cur_cmd_info))
13099 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
13100 rdev->cur_cmd_info->snd_portid,
13101 rdev->cur_cmd_info->snd_seq,
13102 cmd, attr, NULL, GFP_KERNEL);
13104 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
13106 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
13108 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
13109 void *hdr = ((void **)skb->cb)[1];
13110 struct nlattr *data = ((void **)skb->cb)[2];
13112 /* clear CB data for netlink core to own from now on */
13113 memset(skb->cb, 0, sizeof(skb->cb));
13115 if (WARN_ON(!rdev->cur_cmd_info)) {
13120 nla_nest_end(skb, data);
13121 genlmsg_end(skb, hdr);
13122 return genlmsg_reply(skb, rdev->cur_cmd_info);
13124 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
13126 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy *wiphy)
13128 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
13130 if (WARN_ON(!rdev->cur_cmd_info))
13133 return rdev->cur_cmd_info->snd_portid;
13135 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_get_sender);
13137 static int nl80211_set_qos_map(struct sk_buff *skb,
13138 struct genl_info *info)
13140 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13141 struct cfg80211_qos_map *qos_map = NULL;
13142 struct net_device *dev = info->user_ptr[1];
13143 u8 *pos, len, num_des, des_len, des;
13146 if (!rdev->ops->set_qos_map)
13147 return -EOPNOTSUPP;
13149 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
13150 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
13151 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
13153 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
13154 len > IEEE80211_QOS_MAP_LEN_MAX)
13157 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
13161 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
13163 des_len = num_des *
13164 sizeof(struct cfg80211_dscp_exception);
13165 memcpy(qos_map->dscp_exception, pos, des_len);
13166 qos_map->num_des = num_des;
13167 for (des = 0; des < num_des; des++) {
13168 if (qos_map->dscp_exception[des].up > 7) {
13175 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
13178 wdev_lock(dev->ieee80211_ptr);
13179 ret = nl80211_key_allowed(dev->ieee80211_ptr);
13181 ret = rdev_set_qos_map(rdev, dev, qos_map);
13182 wdev_unlock(dev->ieee80211_ptr);
13188 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
13190 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13191 struct net_device *dev = info->user_ptr[1];
13192 struct wireless_dev *wdev = dev->ieee80211_ptr;
13195 u16 admitted_time = 0;
13198 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
13199 return -EOPNOTSUPP;
13201 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
13202 !info->attrs[NL80211_ATTR_USER_PRIO])
13205 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
13206 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
13208 /* WMM uses TIDs 0-7 even for TSPEC */
13209 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
13210 /* TODO: handle 802.11 TSPEC/admission control
13211 * need more attributes for that (e.g. BA session requirement);
13212 * change the WMM adminssion test above to allow both then
13217 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
13219 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
13221 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
13222 if (!admitted_time)
13227 switch (wdev->iftype) {
13228 case NL80211_IFTYPE_STATION:
13229 case NL80211_IFTYPE_P2P_CLIENT:
13230 if (wdev->current_bss)
13239 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
13246 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
13248 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13249 struct net_device *dev = info->user_ptr[1];
13250 struct wireless_dev *wdev = dev->ieee80211_ptr;
13255 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
13258 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
13259 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
13262 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
13268 static int nl80211_tdls_channel_switch(struct sk_buff *skb,
13269 struct genl_info *info)
13271 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13272 struct net_device *dev = info->user_ptr[1];
13273 struct wireless_dev *wdev = dev->ieee80211_ptr;
13274 struct cfg80211_chan_def chandef = {};
13279 if (!rdev->ops->tdls_channel_switch ||
13280 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
13281 return -EOPNOTSUPP;
13283 switch (dev->ieee80211_ptr->iftype) {
13284 case NL80211_IFTYPE_STATION:
13285 case NL80211_IFTYPE_P2P_CLIENT:
13288 return -EOPNOTSUPP;
13291 if (!info->attrs[NL80211_ATTR_MAC] ||
13292 !info->attrs[NL80211_ATTR_OPER_CLASS])
13295 err = nl80211_parse_chandef(rdev, info, &chandef);
13300 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
13301 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
13302 * specification is not defined for them.
13304 if (chandef.chan->band == NL80211_BAND_2GHZ &&
13305 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
13306 chandef.width != NL80211_CHAN_WIDTH_20)
13309 /* we will be active on the TDLS link */
13310 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
13314 /* don't allow switching to DFS channels */
13315 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
13318 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
13319 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
13322 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
13328 static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
13329 struct genl_info *info)
13331 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13332 struct net_device *dev = info->user_ptr[1];
13333 struct wireless_dev *wdev = dev->ieee80211_ptr;
13336 if (!rdev->ops->tdls_channel_switch ||
13337 !rdev->ops->tdls_cancel_channel_switch ||
13338 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
13339 return -EOPNOTSUPP;
13341 switch (dev->ieee80211_ptr->iftype) {
13342 case NL80211_IFTYPE_STATION:
13343 case NL80211_IFTYPE_P2P_CLIENT:
13346 return -EOPNOTSUPP;
13349 if (!info->attrs[NL80211_ATTR_MAC])
13352 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
13355 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
13361 static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
13362 struct genl_info *info)
13364 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13365 struct net_device *dev = info->user_ptr[1];
13366 struct wireless_dev *wdev = dev->ieee80211_ptr;
13367 const struct nlattr *nla;
13370 if (!rdev->ops->set_multicast_to_unicast)
13371 return -EOPNOTSUPP;
13373 if (wdev->iftype != NL80211_IFTYPE_AP &&
13374 wdev->iftype != NL80211_IFTYPE_P2P_GO)
13375 return -EOPNOTSUPP;
13377 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
13378 enabled = nla_get_flag(nla);
13380 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
13383 static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
13385 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13386 struct net_device *dev = info->user_ptr[1];
13387 struct wireless_dev *wdev = dev->ieee80211_ptr;
13388 struct cfg80211_pmk_conf pmk_conf = {};
13391 if (wdev->iftype != NL80211_IFTYPE_STATION &&
13392 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
13393 return -EOPNOTSUPP;
13395 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13396 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
13397 return -EOPNOTSUPP;
13399 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
13403 if (!wdev->current_bss) {
13408 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
13409 if (memcmp(pmk_conf.aa, wdev->current_bss->pub.bssid, ETH_ALEN)) {
13414 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
13415 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
13416 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
13417 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
13422 if (info->attrs[NL80211_ATTR_PMKR0_NAME]) {
13423 int r0_name_len = nla_len(info->attrs[NL80211_ATTR_PMKR0_NAME]);
13425 if (r0_name_len != WLAN_PMK_NAME_LEN) {
13430 pmk_conf.pmk_r0_name =
13431 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
13434 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
13440 static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
13442 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13443 struct net_device *dev = info->user_ptr[1];
13444 struct wireless_dev *wdev = dev->ieee80211_ptr;
13448 if (wdev->iftype != NL80211_IFTYPE_STATION &&
13449 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
13450 return -EOPNOTSUPP;
13452 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13453 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
13454 return -EOPNOTSUPP;
13456 if (!info->attrs[NL80211_ATTR_MAC])
13460 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
13461 ret = rdev_del_pmk(rdev, dev, aa);
13467 static int nl80211_external_auth(struct sk_buff *skb, struct genl_info *info)
13469 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13470 struct net_device *dev = info->user_ptr[1];
13471 struct cfg80211_external_auth_params params;
13473 if (!rdev->ops->external_auth)
13474 return -EOPNOTSUPP;
13476 if (!info->attrs[NL80211_ATTR_SSID] &&
13477 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
13478 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
13481 if (!info->attrs[NL80211_ATTR_BSSID])
13484 if (!info->attrs[NL80211_ATTR_STATUS_CODE])
13487 memset(¶ms, 0, sizeof(params));
13489 if (info->attrs[NL80211_ATTR_SSID]) {
13490 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
13491 if (params.ssid.ssid_len == 0 ||
13492 params.ssid.ssid_len > IEEE80211_MAX_SSID_LEN)
13494 memcpy(params.ssid.ssid,
13495 nla_data(info->attrs[NL80211_ATTR_SSID]),
13496 params.ssid.ssid_len);
13499 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]),
13502 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
13504 if (info->attrs[NL80211_ATTR_PMKID])
13505 params.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
13507 return rdev_external_auth(rdev, dev, ¶ms);
13510 static int nl80211_tx_control_port(struct sk_buff *skb, struct genl_info *info)
13512 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13513 struct net_device *dev = info->user_ptr[1];
13514 struct wireless_dev *wdev = dev->ieee80211_ptr;
13522 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13523 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
13524 return -EOPNOTSUPP;
13526 if (!rdev->ops->tx_control_port)
13527 return -EOPNOTSUPP;
13529 if (!info->attrs[NL80211_ATTR_FRAME] ||
13530 !info->attrs[NL80211_ATTR_MAC] ||
13531 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
13532 GENL_SET_ERR_MSG(info, "Frame, MAC or ethertype missing");
13538 switch (wdev->iftype) {
13539 case NL80211_IFTYPE_AP:
13540 case NL80211_IFTYPE_P2P_GO:
13541 case NL80211_IFTYPE_MESH_POINT:
13543 case NL80211_IFTYPE_ADHOC:
13544 case NL80211_IFTYPE_STATION:
13545 case NL80211_IFTYPE_P2P_CLIENT:
13546 if (wdev->current_bss)
13557 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
13558 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
13559 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
13560 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
13562 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
13564 return rdev_tx_control_port(rdev, dev, buf, len,
13565 dest, cpu_to_be16(proto), noencrypt);
13572 static int nl80211_get_ftm_responder_stats(struct sk_buff *skb,
13573 struct genl_info *info)
13575 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13576 struct net_device *dev = info->user_ptr[1];
13577 struct wireless_dev *wdev = dev->ieee80211_ptr;
13578 struct cfg80211_ftm_responder_stats ftm_stats = {};
13579 struct sk_buff *msg;
13581 struct nlattr *ftm_stats_attr;
13584 if (wdev->iftype != NL80211_IFTYPE_AP || !wdev->beacon_interval)
13585 return -EOPNOTSUPP;
13587 err = rdev_get_ftm_responder_stats(rdev, dev, &ftm_stats);
13591 if (!ftm_stats.filled)
13594 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13598 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13599 NL80211_CMD_GET_FTM_RESPONDER_STATS);
13603 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
13604 goto nla_put_failure;
13606 ftm_stats_attr = nla_nest_start_noflag(msg,
13607 NL80211_ATTR_FTM_RESPONDER_STATS);
13608 if (!ftm_stats_attr)
13609 goto nla_put_failure;
13611 #define SET_FTM(field, name, type) \
13612 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
13613 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \
13614 ftm_stats.field)) \
13615 goto nla_put_failure; } while (0)
13616 #define SET_FTM_U64(field, name) \
13617 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
13618 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \
13619 ftm_stats.field, NL80211_FTM_STATS_PAD)) \
13620 goto nla_put_failure; } while (0)
13622 SET_FTM(success_num, SUCCESS_NUM, u32);
13623 SET_FTM(partial_num, PARTIAL_NUM, u32);
13624 SET_FTM(failed_num, FAILED_NUM, u32);
13625 SET_FTM(asap_num, ASAP_NUM, u32);
13626 SET_FTM(non_asap_num, NON_ASAP_NUM, u32);
13627 SET_FTM_U64(total_duration_ms, TOTAL_DURATION_MSEC);
13628 SET_FTM(unknown_triggers_num, UNKNOWN_TRIGGERS_NUM, u32);
13629 SET_FTM(reschedule_requests_num, RESCHEDULE_REQUESTS_NUM, u32);
13630 SET_FTM(out_of_window_triggers_num, OUT_OF_WINDOW_TRIGGERS_NUM, u32);
13633 nla_nest_end(msg, ftm_stats_attr);
13635 genlmsg_end(msg, hdr);
13636 return genlmsg_reply(msg, info);
13643 static int nl80211_update_owe_info(struct sk_buff *skb, struct genl_info *info)
13645 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13646 struct cfg80211_update_owe_info owe_info;
13647 struct net_device *dev = info->user_ptr[1];
13649 if (!rdev->ops->update_owe_info)
13650 return -EOPNOTSUPP;
13652 if (!info->attrs[NL80211_ATTR_STATUS_CODE] ||
13653 !info->attrs[NL80211_ATTR_MAC])
13656 memset(&owe_info, 0, sizeof(owe_info));
13657 owe_info.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
13658 nla_memcpy(owe_info.peer, info->attrs[NL80211_ATTR_MAC], ETH_ALEN);
13660 if (info->attrs[NL80211_ATTR_IE]) {
13661 owe_info.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
13662 owe_info.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
13665 return rdev_update_owe_info(rdev, dev, &owe_info);
13668 static int nl80211_probe_mesh_link(struct sk_buff *skb, struct genl_info *info)
13670 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13671 struct net_device *dev = info->user_ptr[1];
13672 struct wireless_dev *wdev = dev->ieee80211_ptr;
13673 struct station_info sinfo = {};
13679 if (!rdev->ops->probe_mesh_link || !rdev->ops->get_station)
13680 return -EOPNOTSUPP;
13682 if (!info->attrs[NL80211_ATTR_MAC] ||
13683 !info->attrs[NL80211_ATTR_FRAME]) {
13684 GENL_SET_ERR_MSG(info, "Frame or MAC missing");
13688 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
13689 return -EOPNOTSUPP;
13691 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
13692 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
13693 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
13695 if (len < sizeof(struct ethhdr))
13698 if (!ether_addr_equal(buf, dest) || is_multicast_ether_addr(buf) ||
13699 !ether_addr_equal(buf + ETH_ALEN, dev->dev_addr))
13702 err = rdev_get_station(rdev, dev, dest, &sinfo);
13706 return rdev_probe_mesh_link(rdev, dev, dest, buf, len);
13709 #define NL80211_FLAG_NEED_WIPHY 0x01
13710 #define NL80211_FLAG_NEED_NETDEV 0x02
13711 #define NL80211_FLAG_NEED_RTNL 0x04
13712 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
13713 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
13714 NL80211_FLAG_CHECK_NETDEV_UP)
13715 #define NL80211_FLAG_NEED_WDEV 0x10
13716 /* If a netdev is associated, it must be UP, P2P must be started */
13717 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
13718 NL80211_FLAG_CHECK_NETDEV_UP)
13719 #define NL80211_FLAG_CLEAR_SKB 0x20
13721 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
13722 struct genl_info *info)
13724 struct cfg80211_registered_device *rdev;
13725 struct wireless_dev *wdev;
13726 struct net_device *dev;
13727 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
13732 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
13733 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
13734 if (IS_ERR(rdev)) {
13737 return PTR_ERR(rdev);
13739 info->user_ptr[0] = rdev;
13740 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
13741 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
13744 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
13746 if (IS_ERR(wdev)) {
13749 return PTR_ERR(wdev);
13752 dev = wdev->netdev;
13753 rdev = wiphy_to_rdev(wdev->wiphy);
13755 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
13762 info->user_ptr[1] = dev;
13764 info->user_ptr[1] = wdev;
13767 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
13768 !wdev_running(wdev)) {
13777 info->user_ptr[0] = rdev;
13783 static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
13784 struct genl_info *info)
13786 if (info->user_ptr[1]) {
13787 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
13788 struct wireless_dev *wdev = info->user_ptr[1];
13791 dev_put(wdev->netdev);
13793 dev_put(info->user_ptr[1]);
13797 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
13800 /* If needed, clear the netlink message payload from the SKB
13801 * as it might contain key data that shouldn't stick around on
13802 * the heap after the SKB is freed. The netlink message header
13803 * is still needed for further processing, so leave it intact.
13805 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
13806 struct nlmsghdr *nlh = nlmsg_hdr(skb);
13808 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
13812 static const struct genl_ops nl80211_ops[] = {
13814 .cmd = NL80211_CMD_GET_WIPHY,
13815 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13816 .doit = nl80211_get_wiphy,
13817 .dumpit = nl80211_dump_wiphy,
13818 .done = nl80211_dump_wiphy_done,
13819 /* can be retrieved by unprivileged users */
13820 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13821 NL80211_FLAG_NEED_RTNL,
13824 .cmd = NL80211_CMD_SET_WIPHY,
13825 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13826 .doit = nl80211_set_wiphy,
13827 .flags = GENL_UNS_ADMIN_PERM,
13828 .internal_flags = NL80211_FLAG_NEED_RTNL,
13831 .cmd = NL80211_CMD_GET_INTERFACE,
13832 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13833 .doit = nl80211_get_interface,
13834 .dumpit = nl80211_dump_interface,
13835 /* can be retrieved by unprivileged users */
13836 .internal_flags = NL80211_FLAG_NEED_WDEV |
13837 NL80211_FLAG_NEED_RTNL,
13840 .cmd = NL80211_CMD_SET_INTERFACE,
13841 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13842 .doit = nl80211_set_interface,
13843 .flags = GENL_UNS_ADMIN_PERM,
13844 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13845 NL80211_FLAG_NEED_RTNL,
13848 .cmd = NL80211_CMD_NEW_INTERFACE,
13849 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13850 .doit = nl80211_new_interface,
13851 .flags = GENL_UNS_ADMIN_PERM,
13852 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13853 NL80211_FLAG_NEED_RTNL,
13856 .cmd = NL80211_CMD_DEL_INTERFACE,
13857 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13858 .doit = nl80211_del_interface,
13859 .flags = GENL_UNS_ADMIN_PERM,
13860 .internal_flags = NL80211_FLAG_NEED_WDEV |
13861 NL80211_FLAG_NEED_RTNL,
13864 .cmd = NL80211_CMD_GET_KEY,
13865 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13866 .doit = nl80211_get_key,
13867 .flags = GENL_UNS_ADMIN_PERM,
13868 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13869 NL80211_FLAG_NEED_RTNL,
13872 .cmd = NL80211_CMD_SET_KEY,
13873 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13874 .doit = nl80211_set_key,
13875 .flags = GENL_UNS_ADMIN_PERM,
13876 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13877 NL80211_FLAG_NEED_RTNL |
13878 NL80211_FLAG_CLEAR_SKB,
13881 .cmd = NL80211_CMD_NEW_KEY,
13882 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13883 .doit = nl80211_new_key,
13884 .flags = GENL_UNS_ADMIN_PERM,
13885 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13886 NL80211_FLAG_NEED_RTNL |
13887 NL80211_FLAG_CLEAR_SKB,
13890 .cmd = NL80211_CMD_DEL_KEY,
13891 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13892 .doit = nl80211_del_key,
13893 .flags = GENL_UNS_ADMIN_PERM,
13894 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13895 NL80211_FLAG_NEED_RTNL,
13898 .cmd = NL80211_CMD_SET_BEACON,
13899 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13900 .flags = GENL_UNS_ADMIN_PERM,
13901 .doit = nl80211_set_beacon,
13902 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13903 NL80211_FLAG_NEED_RTNL,
13906 .cmd = NL80211_CMD_START_AP,
13907 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13908 .flags = GENL_UNS_ADMIN_PERM,
13909 .doit = nl80211_start_ap,
13910 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13911 NL80211_FLAG_NEED_RTNL,
13914 .cmd = NL80211_CMD_STOP_AP,
13915 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13916 .flags = GENL_UNS_ADMIN_PERM,
13917 .doit = nl80211_stop_ap,
13918 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13919 NL80211_FLAG_NEED_RTNL,
13922 .cmd = NL80211_CMD_GET_STATION,
13923 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13924 .doit = nl80211_get_station,
13925 .dumpit = nl80211_dump_station,
13926 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13927 NL80211_FLAG_NEED_RTNL,
13930 .cmd = NL80211_CMD_SET_STATION,
13931 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13932 .doit = nl80211_set_station,
13933 .flags = GENL_UNS_ADMIN_PERM,
13934 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13935 NL80211_FLAG_NEED_RTNL,
13938 .cmd = NL80211_CMD_NEW_STATION,
13939 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13940 .doit = nl80211_new_station,
13941 .flags = GENL_UNS_ADMIN_PERM,
13942 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13943 NL80211_FLAG_NEED_RTNL,
13946 .cmd = NL80211_CMD_DEL_STATION,
13947 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13948 .doit = nl80211_del_station,
13949 .flags = GENL_UNS_ADMIN_PERM,
13950 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13951 NL80211_FLAG_NEED_RTNL,
13954 .cmd = NL80211_CMD_GET_MPATH,
13955 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13956 .doit = nl80211_get_mpath,
13957 .dumpit = nl80211_dump_mpath,
13958 .flags = GENL_UNS_ADMIN_PERM,
13959 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13960 NL80211_FLAG_NEED_RTNL,
13963 .cmd = NL80211_CMD_GET_MPP,
13964 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13965 .doit = nl80211_get_mpp,
13966 .dumpit = nl80211_dump_mpp,
13967 .flags = GENL_UNS_ADMIN_PERM,
13968 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13969 NL80211_FLAG_NEED_RTNL,
13972 .cmd = NL80211_CMD_SET_MPATH,
13973 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13974 .doit = nl80211_set_mpath,
13975 .flags = GENL_UNS_ADMIN_PERM,
13976 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13977 NL80211_FLAG_NEED_RTNL,
13980 .cmd = NL80211_CMD_NEW_MPATH,
13981 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13982 .doit = nl80211_new_mpath,
13983 .flags = GENL_UNS_ADMIN_PERM,
13984 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13985 NL80211_FLAG_NEED_RTNL,
13988 .cmd = NL80211_CMD_DEL_MPATH,
13989 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13990 .doit = nl80211_del_mpath,
13991 .flags = GENL_UNS_ADMIN_PERM,
13992 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13993 NL80211_FLAG_NEED_RTNL,
13996 .cmd = NL80211_CMD_SET_BSS,
13997 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
13998 .doit = nl80211_set_bss,
13999 .flags = GENL_UNS_ADMIN_PERM,
14000 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14001 NL80211_FLAG_NEED_RTNL,
14004 .cmd = NL80211_CMD_GET_REG,
14005 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14006 .doit = nl80211_get_reg_do,
14007 .dumpit = nl80211_get_reg_dump,
14008 .internal_flags = NL80211_FLAG_NEED_RTNL,
14009 /* can be retrieved by unprivileged users */
14011 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
14013 .cmd = NL80211_CMD_SET_REG,
14014 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14015 .doit = nl80211_set_reg,
14016 .flags = GENL_ADMIN_PERM,
14017 .internal_flags = NL80211_FLAG_NEED_RTNL,
14021 .cmd = NL80211_CMD_REQ_SET_REG,
14022 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14023 .doit = nl80211_req_set_reg,
14024 .flags = GENL_ADMIN_PERM,
14027 .cmd = NL80211_CMD_RELOAD_REGDB,
14028 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14029 .doit = nl80211_reload_regdb,
14030 .flags = GENL_ADMIN_PERM,
14033 .cmd = NL80211_CMD_GET_MESH_CONFIG,
14034 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14035 .doit = nl80211_get_mesh_config,
14036 /* can be retrieved by unprivileged users */
14037 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14038 NL80211_FLAG_NEED_RTNL,
14041 .cmd = NL80211_CMD_SET_MESH_CONFIG,
14042 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14043 .doit = nl80211_update_mesh_config,
14044 .flags = GENL_UNS_ADMIN_PERM,
14045 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14046 NL80211_FLAG_NEED_RTNL,
14049 .cmd = NL80211_CMD_TRIGGER_SCAN,
14050 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14051 .doit = nl80211_trigger_scan,
14052 .flags = GENL_UNS_ADMIN_PERM,
14053 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14054 NL80211_FLAG_NEED_RTNL,
14057 .cmd = NL80211_CMD_ABORT_SCAN,
14058 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14059 .doit = nl80211_abort_scan,
14060 .flags = GENL_UNS_ADMIN_PERM,
14061 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14062 NL80211_FLAG_NEED_RTNL,
14065 .cmd = NL80211_CMD_GET_SCAN,
14066 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14067 .dumpit = nl80211_dump_scan,
14070 .cmd = NL80211_CMD_START_SCHED_SCAN,
14071 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14072 .doit = nl80211_start_sched_scan,
14073 .flags = GENL_UNS_ADMIN_PERM,
14074 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14075 NL80211_FLAG_NEED_RTNL,
14078 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
14079 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14080 .doit = nl80211_stop_sched_scan,
14081 .flags = GENL_UNS_ADMIN_PERM,
14082 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14083 NL80211_FLAG_NEED_RTNL,
14086 .cmd = NL80211_CMD_AUTHENTICATE,
14087 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14088 .doit = nl80211_authenticate,
14089 .flags = GENL_UNS_ADMIN_PERM,
14090 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14091 NL80211_FLAG_NEED_RTNL |
14092 NL80211_FLAG_CLEAR_SKB,
14095 .cmd = NL80211_CMD_ASSOCIATE,
14096 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14097 .doit = nl80211_associate,
14098 .flags = GENL_UNS_ADMIN_PERM,
14099 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14100 NL80211_FLAG_NEED_RTNL |
14101 NL80211_FLAG_CLEAR_SKB,
14104 .cmd = NL80211_CMD_DEAUTHENTICATE,
14105 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14106 .doit = nl80211_deauthenticate,
14107 .flags = GENL_UNS_ADMIN_PERM,
14108 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14109 NL80211_FLAG_NEED_RTNL,
14112 .cmd = NL80211_CMD_DISASSOCIATE,
14113 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14114 .doit = nl80211_disassociate,
14115 .flags = GENL_UNS_ADMIN_PERM,
14116 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14117 NL80211_FLAG_NEED_RTNL,
14120 .cmd = NL80211_CMD_JOIN_IBSS,
14121 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14122 .doit = nl80211_join_ibss,
14123 .flags = GENL_UNS_ADMIN_PERM,
14124 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14125 NL80211_FLAG_NEED_RTNL,
14128 .cmd = NL80211_CMD_LEAVE_IBSS,
14129 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14130 .doit = nl80211_leave_ibss,
14131 .flags = GENL_UNS_ADMIN_PERM,
14132 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14133 NL80211_FLAG_NEED_RTNL,
14135 #ifdef CONFIG_NL80211_TESTMODE
14137 .cmd = NL80211_CMD_TESTMODE,
14138 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14139 .doit = nl80211_testmode_do,
14140 .dumpit = nl80211_testmode_dump,
14141 .flags = GENL_UNS_ADMIN_PERM,
14142 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14143 NL80211_FLAG_NEED_RTNL,
14147 .cmd = NL80211_CMD_CONNECT,
14148 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14149 .doit = nl80211_connect,
14150 .flags = GENL_UNS_ADMIN_PERM,
14151 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14152 NL80211_FLAG_NEED_RTNL |
14153 NL80211_FLAG_CLEAR_SKB,
14156 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
14157 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14158 .doit = nl80211_update_connect_params,
14159 .flags = GENL_ADMIN_PERM,
14160 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14161 NL80211_FLAG_NEED_RTNL |
14162 NL80211_FLAG_CLEAR_SKB,
14165 .cmd = NL80211_CMD_DISCONNECT,
14166 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14167 .doit = nl80211_disconnect,
14168 .flags = GENL_UNS_ADMIN_PERM,
14169 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14170 NL80211_FLAG_NEED_RTNL,
14173 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
14174 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14175 .doit = nl80211_wiphy_netns,
14176 .flags = GENL_UNS_ADMIN_PERM,
14177 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14178 NL80211_FLAG_NEED_RTNL,
14181 .cmd = NL80211_CMD_GET_SURVEY,
14182 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14183 .dumpit = nl80211_dump_survey,
14186 .cmd = NL80211_CMD_SET_PMKSA,
14187 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14188 .doit = nl80211_setdel_pmksa,
14189 .flags = GENL_UNS_ADMIN_PERM,
14190 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14191 NL80211_FLAG_NEED_RTNL |
14192 NL80211_FLAG_CLEAR_SKB,
14195 .cmd = NL80211_CMD_DEL_PMKSA,
14196 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14197 .doit = nl80211_setdel_pmksa,
14198 .flags = GENL_UNS_ADMIN_PERM,
14199 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14200 NL80211_FLAG_NEED_RTNL,
14203 .cmd = NL80211_CMD_FLUSH_PMKSA,
14204 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14205 .doit = nl80211_flush_pmksa,
14206 .flags = GENL_UNS_ADMIN_PERM,
14207 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14208 NL80211_FLAG_NEED_RTNL,
14211 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
14212 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14213 .doit = nl80211_remain_on_channel,
14214 .flags = GENL_UNS_ADMIN_PERM,
14215 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14216 NL80211_FLAG_NEED_RTNL,
14219 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
14220 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14221 .doit = nl80211_cancel_remain_on_channel,
14222 .flags = GENL_UNS_ADMIN_PERM,
14223 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14224 NL80211_FLAG_NEED_RTNL,
14227 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
14228 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14229 .doit = nl80211_set_tx_bitrate_mask,
14230 .flags = GENL_UNS_ADMIN_PERM,
14231 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14232 NL80211_FLAG_NEED_RTNL,
14235 .cmd = NL80211_CMD_REGISTER_FRAME,
14236 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14237 .doit = nl80211_register_mgmt,
14238 .flags = GENL_UNS_ADMIN_PERM,
14239 .internal_flags = NL80211_FLAG_NEED_WDEV |
14240 NL80211_FLAG_NEED_RTNL,
14243 .cmd = NL80211_CMD_FRAME,
14244 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14245 .doit = nl80211_tx_mgmt,
14246 .flags = GENL_UNS_ADMIN_PERM,
14247 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14248 NL80211_FLAG_NEED_RTNL,
14251 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
14252 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14253 .doit = nl80211_tx_mgmt_cancel_wait,
14254 .flags = GENL_UNS_ADMIN_PERM,
14255 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14256 NL80211_FLAG_NEED_RTNL,
14259 .cmd = NL80211_CMD_SET_POWER_SAVE,
14260 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14261 .doit = nl80211_set_power_save,
14262 .flags = GENL_UNS_ADMIN_PERM,
14263 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14264 NL80211_FLAG_NEED_RTNL,
14267 .cmd = NL80211_CMD_GET_POWER_SAVE,
14268 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14269 .doit = nl80211_get_power_save,
14270 /* can be retrieved by unprivileged users */
14271 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14272 NL80211_FLAG_NEED_RTNL,
14275 .cmd = NL80211_CMD_SET_CQM,
14276 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14277 .doit = nl80211_set_cqm,
14278 .flags = GENL_UNS_ADMIN_PERM,
14279 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14280 NL80211_FLAG_NEED_RTNL,
14283 .cmd = NL80211_CMD_SET_CHANNEL,
14284 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14285 .doit = nl80211_set_channel,
14286 .flags = GENL_UNS_ADMIN_PERM,
14287 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14288 NL80211_FLAG_NEED_RTNL,
14291 .cmd = NL80211_CMD_SET_WDS_PEER,
14292 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14293 .doit = nl80211_set_wds_peer,
14294 .flags = GENL_UNS_ADMIN_PERM,
14295 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14296 NL80211_FLAG_NEED_RTNL,
14299 .cmd = NL80211_CMD_JOIN_MESH,
14300 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14301 .doit = nl80211_join_mesh,
14302 .flags = GENL_UNS_ADMIN_PERM,
14303 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14304 NL80211_FLAG_NEED_RTNL,
14307 .cmd = NL80211_CMD_LEAVE_MESH,
14308 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14309 .doit = nl80211_leave_mesh,
14310 .flags = GENL_UNS_ADMIN_PERM,
14311 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14312 NL80211_FLAG_NEED_RTNL,
14315 .cmd = NL80211_CMD_JOIN_OCB,
14316 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14317 .doit = nl80211_join_ocb,
14318 .flags = GENL_UNS_ADMIN_PERM,
14319 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14320 NL80211_FLAG_NEED_RTNL,
14323 .cmd = NL80211_CMD_LEAVE_OCB,
14324 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14325 .doit = nl80211_leave_ocb,
14326 .flags = GENL_UNS_ADMIN_PERM,
14327 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14328 NL80211_FLAG_NEED_RTNL,
14332 .cmd = NL80211_CMD_GET_WOWLAN,
14333 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14334 .doit = nl80211_get_wowlan,
14335 /* can be retrieved by unprivileged users */
14336 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14337 NL80211_FLAG_NEED_RTNL,
14340 .cmd = NL80211_CMD_SET_WOWLAN,
14341 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14342 .doit = nl80211_set_wowlan,
14343 .flags = GENL_UNS_ADMIN_PERM,
14344 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14345 NL80211_FLAG_NEED_RTNL,
14349 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
14350 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14351 .doit = nl80211_set_rekey_data,
14352 .flags = GENL_UNS_ADMIN_PERM,
14353 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14354 NL80211_FLAG_NEED_RTNL |
14355 NL80211_FLAG_CLEAR_SKB,
14358 .cmd = NL80211_CMD_TDLS_MGMT,
14359 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14360 .doit = nl80211_tdls_mgmt,
14361 .flags = GENL_UNS_ADMIN_PERM,
14362 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14363 NL80211_FLAG_NEED_RTNL,
14366 .cmd = NL80211_CMD_TDLS_OPER,
14367 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14368 .doit = nl80211_tdls_oper,
14369 .flags = GENL_UNS_ADMIN_PERM,
14370 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14371 NL80211_FLAG_NEED_RTNL,
14374 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
14375 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14376 .doit = nl80211_register_unexpected_frame,
14377 .flags = GENL_UNS_ADMIN_PERM,
14378 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14379 NL80211_FLAG_NEED_RTNL,
14382 .cmd = NL80211_CMD_PROBE_CLIENT,
14383 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14384 .doit = nl80211_probe_client,
14385 .flags = GENL_UNS_ADMIN_PERM,
14386 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14387 NL80211_FLAG_NEED_RTNL,
14390 .cmd = NL80211_CMD_REGISTER_BEACONS,
14391 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14392 .doit = nl80211_register_beacons,
14393 .flags = GENL_UNS_ADMIN_PERM,
14394 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14395 NL80211_FLAG_NEED_RTNL,
14398 .cmd = NL80211_CMD_SET_NOACK_MAP,
14399 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14400 .doit = nl80211_set_noack_map,
14401 .flags = GENL_UNS_ADMIN_PERM,
14402 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14403 NL80211_FLAG_NEED_RTNL,
14406 .cmd = NL80211_CMD_START_P2P_DEVICE,
14407 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14408 .doit = nl80211_start_p2p_device,
14409 .flags = GENL_UNS_ADMIN_PERM,
14410 .internal_flags = NL80211_FLAG_NEED_WDEV |
14411 NL80211_FLAG_NEED_RTNL,
14414 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
14415 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14416 .doit = nl80211_stop_p2p_device,
14417 .flags = GENL_UNS_ADMIN_PERM,
14418 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14419 NL80211_FLAG_NEED_RTNL,
14422 .cmd = NL80211_CMD_START_NAN,
14423 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14424 .doit = nl80211_start_nan,
14425 .flags = GENL_ADMIN_PERM,
14426 .internal_flags = NL80211_FLAG_NEED_WDEV |
14427 NL80211_FLAG_NEED_RTNL,
14430 .cmd = NL80211_CMD_STOP_NAN,
14431 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14432 .doit = nl80211_stop_nan,
14433 .flags = GENL_ADMIN_PERM,
14434 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14435 NL80211_FLAG_NEED_RTNL,
14438 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
14439 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14440 .doit = nl80211_nan_add_func,
14441 .flags = GENL_ADMIN_PERM,
14442 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14443 NL80211_FLAG_NEED_RTNL,
14446 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
14447 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14448 .doit = nl80211_nan_del_func,
14449 .flags = GENL_ADMIN_PERM,
14450 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14451 NL80211_FLAG_NEED_RTNL,
14454 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
14455 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14456 .doit = nl80211_nan_change_config,
14457 .flags = GENL_ADMIN_PERM,
14458 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14459 NL80211_FLAG_NEED_RTNL,
14462 .cmd = NL80211_CMD_SET_MCAST_RATE,
14463 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14464 .doit = nl80211_set_mcast_rate,
14465 .flags = GENL_UNS_ADMIN_PERM,
14466 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14467 NL80211_FLAG_NEED_RTNL,
14470 .cmd = NL80211_CMD_SET_MAC_ACL,
14471 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14472 .doit = nl80211_set_mac_acl,
14473 .flags = GENL_UNS_ADMIN_PERM,
14474 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14475 NL80211_FLAG_NEED_RTNL,
14478 .cmd = NL80211_CMD_RADAR_DETECT,
14479 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14480 .doit = nl80211_start_radar_detection,
14481 .flags = GENL_UNS_ADMIN_PERM,
14482 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14483 NL80211_FLAG_NEED_RTNL,
14486 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
14487 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14488 .doit = nl80211_get_protocol_features,
14491 .cmd = NL80211_CMD_UPDATE_FT_IES,
14492 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14493 .doit = nl80211_update_ft_ies,
14494 .flags = GENL_UNS_ADMIN_PERM,
14495 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14496 NL80211_FLAG_NEED_RTNL,
14499 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
14500 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14501 .doit = nl80211_crit_protocol_start,
14502 .flags = GENL_UNS_ADMIN_PERM,
14503 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14504 NL80211_FLAG_NEED_RTNL,
14507 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
14508 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14509 .doit = nl80211_crit_protocol_stop,
14510 .flags = GENL_UNS_ADMIN_PERM,
14511 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14512 NL80211_FLAG_NEED_RTNL,
14515 .cmd = NL80211_CMD_GET_COALESCE,
14516 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14517 .doit = nl80211_get_coalesce,
14518 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14519 NL80211_FLAG_NEED_RTNL,
14522 .cmd = NL80211_CMD_SET_COALESCE,
14523 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14524 .doit = nl80211_set_coalesce,
14525 .flags = GENL_UNS_ADMIN_PERM,
14526 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14527 NL80211_FLAG_NEED_RTNL,
14530 .cmd = NL80211_CMD_CHANNEL_SWITCH,
14531 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14532 .doit = nl80211_channel_switch,
14533 .flags = GENL_UNS_ADMIN_PERM,
14534 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14535 NL80211_FLAG_NEED_RTNL,
14538 .cmd = NL80211_CMD_VENDOR,
14539 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14540 .doit = nl80211_vendor_cmd,
14541 .dumpit = nl80211_vendor_cmd_dump,
14542 .flags = GENL_UNS_ADMIN_PERM,
14543 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14544 NL80211_FLAG_NEED_RTNL |
14545 NL80211_FLAG_CLEAR_SKB,
14548 .cmd = NL80211_CMD_SET_QOS_MAP,
14549 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14550 .doit = nl80211_set_qos_map,
14551 .flags = GENL_UNS_ADMIN_PERM,
14552 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14553 NL80211_FLAG_NEED_RTNL,
14556 .cmd = NL80211_CMD_ADD_TX_TS,
14557 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14558 .doit = nl80211_add_tx_ts,
14559 .flags = GENL_UNS_ADMIN_PERM,
14560 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14561 NL80211_FLAG_NEED_RTNL,
14564 .cmd = NL80211_CMD_DEL_TX_TS,
14565 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14566 .doit = nl80211_del_tx_ts,
14567 .flags = GENL_UNS_ADMIN_PERM,
14568 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14569 NL80211_FLAG_NEED_RTNL,
14572 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
14573 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14574 .doit = nl80211_tdls_channel_switch,
14575 .flags = GENL_UNS_ADMIN_PERM,
14576 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14577 NL80211_FLAG_NEED_RTNL,
14580 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
14581 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14582 .doit = nl80211_tdls_cancel_channel_switch,
14583 .flags = GENL_UNS_ADMIN_PERM,
14584 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14585 NL80211_FLAG_NEED_RTNL,
14588 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
14589 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14590 .doit = nl80211_set_multicast_to_unicast,
14591 .flags = GENL_UNS_ADMIN_PERM,
14592 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14593 NL80211_FLAG_NEED_RTNL,
14596 .cmd = NL80211_CMD_SET_PMK,
14597 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14598 .doit = nl80211_set_pmk,
14599 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14600 NL80211_FLAG_NEED_RTNL |
14601 NL80211_FLAG_CLEAR_SKB,
14604 .cmd = NL80211_CMD_DEL_PMK,
14605 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14606 .doit = nl80211_del_pmk,
14607 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14608 NL80211_FLAG_NEED_RTNL,
14611 .cmd = NL80211_CMD_EXTERNAL_AUTH,
14612 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14613 .doit = nl80211_external_auth,
14614 .flags = GENL_ADMIN_PERM,
14615 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14616 NL80211_FLAG_NEED_RTNL,
14619 .cmd = NL80211_CMD_CONTROL_PORT_FRAME,
14620 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14621 .doit = nl80211_tx_control_port,
14622 .flags = GENL_UNS_ADMIN_PERM,
14623 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14624 NL80211_FLAG_NEED_RTNL,
14627 .cmd = NL80211_CMD_GET_FTM_RESPONDER_STATS,
14628 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14629 .doit = nl80211_get_ftm_responder_stats,
14630 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14631 NL80211_FLAG_NEED_RTNL,
14634 .cmd = NL80211_CMD_PEER_MEASUREMENT_START,
14635 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14636 .doit = nl80211_pmsr_start,
14637 .flags = GENL_UNS_ADMIN_PERM,
14638 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14639 NL80211_FLAG_NEED_RTNL,
14642 .cmd = NL80211_CMD_NOTIFY_RADAR,
14643 .validate = GENL_DONT_VALIDATE_STRICT | GENL_DONT_VALIDATE_DUMP,
14644 .doit = nl80211_notify_radar_detection,
14645 .flags = GENL_UNS_ADMIN_PERM,
14646 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14647 NL80211_FLAG_NEED_RTNL,
14650 .cmd = NL80211_CMD_UPDATE_OWE_INFO,
14651 .doit = nl80211_update_owe_info,
14652 .flags = GENL_ADMIN_PERM,
14653 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14654 NL80211_FLAG_NEED_RTNL,
14657 .cmd = NL80211_CMD_PROBE_MESH_LINK,
14658 .doit = nl80211_probe_mesh_link,
14659 .flags = GENL_UNS_ADMIN_PERM,
14660 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14661 NL80211_FLAG_NEED_RTNL,
14665 static struct genl_family nl80211_fam __ro_after_init = {
14666 .name = NL80211_GENL_NAME, /* have users key off the name instead */
14667 .hdrsize = 0, /* no private header */
14668 .version = 1, /* no particular meaning now */
14669 .maxattr = NL80211_ATTR_MAX,
14670 .policy = nl80211_policy,
14672 .pre_doit = nl80211_pre_doit,
14673 .post_doit = nl80211_post_doit,
14674 .module = THIS_MODULE,
14675 .ops = nl80211_ops,
14676 .n_ops = ARRAY_SIZE(nl80211_ops),
14677 .mcgrps = nl80211_mcgrps,
14678 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
14679 .parallel_ops = true,
14682 /* notification functions */
14684 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
14685 enum nl80211_commands cmd)
14687 struct sk_buff *msg;
14688 struct nl80211_dump_wiphy_state state = {};
14690 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
14691 cmd != NL80211_CMD_DEL_WIPHY);
14693 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14697 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
14702 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14703 NL80211_MCGRP_CONFIG, GFP_KERNEL);
14706 void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
14707 struct wireless_dev *wdev,
14708 enum nl80211_commands cmd)
14710 struct sk_buff *msg;
14712 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14716 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, cmd) < 0) {
14721 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14722 NL80211_MCGRP_CONFIG, GFP_KERNEL);
14725 static int nl80211_add_scan_req(struct sk_buff *msg,
14726 struct cfg80211_registered_device *rdev)
14728 struct cfg80211_scan_request *req = rdev->scan_req;
14729 struct nlattr *nest;
14735 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_SSIDS);
14737 goto nla_put_failure;
14738 for (i = 0; i < req->n_ssids; i++) {
14739 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
14740 goto nla_put_failure;
14742 nla_nest_end(msg, nest);
14744 nest = nla_nest_start_noflag(msg, NL80211_ATTR_SCAN_FREQUENCIES);
14746 goto nla_put_failure;
14747 for (i = 0; i < req->n_channels; i++) {
14748 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
14749 goto nla_put_failure;
14751 nla_nest_end(msg, nest);
14754 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
14755 goto nla_put_failure;
14758 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
14759 goto nla_put_failure;
14761 if (req->info.scan_start_tsf &&
14762 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
14763 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
14764 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
14765 req->info.tsf_bssid)))
14766 goto nla_put_failure;
14773 static int nl80211_prep_scan_msg(struct sk_buff *msg,
14774 struct cfg80211_registered_device *rdev,
14775 struct wireless_dev *wdev,
14776 u32 portid, u32 seq, int flags,
14781 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
14785 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14786 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14787 wdev->netdev->ifindex)) ||
14788 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14790 goto nla_put_failure;
14792 /* ignore errors and send incomplete event anyway */
14793 nl80211_add_scan_req(msg, rdev);
14795 genlmsg_end(msg, hdr);
14799 genlmsg_cancel(msg, hdr);
14804 nl80211_prep_sched_scan_msg(struct sk_buff *msg,
14805 struct cfg80211_sched_scan_request *req, u32 cmd)
14809 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14813 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
14814 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
14815 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
14816 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
14818 goto nla_put_failure;
14820 genlmsg_end(msg, hdr);
14824 genlmsg_cancel(msg, hdr);
14828 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
14829 struct wireless_dev *wdev)
14831 struct sk_buff *msg;
14833 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14837 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
14838 NL80211_CMD_TRIGGER_SCAN) < 0) {
14843 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14844 NL80211_MCGRP_SCAN, GFP_KERNEL);
14847 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
14848 struct wireless_dev *wdev, bool aborted)
14850 struct sk_buff *msg;
14852 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14856 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
14857 aborted ? NL80211_CMD_SCAN_ABORTED :
14858 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
14866 /* send message created by nl80211_build_scan_msg() */
14867 void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
14868 struct sk_buff *msg)
14873 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14874 NL80211_MCGRP_SCAN, GFP_KERNEL);
14877 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
14879 struct sk_buff *msg;
14881 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14885 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
14890 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
14891 NL80211_MCGRP_SCAN, GFP_KERNEL);
14894 static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
14895 struct regulatory_request *request)
14897 /* Userspace can always count this one always being set */
14898 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
14899 goto nla_put_failure;
14901 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
14902 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14903 NL80211_REGDOM_TYPE_WORLD))
14904 goto nla_put_failure;
14905 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
14906 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14907 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
14908 goto nla_put_failure;
14909 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
14910 request->intersect) {
14911 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14912 NL80211_REGDOM_TYPE_INTERSECTION))
14913 goto nla_put_failure;
14915 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14916 NL80211_REGDOM_TYPE_COUNTRY) ||
14917 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
14919 goto nla_put_failure;
14922 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
14923 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
14926 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
14927 goto nla_put_failure;
14930 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
14931 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
14932 goto nla_put_failure;
14942 * This can happen on global regulatory changes or device specific settings
14943 * based on custom regulatory domains.
14945 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
14946 struct regulatory_request *request)
14948 struct sk_buff *msg;
14951 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14955 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
14961 if (nl80211_reg_change_event_fill(msg, request) == false)
14962 goto nla_put_failure;
14964 genlmsg_end(msg, hdr);
14967 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
14968 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
14977 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
14978 struct net_device *netdev,
14979 const u8 *buf, size_t len,
14980 enum nl80211_commands cmd, gfp_t gfp,
14981 int uapsd_queues, const u8 *req_ies,
14982 size_t req_ies_len)
14984 struct sk_buff *msg;
14987 msg = nlmsg_new(100 + len + req_ies_len, gfp);
14991 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14997 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14998 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14999 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
15001 nla_put(msg, NL80211_ATTR_REQ_IE, req_ies_len, req_ies)))
15002 goto nla_put_failure;
15004 if (uapsd_queues >= 0) {
15005 struct nlattr *nla_wmm =
15006 nla_nest_start_noflag(msg, NL80211_ATTR_STA_WME);
15008 goto nla_put_failure;
15010 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
15012 goto nla_put_failure;
15014 nla_nest_end(msg, nla_wmm);
15017 genlmsg_end(msg, hdr);
15019 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15020 NL80211_MCGRP_MLME, gfp);
15027 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
15028 struct net_device *netdev, const u8 *buf,
15029 size_t len, gfp_t gfp)
15031 nl80211_send_mlme_event(rdev, netdev, buf, len,
15032 NL80211_CMD_AUTHENTICATE, gfp, -1, NULL, 0);
15035 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
15036 struct net_device *netdev, const u8 *buf,
15037 size_t len, gfp_t gfp, int uapsd_queues,
15038 const u8 *req_ies, size_t req_ies_len)
15040 nl80211_send_mlme_event(rdev, netdev, buf, len,
15041 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues,
15042 req_ies, req_ies_len);
15045 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
15046 struct net_device *netdev, const u8 *buf,
15047 size_t len, gfp_t gfp)
15049 nl80211_send_mlme_event(rdev, netdev, buf, len,
15050 NL80211_CMD_DEAUTHENTICATE, gfp, -1, NULL, 0);
15053 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
15054 struct net_device *netdev, const u8 *buf,
15055 size_t len, gfp_t gfp)
15057 nl80211_send_mlme_event(rdev, netdev, buf, len,
15058 NL80211_CMD_DISASSOCIATE, gfp, -1, NULL, 0);
15061 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
15064 struct wireless_dev *wdev = dev->ieee80211_ptr;
15065 struct wiphy *wiphy = wdev->wiphy;
15066 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15067 const struct ieee80211_mgmt *mgmt = (void *)buf;
15070 if (WARN_ON(len < 2))
15073 if (ieee80211_is_deauth(mgmt->frame_control))
15074 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
15076 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
15078 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
15079 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1,
15082 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
15084 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
15085 struct net_device *netdev, int cmd,
15086 const u8 *addr, gfp_t gfp)
15088 struct sk_buff *msg;
15091 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15095 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15101 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15102 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15103 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
15104 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
15105 goto nla_put_failure;
15107 genlmsg_end(msg, hdr);
15109 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15110 NL80211_MCGRP_MLME, gfp);
15117 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
15118 struct net_device *netdev, const u8 *addr,
15121 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
15125 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
15126 struct net_device *netdev, const u8 *addr,
15129 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
15133 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
15134 struct net_device *netdev,
15135 struct cfg80211_connect_resp_params *cr,
15138 struct sk_buff *msg;
15141 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
15142 cr->fils.kek_len + cr->fils.pmk_len +
15143 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
15147 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
15153 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15154 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15156 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
15157 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
15158 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
15161 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
15162 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
15163 cr->timeout_reason))) ||
15165 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
15167 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
15169 (cr->fils.update_erp_next_seq_num &&
15170 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
15171 cr->fils.erp_next_seq_num)) ||
15172 (cr->status == WLAN_STATUS_SUCCESS &&
15174 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len,
15177 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) ||
15179 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid)))))
15180 goto nla_put_failure;
15182 genlmsg_end(msg, hdr);
15184 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15185 NL80211_MCGRP_MLME, gfp);
15192 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
15193 struct net_device *netdev,
15194 struct cfg80211_roam_info *info, gfp_t gfp)
15196 struct sk_buff *msg;
15198 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
15200 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len +
15201 info->fils.kek_len + info->fils.pmk_len +
15202 (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
15206 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
15212 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15213 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15214 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
15216 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
15219 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
15221 (info->fils.update_erp_next_seq_num &&
15222 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
15223 info->fils.erp_next_seq_num)) ||
15225 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len,
15226 info->fils.kek)) ||
15228 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) ||
15229 (info->fils.pmkid &&
15230 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid)))
15231 goto nla_put_failure;
15233 genlmsg_end(msg, hdr);
15235 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15236 NL80211_MCGRP_MLME, gfp);
15243 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
15244 struct net_device *netdev, const u8 *bssid)
15246 struct sk_buff *msg;
15249 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
15253 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED);
15259 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15260 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15261 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
15262 goto nla_put_failure;
15264 genlmsg_end(msg, hdr);
15266 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15267 NL80211_MCGRP_MLME, GFP_KERNEL);
15274 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
15275 struct net_device *netdev, u16 reason,
15276 const u8 *ie, size_t ie_len, bool from_ap)
15278 struct sk_buff *msg;
15281 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
15285 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
15291 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15292 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15294 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
15296 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
15297 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
15298 goto nla_put_failure;
15300 genlmsg_end(msg, hdr);
15302 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15303 NL80211_MCGRP_MLME, GFP_KERNEL);
15310 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
15311 struct net_device *netdev, const u8 *bssid,
15314 struct sk_buff *msg;
15317 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15321 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
15327 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15328 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15329 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
15330 goto nla_put_failure;
15332 genlmsg_end(msg, hdr);
15334 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15335 NL80211_MCGRP_MLME, gfp);
15342 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
15343 const u8 *ie, u8 ie_len,
15344 int sig_dbm, gfp_t gfp)
15346 struct wireless_dev *wdev = dev->ieee80211_ptr;
15347 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15348 struct sk_buff *msg;
15351 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
15354 trace_cfg80211_notify_new_peer_candidate(dev, addr);
15356 msg = nlmsg_new(100 + ie_len, gfp);
15360 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
15366 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15367 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15368 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
15370 nla_put(msg, NL80211_ATTR_IE, ie_len, ie)) ||
15372 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)))
15373 goto nla_put_failure;
15375 genlmsg_end(msg, hdr);
15377 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15378 NL80211_MCGRP_MLME, gfp);
15384 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
15386 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
15387 struct net_device *netdev, const u8 *addr,
15388 enum nl80211_key_type key_type, int key_id,
15389 const u8 *tsc, gfp_t gfp)
15391 struct sk_buff *msg;
15394 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15398 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
15404 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15405 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15406 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
15407 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
15409 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
15410 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
15411 goto nla_put_failure;
15413 genlmsg_end(msg, hdr);
15415 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15416 NL80211_MCGRP_MLME, gfp);
15423 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
15424 struct ieee80211_channel *channel_before,
15425 struct ieee80211_channel *channel_after)
15427 struct sk_buff *msg;
15429 struct nlattr *nl_freq;
15431 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
15435 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
15442 * Since we are applying the beacon hint to a wiphy we know its
15443 * wiphy_idx is valid
15445 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
15446 goto nla_put_failure;
15449 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_BEFORE);
15451 goto nla_put_failure;
15453 if (nl80211_msg_put_channel(msg, wiphy, channel_before, false))
15454 goto nla_put_failure;
15455 nla_nest_end(msg, nl_freq);
15458 nl_freq = nla_nest_start_noflag(msg, NL80211_ATTR_FREQ_AFTER);
15460 goto nla_put_failure;
15462 if (nl80211_msg_put_channel(msg, wiphy, channel_after, false))
15463 goto nla_put_failure;
15464 nla_nest_end(msg, nl_freq);
15466 genlmsg_end(msg, hdr);
15469 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
15470 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
15479 static void nl80211_send_remain_on_chan_event(
15480 int cmd, struct cfg80211_registered_device *rdev,
15481 struct wireless_dev *wdev, u64 cookie,
15482 struct ieee80211_channel *chan,
15483 unsigned int duration, gfp_t gfp)
15485 struct sk_buff *msg;
15488 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15492 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15498 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15499 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15500 wdev->netdev->ifindex)) ||
15501 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15502 NL80211_ATTR_PAD) ||
15503 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
15504 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
15505 NL80211_CHAN_NO_HT) ||
15506 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
15508 goto nla_put_failure;
15510 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
15511 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
15512 goto nla_put_failure;
15514 genlmsg_end(msg, hdr);
15516 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15517 NL80211_MCGRP_MLME, gfp);
15524 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
15525 struct ieee80211_channel *chan,
15526 unsigned int duration, gfp_t gfp)
15528 struct wiphy *wiphy = wdev->wiphy;
15529 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15531 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
15532 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
15533 rdev, wdev, cookie, chan,
15536 EXPORT_SYMBOL(cfg80211_ready_on_channel);
15538 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
15539 struct ieee80211_channel *chan,
15542 struct wiphy *wiphy = wdev->wiphy;
15543 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15545 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
15546 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
15547 rdev, wdev, cookie, chan, 0, gfp);
15549 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
15551 void cfg80211_tx_mgmt_expired(struct wireless_dev *wdev, u64 cookie,
15552 struct ieee80211_channel *chan,
15555 struct wiphy *wiphy = wdev->wiphy;
15556 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15558 trace_cfg80211_tx_mgmt_expired(wdev, cookie, chan);
15559 nl80211_send_remain_on_chan_event(NL80211_CMD_FRAME_WAIT_CANCEL,
15560 rdev, wdev, cookie, chan, 0, gfp);
15562 EXPORT_SYMBOL(cfg80211_tx_mgmt_expired);
15564 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
15565 struct station_info *sinfo, gfp_t gfp)
15567 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15568 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15569 struct sk_buff *msg;
15571 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
15573 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15577 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
15578 rdev, dev, mac_addr, sinfo) < 0) {
15583 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15584 NL80211_MCGRP_MLME, gfp);
15586 EXPORT_SYMBOL(cfg80211_new_sta);
15588 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
15589 struct station_info *sinfo, gfp_t gfp)
15591 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15592 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15593 struct sk_buff *msg;
15594 struct station_info empty_sinfo = {};
15597 sinfo = &empty_sinfo;
15599 trace_cfg80211_del_sta(dev, mac_addr);
15601 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15603 cfg80211_sinfo_release_content(sinfo);
15607 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
15608 rdev, dev, mac_addr, sinfo) < 0) {
15613 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15614 NL80211_MCGRP_MLME, gfp);
15616 EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
15618 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
15619 enum nl80211_connect_failed_reason reason,
15622 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15623 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15624 struct sk_buff *msg;
15627 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
15631 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
15637 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15638 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
15639 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
15640 goto nla_put_failure;
15642 genlmsg_end(msg, hdr);
15644 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15645 NL80211_MCGRP_MLME, gfp);
15651 EXPORT_SYMBOL(cfg80211_conn_failed);
15653 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
15654 const u8 *addr, gfp_t gfp)
15656 struct wireless_dev *wdev = dev->ieee80211_ptr;
15657 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15658 struct sk_buff *msg;
15660 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
15665 msg = nlmsg_new(100, gfp);
15669 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15675 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15676 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15677 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
15678 goto nla_put_failure;
15680 genlmsg_end(msg, hdr);
15681 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15689 bool cfg80211_rx_spurious_frame(struct net_device *dev,
15690 const u8 *addr, gfp_t gfp)
15692 struct wireless_dev *wdev = dev->ieee80211_ptr;
15695 trace_cfg80211_rx_spurious_frame(dev, addr);
15697 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
15698 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
15699 trace_cfg80211_return_bool(false);
15702 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
15704 trace_cfg80211_return_bool(ret);
15707 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
15709 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
15710 const u8 *addr, gfp_t gfp)
15712 struct wireless_dev *wdev = dev->ieee80211_ptr;
15715 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
15717 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
15718 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
15719 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
15720 trace_cfg80211_return_bool(false);
15723 ret = __nl80211_unexpected_frame(dev,
15724 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
15726 trace_cfg80211_return_bool(ret);
15729 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
15731 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15732 struct wireless_dev *wdev, u32 nlportid,
15733 int freq, int sig_dbm,
15734 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
15736 struct net_device *netdev = wdev->netdev;
15737 struct sk_buff *msg;
15740 msg = nlmsg_new(100 + len, gfp);
15744 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
15750 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15751 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15752 netdev->ifindex)) ||
15753 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15754 NL80211_ATTR_PAD) ||
15755 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
15757 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
15758 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
15760 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
15761 goto nla_put_failure;
15763 genlmsg_end(msg, hdr);
15765 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15772 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
15773 const u8 *buf, size_t len, bool ack, gfp_t gfp)
15775 struct wiphy *wiphy = wdev->wiphy;
15776 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15777 struct net_device *netdev = wdev->netdev;
15778 struct sk_buff *msg;
15781 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
15783 msg = nlmsg_new(100 + len, gfp);
15787 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
15793 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15794 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15795 netdev->ifindex)) ||
15796 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15797 NL80211_ATTR_PAD) ||
15798 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
15799 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
15800 NL80211_ATTR_PAD) ||
15801 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
15802 goto nla_put_failure;
15804 genlmsg_end(msg, hdr);
15806 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15807 NL80211_MCGRP_MLME, gfp);
15813 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
15815 static int __nl80211_rx_control_port(struct net_device *dev,
15816 struct sk_buff *skb,
15817 bool unencrypted, gfp_t gfp)
15819 struct wireless_dev *wdev = dev->ieee80211_ptr;
15820 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15821 struct ethhdr *ehdr = eth_hdr(skb);
15822 const u8 *addr = ehdr->h_source;
15823 u16 proto = be16_to_cpu(skb->protocol);
15824 struct sk_buff *msg;
15826 struct nlattr *frame;
15828 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid);
15833 msg = nlmsg_new(100 + skb->len, gfp);
15837 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME);
15843 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15844 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15845 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15846 NL80211_ATTR_PAD) ||
15847 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
15848 nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) ||
15849 (unencrypted && nla_put_flag(msg,
15850 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
15851 goto nla_put_failure;
15853 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len);
15855 goto nla_put_failure;
15857 skb_copy_bits(skb, 0, nla_data(frame), skb->len);
15858 genlmsg_end(msg, hdr);
15860 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15867 bool cfg80211_rx_control_port(struct net_device *dev,
15868 struct sk_buff *skb, bool unencrypted)
15872 trace_cfg80211_rx_control_port(dev, skb, unencrypted);
15873 ret = __nl80211_rx_control_port(dev, skb, unencrypted, GFP_ATOMIC);
15874 trace_cfg80211_return_bool(ret == 0);
15877 EXPORT_SYMBOL(cfg80211_rx_control_port);
15879 static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
15880 const char *mac, gfp_t gfp)
15882 struct wireless_dev *wdev = dev->ieee80211_ptr;
15883 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15884 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15890 cb = (void **)msg->cb;
15892 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
15898 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15899 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
15900 goto nla_put_failure;
15902 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
15903 goto nla_put_failure;
15905 cb[1] = nla_nest_start_noflag(msg, NL80211_ATTR_CQM);
15907 goto nla_put_failure;
15917 static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
15919 void **cb = (void **)msg->cb;
15920 struct cfg80211_registered_device *rdev = cb[2];
15922 nla_nest_end(msg, cb[1]);
15923 genlmsg_end(msg, cb[0]);
15925 memset(msg->cb, 0, sizeof(msg->cb));
15927 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15928 NL80211_MCGRP_MLME, gfp);
15931 void cfg80211_cqm_rssi_notify(struct net_device *dev,
15932 enum nl80211_cqm_rssi_threshold_event rssi_event,
15933 s32 rssi_level, gfp_t gfp)
15935 struct sk_buff *msg;
15936 struct wireless_dev *wdev = dev->ieee80211_ptr;
15937 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15939 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
15941 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
15942 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
15945 if (wdev->cqm_config) {
15946 wdev->cqm_config->last_rssi_event_value = rssi_level;
15948 cfg80211_cqm_rssi_update(rdev, dev);
15950 if (rssi_level == 0)
15951 rssi_level = wdev->cqm_config->last_rssi_event_value;
15954 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
15958 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
15960 goto nla_put_failure;
15962 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
15964 goto nla_put_failure;
15966 cfg80211_send_cqm(msg, gfp);
15973 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
15975 void cfg80211_cqm_txe_notify(struct net_device *dev,
15976 const u8 *peer, u32 num_packets,
15977 u32 rate, u32 intvl, gfp_t gfp)
15979 struct sk_buff *msg;
15981 msg = cfg80211_prepare_cqm(dev, peer, gfp);
15985 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
15986 goto nla_put_failure;
15988 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
15989 goto nla_put_failure;
15991 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
15992 goto nla_put_failure;
15994 cfg80211_send_cqm(msg, gfp);
16000 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
16002 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
16003 const u8 *peer, u32 num_packets, gfp_t gfp)
16005 struct sk_buff *msg;
16007 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
16009 msg = cfg80211_prepare_cqm(dev, peer, gfp);
16013 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
16014 goto nla_put_failure;
16016 cfg80211_send_cqm(msg, gfp);
16022 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
16024 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
16026 struct sk_buff *msg;
16028 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
16032 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
16033 goto nla_put_failure;
16035 cfg80211_send_cqm(msg, gfp);
16041 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
16043 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
16044 struct net_device *netdev, const u8 *bssid,
16045 const u8 *replay_ctr, gfp_t gfp)
16047 struct sk_buff *msg;
16048 struct nlattr *rekey_attr;
16051 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16055 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
16061 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16062 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16063 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
16064 goto nla_put_failure;
16066 rekey_attr = nla_nest_start_noflag(msg, NL80211_ATTR_REKEY_DATA);
16068 goto nla_put_failure;
16070 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
16071 NL80211_REPLAY_CTR_LEN, replay_ctr))
16072 goto nla_put_failure;
16074 nla_nest_end(msg, rekey_attr);
16076 genlmsg_end(msg, hdr);
16078 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16079 NL80211_MCGRP_MLME, gfp);
16086 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
16087 const u8 *replay_ctr, gfp_t gfp)
16089 struct wireless_dev *wdev = dev->ieee80211_ptr;
16090 struct wiphy *wiphy = wdev->wiphy;
16091 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16093 trace_cfg80211_gtk_rekey_notify(dev, bssid);
16094 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
16096 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
16099 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
16100 struct net_device *netdev, int index,
16101 const u8 *bssid, bool preauth, gfp_t gfp)
16103 struct sk_buff *msg;
16104 struct nlattr *attr;
16107 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16111 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
16117 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16118 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
16119 goto nla_put_failure;
16121 attr = nla_nest_start_noflag(msg, NL80211_ATTR_PMKSA_CANDIDATE);
16123 goto nla_put_failure;
16125 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
16126 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
16128 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
16129 goto nla_put_failure;
16131 nla_nest_end(msg, attr);
16133 genlmsg_end(msg, hdr);
16135 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16136 NL80211_MCGRP_MLME, gfp);
16143 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
16144 const u8 *bssid, bool preauth, gfp_t gfp)
16146 struct wireless_dev *wdev = dev->ieee80211_ptr;
16147 struct wiphy *wiphy = wdev->wiphy;
16148 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16150 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
16151 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
16153 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
16155 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
16156 struct net_device *netdev,
16157 struct cfg80211_chan_def *chandef,
16159 enum nl80211_commands notif,
16162 struct sk_buff *msg;
16165 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16169 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
16175 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
16176 goto nla_put_failure;
16178 if (nl80211_send_chandef(msg, chandef))
16179 goto nla_put_failure;
16181 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
16182 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
16183 goto nla_put_failure;
16185 genlmsg_end(msg, hdr);
16187 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16188 NL80211_MCGRP_MLME, gfp);
16195 void cfg80211_ch_switch_notify(struct net_device *dev,
16196 struct cfg80211_chan_def *chandef)
16198 struct wireless_dev *wdev = dev->ieee80211_ptr;
16199 struct wiphy *wiphy = wdev->wiphy;
16200 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16202 ASSERT_WDEV_LOCK(wdev);
16204 trace_cfg80211_ch_switch_notify(dev, chandef);
16206 wdev->chandef = *chandef;
16207 wdev->preset_chandef = *chandef;
16209 if (wdev->iftype == NL80211_IFTYPE_STATION &&
16210 !WARN_ON(!wdev->current_bss))
16211 cfg80211_update_assoc_bss_entry(wdev, chandef->chan);
16213 cfg80211_sched_dfs_chan_update(rdev);
16215 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
16216 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
16218 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
16220 void cfg80211_ch_switch_started_notify(struct net_device *dev,
16221 struct cfg80211_chan_def *chandef,
16224 struct wireless_dev *wdev = dev->ieee80211_ptr;
16225 struct wiphy *wiphy = wdev->wiphy;
16226 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16228 trace_cfg80211_ch_switch_started_notify(dev, chandef);
16230 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
16231 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
16233 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
16236 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
16237 const struct cfg80211_chan_def *chandef,
16238 enum nl80211_radar_event event,
16239 struct net_device *netdev, gfp_t gfp)
16241 struct sk_buff *msg;
16244 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16248 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
16254 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
16255 goto nla_put_failure;
16257 /* NOP and radar events don't need a netdev parameter */
16259 struct wireless_dev *wdev = netdev->ieee80211_ptr;
16261 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16262 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16264 goto nla_put_failure;
16267 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
16268 goto nla_put_failure;
16270 if (nl80211_send_chandef(msg, chandef))
16271 goto nla_put_failure;
16273 genlmsg_end(msg, hdr);
16275 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16276 NL80211_MCGRP_MLME, gfp);
16283 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac,
16284 struct sta_opmode_info *sta_opmode,
16287 struct sk_buff *msg;
16288 struct wireless_dev *wdev = dev->ieee80211_ptr;
16289 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16295 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16299 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED);
16305 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
16306 goto nla_put_failure;
16308 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
16309 goto nla_put_failure;
16311 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
16312 goto nla_put_failure;
16314 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) &&
16315 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode))
16316 goto nla_put_failure;
16318 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) &&
16319 nla_put_u8(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw))
16320 goto nla_put_failure;
16322 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) &&
16323 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss))
16324 goto nla_put_failure;
16326 genlmsg_end(msg, hdr);
16328 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16329 NL80211_MCGRP_MLME, gfp);
16336 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify);
16338 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
16339 u64 cookie, bool acked, s32 ack_signal,
16340 bool is_valid_ack_signal, gfp_t gfp)
16342 struct wireless_dev *wdev = dev->ieee80211_ptr;
16343 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16344 struct sk_buff *msg;
16347 trace_cfg80211_probe_status(dev, addr, cookie, acked);
16349 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16354 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
16360 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16361 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16362 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
16363 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
16364 NL80211_ATTR_PAD) ||
16365 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
16366 (is_valid_ack_signal && nla_put_s32(msg, NL80211_ATTR_ACK_SIGNAL,
16368 goto nla_put_failure;
16370 genlmsg_end(msg, hdr);
16372 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16373 NL80211_MCGRP_MLME, gfp);
16379 EXPORT_SYMBOL(cfg80211_probe_status);
16381 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
16382 const u8 *frame, size_t len,
16383 int freq, int sig_dbm)
16385 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16386 struct sk_buff *msg;
16388 struct cfg80211_beacon_registration *reg;
16390 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
16392 spin_lock_bh(&rdev->beacon_registrations_lock);
16393 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
16394 msg = nlmsg_new(len + 100, GFP_ATOMIC);
16396 spin_unlock_bh(&rdev->beacon_registrations_lock);
16400 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
16402 goto nla_put_failure;
16404 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16406 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
16408 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
16409 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
16410 goto nla_put_failure;
16412 genlmsg_end(msg, hdr);
16414 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
16416 spin_unlock_bh(&rdev->beacon_registrations_lock);
16420 spin_unlock_bh(&rdev->beacon_registrations_lock);
16423 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
16426 static int cfg80211_net_detect_results(struct sk_buff *msg,
16427 struct cfg80211_wowlan_wakeup *wakeup)
16429 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
16430 struct nlattr *nl_results, *nl_match, *nl_freqs;
16433 nl_results = nla_nest_start_noflag(msg,
16434 NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
16438 for (i = 0; i < nd->n_matches; i++) {
16439 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
16441 nl_match = nla_nest_start_noflag(msg, i);
16445 /* The SSID attribute is optional in nl80211, but for
16446 * simplicity reasons it's always present in the
16447 * cfg80211 structure. If a driver can't pass the
16448 * SSID, that needs to be changed. A zero length SSID
16449 * is still a valid SSID (wildcard), so it cannot be
16450 * used for this purpose.
16452 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
16453 match->ssid.ssid)) {
16454 nla_nest_cancel(msg, nl_match);
16458 if (match->n_channels) {
16459 nl_freqs = nla_nest_start_noflag(msg,
16460 NL80211_ATTR_SCAN_FREQUENCIES);
16462 nla_nest_cancel(msg, nl_match);
16466 for (j = 0; j < match->n_channels; j++) {
16467 if (nla_put_u32(msg, j, match->channels[j])) {
16468 nla_nest_cancel(msg, nl_freqs);
16469 nla_nest_cancel(msg, nl_match);
16474 nla_nest_end(msg, nl_freqs);
16477 nla_nest_end(msg, nl_match);
16481 nla_nest_end(msg, nl_results);
16485 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
16486 struct cfg80211_wowlan_wakeup *wakeup,
16489 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16490 struct sk_buff *msg;
16494 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
16497 size += wakeup->packet_present_len;
16499 msg = nlmsg_new(size, gfp);
16503 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
16507 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16508 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16512 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
16513 wdev->netdev->ifindex))
16517 struct nlattr *reasons;
16519 reasons = nla_nest_start_noflag(msg,
16520 NL80211_ATTR_WOWLAN_TRIGGERS);
16524 if (wakeup->disconnect &&
16525 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
16527 if (wakeup->magic_pkt &&
16528 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
16530 if (wakeup->gtk_rekey_failure &&
16531 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
16533 if (wakeup->eap_identity_req &&
16534 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
16536 if (wakeup->four_way_handshake &&
16537 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
16539 if (wakeup->rfkill_release &&
16540 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
16543 if (wakeup->pattern_idx >= 0 &&
16544 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
16545 wakeup->pattern_idx))
16548 if (wakeup->tcp_match &&
16549 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
16552 if (wakeup->tcp_connlost &&
16553 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
16556 if (wakeup->tcp_nomoretokens &&
16558 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
16561 if (wakeup->packet) {
16562 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
16563 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
16565 if (!wakeup->packet_80211) {
16567 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
16569 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
16572 if (wakeup->packet_len &&
16573 nla_put_u32(msg, len_attr, wakeup->packet_len))
16576 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
16581 if (wakeup->net_detect &&
16582 cfg80211_net_detect_results(msg, wakeup))
16585 nla_nest_end(msg, reasons);
16588 genlmsg_end(msg, hdr);
16590 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16591 NL80211_MCGRP_MLME, gfp);
16597 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
16600 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
16601 enum nl80211_tdls_operation oper,
16602 u16 reason_code, gfp_t gfp)
16604 struct wireless_dev *wdev = dev->ieee80211_ptr;
16605 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16606 struct sk_buff *msg;
16609 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
16612 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16616 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
16622 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16623 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16624 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
16625 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
16626 (reason_code > 0 &&
16627 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
16628 goto nla_put_failure;
16630 genlmsg_end(msg, hdr);
16632 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16633 NL80211_MCGRP_MLME, gfp);
16639 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
16641 static int nl80211_netlink_notify(struct notifier_block * nb,
16642 unsigned long state,
16645 struct netlink_notify *notify = _notify;
16646 struct cfg80211_registered_device *rdev;
16647 struct wireless_dev *wdev;
16648 struct cfg80211_beacon_registration *reg, *tmp;
16650 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
16651 return NOTIFY_DONE;
16655 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
16656 struct cfg80211_sched_scan_request *sched_scan_req;
16658 list_for_each_entry_rcu(sched_scan_req,
16659 &rdev->sched_scan_req_list,
16661 if (sched_scan_req->owner_nlportid == notify->portid) {
16662 sched_scan_req->nl_owner_dead = true;
16663 schedule_work(&rdev->sched_scan_stop_wk);
16667 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
16668 cfg80211_mlme_unregister_socket(wdev, notify->portid);
16670 if (wdev->owner_nlportid == notify->portid) {
16671 wdev->nl_owner_dead = true;
16672 schedule_work(&rdev->destroy_work);
16673 } else if (wdev->conn_owner_nlportid == notify->portid) {
16674 schedule_work(&wdev->disconnect_wk);
16677 cfg80211_release_pmsr(wdev, notify->portid);
16680 spin_lock_bh(&rdev->beacon_registrations_lock);
16681 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
16683 if (reg->nlportid == notify->portid) {
16684 list_del(®->list);
16689 spin_unlock_bh(&rdev->beacon_registrations_lock);
16695 * It is possible that the user space process that is controlling the
16696 * indoor setting disappeared, so notify the regulatory core.
16698 regulatory_netlink_notify(notify->portid);
16702 static struct notifier_block nl80211_netlink_notifier = {
16703 .notifier_call = nl80211_netlink_notify,
16706 void cfg80211_ft_event(struct net_device *netdev,
16707 struct cfg80211_ft_event_params *ft_event)
16709 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
16710 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16711 struct sk_buff *msg;
16714 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
16716 if (!ft_event->target_ap)
16719 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len,
16724 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
16728 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16729 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16730 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
16733 if (ft_event->ies &&
16734 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
16736 if (ft_event->ric_ies &&
16737 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
16738 ft_event->ric_ies))
16741 genlmsg_end(msg, hdr);
16743 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16744 NL80211_MCGRP_MLME, GFP_KERNEL);
16749 EXPORT_SYMBOL(cfg80211_ft_event);
16751 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
16753 struct cfg80211_registered_device *rdev;
16754 struct sk_buff *msg;
16758 rdev = wiphy_to_rdev(wdev->wiphy);
16759 if (!rdev->crit_proto_nlportid)
16762 nlportid = rdev->crit_proto_nlportid;
16763 rdev->crit_proto_nlportid = 0;
16765 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16769 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
16771 goto nla_put_failure;
16773 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16774 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16776 goto nla_put_failure;
16778 genlmsg_end(msg, hdr);
16780 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16786 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
16788 void nl80211_send_ap_stopped(struct wireless_dev *wdev)
16790 struct wiphy *wiphy = wdev->wiphy;
16791 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16792 struct sk_buff *msg;
16795 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
16799 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
16803 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16804 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
16805 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16809 genlmsg_end(msg, hdr);
16811 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
16812 NL80211_MCGRP_MLME, GFP_KERNEL);
16818 int cfg80211_external_auth_request(struct net_device *dev,
16819 struct cfg80211_external_auth_params *params,
16822 struct wireless_dev *wdev = dev->ieee80211_ptr;
16823 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16824 struct sk_buff *msg;
16827 if (!wdev->conn_owner_nlportid)
16830 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16834 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH);
16836 goto nla_put_failure;
16838 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16839 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16840 nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, params->key_mgmt_suite) ||
16841 nla_put_u32(msg, NL80211_ATTR_EXTERNAL_AUTH_ACTION,
16843 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) ||
16844 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len,
16845 params->ssid.ssid))
16846 goto nla_put_failure;
16848 genlmsg_end(msg, hdr);
16849 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
16850 wdev->conn_owner_nlportid);
16857 EXPORT_SYMBOL(cfg80211_external_auth_request);
16859 void cfg80211_update_owe_info_event(struct net_device *netdev,
16860 struct cfg80211_update_owe_info *owe_info,
16863 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
16864 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16865 struct sk_buff *msg;
16868 trace_cfg80211_update_owe_info_event(wiphy, netdev, owe_info);
16870 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16874 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_UPDATE_OWE_INFO);
16876 goto nla_put_failure;
16878 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16879 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16880 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, owe_info->peer))
16881 goto nla_put_failure;
16883 if (!owe_info->ie_len ||
16884 nla_put(msg, NL80211_ATTR_IE, owe_info->ie_len, owe_info->ie))
16885 goto nla_put_failure;
16887 genlmsg_end(msg, hdr);
16889 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16890 NL80211_MCGRP_MLME, gfp);
16894 genlmsg_cancel(msg, hdr);
16897 EXPORT_SYMBOL(cfg80211_update_owe_info_event);
16899 /* initialisation/exit functions */
16901 int __init nl80211_init(void)
16905 err = genl_register_family(&nl80211_fam);
16909 err = netlink_register_notifier(&nl80211_netlink_notifier);
16915 genl_unregister_family(&nl80211_fam);
16919 void nl80211_exit(void)
16921 netlink_unregister_notifier(&nl80211_netlink_notifier);
16922 genl_unregister_family(&nl80211_fam);