2 * This is the new netlink-based wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2013-2014 Intel Mobile Communications GmbH
6 * Copyright 2015-2017 Intel Deutschland GmbH
7 * Copyright (C) 2018 Intel Corporation
11 #include <linux/module.h>
12 #include <linux/err.h>
13 #include <linux/slab.h>
14 #include <linux/list.h>
15 #include <linux/if_ether.h>
16 #include <linux/ieee80211.h>
17 #include <linux/nl80211.h>
18 #include <linux/rtnetlink.h>
19 #include <linux/netlink.h>
20 #include <linux/nospec.h>
21 #include <linux/etherdevice.h>
22 #include <net/net_namespace.h>
23 #include <net/genetlink.h>
24 #include <net/cfg80211.h>
26 #include <net/inet_connection_sock.h>
32 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
33 struct genl_info *info,
34 struct cfg80211_crypto_settings *settings,
37 /* the netlink family */
38 static struct genl_family nl80211_fam;
40 /* multicast groups */
41 enum nl80211_multicast_groups {
44 NL80211_MCGRP_REGULATORY,
48 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
51 static const struct genl_multicast_group nl80211_mcgrps[] = {
52 [NL80211_MCGRP_CONFIG] = { .name = NL80211_MULTICAST_GROUP_CONFIG },
53 [NL80211_MCGRP_SCAN] = { .name = NL80211_MULTICAST_GROUP_SCAN },
54 [NL80211_MCGRP_REGULATORY] = { .name = NL80211_MULTICAST_GROUP_REG },
55 [NL80211_MCGRP_MLME] = { .name = NL80211_MULTICAST_GROUP_MLME },
56 [NL80211_MCGRP_VENDOR] = { .name = NL80211_MULTICAST_GROUP_VENDOR },
57 [NL80211_MCGRP_NAN] = { .name = NL80211_MULTICAST_GROUP_NAN },
58 #ifdef CONFIG_NL80211_TESTMODE
59 [NL80211_MCGRP_TESTMODE] = { .name = NL80211_MULTICAST_GROUP_TESTMODE }
63 /* returns ERR_PTR values */
64 static struct wireless_dev *
65 __cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
67 struct cfg80211_registered_device *rdev;
68 struct wireless_dev *result = NULL;
69 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
70 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
77 if (!have_ifidx && !have_wdev_id)
78 return ERR_PTR(-EINVAL);
81 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
83 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
84 wiphy_idx = wdev_id >> 32;
87 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
88 struct wireless_dev *wdev;
90 if (wiphy_net(&rdev->wiphy) != netns)
93 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
96 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
97 if (have_ifidx && wdev->netdev &&
98 wdev->netdev->ifindex == ifidx) {
102 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
114 return ERR_PTR(-ENODEV);
117 static struct cfg80211_registered_device *
118 __cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
120 struct cfg80211_registered_device *rdev = NULL, *tmp;
121 struct net_device *netdev;
125 if (!attrs[NL80211_ATTR_WIPHY] &&
126 !attrs[NL80211_ATTR_IFINDEX] &&
127 !attrs[NL80211_ATTR_WDEV])
128 return ERR_PTR(-EINVAL);
130 if (attrs[NL80211_ATTR_WIPHY])
131 rdev = cfg80211_rdev_by_wiphy_idx(
132 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
134 if (attrs[NL80211_ATTR_WDEV]) {
135 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
136 struct wireless_dev *wdev;
139 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
141 /* make sure wdev exists */
142 list_for_each_entry(wdev, &tmp->wiphy.wdev_list, list) {
143 if (wdev->identifier != (u32)wdev_id)
152 if (rdev && tmp != rdev)
153 return ERR_PTR(-EINVAL);
158 if (attrs[NL80211_ATTR_IFINDEX]) {
159 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
161 netdev = __dev_get_by_index(netns, ifindex);
163 if (netdev->ieee80211_ptr)
165 netdev->ieee80211_ptr->wiphy);
169 /* not wireless device -- return error */
171 return ERR_PTR(-EINVAL);
173 /* mismatch -- return error */
174 if (rdev && tmp != rdev)
175 return ERR_PTR(-EINVAL);
182 return ERR_PTR(-ENODEV);
184 if (netns != wiphy_net(&rdev->wiphy))
185 return ERR_PTR(-ENODEV);
191 * This function returns a pointer to the driver
192 * that the genl_info item that is passed refers to.
194 * The result of this can be a PTR_ERR and hence must
195 * be checked with IS_ERR() for errors.
197 static struct cfg80211_registered_device *
198 cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
200 return __cfg80211_rdev_from_attrs(netns, info->attrs);
203 static int validate_ie_attr(const struct nlattr *attr,
204 struct netlink_ext_ack *extack)
209 pos = nla_data(attr);
229 NL_SET_ERR_MSG_ATTR(extack, attr, "malformed information elements");
233 /* policy for the attributes */
234 static const struct nla_policy
235 nl80211_ftm_responder_policy[NL80211_FTM_RESP_ATTR_MAX + 1] = {
236 [NL80211_FTM_RESP_ATTR_ENABLED] = { .type = NLA_FLAG, },
237 [NL80211_FTM_RESP_ATTR_LCI] = { .type = NLA_BINARY,
239 [NL80211_FTM_RESP_ATTR_CIVICLOC] = { .type = NLA_BINARY,
243 static const struct nla_policy
244 nl80211_pmsr_ftm_req_attr_policy[NL80211_PMSR_FTM_REQ_ATTR_MAX + 1] = {
245 [NL80211_PMSR_FTM_REQ_ATTR_ASAP] = { .type = NLA_FLAG },
246 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE] = { .type = NLA_U32 },
247 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP] =
248 NLA_POLICY_MAX(NLA_U8, 15),
249 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD] = { .type = NLA_U16 },
250 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION] =
251 NLA_POLICY_MAX(NLA_U8, 15),
252 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST] =
253 NLA_POLICY_MAX(NLA_U8, 31),
254 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES] = { .type = NLA_U8 },
255 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI] = { .type = NLA_FLAG },
256 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC] = { .type = NLA_FLAG },
259 static const struct nla_policy
260 nl80211_pmsr_req_data_policy[NL80211_PMSR_TYPE_MAX + 1] = {
261 [NL80211_PMSR_TYPE_FTM] =
262 NLA_POLICY_NESTED(NL80211_PMSR_FTM_REQ_ATTR_MAX,
263 nl80211_pmsr_ftm_req_attr_policy),
266 static const struct nla_policy
267 nl80211_pmsr_req_attr_policy[NL80211_PMSR_REQ_ATTR_MAX + 1] = {
268 [NL80211_PMSR_REQ_ATTR_DATA] =
269 NLA_POLICY_NESTED(NL80211_PMSR_TYPE_MAX,
270 nl80211_pmsr_req_data_policy),
271 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF] = { .type = NLA_FLAG },
274 static const struct nla_policy
275 nl80211_psmr_peer_attr_policy[NL80211_PMSR_PEER_ATTR_MAX + 1] = {
276 [NL80211_PMSR_PEER_ATTR_ADDR] = NLA_POLICY_ETH_ADDR,
278 * we could specify this again to be the top-level policy,
279 * but that would open us up to recursion problems ...
281 [NL80211_PMSR_PEER_ATTR_CHAN] = { .type = NLA_NESTED },
282 [NL80211_PMSR_PEER_ATTR_REQ] =
283 NLA_POLICY_NESTED(NL80211_PMSR_REQ_ATTR_MAX,
284 nl80211_pmsr_req_attr_policy),
285 [NL80211_PMSR_PEER_ATTR_RESP] = { .type = NLA_REJECT },
288 static const struct nla_policy
289 nl80211_pmsr_attr_policy[NL80211_PMSR_ATTR_MAX + 1] = {
290 [NL80211_PMSR_ATTR_MAX_PEERS] = { .type = NLA_REJECT },
291 [NL80211_PMSR_ATTR_REPORT_AP_TSF] = { .type = NLA_REJECT },
292 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR] = { .type = NLA_REJECT },
293 [NL80211_PMSR_ATTR_TYPE_CAPA] = { .type = NLA_REJECT },
294 [NL80211_PMSR_ATTR_PEERS] =
295 NLA_POLICY_NESTED_ARRAY(NL80211_PMSR_PEER_ATTR_MAX,
296 nl80211_psmr_peer_attr_policy),
299 const struct nla_policy nl80211_policy[NUM_NL80211_ATTR] = {
300 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
301 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
303 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
305 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
306 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
307 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
308 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
309 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
311 [NL80211_ATTR_WIPHY_RETRY_SHORT] = NLA_POLICY_MIN(NLA_U8, 1),
312 [NL80211_ATTR_WIPHY_RETRY_LONG] = NLA_POLICY_MIN(NLA_U8, 1),
313 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
314 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
315 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
316 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
318 [NL80211_ATTR_IFTYPE] = NLA_POLICY_MAX(NLA_U32, NL80211_IFTYPE_MAX),
319 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
320 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
322 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
323 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
325 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
326 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
327 .len = WLAN_MAX_KEY_LEN },
328 [NL80211_ATTR_KEY_IDX] = NLA_POLICY_MAX(NLA_U8, 5),
329 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
330 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
331 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
332 [NL80211_ATTR_KEY_TYPE] =
333 NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES),
335 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
336 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
337 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
338 .len = IEEE80211_MAX_DATA_LEN },
339 [NL80211_ATTR_BEACON_TAIL] =
340 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
341 IEEE80211_MAX_DATA_LEN),
342 [NL80211_ATTR_STA_AID] =
343 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
344 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
345 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
346 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
347 .len = NL80211_MAX_SUPP_RATES },
348 [NL80211_ATTR_STA_PLINK_ACTION] =
349 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_ACTIONS - 1),
350 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
351 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
352 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
353 .len = IEEE80211_MAX_MESH_ID_LEN },
354 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
356 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
357 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
359 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
360 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
361 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
362 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
363 .len = NL80211_MAX_SUPP_RATES },
364 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
366 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
367 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
369 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
371 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
372 [NL80211_ATTR_IE] = NLA_POLICY_VALIDATE_FN(NLA_BINARY,
374 IEEE80211_MAX_DATA_LEN),
375 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
376 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
378 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
379 .len = IEEE80211_MAX_SSID_LEN },
380 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
381 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
382 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
383 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
384 [NL80211_ATTR_USE_MFP] = NLA_POLICY_RANGE(NLA_U32,
386 NL80211_MFP_OPTIONAL),
387 [NL80211_ATTR_STA_FLAGS2] = {
388 .len = sizeof(struct nl80211_sta_flag_update),
390 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
391 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
392 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
393 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211] = { .type = NLA_FLAG },
394 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
395 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
396 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
397 [NL80211_ATTR_PID] = { .type = NLA_U32 },
398 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
399 [NL80211_ATTR_PMKID] = { .len = WLAN_PMKID_LEN },
400 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
401 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
402 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
403 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
404 .len = IEEE80211_MAX_DATA_LEN },
405 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
406 [NL80211_ATTR_PS_STATE] = NLA_POLICY_RANGE(NLA_U32,
409 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
410 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
411 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
412 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
413 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
414 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
415 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
416 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
417 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
418 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
419 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
420 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
421 [NL80211_ATTR_STA_PLINK_STATE] =
422 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_PLINK_STATES - 1),
423 [NL80211_ATTR_MESH_PEER_AID] =
424 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
425 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
426 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
427 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
428 [NL80211_ATTR_HIDDEN_SSID] =
429 NLA_POLICY_RANGE(NLA_U32,
430 NL80211_HIDDEN_SSID_NOT_IN_USE,
431 NL80211_HIDDEN_SSID_ZERO_CONTENTS),
432 [NL80211_ATTR_IE_PROBE_RESP] =
433 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
434 IEEE80211_MAX_DATA_LEN),
435 [NL80211_ATTR_IE_ASSOC_RESP] =
436 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
437 IEEE80211_MAX_DATA_LEN),
438 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
439 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
440 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
441 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
442 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
443 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
444 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
445 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
446 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
447 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
448 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
449 .len = IEEE80211_MAX_DATA_LEN },
450 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
451 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
452 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
453 .len = NL80211_HT_CAPABILITY_LEN
455 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
456 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
457 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
458 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
459 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
460 [NL80211_ATTR_AUTH_DATA] = { .type = NLA_BINARY, },
461 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
462 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
463 [NL80211_ATTR_P2P_CTWINDOW] = NLA_POLICY_MAX(NLA_U8, 127),
464 [NL80211_ATTR_P2P_OPPPS] = NLA_POLICY_MAX(NLA_U8, 1),
465 [NL80211_ATTR_LOCAL_MESH_POWER_MODE] =
466 NLA_POLICY_RANGE(NLA_U32,
467 NL80211_MESH_POWER_UNKNOWN + 1,
468 NL80211_MESH_POWER_MAX),
469 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
470 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
471 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
472 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
473 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
474 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
475 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
476 .len = NL80211_VHT_CAPABILITY_LEN,
478 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
479 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
480 .len = IEEE80211_MAX_DATA_LEN },
481 [NL80211_ATTR_PEER_AID] =
482 NLA_POLICY_RANGE(NLA_U16, 1, IEEE80211_MAX_AID),
483 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
484 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
485 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
486 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
487 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
488 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
489 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
490 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
491 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
492 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
493 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
494 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
495 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
496 .len = IEEE80211_QOS_MAP_LEN_MAX },
497 [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
498 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
499 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
500 [NL80211_ATTR_SOCKET_OWNER] = { .type = NLA_FLAG },
501 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
502 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
503 [NL80211_ATTR_TSID] = NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_TIDS - 1),
504 [NL80211_ATTR_USER_PRIO] =
505 NLA_POLICY_MAX(NLA_U8, IEEE80211_NUM_UPS - 1),
506 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
507 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
508 [NL80211_ATTR_MAC_MASK] = { .len = ETH_ALEN },
509 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG] = { .type = NLA_FLAG },
510 [NL80211_ATTR_NETNS_FD] = { .type = NLA_U32 },
511 [NL80211_ATTR_SCHED_SCAN_DELAY] = { .type = NLA_U32 },
512 [NL80211_ATTR_REG_INDOOR] = { .type = NLA_FLAG },
513 [NL80211_ATTR_PBSS] = { .type = NLA_FLAG },
514 [NL80211_ATTR_BSS_SELECT] = { .type = NLA_NESTED },
515 [NL80211_ATTR_STA_SUPPORT_P2P_PS] =
516 NLA_POLICY_MAX(NLA_U8, NUM_NL80211_P2P_PS_STATUS - 1),
517 [NL80211_ATTR_MU_MIMO_GROUP_DATA] = {
518 .len = VHT_MUMIMO_GROUPS_DATA_LEN
520 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR] = { .len = ETH_ALEN },
521 [NL80211_ATTR_NAN_MASTER_PREF] = NLA_POLICY_MIN(NLA_U8, 1),
522 [NL80211_ATTR_BANDS] = { .type = NLA_U32 },
523 [NL80211_ATTR_NAN_FUNC] = { .type = NLA_NESTED },
524 [NL80211_ATTR_FILS_KEK] = { .type = NLA_BINARY,
525 .len = FILS_MAX_KEK_LEN },
526 [NL80211_ATTR_FILS_NONCES] = { .len = 2 * FILS_NONCE_LEN },
527 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED] = { .type = NLA_FLAG, },
528 [NL80211_ATTR_BSSID] = { .len = ETH_ALEN },
529 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] = { .type = NLA_S8 },
530 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST] = {
531 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
533 [NL80211_ATTR_TIMEOUT_REASON] = { .type = NLA_U32 },
534 [NL80211_ATTR_FILS_ERP_USERNAME] = { .type = NLA_BINARY,
535 .len = FILS_ERP_MAX_USERNAME_LEN },
536 [NL80211_ATTR_FILS_ERP_REALM] = { .type = NLA_BINARY,
537 .len = FILS_ERP_MAX_REALM_LEN },
538 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] = { .type = NLA_U16 },
539 [NL80211_ATTR_FILS_ERP_RRK] = { .type = NLA_BINARY,
540 .len = FILS_ERP_MAX_RRK_LEN },
541 [NL80211_ATTR_FILS_CACHE_ID] = { .len = 2 },
542 [NL80211_ATTR_PMK] = { .type = NLA_BINARY, .len = PMK_MAX_LEN },
543 [NL80211_ATTR_SCHED_SCAN_MULTI] = { .type = NLA_FLAG },
544 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT] = { .type = NLA_FLAG },
546 [NL80211_ATTR_TXQ_LIMIT] = { .type = NLA_U32 },
547 [NL80211_ATTR_TXQ_MEMORY_LIMIT] = { .type = NLA_U32 },
548 [NL80211_ATTR_TXQ_QUANTUM] = { .type = NLA_U32 },
549 [NL80211_ATTR_HE_CAPABILITY] = { .type = NLA_BINARY,
550 .len = NL80211_HE_MAX_CAPABILITY_LEN },
552 [NL80211_ATTR_FTM_RESPONDER] = {
554 .validation_data = nl80211_ftm_responder_policy,
556 [NL80211_ATTR_TIMEOUT] = NLA_POLICY_MIN(NLA_U32, 1),
557 [NL80211_ATTR_PEER_MEASUREMENTS] =
558 NLA_POLICY_NESTED(NL80211_PMSR_ATTR_MAX,
559 nl80211_pmsr_attr_policy),
562 /* policy for the key attributes */
563 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
564 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
565 [NL80211_KEY_IDX] = { .type = NLA_U8 },
566 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
567 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
568 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
569 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
570 [NL80211_KEY_TYPE] = NLA_POLICY_MAX(NLA_U32, NUM_NL80211_KEYTYPES - 1),
571 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
574 /* policy for the key default flags */
575 static const struct nla_policy
576 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
577 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
578 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
582 /* policy for WoWLAN attributes */
583 static const struct nla_policy
584 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
585 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
586 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
587 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
588 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
589 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
590 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
591 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
592 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
593 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
594 [NL80211_WOWLAN_TRIG_NET_DETECT] = { .type = NLA_NESTED },
597 static const struct nla_policy
598 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
599 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
600 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
601 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
602 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
603 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
604 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
605 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
606 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
608 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
609 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
611 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
612 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
613 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
615 #endif /* CONFIG_PM */
617 /* policy for coalesce rule attributes */
618 static const struct nla_policy
619 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
620 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
621 [NL80211_ATTR_COALESCE_RULE_CONDITION] =
622 NLA_POLICY_RANGE(NLA_U32,
623 NL80211_COALESCE_CONDITION_MATCH,
624 NL80211_COALESCE_CONDITION_NO_MATCH),
625 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
628 /* policy for GTK rekey offload attributes */
629 static const struct nla_policy
630 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
631 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
632 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
633 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
636 static const struct nla_policy
637 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
638 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
639 .len = IEEE80211_MAX_SSID_LEN },
640 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID] = { .len = ETH_ALEN },
641 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
644 static const struct nla_policy
645 nl80211_plan_policy[NL80211_SCHED_SCAN_PLAN_MAX + 1] = {
646 [NL80211_SCHED_SCAN_PLAN_INTERVAL] = { .type = NLA_U32 },
647 [NL80211_SCHED_SCAN_PLAN_ITERATIONS] = { .type = NLA_U32 },
650 static const struct nla_policy
651 nl80211_bss_select_policy[NL80211_BSS_SELECT_ATTR_MAX + 1] = {
652 [NL80211_BSS_SELECT_ATTR_RSSI] = { .type = NLA_FLAG },
653 [NL80211_BSS_SELECT_ATTR_BAND_PREF] = { .type = NLA_U32 },
654 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST] = {
655 .len = sizeof(struct nl80211_bss_select_rssi_adjust)
659 /* policy for NAN function attributes */
660 static const struct nla_policy
661 nl80211_nan_func_policy[NL80211_NAN_FUNC_ATTR_MAX + 1] = {
662 [NL80211_NAN_FUNC_TYPE] = { .type = NLA_U8 },
663 [NL80211_NAN_FUNC_SERVICE_ID] = {
664 .len = NL80211_NAN_FUNC_SERVICE_ID_LEN },
665 [NL80211_NAN_FUNC_PUBLISH_TYPE] = { .type = NLA_U8 },
666 [NL80211_NAN_FUNC_PUBLISH_BCAST] = { .type = NLA_FLAG },
667 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE] = { .type = NLA_FLAG },
668 [NL80211_NAN_FUNC_FOLLOW_UP_ID] = { .type = NLA_U8 },
669 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] = { .type = NLA_U8 },
670 [NL80211_NAN_FUNC_FOLLOW_UP_DEST] = { .len = ETH_ALEN },
671 [NL80211_NAN_FUNC_CLOSE_RANGE] = { .type = NLA_FLAG },
672 [NL80211_NAN_FUNC_TTL] = { .type = NLA_U32 },
673 [NL80211_NAN_FUNC_SERVICE_INFO] = { .type = NLA_BINARY,
674 .len = NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN },
675 [NL80211_NAN_FUNC_SRF] = { .type = NLA_NESTED },
676 [NL80211_NAN_FUNC_RX_MATCH_FILTER] = { .type = NLA_NESTED },
677 [NL80211_NAN_FUNC_TX_MATCH_FILTER] = { .type = NLA_NESTED },
678 [NL80211_NAN_FUNC_INSTANCE_ID] = { .type = NLA_U8 },
679 [NL80211_NAN_FUNC_TERM_REASON] = { .type = NLA_U8 },
682 /* policy for Service Response Filter attributes */
683 static const struct nla_policy
684 nl80211_nan_srf_policy[NL80211_NAN_SRF_ATTR_MAX + 1] = {
685 [NL80211_NAN_SRF_INCLUDE] = { .type = NLA_FLAG },
686 [NL80211_NAN_SRF_BF] = { .type = NLA_BINARY,
687 .len = NL80211_NAN_FUNC_SRF_MAX_LEN },
688 [NL80211_NAN_SRF_BF_IDX] = { .type = NLA_U8 },
689 [NL80211_NAN_SRF_MAC_ADDRS] = { .type = NLA_NESTED },
692 /* policy for packet pattern attributes */
693 static const struct nla_policy
694 nl80211_packet_pattern_policy[MAX_NL80211_PKTPAT + 1] = {
695 [NL80211_PKTPAT_MASK] = { .type = NLA_BINARY, },
696 [NL80211_PKTPAT_PATTERN] = { .type = NLA_BINARY, },
697 [NL80211_PKTPAT_OFFSET] = { .type = NLA_U32 },
700 int nl80211_prepare_wdev_dump(struct netlink_callback *cb,
701 struct cfg80211_registered_device **rdev,
702 struct wireless_dev **wdev)
707 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
708 genl_family_attrbuf(&nl80211_fam),
709 nl80211_fam.maxattr, nl80211_policy, NULL);
713 *wdev = __cfg80211_wdev_from_attrs(
714 sock_net(cb->skb->sk),
715 genl_family_attrbuf(&nl80211_fam));
717 return PTR_ERR(*wdev);
718 *rdev = wiphy_to_rdev((*wdev)->wiphy);
719 /* 0 is the first index - add 1 to parse only once */
720 cb->args[0] = (*rdev)->wiphy_idx + 1;
721 cb->args[1] = (*wdev)->identifier;
723 /* subtract the 1 again here */
724 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
725 struct wireless_dev *tmp;
729 *rdev = wiphy_to_rdev(wiphy);
732 list_for_each_entry(tmp, &(*rdev)->wiphy.wdev_list, list) {
733 if (tmp->identifier == cb->args[1]) {
746 /* message building helper */
747 void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
750 /* since there is no private header just add the generic one */
751 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
754 static int nl80211_msg_put_wmm_rules(struct sk_buff *msg,
755 const struct ieee80211_reg_rule *rule)
758 struct nlattr *nl_wmm_rules =
759 nla_nest_start(msg, NL80211_FREQUENCY_ATTR_WMM);
762 goto nla_put_failure;
764 for (j = 0; j < IEEE80211_NUM_ACS; j++) {
765 struct nlattr *nl_wmm_rule = nla_nest_start(msg, j);
768 goto nla_put_failure;
770 if (nla_put_u16(msg, NL80211_WMMR_CW_MIN,
771 rule->wmm_rule.client[j].cw_min) ||
772 nla_put_u16(msg, NL80211_WMMR_CW_MAX,
773 rule->wmm_rule.client[j].cw_max) ||
774 nla_put_u8(msg, NL80211_WMMR_AIFSN,
775 rule->wmm_rule.client[j].aifsn) ||
776 nla_put_u16(msg, NL80211_WMMR_TXOP,
777 rule->wmm_rule.client[j].cot))
778 goto nla_put_failure;
780 nla_nest_end(msg, nl_wmm_rule);
782 nla_nest_end(msg, nl_wmm_rules);
790 static int nl80211_msg_put_channel(struct sk_buff *msg, struct wiphy *wiphy,
791 struct ieee80211_channel *chan,
794 /* Some channels must be completely excluded from the
795 * list to protect old user-space tools from breaking
797 if (!large && chan->flags &
798 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
801 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
803 goto nla_put_failure;
805 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
806 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
807 goto nla_put_failure;
808 if (chan->flags & IEEE80211_CHAN_NO_IR) {
809 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
810 goto nla_put_failure;
811 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
812 goto nla_put_failure;
814 if (chan->flags & IEEE80211_CHAN_RADAR) {
815 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
816 goto nla_put_failure;
820 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
822 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
824 goto nla_put_failure;
825 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
827 goto nla_put_failure;
829 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
831 goto nla_put_failure;
836 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
837 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
838 goto nla_put_failure;
839 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
840 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
841 goto nla_put_failure;
842 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
843 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
844 goto nla_put_failure;
845 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
846 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
847 goto nla_put_failure;
848 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
849 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
850 goto nla_put_failure;
851 if ((chan->flags & IEEE80211_CHAN_IR_CONCURRENT) &&
852 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_IR_CONCURRENT))
853 goto nla_put_failure;
854 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
855 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
856 goto nla_put_failure;
857 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
858 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
859 goto nla_put_failure;
862 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
863 DBM_TO_MBM(chan->max_power)))
864 goto nla_put_failure;
867 const struct ieee80211_reg_rule *rule =
868 freq_reg_info(wiphy, MHZ_TO_KHZ(chan->center_freq));
870 if (!IS_ERR_OR_NULL(rule) && rule->has_wmm) {
871 if (nl80211_msg_put_wmm_rules(msg, rule))
872 goto nla_put_failure;
882 static bool nl80211_put_txq_stats(struct sk_buff *msg,
883 struct cfg80211_txq_stats *txqstats,
886 struct nlattr *txqattr;
888 #define PUT_TXQVAL_U32(attr, memb) do { \
889 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
890 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
894 txqattr = nla_nest_start(msg, attrtype);
898 PUT_TXQVAL_U32(BACKLOG_BYTES, backlog_bytes);
899 PUT_TXQVAL_U32(BACKLOG_PACKETS, backlog_packets);
900 PUT_TXQVAL_U32(FLOWS, flows);
901 PUT_TXQVAL_U32(DROPS, drops);
902 PUT_TXQVAL_U32(ECN_MARKS, ecn_marks);
903 PUT_TXQVAL_U32(OVERLIMIT, overlimit);
904 PUT_TXQVAL_U32(OVERMEMORY, overmemory);
905 PUT_TXQVAL_U32(COLLISIONS, collisions);
906 PUT_TXQVAL_U32(TX_BYTES, tx_bytes);
907 PUT_TXQVAL_U32(TX_PACKETS, tx_packets);
908 PUT_TXQVAL_U32(MAX_FLOWS, max_flows);
909 nla_nest_end(msg, txqattr);
911 #undef PUT_TXQVAL_U32
915 /* netlink command implementations */
922 bool def_uni, def_multi;
925 static int nl80211_parse_key_new(struct genl_info *info, struct nlattr *key,
928 struct nlattr *tb[NL80211_KEY_MAX + 1];
929 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
930 nl80211_key_policy, info->extack);
934 k->def = !!tb[NL80211_KEY_DEFAULT];
935 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
944 if (tb[NL80211_KEY_IDX])
945 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
947 if (tb[NL80211_KEY_DATA]) {
948 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
949 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
952 if (tb[NL80211_KEY_SEQ]) {
953 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
954 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
957 if (tb[NL80211_KEY_CIPHER])
958 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
960 if (tb[NL80211_KEY_TYPE])
961 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
963 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
964 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
966 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
967 tb[NL80211_KEY_DEFAULT_TYPES],
968 nl80211_key_default_policy,
973 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
974 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
980 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
982 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
983 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
984 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
987 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
988 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
989 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
992 if (info->attrs[NL80211_ATTR_KEY_IDX])
993 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
995 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
996 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
998 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
999 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
1003 k->def_multi = true;
1006 k->def_multi = true;
1008 if (info->attrs[NL80211_ATTR_KEY_TYPE])
1009 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
1011 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
1012 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
1013 int err = nla_parse_nested(kdt,
1014 NUM_NL80211_KEY_DEFAULT_TYPES - 1,
1015 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
1016 nl80211_key_default_policy,
1021 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
1022 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
1028 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
1032 memset(k, 0, sizeof(*k));
1036 if (info->attrs[NL80211_ATTR_KEY])
1037 err = nl80211_parse_key_new(info, info->attrs[NL80211_ATTR_KEY], k);
1039 err = nl80211_parse_key_old(info, k);
1044 if (k->def && k->defmgmt) {
1045 GENL_SET_ERR_MSG(info, "key with def && defmgmt is invalid");
1050 if (k->def_uni || !k->def_multi) {
1051 GENL_SET_ERR_MSG(info, "defmgmt key must be mcast");
1058 if (k->idx < 4 || k->idx > 5) {
1059 GENL_SET_ERR_MSG(info,
1060 "defmgmt key idx not 4 or 5");
1063 } else if (k->def) {
1064 if (k->idx < 0 || k->idx > 3) {
1065 GENL_SET_ERR_MSG(info, "def key idx not 0-3");
1069 if (k->idx < 0 || k->idx > 5) {
1070 GENL_SET_ERR_MSG(info, "key idx not 0-5");
1079 static struct cfg80211_cached_keys *
1080 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
1081 struct genl_info *info, bool *no_ht)
1083 struct nlattr *keys = info->attrs[NL80211_ATTR_KEYS];
1084 struct key_parse parse;
1086 struct cfg80211_cached_keys *result;
1087 int rem, err, def = 0;
1088 bool have_key = false;
1090 nla_for_each_nested(key, keys, rem) {
1098 result = kzalloc(sizeof(*result), GFP_KERNEL);
1100 return ERR_PTR(-ENOMEM);
1104 nla_for_each_nested(key, keys, rem) {
1105 memset(&parse, 0, sizeof(parse));
1108 err = nl80211_parse_key_new(info, key, &parse);
1114 if (parse.idx < 0 || parse.idx > 3) {
1115 GENL_SET_ERR_MSG(info, "key index out of range [0-3]");
1120 GENL_SET_ERR_MSG(info,
1121 "only one key can be default");
1125 result->def = parse.idx;
1126 if (!parse.def_uni || !parse.def_multi)
1128 } else if (parse.defmgmt)
1130 err = cfg80211_validate_key_settings(rdev, &parse.p,
1131 parse.idx, false, NULL);
1134 if (parse.p.cipher != WLAN_CIPHER_SUITE_WEP40 &&
1135 parse.p.cipher != WLAN_CIPHER_SUITE_WEP104) {
1136 GENL_SET_ERR_MSG(info, "connect key must be WEP");
1140 result->params[parse.idx].cipher = parse.p.cipher;
1141 result->params[parse.idx].key_len = parse.p.key_len;
1142 result->params[parse.idx].key = result->data[parse.idx];
1143 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
1145 /* must be WEP key if we got here */
1150 if (result->def < 0) {
1152 GENL_SET_ERR_MSG(info, "need a default/TX key");
1159 return ERR_PTR(err);
1162 static int nl80211_key_allowed(struct wireless_dev *wdev)
1164 ASSERT_WDEV_LOCK(wdev);
1166 switch (wdev->iftype) {
1167 case NL80211_IFTYPE_AP:
1168 case NL80211_IFTYPE_AP_VLAN:
1169 case NL80211_IFTYPE_P2P_GO:
1170 case NL80211_IFTYPE_MESH_POINT:
1172 case NL80211_IFTYPE_ADHOC:
1173 case NL80211_IFTYPE_STATION:
1174 case NL80211_IFTYPE_P2P_CLIENT:
1175 if (!wdev->current_bss)
1178 case NL80211_IFTYPE_UNSPECIFIED:
1179 case NL80211_IFTYPE_OCB:
1180 case NL80211_IFTYPE_MONITOR:
1181 case NL80211_IFTYPE_NAN:
1182 case NL80211_IFTYPE_P2P_DEVICE:
1183 case NL80211_IFTYPE_WDS:
1184 case NUM_NL80211_IFTYPES:
1191 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
1194 struct ieee80211_channel *chan;
1198 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
1199 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
1204 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
1206 struct nlattr *nl_modes = nla_nest_start(msg, attr);
1210 goto nla_put_failure;
1214 if ((ifmodes & 1) && nla_put_flag(msg, i))
1215 goto nla_put_failure;
1220 nla_nest_end(msg, nl_modes);
1227 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
1228 struct sk_buff *msg,
1231 struct nlattr *nl_combis;
1234 nl_combis = nla_nest_start(msg,
1235 NL80211_ATTR_INTERFACE_COMBINATIONS);
1237 goto nla_put_failure;
1239 for (i = 0; i < wiphy->n_iface_combinations; i++) {
1240 const struct ieee80211_iface_combination *c;
1241 struct nlattr *nl_combi, *nl_limits;
1243 c = &wiphy->iface_combinations[i];
1245 nl_combi = nla_nest_start(msg, i + 1);
1247 goto nla_put_failure;
1249 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
1251 goto nla_put_failure;
1253 for (j = 0; j < c->n_limits; j++) {
1254 struct nlattr *nl_limit;
1256 nl_limit = nla_nest_start(msg, j + 1);
1258 goto nla_put_failure;
1259 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
1261 goto nla_put_failure;
1262 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
1263 c->limits[j].types))
1264 goto nla_put_failure;
1265 nla_nest_end(msg, nl_limit);
1268 nla_nest_end(msg, nl_limits);
1270 if (c->beacon_int_infra_match &&
1271 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
1272 goto nla_put_failure;
1273 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
1274 c->num_different_channels) ||
1275 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
1277 goto nla_put_failure;
1279 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
1280 c->radar_detect_widths) ||
1281 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
1282 c->radar_detect_regions)))
1283 goto nla_put_failure;
1284 if (c->beacon_int_min_gcd &&
1285 nla_put_u32(msg, NL80211_IFACE_COMB_BI_MIN_GCD,
1286 c->beacon_int_min_gcd))
1287 goto nla_put_failure;
1289 nla_nest_end(msg, nl_combi);
1292 nla_nest_end(msg, nl_combis);
1300 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1301 struct sk_buff *msg)
1303 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1304 struct nlattr *nl_tcp;
1309 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1313 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1314 tcp->data_payload_max))
1317 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1318 tcp->data_payload_max))
1321 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1324 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1325 sizeof(*tcp->tok), tcp->tok))
1328 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1329 tcp->data_interval_max))
1332 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1333 tcp->wake_payload_max))
1336 nla_nest_end(msg, nl_tcp);
1340 static int nl80211_send_wowlan(struct sk_buff *msg,
1341 struct cfg80211_registered_device *rdev,
1344 struct nlattr *nl_wowlan;
1346 if (!rdev->wiphy.wowlan)
1349 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1353 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1354 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1355 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1356 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1357 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1358 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1359 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1360 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1361 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1362 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1363 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1364 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1365 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1366 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1367 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1368 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1371 if (rdev->wiphy.wowlan->n_patterns) {
1372 struct nl80211_pattern_support pat = {
1373 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1374 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1375 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1376 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1379 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1384 if ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_NET_DETECT) &&
1385 nla_put_u32(msg, NL80211_WOWLAN_TRIG_NET_DETECT,
1386 rdev->wiphy.wowlan->max_nd_match_sets))
1389 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
1392 nla_nest_end(msg, nl_wowlan);
1398 static int nl80211_send_coalesce(struct sk_buff *msg,
1399 struct cfg80211_registered_device *rdev)
1401 struct nl80211_coalesce_rule_support rule;
1403 if (!rdev->wiphy.coalesce)
1406 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1407 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1408 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1409 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1410 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1411 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1413 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1420 nl80211_send_iftype_data(struct sk_buff *msg,
1421 const struct ieee80211_sband_iftype_data *iftdata)
1423 const struct ieee80211_sta_he_cap *he_cap = &iftdata->he_cap;
1425 if (nl80211_put_iftypes(msg, NL80211_BAND_IFTYPE_ATTR_IFTYPES,
1426 iftdata->types_mask))
1429 if (he_cap->has_he) {
1430 if (nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC,
1431 sizeof(he_cap->he_cap_elem.mac_cap_info),
1432 he_cap->he_cap_elem.mac_cap_info) ||
1433 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY,
1434 sizeof(he_cap->he_cap_elem.phy_cap_info),
1435 he_cap->he_cap_elem.phy_cap_info) ||
1436 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET,
1437 sizeof(he_cap->he_mcs_nss_supp),
1438 &he_cap->he_mcs_nss_supp) ||
1439 nla_put(msg, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE,
1440 sizeof(he_cap->ppe_thres), he_cap->ppe_thres))
1447 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1448 struct ieee80211_supported_band *sband)
1450 struct nlattr *nl_rates, *nl_rate;
1451 struct ieee80211_rate *rate;
1455 if (sband->ht_cap.ht_supported &&
1456 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1457 sizeof(sband->ht_cap.mcs),
1458 &sband->ht_cap.mcs) ||
1459 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1460 sband->ht_cap.cap) ||
1461 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1462 sband->ht_cap.ampdu_factor) ||
1463 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1464 sband->ht_cap.ampdu_density)))
1468 if (sband->vht_cap.vht_supported &&
1469 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1470 sizeof(sband->vht_cap.vht_mcs),
1471 &sband->vht_cap.vht_mcs) ||
1472 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1473 sband->vht_cap.cap)))
1476 if (sband->n_iftype_data) {
1477 struct nlattr *nl_iftype_data =
1478 nla_nest_start(msg, NL80211_BAND_ATTR_IFTYPE_DATA);
1481 if (!nl_iftype_data)
1484 for (i = 0; i < sband->n_iftype_data; i++) {
1485 struct nlattr *iftdata;
1487 iftdata = nla_nest_start(msg, i + 1);
1491 err = nl80211_send_iftype_data(msg,
1492 &sband->iftype_data[i]);
1496 nla_nest_end(msg, iftdata);
1499 nla_nest_end(msg, nl_iftype_data);
1503 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1507 for (i = 0; i < sband->n_bitrates; i++) {
1508 nl_rate = nla_nest_start(msg, i);
1512 rate = &sband->bitrates[i];
1513 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1516 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1518 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1521 nla_nest_end(msg, nl_rate);
1524 nla_nest_end(msg, nl_rates);
1530 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1531 const struct ieee80211_txrx_stypes *mgmt_stypes)
1534 struct nlattr *nl_ftypes, *nl_ifs;
1535 enum nl80211_iftype ift;
1541 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1545 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1546 nl_ftypes = nla_nest_start(msg, ift);
1550 stypes = mgmt_stypes[ift].tx;
1553 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1554 (i << 4) | IEEE80211_FTYPE_MGMT))
1559 nla_nest_end(msg, nl_ftypes);
1562 nla_nest_end(msg, nl_ifs);
1564 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1568 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1569 nl_ftypes = nla_nest_start(msg, ift);
1573 stypes = mgmt_stypes[ift].rx;
1576 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1577 (i << 4) | IEEE80211_FTYPE_MGMT))
1582 nla_nest_end(msg, nl_ftypes);
1584 nla_nest_end(msg, nl_ifs);
1589 #define CMD(op, n) \
1591 if (rdev->ops->op) { \
1593 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1594 goto nla_put_failure; \
1598 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device *rdev,
1599 struct sk_buff *msg)
1604 * do *NOT* add anything into this function, new things need to be
1605 * advertised only to new versions of userspace that can deal with
1606 * the split (and they can't possibly care about new features...
1608 CMD(add_virtual_intf, NEW_INTERFACE);
1609 CMD(change_virtual_intf, SET_INTERFACE);
1610 CMD(add_key, NEW_KEY);
1611 CMD(start_ap, START_AP);
1612 CMD(add_station, NEW_STATION);
1613 CMD(add_mpath, NEW_MPATH);
1614 CMD(update_mesh_config, SET_MESH_CONFIG);
1615 CMD(change_bss, SET_BSS);
1616 CMD(auth, AUTHENTICATE);
1617 CMD(assoc, ASSOCIATE);
1618 CMD(deauth, DEAUTHENTICATE);
1619 CMD(disassoc, DISASSOCIATE);
1620 CMD(join_ibss, JOIN_IBSS);
1621 CMD(join_mesh, JOIN_MESH);
1622 CMD(set_pmksa, SET_PMKSA);
1623 CMD(del_pmksa, DEL_PMKSA);
1624 CMD(flush_pmksa, FLUSH_PMKSA);
1625 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1626 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1627 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1628 CMD(mgmt_tx, FRAME);
1629 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1630 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1632 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1633 goto nla_put_failure;
1635 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1636 rdev->ops->join_mesh) {
1638 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1639 goto nla_put_failure;
1641 CMD(set_wds_peer, SET_WDS_PEER);
1642 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1643 CMD(tdls_mgmt, TDLS_MGMT);
1644 CMD(tdls_oper, TDLS_OPER);
1646 if (rdev->wiphy.max_sched_scan_reqs)
1647 CMD(sched_scan_start, START_SCHED_SCAN);
1648 CMD(probe_client, PROBE_CLIENT);
1649 CMD(set_noack_map, SET_NOACK_MAP);
1650 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1652 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1653 goto nla_put_failure;
1655 CMD(start_p2p_device, START_P2P_DEVICE);
1656 CMD(set_mcast_rate, SET_MCAST_RATE);
1657 #ifdef CONFIG_NL80211_TESTMODE
1658 CMD(testmode_cmd, TESTMODE);
1661 if (rdev->ops->connect || rdev->ops->auth) {
1663 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1664 goto nla_put_failure;
1667 if (rdev->ops->disconnect || rdev->ops->deauth) {
1669 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1670 goto nla_put_failure;
1679 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities *cap,
1680 struct sk_buff *msg)
1684 if (!cap->ftm.supported)
1687 ftm = nla_nest_start(msg, NL80211_PMSR_TYPE_FTM);
1691 if (cap->ftm.asap && nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_ASAP))
1693 if (cap->ftm.non_asap &&
1694 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP))
1696 if (cap->ftm.request_lci &&
1697 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI))
1699 if (cap->ftm.request_civicloc &&
1700 nla_put_flag(msg, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC))
1702 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES,
1703 cap->ftm.preambles))
1705 if (nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS,
1706 cap->ftm.bandwidths))
1708 if (cap->ftm.max_bursts_exponent >= 0 &&
1709 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT,
1710 cap->ftm.max_bursts_exponent))
1712 if (cap->ftm.max_ftms_per_burst &&
1713 nla_put_u32(msg, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST,
1714 cap->ftm.max_ftms_per_burst))
1717 nla_nest_end(msg, ftm);
1721 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device *rdev,
1722 struct sk_buff *msg)
1724 const struct cfg80211_pmsr_capabilities *cap = rdev->wiphy.pmsr_capa;
1725 struct nlattr *pmsr, *caps;
1731 * we don't need to clean up anything here since the caller
1732 * will genlmsg_cancel() if we fail
1735 pmsr = nla_nest_start(msg, NL80211_ATTR_PEER_MEASUREMENTS);
1739 if (nla_put_u32(msg, NL80211_PMSR_ATTR_MAX_PEERS, cap->max_peers))
1742 if (cap->report_ap_tsf &&
1743 nla_put_flag(msg, NL80211_PMSR_ATTR_REPORT_AP_TSF))
1746 if (cap->randomize_mac_addr &&
1747 nla_put_flag(msg, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR))
1750 caps = nla_nest_start(msg, NL80211_PMSR_ATTR_TYPE_CAPA);
1754 if (nl80211_send_pmsr_ftm_capa(cap, msg))
1757 nla_nest_end(msg, caps);
1758 nla_nest_end(msg, pmsr);
1763 struct nl80211_dump_wiphy_state {
1766 long split_start, band_start, chan_start, capa_start;
1770 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
1771 enum nl80211_commands cmd,
1772 struct sk_buff *msg, u32 portid, u32 seq,
1773 int flags, struct nl80211_dump_wiphy_state *state)
1776 struct nlattr *nl_bands, *nl_band;
1777 struct nlattr *nl_freqs, *nl_freq;
1778 struct nlattr *nl_cmds;
1779 enum nl80211_band band;
1780 struct ieee80211_channel *chan;
1782 const struct ieee80211_txrx_stypes *mgmt_stypes =
1783 rdev->wiphy.mgmt_stypes;
1786 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
1790 if (WARN_ON(!state))
1793 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
1794 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1795 wiphy_name(&rdev->wiphy)) ||
1796 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1797 cfg80211_rdev_list_generation))
1798 goto nla_put_failure;
1800 if (cmd != NL80211_CMD_NEW_WIPHY)
1803 switch (state->split_start) {
1805 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1806 rdev->wiphy.retry_short) ||
1807 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1808 rdev->wiphy.retry_long) ||
1809 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1810 rdev->wiphy.frag_threshold) ||
1811 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1812 rdev->wiphy.rts_threshold) ||
1813 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1814 rdev->wiphy.coverage_class) ||
1815 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1816 rdev->wiphy.max_scan_ssids) ||
1817 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1818 rdev->wiphy.max_sched_scan_ssids) ||
1819 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1820 rdev->wiphy.max_scan_ie_len) ||
1821 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1822 rdev->wiphy.max_sched_scan_ie_len) ||
1823 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
1824 rdev->wiphy.max_match_sets) ||
1825 nla_put_u32(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS,
1826 rdev->wiphy.max_sched_scan_plans) ||
1827 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL,
1828 rdev->wiphy.max_sched_scan_plan_interval) ||
1829 nla_put_u32(msg, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS,
1830 rdev->wiphy.max_sched_scan_plan_iterations))
1831 goto nla_put_failure;
1833 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
1834 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
1835 goto nla_put_failure;
1836 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
1837 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1838 goto nla_put_failure;
1839 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
1840 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1841 goto nla_put_failure;
1842 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
1843 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1844 goto nla_put_failure;
1845 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
1846 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1847 goto nla_put_failure;
1848 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
1849 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
1850 goto nla_put_failure;
1851 state->split_start++;
1856 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1857 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1858 rdev->wiphy.cipher_suites))
1859 goto nla_put_failure;
1861 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1862 rdev->wiphy.max_num_pmkids))
1863 goto nla_put_failure;
1865 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
1866 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
1867 goto nla_put_failure;
1869 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1870 rdev->wiphy.available_antennas_tx) ||
1871 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1872 rdev->wiphy.available_antennas_rx))
1873 goto nla_put_failure;
1875 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
1876 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1877 rdev->wiphy.probe_resp_offload))
1878 goto nla_put_failure;
1880 if ((rdev->wiphy.available_antennas_tx ||
1881 rdev->wiphy.available_antennas_rx) &&
1882 rdev->ops->get_antenna) {
1883 u32 tx_ant = 0, rx_ant = 0;
1886 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
1888 if (nla_put_u32(msg,
1889 NL80211_ATTR_WIPHY_ANTENNA_TX,
1892 NL80211_ATTR_WIPHY_ANTENNA_RX,
1894 goto nla_put_failure;
1898 state->split_start++;
1903 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1904 rdev->wiphy.interface_modes))
1905 goto nla_put_failure;
1906 state->split_start++;
1911 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1913 goto nla_put_failure;
1915 for (band = state->band_start;
1916 band < NUM_NL80211_BANDS; band++) {
1917 struct ieee80211_supported_band *sband;
1919 sband = rdev->wiphy.bands[band];
1924 nl_band = nla_nest_start(msg, band);
1926 goto nla_put_failure;
1928 switch (state->chan_start) {
1930 if (nl80211_send_band_rateinfo(msg, sband))
1931 goto nla_put_failure;
1932 state->chan_start++;
1937 /* add frequencies */
1938 nl_freqs = nla_nest_start(
1939 msg, NL80211_BAND_ATTR_FREQS);
1941 goto nla_put_failure;
1943 for (i = state->chan_start - 1;
1944 i < sband->n_channels;
1946 nl_freq = nla_nest_start(msg, i);
1948 goto nla_put_failure;
1950 chan = &sband->channels[i];
1952 if (nl80211_msg_put_channel(
1953 msg, &rdev->wiphy, chan,
1955 goto nla_put_failure;
1957 nla_nest_end(msg, nl_freq);
1961 if (i < sband->n_channels)
1962 state->chan_start = i + 2;
1964 state->chan_start = 0;
1965 nla_nest_end(msg, nl_freqs);
1968 nla_nest_end(msg, nl_band);
1971 /* start again here */
1972 if (state->chan_start)
1977 nla_nest_end(msg, nl_bands);
1979 if (band < NUM_NL80211_BANDS)
1980 state->band_start = band + 1;
1982 state->band_start = 0;
1984 /* if bands & channels are done, continue outside */
1985 if (state->band_start == 0 && state->chan_start == 0)
1986 state->split_start++;
1991 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1993 goto nla_put_failure;
1995 i = nl80211_add_commands_unsplit(rdev, msg);
1997 goto nla_put_failure;
1999 CMD(crit_proto_start, CRIT_PROTOCOL_START);
2000 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
2001 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
2002 CMD(channel_switch, CHANNEL_SWITCH);
2003 CMD(set_qos_map, SET_QOS_MAP);
2004 if (rdev->wiphy.features &
2005 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
2006 CMD(add_tx_ts, ADD_TX_TS);
2007 CMD(set_multicast_to_unicast, SET_MULTICAST_TO_UNICAST);
2008 CMD(update_connect_params, UPDATE_CONNECT_PARAMS);
2012 nla_nest_end(msg, nl_cmds);
2013 state->split_start++;
2018 if (rdev->ops->remain_on_channel &&
2019 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
2021 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
2022 rdev->wiphy.max_remain_on_channel_duration))
2023 goto nla_put_failure;
2025 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
2026 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
2027 goto nla_put_failure;
2029 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
2030 goto nla_put_failure;
2031 state->split_start++;
2037 if (nl80211_send_wowlan(msg, rdev, state->split))
2038 goto nla_put_failure;
2039 state->split_start++;
2043 state->split_start++;
2047 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
2048 rdev->wiphy.software_iftypes))
2049 goto nla_put_failure;
2051 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
2053 goto nla_put_failure;
2055 state->split_start++;
2060 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
2061 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
2062 rdev->wiphy.ap_sme_capa))
2063 goto nla_put_failure;
2065 features = rdev->wiphy.features;
2067 * We can only add the per-channel limit information if the
2068 * dump is split, otherwise it makes it too big. Therefore
2069 * only advertise it in that case.
2072 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
2073 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
2074 goto nla_put_failure;
2076 if (rdev->wiphy.ht_capa_mod_mask &&
2077 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
2078 sizeof(*rdev->wiphy.ht_capa_mod_mask),
2079 rdev->wiphy.ht_capa_mod_mask))
2080 goto nla_put_failure;
2082 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
2083 rdev->wiphy.max_acl_mac_addrs &&
2084 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
2085 rdev->wiphy.max_acl_mac_addrs))
2086 goto nla_put_failure;
2089 * Any information below this point is only available to
2090 * applications that can deal with it being split. This
2091 * helps ensure that newly added capabilities don't break
2092 * older tools by overrunning their buffers.
2094 * We still increment split_start so that in the split
2095 * case we'll continue with more data in the next round,
2096 * but break unconditionally so unsplit data stops here.
2098 state->split_start++;
2101 if (rdev->wiphy.extended_capabilities &&
2102 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
2103 rdev->wiphy.extended_capabilities_len,
2104 rdev->wiphy.extended_capabilities) ||
2105 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2106 rdev->wiphy.extended_capabilities_len,
2107 rdev->wiphy.extended_capabilities_mask)))
2108 goto nla_put_failure;
2110 if (rdev->wiphy.vht_capa_mod_mask &&
2111 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
2112 sizeof(*rdev->wiphy.vht_capa_mod_mask),
2113 rdev->wiphy.vht_capa_mod_mask))
2114 goto nla_put_failure;
2116 state->split_start++;
2119 if (nl80211_send_coalesce(msg, rdev))
2120 goto nla_put_failure;
2122 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
2123 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
2124 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
2125 goto nla_put_failure;
2127 if (rdev->wiphy.max_ap_assoc_sta &&
2128 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
2129 rdev->wiphy.max_ap_assoc_sta))
2130 goto nla_put_failure;
2132 state->split_start++;
2135 if (rdev->wiphy.n_vendor_commands) {
2136 const struct nl80211_vendor_cmd_info *info;
2137 struct nlattr *nested;
2139 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
2141 goto nla_put_failure;
2143 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
2144 info = &rdev->wiphy.vendor_commands[i].info;
2145 if (nla_put(msg, i + 1, sizeof(*info), info))
2146 goto nla_put_failure;
2148 nla_nest_end(msg, nested);
2151 if (rdev->wiphy.n_vendor_events) {
2152 const struct nl80211_vendor_cmd_info *info;
2153 struct nlattr *nested;
2155 nested = nla_nest_start(msg,
2156 NL80211_ATTR_VENDOR_EVENTS);
2158 goto nla_put_failure;
2160 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
2161 info = &rdev->wiphy.vendor_events[i];
2162 if (nla_put(msg, i + 1, sizeof(*info), info))
2163 goto nla_put_failure;
2165 nla_nest_end(msg, nested);
2167 state->split_start++;
2170 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
2171 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
2172 rdev->wiphy.max_num_csa_counters))
2173 goto nla_put_failure;
2175 if (rdev->wiphy.regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
2176 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
2177 goto nla_put_failure;
2179 if (rdev->wiphy.max_sched_scan_reqs &&
2180 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_MAX_REQS,
2181 rdev->wiphy.max_sched_scan_reqs))
2182 goto nla_put_failure;
2184 if (nla_put(msg, NL80211_ATTR_EXT_FEATURES,
2185 sizeof(rdev->wiphy.ext_features),
2186 rdev->wiphy.ext_features))
2187 goto nla_put_failure;
2189 if (rdev->wiphy.bss_select_support) {
2190 struct nlattr *nested;
2191 u32 bss_select_support = rdev->wiphy.bss_select_support;
2193 nested = nla_nest_start(msg, NL80211_ATTR_BSS_SELECT);
2195 goto nla_put_failure;
2198 while (bss_select_support) {
2199 if ((bss_select_support & 1) &&
2200 nla_put_flag(msg, i))
2201 goto nla_put_failure;
2203 bss_select_support >>= 1;
2205 nla_nest_end(msg, nested);
2208 state->split_start++;
2211 if (rdev->wiphy.num_iftype_ext_capab &&
2212 rdev->wiphy.iftype_ext_capab) {
2213 struct nlattr *nested_ext_capab, *nested;
2215 nested = nla_nest_start(msg,
2216 NL80211_ATTR_IFTYPE_EXT_CAPA);
2218 goto nla_put_failure;
2220 for (i = state->capa_start;
2221 i < rdev->wiphy.num_iftype_ext_capab; i++) {
2222 const struct wiphy_iftype_ext_capab *capab;
2224 capab = &rdev->wiphy.iftype_ext_capab[i];
2226 nested_ext_capab = nla_nest_start(msg, i);
2227 if (!nested_ext_capab ||
2228 nla_put_u32(msg, NL80211_ATTR_IFTYPE,
2230 nla_put(msg, NL80211_ATTR_EXT_CAPA,
2231 capab->extended_capabilities_len,
2232 capab->extended_capabilities) ||
2233 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
2234 capab->extended_capabilities_len,
2235 capab->extended_capabilities_mask))
2236 goto nla_put_failure;
2238 nla_nest_end(msg, nested_ext_capab);
2242 nla_nest_end(msg, nested);
2243 if (i < rdev->wiphy.num_iftype_ext_capab) {
2244 state->capa_start = i + 1;
2249 if (nla_put_u32(msg, NL80211_ATTR_BANDS,
2250 rdev->wiphy.nan_supported_bands))
2251 goto nla_put_failure;
2253 if (wiphy_ext_feature_isset(&rdev->wiphy,
2254 NL80211_EXT_FEATURE_TXQS)) {
2255 struct cfg80211_txq_stats txqstats = {};
2258 res = rdev_get_txq_stats(rdev, NULL, &txqstats);
2260 !nl80211_put_txq_stats(msg, &txqstats,
2261 NL80211_ATTR_TXQ_STATS))
2262 goto nla_put_failure;
2264 if (nla_put_u32(msg, NL80211_ATTR_TXQ_LIMIT,
2265 rdev->wiphy.txq_limit))
2266 goto nla_put_failure;
2267 if (nla_put_u32(msg, NL80211_ATTR_TXQ_MEMORY_LIMIT,
2268 rdev->wiphy.txq_memory_limit))
2269 goto nla_put_failure;
2270 if (nla_put_u32(msg, NL80211_ATTR_TXQ_QUANTUM,
2271 rdev->wiphy.txq_quantum))
2272 goto nla_put_failure;
2275 state->split_start++;
2278 if (nl80211_send_pmsr_capa(rdev, msg))
2279 goto nla_put_failure;
2282 state->split_start = 0;
2286 genlmsg_end(msg, hdr);
2290 genlmsg_cancel(msg, hdr);
2294 static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
2295 struct netlink_callback *cb,
2296 struct nl80211_dump_wiphy_state *state)
2298 struct nlattr **tb = genl_family_attrbuf(&nl80211_fam);
2299 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, tb,
2300 nl80211_fam.maxattr, nl80211_policy, NULL);
2301 /* ignore parse errors for backward compatibility */
2305 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
2306 if (tb[NL80211_ATTR_WIPHY])
2307 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
2308 if (tb[NL80211_ATTR_WDEV])
2309 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
2310 if (tb[NL80211_ATTR_IFINDEX]) {
2311 struct net_device *netdev;
2312 struct cfg80211_registered_device *rdev;
2313 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
2315 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
2318 if (netdev->ieee80211_ptr) {
2319 rdev = wiphy_to_rdev(
2320 netdev->ieee80211_ptr->wiphy);
2321 state->filter_wiphy = rdev->wiphy_idx;
2328 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
2331 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
2332 struct cfg80211_registered_device *rdev;
2336 state = kzalloc(sizeof(*state), GFP_KERNEL);
2341 state->filter_wiphy = -1;
2342 ret = nl80211_dump_wiphy_parse(skb, cb, state);
2348 cb->args[0] = (long)state;
2351 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2352 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2354 if (++idx <= state->start)
2356 if (state->filter_wiphy != -1 &&
2357 state->filter_wiphy != rdev->wiphy_idx)
2359 /* attempt to fit multiple wiphy data chunks into the skb */
2361 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
2363 NETLINK_CB(cb->skb).portid,
2365 NLM_F_MULTI, state);
2368 * If sending the wiphy data didn't fit (ENOBUFS
2369 * or EMSGSIZE returned), this SKB is still
2370 * empty (so it's not too big because another
2371 * wiphy dataset is already in the skb) and
2372 * we've not tried to adjust the dump allocation
2373 * yet ... then adjust the alloc size to be
2374 * bigger, and return 1 but with the empty skb.
2375 * This results in an empty message being RX'ed
2376 * in userspace, but that is ignored.
2378 * We can then retry with the larger buffer.
2380 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
2381 !skb->len && !state->split &&
2382 cb->min_dump_alloc < 4096) {
2383 cb->min_dump_alloc = 4096;
2384 state->split_start = 0;
2391 } while (state->split_start > 0);
2401 static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
2403 kfree((void *)cb->args[0]);
2407 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
2409 struct sk_buff *msg;
2410 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2411 struct nl80211_dump_wiphy_state state = {};
2413 msg = nlmsg_new(4096, GFP_KERNEL);
2417 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
2418 info->snd_portid, info->snd_seq, 0,
2424 return genlmsg_reply(msg, info);
2427 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
2428 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
2429 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
2430 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
2431 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
2432 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
2435 static int parse_txq_params(struct nlattr *tb[],
2436 struct ieee80211_txq_params *txq_params)
2440 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
2441 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
2442 !tb[NL80211_TXQ_ATTR_AIFS])
2445 ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
2446 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
2447 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
2448 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
2449 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
2451 if (ac >= NL80211_NUM_ACS)
2453 txq_params->ac = array_index_nospec(ac, NL80211_NUM_ACS);
2457 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
2460 * You can only set the channel explicitly for WDS interfaces,
2461 * all others have their channel managed via their respective
2462 * "establish a connection" command (connect, join, ...)
2464 * For AP/GO and mesh mode, the channel can be set with the
2465 * channel userspace API, but is only stored and passed to the
2466 * low-level driver when the AP starts or the mesh is joined.
2467 * This is for backward compatibility, userspace can also give
2468 * the channel in the start-ap or join-mesh commands instead.
2470 * Monitors are special as they are normally slaved to
2471 * whatever else is going on, so they have their own special
2472 * operation to set the monitor channel if possible.
2475 wdev->iftype == NL80211_IFTYPE_AP ||
2476 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
2477 wdev->iftype == NL80211_IFTYPE_MONITOR ||
2478 wdev->iftype == NL80211_IFTYPE_P2P_GO;
2481 int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
2482 struct genl_info *info,
2483 struct cfg80211_chan_def *chandef)
2485 struct netlink_ext_ack *extack = info->extack;
2486 struct nlattr **attrs = info->attrs;
2489 if (!attrs[NL80211_ATTR_WIPHY_FREQ])
2492 control_freq = nla_get_u32(attrs[NL80211_ATTR_WIPHY_FREQ]);
2494 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
2495 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
2496 chandef->center_freq1 = control_freq;
2497 chandef->center_freq2 = 0;
2499 /* Primary channel not allowed */
2500 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED) {
2501 NL_SET_ERR_MSG_ATTR(extack, attrs[NL80211_ATTR_WIPHY_FREQ],
2502 "Channel is disabled");
2506 if (attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
2507 enum nl80211_channel_type chantype;
2509 chantype = nla_get_u32(attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
2512 case NL80211_CHAN_NO_HT:
2513 case NL80211_CHAN_HT20:
2514 case NL80211_CHAN_HT40PLUS:
2515 case NL80211_CHAN_HT40MINUS:
2516 cfg80211_chandef_create(chandef, chandef->chan,
2518 /* user input for center_freq is incorrect */
2519 if (attrs[NL80211_ATTR_CENTER_FREQ1] &&
2520 chandef->center_freq1 != nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1])) {
2521 NL_SET_ERR_MSG_ATTR(extack,
2522 attrs[NL80211_ATTR_CENTER_FREQ1],
2523 "bad center frequency 1");
2526 /* center_freq2 must be zero */
2527 if (attrs[NL80211_ATTR_CENTER_FREQ2] &&
2528 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2])) {
2529 NL_SET_ERR_MSG_ATTR(extack,
2530 attrs[NL80211_ATTR_CENTER_FREQ2],
2531 "center frequency 2 can't be used");
2536 NL_SET_ERR_MSG_ATTR(extack,
2537 attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE],
2538 "invalid channel type");
2541 } else if (attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
2543 nla_get_u32(attrs[NL80211_ATTR_CHANNEL_WIDTH]);
2544 if (attrs[NL80211_ATTR_CENTER_FREQ1])
2545 chandef->center_freq1 =
2546 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ1]);
2547 if (attrs[NL80211_ATTR_CENTER_FREQ2])
2548 chandef->center_freq2 =
2549 nla_get_u32(attrs[NL80211_ATTR_CENTER_FREQ2]);
2552 if (!cfg80211_chandef_valid(chandef)) {
2553 NL_SET_ERR_MSG(extack, "invalid channel definition");
2557 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
2558 IEEE80211_CHAN_DISABLED)) {
2559 NL_SET_ERR_MSG(extack, "(extension) channel is disabled");
2563 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
2564 chandef->width == NL80211_CHAN_WIDTH_10) &&
2565 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ)) {
2566 NL_SET_ERR_MSG(extack, "5/10 MHz not supported");
2573 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
2574 struct net_device *dev,
2575 struct genl_info *info)
2577 struct cfg80211_chan_def chandef;
2579 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
2580 struct wireless_dev *wdev = NULL;
2583 wdev = dev->ieee80211_ptr;
2584 if (!nl80211_can_set_dev_channel(wdev))
2587 iftype = wdev->iftype;
2589 result = nl80211_parse_chandef(rdev, info, &chandef);
2594 case NL80211_IFTYPE_AP:
2595 case NL80211_IFTYPE_P2P_GO:
2596 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
2601 if (wdev->beacon_interval) {
2602 if (!dev || !rdev->ops->set_ap_chanwidth ||
2603 !(rdev->wiphy.features &
2604 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
2609 /* Only allow dynamic channel width changes */
2610 if (chandef.chan != wdev->preset_chandef.chan) {
2614 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2618 wdev->preset_chandef = chandef;
2621 case NL80211_IFTYPE_MESH_POINT:
2622 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
2624 case NL80211_IFTYPE_MONITOR:
2625 result = cfg80211_set_monitor_channel(rdev, &chandef);
2634 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2636 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2637 struct net_device *netdev = info->user_ptr[1];
2639 return __nl80211_set_channel(rdev, netdev, info);
2642 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2644 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2645 struct net_device *dev = info->user_ptr[1];
2646 struct wireless_dev *wdev = dev->ieee80211_ptr;
2649 if (!info->attrs[NL80211_ATTR_MAC])
2652 if (netif_running(dev))
2655 if (!rdev->ops->set_wds_peer)
2658 if (wdev->iftype != NL80211_IFTYPE_WDS)
2661 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
2662 return rdev_set_wds_peer(rdev, dev, bssid);
2665 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2667 struct cfg80211_registered_device *rdev;
2668 struct net_device *netdev = NULL;
2669 struct wireless_dev *wdev;
2670 int result = 0, rem_txq_params = 0;
2671 struct nlattr *nl_txq_params;
2673 u8 retry_short = 0, retry_long = 0;
2674 u32 frag_threshold = 0, rts_threshold = 0;
2675 u8 coverage_class = 0;
2676 u32 txq_limit = 0, txq_memory_limit = 0, txq_quantum = 0;
2681 * Try to find the wiphy and netdev. Normally this
2682 * function shouldn't need the netdev, but this is
2683 * done for backward compatibility -- previously
2684 * setting the channel was done per wiphy, but now
2685 * it is per netdev. Previous userland like hostapd
2686 * also passed a netdev to set_wiphy, so that it is
2687 * possible to let that go to the right netdev!
2690 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2691 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2693 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
2694 if (netdev && netdev->ieee80211_ptr)
2695 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
2701 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2704 return PTR_ERR(rdev);
2709 wdev = netdev->ieee80211_ptr;
2712 * end workaround code, by now the rdev is available
2713 * and locked, and wdev may or may not be NULL.
2716 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
2717 result = cfg80211_dev_rename(
2718 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
2723 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2724 struct ieee80211_txq_params txq_params;
2725 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2727 if (!rdev->ops->set_txq_params)
2733 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2734 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2737 if (!netif_running(netdev))
2740 nla_for_each_nested(nl_txq_params,
2741 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2743 result = nla_parse_nested(tb, NL80211_TXQ_ATTR_MAX,
2749 result = parse_txq_params(tb, &txq_params);
2753 result = rdev_set_txq_params(rdev, netdev,
2760 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2761 result = __nl80211_set_channel(
2763 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2769 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
2770 struct wireless_dev *txp_wdev = wdev;
2771 enum nl80211_tx_power_setting type;
2774 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2777 if (!rdev->ops->set_tx_power)
2780 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2781 type = nla_get_u32(info->attrs[idx]);
2783 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
2784 (type != NL80211_TX_POWER_AUTOMATIC))
2787 if (type != NL80211_TX_POWER_AUTOMATIC) {
2788 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2789 mbm = nla_get_u32(info->attrs[idx]);
2792 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
2797 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2798 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2801 if ((!rdev->wiphy.available_antennas_tx &&
2802 !rdev->wiphy.available_antennas_rx) ||
2803 !rdev->ops->set_antenna)
2806 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2807 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2809 /* reject antenna configurations which don't match the
2810 * available antenna masks, except for the "all" mask */
2811 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
2812 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2815 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2816 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
2818 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
2825 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2826 retry_short = nla_get_u8(
2827 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
2829 changed |= WIPHY_PARAM_RETRY_SHORT;
2832 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2833 retry_long = nla_get_u8(
2834 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
2836 changed |= WIPHY_PARAM_RETRY_LONG;
2839 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2840 frag_threshold = nla_get_u32(
2841 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
2842 if (frag_threshold < 256)
2845 if (frag_threshold != (u32) -1) {
2847 * Fragments (apart from the last one) are required to
2848 * have even length. Make the fragmentation code
2849 * simpler by stripping LSB should someone try to use
2850 * odd threshold value.
2852 frag_threshold &= ~0x1;
2854 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2857 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2858 rts_threshold = nla_get_u32(
2859 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2860 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2863 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
2864 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2867 coverage_class = nla_get_u8(
2868 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2869 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2872 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2873 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2876 changed |= WIPHY_PARAM_DYN_ACK;
2879 if (info->attrs[NL80211_ATTR_TXQ_LIMIT]) {
2880 if (!wiphy_ext_feature_isset(&rdev->wiphy,
2881 NL80211_EXT_FEATURE_TXQS))
2883 txq_limit = nla_get_u32(
2884 info->attrs[NL80211_ATTR_TXQ_LIMIT]);
2885 changed |= WIPHY_PARAM_TXQ_LIMIT;
2888 if (info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]) {
2889 if (!wiphy_ext_feature_isset(&rdev->wiphy,
2890 NL80211_EXT_FEATURE_TXQS))
2892 txq_memory_limit = nla_get_u32(
2893 info->attrs[NL80211_ATTR_TXQ_MEMORY_LIMIT]);
2894 changed |= WIPHY_PARAM_TXQ_MEMORY_LIMIT;
2897 if (info->attrs[NL80211_ATTR_TXQ_QUANTUM]) {
2898 if (!wiphy_ext_feature_isset(&rdev->wiphy,
2899 NL80211_EXT_FEATURE_TXQS))
2901 txq_quantum = nla_get_u32(
2902 info->attrs[NL80211_ATTR_TXQ_QUANTUM]);
2903 changed |= WIPHY_PARAM_TXQ_QUANTUM;
2907 u8 old_retry_short, old_retry_long;
2908 u32 old_frag_threshold, old_rts_threshold;
2909 u8 old_coverage_class;
2910 u32 old_txq_limit, old_txq_memory_limit, old_txq_quantum;
2912 if (!rdev->ops->set_wiphy_params)
2915 old_retry_short = rdev->wiphy.retry_short;
2916 old_retry_long = rdev->wiphy.retry_long;
2917 old_frag_threshold = rdev->wiphy.frag_threshold;
2918 old_rts_threshold = rdev->wiphy.rts_threshold;
2919 old_coverage_class = rdev->wiphy.coverage_class;
2920 old_txq_limit = rdev->wiphy.txq_limit;
2921 old_txq_memory_limit = rdev->wiphy.txq_memory_limit;
2922 old_txq_quantum = rdev->wiphy.txq_quantum;
2924 if (changed & WIPHY_PARAM_RETRY_SHORT)
2925 rdev->wiphy.retry_short = retry_short;
2926 if (changed & WIPHY_PARAM_RETRY_LONG)
2927 rdev->wiphy.retry_long = retry_long;
2928 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2929 rdev->wiphy.frag_threshold = frag_threshold;
2930 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2931 rdev->wiphy.rts_threshold = rts_threshold;
2932 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2933 rdev->wiphy.coverage_class = coverage_class;
2934 if (changed & WIPHY_PARAM_TXQ_LIMIT)
2935 rdev->wiphy.txq_limit = txq_limit;
2936 if (changed & WIPHY_PARAM_TXQ_MEMORY_LIMIT)
2937 rdev->wiphy.txq_memory_limit = txq_memory_limit;
2938 if (changed & WIPHY_PARAM_TXQ_QUANTUM)
2939 rdev->wiphy.txq_quantum = txq_quantum;
2941 result = rdev_set_wiphy_params(rdev, changed);
2943 rdev->wiphy.retry_short = old_retry_short;
2944 rdev->wiphy.retry_long = old_retry_long;
2945 rdev->wiphy.frag_threshold = old_frag_threshold;
2946 rdev->wiphy.rts_threshold = old_rts_threshold;
2947 rdev->wiphy.coverage_class = old_coverage_class;
2948 rdev->wiphy.txq_limit = old_txq_limit;
2949 rdev->wiphy.txq_memory_limit = old_txq_memory_limit;
2950 rdev->wiphy.txq_quantum = old_txq_quantum;
2957 static int nl80211_send_chandef(struct sk_buff *msg,
2958 const struct cfg80211_chan_def *chandef)
2960 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
2963 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2964 chandef->chan->center_freq))
2966 switch (chandef->width) {
2967 case NL80211_CHAN_WIDTH_20_NOHT:
2968 case NL80211_CHAN_WIDTH_20:
2969 case NL80211_CHAN_WIDTH_40:
2970 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2971 cfg80211_get_chandef_type(chandef)))
2977 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2979 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2981 if (chandef->center_freq2 &&
2982 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
2987 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
2988 struct cfg80211_registered_device *rdev,
2989 struct wireless_dev *wdev,
2990 enum nl80211_commands cmd)
2992 struct net_device *dev = wdev->netdev;
2995 WARN_ON(cmd != NL80211_CMD_NEW_INTERFACE &&
2996 cmd != NL80211_CMD_DEL_INTERFACE &&
2997 cmd != NL80211_CMD_SET_INTERFACE);
2999 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
3004 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3005 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
3006 goto nla_put_failure;
3008 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
3009 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
3010 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
3011 NL80211_ATTR_PAD) ||
3012 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
3013 nla_put_u32(msg, NL80211_ATTR_GENERATION,
3014 rdev->devlist_generation ^
3015 (cfg80211_rdev_list_generation << 2)) ||
3016 nla_put_u8(msg, NL80211_ATTR_4ADDR, wdev->use_4addr))
3017 goto nla_put_failure;
3019 if (rdev->ops->get_channel) {
3021 struct cfg80211_chan_def chandef;
3023 ret = rdev_get_channel(rdev, wdev, &chandef);
3025 if (nl80211_send_chandef(msg, &chandef))
3026 goto nla_put_failure;
3030 if (rdev->ops->get_tx_power) {
3033 ret = rdev_get_tx_power(rdev, wdev, &dbm);
3035 nla_put_u32(msg, NL80211_ATTR_WIPHY_TX_POWER_LEVEL,
3037 goto nla_put_failure;
3041 switch (wdev->iftype) {
3042 case NL80211_IFTYPE_AP:
3043 if (wdev->ssid_len &&
3044 nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
3045 goto nla_put_failure_locked;
3047 case NL80211_IFTYPE_STATION:
3048 case NL80211_IFTYPE_P2P_CLIENT:
3049 case NL80211_IFTYPE_ADHOC: {
3051 if (!wdev->current_bss)
3054 ssid_ie = ieee80211_bss_get_ie(&wdev->current_bss->pub,
3057 nla_put(msg, NL80211_ATTR_SSID, ssid_ie[1], ssid_ie + 2))
3058 goto nla_put_failure_rcu_locked;
3068 if (rdev->ops->get_txq_stats) {
3069 struct cfg80211_txq_stats txqstats = {};
3070 int ret = rdev_get_txq_stats(rdev, wdev, &txqstats);
3073 !nl80211_put_txq_stats(msg, &txqstats,
3074 NL80211_ATTR_TXQ_STATS))
3075 goto nla_put_failure;
3078 genlmsg_end(msg, hdr);
3081 nla_put_failure_rcu_locked:
3083 nla_put_failure_locked:
3086 genlmsg_cancel(msg, hdr);
3090 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
3094 int wp_start = cb->args[0];
3095 int if_start = cb->args[1];
3096 int filter_wiphy = -1;
3097 struct cfg80211_registered_device *rdev;
3098 struct wireless_dev *wdev;
3103 struct nl80211_dump_wiphy_state state = {
3107 ret = nl80211_dump_wiphy_parse(skb, cb, &state);
3111 filter_wiphy = state.filter_wiphy;
3114 * if filtering, set cb->args[2] to +1 since 0 is the default
3115 * value needed to determine that parsing is necessary.
3117 if (filter_wiphy >= 0)
3118 cb->args[2] = filter_wiphy + 1;
3121 } else if (cb->args[2] > 0) {
3122 filter_wiphy = cb->args[2] - 1;
3125 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
3126 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
3128 if (wp_idx < wp_start) {
3133 if (filter_wiphy >= 0 && filter_wiphy != rdev->wiphy_idx)
3138 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
3139 if (if_idx < if_start) {
3143 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
3144 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3146 NL80211_CMD_NEW_INTERFACE) < 0) {
3155 cb->args[0] = wp_idx;
3156 cb->args[1] = if_idx;
3165 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
3167 struct sk_buff *msg;
3168 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3169 struct wireless_dev *wdev = info->user_ptr[1];
3171 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3175 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3176 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3181 return genlmsg_reply(msg, info);
3184 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
3185 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
3186 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
3187 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
3188 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
3189 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
3190 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
3193 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
3195 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
3203 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX, nla,
3204 mntr_flags_policy, NULL))
3207 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
3209 *mntrflags |= (1<<flag);
3211 *mntrflags |= MONITOR_FLAG_CHANGED;
3216 static int nl80211_parse_mon_options(struct cfg80211_registered_device *rdev,
3217 enum nl80211_iftype type,
3218 struct genl_info *info,
3219 struct vif_params *params)
3221 bool change = false;
3224 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
3225 if (type != NL80211_IFTYPE_MONITOR)
3228 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
3236 if (params->flags & MONITOR_FLAG_ACTIVE &&
3237 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
3240 if (info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]) {
3241 const u8 *mumimo_groups;
3242 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3244 if (type != NL80211_IFTYPE_MONITOR)
3247 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3251 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_GROUP_DATA]);
3253 /* bits 0 and 63 are reserved and must be zero */
3254 if ((mumimo_groups[0] & BIT(0)) ||
3255 (mumimo_groups[VHT_MUMIMO_GROUPS_DATA_LEN - 1] & BIT(7)))
3258 params->vht_mumimo_groups = mumimo_groups;
3262 if (info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]) {
3263 u32 cap_flag = NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER;
3265 if (type != NL80211_IFTYPE_MONITOR)
3268 if (!wiphy_ext_feature_isset(&rdev->wiphy, cap_flag))
3271 params->vht_mumimo_follow_addr =
3272 nla_data(info->attrs[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR]);
3276 return change ? 1 : 0;
3279 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
3280 struct net_device *netdev, u8 use_4addr,
3281 enum nl80211_iftype iftype)
3284 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
3290 case NL80211_IFTYPE_AP_VLAN:
3291 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
3294 case NL80211_IFTYPE_STATION:
3295 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
3305 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
3307 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3308 struct vif_params params;
3310 enum nl80211_iftype otype, ntype;
3311 struct net_device *dev = info->user_ptr[1];
3312 bool change = false;
3314 memset(¶ms, 0, sizeof(params));
3316 otype = ntype = dev->ieee80211_ptr->iftype;
3318 if (info->attrs[NL80211_ATTR_IFTYPE]) {
3319 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3324 if (info->attrs[NL80211_ATTR_MESH_ID]) {
3325 struct wireless_dev *wdev = dev->ieee80211_ptr;
3327 if (ntype != NL80211_IFTYPE_MESH_POINT)
3329 if (netif_running(dev))
3333 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3334 IEEE80211_MAX_MESH_ID_LEN);
3335 wdev->mesh_id_up_len =
3336 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3337 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3338 wdev->mesh_id_up_len);
3342 if (info->attrs[NL80211_ATTR_4ADDR]) {
3343 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3345 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
3349 params.use_4addr = -1;
3352 err = nl80211_parse_mon_options(rdev, ntype, info, ¶ms);
3359 err = cfg80211_change_iface(rdev, dev, ntype, ¶ms);
3363 if (!err && params.use_4addr != -1)
3364 dev->ieee80211_ptr->use_4addr = params.use_4addr;
3366 if (change && !err) {
3367 struct wireless_dev *wdev = dev->ieee80211_ptr;
3369 nl80211_notify_iface(rdev, wdev, NL80211_CMD_SET_INTERFACE);
3375 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
3377 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3378 struct vif_params params;
3379 struct wireless_dev *wdev;
3380 struct sk_buff *msg;
3382 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
3384 /* to avoid failing a new interface creation due to pending removal */
3385 cfg80211_destroy_ifaces(rdev);
3387 memset(¶ms, 0, sizeof(params));
3389 if (!info->attrs[NL80211_ATTR_IFNAME])
3392 if (info->attrs[NL80211_ATTR_IFTYPE])
3393 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
3395 if (!rdev->ops->add_virtual_intf ||
3396 !(rdev->wiphy.interface_modes & (1 << type)))
3399 if ((type == NL80211_IFTYPE_P2P_DEVICE || type == NL80211_IFTYPE_NAN ||
3400 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
3401 info->attrs[NL80211_ATTR_MAC]) {
3402 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
3404 if (!is_valid_ether_addr(params.macaddr))
3405 return -EADDRNOTAVAIL;
3408 if (info->attrs[NL80211_ATTR_4ADDR]) {
3409 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
3410 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
3415 err = nl80211_parse_mon_options(rdev, type, info, ¶ms);
3419 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3423 wdev = rdev_add_virtual_intf(rdev,
3424 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
3425 NET_NAME_USER, type, ¶ms);
3426 if (WARN_ON(!wdev)) {
3429 } else if (IS_ERR(wdev)) {
3431 return PTR_ERR(wdev);
3434 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
3435 wdev->owner_nlportid = info->snd_portid;
3438 case NL80211_IFTYPE_MESH_POINT:
3439 if (!info->attrs[NL80211_ATTR_MESH_ID])
3442 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
3443 IEEE80211_MAX_MESH_ID_LEN);
3444 wdev->mesh_id_up_len =
3445 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
3446 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
3447 wdev->mesh_id_up_len);
3450 case NL80211_IFTYPE_NAN:
3451 case NL80211_IFTYPE_P2P_DEVICE:
3453 * P2P Device and NAN do not have a netdev, so don't go
3454 * through the netdev notifier and must be added here
3456 cfg80211_init_wdev(rdev, wdev);
3462 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
3463 rdev, wdev, NL80211_CMD_NEW_INTERFACE) < 0) {
3468 return genlmsg_reply(msg, info);
3471 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
3473 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3474 struct wireless_dev *wdev = info->user_ptr[1];
3476 if (!rdev->ops->del_virtual_intf)
3480 * If we remove a wireless device without a netdev then clear
3481 * user_ptr[1] so that nl80211_post_doit won't dereference it
3482 * to check if it needs to do dev_put(). Otherwise it crashes
3483 * since the wdev has been freed, unlike with a netdev where
3484 * we need the dev_put() for the netdev to really be freed.
3487 info->user_ptr[1] = NULL;
3489 return rdev_del_virtual_intf(rdev, wdev);
3492 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
3494 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3495 struct net_device *dev = info->user_ptr[1];
3498 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
3501 if (!rdev->ops->set_noack_map)
3504 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
3506 return rdev_set_noack_map(rdev, dev, noack_map);
3509 struct get_key_cookie {
3510 struct sk_buff *msg;
3515 static void get_key_callback(void *c, struct key_params *params)
3518 struct get_key_cookie *cookie = c;
3521 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
3522 params->key_len, params->key)) ||
3524 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
3525 params->seq_len, params->seq)) ||
3527 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
3529 goto nla_put_failure;
3531 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
3533 goto nla_put_failure;
3536 nla_put(cookie->msg, NL80211_KEY_DATA,
3537 params->key_len, params->key)) ||
3539 nla_put(cookie->msg, NL80211_KEY_SEQ,
3540 params->seq_len, params->seq)) ||
3542 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
3544 goto nla_put_failure;
3546 if (nla_put_u8(cookie->msg, NL80211_KEY_IDX, cookie->idx))
3547 goto nla_put_failure;
3549 nla_nest_end(cookie->msg, key);
3556 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
3558 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3560 struct net_device *dev = info->user_ptr[1];
3562 const u8 *mac_addr = NULL;
3564 struct get_key_cookie cookie = {
3568 struct sk_buff *msg;
3570 if (info->attrs[NL80211_ATTR_KEY_IDX])
3571 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
3573 if (info->attrs[NL80211_ATTR_MAC])
3574 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3576 pairwise = !!mac_addr;
3577 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
3578 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
3580 if (kt != NL80211_KEYTYPE_GROUP &&
3581 kt != NL80211_KEYTYPE_PAIRWISE)
3583 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
3586 if (!rdev->ops->get_key)
3589 if (!pairwise && mac_addr && !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3592 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3596 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
3597 NL80211_CMD_NEW_KEY);
3599 goto nla_put_failure;
3602 cookie.idx = key_idx;
3604 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3605 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
3606 goto nla_put_failure;
3608 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
3609 goto nla_put_failure;
3611 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
3618 goto nla_put_failure;
3620 genlmsg_end(msg, hdr);
3621 return genlmsg_reply(msg, info);
3630 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
3632 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3633 struct key_parse key;
3635 struct net_device *dev = info->user_ptr[1];
3637 err = nl80211_parse_key(info, &key);
3644 /* only support setting default key */
3645 if (!key.def && !key.defmgmt)
3648 wdev_lock(dev->ieee80211_ptr);
3651 if (!rdev->ops->set_default_key) {
3656 err = nl80211_key_allowed(dev->ieee80211_ptr);
3660 err = rdev_set_default_key(rdev, dev, key.idx,
3661 key.def_uni, key.def_multi);
3666 #ifdef CONFIG_CFG80211_WEXT
3667 dev->ieee80211_ptr->wext.default_key = key.idx;
3670 if (key.def_uni || !key.def_multi) {
3675 if (!rdev->ops->set_default_mgmt_key) {
3680 err = nl80211_key_allowed(dev->ieee80211_ptr);
3684 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
3688 #ifdef CONFIG_CFG80211_WEXT
3689 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
3694 wdev_unlock(dev->ieee80211_ptr);
3699 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
3701 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3703 struct net_device *dev = info->user_ptr[1];
3704 struct key_parse key;
3705 const u8 *mac_addr = NULL;
3707 err = nl80211_parse_key(info, &key);
3714 if (info->attrs[NL80211_ATTR_MAC])
3715 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3717 if (key.type == -1) {
3719 key.type = NL80211_KEYTYPE_PAIRWISE;
3721 key.type = NL80211_KEYTYPE_GROUP;
3725 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3726 key.type != NL80211_KEYTYPE_GROUP)
3729 if (!rdev->ops->add_key)
3732 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
3733 key.type == NL80211_KEYTYPE_PAIRWISE,
3737 wdev_lock(dev->ieee80211_ptr);
3738 err = nl80211_key_allowed(dev->ieee80211_ptr);
3740 err = rdev_add_key(rdev, dev, key.idx,
3741 key.type == NL80211_KEYTYPE_PAIRWISE,
3743 wdev_unlock(dev->ieee80211_ptr);
3748 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
3750 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3752 struct net_device *dev = info->user_ptr[1];
3753 u8 *mac_addr = NULL;
3754 struct key_parse key;
3756 err = nl80211_parse_key(info, &key);
3760 if (info->attrs[NL80211_ATTR_MAC])
3761 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3763 if (key.type == -1) {
3765 key.type = NL80211_KEYTYPE_PAIRWISE;
3767 key.type = NL80211_KEYTYPE_GROUP;
3771 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
3772 key.type != NL80211_KEYTYPE_GROUP)
3775 if (!rdev->ops->del_key)
3778 wdev_lock(dev->ieee80211_ptr);
3779 err = nl80211_key_allowed(dev->ieee80211_ptr);
3781 if (key.type == NL80211_KEYTYPE_GROUP && mac_addr &&
3782 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3786 err = rdev_del_key(rdev, dev, key.idx,
3787 key.type == NL80211_KEYTYPE_PAIRWISE,
3790 #ifdef CONFIG_CFG80211_WEXT
3792 if (key.idx == dev->ieee80211_ptr->wext.default_key)
3793 dev->ieee80211_ptr->wext.default_key = -1;
3794 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
3795 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3798 wdev_unlock(dev->ieee80211_ptr);
3803 /* This function returns an error or the number of nested attributes */
3804 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3806 struct nlattr *attr;
3807 int n_entries = 0, tmp;
3809 nla_for_each_nested(attr, nl_attr, tmp) {
3810 if (nla_len(attr) != ETH_ALEN)
3820 * This function parses ACL information and allocates memory for ACL data.
3821 * On successful return, the calling function is responsible to free the
3822 * ACL buffer returned by this function.
3824 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3825 struct genl_info *info)
3827 enum nl80211_acl_policy acl_policy;
3828 struct nlattr *attr;
3829 struct cfg80211_acl_data *acl;
3830 int i = 0, n_entries, tmp;
3832 if (!wiphy->max_acl_mac_addrs)
3833 return ERR_PTR(-EOPNOTSUPP);
3835 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3836 return ERR_PTR(-EINVAL);
3838 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3839 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3840 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3841 return ERR_PTR(-EINVAL);
3843 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3844 return ERR_PTR(-EINVAL);
3846 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3848 return ERR_PTR(n_entries);
3850 if (n_entries > wiphy->max_acl_mac_addrs)
3851 return ERR_PTR(-ENOTSUPP);
3853 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3856 return ERR_PTR(-ENOMEM);
3858 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3859 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3863 acl->n_acl_entries = n_entries;
3864 acl->acl_policy = acl_policy;
3869 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3871 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3872 struct net_device *dev = info->user_ptr[1];
3873 struct cfg80211_acl_data *acl;
3876 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3877 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3880 if (!dev->ieee80211_ptr->beacon_interval)
3883 acl = parse_acl_data(&rdev->wiphy, info);
3885 return PTR_ERR(acl);
3887 err = rdev_set_mac_acl(rdev, dev, acl);
3894 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
3895 u8 *rates, u8 rates_len)
3900 for (i = 0; i < rates_len; i++) {
3901 int rate = (rates[i] & 0x7f) * 5;
3904 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
3905 struct ieee80211_rate *srate =
3906 &sband->bitrates[ridx];
3907 if (rate == srate->bitrate) {
3912 if (ridx == sband->n_bitrates)
3913 return 0; /* rate not found */
3919 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
3920 u8 *rates, u8 rates_len,
3921 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
3925 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
3927 for (i = 0; i < rates_len; i++) {
3930 ridx = rates[i] / 8;
3931 rbit = BIT(rates[i] % 8);
3933 /* check validity */
3934 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
3937 /* check availability */
3938 ridx = array_index_nospec(ridx, IEEE80211_HT_MCS_MASK_LEN);
3939 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
3948 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
3952 switch (vht_mcs_map) {
3953 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
3955 case IEEE80211_VHT_MCS_SUPPORT_0_7:
3958 case IEEE80211_VHT_MCS_SUPPORT_0_8:
3961 case IEEE80211_VHT_MCS_SUPPORT_0_9:
3971 static void vht_build_mcs_mask(u16 vht_mcs_map,
3972 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
3976 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
3977 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
3982 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
3983 struct nl80211_txrate_vht *txrate,
3984 u16 mcs[NL80211_VHT_NSS_MAX])
3986 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
3987 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
3990 if (!sband->vht_cap.vht_supported)
3993 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
3995 /* Build vht_mcs_mask from VHT capabilities */
3996 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
3998 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
3999 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
4000 mcs[i] = txrate->mcs[i];
4008 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
4009 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
4010 .len = NL80211_MAX_SUPP_RATES },
4011 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
4012 .len = NL80211_MAX_SUPP_HT_RATES },
4013 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
4014 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
4017 static int nl80211_parse_tx_bitrate_mask(struct genl_info *info,
4018 struct cfg80211_bitrate_mask *mask)
4020 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
4021 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4023 struct nlattr *tx_rates;
4024 struct ieee80211_supported_band *sband;
4027 memset(mask, 0, sizeof(*mask));
4028 /* Default to all rates enabled */
4029 for (i = 0; i < NUM_NL80211_BANDS; i++) {
4030 sband = rdev->wiphy.bands[i];
4035 mask->control[i].legacy = (1 << sband->n_bitrates) - 1;
4036 memcpy(mask->control[i].ht_mcs,
4037 sband->ht_cap.mcs.rx_mask,
4038 sizeof(mask->control[i].ht_mcs));
4040 if (!sband->vht_cap.vht_supported)
4043 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
4044 vht_build_mcs_mask(vht_tx_mcs_map, mask->control[i].vht_mcs);
4047 /* if no rates are given set it back to the defaults */
4048 if (!info->attrs[NL80211_ATTR_TX_RATES])
4051 /* The nested attribute uses enum nl80211_band as the index. This maps
4052 * directly to the enum nl80211_band values used in cfg80211.
4054 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
4055 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
4056 enum nl80211_band band = nla_type(tx_rates);
4059 if (band < 0 || band >= NUM_NL80211_BANDS)
4061 sband = rdev->wiphy.bands[band];
4064 err = nla_parse_nested(tb, NL80211_TXRATE_MAX, tx_rates,
4065 nl80211_txattr_policy, info->extack);
4068 if (tb[NL80211_TXRATE_LEGACY]) {
4069 mask->control[band].legacy = rateset_to_mask(
4071 nla_data(tb[NL80211_TXRATE_LEGACY]),
4072 nla_len(tb[NL80211_TXRATE_LEGACY]));
4073 if ((mask->control[band].legacy == 0) &&
4074 nla_len(tb[NL80211_TXRATE_LEGACY]))
4077 if (tb[NL80211_TXRATE_HT]) {
4078 if (!ht_rateset_to_mask(
4080 nla_data(tb[NL80211_TXRATE_HT]),
4081 nla_len(tb[NL80211_TXRATE_HT]),
4082 mask->control[band].ht_mcs))
4085 if (tb[NL80211_TXRATE_VHT]) {
4086 if (!vht_set_mcs_mask(
4088 nla_data(tb[NL80211_TXRATE_VHT]),
4089 mask->control[band].vht_mcs))
4092 if (tb[NL80211_TXRATE_GI]) {
4093 mask->control[band].gi =
4094 nla_get_u8(tb[NL80211_TXRATE_GI]);
4095 if (mask->control[band].gi > NL80211_TXRATE_FORCE_LGI)
4099 if (mask->control[band].legacy == 0) {
4100 /* don't allow empty legacy rates if HT or VHT
4101 * are not even supported.
4103 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
4104 rdev->wiphy.bands[band]->vht_cap.vht_supported))
4107 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4108 if (mask->control[band].ht_mcs[i])
4111 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4112 if (mask->control[band].vht_mcs[i])
4115 /* legacy and mcs rates may not be both empty */
4124 static int validate_beacon_tx_rate(struct cfg80211_registered_device *rdev,
4125 enum nl80211_band band,
4126 struct cfg80211_bitrate_mask *beacon_rate)
4128 u32 count_ht, count_vht, i;
4129 u32 rate = beacon_rate->control[band].legacy;
4131 /* Allow only one rate */
4132 if (hweight32(rate) > 1)
4136 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4137 if (hweight8(beacon_rate->control[band].ht_mcs[i]) > 1) {
4139 } else if (beacon_rate->control[band].ht_mcs[i]) {
4144 if (count_ht && rate)
4149 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4150 if (hweight16(beacon_rate->control[band].vht_mcs[i]) > 1) {
4152 } else if (beacon_rate->control[band].vht_mcs[i]) {
4157 if (count_vht && rate)
4161 if ((count_ht && count_vht) || (!rate && !count_ht && !count_vht))
4165 !wiphy_ext_feature_isset(&rdev->wiphy,
4166 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY))
4169 !wiphy_ext_feature_isset(&rdev->wiphy,
4170 NL80211_EXT_FEATURE_BEACON_RATE_HT))
4173 !wiphy_ext_feature_isset(&rdev->wiphy,
4174 NL80211_EXT_FEATURE_BEACON_RATE_VHT))
4180 static int nl80211_parse_beacon(struct cfg80211_registered_device *rdev,
4181 struct nlattr *attrs[],
4182 struct cfg80211_beacon_data *bcn)
4184 bool haveinfo = false;
4187 memset(bcn, 0, sizeof(*bcn));
4189 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
4190 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
4191 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
4197 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
4198 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
4199 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
4206 if (attrs[NL80211_ATTR_IE]) {
4207 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
4208 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
4211 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
4212 bcn->proberesp_ies =
4213 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
4214 bcn->proberesp_ies_len =
4215 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
4218 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
4219 bcn->assocresp_ies =
4220 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
4221 bcn->assocresp_ies_len =
4222 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
4225 if (attrs[NL80211_ATTR_PROBE_RESP]) {
4226 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
4227 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
4230 if (attrs[NL80211_ATTR_FTM_RESPONDER]) {
4231 struct nlattr *tb[NL80211_FTM_RESP_ATTR_MAX + 1];
4233 err = nla_parse_nested(tb, NL80211_FTM_RESP_ATTR_MAX,
4234 attrs[NL80211_ATTR_FTM_RESPONDER],
4239 if (tb[NL80211_FTM_RESP_ATTR_ENABLED] &&
4240 wiphy_ext_feature_isset(&rdev->wiphy,
4241 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
4242 bcn->ftm_responder = 1;
4246 if (tb[NL80211_FTM_RESP_ATTR_LCI]) {
4247 bcn->lci = nla_data(tb[NL80211_FTM_RESP_ATTR_LCI]);
4248 bcn->lci_len = nla_len(tb[NL80211_FTM_RESP_ATTR_LCI]);
4251 if (tb[NL80211_FTM_RESP_ATTR_CIVICLOC]) {
4252 bcn->civicloc = nla_data(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
4253 bcn->civicloc_len = nla_len(tb[NL80211_FTM_RESP_ATTR_CIVICLOC]);
4256 bcn->ftm_responder = -1;
4262 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings *params,
4270 for (i = 0; i < rates[1]; i++) {
4271 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
4272 params->ht_required = true;
4273 if (rates[2 + i] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY)
4274 params->vht_required = true;
4279 * Since the nl80211 API didn't include, from the beginning, attributes about
4280 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
4281 * benefit of drivers that rebuild IEs in the firmware.
4283 static void nl80211_calculate_ap_params(struct cfg80211_ap_settings *params)
4285 const struct cfg80211_beacon_data *bcn = ¶ms->beacon;
4286 size_t ies_len = bcn->tail_len;
4287 const u8 *ies = bcn->tail;
4291 rates = cfg80211_find_ie(WLAN_EID_SUPP_RATES, ies, ies_len);
4292 nl80211_check_ap_rate_selectors(params, rates);
4294 rates = cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES, ies, ies_len);
4295 nl80211_check_ap_rate_selectors(params, rates);
4297 cap = cfg80211_find_ie(WLAN_EID_HT_CAPABILITY, ies, ies_len);
4298 if (cap && cap[1] >= sizeof(*params->ht_cap))
4299 params->ht_cap = (void *)(cap + 2);
4300 cap = cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY, ies, ies_len);
4301 if (cap && cap[1] >= sizeof(*params->vht_cap))
4302 params->vht_cap = (void *)(cap + 2);
4303 cap = cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY, ies, ies_len);
4304 if (cap && cap[1] >= sizeof(*params->he_cap) + 1)
4305 params->he_cap = (void *)(cap + 3);
4308 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
4309 struct cfg80211_ap_settings *params)
4311 struct wireless_dev *wdev;
4314 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
4315 if (wdev->iftype != NL80211_IFTYPE_AP &&
4316 wdev->iftype != NL80211_IFTYPE_P2P_GO)
4319 if (!wdev->preset_chandef.chan)
4322 params->chandef = wdev->preset_chandef;
4330 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
4331 enum nl80211_auth_type auth_type,
4332 enum nl80211_commands cmd)
4334 if (auth_type > NL80211_AUTHTYPE_MAX)
4338 case NL80211_CMD_AUTHENTICATE:
4339 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
4340 auth_type == NL80211_AUTHTYPE_SAE)
4342 if (!wiphy_ext_feature_isset(&rdev->wiphy,
4343 NL80211_EXT_FEATURE_FILS_STA) &&
4344 (auth_type == NL80211_AUTHTYPE_FILS_SK ||
4345 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4346 auth_type == NL80211_AUTHTYPE_FILS_PK))
4349 case NL80211_CMD_CONNECT:
4350 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
4351 auth_type == NL80211_AUTHTYPE_SAE)
4354 /* FILS with SK PFS or PK not supported yet */
4355 if (auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4356 auth_type == NL80211_AUTHTYPE_FILS_PK)
4358 if (!wiphy_ext_feature_isset(
4360 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
4361 auth_type == NL80211_AUTHTYPE_FILS_SK)
4364 case NL80211_CMD_START_AP:
4365 /* SAE not supported yet */
4366 if (auth_type == NL80211_AUTHTYPE_SAE)
4368 /* FILS not supported yet */
4369 if (auth_type == NL80211_AUTHTYPE_FILS_SK ||
4370 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
4371 auth_type == NL80211_AUTHTYPE_FILS_PK)
4379 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
4381 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4382 struct net_device *dev = info->user_ptr[1];
4383 struct wireless_dev *wdev = dev->ieee80211_ptr;
4384 struct cfg80211_ap_settings params;
4387 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4388 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4391 if (!rdev->ops->start_ap)
4394 if (wdev->beacon_interval)
4397 memset(¶ms, 0, sizeof(params));
4399 /* these are required for START_AP */
4400 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
4401 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
4402 !info->attrs[NL80211_ATTR_BEACON_HEAD])
4405 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon);
4409 params.beacon_interval =
4410 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
4411 params.dtim_period =
4412 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
4414 err = cfg80211_validate_beacon_int(rdev, dev->ieee80211_ptr->iftype,
4415 params.beacon_interval);
4420 * In theory, some of these attributes should be required here
4421 * but since they were not used when the command was originally
4422 * added, keep them optional for old user space programs to let
4423 * them continue to work with drivers that do not need the
4424 * additional information -- drivers must check!
4426 if (info->attrs[NL80211_ATTR_SSID]) {
4427 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
4429 nla_len(info->attrs[NL80211_ATTR_SSID]);
4430 if (params.ssid_len == 0 ||
4431 params.ssid_len > IEEE80211_MAX_SSID_LEN)
4435 if (info->attrs[NL80211_ATTR_HIDDEN_SSID])
4436 params.hidden_ssid = nla_get_u32(
4437 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
4439 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
4441 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
4442 params.auth_type = nla_get_u32(
4443 info->attrs[NL80211_ATTR_AUTH_TYPE]);
4444 if (!nl80211_valid_auth_type(rdev, params.auth_type,
4445 NL80211_CMD_START_AP))
4448 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
4450 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
4451 NL80211_MAX_NR_CIPHER_SUITES);
4455 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
4456 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
4458 params.inactivity_timeout = nla_get_u16(
4459 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
4462 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4463 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4465 params.p2p_ctwindow =
4466 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4467 if (params.p2p_ctwindow != 0 &&
4468 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4472 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4475 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4477 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4478 params.p2p_opp_ps = tmp;
4479 if (params.p2p_opp_ps != 0 &&
4480 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4484 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
4485 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
4488 } else if (wdev->preset_chandef.chan) {
4489 params.chandef = wdev->preset_chandef;
4490 } else if (!nl80211_get_ap_channel(rdev, ¶ms))
4493 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
4497 if (info->attrs[NL80211_ATTR_TX_RATES]) {
4498 err = nl80211_parse_tx_bitrate_mask(info, ¶ms.beacon_rate);
4502 err = validate_beacon_tx_rate(rdev, params.chandef.chan->band,
4503 ¶ms.beacon_rate);
4508 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
4510 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
4511 switch (params.smps_mode) {
4512 case NL80211_SMPS_OFF:
4514 case NL80211_SMPS_STATIC:
4515 if (!(rdev->wiphy.features &
4516 NL80211_FEATURE_STATIC_SMPS))
4519 case NL80211_SMPS_DYNAMIC:
4520 if (!(rdev->wiphy.features &
4521 NL80211_FEATURE_DYNAMIC_SMPS))
4528 params.smps_mode = NL80211_SMPS_OFF;
4531 params.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
4532 if (params.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ])
4535 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
4536 params.acl = parse_acl_data(&rdev->wiphy, info);
4537 if (IS_ERR(params.acl))
4538 return PTR_ERR(params.acl);
4541 nl80211_calculate_ap_params(¶ms);
4544 err = rdev_start_ap(rdev, dev, ¶ms);
4546 wdev->preset_chandef = params.chandef;
4547 wdev->beacon_interval = params.beacon_interval;
4548 wdev->chandef = params.chandef;
4549 wdev->ssid_len = params.ssid_len;
4550 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
4552 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
4553 wdev->conn_owner_nlportid = info->snd_portid;
4562 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
4564 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4565 struct net_device *dev = info->user_ptr[1];
4566 struct wireless_dev *wdev = dev->ieee80211_ptr;
4567 struct cfg80211_beacon_data params;
4570 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4571 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4574 if (!rdev->ops->change_beacon)
4577 if (!wdev->beacon_interval)
4580 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms);
4585 err = rdev_change_beacon(rdev, dev, ¶ms);
4591 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
4593 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4594 struct net_device *dev = info->user_ptr[1];
4596 return cfg80211_stop_ap(rdev, dev, false);
4599 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
4600 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
4601 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
4602 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
4603 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
4604 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
4605 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
4608 static int parse_station_flags(struct genl_info *info,
4609 enum nl80211_iftype iftype,
4610 struct station_parameters *params)
4612 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
4617 * Try parsing the new attribute first so userspace
4618 * can specify both for older kernels.
4620 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
4622 struct nl80211_sta_flag_update *sta_flags;
4624 sta_flags = nla_data(nla);
4625 params->sta_flags_mask = sta_flags->mask;
4626 params->sta_flags_set = sta_flags->set;
4627 params->sta_flags_set &= params->sta_flags_mask;
4628 if ((params->sta_flags_mask |
4629 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
4634 /* if present, parse the old attribute */
4636 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
4640 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX, nla,
4641 sta_flags_policy, info->extack))
4645 * Only allow certain flags for interface types so that
4646 * other attributes are silently ignored. Remember that
4647 * this is backward compatibility code with old userspace
4648 * and shouldn't be hit in other cases anyway.
4651 case NL80211_IFTYPE_AP:
4652 case NL80211_IFTYPE_AP_VLAN:
4653 case NL80211_IFTYPE_P2P_GO:
4654 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4655 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
4656 BIT(NL80211_STA_FLAG_WME) |
4657 BIT(NL80211_STA_FLAG_MFP);
4659 case NL80211_IFTYPE_P2P_CLIENT:
4660 case NL80211_IFTYPE_STATION:
4661 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
4662 BIT(NL80211_STA_FLAG_TDLS_PEER);
4664 case NL80211_IFTYPE_MESH_POINT:
4665 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4666 BIT(NL80211_STA_FLAG_MFP) |
4667 BIT(NL80211_STA_FLAG_AUTHORIZED);
4673 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
4675 params->sta_flags_set |= (1<<flag);
4677 /* no longer support new API additions in old API */
4678 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
4686 bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info, int attr)
4688 struct nlattr *rate;
4691 enum nl80211_rate_info rate_flg;
4693 rate = nla_nest_start(msg, attr);
4697 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
4698 bitrate = cfg80211_calculate_bitrate(info);
4699 /* report 16-bit bitrate only if we can */
4700 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
4702 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
4704 if (bitrate_compat > 0 &&
4705 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
4709 case RATE_INFO_BW_5:
4710 rate_flg = NL80211_RATE_INFO_5_MHZ_WIDTH;
4712 case RATE_INFO_BW_10:
4713 rate_flg = NL80211_RATE_INFO_10_MHZ_WIDTH;
4718 case RATE_INFO_BW_20:
4721 case RATE_INFO_BW_40:
4722 rate_flg = NL80211_RATE_INFO_40_MHZ_WIDTH;
4724 case RATE_INFO_BW_80:
4725 rate_flg = NL80211_RATE_INFO_80_MHZ_WIDTH;
4727 case RATE_INFO_BW_160:
4728 rate_flg = NL80211_RATE_INFO_160_MHZ_WIDTH;
4730 case RATE_INFO_BW_HE_RU:
4732 WARN_ON(!(info->flags & RATE_INFO_FLAGS_HE_MCS));
4735 if (rate_flg && nla_put_flag(msg, rate_flg))
4738 if (info->flags & RATE_INFO_FLAGS_MCS) {
4739 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
4741 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4742 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4744 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
4745 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
4747 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
4749 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
4750 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
4752 } else if (info->flags & RATE_INFO_FLAGS_HE_MCS) {
4753 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_MCS, info->mcs))
4755 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_NSS, info->nss))
4757 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_GI, info->he_gi))
4759 if (nla_put_u8(msg, NL80211_RATE_INFO_HE_DCM, info->he_dcm))
4761 if (info->bw == RATE_INFO_BW_HE_RU &&
4762 nla_put_u8(msg, NL80211_RATE_INFO_HE_RU_ALLOC,
4767 nla_nest_end(msg, rate);
4771 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
4780 attr = nla_nest_start(msg, id);
4784 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
4785 if (!(mask & BIT(i)))
4788 if (nla_put_u8(msg, i, signal[i]))
4792 nla_nest_end(msg, attr);
4797 static int nl80211_send_station(struct sk_buff *msg, u32 cmd, u32 portid,
4799 struct cfg80211_registered_device *rdev,
4800 struct net_device *dev,
4801 const u8 *mac_addr, struct station_info *sinfo)
4804 struct nlattr *sinfoattr, *bss_param;
4806 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
4810 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4811 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
4812 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
4813 goto nla_put_failure;
4815 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
4817 goto nla_put_failure;
4819 #define PUT_SINFO(attr, memb, type) do { \
4820 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
4821 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
4822 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
4824 goto nla_put_failure; \
4826 #define PUT_SINFO_U64(attr, memb) do { \
4827 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
4828 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
4829 sinfo->memb, NL80211_STA_INFO_PAD)) \
4830 goto nla_put_failure; \
4833 PUT_SINFO(CONNECTED_TIME, connected_time, u32);
4834 PUT_SINFO(INACTIVE_TIME, inactive_time, u32);
4836 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_RX_BYTES) |
4837 BIT_ULL(NL80211_STA_INFO_RX_BYTES64)) &&
4838 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
4839 (u32)sinfo->rx_bytes))
4840 goto nla_put_failure;
4842 if (sinfo->filled & (BIT_ULL(NL80211_STA_INFO_TX_BYTES) |
4843 BIT_ULL(NL80211_STA_INFO_TX_BYTES64)) &&
4844 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
4845 (u32)sinfo->tx_bytes))
4846 goto nla_put_failure;
4848 PUT_SINFO_U64(RX_BYTES64, rx_bytes);
4849 PUT_SINFO_U64(TX_BYTES64, tx_bytes);
4850 PUT_SINFO(LLID, llid, u16);
4851 PUT_SINFO(PLID, plid, u16);
4852 PUT_SINFO(PLINK_STATE, plink_state, u8);
4853 PUT_SINFO_U64(RX_DURATION, rx_duration);
4855 switch (rdev->wiphy.signal_type) {
4856 case CFG80211_SIGNAL_TYPE_MBM:
4857 PUT_SINFO(SIGNAL, signal, u8);
4858 PUT_SINFO(SIGNAL_AVG, signal_avg, u8);
4863 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL)) {
4864 if (!nl80211_put_signal(msg, sinfo->chains,
4865 sinfo->chain_signal,
4866 NL80211_STA_INFO_CHAIN_SIGNAL))
4867 goto nla_put_failure;
4869 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG)) {
4870 if (!nl80211_put_signal(msg, sinfo->chains,
4871 sinfo->chain_signal_avg,
4872 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
4873 goto nla_put_failure;
4875 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_TX_BITRATE)) {
4876 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
4877 NL80211_STA_INFO_TX_BITRATE))
4878 goto nla_put_failure;
4880 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_RX_BITRATE)) {
4881 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
4882 NL80211_STA_INFO_RX_BITRATE))
4883 goto nla_put_failure;
4886 PUT_SINFO(RX_PACKETS, rx_packets, u32);
4887 PUT_SINFO(TX_PACKETS, tx_packets, u32);
4888 PUT_SINFO(TX_RETRIES, tx_retries, u32);
4889 PUT_SINFO(TX_FAILED, tx_failed, u32);
4890 PUT_SINFO(EXPECTED_THROUGHPUT, expected_throughput, u32);
4891 PUT_SINFO(BEACON_LOSS, beacon_loss_count, u32);
4892 PUT_SINFO(LOCAL_PM, local_pm, u32);
4893 PUT_SINFO(PEER_PM, peer_pm, u32);
4894 PUT_SINFO(NONPEER_PM, nonpeer_pm, u32);
4895 PUT_SINFO(CONNECTED_TO_GATE, connected_to_gate, u8);
4897 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_BSS_PARAM)) {
4898 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
4900 goto nla_put_failure;
4902 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
4903 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
4904 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
4905 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
4906 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
4907 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
4908 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
4909 sinfo->bss_param.dtim_period) ||
4910 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
4911 sinfo->bss_param.beacon_interval))
4912 goto nla_put_failure;
4914 nla_nest_end(msg, bss_param);
4916 if ((sinfo->filled & BIT_ULL(NL80211_STA_INFO_STA_FLAGS)) &&
4917 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
4918 sizeof(struct nl80211_sta_flag_update),
4920 goto nla_put_failure;
4922 PUT_SINFO_U64(T_OFFSET, t_offset);
4923 PUT_SINFO_U64(RX_DROP_MISC, rx_dropped_misc);
4924 PUT_SINFO_U64(BEACON_RX, rx_beacon);
4925 PUT_SINFO(BEACON_SIGNAL_AVG, rx_beacon_signal_avg, u8);
4926 PUT_SINFO(RX_MPDUS, rx_mpdu_count, u32);
4927 PUT_SINFO(FCS_ERROR_COUNT, fcs_err_count, u32);
4928 if (wiphy_ext_feature_isset(&rdev->wiphy,
4929 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT)) {
4930 PUT_SINFO(ACK_SIGNAL, ack_signal, u8);
4931 PUT_SINFO(ACK_SIGNAL_AVG, avg_ack_signal, s8);
4935 #undef PUT_SINFO_U64
4937 if (sinfo->pertid) {
4938 struct nlattr *tidsattr;
4941 tidsattr = nla_nest_start(msg, NL80211_STA_INFO_TID_STATS);
4943 goto nla_put_failure;
4945 for (tid = 0; tid < IEEE80211_NUM_TIDS + 1; tid++) {
4946 struct cfg80211_tid_stats *tidstats;
4947 struct nlattr *tidattr;
4949 tidstats = &sinfo->pertid[tid];
4951 if (!tidstats->filled)
4954 tidattr = nla_nest_start(msg, tid + 1);
4956 goto nla_put_failure;
4958 #define PUT_TIDVAL_U64(attr, memb) do { \
4959 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
4960 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
4961 tidstats->memb, NL80211_TID_STATS_PAD)) \
4962 goto nla_put_failure; \
4965 PUT_TIDVAL_U64(RX_MSDU, rx_msdu);
4966 PUT_TIDVAL_U64(TX_MSDU, tx_msdu);
4967 PUT_TIDVAL_U64(TX_MSDU_RETRIES, tx_msdu_retries);
4968 PUT_TIDVAL_U64(TX_MSDU_FAILED, tx_msdu_failed);
4970 #undef PUT_TIDVAL_U64
4971 if ((tidstats->filled &
4972 BIT(NL80211_TID_STATS_TXQ_STATS)) &&
4973 !nl80211_put_txq_stats(msg, &tidstats->txq_stats,
4974 NL80211_TID_STATS_TXQ_STATS))
4975 goto nla_put_failure;
4977 nla_nest_end(msg, tidattr);
4980 nla_nest_end(msg, tidsattr);
4983 nla_nest_end(msg, sinfoattr);
4985 if (sinfo->assoc_req_ies_len &&
4986 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
4987 sinfo->assoc_req_ies))
4988 goto nla_put_failure;
4990 cfg80211_sinfo_release_content(sinfo);
4991 genlmsg_end(msg, hdr);
4995 cfg80211_sinfo_release_content(sinfo);
4996 genlmsg_cancel(msg, hdr);
5000 static int nl80211_dump_station(struct sk_buff *skb,
5001 struct netlink_callback *cb)
5003 struct station_info sinfo;
5004 struct cfg80211_registered_device *rdev;
5005 struct wireless_dev *wdev;
5006 u8 mac_addr[ETH_ALEN];
5007 int sta_idx = cb->args[2];
5011 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
5015 if (!wdev->netdev) {
5020 if (!rdev->ops->dump_station) {
5026 memset(&sinfo, 0, sizeof(sinfo));
5027 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
5034 if (nl80211_send_station(skb, NL80211_CMD_NEW_STATION,
5035 NETLINK_CB(cb->skb).portid,
5036 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5037 rdev, wdev->netdev, mac_addr,
5045 cb->args[2] = sta_idx;
5053 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
5055 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5056 struct net_device *dev = info->user_ptr[1];
5057 struct station_info sinfo;
5058 struct sk_buff *msg;
5059 u8 *mac_addr = NULL;
5062 memset(&sinfo, 0, sizeof(sinfo));
5064 if (!info->attrs[NL80211_ATTR_MAC])
5067 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5069 if (!rdev->ops->get_station)
5072 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
5076 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5078 cfg80211_sinfo_release_content(&sinfo);
5082 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION,
5083 info->snd_portid, info->snd_seq, 0,
5084 rdev, dev, mac_addr, &sinfo) < 0) {
5089 return genlmsg_reply(msg, info);
5092 int cfg80211_check_station_change(struct wiphy *wiphy,
5093 struct station_parameters *params,
5094 enum cfg80211_station_type statype)
5096 if (params->listen_interval != -1 &&
5097 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5100 if (params->support_p2p_ps != -1 &&
5101 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5105 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) &&
5106 statype != CFG80211_STA_AP_CLIENT_UNASSOC)
5109 /* When you run into this, adjust the code below for the new flag */
5110 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5113 case CFG80211_STA_MESH_PEER_KERNEL:
5114 case CFG80211_STA_MESH_PEER_USER:
5116 * No ignoring the TDLS flag here -- the userspace mesh
5117 * code doesn't have the bug of including TDLS in the
5120 if (params->sta_flags_mask &
5121 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5122 BIT(NL80211_STA_FLAG_MFP) |
5123 BIT(NL80211_STA_FLAG_AUTHORIZED)))
5126 case CFG80211_STA_TDLS_PEER_SETUP:
5127 case CFG80211_STA_TDLS_PEER_ACTIVE:
5128 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5130 /* ignore since it can't change */
5131 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5134 /* disallow mesh-specific things */
5135 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
5137 if (params->local_pm)
5139 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
5143 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
5144 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
5145 /* TDLS can't be set, ... */
5146 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
5149 * ... but don't bother the driver with it. This works around
5150 * a hostapd/wpa_supplicant issue -- it always includes the
5151 * TLDS_PEER flag in the mask even for AP mode.
5153 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5156 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
5157 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
5158 /* reject other things that can't change */
5159 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
5161 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
5163 if (params->supported_rates)
5165 if (params->ext_capab || params->ht_capa || params->vht_capa ||
5170 if (statype != CFG80211_STA_AP_CLIENT &&
5171 statype != CFG80211_STA_AP_CLIENT_UNASSOC) {
5177 case CFG80211_STA_AP_MLME_CLIENT:
5178 /* Use this only for authorizing/unauthorizing a station */
5179 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
5182 case CFG80211_STA_AP_CLIENT:
5183 case CFG80211_STA_AP_CLIENT_UNASSOC:
5184 /* accept only the listed bits */
5185 if (params->sta_flags_mask &
5186 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
5187 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5188 BIT(NL80211_STA_FLAG_ASSOCIATED) |
5189 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
5190 BIT(NL80211_STA_FLAG_WME) |
5191 BIT(NL80211_STA_FLAG_MFP)))
5194 /* but authenticated/associated only if driver handles it */
5195 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
5196 params->sta_flags_mask &
5197 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5198 BIT(NL80211_STA_FLAG_ASSOCIATED)))
5201 case CFG80211_STA_IBSS:
5202 case CFG80211_STA_AP_STA:
5203 /* reject any changes other than AUTHORIZED */
5204 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
5207 case CFG80211_STA_TDLS_PEER_SETUP:
5208 /* reject any changes other than AUTHORIZED or WME */
5209 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
5210 BIT(NL80211_STA_FLAG_WME)))
5212 /* force (at least) rates when authorizing */
5213 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
5214 !params->supported_rates)
5217 case CFG80211_STA_TDLS_PEER_ACTIVE:
5218 /* reject any changes */
5220 case CFG80211_STA_MESH_PEER_KERNEL:
5221 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
5224 case CFG80211_STA_MESH_PEER_USER:
5225 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION &&
5226 params->plink_action != NL80211_PLINK_ACTION_BLOCK)
5232 * Older kernel versions ignored this attribute entirely, so don't
5233 * reject attempts to update it but mark it as unused instead so the
5234 * driver won't look at the data.
5236 if (statype != CFG80211_STA_AP_CLIENT_UNASSOC &&
5237 statype != CFG80211_STA_TDLS_PEER_SETUP)
5238 params->opmode_notif_used = false;
5242 EXPORT_SYMBOL(cfg80211_check_station_change);
5245 * Get vlan interface making sure it is running and on the right wiphy.
5247 static struct net_device *get_vlan(struct genl_info *info,
5248 struct cfg80211_registered_device *rdev)
5250 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
5251 struct net_device *v;
5257 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
5259 return ERR_PTR(-ENODEV);
5261 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
5266 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5267 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5268 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
5273 if (!netif_running(v)) {
5281 return ERR_PTR(ret);
5284 static const struct nla_policy
5285 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
5286 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
5287 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
5290 static int nl80211_parse_sta_wme(struct genl_info *info,
5291 struct station_parameters *params)
5293 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
5297 /* parse WME attributes if present */
5298 if (!info->attrs[NL80211_ATTR_STA_WME])
5301 nla = info->attrs[NL80211_ATTR_STA_WME];
5302 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
5303 nl80211_sta_wme_policy, info->extack);
5307 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
5308 params->uapsd_queues = nla_get_u8(
5309 tb[NL80211_STA_WME_UAPSD_QUEUES]);
5310 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
5313 if (tb[NL80211_STA_WME_MAX_SP])
5314 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
5316 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
5319 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
5324 static int nl80211_parse_sta_channel_info(struct genl_info *info,
5325 struct station_parameters *params)
5327 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
5328 params->supported_channels =
5329 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
5330 params->supported_channels_len =
5331 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
5333 * Need to include at least one (first channel, number of
5334 * channels) tuple for each subband, and must have proper
5335 * tuples for the rest of the data as well.
5337 if (params->supported_channels_len < 2)
5339 if (params->supported_channels_len % 2)
5343 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
5344 params->supported_oper_classes =
5345 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
5346 params->supported_oper_classes_len =
5347 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
5349 * The value of the Length field of the Supported Operating
5350 * Classes element is between 2 and 253.
5352 if (params->supported_oper_classes_len < 2 ||
5353 params->supported_oper_classes_len > 253)
5359 static int nl80211_set_station_tdls(struct genl_info *info,
5360 struct station_parameters *params)
5363 /* Dummy STA entry gets updated once the peer capabilities are known */
5364 if (info->attrs[NL80211_ATTR_PEER_AID])
5365 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
5366 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5368 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5369 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5371 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
5372 if (info->attrs[NL80211_ATTR_HE_CAPABILITY]) {
5374 nla_data(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5375 params->he_capa_len =
5376 nla_len(info->attrs[NL80211_ATTR_HE_CAPABILITY]);
5378 if (params->he_capa_len < NL80211_HE_MIN_CAPABILITY_LEN)
5382 err = nl80211_parse_sta_channel_info(info, params);
5386 return nl80211_parse_sta_wme(info, params);
5389 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
5391 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5392 struct net_device *dev = info->user_ptr[1];
5393 struct station_parameters params;
5397 memset(¶ms, 0, sizeof(params));
5399 if (!rdev->ops->change_station)
5403 * AID and listen_interval properties can be set only for unassociated
5404 * station. Include these parameters here and will check them in
5405 * cfg80211_check_station_change().
5407 if (info->attrs[NL80211_ATTR_STA_AID])
5408 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
5410 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5411 params.listen_interval =
5412 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
5414 params.listen_interval = -1;
5416 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS])
5417 params.support_p2p_ps =
5418 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5420 params.support_p2p_ps = -1;
5422 if (!info->attrs[NL80211_ATTR_MAC])
5425 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5427 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
5428 params.supported_rates =
5429 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5430 params.supported_rates_len =
5431 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5434 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5436 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5437 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5440 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5442 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5443 params.ext_capab_len =
5444 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5447 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
5450 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
5451 params.plink_action =
5452 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5454 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
5455 params.plink_state =
5456 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
5457 if (info->attrs[NL80211_ATTR_MESH_PEER_AID])
5458 params.peer_aid = nla_get_u16(
5459 info->attrs[NL80211_ATTR_MESH_PEER_AID]);
5460 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
5463 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE])
5464 params.local_pm = nla_get_u32(
5465 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
5467 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5468 params.opmode_notif_used = true;
5469 params.opmode_notif =
5470 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5473 /* Include parameters for TDLS peer (will check later) */
5474 err = nl80211_set_station_tdls(info, ¶ms);
5478 params.vlan = get_vlan(info, rdev);
5479 if (IS_ERR(params.vlan))
5480 return PTR_ERR(params.vlan);
5482 switch (dev->ieee80211_ptr->iftype) {
5483 case NL80211_IFTYPE_AP:
5484 case NL80211_IFTYPE_AP_VLAN:
5485 case NL80211_IFTYPE_P2P_GO:
5486 case NL80211_IFTYPE_P2P_CLIENT:
5487 case NL80211_IFTYPE_STATION:
5488 case NL80211_IFTYPE_ADHOC:
5489 case NL80211_IFTYPE_MESH_POINT:
5496 /* driver will call cfg80211_check_station_change() */
5497 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
5501 dev_put(params.vlan);
5506 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
5508 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5510 struct net_device *dev = info->user_ptr[1];
5511 struct station_parameters params;
5512 u8 *mac_addr = NULL;
5513 u32 auth_assoc = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
5514 BIT(NL80211_STA_FLAG_ASSOCIATED);
5516 memset(¶ms, 0, sizeof(params));
5518 if (!rdev->ops->add_station)
5521 if (!info->attrs[NL80211_ATTR_MAC])
5524 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
5527 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
5530 if (!info->attrs[NL80211_ATTR_STA_AID] &&
5531 !info->attrs[NL80211_ATTR_PEER_AID])
5534 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
5535 params.supported_rates =
5536 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5537 params.supported_rates_len =
5538 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
5539 params.listen_interval =
5540 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
5542 if (info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]) {
5543 params.support_p2p_ps =
5544 nla_get_u8(info->attrs[NL80211_ATTR_STA_SUPPORT_P2P_PS]);
5547 * if not specified, assume it's supported for P2P GO interface,
5548 * and is NOT supported for AP interface
5550 params.support_p2p_ps =
5551 dev->ieee80211_ptr->iftype == NL80211_IFTYPE_P2P_GO;
5554 if (info->attrs[NL80211_ATTR_PEER_AID])
5555 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
5557 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
5559 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
5561 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
5562 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
5565 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
5567 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5568 params.ext_capab_len =
5569 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
5572 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
5574 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5576 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
5578 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 /* max len is validated in nla policy */
5587 if (params.he_capa_len < NL80211_HE_MIN_CAPABILITY_LEN)
5591 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
5592 params.opmode_notif_used = true;
5593 params.opmode_notif =
5594 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
5597 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
5598 params.plink_action =
5599 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
5601 err = nl80211_parse_sta_channel_info(info, ¶ms);
5605 err = nl80211_parse_sta_wme(info, ¶ms);
5609 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
5612 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
5613 * as userspace might just pass through the capabilities from the IEs
5614 * directly, rather than enforcing this restriction and returning an
5615 * error in this case.
5617 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME))) {
5618 params.ht_capa = NULL;
5619 params.vht_capa = NULL;
5621 /* HE requires WME */
5622 if (params.he_capa_len)
5626 /* When you run into this, adjust the code below for the new flag */
5627 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
5629 switch (dev->ieee80211_ptr->iftype) {
5630 case NL80211_IFTYPE_AP:
5631 case NL80211_IFTYPE_AP_VLAN:
5632 case NL80211_IFTYPE_P2P_GO:
5633 /* ignore WME attributes if iface/sta is not capable */
5634 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
5635 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
5636 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5638 /* TDLS peers cannot be added */
5639 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5640 info->attrs[NL80211_ATTR_PEER_AID])
5642 /* but don't bother the driver with it */
5643 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
5645 /* allow authenticated/associated only if driver handles it */
5646 if (!(rdev->wiphy.features &
5647 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
5648 params.sta_flags_mask & auth_assoc)
5651 /* Older userspace, or userspace wanting to be compatible with
5652 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
5653 * and assoc flags in the mask, but assumes the station will be
5654 * added as associated anyway since this was the required driver
5655 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
5657 * In order to not bother drivers with this quirk in the API
5658 * set the flags in both the mask and set for new stations in
5661 if (!(params.sta_flags_mask & auth_assoc)) {
5662 params.sta_flags_mask |= auth_assoc;
5663 params.sta_flags_set |= auth_assoc;
5666 /* must be last in here for error handling */
5667 params.vlan = get_vlan(info, rdev);
5668 if (IS_ERR(params.vlan))
5669 return PTR_ERR(params.vlan);
5671 case NL80211_IFTYPE_MESH_POINT:
5672 /* ignore uAPSD data */
5673 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5675 /* associated is disallowed */
5676 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
5678 /* TDLS peers cannot be added */
5679 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
5680 info->attrs[NL80211_ATTR_PEER_AID])
5683 case NL80211_IFTYPE_STATION:
5684 case NL80211_IFTYPE_P2P_CLIENT:
5685 /* ignore uAPSD data */
5686 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
5688 /* these are disallowed */
5689 if (params.sta_flags_mask &
5690 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
5691 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
5693 /* Only TDLS peers can be added */
5694 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
5696 /* Can only add if TDLS ... */
5697 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
5699 /* ... with external setup is supported */
5700 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
5703 * Older wpa_supplicant versions always mark the TDLS peer
5704 * as authorized, but it shouldn't yet be.
5706 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
5712 /* be aware of params.vlan when changing code here */
5714 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
5717 dev_put(params.vlan);
5721 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
5723 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5724 struct net_device *dev = info->user_ptr[1];
5725 struct station_del_parameters params;
5727 memset(¶ms, 0, sizeof(params));
5729 if (info->attrs[NL80211_ATTR_MAC])
5730 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
5732 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
5733 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
5734 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
5735 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
5738 if (!rdev->ops->del_station)
5741 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
5743 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
5744 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
5745 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
5748 /* Default to Deauthentication frame */
5749 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
5752 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
5753 params.reason_code =
5754 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5755 if (params.reason_code == 0)
5756 return -EINVAL; /* 0 is reserved */
5758 /* Default to reason code 2 */
5759 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
5762 return rdev_del_station(rdev, dev, ¶ms);
5765 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
5766 int flags, struct net_device *dev,
5767 u8 *dst, u8 *next_hop,
5768 struct mpath_info *pinfo)
5771 struct nlattr *pinfoattr;
5773 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_MPATH);
5777 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
5778 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
5779 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
5780 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
5781 goto nla_put_failure;
5783 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
5785 goto nla_put_failure;
5786 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
5787 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
5789 goto nla_put_failure;
5790 if (((pinfo->filled & MPATH_INFO_SN) &&
5791 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
5792 ((pinfo->filled & MPATH_INFO_METRIC) &&
5793 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
5795 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
5796 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
5798 ((pinfo->filled & MPATH_INFO_FLAGS) &&
5799 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
5801 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
5802 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
5803 pinfo->discovery_timeout)) ||
5804 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
5805 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
5806 pinfo->discovery_retries)))
5807 goto nla_put_failure;
5809 nla_nest_end(msg, pinfoattr);
5811 genlmsg_end(msg, hdr);
5815 genlmsg_cancel(msg, hdr);
5819 static int nl80211_dump_mpath(struct sk_buff *skb,
5820 struct netlink_callback *cb)
5822 struct mpath_info pinfo;
5823 struct cfg80211_registered_device *rdev;
5824 struct wireless_dev *wdev;
5826 u8 next_hop[ETH_ALEN];
5827 int path_idx = cb->args[2];
5831 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
5835 if (!rdev->ops->dump_mpath) {
5840 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
5846 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
5853 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
5854 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5855 wdev->netdev, dst, next_hop,
5863 cb->args[2] = path_idx;
5870 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
5872 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5874 struct net_device *dev = info->user_ptr[1];
5875 struct mpath_info pinfo;
5876 struct sk_buff *msg;
5878 u8 next_hop[ETH_ALEN];
5880 memset(&pinfo, 0, sizeof(pinfo));
5882 if (!info->attrs[NL80211_ATTR_MAC])
5885 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5887 if (!rdev->ops->get_mpath)
5890 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5893 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
5897 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5901 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
5902 dev, dst, next_hop, &pinfo) < 0) {
5907 return genlmsg_reply(msg, info);
5910 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
5912 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5913 struct net_device *dev = info->user_ptr[1];
5915 u8 *next_hop = NULL;
5917 if (!info->attrs[NL80211_ATTR_MAC])
5920 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5923 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5924 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5926 if (!rdev->ops->change_mpath)
5929 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5932 return rdev_change_mpath(rdev, dev, dst, next_hop);
5935 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
5937 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5938 struct net_device *dev = info->user_ptr[1];
5940 u8 *next_hop = NULL;
5942 if (!info->attrs[NL80211_ATTR_MAC])
5945 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
5948 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5949 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
5951 if (!rdev->ops->add_mpath)
5954 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5957 return rdev_add_mpath(rdev, dev, dst, next_hop);
5960 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
5962 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5963 struct net_device *dev = info->user_ptr[1];
5966 if (info->attrs[NL80211_ATTR_MAC])
5967 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5969 if (!rdev->ops->del_mpath)
5972 return rdev_del_mpath(rdev, dev, dst);
5975 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
5977 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5979 struct net_device *dev = info->user_ptr[1];
5980 struct mpath_info pinfo;
5981 struct sk_buff *msg;
5985 memset(&pinfo, 0, sizeof(pinfo));
5987 if (!info->attrs[NL80211_ATTR_MAC])
5990 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
5992 if (!rdev->ops->get_mpp)
5995 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
5998 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
6002 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6006 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
6007 dev, dst, mpp, &pinfo) < 0) {
6012 return genlmsg_reply(msg, info);
6015 static int nl80211_dump_mpp(struct sk_buff *skb,
6016 struct netlink_callback *cb)
6018 struct mpath_info pinfo;
6019 struct cfg80211_registered_device *rdev;
6020 struct wireless_dev *wdev;
6023 int path_idx = cb->args[2];
6027 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
6031 if (!rdev->ops->dump_mpp) {
6036 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
6042 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
6049 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
6050 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6051 wdev->netdev, dst, mpp,
6059 cb->args[2] = path_idx;
6066 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
6068 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6069 struct net_device *dev = info->user_ptr[1];
6070 struct wireless_dev *wdev = dev->ieee80211_ptr;
6071 struct bss_parameters params;
6074 memset(¶ms, 0, sizeof(params));
6075 /* default to not changing parameters */
6076 params.use_cts_prot = -1;
6077 params.use_short_preamble = -1;
6078 params.use_short_slot_time = -1;
6079 params.ap_isolate = -1;
6080 params.ht_opmode = -1;
6081 params.p2p_ctwindow = -1;
6082 params.p2p_opp_ps = -1;
6084 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
6085 params.use_cts_prot =
6086 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
6087 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
6088 params.use_short_preamble =
6089 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
6090 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
6091 params.use_short_slot_time =
6092 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
6093 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6094 params.basic_rates =
6095 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6096 params.basic_rates_len =
6097 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6099 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
6100 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
6101 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
6103 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
6105 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
6106 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6108 params.p2p_ctwindow =
6109 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
6110 if (params.p2p_ctwindow != 0 &&
6111 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
6115 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
6118 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6120 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
6121 params.p2p_opp_ps = tmp;
6122 if (params.p2p_opp_ps &&
6123 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
6127 if (!rdev->ops->change_bss)
6130 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
6131 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
6135 err = rdev_change_bss(rdev, dev, ¶ms);
6141 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
6145 enum nl80211_user_reg_hint_type user_reg_hint_type;
6149 * You should only get this when cfg80211 hasn't yet initialized
6150 * completely when built-in to the kernel right between the time
6151 * window between nl80211_init() and regulatory_init(), if that is
6154 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
6155 return -EINPROGRESS;
6157 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
6158 user_reg_hint_type =
6159 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
6161 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
6163 switch (user_reg_hint_type) {
6164 case NL80211_USER_REG_HINT_USER:
6165 case NL80211_USER_REG_HINT_CELL_BASE:
6166 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6169 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6170 return regulatory_hint_user(data, user_reg_hint_type);
6171 case NL80211_USER_REG_HINT_INDOOR:
6172 if (info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
6173 owner_nlportid = info->snd_portid;
6174 is_indoor = !!info->attrs[NL80211_ATTR_REG_INDOOR];
6180 return regulatory_hint_indoor(is_indoor, owner_nlportid);
6186 static int nl80211_reload_regdb(struct sk_buff *skb, struct genl_info *info)
6188 return reg_reload_regdb();
6191 static int nl80211_get_mesh_config(struct sk_buff *skb,
6192 struct genl_info *info)
6194 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6195 struct net_device *dev = info->user_ptr[1];
6196 struct wireless_dev *wdev = dev->ieee80211_ptr;
6197 struct mesh_config cur_params;
6200 struct nlattr *pinfoattr;
6201 struct sk_buff *msg;
6203 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6206 if (!rdev->ops->get_mesh_config)
6210 /* If not connected, get default parameters */
6211 if (!wdev->mesh_id_len)
6212 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
6214 err = rdev_get_mesh_config(rdev, dev, &cur_params);
6220 /* Draw up a netlink message to send back */
6221 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6224 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6225 NL80211_CMD_GET_MESH_CONFIG);
6228 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
6230 goto nla_put_failure;
6231 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
6232 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
6233 cur_params.dot11MeshRetryTimeout) ||
6234 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
6235 cur_params.dot11MeshConfirmTimeout) ||
6236 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
6237 cur_params.dot11MeshHoldingTimeout) ||
6238 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
6239 cur_params.dot11MeshMaxPeerLinks) ||
6240 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
6241 cur_params.dot11MeshMaxRetries) ||
6242 nla_put_u8(msg, NL80211_MESHCONF_TTL,
6243 cur_params.dot11MeshTTL) ||
6244 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
6245 cur_params.element_ttl) ||
6246 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
6247 cur_params.auto_open_plinks) ||
6248 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
6249 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
6250 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
6251 cur_params.dot11MeshHWMPmaxPREQretries) ||
6252 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
6253 cur_params.path_refresh_time) ||
6254 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
6255 cur_params.min_discovery_timeout) ||
6256 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
6257 cur_params.dot11MeshHWMPactivePathTimeout) ||
6258 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
6259 cur_params.dot11MeshHWMPpreqMinInterval) ||
6260 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
6261 cur_params.dot11MeshHWMPperrMinInterval) ||
6262 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
6263 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
6264 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
6265 cur_params.dot11MeshHWMPRootMode) ||
6266 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
6267 cur_params.dot11MeshHWMPRannInterval) ||
6268 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
6269 cur_params.dot11MeshGateAnnouncementProtocol) ||
6270 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
6271 cur_params.dot11MeshForwarding) ||
6272 nla_put_s32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
6273 cur_params.rssi_threshold) ||
6274 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
6275 cur_params.ht_opmode) ||
6276 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
6277 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
6278 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
6279 cur_params.dot11MeshHWMProotInterval) ||
6280 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
6281 cur_params.dot11MeshHWMPconfirmationInterval) ||
6282 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
6283 cur_params.power_mode) ||
6284 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
6285 cur_params.dot11MeshAwakeWindowDuration) ||
6286 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
6287 cur_params.plink_timeout) ||
6288 nla_put_u8(msg, NL80211_MESHCONF_CONNECTED_TO_GATE,
6289 cur_params.dot11MeshConnectedToMeshGate))
6290 goto nla_put_failure;
6291 nla_nest_end(msg, pinfoattr);
6292 genlmsg_end(msg, hdr);
6293 return genlmsg_reply(msg, info);
6301 static const struct nla_policy
6302 nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
6303 [NL80211_MESHCONF_RETRY_TIMEOUT] =
6304 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6305 [NL80211_MESHCONF_CONFIRM_TIMEOUT] =
6306 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6307 [NL80211_MESHCONF_HOLDING_TIMEOUT] =
6308 NLA_POLICY_RANGE(NLA_U16, 1, 255),
6309 [NL80211_MESHCONF_MAX_PEER_LINKS] =
6310 NLA_POLICY_RANGE(NLA_U16, 0, 255),
6311 [NL80211_MESHCONF_MAX_RETRIES] = NLA_POLICY_MAX(NLA_U8, 16),
6312 [NL80211_MESHCONF_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
6313 [NL80211_MESHCONF_ELEMENT_TTL] = NLA_POLICY_MIN(NLA_U8, 1),
6314 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = NLA_POLICY_MAX(NLA_U8, 1),
6315 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] =
6316 NLA_POLICY_RANGE(NLA_U32, 1, 255),
6317 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
6318 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
6319 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = NLA_POLICY_MIN(NLA_U16, 1),
6320 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
6321 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] =
6322 NLA_POLICY_MIN(NLA_U16, 1),
6323 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] =
6324 NLA_POLICY_MIN(NLA_U16, 1),
6325 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] =
6326 NLA_POLICY_MIN(NLA_U16, 1),
6327 [NL80211_MESHCONF_HWMP_ROOTMODE] = NLA_POLICY_MAX(NLA_U8, 4),
6328 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] =
6329 NLA_POLICY_MIN(NLA_U16, 1),
6330 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = NLA_POLICY_MAX(NLA_U8, 1),
6331 [NL80211_MESHCONF_FORWARDING] = NLA_POLICY_MAX(NLA_U8, 1),
6332 [NL80211_MESHCONF_RSSI_THRESHOLD] =
6333 NLA_POLICY_RANGE(NLA_S32, -255, 0),
6334 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
6335 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
6336 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] =
6337 NLA_POLICY_MIN(NLA_U16, 1),
6338 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] =
6339 NLA_POLICY_MIN(NLA_U16, 1),
6340 [NL80211_MESHCONF_POWER_MODE] =
6341 NLA_POLICY_RANGE(NLA_U32,
6342 NL80211_MESH_POWER_ACTIVE,
6343 NL80211_MESH_POWER_MAX),
6344 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
6345 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
6346 [NL80211_MESHCONF_CONNECTED_TO_GATE] = NLA_POLICY_RANGE(NLA_U8, 0, 1),
6349 static const struct nla_policy
6350 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
6351 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
6352 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
6353 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
6354 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
6355 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
6356 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
6357 [NL80211_MESH_SETUP_IE] =
6358 NLA_POLICY_VALIDATE_FN(NLA_BINARY, validate_ie_attr,
6359 IEEE80211_MAX_DATA_LEN),
6360 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
6363 static int nl80211_parse_mesh_config(struct genl_info *info,
6364 struct mesh_config *cfg,
6367 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
6371 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \
6374 cfg->param = fn(tb[attr]); \
6375 mask |= BIT((attr) - 1); \
6379 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
6381 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
6382 info->attrs[NL80211_ATTR_MESH_CONFIG],
6383 nl80211_meshconf_params_policy, info->extack))
6386 /* This makes sure that there aren't more than 32 mesh config
6387 * parameters (otherwise our bitfield scheme would not work.) */
6388 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
6390 /* Fill in the params struct */
6391 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, mask,
6392 NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
6393 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, mask,
6394 NL80211_MESHCONF_CONFIRM_TIMEOUT,
6396 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, mask,
6397 NL80211_MESHCONF_HOLDING_TIMEOUT,
6399 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, mask,
6400 NL80211_MESHCONF_MAX_PEER_LINKS,
6402 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, mask,
6403 NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
6404 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, mask,
6405 NL80211_MESHCONF_TTL, nla_get_u8);
6406 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, mask,
6407 NL80211_MESHCONF_ELEMENT_TTL, nla_get_u8);
6408 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, mask,
6409 NL80211_MESHCONF_AUTO_OPEN_PLINKS,
6411 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
6413 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
6415 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, mask,
6416 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
6418 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, mask,
6419 NL80211_MESHCONF_PATH_REFRESH_TIME,
6421 if (mask & BIT(NL80211_MESHCONF_PATH_REFRESH_TIME) &&
6422 (cfg->path_refresh_time < 1 || cfg->path_refresh_time > 65535))
6424 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, mask,
6425 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
6427 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
6429 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
6431 if (mask & BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT) &&
6432 (cfg->dot11MeshHWMPactivePathTimeout < 1 ||
6433 cfg->dot11MeshHWMPactivePathTimeout > 65535))
6435 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval, mask,
6436 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
6438 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval, mask,
6439 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
6441 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
6442 dot11MeshHWMPnetDiameterTraversalTime, mask,
6443 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
6445 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, mask,
6446 NL80211_MESHCONF_HWMP_ROOTMODE, nla_get_u8);
6447 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, mask,
6448 NL80211_MESHCONF_HWMP_RANN_INTERVAL,
6450 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshGateAnnouncementProtocol,
6451 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
6453 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, mask,
6454 NL80211_MESHCONF_FORWARDING, nla_get_u8);
6455 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, mask,
6456 NL80211_MESHCONF_RSSI_THRESHOLD,
6458 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConnectedToMeshGate, mask,
6459 NL80211_MESHCONF_CONNECTED_TO_GATE,
6462 * Check HT operation mode based on
6463 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
6465 if (tb[NL80211_MESHCONF_HT_OPMODE]) {
6466 ht_opmode = nla_get_u16(tb[NL80211_MESHCONF_HT_OPMODE]);
6468 if (ht_opmode & ~(IEEE80211_HT_OP_MODE_PROTECTION |
6469 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT |
6470 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT))
6473 /* NON_HT_STA bit is reserved, but some programs set it */
6474 ht_opmode &= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT;
6476 cfg->ht_opmode = ht_opmode;
6477 mask |= (1 << (NL80211_MESHCONF_HT_OPMODE - 1));
6479 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
6480 dot11MeshHWMPactivePathToRootTimeout, mask,
6481 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
6483 if (mask & BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT) &&
6484 (cfg->dot11MeshHWMPactivePathToRootTimeout < 1 ||
6485 cfg->dot11MeshHWMPactivePathToRootTimeout > 65535))
6487 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, mask,
6488 NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
6490 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPconfirmationInterval,
6492 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
6494 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode, mask,
6495 NL80211_MESHCONF_POWER_MODE, nla_get_u32);
6496 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration, mask,
6497 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
6498 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, mask,
6499 NL80211_MESHCONF_PLINK_TIMEOUT, nla_get_u32);
6505 #undef FILL_IN_MESH_PARAM_IF_SET
6508 static int nl80211_parse_mesh_setup(struct genl_info *info,
6509 struct mesh_setup *setup)
6511 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6512 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
6514 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
6516 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
6517 info->attrs[NL80211_ATTR_MESH_SETUP],
6518 nl80211_mesh_setup_params_policy, info->extack))
6521 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
6522 setup->sync_method =
6523 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
6524 IEEE80211_SYNC_METHOD_VENDOR :
6525 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
6527 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
6528 setup->path_sel_proto =
6529 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
6530 IEEE80211_PATH_PROTOCOL_VENDOR :
6531 IEEE80211_PATH_PROTOCOL_HWMP;
6533 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
6534 setup->path_metric =
6535 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
6536 IEEE80211_PATH_METRIC_VENDOR :
6537 IEEE80211_PATH_METRIC_AIRTIME;
6539 if (tb[NL80211_MESH_SETUP_IE]) {
6540 struct nlattr *ieattr =
6541 tb[NL80211_MESH_SETUP_IE];
6542 setup->ie = nla_data(ieattr);
6543 setup->ie_len = nla_len(ieattr);
6545 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
6546 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
6548 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
6549 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
6550 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
6551 if (setup->is_secure)
6552 setup->user_mpm = true;
6554 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
6555 if (!setup->user_mpm)
6558 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
6564 static int nl80211_update_mesh_config(struct sk_buff *skb,
6565 struct genl_info *info)
6567 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6568 struct net_device *dev = info->user_ptr[1];
6569 struct wireless_dev *wdev = dev->ieee80211_ptr;
6570 struct mesh_config cfg;
6574 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
6577 if (!rdev->ops->update_mesh_config)
6580 err = nl80211_parse_mesh_config(info, &cfg, &mask);
6585 if (!wdev->mesh_id_len)
6589 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
6596 static int nl80211_put_regdom(const struct ieee80211_regdomain *regdom,
6597 struct sk_buff *msg)
6599 struct nlattr *nl_reg_rules;
6602 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
6603 (regdom->dfs_region &&
6604 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
6605 goto nla_put_failure;
6607 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
6609 goto nla_put_failure;
6611 for (i = 0; i < regdom->n_reg_rules; i++) {
6612 struct nlattr *nl_reg_rule;
6613 const struct ieee80211_reg_rule *reg_rule;
6614 const struct ieee80211_freq_range *freq_range;
6615 const struct ieee80211_power_rule *power_rule;
6616 unsigned int max_bandwidth_khz;
6618 reg_rule = ®dom->reg_rules[i];
6619 freq_range = ®_rule->freq_range;
6620 power_rule = ®_rule->power_rule;
6622 nl_reg_rule = nla_nest_start(msg, i);
6624 goto nla_put_failure;
6626 max_bandwidth_khz = freq_range->max_bandwidth_khz;
6627 if (!max_bandwidth_khz)
6628 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
6631 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
6633 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
6634 freq_range->start_freq_khz) ||
6635 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
6636 freq_range->end_freq_khz) ||
6637 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
6638 max_bandwidth_khz) ||
6639 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
6640 power_rule->max_antenna_gain) ||
6641 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
6642 power_rule->max_eirp) ||
6643 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
6644 reg_rule->dfs_cac_ms))
6645 goto nla_put_failure;
6647 nla_nest_end(msg, nl_reg_rule);
6650 nla_nest_end(msg, nl_reg_rules);
6657 static int nl80211_get_reg_do(struct sk_buff *skb, struct genl_info *info)
6659 const struct ieee80211_regdomain *regdom = NULL;
6660 struct cfg80211_registered_device *rdev;
6661 struct wiphy *wiphy = NULL;
6662 struct sk_buff *msg;
6665 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6669 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6670 NL80211_CMD_GET_REG);
6674 if (info->attrs[NL80211_ATTR_WIPHY]) {
6677 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
6680 return PTR_ERR(rdev);
6683 wiphy = &rdev->wiphy;
6684 self_managed = wiphy->regulatory_flags &
6685 REGULATORY_WIPHY_SELF_MANAGED;
6686 regdom = get_wiphy_regdom(wiphy);
6688 /* a self-managed-reg device must have a private regdom */
6689 if (WARN_ON(!regdom && self_managed)) {
6695 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6696 goto nla_put_failure;
6699 if (!wiphy && reg_last_request_cell_base() &&
6700 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6701 NL80211_USER_REG_HINT_CELL_BASE))
6702 goto nla_put_failure;
6707 regdom = rcu_dereference(cfg80211_regdomain);
6709 if (nl80211_put_regdom(regdom, msg))
6710 goto nla_put_failure_rcu;
6714 genlmsg_end(msg, hdr);
6715 return genlmsg_reply(msg, info);
6717 nla_put_failure_rcu:
6725 static int nl80211_send_regdom(struct sk_buff *msg, struct netlink_callback *cb,
6726 u32 seq, int flags, struct wiphy *wiphy,
6727 const struct ieee80211_regdomain *regdom)
6729 void *hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6730 NL80211_CMD_GET_REG);
6735 genl_dump_check_consistent(cb, hdr);
6737 if (nl80211_put_regdom(regdom, msg))
6738 goto nla_put_failure;
6740 if (!wiphy && reg_last_request_cell_base() &&
6741 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
6742 NL80211_USER_REG_HINT_CELL_BASE))
6743 goto nla_put_failure;
6746 nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
6747 goto nla_put_failure;
6749 if (wiphy && wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
6750 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
6751 goto nla_put_failure;
6753 genlmsg_end(msg, hdr);
6757 genlmsg_cancel(msg, hdr);
6761 static int nl80211_get_reg_dump(struct sk_buff *skb,
6762 struct netlink_callback *cb)
6764 const struct ieee80211_regdomain *regdom = NULL;
6765 struct cfg80211_registered_device *rdev;
6766 int err, reg_idx, start = cb->args[2];
6770 if (cfg80211_regdomain && start == 0) {
6771 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6773 rtnl_dereference(cfg80211_regdomain));
6778 /* the global regdom is idx 0 */
6780 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
6781 regdom = get_wiphy_regdom(&rdev->wiphy);
6785 if (++reg_idx <= start)
6788 err = nl80211_send_regdom(skb, cb, cb->nlh->nlmsg_seq,
6789 NLM_F_MULTI, &rdev->wiphy, regdom);
6796 cb->args[2] = reg_idx;
6803 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
6804 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
6805 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
6806 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
6807 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
6808 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
6809 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
6810 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
6811 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
6814 static int parse_reg_rule(struct nlattr *tb[],
6815 struct ieee80211_reg_rule *reg_rule)
6817 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
6818 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
6820 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
6822 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
6824 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
6826 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
6828 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
6831 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
6833 freq_range->start_freq_khz =
6834 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
6835 freq_range->end_freq_khz =
6836 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
6837 freq_range->max_bandwidth_khz =
6838 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
6840 power_rule->max_eirp =
6841 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
6843 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
6844 power_rule->max_antenna_gain =
6845 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
6847 if (tb[NL80211_ATTR_DFS_CAC_TIME])
6848 reg_rule->dfs_cac_ms =
6849 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
6854 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
6856 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
6857 struct nlattr *nl_reg_rule;
6859 int rem_reg_rules, r;
6860 u32 num_rules = 0, rule_idx = 0, size_of_regd;
6861 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
6862 struct ieee80211_regdomain *rd;
6864 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
6867 if (!info->attrs[NL80211_ATTR_REG_RULES])
6870 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
6872 if (info->attrs[NL80211_ATTR_DFS_REGION])
6873 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
6875 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
6878 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
6882 if (!reg_is_valid_request(alpha2))
6885 size_of_regd = sizeof(struct ieee80211_regdomain) +
6886 num_rules * sizeof(struct ieee80211_reg_rule);
6888 rd = kzalloc(size_of_regd, GFP_KERNEL);
6892 rd->n_reg_rules = num_rules;
6893 rd->alpha2[0] = alpha2[0];
6894 rd->alpha2[1] = alpha2[1];
6897 * Disable DFS master mode if the DFS region was
6898 * not supported or known on this kernel.
6900 if (reg_supported_dfs_region(dfs_region))
6901 rd->dfs_region = dfs_region;
6903 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
6905 r = nla_parse_nested(tb, NL80211_REG_RULE_ATTR_MAX,
6906 nl_reg_rule, reg_rule_policy,
6910 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
6916 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
6922 /* set_regdom takes ownership of rd */
6923 return set_regdom(rd, REGD_SOURCE_CRDA);
6928 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
6930 static int validate_scan_freqs(struct nlattr *freqs)
6932 struct nlattr *attr1, *attr2;
6933 int n_channels = 0, tmp1, tmp2;
6935 nla_for_each_nested(attr1, freqs, tmp1)
6936 if (nla_len(attr1) != sizeof(u32))
6939 nla_for_each_nested(attr1, freqs, tmp1) {
6942 * Some hardware has a limited channel list for
6943 * scanning, and it is pretty much nonsensical
6944 * to scan for a channel twice, so disallow that
6945 * and don't require drivers to check that the
6946 * channel list they get isn't longer than what
6947 * they can scan, as long as they can scan all
6948 * the channels they registered at once.
6950 nla_for_each_nested(attr2, freqs, tmp2)
6951 if (attr1 != attr2 &&
6952 nla_get_u32(attr1) == nla_get_u32(attr2))
6959 static bool is_band_valid(struct wiphy *wiphy, enum nl80211_band b)
6961 return b < NUM_NL80211_BANDS && wiphy->bands[b];
6964 static int parse_bss_select(struct nlattr *nla, struct wiphy *wiphy,
6965 struct cfg80211_bss_selection *bss_select)
6967 struct nlattr *attr[NL80211_BSS_SELECT_ATTR_MAX + 1];
6968 struct nlattr *nest;
6973 /* only process one nested attribute */
6974 nest = nla_data(nla);
6975 if (!nla_ok(nest, nla_len(nest)))
6978 err = nla_parse_nested(attr, NL80211_BSS_SELECT_ATTR_MAX, nest,
6979 nl80211_bss_select_policy, NULL);
6983 /* only one attribute may be given */
6984 for (i = 0; i <= NL80211_BSS_SELECT_ATTR_MAX; i++) {
6992 bss_select->behaviour = __NL80211_BSS_SELECT_ATTR_INVALID;
6994 if (attr[NL80211_BSS_SELECT_ATTR_RSSI])
6995 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI;
6997 if (attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]) {
6998 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_BAND_PREF;
6999 bss_select->param.band_pref =
7000 nla_get_u32(attr[NL80211_BSS_SELECT_ATTR_BAND_PREF]);
7001 if (!is_band_valid(wiphy, bss_select->param.band_pref))
7005 if (attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]) {
7006 struct nl80211_bss_select_rssi_adjust *adj_param;
7008 adj_param = nla_data(attr[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST]);
7009 bss_select->behaviour = NL80211_BSS_SELECT_ATTR_RSSI_ADJUST;
7010 bss_select->param.adjust.band = adj_param->band;
7011 bss_select->param.adjust.delta = adj_param->delta;
7012 if (!is_band_valid(wiphy, bss_select->param.adjust.band))
7016 /* user-space did not provide behaviour attribute */
7017 if (bss_select->behaviour == __NL80211_BSS_SELECT_ATTR_INVALID)
7020 if (!(wiphy->bss_select_support & BIT(bss_select->behaviour)))
7026 int nl80211_parse_random_mac(struct nlattr **attrs,
7027 u8 *mac_addr, u8 *mac_addr_mask)
7031 if (!attrs[NL80211_ATTR_MAC] && !attrs[NL80211_ATTR_MAC_MASK]) {
7032 eth_zero_addr(mac_addr);
7033 eth_zero_addr(mac_addr_mask);
7035 mac_addr_mask[0] = 0x3;
7040 /* need both or none */
7041 if (!attrs[NL80211_ATTR_MAC] || !attrs[NL80211_ATTR_MAC_MASK])
7044 memcpy(mac_addr, nla_data(attrs[NL80211_ATTR_MAC]), ETH_ALEN);
7045 memcpy(mac_addr_mask, nla_data(attrs[NL80211_ATTR_MAC_MASK]), ETH_ALEN);
7047 /* don't allow or configure an mcast address */
7048 if (!is_multicast_ether_addr(mac_addr_mask) ||
7049 is_multicast_ether_addr(mac_addr))
7053 * allow users to pass a MAC address that has bits set outside
7054 * of the mask, but don't bother drivers with having to deal
7057 for (i = 0; i < ETH_ALEN; i++)
7058 mac_addr[i] &= mac_addr_mask[i];
7063 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev *wdev)
7065 ASSERT_WDEV_LOCK(wdev);
7067 if (!cfg80211_beaconing_iface_active(wdev))
7070 if (!(wdev->chandef.chan->flags & IEEE80211_CHAN_RADAR))
7073 return regulatory_pre_cac_allowed(wdev->wiphy);
7076 static bool nl80211_check_scan_feat(struct wiphy *wiphy, u32 flags, u32 flag,
7077 enum nl80211_ext_feature_index feat)
7079 if (!(flags & flag))
7081 if (wiphy_ext_feature_isset(wiphy, feat))
7087 nl80211_check_scan_flags(struct wiphy *wiphy, struct wireless_dev *wdev,
7088 void *request, struct nlattr **attrs,
7091 u8 *mac_addr, *mac_addr_mask;
7093 enum nl80211_feature_flags randomness_flag;
7095 if (!attrs[NL80211_ATTR_SCAN_FLAGS])
7098 if (is_sched_scan) {
7099 struct cfg80211_sched_scan_request *req = request;
7101 randomness_flag = wdev ?
7102 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR :
7103 NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
7104 flags = &req->flags;
7105 mac_addr = req->mac_addr;
7106 mac_addr_mask = req->mac_addr_mask;
7108 struct cfg80211_scan_request *req = request;
7110 randomness_flag = NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
7111 flags = &req->flags;
7112 mac_addr = req->mac_addr;
7113 mac_addr_mask = req->mac_addr_mask;
7116 *flags = nla_get_u32(attrs[NL80211_ATTR_SCAN_FLAGS]);
7118 if (((*flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
7119 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
7120 !nl80211_check_scan_feat(wiphy, *flags,
7121 NL80211_SCAN_FLAG_LOW_SPAN,
7122 NL80211_EXT_FEATURE_LOW_SPAN_SCAN) ||
7123 !nl80211_check_scan_feat(wiphy, *flags,
7124 NL80211_SCAN_FLAG_LOW_POWER,
7125 NL80211_EXT_FEATURE_LOW_POWER_SCAN) ||
7126 !nl80211_check_scan_feat(wiphy, *flags,
7127 NL80211_SCAN_FLAG_HIGH_ACCURACY,
7128 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN) ||
7129 !nl80211_check_scan_feat(wiphy, *flags,
7130 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME,
7131 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME) ||
7132 !nl80211_check_scan_feat(wiphy, *flags,
7133 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP,
7134 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP) ||
7135 !nl80211_check_scan_feat(wiphy, *flags,
7136 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION,
7137 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION) ||
7138 !nl80211_check_scan_feat(wiphy, *flags,
7139 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE,
7140 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE) ||
7141 !nl80211_check_scan_feat(wiphy, *flags,
7142 NL80211_SCAN_FLAG_RANDOM_SN,
7143 NL80211_EXT_FEATURE_SCAN_RANDOM_SN) ||
7144 !nl80211_check_scan_feat(wiphy, *flags,
7145 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT,
7146 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT))
7149 if (*flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
7152 if (!(wiphy->features & randomness_flag) ||
7153 (wdev && wdev->current_bss))
7156 err = nl80211_parse_random_mac(attrs, mac_addr, mac_addr_mask);
7164 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
7166 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7167 struct wireless_dev *wdev = info->user_ptr[1];
7168 struct cfg80211_scan_request *request;
7169 struct nlattr *attr;
7170 struct wiphy *wiphy;
7171 int err, tmp, n_ssids = 0, n_channels, i;
7174 wiphy = &rdev->wiphy;
7176 if (wdev->iftype == NL80211_IFTYPE_NAN)
7179 if (!rdev->ops->scan)
7182 if (rdev->scan_req || rdev->scan_msg) {
7187 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7188 n_channels = validate_scan_freqs(
7189 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
7195 n_channels = ieee80211_get_num_supported_channels(wiphy);
7198 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
7199 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
7202 if (n_ssids > wiphy->max_scan_ssids) {
7207 if (info->attrs[NL80211_ATTR_IE])
7208 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7212 if (ie_len > wiphy->max_scan_ie_len) {
7217 request = kzalloc(sizeof(*request)
7218 + sizeof(*request->ssids) * n_ssids
7219 + sizeof(*request->channels) * n_channels
7220 + ie_len, GFP_KERNEL);
7227 request->ssids = (void *)&request->channels[n_channels];
7228 request->n_ssids = n_ssids;
7231 request->ie = (void *)(request->ssids + n_ssids);
7233 request->ie = (void *)(request->channels + n_channels);
7237 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7238 /* user specified, bail out if channel not found */
7239 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
7240 struct ieee80211_channel *chan;
7242 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7249 /* ignore disabled channels */
7250 if (chan->flags & IEEE80211_CHAN_DISABLED)
7253 request->channels[i] = chan;
7257 enum nl80211_band band;
7260 for (band = 0; band < NUM_NL80211_BANDS; band++) {
7263 if (!wiphy->bands[band])
7265 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7266 struct ieee80211_channel *chan;
7268 chan = &wiphy->bands[band]->channels[j];
7270 if (chan->flags & IEEE80211_CHAN_DISABLED)
7273 request->channels[i] = chan;
7284 request->n_channels = i;
7287 if (!cfg80211_off_channel_oper_allowed(wdev)) {
7288 struct ieee80211_channel *chan;
7290 if (request->n_channels != 1) {
7296 chan = request->channels[0];
7297 if (chan->center_freq != wdev->chandef.chan->center_freq) {
7307 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
7308 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
7312 request->ssids[i].ssid_len = nla_len(attr);
7313 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
7318 if (info->attrs[NL80211_ATTR_IE]) {
7319 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7320 memcpy((void *)request->ie,
7321 nla_data(info->attrs[NL80211_ATTR_IE]),
7325 for (i = 0; i < NUM_NL80211_BANDS; i++)
7326 if (wiphy->bands[i])
7328 (1 << wiphy->bands[i]->n_bitrates) - 1;
7330 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
7331 nla_for_each_nested(attr,
7332 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
7334 enum nl80211_band band = nla_type(attr);
7336 if (band < 0 || band >= NUM_NL80211_BANDS) {
7341 if (!wiphy->bands[band])
7344 err = ieee80211_get_ratemask(wiphy->bands[band],
7347 &request->rates[band]);
7353 if (info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]) {
7354 if (!wiphy_ext_feature_isset(wiphy,
7355 NL80211_EXT_FEATURE_SET_SCAN_DWELL)) {
7361 nla_get_u16(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION]);
7362 request->duration_mandatory =
7363 nla_get_flag(info->attrs[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY]);
7366 err = nl80211_check_scan_flags(wiphy, wdev, request, info->attrs,
7372 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
7374 /* Initial implementation used NL80211_ATTR_MAC to set the specific
7375 * BSSID to scan for. This was problematic because that same attribute
7376 * was already used for another purpose (local random MAC address). The
7377 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
7378 * compatibility with older userspace components, also use the
7379 * NL80211_ATTR_MAC value here if it can be determined to be used for
7380 * the specific BSSID use case instead of the random MAC address
7381 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
7383 if (info->attrs[NL80211_ATTR_BSSID])
7384 memcpy(request->bssid,
7385 nla_data(info->attrs[NL80211_ATTR_BSSID]), ETH_ALEN);
7386 else if (!(request->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) &&
7387 info->attrs[NL80211_ATTR_MAC])
7388 memcpy(request->bssid, nla_data(info->attrs[NL80211_ATTR_MAC]),
7391 eth_broadcast_addr(request->bssid);
7393 request->wdev = wdev;
7394 request->wiphy = &rdev->wiphy;
7395 request->scan_start = jiffies;
7397 rdev->scan_req = request;
7398 err = rdev_scan(rdev, request);
7401 nl80211_send_scan_start(rdev, wdev);
7403 dev_hold(wdev->netdev);
7406 rdev->scan_req = NULL;
7414 static int nl80211_abort_scan(struct sk_buff *skb, struct genl_info *info)
7416 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7417 struct wireless_dev *wdev = info->user_ptr[1];
7419 if (!rdev->ops->abort_scan)
7425 if (!rdev->scan_req)
7428 rdev_abort_scan(rdev, wdev);
7433 nl80211_parse_sched_scan_plans(struct wiphy *wiphy, int n_plans,
7434 struct cfg80211_sched_scan_request *request,
7435 struct nlattr **attrs)
7437 int tmp, err, i = 0;
7438 struct nlattr *attr;
7440 if (!attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7444 * If scan plans are not specified,
7445 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
7446 * case one scan plan will be set with the specified scan
7447 * interval and infinite number of iterations.
7449 interval = nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
7453 request->scan_plans[0].interval =
7454 DIV_ROUND_UP(interval, MSEC_PER_SEC);
7455 if (!request->scan_plans[0].interval)
7458 if (request->scan_plans[0].interval >
7459 wiphy->max_sched_scan_plan_interval)
7460 request->scan_plans[0].interval =
7461 wiphy->max_sched_scan_plan_interval;
7466 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp) {
7467 struct nlattr *plan[NL80211_SCHED_SCAN_PLAN_MAX + 1];
7469 if (WARN_ON(i >= n_plans))
7472 err = nla_parse_nested(plan, NL80211_SCHED_SCAN_PLAN_MAX,
7473 attr, nl80211_plan_policy, NULL);
7477 if (!plan[NL80211_SCHED_SCAN_PLAN_INTERVAL])
7480 request->scan_plans[i].interval =
7481 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_INTERVAL]);
7482 if (!request->scan_plans[i].interval ||
7483 request->scan_plans[i].interval >
7484 wiphy->max_sched_scan_plan_interval)
7487 if (plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]) {
7488 request->scan_plans[i].iterations =
7489 nla_get_u32(plan[NL80211_SCHED_SCAN_PLAN_ITERATIONS]);
7490 if (!request->scan_plans[i].iterations ||
7491 (request->scan_plans[i].iterations >
7492 wiphy->max_sched_scan_plan_iterations))
7494 } else if (i < n_plans - 1) {
7496 * All scan plans but the last one must specify
7497 * a finite number of iterations
7506 * The last scan plan must not specify the number of
7507 * iterations, it is supposed to run infinitely
7509 if (request->scan_plans[n_plans - 1].iterations)
7515 static struct cfg80211_sched_scan_request *
7516 nl80211_parse_sched_scan(struct wiphy *wiphy, struct wireless_dev *wdev,
7517 struct nlattr **attrs, int max_match_sets)
7519 struct cfg80211_sched_scan_request *request;
7520 struct nlattr *attr;
7521 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i, n_plans = 0;
7522 enum nl80211_band band;
7524 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
7525 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
7527 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7528 n_channels = validate_scan_freqs(
7529 attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
7531 return ERR_PTR(-EINVAL);
7533 n_channels = ieee80211_get_num_supported_channels(wiphy);
7536 if (attrs[NL80211_ATTR_SCAN_SSIDS])
7537 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
7541 if (n_ssids > wiphy->max_sched_scan_ssids)
7542 return ERR_PTR(-EINVAL);
7545 * First, count the number of 'real' matchsets. Due to an issue with
7546 * the old implementation, matchsets containing only the RSSI attribute
7547 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
7548 * RSSI for all matchsets, rather than their own matchset for reporting
7549 * all APs with a strong RSSI. This is needed to be compatible with
7550 * older userspace that treated a matchset with only the RSSI as the
7551 * global RSSI for all other matchsets - if there are other matchsets.
7553 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
7554 nla_for_each_nested(attr,
7555 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
7557 struct nlattr *rssi;
7559 err = nla_parse_nested(tb,
7560 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
7561 attr, nl80211_match_policy,
7564 return ERR_PTR(err);
7566 /* SSID and BSSID are mutually exclusive */
7567 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] &&
7568 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID])
7569 return ERR_PTR(-EINVAL);
7571 /* add other standalone attributes here */
7572 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID] ||
7573 tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID]) {
7577 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7579 default_match_rssi = nla_get_s32(rssi);
7583 /* However, if there's no other matchset, add the RSSI one */
7584 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
7587 if (n_match_sets > max_match_sets)
7588 return ERR_PTR(-EINVAL);
7590 if (attrs[NL80211_ATTR_IE])
7591 ie_len = nla_len(attrs[NL80211_ATTR_IE]);
7595 if (ie_len > wiphy->max_sched_scan_ie_len)
7596 return ERR_PTR(-EINVAL);
7598 if (attrs[NL80211_ATTR_SCHED_SCAN_PLANS]) {
7600 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
7601 * each scan plan already specifies its own interval
7603 if (attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7604 return ERR_PTR(-EINVAL);
7606 nla_for_each_nested(attr,
7607 attrs[NL80211_ATTR_SCHED_SCAN_PLANS], tmp)
7611 * The scan interval attribute is kept for backward
7612 * compatibility. If no scan plans are specified and sched scan
7613 * interval is specified, one scan plan will be set with this
7614 * scan interval and infinite number of iterations.
7616 if (!attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
7617 return ERR_PTR(-EINVAL);
7622 if (!n_plans || n_plans > wiphy->max_sched_scan_plans)
7623 return ERR_PTR(-EINVAL);
7625 if (!wiphy_ext_feature_isset(
7626 wiphy, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI) &&
7627 (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI] ||
7628 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]))
7629 return ERR_PTR(-EINVAL);
7631 request = kzalloc(sizeof(*request)
7632 + sizeof(*request->ssids) * n_ssids
7633 + sizeof(*request->match_sets) * n_match_sets
7634 + sizeof(*request->scan_plans) * n_plans
7635 + sizeof(*request->channels) * n_channels
7636 + ie_len, GFP_KERNEL);
7638 return ERR_PTR(-ENOMEM);
7641 request->ssids = (void *)&request->channels[n_channels];
7642 request->n_ssids = n_ssids;
7645 request->ie = (void *)(request->ssids + n_ssids);
7647 request->ie = (void *)(request->channels + n_channels);
7652 request->match_sets = (void *)(request->ie + ie_len);
7654 request->match_sets =
7655 (void *)(request->ssids + n_ssids);
7657 request->match_sets =
7658 (void *)(request->channels + n_channels);
7660 request->n_match_sets = n_match_sets;
7663 request->scan_plans = (void *)(request->match_sets +
7665 else if (request->ie)
7666 request->scan_plans = (void *)(request->ie + ie_len);
7668 request->scan_plans = (void *)(request->ssids + n_ssids);
7670 request->scan_plans = (void *)(request->channels + n_channels);
7672 request->n_scan_plans = n_plans;
7675 if (attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
7676 /* user specified, bail out if channel not found */
7677 nla_for_each_nested(attr,
7678 attrs[NL80211_ATTR_SCAN_FREQUENCIES],
7680 struct ieee80211_channel *chan;
7682 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
7689 /* ignore disabled channels */
7690 if (chan->flags & IEEE80211_CHAN_DISABLED)
7693 request->channels[i] = chan;
7698 for (band = 0; band < NUM_NL80211_BANDS; band++) {
7701 if (!wiphy->bands[band])
7703 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
7704 struct ieee80211_channel *chan;
7706 chan = &wiphy->bands[band]->channels[j];
7708 if (chan->flags & IEEE80211_CHAN_DISABLED)
7711 request->channels[i] = chan;
7722 request->n_channels = i;
7726 nla_for_each_nested(attr, attrs[NL80211_ATTR_SCAN_SSIDS],
7728 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
7732 request->ssids[i].ssid_len = nla_len(attr);
7733 memcpy(request->ssids[i].ssid, nla_data(attr),
7740 if (attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
7741 nla_for_each_nested(attr,
7742 attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
7744 struct nlattr *ssid, *bssid, *rssi;
7746 err = nla_parse_nested(tb,
7747 NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
7748 attr, nl80211_match_policy,
7752 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
7753 bssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID];
7754 if (ssid || bssid) {
7755 if (WARN_ON(i >= n_match_sets)) {
7756 /* this indicates a programming error,
7757 * the loop above should have verified
7765 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
7769 memcpy(request->match_sets[i].ssid.ssid,
7770 nla_data(ssid), nla_len(ssid));
7771 request->match_sets[i].ssid.ssid_len =
7775 if (nla_len(bssid) != ETH_ALEN) {
7779 memcpy(request->match_sets[i].bssid,
7780 nla_data(bssid), ETH_ALEN);
7783 /* special attribute - old implementation w/a */
7784 request->match_sets[i].rssi_thold =
7786 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
7788 request->match_sets[i].rssi_thold =
7794 /* there was no other matchset, so the RSSI one is alone */
7795 if (i == 0 && n_match_sets)
7796 request->match_sets[0].rssi_thold = default_match_rssi;
7798 request->min_rssi_thold = INT_MAX;
7799 for (i = 0; i < n_match_sets; i++)
7800 request->min_rssi_thold =
7801 min(request->match_sets[i].rssi_thold,
7802 request->min_rssi_thold);
7804 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
7808 request->ie_len = ie_len;
7809 memcpy((void *)request->ie,
7810 nla_data(attrs[NL80211_ATTR_IE]),
7814 err = nl80211_check_scan_flags(wiphy, wdev, request, attrs, true);
7818 if (attrs[NL80211_ATTR_SCHED_SCAN_DELAY])
7820 nla_get_u32(attrs[NL80211_ATTR_SCHED_SCAN_DELAY]);
7822 if (attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]) {
7823 request->relative_rssi = nla_get_s8(
7824 attrs[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI]);
7825 request->relative_rssi_set = true;
7828 if (request->relative_rssi_set &&
7829 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]) {
7830 struct nl80211_bss_select_rssi_adjust *rssi_adjust;
7832 rssi_adjust = nla_data(
7833 attrs[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST]);
7834 request->rssi_adjust.band = rssi_adjust->band;
7835 request->rssi_adjust.delta = rssi_adjust->delta;
7836 if (!is_band_valid(wiphy, request->rssi_adjust.band)) {
7842 err = nl80211_parse_sched_scan_plans(wiphy, n_plans, request, attrs);
7846 request->scan_start = jiffies;
7852 return ERR_PTR(err);
7855 static int nl80211_start_sched_scan(struct sk_buff *skb,
7856 struct genl_info *info)
7858 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7859 struct net_device *dev = info->user_ptr[1];
7860 struct wireless_dev *wdev = dev->ieee80211_ptr;
7861 struct cfg80211_sched_scan_request *sched_scan_req;
7865 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_start)
7868 want_multi = info->attrs[NL80211_ATTR_SCHED_SCAN_MULTI];
7869 err = cfg80211_sched_scan_req_possible(rdev, want_multi);
7873 sched_scan_req = nl80211_parse_sched_scan(&rdev->wiphy, wdev,
7875 rdev->wiphy.max_match_sets);
7877 err = PTR_ERR_OR_ZERO(sched_scan_req);
7881 /* leave request id zero for legacy request
7882 * or if driver does not support multi-scheduled scan
7884 if (want_multi && rdev->wiphy.max_sched_scan_reqs > 1) {
7885 while (!sched_scan_req->reqid)
7886 sched_scan_req->reqid = cfg80211_assign_cookie(rdev);
7889 err = rdev_sched_scan_start(rdev, dev, sched_scan_req);
7893 sched_scan_req->dev = dev;
7894 sched_scan_req->wiphy = &rdev->wiphy;
7896 if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
7897 sched_scan_req->owner_nlportid = info->snd_portid;
7899 cfg80211_add_sched_scan_req(rdev, sched_scan_req);
7901 nl80211_send_sched_scan(sched_scan_req, NL80211_CMD_START_SCHED_SCAN);
7905 kfree(sched_scan_req);
7910 static int nl80211_stop_sched_scan(struct sk_buff *skb,
7911 struct genl_info *info)
7913 struct cfg80211_sched_scan_request *req;
7914 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7917 if (!rdev->wiphy.max_sched_scan_reqs || !rdev->ops->sched_scan_stop)
7920 if (info->attrs[NL80211_ATTR_COOKIE]) {
7921 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7922 return __cfg80211_stop_sched_scan(rdev, cookie, false);
7925 req = list_first_or_null_rcu(&rdev->sched_scan_req_list,
7926 struct cfg80211_sched_scan_request,
7928 if (!req || req->reqid ||
7929 (req->owner_nlportid &&
7930 req->owner_nlportid != info->snd_portid))
7933 return cfg80211_stop_sched_scan_req(rdev, req, false);
7936 static int nl80211_start_radar_detection(struct sk_buff *skb,
7937 struct genl_info *info)
7939 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7940 struct net_device *dev = info->user_ptr[1];
7941 struct wireless_dev *wdev = dev->ieee80211_ptr;
7942 struct wiphy *wiphy = wdev->wiphy;
7943 struct cfg80211_chan_def chandef;
7944 enum nl80211_dfs_regions dfs_region;
7945 unsigned int cac_time_ms;
7948 dfs_region = reg_get_dfs_region(wiphy);
7949 if (dfs_region == NL80211_DFS_UNSET)
7952 err = nl80211_parse_chandef(rdev, info, &chandef);
7956 if (netif_carrier_ok(dev))
7959 if (wdev->cac_started)
7962 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
7969 if (!cfg80211_chandef_dfs_usable(wiphy, &chandef))
7972 /* CAC start is offloaded to HW and can't be started manually */
7973 if (wiphy_ext_feature_isset(wiphy, NL80211_EXT_FEATURE_DFS_OFFLOAD))
7976 if (!rdev->ops->start_radar_detection)
7979 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
7980 if (WARN_ON(!cac_time_ms))
7981 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
7983 err = rdev_start_radar_detection(rdev, dev, &chandef, cac_time_ms);
7985 wdev->chandef = chandef;
7986 wdev->cac_started = true;
7987 wdev->cac_start_time = jiffies;
7988 wdev->cac_time_ms = cac_time_ms;
7993 static int nl80211_notify_radar_detection(struct sk_buff *skb,
7994 struct genl_info *info)
7996 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7997 struct net_device *dev = info->user_ptr[1];
7998 struct wireless_dev *wdev = dev->ieee80211_ptr;
7999 struct wiphy *wiphy = wdev->wiphy;
8000 struct cfg80211_chan_def chandef;
8001 enum nl80211_dfs_regions dfs_region;
8004 dfs_region = reg_get_dfs_region(wiphy);
8005 if (dfs_region == NL80211_DFS_UNSET) {
8006 GENL_SET_ERR_MSG(info,
8007 "DFS Region is not set. Unexpected Radar indication");
8011 err = nl80211_parse_chandef(rdev, info, &chandef);
8013 GENL_SET_ERR_MSG(info, "Unable to extract chandef info");
8017 err = cfg80211_chandef_dfs_required(wiphy, &chandef, wdev->iftype);
8019 GENL_SET_ERR_MSG(info, "chandef is invalid");
8024 GENL_SET_ERR_MSG(info,
8025 "Unexpected Radar indication for chandef/iftype");
8029 /* Do not process this notification if radar is already detected
8030 * by kernel on this channel, and return success.
8032 if (chandef.chan->dfs_state == NL80211_DFS_UNAVAILABLE)
8035 cfg80211_set_dfs_state(wiphy, &chandef, NL80211_DFS_UNAVAILABLE);
8037 cfg80211_sched_dfs_chan_update(rdev);
8039 memcpy(&rdev->radar_chandef, &chandef, sizeof(chandef));
8041 /* Propagate this notification to other radios as well */
8042 queue_work(cfg80211_wq, &rdev->propagate_radar_detect_wk);
8047 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
8049 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8050 struct net_device *dev = info->user_ptr[1];
8051 struct wireless_dev *wdev = dev->ieee80211_ptr;
8052 struct cfg80211_csa_settings params;
8053 /* csa_attrs is defined static to avoid waste of stack size - this
8054 * function is called under RTNL lock, so this should not be a problem.
8056 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
8058 bool need_new_beacon = false;
8059 bool need_handle_dfs_flag = true;
8063 if (!rdev->ops->channel_switch ||
8064 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
8067 switch (dev->ieee80211_ptr->iftype) {
8068 case NL80211_IFTYPE_AP:
8069 case NL80211_IFTYPE_P2P_GO:
8070 need_new_beacon = true;
8071 /* For all modes except AP the handle_dfs flag needs to be
8072 * supplied to tell the kernel that userspace will handle radar
8073 * events when they happen. Otherwise a switch to a channel
8074 * requiring DFS will be rejected.
8076 need_handle_dfs_flag = false;
8078 /* useless if AP is not running */
8079 if (!wdev->beacon_interval)
8082 case NL80211_IFTYPE_ADHOC:
8083 if (!wdev->ssid_len)
8086 case NL80211_IFTYPE_MESH_POINT:
8087 if (!wdev->mesh_id_len)
8094 memset(¶ms, 0, sizeof(params));
8095 params.beacon_csa.ftm_responder = -1;
8097 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
8098 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
8101 /* only important for AP, IBSS and mesh create IEs internally */
8102 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
8105 /* Even though the attribute is u32, the specification says
8106 * u8, so let's make sure we don't overflow.
8108 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
8112 params.count = cs_count;
8114 if (!need_new_beacon)
8117 err = nl80211_parse_beacon(rdev, info->attrs, ¶ms.beacon_after);
8121 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
8122 info->attrs[NL80211_ATTR_CSA_IES],
8123 nl80211_policy, info->extack);
8127 err = nl80211_parse_beacon(rdev, csa_attrs, ¶ms.beacon_csa);
8131 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
8134 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
8135 if (!len || (len % sizeof(u16)))
8138 params.n_counter_offsets_beacon = len / sizeof(u16);
8139 if (rdev->wiphy.max_num_csa_counters &&
8140 (params.n_counter_offsets_beacon >
8141 rdev->wiphy.max_num_csa_counters))
8144 params.counter_offsets_beacon =
8145 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
8147 /* sanity checks - counters should fit and be the same */
8148 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
8149 u16 offset = params.counter_offsets_beacon[i];
8151 if (offset >= params.beacon_csa.tail_len)
8154 if (params.beacon_csa.tail[offset] != params.count)
8158 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
8159 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
8160 if (!len || (len % sizeof(u16)))
8163 params.n_counter_offsets_presp = len / sizeof(u16);
8164 if (rdev->wiphy.max_num_csa_counters &&
8165 (params.n_counter_offsets_presp >
8166 rdev->wiphy.max_num_csa_counters))
8169 params.counter_offsets_presp =
8170 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
8172 /* sanity checks - counters should fit and be the same */
8173 for (i = 0; i < params.n_counter_offsets_presp; i++) {
8174 u16 offset = params.counter_offsets_presp[i];
8176 if (offset >= params.beacon_csa.probe_resp_len)
8179 if (params.beacon_csa.probe_resp[offset] !=
8186 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
8190 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, ¶ms.chandef,
8194 err = cfg80211_chandef_dfs_required(wdev->wiphy,
8201 params.radar_required = true;
8202 if (need_handle_dfs_flag &&
8203 !nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS])) {
8208 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
8209 params.block_tx = true;
8212 err = rdev_channel_switch(rdev, dev, ¶ms);
8218 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
8220 struct cfg80211_registered_device *rdev,
8221 struct wireless_dev *wdev,
8222 struct cfg80211_internal_bss *intbss)
8224 struct cfg80211_bss *res = &intbss->pub;
8225 const struct cfg80211_bss_ies *ies;
8229 ASSERT_WDEV_LOCK(wdev);
8231 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
8232 NL80211_CMD_NEW_SCAN_RESULTS);
8236 genl_dump_check_consistent(cb, hdr);
8238 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
8239 goto nla_put_failure;
8241 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
8242 goto nla_put_failure;
8243 if (nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
8245 goto nla_put_failure;
8247 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
8249 goto nla_put_failure;
8250 if ((!is_zero_ether_addr(res->bssid) &&
8251 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
8252 goto nla_put_failure;
8255 /* indicate whether we have probe response data or not */
8256 if (rcu_access_pointer(res->proberesp_ies) &&
8257 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
8258 goto fail_unlock_rcu;
8260 /* this pointer prefers to be pointed to probe response data
8261 * but is always valid
8263 ies = rcu_dereference(res->ies);
8265 if (nla_put_u64_64bit(msg, NL80211_BSS_TSF, ies->tsf,
8267 goto fail_unlock_rcu;
8268 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
8269 ies->len, ies->data))
8270 goto fail_unlock_rcu;
8273 /* and this pointer is always (unless driver didn't know) beacon data */
8274 ies = rcu_dereference(res->beacon_ies);
8275 if (ies && ies->from_beacon) {
8276 if (nla_put_u64_64bit(msg, NL80211_BSS_BEACON_TSF, ies->tsf,
8278 goto fail_unlock_rcu;
8279 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
8280 ies->len, ies->data))
8281 goto fail_unlock_rcu;
8285 if (res->beacon_interval &&
8286 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
8287 goto nla_put_failure;
8288 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
8289 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
8290 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
8291 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
8292 jiffies_to_msecs(jiffies - intbss->ts)))
8293 goto nla_put_failure;
8295 if (intbss->parent_tsf &&
8296 (nla_put_u64_64bit(msg, NL80211_BSS_PARENT_TSF,
8297 intbss->parent_tsf, NL80211_BSS_PAD) ||
8298 nla_put(msg, NL80211_BSS_PARENT_BSSID, ETH_ALEN,
8299 intbss->parent_bssid)))
8300 goto nla_put_failure;
8302 if (intbss->ts_boottime &&
8303 nla_put_u64_64bit(msg, NL80211_BSS_LAST_SEEN_BOOTTIME,
8304 intbss->ts_boottime, NL80211_BSS_PAD))
8305 goto nla_put_failure;
8307 if (!nl80211_put_signal(msg, intbss->pub.chains,
8308 intbss->pub.chain_signal,
8309 NL80211_BSS_CHAIN_SIGNAL))
8310 goto nla_put_failure;
8312 switch (rdev->wiphy.signal_type) {
8313 case CFG80211_SIGNAL_TYPE_MBM:
8314 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
8315 goto nla_put_failure;
8317 case CFG80211_SIGNAL_TYPE_UNSPEC:
8318 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
8319 goto nla_put_failure;
8325 switch (wdev->iftype) {
8326 case NL80211_IFTYPE_P2P_CLIENT:
8327 case NL80211_IFTYPE_STATION:
8328 if (intbss == wdev->current_bss &&
8329 nla_put_u32(msg, NL80211_BSS_STATUS,
8330 NL80211_BSS_STATUS_ASSOCIATED))
8331 goto nla_put_failure;
8333 case NL80211_IFTYPE_ADHOC:
8334 if (intbss == wdev->current_bss &&
8335 nla_put_u32(msg, NL80211_BSS_STATUS,
8336 NL80211_BSS_STATUS_IBSS_JOINED))
8337 goto nla_put_failure;
8343 nla_nest_end(msg, bss);
8345 genlmsg_end(msg, hdr);
8351 genlmsg_cancel(msg, hdr);
8355 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
8357 struct cfg80211_registered_device *rdev;
8358 struct cfg80211_internal_bss *scan;
8359 struct wireless_dev *wdev;
8360 int start = cb->args[2], idx = 0;
8364 err = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
8371 spin_lock_bh(&rdev->bss_lock);
8374 * dump_scan will be called multiple times to break up the scan results
8375 * into multiple messages. It is unlikely that any more bss-es will be
8376 * expired after the first call, so only call only call this on the
8377 * first dump_scan invocation.
8380 cfg80211_bss_expire(rdev);
8382 cb->seq = rdev->bss_generation;
8384 list_for_each_entry(scan, &rdev->bss_list, list) {
8387 if (nl80211_send_bss(skb, cb,
8388 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8389 rdev, wdev, scan) < 0) {
8395 spin_unlock_bh(&rdev->bss_lock);
8404 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
8405 int flags, struct net_device *dev,
8406 bool allow_radio_stats,
8407 struct survey_info *survey)
8410 struct nlattr *infoattr;
8412 /* skip radio stats if userspace didn't request them */
8413 if (!survey->channel && !allow_radio_stats)
8416 hdr = nl80211hdr_put(msg, portid, seq, flags,
8417 NL80211_CMD_NEW_SURVEY_RESULTS);
8421 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
8422 goto nla_put_failure;
8424 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
8426 goto nla_put_failure;
8428 if (survey->channel &&
8429 nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
8430 survey->channel->center_freq))
8431 goto nla_put_failure;
8433 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
8434 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
8435 goto nla_put_failure;
8436 if ((survey->filled & SURVEY_INFO_IN_USE) &&
8437 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
8438 goto nla_put_failure;
8439 if ((survey->filled & SURVEY_INFO_TIME) &&
8440 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME,
8441 survey->time, NL80211_SURVEY_INFO_PAD))
8442 goto nla_put_failure;
8443 if ((survey->filled & SURVEY_INFO_TIME_BUSY) &&
8444 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_BUSY,
8445 survey->time_busy, NL80211_SURVEY_INFO_PAD))
8446 goto nla_put_failure;
8447 if ((survey->filled & SURVEY_INFO_TIME_EXT_BUSY) &&
8448 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_EXT_BUSY,
8449 survey->time_ext_busy, NL80211_SURVEY_INFO_PAD))
8450 goto nla_put_failure;
8451 if ((survey->filled & SURVEY_INFO_TIME_RX) &&
8452 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_RX,
8453 survey->time_rx, NL80211_SURVEY_INFO_PAD))
8454 goto nla_put_failure;
8455 if ((survey->filled & SURVEY_INFO_TIME_TX) &&
8456 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_TX,
8457 survey->time_tx, NL80211_SURVEY_INFO_PAD))
8458 goto nla_put_failure;
8459 if ((survey->filled & SURVEY_INFO_TIME_SCAN) &&
8460 nla_put_u64_64bit(msg, NL80211_SURVEY_INFO_TIME_SCAN,
8461 survey->time_scan, NL80211_SURVEY_INFO_PAD))
8462 goto nla_put_failure;
8464 nla_nest_end(msg, infoattr);
8466 genlmsg_end(msg, hdr);
8470 genlmsg_cancel(msg, hdr);
8474 static int nl80211_dump_survey(struct sk_buff *skb, struct netlink_callback *cb)
8476 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
8477 struct survey_info survey;
8478 struct cfg80211_registered_device *rdev;
8479 struct wireless_dev *wdev;
8480 int survey_idx = cb->args[2];
8485 res = nl80211_prepare_wdev_dump(cb, &rdev, &wdev);
8489 /* prepare_wdev_dump parsed the attributes */
8490 radio_stats = attrbuf[NL80211_ATTR_SURVEY_RADIO_STATS];
8492 if (!wdev->netdev) {
8497 if (!rdev->ops->dump_survey) {
8503 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
8509 /* don't send disabled channels, but do send non-channel data */
8510 if (survey.channel &&
8511 survey.channel->flags & IEEE80211_CHAN_DISABLED) {
8516 if (nl80211_send_survey(skb,
8517 NETLINK_CB(cb->skb).portid,
8518 cb->nlh->nlmsg_seq, NLM_F_MULTI,
8519 wdev->netdev, radio_stats, &survey) < 0)
8525 cb->args[2] = survey_idx;
8532 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
8534 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
8535 NL80211_WPA_VERSION_2));
8538 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
8540 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8541 struct net_device *dev = info->user_ptr[1];
8542 struct ieee80211_channel *chan;
8543 const u8 *bssid, *ssid, *ie = NULL, *auth_data = NULL;
8544 int err, ssid_len, ie_len = 0, auth_data_len = 0;
8545 enum nl80211_auth_type auth_type;
8546 struct key_parse key;
8547 bool local_state_change;
8549 if (!info->attrs[NL80211_ATTR_MAC])
8552 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
8555 if (!info->attrs[NL80211_ATTR_SSID])
8558 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
8561 err = nl80211_parse_key(info, &key);
8566 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
8568 if (!key.p.key || !key.p.key_len)
8570 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
8571 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
8572 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
8573 key.p.key_len != WLAN_KEY_LEN_WEP104))
8586 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
8587 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
8596 if (!rdev->ops->auth)
8599 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
8600 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8603 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
8604 chan = nl80211_get_valid_chan(&rdev->wiphy,
8605 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8609 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8610 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8612 if (info->attrs[NL80211_ATTR_IE]) {
8613 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8614 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8617 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
8618 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
8621 if ((auth_type == NL80211_AUTHTYPE_SAE ||
8622 auth_type == NL80211_AUTHTYPE_FILS_SK ||
8623 auth_type == NL80211_AUTHTYPE_FILS_SK_PFS ||
8624 auth_type == NL80211_AUTHTYPE_FILS_PK) &&
8625 !info->attrs[NL80211_ATTR_AUTH_DATA])
8628 if (info->attrs[NL80211_ATTR_AUTH_DATA]) {
8629 if (auth_type != NL80211_AUTHTYPE_SAE &&
8630 auth_type != NL80211_AUTHTYPE_FILS_SK &&
8631 auth_type != NL80211_AUTHTYPE_FILS_SK_PFS &&
8632 auth_type != NL80211_AUTHTYPE_FILS_PK)
8634 auth_data = nla_data(info->attrs[NL80211_ATTR_AUTH_DATA]);
8635 auth_data_len = nla_len(info->attrs[NL80211_ATTR_AUTH_DATA]);
8636 /* need to include at least Auth Transaction and Status Code */
8637 if (auth_data_len < 4)
8641 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8644 * Since we no longer track auth state, ignore
8645 * requests to only change local state.
8647 if (local_state_change)
8650 wdev_lock(dev->ieee80211_ptr);
8651 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
8652 ssid, ssid_len, ie, ie_len,
8653 key.p.key, key.p.key_len, key.idx,
8654 auth_data, auth_data_len);
8655 wdev_unlock(dev->ieee80211_ptr);
8659 static int validate_pae_over_nl80211(struct cfg80211_registered_device *rdev,
8660 struct genl_info *info)
8662 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8663 GENL_SET_ERR_MSG(info, "SOCKET_OWNER not set");
8667 if (!rdev->ops->tx_control_port ||
8668 !wiphy_ext_feature_isset(&rdev->wiphy,
8669 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
8675 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
8676 struct genl_info *info,
8677 struct cfg80211_crypto_settings *settings,
8680 memset(settings, 0, sizeof(*settings));
8682 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
8684 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
8687 proto = nla_get_u16(
8688 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
8689 settings->control_port_ethertype = cpu_to_be16(proto);
8690 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
8693 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
8694 settings->control_port_no_encrypt = true;
8696 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
8698 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
8699 int r = validate_pae_over_nl80211(rdev, info);
8704 settings->control_port_over_nl80211 = true;
8707 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
8711 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8712 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
8713 settings->n_ciphers_pairwise = len / sizeof(u32);
8715 if (len % sizeof(u32))
8718 if (settings->n_ciphers_pairwise > cipher_limit)
8721 memcpy(settings->ciphers_pairwise, data, len);
8723 for (i = 0; i < settings->n_ciphers_pairwise; i++)
8724 if (!cfg80211_supported_cipher_suite(
8726 settings->ciphers_pairwise[i]))
8730 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
8731 settings->cipher_group =
8732 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
8733 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
8734 settings->cipher_group))
8738 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
8739 settings->wpa_versions =
8740 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
8741 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
8745 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
8749 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
8750 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
8751 settings->n_akm_suites = len / sizeof(u32);
8753 if (len % sizeof(u32))
8756 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
8759 memcpy(settings->akm_suites, data, len);
8762 if (info->attrs[NL80211_ATTR_PMK]) {
8763 if (nla_len(info->attrs[NL80211_ATTR_PMK]) != WLAN_PMK_LEN)
8765 if (!wiphy_ext_feature_isset(&rdev->wiphy,
8766 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK))
8768 settings->psk = nla_data(info->attrs[NL80211_ATTR_PMK]);
8774 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
8776 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8777 struct net_device *dev = info->user_ptr[1];
8778 struct ieee80211_channel *chan;
8779 struct cfg80211_assoc_request req = {};
8780 const u8 *bssid, *ssid;
8781 int err, ssid_len = 0;
8783 if (dev->ieee80211_ptr->conn_owner_nlportid &&
8784 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
8787 if (!info->attrs[NL80211_ATTR_MAC] ||
8788 !info->attrs[NL80211_ATTR_SSID] ||
8789 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
8792 if (!rdev->ops->assoc)
8795 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
8796 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8799 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
8801 chan = nl80211_get_valid_chan(&rdev->wiphy,
8802 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
8806 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
8807 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
8809 if (info->attrs[NL80211_ATTR_IE]) {
8810 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8811 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8814 if (info->attrs[NL80211_ATTR_USE_MFP]) {
8815 enum nl80211_mfp mfp =
8816 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
8817 if (mfp == NL80211_MFP_REQUIRED)
8819 else if (mfp != NL80211_MFP_NO)
8823 if (info->attrs[NL80211_ATTR_PREV_BSSID])
8824 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
8826 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
8827 req.flags |= ASSOC_REQ_DISABLE_HT;
8829 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8830 memcpy(&req.ht_capa_mask,
8831 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
8832 sizeof(req.ht_capa_mask));
8834 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
8835 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
8837 memcpy(&req.ht_capa,
8838 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
8839 sizeof(req.ht_capa));
8842 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
8843 req.flags |= ASSOC_REQ_DISABLE_VHT;
8845 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
8846 memcpy(&req.vht_capa_mask,
8847 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
8848 sizeof(req.vht_capa_mask));
8850 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
8851 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
8853 memcpy(&req.vht_capa,
8854 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
8855 sizeof(req.vht_capa));
8858 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
8859 if (!((rdev->wiphy.features &
8860 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
8861 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
8862 !wiphy_ext_feature_isset(&rdev->wiphy,
8863 NL80211_EXT_FEATURE_RRM))
8865 req.flags |= ASSOC_REQ_USE_RRM;
8868 if (info->attrs[NL80211_ATTR_FILS_KEK]) {
8869 req.fils_kek = nla_data(info->attrs[NL80211_ATTR_FILS_KEK]);
8870 req.fils_kek_len = nla_len(info->attrs[NL80211_ATTR_FILS_KEK]);
8871 if (!info->attrs[NL80211_ATTR_FILS_NONCES])
8874 nla_data(info->attrs[NL80211_ATTR_FILS_NONCES]);
8877 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
8879 wdev_lock(dev->ieee80211_ptr);
8881 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
8882 ssid, ssid_len, &req);
8884 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
8885 dev->ieee80211_ptr->conn_owner_nlportid =
8887 memcpy(dev->ieee80211_ptr->disconnect_bssid,
8891 wdev_unlock(dev->ieee80211_ptr);
8897 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
8899 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8900 struct net_device *dev = info->user_ptr[1];
8901 const u8 *ie = NULL, *bssid;
8902 int ie_len = 0, err;
8904 bool local_state_change;
8906 if (dev->ieee80211_ptr->conn_owner_nlportid &&
8907 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
8910 if (!info->attrs[NL80211_ATTR_MAC])
8913 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8916 if (!rdev->ops->deauth)
8919 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
8920 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8923 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
8925 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8926 if (reason_code == 0) {
8927 /* Reason Code 0 is reserved */
8931 if (info->attrs[NL80211_ATTR_IE]) {
8932 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8933 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8936 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8938 wdev_lock(dev->ieee80211_ptr);
8939 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
8940 local_state_change);
8941 wdev_unlock(dev->ieee80211_ptr);
8945 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
8947 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8948 struct net_device *dev = info->user_ptr[1];
8949 const u8 *ie = NULL, *bssid;
8950 int ie_len = 0, err;
8952 bool local_state_change;
8954 if (dev->ieee80211_ptr->conn_owner_nlportid &&
8955 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
8958 if (!info->attrs[NL80211_ATTR_MAC])
8961 if (!info->attrs[NL80211_ATTR_REASON_CODE])
8964 if (!rdev->ops->disassoc)
8967 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
8968 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
8971 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
8973 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
8974 if (reason_code == 0) {
8975 /* Reason Code 0 is reserved */
8979 if (info->attrs[NL80211_ATTR_IE]) {
8980 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8981 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8984 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
8986 wdev_lock(dev->ieee80211_ptr);
8987 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
8988 local_state_change);
8989 wdev_unlock(dev->ieee80211_ptr);
8994 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
8995 int mcast_rate[NUM_NL80211_BANDS],
8998 struct wiphy *wiphy = &rdev->wiphy;
9002 for (band = 0; band < NUM_NL80211_BANDS; band++) {
9003 struct ieee80211_supported_band *sband;
9005 sband = wiphy->bands[band];
9009 for (i = 0; i < sband->n_bitrates; i++) {
9010 if (sband->bitrates[i].bitrate == rateval) {
9011 mcast_rate[band] = i + 1;
9021 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
9023 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9024 struct net_device *dev = info->user_ptr[1];
9025 struct cfg80211_ibss_params ibss;
9026 struct wiphy *wiphy;
9027 struct cfg80211_cached_keys *connkeys = NULL;
9030 memset(&ibss, 0, sizeof(ibss));
9032 if (!info->attrs[NL80211_ATTR_SSID] ||
9033 !nla_len(info->attrs[NL80211_ATTR_SSID]))
9036 ibss.beacon_interval = 100;
9038 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL])
9039 ibss.beacon_interval =
9040 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
9042 err = cfg80211_validate_beacon_int(rdev, NL80211_IFTYPE_ADHOC,
9043 ibss.beacon_interval);
9047 if (!rdev->ops->join_ibss)
9050 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
9053 wiphy = &rdev->wiphy;
9055 if (info->attrs[NL80211_ATTR_MAC]) {
9056 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9058 if (!is_valid_ether_addr(ibss.bssid))
9061 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9062 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9064 if (info->attrs[NL80211_ATTR_IE]) {
9065 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9066 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9069 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
9073 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
9074 NL80211_IFTYPE_ADHOC))
9077 switch (ibss.chandef.width) {
9078 case NL80211_CHAN_WIDTH_5:
9079 case NL80211_CHAN_WIDTH_10:
9080 case NL80211_CHAN_WIDTH_20_NOHT:
9082 case NL80211_CHAN_WIDTH_20:
9083 case NL80211_CHAN_WIDTH_40:
9084 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
9087 case NL80211_CHAN_WIDTH_80:
9088 case NL80211_CHAN_WIDTH_80P80:
9089 case NL80211_CHAN_WIDTH_160:
9090 if (!(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
9092 if (!wiphy_ext_feature_isset(&rdev->wiphy,
9093 NL80211_EXT_FEATURE_VHT_IBSS))
9100 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
9101 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
9103 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
9105 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9107 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
9108 struct ieee80211_supported_band *sband =
9109 wiphy->bands[ibss.chandef.chan->band];
9111 err = ieee80211_get_ratemask(sband, rates, n_rates,
9117 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9118 memcpy(&ibss.ht_capa_mask,
9119 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9120 sizeof(ibss.ht_capa_mask));
9122 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9123 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9125 memcpy(&ibss.ht_capa,
9126 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9127 sizeof(ibss.ht_capa));
9130 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
9131 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
9132 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
9135 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
9138 connkeys = nl80211_parse_connkeys(rdev, info, &no_ht);
9139 if (IS_ERR(connkeys))
9140 return PTR_ERR(connkeys);
9142 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
9150 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
9152 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
9153 int r = validate_pae_over_nl80211(rdev, info);
9160 ibss.control_port_over_nl80211 = true;
9163 ibss.userspace_handles_dfs =
9164 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
9166 wdev_lock(dev->ieee80211_ptr);
9167 err = __cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
9170 else if (info->attrs[NL80211_ATTR_SOCKET_OWNER])
9171 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9172 wdev_unlock(dev->ieee80211_ptr);
9177 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
9179 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9180 struct net_device *dev = info->user_ptr[1];
9182 if (!rdev->ops->leave_ibss)
9185 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
9188 return cfg80211_leave_ibss(rdev, dev, false);
9191 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
9193 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9194 struct net_device *dev = info->user_ptr[1];
9195 int mcast_rate[NUM_NL80211_BANDS];
9199 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
9200 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
9201 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_OCB)
9204 if (!rdev->ops->set_mcast_rate)
9207 memset(mcast_rate, 0, sizeof(mcast_rate));
9209 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
9212 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
9213 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
9216 err = rdev_set_mcast_rate(rdev, dev, mcast_rate);
9221 static struct sk_buff *
9222 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
9223 struct wireless_dev *wdev, int approxlen,
9224 u32 portid, u32 seq, enum nl80211_commands cmd,
9225 enum nl80211_attrs attr,
9226 const struct nl80211_vendor_cmd_info *info,
9229 struct sk_buff *skb;
9231 struct nlattr *data;
9233 skb = nlmsg_new(approxlen + 100, gfp);
9237 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
9243 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
9244 goto nla_put_failure;
9247 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
9249 goto nla_put_failure;
9250 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
9252 goto nla_put_failure;
9256 if (nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
9257 wdev_id(wdev), NL80211_ATTR_PAD))
9258 goto nla_put_failure;
9260 nla_put_u32(skb, NL80211_ATTR_IFINDEX,
9261 wdev->netdev->ifindex))
9262 goto nla_put_failure;
9265 data = nla_nest_start(skb, attr);
9267 goto nla_put_failure;
9269 ((void **)skb->cb)[0] = rdev;
9270 ((void **)skb->cb)[1] = hdr;
9271 ((void **)skb->cb)[2] = data;
9280 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
9281 struct wireless_dev *wdev,
9282 enum nl80211_commands cmd,
9283 enum nl80211_attrs attr,
9284 int vendor_event_idx,
9285 int approxlen, gfp_t gfp)
9287 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
9288 const struct nl80211_vendor_cmd_info *info;
9291 case NL80211_CMD_TESTMODE:
9292 if (WARN_ON(vendor_event_idx != -1))
9296 case NL80211_CMD_VENDOR:
9297 if (WARN_ON(vendor_event_idx < 0 ||
9298 vendor_event_idx >= wiphy->n_vendor_events))
9300 info = &wiphy->vendor_events[vendor_event_idx];
9307 return __cfg80211_alloc_vendor_skb(rdev, wdev, approxlen, 0, 0,
9308 cmd, attr, info, gfp);
9310 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
9312 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
9314 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
9315 void *hdr = ((void **)skb->cb)[1];
9316 struct nlattr *data = ((void **)skb->cb)[2];
9317 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
9319 /* clear CB data for netlink core to own from now on */
9320 memset(skb->cb, 0, sizeof(skb->cb));
9322 nla_nest_end(skb, data);
9323 genlmsg_end(skb, hdr);
9325 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
9326 mcgrp = NL80211_MCGRP_VENDOR;
9328 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
9331 EXPORT_SYMBOL(__cfg80211_send_event_skb);
9333 #ifdef CONFIG_NL80211_TESTMODE
9334 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
9336 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9337 struct wireless_dev *wdev =
9338 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
9341 if (!rdev->ops->testmode_cmd)
9345 err = PTR_ERR(wdev);
9349 } else if (wdev->wiphy != &rdev->wiphy) {
9353 if (!info->attrs[NL80211_ATTR_TESTDATA])
9356 rdev->cur_cmd_info = info;
9357 err = rdev_testmode_cmd(rdev, wdev,
9358 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
9359 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
9360 rdev->cur_cmd_info = NULL;
9365 static int nl80211_testmode_dump(struct sk_buff *skb,
9366 struct netlink_callback *cb)
9368 struct cfg80211_registered_device *rdev;
9378 * 0 is a valid index, but not valid for args[0],
9379 * so we need to offset by 1.
9381 phy_idx = cb->args[0] - 1;
9383 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
9389 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
9391 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
9392 attrbuf, nl80211_fam.maxattr,
9393 nl80211_policy, NULL);
9397 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
9399 err = PTR_ERR(rdev);
9402 phy_idx = rdev->wiphy_idx;
9404 if (attrbuf[NL80211_ATTR_TESTDATA])
9405 cb->args[1] = (long)attrbuf[NL80211_ATTR_TESTDATA];
9409 data = nla_data((void *)cb->args[1]);
9410 data_len = nla_len((void *)cb->args[1]);
9413 if (!rdev->ops->testmode_dump) {
9419 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
9420 cb->nlh->nlmsg_seq, NLM_F_MULTI,
9421 NL80211_CMD_TESTMODE);
9422 struct nlattr *tmdata;
9427 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
9428 genlmsg_cancel(skb, hdr);
9432 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
9434 genlmsg_cancel(skb, hdr);
9437 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
9438 nla_nest_end(skb, tmdata);
9440 if (err == -ENOBUFS || err == -ENOENT) {
9441 genlmsg_cancel(skb, hdr);
9444 genlmsg_cancel(skb, hdr);
9448 genlmsg_end(skb, hdr);
9453 cb->args[0] = phy_idx + 1;
9460 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
9462 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9463 struct net_device *dev = info->user_ptr[1];
9464 struct cfg80211_connect_params connect;
9465 struct wiphy *wiphy;
9466 struct cfg80211_cached_keys *connkeys = NULL;
9469 memset(&connect, 0, sizeof(connect));
9471 if (!info->attrs[NL80211_ATTR_SSID] ||
9472 !nla_len(info->attrs[NL80211_ATTR_SSID]))
9475 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
9477 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
9478 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
9479 NL80211_CMD_CONNECT))
9482 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
9484 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
9486 if (info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS] &&
9487 !wiphy_ext_feature_isset(&rdev->wiphy,
9488 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
9490 connect.want_1x = info->attrs[NL80211_ATTR_WANT_1X_4WAY_HS];
9492 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
9493 NL80211_MAX_NR_CIPHER_SUITES);
9497 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9498 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9501 wiphy = &rdev->wiphy;
9503 connect.bg_scan_period = -1;
9504 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
9505 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
9506 connect.bg_scan_period =
9507 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
9510 if (info->attrs[NL80211_ATTR_MAC])
9511 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9512 else if (info->attrs[NL80211_ATTR_MAC_HINT])
9513 connect.bssid_hint =
9514 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
9515 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9516 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9518 if (info->attrs[NL80211_ATTR_IE]) {
9519 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9520 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9523 if (info->attrs[NL80211_ATTR_USE_MFP]) {
9524 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
9525 if (connect.mfp == NL80211_MFP_OPTIONAL &&
9526 !wiphy_ext_feature_isset(&rdev->wiphy,
9527 NL80211_EXT_FEATURE_MFP_OPTIONAL))
9530 connect.mfp = NL80211_MFP_NO;
9533 if (info->attrs[NL80211_ATTR_PREV_BSSID])
9534 connect.prev_bssid =
9535 nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
9537 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
9538 connect.channel = nl80211_get_valid_chan(
9539 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
9540 if (!connect.channel)
9542 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
9543 connect.channel_hint = nl80211_get_valid_chan(
9544 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
9545 if (!connect.channel_hint)
9549 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
9550 connkeys = nl80211_parse_connkeys(rdev, info, NULL);
9551 if (IS_ERR(connkeys))
9552 return PTR_ERR(connkeys);
9555 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
9556 connect.flags |= ASSOC_REQ_DISABLE_HT;
9558 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
9559 memcpy(&connect.ht_capa_mask,
9560 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
9561 sizeof(connect.ht_capa_mask));
9563 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
9564 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
9568 memcpy(&connect.ht_capa,
9569 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
9570 sizeof(connect.ht_capa));
9573 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
9574 connect.flags |= ASSOC_REQ_DISABLE_VHT;
9576 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
9577 memcpy(&connect.vht_capa_mask,
9578 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
9579 sizeof(connect.vht_capa_mask));
9581 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
9582 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
9586 memcpy(&connect.vht_capa,
9587 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
9588 sizeof(connect.vht_capa));
9591 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
9592 if (!((rdev->wiphy.features &
9593 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) &&
9594 (rdev->wiphy.features & NL80211_FEATURE_QUIET)) &&
9595 !wiphy_ext_feature_isset(&rdev->wiphy,
9596 NL80211_EXT_FEATURE_RRM)) {
9600 connect.flags |= ASSOC_REQ_USE_RRM;
9603 connect.pbss = nla_get_flag(info->attrs[NL80211_ATTR_PBSS]);
9604 if (connect.pbss && !rdev->wiphy.bands[NL80211_BAND_60GHZ]) {
9609 if (info->attrs[NL80211_ATTR_BSS_SELECT]) {
9610 /* bss selection makes no sense if bssid is set */
9611 if (connect.bssid) {
9616 err = parse_bss_select(info->attrs[NL80211_ATTR_BSS_SELECT],
9617 wiphy, &connect.bss_select);
9624 if (wiphy_ext_feature_isset(&rdev->wiphy,
9625 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD) &&
9626 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
9627 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
9628 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
9629 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9630 connect.fils_erp_username =
9631 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9632 connect.fils_erp_username_len =
9633 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9634 connect.fils_erp_realm =
9635 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9636 connect.fils_erp_realm_len =
9637 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9638 connect.fils_erp_next_seq_num =
9640 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
9641 connect.fils_erp_rrk =
9642 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9643 connect.fils_erp_rrk_len =
9644 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9645 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
9646 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
9647 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
9648 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9653 if (nla_get_flag(info->attrs[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT])) {
9654 if (!info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9656 GENL_SET_ERR_MSG(info,
9657 "external auth requires connection ownership");
9660 connect.flags |= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT;
9663 wdev_lock(dev->ieee80211_ptr);
9665 err = cfg80211_connect(rdev, dev, &connect, connkeys,
9666 connect.prev_bssid);
9670 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER]) {
9671 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
9673 memcpy(dev->ieee80211_ptr->disconnect_bssid,
9674 connect.bssid, ETH_ALEN);
9676 memset(dev->ieee80211_ptr->disconnect_bssid,
9680 wdev_unlock(dev->ieee80211_ptr);
9685 static int nl80211_update_connect_params(struct sk_buff *skb,
9686 struct genl_info *info)
9688 struct cfg80211_connect_params connect = {};
9689 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9690 struct net_device *dev = info->user_ptr[1];
9691 struct wireless_dev *wdev = dev->ieee80211_ptr;
9692 bool fils_sk_offload;
9697 if (!rdev->ops->update_connect_params)
9700 if (info->attrs[NL80211_ATTR_IE]) {
9701 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9702 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9703 changed |= UPDATE_ASSOC_IES;
9706 fils_sk_offload = wiphy_ext_feature_isset(&rdev->wiphy,
9707 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD);
9710 * when driver supports fils-sk offload all attributes must be
9711 * provided. So the else covers "fils-sk-not-all" and
9714 if (fils_sk_offload &&
9715 info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] &&
9716 info->attrs[NL80211_ATTR_FILS_ERP_REALM] &&
9717 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] &&
9718 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9719 connect.fils_erp_username =
9720 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9721 connect.fils_erp_username_len =
9722 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_USERNAME]);
9723 connect.fils_erp_realm =
9724 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9725 connect.fils_erp_realm_len =
9726 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_REALM]);
9727 connect.fils_erp_next_seq_num =
9729 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM]);
9730 connect.fils_erp_rrk =
9731 nla_data(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9732 connect.fils_erp_rrk_len =
9733 nla_len(info->attrs[NL80211_ATTR_FILS_ERP_RRK]);
9734 changed |= UPDATE_FILS_ERP_INFO;
9735 } else if (info->attrs[NL80211_ATTR_FILS_ERP_USERNAME] ||
9736 info->attrs[NL80211_ATTR_FILS_ERP_REALM] ||
9737 info->attrs[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM] ||
9738 info->attrs[NL80211_ATTR_FILS_ERP_RRK]) {
9742 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
9743 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
9744 if (!nl80211_valid_auth_type(rdev, auth_type,
9745 NL80211_CMD_CONNECT))
9748 if (auth_type == NL80211_AUTHTYPE_FILS_SK &&
9749 fils_sk_offload && !(changed & UPDATE_FILS_ERP_INFO))
9752 connect.auth_type = auth_type;
9753 changed |= UPDATE_AUTH_TYPE;
9756 wdev_lock(dev->ieee80211_ptr);
9757 if (!wdev->current_bss)
9760 ret = rdev_update_connect_params(rdev, dev, &connect, changed);
9761 wdev_unlock(dev->ieee80211_ptr);
9766 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
9768 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9769 struct net_device *dev = info->user_ptr[1];
9773 if (dev->ieee80211_ptr->conn_owner_nlportid &&
9774 dev->ieee80211_ptr->conn_owner_nlportid != info->snd_portid)
9777 if (!info->attrs[NL80211_ATTR_REASON_CODE])
9778 reason = WLAN_REASON_DEAUTH_LEAVING;
9780 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
9785 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9786 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9789 wdev_lock(dev->ieee80211_ptr);
9790 ret = cfg80211_disconnect(rdev, dev, reason, true);
9791 wdev_unlock(dev->ieee80211_ptr);
9795 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
9797 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9801 if (info->attrs[NL80211_ATTR_PID]) {
9802 u32 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
9804 net = get_net_ns_by_pid(pid);
9805 } else if (info->attrs[NL80211_ATTR_NETNS_FD]) {
9806 u32 fd = nla_get_u32(info->attrs[NL80211_ATTR_NETNS_FD]);
9808 net = get_net_ns_by_fd(fd);
9814 return PTR_ERR(net);
9818 /* check if anything to do */
9819 if (!net_eq(wiphy_net(&rdev->wiphy), net))
9820 err = cfg80211_switch_netns(rdev, net);
9826 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
9828 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9829 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
9830 struct cfg80211_pmksa *pmksa) = NULL;
9831 struct net_device *dev = info->user_ptr[1];
9832 struct cfg80211_pmksa pmksa;
9834 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
9836 if (!info->attrs[NL80211_ATTR_PMKID])
9839 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
9841 if (info->attrs[NL80211_ATTR_MAC]) {
9842 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
9843 } else if (info->attrs[NL80211_ATTR_SSID] &&
9844 info->attrs[NL80211_ATTR_FILS_CACHE_ID] &&
9845 (info->genlhdr->cmd == NL80211_CMD_DEL_PMKSA ||
9846 info->attrs[NL80211_ATTR_PMK])) {
9847 pmksa.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
9848 pmksa.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
9850 nla_data(info->attrs[NL80211_ATTR_FILS_CACHE_ID]);
9854 if (info->attrs[NL80211_ATTR_PMK]) {
9855 pmksa.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
9856 pmksa.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
9859 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9860 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9863 switch (info->genlhdr->cmd) {
9864 case NL80211_CMD_SET_PMKSA:
9865 rdev_ops = rdev->ops->set_pmksa;
9867 case NL80211_CMD_DEL_PMKSA:
9868 rdev_ops = rdev->ops->del_pmksa;
9878 return rdev_ops(&rdev->wiphy, dev, &pmksa);
9881 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
9883 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9884 struct net_device *dev = info->user_ptr[1];
9886 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
9887 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
9890 if (!rdev->ops->flush_pmksa)
9893 return rdev_flush_pmksa(rdev, dev);
9896 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
9898 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9899 struct net_device *dev = info->user_ptr[1];
9900 u8 action_code, dialog_token;
9901 u32 peer_capability = 0;
9906 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9907 !rdev->ops->tdls_mgmt)
9910 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
9911 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
9912 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
9913 !info->attrs[NL80211_ATTR_IE] ||
9914 !info->attrs[NL80211_ATTR_MAC])
9917 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9918 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
9919 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
9920 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
9921 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
9922 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
9924 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
9926 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
9927 dialog_token, status_code, peer_capability,
9929 nla_data(info->attrs[NL80211_ATTR_IE]),
9930 nla_len(info->attrs[NL80211_ATTR_IE]));
9933 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
9935 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9936 struct net_device *dev = info->user_ptr[1];
9937 enum nl80211_tdls_operation operation;
9940 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
9941 !rdev->ops->tdls_oper)
9944 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
9945 !info->attrs[NL80211_ATTR_MAC])
9948 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
9949 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9951 return rdev_tdls_oper(rdev, dev, peer, operation);
9954 static int nl80211_remain_on_channel(struct sk_buff *skb,
9955 struct genl_info *info)
9957 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9958 struct wireless_dev *wdev = info->user_ptr[1];
9959 struct cfg80211_chan_def chandef;
9960 const struct cfg80211_chan_def *compat_chandef;
9961 struct sk_buff *msg;
9967 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
9968 !info->attrs[NL80211_ATTR_DURATION])
9971 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
9973 if (!rdev->ops->remain_on_channel ||
9974 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
9978 * We should be on that channel for at least a minimum amount of
9979 * time (10ms) but no longer than the driver supports.
9981 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
9982 duration > rdev->wiphy.max_remain_on_channel_duration)
9985 err = nl80211_parse_chandef(rdev, info, &chandef);
9990 if (!cfg80211_off_channel_oper_allowed(wdev) &&
9991 !cfg80211_chandef_identical(&wdev->chandef, &chandef)) {
9992 compat_chandef = cfg80211_chandef_compatible(&wdev->chandef,
9994 if (compat_chandef != &chandef) {
10001 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10005 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10006 NL80211_CMD_REMAIN_ON_CHANNEL);
10012 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
10013 duration, &cookie);
10018 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10020 goto nla_put_failure;
10022 genlmsg_end(msg, hdr);
10024 return genlmsg_reply(msg, info);
10033 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
10034 struct genl_info *info)
10036 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10037 struct wireless_dev *wdev = info->user_ptr[1];
10040 if (!info->attrs[NL80211_ATTR_COOKIE])
10043 if (!rdev->ops->cancel_remain_on_channel)
10044 return -EOPNOTSUPP;
10046 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
10048 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
10051 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
10052 struct genl_info *info)
10054 struct cfg80211_bitrate_mask mask;
10055 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10056 struct net_device *dev = info->user_ptr[1];
10059 if (!rdev->ops->set_bitrate_mask)
10060 return -EOPNOTSUPP;
10062 err = nl80211_parse_tx_bitrate_mask(info, &mask);
10066 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
10069 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
10071 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10072 struct wireless_dev *wdev = info->user_ptr[1];
10073 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
10075 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
10078 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
10079 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
10081 switch (wdev->iftype) {
10082 case NL80211_IFTYPE_STATION:
10083 case NL80211_IFTYPE_ADHOC:
10084 case NL80211_IFTYPE_P2P_CLIENT:
10085 case NL80211_IFTYPE_AP:
10086 case NL80211_IFTYPE_AP_VLAN:
10087 case NL80211_IFTYPE_MESH_POINT:
10088 case NL80211_IFTYPE_P2P_GO:
10089 case NL80211_IFTYPE_P2P_DEVICE:
10091 case NL80211_IFTYPE_NAN:
10093 return -EOPNOTSUPP;
10096 /* not much point in registering if we can't reply */
10097 if (!rdev->ops->mgmt_tx)
10098 return -EOPNOTSUPP;
10100 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
10101 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
10102 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
10105 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
10107 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10108 struct wireless_dev *wdev = info->user_ptr[1];
10109 struct cfg80211_chan_def chandef;
10113 struct sk_buff *msg = NULL;
10114 struct cfg80211_mgmt_tx_params params = {
10115 .dont_wait_for_ack =
10116 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
10119 if (!info->attrs[NL80211_ATTR_FRAME])
10122 if (!rdev->ops->mgmt_tx)
10123 return -EOPNOTSUPP;
10125 switch (wdev->iftype) {
10126 case NL80211_IFTYPE_P2P_DEVICE:
10127 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
10129 case NL80211_IFTYPE_STATION:
10130 case NL80211_IFTYPE_ADHOC:
10131 case NL80211_IFTYPE_P2P_CLIENT:
10132 case NL80211_IFTYPE_AP:
10133 case NL80211_IFTYPE_AP_VLAN:
10134 case NL80211_IFTYPE_MESH_POINT:
10135 case NL80211_IFTYPE_P2P_GO:
10137 case NL80211_IFTYPE_NAN:
10139 return -EOPNOTSUPP;
10142 if (info->attrs[NL80211_ATTR_DURATION]) {
10143 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
10145 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
10148 * We should wait on the channel for at least a minimum amount
10149 * of time (10ms) but no longer than the driver supports.
10151 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
10152 params.wait > rdev->wiphy.max_remain_on_channel_duration)
10156 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
10158 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
10161 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
10163 /* get the channel if any has been specified, otherwise pass NULL to
10164 * the driver. The latter will use the current one
10166 chandef.chan = NULL;
10167 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
10168 err = nl80211_parse_chandef(rdev, info, &chandef);
10173 if (!chandef.chan && params.offchan)
10177 if (params.offchan && !cfg80211_off_channel_oper_allowed(wdev)) {
10183 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
10184 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
10186 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
10187 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
10190 if (len % sizeof(u16))
10193 params.n_csa_offsets = len / sizeof(u16);
10194 params.csa_offsets =
10195 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
10197 /* check that all the offsets fit the frame */
10198 for (i = 0; i < params.n_csa_offsets; i++) {
10199 if (params.csa_offsets[i] >= params.len)
10204 if (!params.dont_wait_for_ack) {
10205 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10209 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10210 NL80211_CMD_FRAME);
10217 params.chan = chandef.chan;
10218 err = cfg80211_mlme_mgmt_tx(rdev, wdev, ¶ms, &cookie);
10223 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
10225 goto nla_put_failure;
10227 genlmsg_end(msg, hdr);
10228 return genlmsg_reply(msg, info);
10240 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
10242 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10243 struct wireless_dev *wdev = info->user_ptr[1];
10246 if (!info->attrs[NL80211_ATTR_COOKIE])
10249 if (!rdev->ops->mgmt_tx_cancel_wait)
10250 return -EOPNOTSUPP;
10252 switch (wdev->iftype) {
10253 case NL80211_IFTYPE_STATION:
10254 case NL80211_IFTYPE_ADHOC:
10255 case NL80211_IFTYPE_P2P_CLIENT:
10256 case NL80211_IFTYPE_AP:
10257 case NL80211_IFTYPE_AP_VLAN:
10258 case NL80211_IFTYPE_P2P_GO:
10259 case NL80211_IFTYPE_P2P_DEVICE:
10261 case NL80211_IFTYPE_NAN:
10263 return -EOPNOTSUPP;
10266 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
10268 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
10271 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
10273 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10274 struct wireless_dev *wdev;
10275 struct net_device *dev = info->user_ptr[1];
10280 if (!info->attrs[NL80211_ATTR_PS_STATE])
10283 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
10285 wdev = dev->ieee80211_ptr;
10287 if (!rdev->ops->set_power_mgmt)
10288 return -EOPNOTSUPP;
10290 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
10292 if (state == wdev->ps)
10295 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
10301 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
10303 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10304 enum nl80211_ps_state ps_state;
10305 struct wireless_dev *wdev;
10306 struct net_device *dev = info->user_ptr[1];
10307 struct sk_buff *msg;
10311 wdev = dev->ieee80211_ptr;
10313 if (!rdev->ops->set_power_mgmt)
10314 return -EOPNOTSUPP;
10316 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10320 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10321 NL80211_CMD_GET_POWER_SAVE);
10328 ps_state = NL80211_PS_ENABLED;
10330 ps_state = NL80211_PS_DISABLED;
10332 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
10333 goto nla_put_failure;
10335 genlmsg_end(msg, hdr);
10336 return genlmsg_reply(msg, info);
10345 static const struct nla_policy
10346 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
10347 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_BINARY },
10348 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
10349 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
10350 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
10351 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
10352 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
10353 [NL80211_ATTR_CQM_RSSI_LEVEL] = { .type = NLA_S32 },
10356 static int nl80211_set_cqm_txe(struct genl_info *info,
10357 u32 rate, u32 pkts, u32 intvl)
10359 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10360 struct net_device *dev = info->user_ptr[1];
10361 struct wireless_dev *wdev = dev->ieee80211_ptr;
10363 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
10366 if (!rdev->ops->set_cqm_txe_config)
10367 return -EOPNOTSUPP;
10369 if (wdev->iftype != NL80211_IFTYPE_STATION &&
10370 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
10371 return -EOPNOTSUPP;
10373 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
10376 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device *rdev,
10377 struct net_device *dev)
10379 struct wireless_dev *wdev = dev->ieee80211_ptr;
10380 s32 last, low, high;
10382 int i, n, low_index;
10385 /* RSSI reporting disabled? */
10386 if (!wdev->cqm_config)
10387 return rdev_set_cqm_rssi_range_config(rdev, dev, 0, 0);
10390 * Obtain current RSSI value if possible, if not and no RSSI threshold
10391 * event has been received yet, we should receive an event after a
10392 * connection is established and enough beacons received to calculate
10395 if (!wdev->cqm_config->last_rssi_event_value && wdev->current_bss &&
10396 rdev->ops->get_station) {
10397 struct station_info sinfo = {};
10400 mac_addr = wdev->current_bss->pub.bssid;
10402 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
10406 if (sinfo.filled & BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG))
10407 wdev->cqm_config->last_rssi_event_value =
10408 (s8) sinfo.rx_beacon_signal_avg;
10411 last = wdev->cqm_config->last_rssi_event_value;
10412 hyst = wdev->cqm_config->rssi_hyst;
10413 n = wdev->cqm_config->n_rssi_thresholds;
10415 for (i = 0; i < n; i++)
10416 if (last < wdev->cqm_config->rssi_thresholds[i])
10420 if (low_index >= 0) {
10421 low_index = array_index_nospec(low_index, n);
10422 low = wdev->cqm_config->rssi_thresholds[low_index] - hyst;
10427 i = array_index_nospec(i, n);
10428 high = wdev->cqm_config->rssi_thresholds[i] + hyst - 1;
10433 return rdev_set_cqm_rssi_range_config(rdev, dev, low, high);
10436 static int nl80211_set_cqm_rssi(struct genl_info *info,
10437 const s32 *thresholds, int n_thresholds,
10440 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10441 struct net_device *dev = info->user_ptr[1];
10442 struct wireless_dev *wdev = dev->ieee80211_ptr;
10444 s32 prev = S32_MIN;
10446 /* Check all values negative and sorted */
10447 for (i = 0; i < n_thresholds; i++) {
10448 if (thresholds[i] > 0 || thresholds[i] <= prev)
10451 prev = thresholds[i];
10454 if (wdev->iftype != NL80211_IFTYPE_STATION &&
10455 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
10456 return -EOPNOTSUPP;
10459 cfg80211_cqm_config_free(wdev);
10462 if (n_thresholds <= 1 && rdev->ops->set_cqm_rssi_config) {
10463 if (n_thresholds == 0 || thresholds[0] == 0) /* Disabling */
10464 return rdev_set_cqm_rssi_config(rdev, dev, 0, 0);
10466 return rdev_set_cqm_rssi_config(rdev, dev,
10467 thresholds[0], hysteresis);
10470 if (!wiphy_ext_feature_isset(&rdev->wiphy,
10471 NL80211_EXT_FEATURE_CQM_RSSI_LIST))
10472 return -EOPNOTSUPP;
10474 if (n_thresholds == 1 && thresholds[0] == 0) /* Disabling */
10478 if (n_thresholds) {
10479 struct cfg80211_cqm_config *cqm_config;
10481 cqm_config = kzalloc(sizeof(struct cfg80211_cqm_config) +
10482 n_thresholds * sizeof(s32), GFP_KERNEL);
10488 cqm_config->rssi_hyst = hysteresis;
10489 cqm_config->n_rssi_thresholds = n_thresholds;
10490 memcpy(cqm_config->rssi_thresholds, thresholds,
10491 n_thresholds * sizeof(s32));
10493 wdev->cqm_config = cqm_config;
10496 err = cfg80211_cqm_rssi_update(rdev, dev);
10504 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
10506 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
10507 struct nlattr *cqm;
10510 cqm = info->attrs[NL80211_ATTR_CQM];
10514 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
10515 nl80211_attr_cqm_policy, info->extack);
10519 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
10520 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
10521 const s32 *thresholds =
10522 nla_data(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
10523 int len = nla_len(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
10524 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
10529 return nl80211_set_cqm_rssi(info, thresholds, len / 4,
10533 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
10534 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
10535 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
10536 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
10537 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
10538 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
10540 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
10546 static int nl80211_join_ocb(struct sk_buff *skb, struct genl_info *info)
10548 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10549 struct net_device *dev = info->user_ptr[1];
10550 struct ocb_setup setup = {};
10553 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
10557 return cfg80211_join_ocb(rdev, dev, &setup);
10560 static int nl80211_leave_ocb(struct sk_buff *skb, struct genl_info *info)
10562 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10563 struct net_device *dev = info->user_ptr[1];
10565 return cfg80211_leave_ocb(rdev, dev);
10568 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
10570 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10571 struct net_device *dev = info->user_ptr[1];
10572 struct mesh_config cfg;
10573 struct mesh_setup setup;
10576 /* start with default */
10577 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
10578 memcpy(&setup, &default_mesh_setup, sizeof(setup));
10580 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
10581 /* and parse parameters if given */
10582 err = nl80211_parse_mesh_config(info, &cfg, NULL);
10587 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
10588 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
10591 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
10592 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
10594 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
10595 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
10596 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
10599 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
10600 setup.beacon_interval =
10601 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
10603 err = cfg80211_validate_beacon_int(rdev,
10604 NL80211_IFTYPE_MESH_POINT,
10605 setup.beacon_interval);
10610 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
10611 setup.dtim_period =
10612 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
10613 if (setup.dtim_period < 1 || setup.dtim_period > 100)
10617 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
10618 /* parse additional setup parameters if given */
10619 err = nl80211_parse_mesh_setup(info, &setup);
10624 if (setup.user_mpm)
10625 cfg.auto_open_plinks = false;
10627 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
10628 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
10632 /* __cfg80211_join_mesh() will sort it out */
10633 setup.chandef.chan = NULL;
10636 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
10637 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10639 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
10640 struct ieee80211_supported_band *sband;
10642 if (!setup.chandef.chan)
10645 sband = rdev->wiphy.bands[setup.chandef.chan->band];
10647 err = ieee80211_get_ratemask(sband, rates, n_rates,
10648 &setup.basic_rates);
10653 if (info->attrs[NL80211_ATTR_TX_RATES]) {
10654 err = nl80211_parse_tx_bitrate_mask(info, &setup.beacon_rate);
10658 if (!setup.chandef.chan)
10661 err = validate_beacon_tx_rate(rdev, setup.chandef.chan->band,
10662 &setup.beacon_rate);
10667 setup.userspace_handles_dfs =
10668 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
10670 if (info->attrs[NL80211_ATTR_CONTROL_PORT_OVER_NL80211]) {
10671 int r = validate_pae_over_nl80211(rdev, info);
10676 setup.control_port_over_nl80211 = true;
10679 wdev_lock(dev->ieee80211_ptr);
10680 err = __cfg80211_join_mesh(rdev, dev, &setup, &cfg);
10681 if (!err && info->attrs[NL80211_ATTR_SOCKET_OWNER])
10682 dev->ieee80211_ptr->conn_owner_nlportid = info->snd_portid;
10683 wdev_unlock(dev->ieee80211_ptr);
10688 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
10690 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10691 struct net_device *dev = info->user_ptr[1];
10693 return cfg80211_leave_mesh(rdev, dev);
10697 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
10698 struct cfg80211_registered_device *rdev)
10700 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
10701 struct nlattr *nl_pats, *nl_pat;
10704 if (!wowlan->n_patterns)
10707 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
10711 for (i = 0; i < wowlan->n_patterns; i++) {
10712 nl_pat = nla_nest_start(msg, i + 1);
10715 pat_len = wowlan->patterns[i].pattern_len;
10716 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
10717 wowlan->patterns[i].mask) ||
10718 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
10719 wowlan->patterns[i].pattern) ||
10720 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
10721 wowlan->patterns[i].pkt_offset))
10723 nla_nest_end(msg, nl_pat);
10725 nla_nest_end(msg, nl_pats);
10730 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
10731 struct cfg80211_wowlan_tcp *tcp)
10733 struct nlattr *nl_tcp;
10738 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
10742 if (nla_put_in_addr(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
10743 nla_put_in_addr(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
10744 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
10745 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
10746 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
10747 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
10748 tcp->payload_len, tcp->payload) ||
10749 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
10750 tcp->data_interval) ||
10751 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
10752 tcp->wake_len, tcp->wake_data) ||
10753 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
10754 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
10757 if (tcp->payload_seq.len &&
10758 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
10759 sizeof(tcp->payload_seq), &tcp->payload_seq))
10762 if (tcp->payload_tok.len &&
10763 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
10764 sizeof(tcp->payload_tok) + tcp->tokens_size,
10765 &tcp->payload_tok))
10768 nla_nest_end(msg, nl_tcp);
10773 static int nl80211_send_wowlan_nd(struct sk_buff *msg,
10774 struct cfg80211_sched_scan_request *req)
10776 struct nlattr *nd, *freqs, *matches, *match, *scan_plans, *scan_plan;
10782 nd = nla_nest_start(msg, NL80211_WOWLAN_TRIG_NET_DETECT);
10786 if (req->n_scan_plans == 1 &&
10787 nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_INTERVAL,
10788 req->scan_plans[0].interval * 1000))
10791 if (nla_put_u32(msg, NL80211_ATTR_SCHED_SCAN_DELAY, req->delay))
10794 if (req->relative_rssi_set) {
10795 struct nl80211_bss_select_rssi_adjust rssi_adjust;
10797 if (nla_put_s8(msg, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI,
10798 req->relative_rssi))
10801 rssi_adjust.band = req->rssi_adjust.band;
10802 rssi_adjust.delta = req->rssi_adjust.delta;
10803 if (nla_put(msg, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST,
10804 sizeof(rssi_adjust), &rssi_adjust))
10808 freqs = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10812 for (i = 0; i < req->n_channels; i++) {
10813 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10817 nla_nest_end(msg, freqs);
10819 if (req->n_match_sets) {
10820 matches = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_MATCH);
10824 for (i = 0; i < req->n_match_sets; i++) {
10825 match = nla_nest_start(msg, i);
10829 if (nla_put(msg, NL80211_SCHED_SCAN_MATCH_ATTR_SSID,
10830 req->match_sets[i].ssid.ssid_len,
10831 req->match_sets[i].ssid.ssid))
10833 nla_nest_end(msg, match);
10835 nla_nest_end(msg, matches);
10838 scan_plans = nla_nest_start(msg, NL80211_ATTR_SCHED_SCAN_PLANS);
10842 for (i = 0; i < req->n_scan_plans; i++) {
10843 scan_plan = nla_nest_start(msg, i + 1);
10847 if (nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_INTERVAL,
10848 req->scan_plans[i].interval) ||
10849 (req->scan_plans[i].iterations &&
10850 nla_put_u32(msg, NL80211_SCHED_SCAN_PLAN_ITERATIONS,
10851 req->scan_plans[i].iterations)))
10853 nla_nest_end(msg, scan_plan);
10855 nla_nest_end(msg, scan_plans);
10857 nla_nest_end(msg, nd);
10862 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
10864 struct cfg80211_registered_device *rdev = info->user_ptr[0];
10865 struct sk_buff *msg;
10867 u32 size = NLMSG_DEFAULT_SIZE;
10869 if (!rdev->wiphy.wowlan)
10870 return -EOPNOTSUPP;
10872 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
10873 /* adjust size to have room for all the data */
10874 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
10875 rdev->wiphy.wowlan_config->tcp->payload_len +
10876 rdev->wiphy.wowlan_config->tcp->wake_len +
10877 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
10880 msg = nlmsg_new(size, GFP_KERNEL);
10884 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
10885 NL80211_CMD_GET_WOWLAN);
10887 goto nla_put_failure;
10889 if (rdev->wiphy.wowlan_config) {
10890 struct nlattr *nl_wowlan;
10892 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10894 goto nla_put_failure;
10896 if ((rdev->wiphy.wowlan_config->any &&
10897 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
10898 (rdev->wiphy.wowlan_config->disconnect &&
10899 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
10900 (rdev->wiphy.wowlan_config->magic_pkt &&
10901 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
10902 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
10903 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
10904 (rdev->wiphy.wowlan_config->eap_identity_req &&
10905 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
10906 (rdev->wiphy.wowlan_config->four_way_handshake &&
10907 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
10908 (rdev->wiphy.wowlan_config->rfkill_release &&
10909 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
10910 goto nla_put_failure;
10912 if (nl80211_send_wowlan_patterns(msg, rdev))
10913 goto nla_put_failure;
10915 if (nl80211_send_wowlan_tcp(msg,
10916 rdev->wiphy.wowlan_config->tcp))
10917 goto nla_put_failure;
10919 if (nl80211_send_wowlan_nd(
10921 rdev->wiphy.wowlan_config->nd_config))
10922 goto nla_put_failure;
10924 nla_nest_end(msg, nl_wowlan);
10927 genlmsg_end(msg, hdr);
10928 return genlmsg_reply(msg, info);
10935 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
10936 struct nlattr *attr,
10937 struct cfg80211_wowlan *trig)
10939 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
10940 struct cfg80211_wowlan_tcp *cfg;
10941 struct nl80211_wowlan_tcp_data_token *tok = NULL;
10942 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
10944 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
10947 if (!rdev->wiphy.wowlan->tcp)
10950 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TCP, attr,
10951 nl80211_wowlan_tcp_policy, NULL);
10955 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
10956 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
10957 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
10958 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
10959 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
10960 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
10961 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
10962 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
10965 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
10966 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
10969 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
10970 rdev->wiphy.wowlan->tcp->data_interval_max ||
10971 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
10974 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
10975 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
10978 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
10979 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
10982 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
10983 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10985 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
10986 tokens_size = tokln - sizeof(*tok);
10988 if (!tok->len || tokens_size % tok->len)
10990 if (!rdev->wiphy.wowlan->tcp->tok)
10992 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
10994 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
10996 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
10998 if (tok->offset + tok->len > data_size)
11002 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
11003 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
11004 if (!rdev->wiphy.wowlan->tcp->seq)
11006 if (seq->len == 0 || seq->len > 4)
11008 if (seq->len + seq->offset > data_size)
11012 size = sizeof(*cfg);
11014 size += wake_size + wake_mask_size;
11015 size += tokens_size;
11017 cfg = kzalloc(size, GFP_KERNEL);
11020 cfg->src = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
11021 cfg->dst = nla_get_in_addr(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
11022 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
11024 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
11025 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
11029 /* allocate a socket and port for it and use it */
11030 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
11031 IPPROTO_TCP, &cfg->sock, 1);
11036 if (inet_csk_get_port(cfg->sock->sk, port)) {
11037 sock_release(cfg->sock);
11039 return -EADDRINUSE;
11041 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
11047 cfg->src_port = port;
11050 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
11051 cfg->payload_len = data_size;
11052 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
11053 memcpy((void *)cfg->payload,
11054 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
11057 cfg->payload_seq = *seq;
11058 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
11059 cfg->wake_len = wake_size;
11060 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
11061 memcpy((void *)cfg->wake_data,
11062 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
11064 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
11065 data_size + wake_size;
11066 memcpy((void *)cfg->wake_mask,
11067 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
11070 cfg->tokens_size = tokens_size;
11071 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
11079 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device *rdev,
11080 const struct wiphy_wowlan_support *wowlan,
11081 struct nlattr *attr,
11082 struct cfg80211_wowlan *trig)
11084 struct nlattr **tb;
11087 tb = kcalloc(NUM_NL80211_ATTR, sizeof(*tb), GFP_KERNEL);
11091 if (!(wowlan->flags & WIPHY_WOWLAN_NET_DETECT)) {
11096 err = nla_parse_nested(tb, NL80211_ATTR_MAX, attr, nl80211_policy,
11101 trig->nd_config = nl80211_parse_sched_scan(&rdev->wiphy, NULL, tb,
11102 wowlan->max_nd_match_sets);
11103 err = PTR_ERR_OR_ZERO(trig->nd_config);
11105 trig->nd_config = NULL;
11112 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
11114 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11115 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
11116 struct cfg80211_wowlan new_triggers = {};
11117 struct cfg80211_wowlan *ntrig;
11118 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
11120 bool prev_enabled = rdev->wiphy.wowlan_config;
11121 bool regular = false;
11124 return -EOPNOTSUPP;
11126 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
11127 cfg80211_rdev_free_wowlan(rdev);
11128 rdev->wiphy.wowlan_config = NULL;
11132 err = nla_parse_nested(tb, MAX_NL80211_WOWLAN_TRIG,
11133 info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS],
11134 nl80211_wowlan_policy, info->extack);
11138 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
11139 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
11141 new_triggers.any = true;
11144 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
11145 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
11147 new_triggers.disconnect = true;
11151 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
11152 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
11154 new_triggers.magic_pkt = true;
11158 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
11161 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
11162 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
11164 new_triggers.gtk_rekey_failure = true;
11168 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
11169 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
11171 new_triggers.eap_identity_req = true;
11175 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
11176 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
11178 new_triggers.four_way_handshake = true;
11182 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
11183 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
11185 new_triggers.rfkill_release = true;
11189 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
11190 struct nlattr *pat;
11191 int n_patterns = 0;
11192 int rem, pat_len, mask_len, pkt_offset;
11193 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
11197 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
11200 if (n_patterns > wowlan->n_patterns)
11203 new_triggers.patterns = kcalloc(n_patterns,
11204 sizeof(new_triggers.patterns[0]),
11206 if (!new_triggers.patterns)
11209 new_triggers.n_patterns = n_patterns;
11212 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
11216 err = nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
11217 nl80211_packet_pattern_policy,
11223 if (!pat_tb[NL80211_PKTPAT_MASK] ||
11224 !pat_tb[NL80211_PKTPAT_PATTERN])
11226 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
11227 mask_len = DIV_ROUND_UP(pat_len, 8);
11228 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
11230 if (pat_len > wowlan->pattern_max_len ||
11231 pat_len < wowlan->pattern_min_len)
11234 if (!pat_tb[NL80211_PKTPAT_OFFSET])
11237 pkt_offset = nla_get_u32(
11238 pat_tb[NL80211_PKTPAT_OFFSET]);
11239 if (pkt_offset > wowlan->max_pkt_offset)
11241 new_triggers.patterns[i].pkt_offset = pkt_offset;
11243 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
11248 new_triggers.patterns[i].mask = mask_pat;
11249 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
11251 mask_pat += mask_len;
11252 new_triggers.patterns[i].pattern = mask_pat;
11253 new_triggers.patterns[i].pattern_len = pat_len;
11255 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
11261 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
11263 err = nl80211_parse_wowlan_tcp(
11264 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
11270 if (tb[NL80211_WOWLAN_TRIG_NET_DETECT]) {
11272 err = nl80211_parse_wowlan_nd(
11273 rdev, wowlan, tb[NL80211_WOWLAN_TRIG_NET_DETECT],
11279 /* The 'any' trigger means the device continues operating more or less
11280 * as in its normal operation mode and wakes up the host on most of the
11281 * normal interrupts (like packet RX, ...)
11282 * It therefore makes little sense to combine with the more constrained
11283 * wakeup trigger modes.
11285 if (new_triggers.any && regular) {
11290 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
11295 cfg80211_rdev_free_wowlan(rdev);
11296 rdev->wiphy.wowlan_config = ntrig;
11299 if (rdev->ops->set_wakeup &&
11300 prev_enabled != !!rdev->wiphy.wowlan_config)
11301 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
11305 for (i = 0; i < new_triggers.n_patterns; i++)
11306 kfree(new_triggers.patterns[i].mask);
11307 kfree(new_triggers.patterns);
11308 if (new_triggers.tcp && new_triggers.tcp->sock)
11309 sock_release(new_triggers.tcp->sock);
11310 kfree(new_triggers.tcp);
11311 kfree(new_triggers.nd_config);
11316 static int nl80211_send_coalesce_rules(struct sk_buff *msg,
11317 struct cfg80211_registered_device *rdev)
11319 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
11321 struct cfg80211_coalesce_rules *rule;
11323 if (!rdev->coalesce->n_rules)
11326 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
11330 for (i = 0; i < rdev->coalesce->n_rules; i++) {
11331 nl_rule = nla_nest_start(msg, i + 1);
11335 rule = &rdev->coalesce->rules[i];
11336 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
11340 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
11344 nl_pats = nla_nest_start(msg,
11345 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
11349 for (j = 0; j < rule->n_patterns; j++) {
11350 nl_pat = nla_nest_start(msg, j + 1);
11353 pat_len = rule->patterns[j].pattern_len;
11354 if (nla_put(msg, NL80211_PKTPAT_MASK,
11355 DIV_ROUND_UP(pat_len, 8),
11356 rule->patterns[j].mask) ||
11357 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
11358 rule->patterns[j].pattern) ||
11359 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
11360 rule->patterns[j].pkt_offset))
11362 nla_nest_end(msg, nl_pat);
11364 nla_nest_end(msg, nl_pats);
11365 nla_nest_end(msg, nl_rule);
11367 nla_nest_end(msg, nl_rules);
11372 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
11374 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11375 struct sk_buff *msg;
11378 if (!rdev->wiphy.coalesce)
11379 return -EOPNOTSUPP;
11381 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11385 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11386 NL80211_CMD_GET_COALESCE);
11388 goto nla_put_failure;
11390 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
11391 goto nla_put_failure;
11393 genlmsg_end(msg, hdr);
11394 return genlmsg_reply(msg, info);
11401 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
11403 struct cfg80211_coalesce *coalesce = rdev->coalesce;
11405 struct cfg80211_coalesce_rules *rule;
11410 for (i = 0; i < coalesce->n_rules; i++) {
11411 rule = &coalesce->rules[i];
11412 for (j = 0; j < rule->n_patterns; j++)
11413 kfree(rule->patterns[j].mask);
11414 kfree(rule->patterns);
11416 kfree(coalesce->rules);
11418 rdev->coalesce = NULL;
11421 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
11422 struct nlattr *rule,
11423 struct cfg80211_coalesce_rules *new_rule)
11426 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
11427 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
11428 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
11429 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
11431 err = nla_parse_nested(tb, NL80211_ATTR_COALESCE_RULE_MAX, rule,
11432 nl80211_coalesce_policy, NULL);
11436 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
11438 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
11439 if (new_rule->delay > coalesce->max_delay)
11442 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
11443 new_rule->condition =
11444 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
11446 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
11449 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
11452 if (n_patterns > coalesce->n_patterns)
11455 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
11457 if (!new_rule->patterns)
11460 new_rule->n_patterns = n_patterns;
11463 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
11467 err = nla_parse_nested(pat_tb, MAX_NL80211_PKTPAT, pat,
11468 nl80211_packet_pattern_policy, NULL);
11472 if (!pat_tb[NL80211_PKTPAT_MASK] ||
11473 !pat_tb[NL80211_PKTPAT_PATTERN])
11475 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
11476 mask_len = DIV_ROUND_UP(pat_len, 8);
11477 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
11479 if (pat_len > coalesce->pattern_max_len ||
11480 pat_len < coalesce->pattern_min_len)
11483 if (!pat_tb[NL80211_PKTPAT_OFFSET])
11486 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
11487 if (pkt_offset > coalesce->max_pkt_offset)
11489 new_rule->patterns[i].pkt_offset = pkt_offset;
11491 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
11495 new_rule->patterns[i].mask = mask_pat;
11496 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
11499 mask_pat += mask_len;
11500 new_rule->patterns[i].pattern = mask_pat;
11501 new_rule->patterns[i].pattern_len = pat_len;
11502 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
11510 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
11512 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11513 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
11514 struct cfg80211_coalesce new_coalesce = {};
11515 struct cfg80211_coalesce *n_coalesce;
11516 int err, rem_rule, n_rules = 0, i, j;
11517 struct nlattr *rule;
11518 struct cfg80211_coalesce_rules *tmp_rule;
11520 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
11521 return -EOPNOTSUPP;
11523 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
11524 cfg80211_rdev_free_coalesce(rdev);
11525 rdev_set_coalesce(rdev, NULL);
11529 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
11532 if (n_rules > coalesce->n_rules)
11535 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
11537 if (!new_coalesce.rules)
11540 new_coalesce.n_rules = n_rules;
11543 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
11545 err = nl80211_parse_coalesce_rule(rdev, rule,
11546 &new_coalesce.rules[i]);
11553 err = rdev_set_coalesce(rdev, &new_coalesce);
11557 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
11562 cfg80211_rdev_free_coalesce(rdev);
11563 rdev->coalesce = n_coalesce;
11567 for (i = 0; i < new_coalesce.n_rules; i++) {
11568 tmp_rule = &new_coalesce.rules[i];
11569 for (j = 0; j < tmp_rule->n_patterns; j++)
11570 kfree(tmp_rule->patterns[j].mask);
11571 kfree(tmp_rule->patterns);
11573 kfree(new_coalesce.rules);
11578 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
11580 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11581 struct net_device *dev = info->user_ptr[1];
11582 struct wireless_dev *wdev = dev->ieee80211_ptr;
11583 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
11584 struct cfg80211_gtk_rekey_data rekey_data;
11587 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
11590 err = nla_parse_nested(tb, MAX_NL80211_REKEY_DATA,
11591 info->attrs[NL80211_ATTR_REKEY_DATA],
11592 nl80211_rekey_policy, info->extack);
11596 if (!tb[NL80211_REKEY_DATA_REPLAY_CTR] || !tb[NL80211_REKEY_DATA_KEK] ||
11597 !tb[NL80211_REKEY_DATA_KCK])
11599 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
11601 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
11603 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
11606 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
11607 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
11608 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
11611 if (!wdev->current_bss) {
11616 if (!rdev->ops->set_rekey_data) {
11621 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
11627 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
11628 struct genl_info *info)
11630 struct net_device *dev = info->user_ptr[1];
11631 struct wireless_dev *wdev = dev->ieee80211_ptr;
11633 if (wdev->iftype != NL80211_IFTYPE_AP &&
11634 wdev->iftype != NL80211_IFTYPE_P2P_GO)
11637 if (wdev->ap_unexpected_nlportid)
11640 wdev->ap_unexpected_nlportid = info->snd_portid;
11644 static int nl80211_probe_client(struct sk_buff *skb,
11645 struct genl_info *info)
11647 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11648 struct net_device *dev = info->user_ptr[1];
11649 struct wireless_dev *wdev = dev->ieee80211_ptr;
11650 struct sk_buff *msg;
11656 if (wdev->iftype != NL80211_IFTYPE_AP &&
11657 wdev->iftype != NL80211_IFTYPE_P2P_GO)
11658 return -EOPNOTSUPP;
11660 if (!info->attrs[NL80211_ATTR_MAC])
11663 if (!rdev->ops->probe_client)
11664 return -EOPNOTSUPP;
11666 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
11670 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
11671 NL80211_CMD_PROBE_CLIENT);
11677 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
11679 err = rdev_probe_client(rdev, dev, addr, &cookie);
11683 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
11685 goto nla_put_failure;
11687 genlmsg_end(msg, hdr);
11689 return genlmsg_reply(msg, info);
11698 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
11700 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11701 struct cfg80211_beacon_registration *reg, *nreg;
11704 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
11705 return -EOPNOTSUPP;
11707 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
11711 /* First, check if already registered. */
11712 spin_lock_bh(&rdev->beacon_registrations_lock);
11713 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
11714 if (reg->nlportid == info->snd_portid) {
11719 /* Add it to the list */
11720 nreg->nlportid = info->snd_portid;
11721 list_add(&nreg->list, &rdev->beacon_registrations);
11723 spin_unlock_bh(&rdev->beacon_registrations_lock);
11727 spin_unlock_bh(&rdev->beacon_registrations_lock);
11732 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
11734 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11735 struct wireless_dev *wdev = info->user_ptr[1];
11738 if (!rdev->ops->start_p2p_device)
11739 return -EOPNOTSUPP;
11741 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11742 return -EOPNOTSUPP;
11744 if (wdev_running(wdev))
11747 if (rfkill_blocked(rdev->rfkill))
11750 err = rdev_start_p2p_device(rdev, wdev);
11754 wdev->is_running = true;
11760 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
11762 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11763 struct wireless_dev *wdev = info->user_ptr[1];
11765 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
11766 return -EOPNOTSUPP;
11768 if (!rdev->ops->stop_p2p_device)
11769 return -EOPNOTSUPP;
11771 cfg80211_stop_p2p_device(rdev, wdev);
11776 static int nl80211_start_nan(struct sk_buff *skb, struct genl_info *info)
11778 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11779 struct wireless_dev *wdev = info->user_ptr[1];
11780 struct cfg80211_nan_conf conf = {};
11783 if (wdev->iftype != NL80211_IFTYPE_NAN)
11784 return -EOPNOTSUPP;
11786 if (wdev_running(wdev))
11789 if (rfkill_blocked(rdev->rfkill))
11792 if (!info->attrs[NL80211_ATTR_NAN_MASTER_PREF])
11796 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
11798 if (info->attrs[NL80211_ATTR_BANDS]) {
11799 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
11801 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
11802 return -EOPNOTSUPP;
11804 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
11807 conf.bands = bands;
11810 err = rdev_start_nan(rdev, wdev, &conf);
11814 wdev->is_running = true;
11820 static int nl80211_stop_nan(struct sk_buff *skb, struct genl_info *info)
11822 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11823 struct wireless_dev *wdev = info->user_ptr[1];
11825 if (wdev->iftype != NL80211_IFTYPE_NAN)
11826 return -EOPNOTSUPP;
11828 cfg80211_stop_nan(rdev, wdev);
11833 static int validate_nan_filter(struct nlattr *filter_attr)
11835 struct nlattr *attr;
11836 int len = 0, n_entries = 0, rem;
11838 nla_for_each_nested(attr, filter_attr, rem) {
11839 len += nla_len(attr);
11849 static int handle_nan_filter(struct nlattr *attr_filter,
11850 struct cfg80211_nan_func *func,
11853 struct nlattr *attr;
11854 int n_entries, rem, i;
11855 struct cfg80211_nan_func_filter *filter;
11857 n_entries = validate_nan_filter(attr_filter);
11861 BUILD_BUG_ON(sizeof(*func->rx_filters) != sizeof(*func->tx_filters));
11863 filter = kcalloc(n_entries, sizeof(*func->rx_filters), GFP_KERNEL);
11868 nla_for_each_nested(attr, attr_filter, rem) {
11869 filter[i].filter = nla_memdup(attr, GFP_KERNEL);
11870 filter[i].len = nla_len(attr);
11874 func->num_tx_filters = n_entries;
11875 func->tx_filters = filter;
11877 func->num_rx_filters = n_entries;
11878 func->rx_filters = filter;
11884 static int nl80211_nan_add_func(struct sk_buff *skb,
11885 struct genl_info *info)
11887 struct cfg80211_registered_device *rdev = info->user_ptr[0];
11888 struct wireless_dev *wdev = info->user_ptr[1];
11889 struct nlattr *tb[NUM_NL80211_NAN_FUNC_ATTR], *func_attr;
11890 struct cfg80211_nan_func *func;
11891 struct sk_buff *msg = NULL;
11895 if (wdev->iftype != NL80211_IFTYPE_NAN)
11896 return -EOPNOTSUPP;
11898 if (!wdev_running(wdev))
11901 if (!info->attrs[NL80211_ATTR_NAN_FUNC])
11904 err = nla_parse_nested(tb, NL80211_NAN_FUNC_ATTR_MAX,
11905 info->attrs[NL80211_ATTR_NAN_FUNC],
11906 nl80211_nan_func_policy, info->extack);
11910 func = kzalloc(sizeof(*func), GFP_KERNEL);
11914 func->cookie = cfg80211_assign_cookie(rdev);
11916 if (!tb[NL80211_NAN_FUNC_TYPE] ||
11917 nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]) > NL80211_NAN_FUNC_MAX_TYPE) {
11923 func->type = nla_get_u8(tb[NL80211_NAN_FUNC_TYPE]);
11925 if (!tb[NL80211_NAN_FUNC_SERVICE_ID]) {
11930 memcpy(func->service_id, nla_data(tb[NL80211_NAN_FUNC_SERVICE_ID]),
11931 sizeof(func->service_id));
11933 func->close_range =
11934 nla_get_flag(tb[NL80211_NAN_FUNC_CLOSE_RANGE]);
11936 if (tb[NL80211_NAN_FUNC_SERVICE_INFO]) {
11937 func->serv_spec_info_len =
11938 nla_len(tb[NL80211_NAN_FUNC_SERVICE_INFO]);
11939 func->serv_spec_info =
11940 kmemdup(nla_data(tb[NL80211_NAN_FUNC_SERVICE_INFO]),
11941 func->serv_spec_info_len,
11943 if (!func->serv_spec_info) {
11949 if (tb[NL80211_NAN_FUNC_TTL])
11950 func->ttl = nla_get_u32(tb[NL80211_NAN_FUNC_TTL]);
11952 switch (func->type) {
11953 case NL80211_NAN_FUNC_PUBLISH:
11954 if (!tb[NL80211_NAN_FUNC_PUBLISH_TYPE]) {
11959 func->publish_type =
11960 nla_get_u8(tb[NL80211_NAN_FUNC_PUBLISH_TYPE]);
11961 func->publish_bcast =
11962 nla_get_flag(tb[NL80211_NAN_FUNC_PUBLISH_BCAST]);
11964 if ((!(func->publish_type & NL80211_NAN_SOLICITED_PUBLISH)) &&
11965 func->publish_bcast) {
11970 case NL80211_NAN_FUNC_SUBSCRIBE:
11971 func->subscribe_active =
11972 nla_get_flag(tb[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE]);
11974 case NL80211_NAN_FUNC_FOLLOW_UP:
11975 if (!tb[NL80211_NAN_FUNC_FOLLOW_UP_ID] ||
11976 !tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID] ||
11977 !tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]) {
11982 func->followup_id =
11983 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_ID]);
11984 func->followup_reqid =
11985 nla_get_u8(tb[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID]);
11986 memcpy(func->followup_dest.addr,
11987 nla_data(tb[NL80211_NAN_FUNC_FOLLOW_UP_DEST]),
11988 sizeof(func->followup_dest.addr));
11999 if (tb[NL80211_NAN_FUNC_SRF]) {
12000 struct nlattr *srf_tb[NUM_NL80211_NAN_SRF_ATTR];
12002 err = nla_parse_nested(srf_tb, NL80211_NAN_SRF_ATTR_MAX,
12003 tb[NL80211_NAN_FUNC_SRF],
12004 nl80211_nan_srf_policy, info->extack);
12008 func->srf_include =
12009 nla_get_flag(srf_tb[NL80211_NAN_SRF_INCLUDE]);
12011 if (srf_tb[NL80211_NAN_SRF_BF]) {
12012 if (srf_tb[NL80211_NAN_SRF_MAC_ADDRS] ||
12013 !srf_tb[NL80211_NAN_SRF_BF_IDX]) {
12019 nla_len(srf_tb[NL80211_NAN_SRF_BF]);
12021 kmemdup(nla_data(srf_tb[NL80211_NAN_SRF_BF]),
12022 func->srf_bf_len, GFP_KERNEL);
12023 if (!func->srf_bf) {
12029 nla_get_u8(srf_tb[NL80211_NAN_SRF_BF_IDX]);
12031 struct nlattr *attr, *mac_attr =
12032 srf_tb[NL80211_NAN_SRF_MAC_ADDRS];
12033 int n_entries, rem, i = 0;
12040 n_entries = validate_acl_mac_addrs(mac_attr);
12041 if (n_entries <= 0) {
12046 func->srf_num_macs = n_entries;
12048 kcalloc(n_entries, sizeof(*func->srf_macs),
12050 if (!func->srf_macs) {
12055 nla_for_each_nested(attr, mac_attr, rem)
12056 memcpy(func->srf_macs[i++].addr, nla_data(attr),
12057 sizeof(*func->srf_macs));
12061 if (tb[NL80211_NAN_FUNC_TX_MATCH_FILTER]) {
12062 err = handle_nan_filter(tb[NL80211_NAN_FUNC_TX_MATCH_FILTER],
12068 if (tb[NL80211_NAN_FUNC_RX_MATCH_FILTER]) {
12069 err = handle_nan_filter(tb[NL80211_NAN_FUNC_RX_MATCH_FILTER],
12075 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12081 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12082 NL80211_CMD_ADD_NAN_FUNCTION);
12083 /* This can't really happen - we just allocated 4KB */
12084 if (WARN_ON(!hdr)) {
12089 err = rdev_add_nan_func(rdev, wdev, func);
12092 cfg80211_free_nan_func(func);
12097 /* propagate the instance id and cookie to userspace */
12098 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, func->cookie,
12100 goto nla_put_failure;
12102 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
12104 goto nla_put_failure;
12106 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID,
12107 func->instance_id))
12108 goto nla_put_failure;
12110 nla_nest_end(msg, func_attr);
12112 genlmsg_end(msg, hdr);
12113 return genlmsg_reply(msg, info);
12120 static int nl80211_nan_del_func(struct sk_buff *skb,
12121 struct genl_info *info)
12123 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12124 struct wireless_dev *wdev = info->user_ptr[1];
12127 if (wdev->iftype != NL80211_IFTYPE_NAN)
12128 return -EOPNOTSUPP;
12130 if (!wdev_running(wdev))
12133 if (!info->attrs[NL80211_ATTR_COOKIE])
12136 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
12138 rdev_del_nan_func(rdev, wdev, cookie);
12143 static int nl80211_nan_change_config(struct sk_buff *skb,
12144 struct genl_info *info)
12146 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12147 struct wireless_dev *wdev = info->user_ptr[1];
12148 struct cfg80211_nan_conf conf = {};
12151 if (wdev->iftype != NL80211_IFTYPE_NAN)
12152 return -EOPNOTSUPP;
12154 if (!wdev_running(wdev))
12157 if (info->attrs[NL80211_ATTR_NAN_MASTER_PREF]) {
12159 nla_get_u8(info->attrs[NL80211_ATTR_NAN_MASTER_PREF]);
12160 if (conf.master_pref <= 1 || conf.master_pref == 255)
12163 changed |= CFG80211_NAN_CONF_CHANGED_PREF;
12166 if (info->attrs[NL80211_ATTR_BANDS]) {
12167 u32 bands = nla_get_u32(info->attrs[NL80211_ATTR_BANDS]);
12169 if (bands & ~(u32)wdev->wiphy->nan_supported_bands)
12170 return -EOPNOTSUPP;
12172 if (bands && !(bands & BIT(NL80211_BAND_2GHZ)))
12175 conf.bands = bands;
12176 changed |= CFG80211_NAN_CONF_CHANGED_BANDS;
12182 return rdev_nan_change_conf(rdev, wdev, &conf, changed);
12185 void cfg80211_nan_match(struct wireless_dev *wdev,
12186 struct cfg80211_nan_match_params *match, gfp_t gfp)
12188 struct wiphy *wiphy = wdev->wiphy;
12189 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12190 struct nlattr *match_attr, *local_func_attr, *peer_func_attr;
12191 struct sk_buff *msg;
12194 if (WARN_ON(!match->inst_id || !match->peer_inst_id || !match->addr))
12197 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12201 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NAN_MATCH);
12207 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12208 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12209 wdev->netdev->ifindex)) ||
12210 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
12212 goto nla_put_failure;
12214 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, match->cookie,
12215 NL80211_ATTR_PAD) ||
12216 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, match->addr))
12217 goto nla_put_failure;
12219 match_attr = nla_nest_start(msg, NL80211_ATTR_NAN_MATCH);
12221 goto nla_put_failure;
12223 local_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_LOCAL);
12224 if (!local_func_attr)
12225 goto nla_put_failure;
12227 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->inst_id))
12228 goto nla_put_failure;
12230 nla_nest_end(msg, local_func_attr);
12232 peer_func_attr = nla_nest_start(msg, NL80211_NAN_MATCH_FUNC_PEER);
12233 if (!peer_func_attr)
12234 goto nla_put_failure;
12236 if (nla_put_u8(msg, NL80211_NAN_FUNC_TYPE, match->type) ||
12237 nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, match->peer_inst_id))
12238 goto nla_put_failure;
12240 if (match->info && match->info_len &&
12241 nla_put(msg, NL80211_NAN_FUNC_SERVICE_INFO, match->info_len,
12243 goto nla_put_failure;
12245 nla_nest_end(msg, peer_func_attr);
12246 nla_nest_end(msg, match_attr);
12247 genlmsg_end(msg, hdr);
12249 if (!wdev->owner_nlportid)
12250 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12251 msg, 0, NL80211_MCGRP_NAN, gfp);
12253 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
12254 wdev->owner_nlportid);
12261 EXPORT_SYMBOL(cfg80211_nan_match);
12263 void cfg80211_nan_func_terminated(struct wireless_dev *wdev,
12265 enum nl80211_nan_func_term_reason reason,
12266 u64 cookie, gfp_t gfp)
12268 struct wiphy *wiphy = wdev->wiphy;
12269 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12270 struct sk_buff *msg;
12271 struct nlattr *func_attr;
12274 if (WARN_ON(!inst_id))
12277 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12281 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION);
12287 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12288 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
12289 wdev->netdev->ifindex)) ||
12290 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
12292 goto nla_put_failure;
12294 if (nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
12296 goto nla_put_failure;
12298 func_attr = nla_nest_start(msg, NL80211_ATTR_NAN_FUNC);
12300 goto nla_put_failure;
12302 if (nla_put_u8(msg, NL80211_NAN_FUNC_INSTANCE_ID, inst_id) ||
12303 nla_put_u8(msg, NL80211_NAN_FUNC_TERM_REASON, reason))
12304 goto nla_put_failure;
12306 nla_nest_end(msg, func_attr);
12307 genlmsg_end(msg, hdr);
12309 if (!wdev->owner_nlportid)
12310 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy),
12311 msg, 0, NL80211_MCGRP_NAN, gfp);
12313 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
12314 wdev->owner_nlportid);
12321 EXPORT_SYMBOL(cfg80211_nan_func_terminated);
12323 static int nl80211_get_protocol_features(struct sk_buff *skb,
12324 struct genl_info *info)
12327 struct sk_buff *msg;
12329 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12333 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
12334 NL80211_CMD_GET_PROTOCOL_FEATURES);
12336 goto nla_put_failure;
12338 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
12339 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
12340 goto nla_put_failure;
12342 genlmsg_end(msg, hdr);
12343 return genlmsg_reply(msg, info);
12350 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
12352 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12353 struct cfg80211_update_ft_ies_params ft_params;
12354 struct net_device *dev = info->user_ptr[1];
12356 if (!rdev->ops->update_ft_ies)
12357 return -EOPNOTSUPP;
12359 if (!info->attrs[NL80211_ATTR_MDID] ||
12360 !info->attrs[NL80211_ATTR_IE])
12363 memset(&ft_params, 0, sizeof(ft_params));
12364 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
12365 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
12366 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
12368 return rdev_update_ft_ies(rdev, dev, &ft_params);
12371 static int nl80211_crit_protocol_start(struct sk_buff *skb,
12372 struct genl_info *info)
12374 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12375 struct wireless_dev *wdev = info->user_ptr[1];
12376 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
12380 if (!rdev->ops->crit_proto_start)
12381 return -EOPNOTSUPP;
12383 if (WARN_ON(!rdev->ops->crit_proto_stop))
12386 if (rdev->crit_proto_nlportid)
12389 /* determine protocol if provided */
12390 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
12391 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
12393 if (proto >= NUM_NL80211_CRIT_PROTO)
12396 /* timeout must be provided */
12397 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
12401 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
12403 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
12406 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
12408 rdev->crit_proto_nlportid = info->snd_portid;
12413 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
12414 struct genl_info *info)
12416 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12417 struct wireless_dev *wdev = info->user_ptr[1];
12419 if (!rdev->ops->crit_proto_stop)
12420 return -EOPNOTSUPP;
12422 if (rdev->crit_proto_nlportid) {
12423 rdev->crit_proto_nlportid = 0;
12424 rdev_crit_proto_stop(rdev, wdev);
12429 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
12431 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12432 struct wireless_dev *wdev =
12433 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
12437 if (!rdev->wiphy.vendor_commands)
12438 return -EOPNOTSUPP;
12440 if (IS_ERR(wdev)) {
12441 err = PTR_ERR(wdev);
12442 if (err != -EINVAL)
12445 } else if (wdev->wiphy != &rdev->wiphy) {
12449 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
12450 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
12453 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
12454 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
12455 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
12456 const struct wiphy_vendor_command *vcmd;
12460 vcmd = &rdev->wiphy.vendor_commands[i];
12462 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
12465 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
12466 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
12469 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
12473 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
12474 if (!wdev_running(wdev))
12479 return -EOPNOTSUPP;
12484 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
12485 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
12486 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
12489 rdev->cur_cmd_info = info;
12490 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
12492 rdev->cur_cmd_info = NULL;
12496 return -EOPNOTSUPP;
12499 static int nl80211_prepare_vendor_dump(struct sk_buff *skb,
12500 struct netlink_callback *cb,
12501 struct cfg80211_registered_device **rdev,
12502 struct wireless_dev **wdev)
12504 struct nlattr **attrbuf = genl_family_attrbuf(&nl80211_fam);
12510 unsigned int data_len = 0;
12513 /* subtract the 1 again here */
12514 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
12515 struct wireless_dev *tmp;
12519 *rdev = wiphy_to_rdev(wiphy);
12523 list_for_each_entry(tmp, &wiphy->wdev_list, list) {
12524 if (tmp->identifier == cb->args[1] - 1) {
12531 /* keep rtnl locked in successful case */
12535 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize, attrbuf,
12536 nl80211_fam.maxattr, nl80211_policy, NULL);
12540 if (!attrbuf[NL80211_ATTR_VENDOR_ID] ||
12541 !attrbuf[NL80211_ATTR_VENDOR_SUBCMD])
12544 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk), attrbuf);
12548 *rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk), attrbuf);
12550 return PTR_ERR(*rdev);
12552 vid = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_ID]);
12553 subcmd = nla_get_u32(attrbuf[NL80211_ATTR_VENDOR_SUBCMD]);
12555 for (i = 0; i < (*rdev)->wiphy.n_vendor_commands; i++) {
12556 const struct wiphy_vendor_command *vcmd;
12558 vcmd = &(*rdev)->wiphy.vendor_commands[i];
12560 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
12564 return -EOPNOTSUPP;
12571 return -EOPNOTSUPP;
12573 if (attrbuf[NL80211_ATTR_VENDOR_DATA]) {
12574 data = nla_data(attrbuf[NL80211_ATTR_VENDOR_DATA]);
12575 data_len = nla_len(attrbuf[NL80211_ATTR_VENDOR_DATA]);
12578 /* 0 is the first index - add 1 to parse only once */
12579 cb->args[0] = (*rdev)->wiphy_idx + 1;
12580 /* add 1 to know if it was NULL */
12581 cb->args[1] = *wdev ? (*wdev)->identifier + 1 : 0;
12582 cb->args[2] = vcmd_idx;
12583 cb->args[3] = (unsigned long)data;
12584 cb->args[4] = data_len;
12586 /* keep rtnl locked in successful case */
12590 static int nl80211_vendor_cmd_dump(struct sk_buff *skb,
12591 struct netlink_callback *cb)
12593 struct cfg80211_registered_device *rdev;
12594 struct wireless_dev *wdev;
12595 unsigned int vcmd_idx;
12596 const struct wiphy_vendor_command *vcmd;
12600 struct nlattr *vendor_data;
12603 err = nl80211_prepare_vendor_dump(skb, cb, &rdev, &wdev);
12607 vcmd_idx = cb->args[2];
12608 data = (void *)cb->args[3];
12609 data_len = cb->args[4];
12610 vcmd = &rdev->wiphy.vendor_commands[vcmd_idx];
12612 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
12613 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
12618 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
12624 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
12625 if (!wdev_running(wdev)) {
12633 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
12634 cb->nlh->nlmsg_seq, NLM_F_MULTI,
12635 NL80211_CMD_VENDOR);
12639 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12640 (wdev && nla_put_u64_64bit(skb, NL80211_ATTR_WDEV,
12642 NL80211_ATTR_PAD))) {
12643 genlmsg_cancel(skb, hdr);
12647 vendor_data = nla_nest_start(skb, NL80211_ATTR_VENDOR_DATA);
12648 if (!vendor_data) {
12649 genlmsg_cancel(skb, hdr);
12653 err = vcmd->dumpit(&rdev->wiphy, wdev, skb, data, data_len,
12654 (unsigned long *)&cb->args[5]);
12655 nla_nest_end(skb, vendor_data);
12657 if (err == -ENOBUFS || err == -ENOENT) {
12658 genlmsg_cancel(skb, hdr);
12661 genlmsg_cancel(skb, hdr);
12665 genlmsg_end(skb, hdr);
12674 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
12675 enum nl80211_commands cmd,
12676 enum nl80211_attrs attr,
12679 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12681 if (WARN_ON(!rdev->cur_cmd_info))
12684 return __cfg80211_alloc_vendor_skb(rdev, NULL, approxlen,
12685 rdev->cur_cmd_info->snd_portid,
12686 rdev->cur_cmd_info->snd_seq,
12687 cmd, attr, NULL, GFP_KERNEL);
12689 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
12691 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
12693 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
12694 void *hdr = ((void **)skb->cb)[1];
12695 struct nlattr *data = ((void **)skb->cb)[2];
12697 /* clear CB data for netlink core to own from now on */
12698 memset(skb->cb, 0, sizeof(skb->cb));
12700 if (WARN_ON(!rdev->cur_cmd_info)) {
12705 nla_nest_end(skb, data);
12706 genlmsg_end(skb, hdr);
12707 return genlmsg_reply(skb, rdev->cur_cmd_info);
12709 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
12711 static int nl80211_set_qos_map(struct sk_buff *skb,
12712 struct genl_info *info)
12714 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12715 struct cfg80211_qos_map *qos_map = NULL;
12716 struct net_device *dev = info->user_ptr[1];
12717 u8 *pos, len, num_des, des_len, des;
12720 if (!rdev->ops->set_qos_map)
12721 return -EOPNOTSUPP;
12723 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
12724 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
12725 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
12727 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
12728 len > IEEE80211_QOS_MAP_LEN_MAX)
12731 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
12735 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
12737 des_len = num_des *
12738 sizeof(struct cfg80211_dscp_exception);
12739 memcpy(qos_map->dscp_exception, pos, des_len);
12740 qos_map->num_des = num_des;
12741 for (des = 0; des < num_des; des++) {
12742 if (qos_map->dscp_exception[des].up > 7) {
12749 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
12752 wdev_lock(dev->ieee80211_ptr);
12753 ret = nl80211_key_allowed(dev->ieee80211_ptr);
12755 ret = rdev_set_qos_map(rdev, dev, qos_map);
12756 wdev_unlock(dev->ieee80211_ptr);
12762 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
12764 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12765 struct net_device *dev = info->user_ptr[1];
12766 struct wireless_dev *wdev = dev->ieee80211_ptr;
12769 u16 admitted_time = 0;
12772 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
12773 return -EOPNOTSUPP;
12775 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
12776 !info->attrs[NL80211_ATTR_USER_PRIO])
12779 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12780 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
12782 /* WMM uses TIDs 0-7 even for TSPEC */
12783 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
12784 /* TODO: handle 802.11 TSPEC/admission control
12785 * need more attributes for that (e.g. BA session requirement);
12786 * change the WMM adminssion test above to allow both then
12791 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12793 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
12795 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
12796 if (!admitted_time)
12801 switch (wdev->iftype) {
12802 case NL80211_IFTYPE_STATION:
12803 case NL80211_IFTYPE_P2P_CLIENT:
12804 if (wdev->current_bss)
12813 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
12820 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
12822 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12823 struct net_device *dev = info->user_ptr[1];
12824 struct wireless_dev *wdev = dev->ieee80211_ptr;
12829 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
12832 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
12833 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
12836 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
12842 static int nl80211_tdls_channel_switch(struct sk_buff *skb,
12843 struct genl_info *info)
12845 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12846 struct net_device *dev = info->user_ptr[1];
12847 struct wireless_dev *wdev = dev->ieee80211_ptr;
12848 struct cfg80211_chan_def chandef = {};
12853 if (!rdev->ops->tdls_channel_switch ||
12854 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12855 return -EOPNOTSUPP;
12857 switch (dev->ieee80211_ptr->iftype) {
12858 case NL80211_IFTYPE_STATION:
12859 case NL80211_IFTYPE_P2P_CLIENT:
12862 return -EOPNOTSUPP;
12865 if (!info->attrs[NL80211_ATTR_MAC] ||
12866 !info->attrs[NL80211_ATTR_OPER_CLASS])
12869 err = nl80211_parse_chandef(rdev, info, &chandef);
12874 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
12875 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
12876 * specification is not defined for them.
12878 if (chandef.chan->band == NL80211_BAND_2GHZ &&
12879 chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
12880 chandef.width != NL80211_CHAN_WIDTH_20)
12883 /* we will be active on the TDLS link */
12884 if (!cfg80211_reg_can_beacon_relax(&rdev->wiphy, &chandef,
12888 /* don't allow switching to DFS channels */
12889 if (cfg80211_chandef_dfs_required(wdev->wiphy, &chandef, wdev->iftype))
12892 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12893 oper_class = nla_get_u8(info->attrs[NL80211_ATTR_OPER_CLASS]);
12896 err = rdev_tdls_channel_switch(rdev, dev, addr, oper_class, &chandef);
12902 static int nl80211_tdls_cancel_channel_switch(struct sk_buff *skb,
12903 struct genl_info *info)
12905 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12906 struct net_device *dev = info->user_ptr[1];
12907 struct wireless_dev *wdev = dev->ieee80211_ptr;
12910 if (!rdev->ops->tdls_channel_switch ||
12911 !rdev->ops->tdls_cancel_channel_switch ||
12912 !(rdev->wiphy.features & NL80211_FEATURE_TDLS_CHANNEL_SWITCH))
12913 return -EOPNOTSUPP;
12915 switch (dev->ieee80211_ptr->iftype) {
12916 case NL80211_IFTYPE_STATION:
12917 case NL80211_IFTYPE_P2P_CLIENT:
12920 return -EOPNOTSUPP;
12923 if (!info->attrs[NL80211_ATTR_MAC])
12926 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
12929 rdev_tdls_cancel_channel_switch(rdev, dev, addr);
12935 static int nl80211_set_multicast_to_unicast(struct sk_buff *skb,
12936 struct genl_info *info)
12938 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12939 struct net_device *dev = info->user_ptr[1];
12940 struct wireless_dev *wdev = dev->ieee80211_ptr;
12941 const struct nlattr *nla;
12944 if (!rdev->ops->set_multicast_to_unicast)
12945 return -EOPNOTSUPP;
12947 if (wdev->iftype != NL80211_IFTYPE_AP &&
12948 wdev->iftype != NL80211_IFTYPE_P2P_GO)
12949 return -EOPNOTSUPP;
12951 nla = info->attrs[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED];
12952 enabled = nla_get_flag(nla);
12954 return rdev_set_multicast_to_unicast(rdev, dev, enabled);
12957 static int nl80211_set_pmk(struct sk_buff *skb, struct genl_info *info)
12959 struct cfg80211_registered_device *rdev = info->user_ptr[0];
12960 struct net_device *dev = info->user_ptr[1];
12961 struct wireless_dev *wdev = dev->ieee80211_ptr;
12962 struct cfg80211_pmk_conf pmk_conf = {};
12965 if (wdev->iftype != NL80211_IFTYPE_STATION &&
12966 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
12967 return -EOPNOTSUPP;
12969 if (!wiphy_ext_feature_isset(&rdev->wiphy,
12970 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
12971 return -EOPNOTSUPP;
12973 if (!info->attrs[NL80211_ATTR_MAC] || !info->attrs[NL80211_ATTR_PMK])
12977 if (!wdev->current_bss) {
12982 pmk_conf.aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
12983 if (memcmp(pmk_conf.aa, wdev->current_bss->pub.bssid, ETH_ALEN)) {
12988 pmk_conf.pmk = nla_data(info->attrs[NL80211_ATTR_PMK]);
12989 pmk_conf.pmk_len = nla_len(info->attrs[NL80211_ATTR_PMK]);
12990 if (pmk_conf.pmk_len != WLAN_PMK_LEN &&
12991 pmk_conf.pmk_len != WLAN_PMK_LEN_SUITE_B_192) {
12996 if (info->attrs[NL80211_ATTR_PMKR0_NAME]) {
12997 int r0_name_len = nla_len(info->attrs[NL80211_ATTR_PMKR0_NAME]);
12999 if (r0_name_len != WLAN_PMK_NAME_LEN) {
13004 pmk_conf.pmk_r0_name =
13005 nla_data(info->attrs[NL80211_ATTR_PMKR0_NAME]);
13008 ret = rdev_set_pmk(rdev, dev, &pmk_conf);
13014 static int nl80211_del_pmk(struct sk_buff *skb, struct genl_info *info)
13016 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13017 struct net_device *dev = info->user_ptr[1];
13018 struct wireless_dev *wdev = dev->ieee80211_ptr;
13022 if (wdev->iftype != NL80211_IFTYPE_STATION &&
13023 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
13024 return -EOPNOTSUPP;
13026 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13027 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X))
13028 return -EOPNOTSUPP;
13030 if (!info->attrs[NL80211_ATTR_MAC])
13034 aa = nla_data(info->attrs[NL80211_ATTR_MAC]);
13035 ret = rdev_del_pmk(rdev, dev, aa);
13041 static int nl80211_external_auth(struct sk_buff *skb, struct genl_info *info)
13043 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13044 struct net_device *dev = info->user_ptr[1];
13045 struct cfg80211_external_auth_params params;
13047 if (!rdev->ops->external_auth)
13048 return -EOPNOTSUPP;
13050 if (!info->attrs[NL80211_ATTR_SSID])
13053 if (!info->attrs[NL80211_ATTR_BSSID])
13056 if (!info->attrs[NL80211_ATTR_STATUS_CODE])
13059 memset(¶ms, 0, sizeof(params));
13061 params.ssid.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
13062 if (params.ssid.ssid_len == 0 ||
13063 params.ssid.ssid_len > IEEE80211_MAX_SSID_LEN)
13065 memcpy(params.ssid.ssid, nla_data(info->attrs[NL80211_ATTR_SSID]),
13066 params.ssid.ssid_len);
13068 memcpy(params.bssid, nla_data(info->attrs[NL80211_ATTR_BSSID]),
13071 params.status = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
13073 return rdev_external_auth(rdev, dev, ¶ms);
13076 static int nl80211_tx_control_port(struct sk_buff *skb, struct genl_info *info)
13078 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13079 struct net_device *dev = info->user_ptr[1];
13080 struct wireless_dev *wdev = dev->ieee80211_ptr;
13088 if (!wiphy_ext_feature_isset(&rdev->wiphy,
13089 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211))
13090 return -EOPNOTSUPP;
13092 if (!rdev->ops->tx_control_port)
13093 return -EOPNOTSUPP;
13095 if (!info->attrs[NL80211_ATTR_FRAME] ||
13096 !info->attrs[NL80211_ATTR_MAC] ||
13097 !info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
13098 GENL_SET_ERR_MSG(info, "Frame, MAC or ethertype missing");
13104 switch (wdev->iftype) {
13105 case NL80211_IFTYPE_AP:
13106 case NL80211_IFTYPE_P2P_GO:
13107 case NL80211_IFTYPE_MESH_POINT:
13109 case NL80211_IFTYPE_ADHOC:
13110 case NL80211_IFTYPE_STATION:
13111 case NL80211_IFTYPE_P2P_CLIENT:
13112 if (wdev->current_bss)
13123 buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
13124 len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
13125 dest = nla_data(info->attrs[NL80211_ATTR_MAC]);
13126 proto = nla_get_u16(info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
13128 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
13130 return rdev_tx_control_port(rdev, dev, buf, len,
13131 dest, cpu_to_be16(proto), noencrypt);
13138 static int nl80211_get_ftm_responder_stats(struct sk_buff *skb,
13139 struct genl_info *info)
13141 struct cfg80211_registered_device *rdev = info->user_ptr[0];
13142 struct net_device *dev = info->user_ptr[1];
13143 struct wireless_dev *wdev = dev->ieee80211_ptr;
13144 struct cfg80211_ftm_responder_stats ftm_stats = {};
13145 struct sk_buff *msg;
13147 struct nlattr *ftm_stats_attr;
13150 if (wdev->iftype != NL80211_IFTYPE_AP || !wdev->beacon_interval)
13151 return -EOPNOTSUPP;
13153 err = rdev_get_ftm_responder_stats(rdev, dev, &ftm_stats);
13157 if (!ftm_stats.filled)
13160 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
13164 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
13165 NL80211_CMD_GET_FTM_RESPONDER_STATS);
13169 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
13170 goto nla_put_failure;
13172 ftm_stats_attr = nla_nest_start(msg, NL80211_ATTR_FTM_RESPONDER_STATS);
13173 if (!ftm_stats_attr)
13174 goto nla_put_failure;
13176 #define SET_FTM(field, name, type) \
13177 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
13178 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \
13179 ftm_stats.field)) \
13180 goto nla_put_failure; } while (0)
13181 #define SET_FTM_U64(field, name) \
13182 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
13183 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \
13184 ftm_stats.field, NL80211_FTM_STATS_PAD)) \
13185 goto nla_put_failure; } while (0)
13187 SET_FTM(success_num, SUCCESS_NUM, u32);
13188 SET_FTM(partial_num, PARTIAL_NUM, u32);
13189 SET_FTM(failed_num, FAILED_NUM, u32);
13190 SET_FTM(asap_num, ASAP_NUM, u32);
13191 SET_FTM(non_asap_num, NON_ASAP_NUM, u32);
13192 SET_FTM_U64(total_duration_ms, TOTAL_DURATION_MSEC);
13193 SET_FTM(unknown_triggers_num, UNKNOWN_TRIGGERS_NUM, u32);
13194 SET_FTM(reschedule_requests_num, RESCHEDULE_REQUESTS_NUM, u32);
13195 SET_FTM(out_of_window_triggers_num, OUT_OF_WINDOW_TRIGGERS_NUM, u32);
13198 nla_nest_end(msg, ftm_stats_attr);
13200 genlmsg_end(msg, hdr);
13201 return genlmsg_reply(msg, info);
13208 #define NL80211_FLAG_NEED_WIPHY 0x01
13209 #define NL80211_FLAG_NEED_NETDEV 0x02
13210 #define NL80211_FLAG_NEED_RTNL 0x04
13211 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
13212 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
13213 NL80211_FLAG_CHECK_NETDEV_UP)
13214 #define NL80211_FLAG_NEED_WDEV 0x10
13215 /* If a netdev is associated, it must be UP, P2P must be started */
13216 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
13217 NL80211_FLAG_CHECK_NETDEV_UP)
13218 #define NL80211_FLAG_CLEAR_SKB 0x20
13220 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
13221 struct genl_info *info)
13223 struct cfg80211_registered_device *rdev;
13224 struct wireless_dev *wdev;
13225 struct net_device *dev;
13226 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
13231 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
13232 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
13233 if (IS_ERR(rdev)) {
13236 return PTR_ERR(rdev);
13238 info->user_ptr[0] = rdev;
13239 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
13240 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
13243 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
13245 if (IS_ERR(wdev)) {
13248 return PTR_ERR(wdev);
13251 dev = wdev->netdev;
13252 rdev = wiphy_to_rdev(wdev->wiphy);
13254 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
13261 info->user_ptr[1] = dev;
13263 info->user_ptr[1] = wdev;
13266 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
13267 !wdev_running(wdev)) {
13276 info->user_ptr[0] = rdev;
13282 static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
13283 struct genl_info *info)
13285 if (info->user_ptr[1]) {
13286 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
13287 struct wireless_dev *wdev = info->user_ptr[1];
13290 dev_put(wdev->netdev);
13292 dev_put(info->user_ptr[1]);
13296 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
13299 /* If needed, clear the netlink message payload from the SKB
13300 * as it might contain key data that shouldn't stick around on
13301 * the heap after the SKB is freed. The netlink message header
13302 * is still needed for further processing, so leave it intact.
13304 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
13305 struct nlmsghdr *nlh = nlmsg_hdr(skb);
13307 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
13311 static const struct genl_ops nl80211_ops[] = {
13313 .cmd = NL80211_CMD_GET_WIPHY,
13314 .doit = nl80211_get_wiphy,
13315 .dumpit = nl80211_dump_wiphy,
13316 .done = nl80211_dump_wiphy_done,
13317 .policy = nl80211_policy,
13318 /* can be retrieved by unprivileged users */
13319 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13320 NL80211_FLAG_NEED_RTNL,
13323 .cmd = NL80211_CMD_SET_WIPHY,
13324 .doit = nl80211_set_wiphy,
13325 .policy = nl80211_policy,
13326 .flags = GENL_UNS_ADMIN_PERM,
13327 .internal_flags = NL80211_FLAG_NEED_RTNL,
13330 .cmd = NL80211_CMD_GET_INTERFACE,
13331 .doit = nl80211_get_interface,
13332 .dumpit = nl80211_dump_interface,
13333 .policy = nl80211_policy,
13334 /* can be retrieved by unprivileged users */
13335 .internal_flags = NL80211_FLAG_NEED_WDEV |
13336 NL80211_FLAG_NEED_RTNL,
13339 .cmd = NL80211_CMD_SET_INTERFACE,
13340 .doit = nl80211_set_interface,
13341 .policy = nl80211_policy,
13342 .flags = GENL_UNS_ADMIN_PERM,
13343 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13344 NL80211_FLAG_NEED_RTNL,
13347 .cmd = NL80211_CMD_NEW_INTERFACE,
13348 .doit = nl80211_new_interface,
13349 .policy = nl80211_policy,
13350 .flags = GENL_UNS_ADMIN_PERM,
13351 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13352 NL80211_FLAG_NEED_RTNL,
13355 .cmd = NL80211_CMD_DEL_INTERFACE,
13356 .doit = nl80211_del_interface,
13357 .policy = nl80211_policy,
13358 .flags = GENL_UNS_ADMIN_PERM,
13359 .internal_flags = NL80211_FLAG_NEED_WDEV |
13360 NL80211_FLAG_NEED_RTNL,
13363 .cmd = NL80211_CMD_GET_KEY,
13364 .doit = nl80211_get_key,
13365 .policy = nl80211_policy,
13366 .flags = GENL_UNS_ADMIN_PERM,
13367 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13368 NL80211_FLAG_NEED_RTNL,
13371 .cmd = NL80211_CMD_SET_KEY,
13372 .doit = nl80211_set_key,
13373 .policy = nl80211_policy,
13374 .flags = GENL_UNS_ADMIN_PERM,
13375 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13376 NL80211_FLAG_NEED_RTNL |
13377 NL80211_FLAG_CLEAR_SKB,
13380 .cmd = NL80211_CMD_NEW_KEY,
13381 .doit = nl80211_new_key,
13382 .policy = nl80211_policy,
13383 .flags = GENL_UNS_ADMIN_PERM,
13384 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13385 NL80211_FLAG_NEED_RTNL |
13386 NL80211_FLAG_CLEAR_SKB,
13389 .cmd = NL80211_CMD_DEL_KEY,
13390 .doit = nl80211_del_key,
13391 .policy = nl80211_policy,
13392 .flags = GENL_UNS_ADMIN_PERM,
13393 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13394 NL80211_FLAG_NEED_RTNL,
13397 .cmd = NL80211_CMD_SET_BEACON,
13398 .policy = nl80211_policy,
13399 .flags = GENL_UNS_ADMIN_PERM,
13400 .doit = nl80211_set_beacon,
13401 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13402 NL80211_FLAG_NEED_RTNL,
13405 .cmd = NL80211_CMD_START_AP,
13406 .policy = nl80211_policy,
13407 .flags = GENL_UNS_ADMIN_PERM,
13408 .doit = nl80211_start_ap,
13409 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13410 NL80211_FLAG_NEED_RTNL,
13413 .cmd = NL80211_CMD_STOP_AP,
13414 .policy = nl80211_policy,
13415 .flags = GENL_UNS_ADMIN_PERM,
13416 .doit = nl80211_stop_ap,
13417 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13418 NL80211_FLAG_NEED_RTNL,
13421 .cmd = NL80211_CMD_GET_STATION,
13422 .doit = nl80211_get_station,
13423 .dumpit = nl80211_dump_station,
13424 .policy = nl80211_policy,
13425 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13426 NL80211_FLAG_NEED_RTNL,
13429 .cmd = NL80211_CMD_SET_STATION,
13430 .doit = nl80211_set_station,
13431 .policy = nl80211_policy,
13432 .flags = GENL_UNS_ADMIN_PERM,
13433 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13434 NL80211_FLAG_NEED_RTNL,
13437 .cmd = NL80211_CMD_NEW_STATION,
13438 .doit = nl80211_new_station,
13439 .policy = nl80211_policy,
13440 .flags = GENL_UNS_ADMIN_PERM,
13441 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13442 NL80211_FLAG_NEED_RTNL,
13445 .cmd = NL80211_CMD_DEL_STATION,
13446 .doit = nl80211_del_station,
13447 .policy = nl80211_policy,
13448 .flags = GENL_UNS_ADMIN_PERM,
13449 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13450 NL80211_FLAG_NEED_RTNL,
13453 .cmd = NL80211_CMD_GET_MPATH,
13454 .doit = nl80211_get_mpath,
13455 .dumpit = nl80211_dump_mpath,
13456 .policy = nl80211_policy,
13457 .flags = GENL_UNS_ADMIN_PERM,
13458 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13459 NL80211_FLAG_NEED_RTNL,
13462 .cmd = NL80211_CMD_GET_MPP,
13463 .doit = nl80211_get_mpp,
13464 .dumpit = nl80211_dump_mpp,
13465 .policy = nl80211_policy,
13466 .flags = GENL_UNS_ADMIN_PERM,
13467 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13468 NL80211_FLAG_NEED_RTNL,
13471 .cmd = NL80211_CMD_SET_MPATH,
13472 .doit = nl80211_set_mpath,
13473 .policy = nl80211_policy,
13474 .flags = GENL_UNS_ADMIN_PERM,
13475 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13476 NL80211_FLAG_NEED_RTNL,
13479 .cmd = NL80211_CMD_NEW_MPATH,
13480 .doit = nl80211_new_mpath,
13481 .policy = nl80211_policy,
13482 .flags = GENL_UNS_ADMIN_PERM,
13483 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13484 NL80211_FLAG_NEED_RTNL,
13487 .cmd = NL80211_CMD_DEL_MPATH,
13488 .doit = nl80211_del_mpath,
13489 .policy = nl80211_policy,
13490 .flags = GENL_UNS_ADMIN_PERM,
13491 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13492 NL80211_FLAG_NEED_RTNL,
13495 .cmd = NL80211_CMD_SET_BSS,
13496 .doit = nl80211_set_bss,
13497 .policy = nl80211_policy,
13498 .flags = GENL_UNS_ADMIN_PERM,
13499 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13500 NL80211_FLAG_NEED_RTNL,
13503 .cmd = NL80211_CMD_GET_REG,
13504 .doit = nl80211_get_reg_do,
13505 .dumpit = nl80211_get_reg_dump,
13506 .policy = nl80211_policy,
13507 .internal_flags = NL80211_FLAG_NEED_RTNL,
13508 /* can be retrieved by unprivileged users */
13510 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
13512 .cmd = NL80211_CMD_SET_REG,
13513 .doit = nl80211_set_reg,
13514 .policy = nl80211_policy,
13515 .flags = GENL_ADMIN_PERM,
13516 .internal_flags = NL80211_FLAG_NEED_RTNL,
13520 .cmd = NL80211_CMD_REQ_SET_REG,
13521 .doit = nl80211_req_set_reg,
13522 .policy = nl80211_policy,
13523 .flags = GENL_ADMIN_PERM,
13526 .cmd = NL80211_CMD_RELOAD_REGDB,
13527 .doit = nl80211_reload_regdb,
13528 .policy = nl80211_policy,
13529 .flags = GENL_ADMIN_PERM,
13532 .cmd = NL80211_CMD_GET_MESH_CONFIG,
13533 .doit = nl80211_get_mesh_config,
13534 .policy = nl80211_policy,
13535 /* can be retrieved by unprivileged users */
13536 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13537 NL80211_FLAG_NEED_RTNL,
13540 .cmd = NL80211_CMD_SET_MESH_CONFIG,
13541 .doit = nl80211_update_mesh_config,
13542 .policy = nl80211_policy,
13543 .flags = GENL_UNS_ADMIN_PERM,
13544 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13545 NL80211_FLAG_NEED_RTNL,
13548 .cmd = NL80211_CMD_TRIGGER_SCAN,
13549 .doit = nl80211_trigger_scan,
13550 .policy = nl80211_policy,
13551 .flags = GENL_UNS_ADMIN_PERM,
13552 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13553 NL80211_FLAG_NEED_RTNL,
13556 .cmd = NL80211_CMD_ABORT_SCAN,
13557 .doit = nl80211_abort_scan,
13558 .policy = nl80211_policy,
13559 .flags = GENL_UNS_ADMIN_PERM,
13560 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13561 NL80211_FLAG_NEED_RTNL,
13564 .cmd = NL80211_CMD_GET_SCAN,
13565 .policy = nl80211_policy,
13566 .dumpit = nl80211_dump_scan,
13569 .cmd = NL80211_CMD_START_SCHED_SCAN,
13570 .doit = nl80211_start_sched_scan,
13571 .policy = nl80211_policy,
13572 .flags = GENL_UNS_ADMIN_PERM,
13573 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13574 NL80211_FLAG_NEED_RTNL,
13577 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
13578 .doit = nl80211_stop_sched_scan,
13579 .policy = nl80211_policy,
13580 .flags = GENL_UNS_ADMIN_PERM,
13581 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13582 NL80211_FLAG_NEED_RTNL,
13585 .cmd = NL80211_CMD_AUTHENTICATE,
13586 .doit = nl80211_authenticate,
13587 .policy = nl80211_policy,
13588 .flags = GENL_UNS_ADMIN_PERM,
13589 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13590 NL80211_FLAG_NEED_RTNL |
13591 NL80211_FLAG_CLEAR_SKB,
13594 .cmd = NL80211_CMD_ASSOCIATE,
13595 .doit = nl80211_associate,
13596 .policy = nl80211_policy,
13597 .flags = GENL_UNS_ADMIN_PERM,
13598 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13599 NL80211_FLAG_NEED_RTNL,
13602 .cmd = NL80211_CMD_DEAUTHENTICATE,
13603 .doit = nl80211_deauthenticate,
13604 .policy = nl80211_policy,
13605 .flags = GENL_UNS_ADMIN_PERM,
13606 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13607 NL80211_FLAG_NEED_RTNL,
13610 .cmd = NL80211_CMD_DISASSOCIATE,
13611 .doit = nl80211_disassociate,
13612 .policy = nl80211_policy,
13613 .flags = GENL_UNS_ADMIN_PERM,
13614 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13615 NL80211_FLAG_NEED_RTNL,
13618 .cmd = NL80211_CMD_JOIN_IBSS,
13619 .doit = nl80211_join_ibss,
13620 .policy = nl80211_policy,
13621 .flags = GENL_UNS_ADMIN_PERM,
13622 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13623 NL80211_FLAG_NEED_RTNL,
13626 .cmd = NL80211_CMD_LEAVE_IBSS,
13627 .doit = nl80211_leave_ibss,
13628 .policy = nl80211_policy,
13629 .flags = GENL_UNS_ADMIN_PERM,
13630 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13631 NL80211_FLAG_NEED_RTNL,
13633 #ifdef CONFIG_NL80211_TESTMODE
13635 .cmd = NL80211_CMD_TESTMODE,
13636 .doit = nl80211_testmode_do,
13637 .dumpit = nl80211_testmode_dump,
13638 .policy = nl80211_policy,
13639 .flags = GENL_UNS_ADMIN_PERM,
13640 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13641 NL80211_FLAG_NEED_RTNL,
13645 .cmd = NL80211_CMD_CONNECT,
13646 .doit = nl80211_connect,
13647 .policy = nl80211_policy,
13648 .flags = GENL_UNS_ADMIN_PERM,
13649 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13650 NL80211_FLAG_NEED_RTNL,
13653 .cmd = NL80211_CMD_UPDATE_CONNECT_PARAMS,
13654 .doit = nl80211_update_connect_params,
13655 .policy = nl80211_policy,
13656 .flags = GENL_ADMIN_PERM,
13657 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13658 NL80211_FLAG_NEED_RTNL,
13661 .cmd = NL80211_CMD_DISCONNECT,
13662 .doit = nl80211_disconnect,
13663 .policy = nl80211_policy,
13664 .flags = GENL_UNS_ADMIN_PERM,
13665 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13666 NL80211_FLAG_NEED_RTNL,
13669 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
13670 .doit = nl80211_wiphy_netns,
13671 .policy = nl80211_policy,
13672 .flags = GENL_UNS_ADMIN_PERM,
13673 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13674 NL80211_FLAG_NEED_RTNL,
13677 .cmd = NL80211_CMD_GET_SURVEY,
13678 .policy = nl80211_policy,
13679 .dumpit = nl80211_dump_survey,
13682 .cmd = NL80211_CMD_SET_PMKSA,
13683 .doit = nl80211_setdel_pmksa,
13684 .policy = nl80211_policy,
13685 .flags = GENL_UNS_ADMIN_PERM,
13686 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13687 NL80211_FLAG_NEED_RTNL,
13690 .cmd = NL80211_CMD_DEL_PMKSA,
13691 .doit = nl80211_setdel_pmksa,
13692 .policy = nl80211_policy,
13693 .flags = GENL_UNS_ADMIN_PERM,
13694 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13695 NL80211_FLAG_NEED_RTNL,
13698 .cmd = NL80211_CMD_FLUSH_PMKSA,
13699 .doit = nl80211_flush_pmksa,
13700 .policy = nl80211_policy,
13701 .flags = GENL_UNS_ADMIN_PERM,
13702 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13703 NL80211_FLAG_NEED_RTNL,
13706 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
13707 .doit = nl80211_remain_on_channel,
13708 .policy = nl80211_policy,
13709 .flags = GENL_UNS_ADMIN_PERM,
13710 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13711 NL80211_FLAG_NEED_RTNL,
13714 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
13715 .doit = nl80211_cancel_remain_on_channel,
13716 .policy = nl80211_policy,
13717 .flags = GENL_UNS_ADMIN_PERM,
13718 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13719 NL80211_FLAG_NEED_RTNL,
13722 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
13723 .doit = nl80211_set_tx_bitrate_mask,
13724 .policy = nl80211_policy,
13725 .flags = GENL_UNS_ADMIN_PERM,
13726 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13727 NL80211_FLAG_NEED_RTNL,
13730 .cmd = NL80211_CMD_REGISTER_FRAME,
13731 .doit = nl80211_register_mgmt,
13732 .policy = nl80211_policy,
13733 .flags = GENL_UNS_ADMIN_PERM,
13734 .internal_flags = NL80211_FLAG_NEED_WDEV |
13735 NL80211_FLAG_NEED_RTNL,
13738 .cmd = NL80211_CMD_FRAME,
13739 .doit = nl80211_tx_mgmt,
13740 .policy = nl80211_policy,
13741 .flags = GENL_UNS_ADMIN_PERM,
13742 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13743 NL80211_FLAG_NEED_RTNL,
13746 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
13747 .doit = nl80211_tx_mgmt_cancel_wait,
13748 .policy = nl80211_policy,
13749 .flags = GENL_UNS_ADMIN_PERM,
13750 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13751 NL80211_FLAG_NEED_RTNL,
13754 .cmd = NL80211_CMD_SET_POWER_SAVE,
13755 .doit = nl80211_set_power_save,
13756 .policy = nl80211_policy,
13757 .flags = GENL_UNS_ADMIN_PERM,
13758 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13759 NL80211_FLAG_NEED_RTNL,
13762 .cmd = NL80211_CMD_GET_POWER_SAVE,
13763 .doit = nl80211_get_power_save,
13764 .policy = nl80211_policy,
13765 /* can be retrieved by unprivileged users */
13766 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13767 NL80211_FLAG_NEED_RTNL,
13770 .cmd = NL80211_CMD_SET_CQM,
13771 .doit = nl80211_set_cqm,
13772 .policy = nl80211_policy,
13773 .flags = GENL_UNS_ADMIN_PERM,
13774 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13775 NL80211_FLAG_NEED_RTNL,
13778 .cmd = NL80211_CMD_SET_CHANNEL,
13779 .doit = nl80211_set_channel,
13780 .policy = nl80211_policy,
13781 .flags = GENL_UNS_ADMIN_PERM,
13782 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13783 NL80211_FLAG_NEED_RTNL,
13786 .cmd = NL80211_CMD_SET_WDS_PEER,
13787 .doit = nl80211_set_wds_peer,
13788 .policy = nl80211_policy,
13789 .flags = GENL_UNS_ADMIN_PERM,
13790 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13791 NL80211_FLAG_NEED_RTNL,
13794 .cmd = NL80211_CMD_JOIN_MESH,
13795 .doit = nl80211_join_mesh,
13796 .policy = nl80211_policy,
13797 .flags = GENL_UNS_ADMIN_PERM,
13798 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13799 NL80211_FLAG_NEED_RTNL,
13802 .cmd = NL80211_CMD_LEAVE_MESH,
13803 .doit = nl80211_leave_mesh,
13804 .policy = nl80211_policy,
13805 .flags = GENL_UNS_ADMIN_PERM,
13806 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13807 NL80211_FLAG_NEED_RTNL,
13810 .cmd = NL80211_CMD_JOIN_OCB,
13811 .doit = nl80211_join_ocb,
13812 .policy = nl80211_policy,
13813 .flags = GENL_UNS_ADMIN_PERM,
13814 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13815 NL80211_FLAG_NEED_RTNL,
13818 .cmd = NL80211_CMD_LEAVE_OCB,
13819 .doit = nl80211_leave_ocb,
13820 .policy = nl80211_policy,
13821 .flags = GENL_UNS_ADMIN_PERM,
13822 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13823 NL80211_FLAG_NEED_RTNL,
13827 .cmd = NL80211_CMD_GET_WOWLAN,
13828 .doit = nl80211_get_wowlan,
13829 .policy = nl80211_policy,
13830 /* can be retrieved by unprivileged users */
13831 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13832 NL80211_FLAG_NEED_RTNL,
13835 .cmd = NL80211_CMD_SET_WOWLAN,
13836 .doit = nl80211_set_wowlan,
13837 .policy = nl80211_policy,
13838 .flags = GENL_UNS_ADMIN_PERM,
13839 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13840 NL80211_FLAG_NEED_RTNL,
13844 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
13845 .doit = nl80211_set_rekey_data,
13846 .policy = nl80211_policy,
13847 .flags = GENL_UNS_ADMIN_PERM,
13848 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13849 NL80211_FLAG_NEED_RTNL |
13850 NL80211_FLAG_CLEAR_SKB,
13853 .cmd = NL80211_CMD_TDLS_MGMT,
13854 .doit = nl80211_tdls_mgmt,
13855 .policy = nl80211_policy,
13856 .flags = GENL_UNS_ADMIN_PERM,
13857 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13858 NL80211_FLAG_NEED_RTNL,
13861 .cmd = NL80211_CMD_TDLS_OPER,
13862 .doit = nl80211_tdls_oper,
13863 .policy = nl80211_policy,
13864 .flags = GENL_UNS_ADMIN_PERM,
13865 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13866 NL80211_FLAG_NEED_RTNL,
13869 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
13870 .doit = nl80211_register_unexpected_frame,
13871 .policy = nl80211_policy,
13872 .flags = GENL_UNS_ADMIN_PERM,
13873 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13874 NL80211_FLAG_NEED_RTNL,
13877 .cmd = NL80211_CMD_PROBE_CLIENT,
13878 .doit = nl80211_probe_client,
13879 .policy = nl80211_policy,
13880 .flags = GENL_UNS_ADMIN_PERM,
13881 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13882 NL80211_FLAG_NEED_RTNL,
13885 .cmd = NL80211_CMD_REGISTER_BEACONS,
13886 .doit = nl80211_register_beacons,
13887 .policy = nl80211_policy,
13888 .flags = GENL_UNS_ADMIN_PERM,
13889 .internal_flags = NL80211_FLAG_NEED_WIPHY |
13890 NL80211_FLAG_NEED_RTNL,
13893 .cmd = NL80211_CMD_SET_NOACK_MAP,
13894 .doit = nl80211_set_noack_map,
13895 .policy = nl80211_policy,
13896 .flags = GENL_UNS_ADMIN_PERM,
13897 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13898 NL80211_FLAG_NEED_RTNL,
13901 .cmd = NL80211_CMD_START_P2P_DEVICE,
13902 .doit = nl80211_start_p2p_device,
13903 .policy = nl80211_policy,
13904 .flags = GENL_UNS_ADMIN_PERM,
13905 .internal_flags = NL80211_FLAG_NEED_WDEV |
13906 NL80211_FLAG_NEED_RTNL,
13909 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
13910 .doit = nl80211_stop_p2p_device,
13911 .policy = nl80211_policy,
13912 .flags = GENL_UNS_ADMIN_PERM,
13913 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13914 NL80211_FLAG_NEED_RTNL,
13917 .cmd = NL80211_CMD_START_NAN,
13918 .doit = nl80211_start_nan,
13919 .policy = nl80211_policy,
13920 .flags = GENL_ADMIN_PERM,
13921 .internal_flags = NL80211_FLAG_NEED_WDEV |
13922 NL80211_FLAG_NEED_RTNL,
13925 .cmd = NL80211_CMD_STOP_NAN,
13926 .doit = nl80211_stop_nan,
13927 .policy = nl80211_policy,
13928 .flags = GENL_ADMIN_PERM,
13929 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13930 NL80211_FLAG_NEED_RTNL,
13933 .cmd = NL80211_CMD_ADD_NAN_FUNCTION,
13934 .doit = nl80211_nan_add_func,
13935 .policy = nl80211_policy,
13936 .flags = GENL_ADMIN_PERM,
13937 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13938 NL80211_FLAG_NEED_RTNL,
13941 .cmd = NL80211_CMD_DEL_NAN_FUNCTION,
13942 .doit = nl80211_nan_del_func,
13943 .policy = nl80211_policy,
13944 .flags = GENL_ADMIN_PERM,
13945 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13946 NL80211_FLAG_NEED_RTNL,
13949 .cmd = NL80211_CMD_CHANGE_NAN_CONFIG,
13950 .doit = nl80211_nan_change_config,
13951 .policy = nl80211_policy,
13952 .flags = GENL_ADMIN_PERM,
13953 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13954 NL80211_FLAG_NEED_RTNL,
13957 .cmd = NL80211_CMD_SET_MCAST_RATE,
13958 .doit = nl80211_set_mcast_rate,
13959 .policy = nl80211_policy,
13960 .flags = GENL_UNS_ADMIN_PERM,
13961 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13962 NL80211_FLAG_NEED_RTNL,
13965 .cmd = NL80211_CMD_SET_MAC_ACL,
13966 .doit = nl80211_set_mac_acl,
13967 .policy = nl80211_policy,
13968 .flags = GENL_UNS_ADMIN_PERM,
13969 .internal_flags = NL80211_FLAG_NEED_NETDEV |
13970 NL80211_FLAG_NEED_RTNL,
13973 .cmd = NL80211_CMD_RADAR_DETECT,
13974 .doit = nl80211_start_radar_detection,
13975 .policy = nl80211_policy,
13976 .flags = GENL_UNS_ADMIN_PERM,
13977 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13978 NL80211_FLAG_NEED_RTNL,
13981 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
13982 .doit = nl80211_get_protocol_features,
13983 .policy = nl80211_policy,
13986 .cmd = NL80211_CMD_UPDATE_FT_IES,
13987 .doit = nl80211_update_ft_ies,
13988 .policy = nl80211_policy,
13989 .flags = GENL_UNS_ADMIN_PERM,
13990 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
13991 NL80211_FLAG_NEED_RTNL,
13994 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
13995 .doit = nl80211_crit_protocol_start,
13996 .policy = nl80211_policy,
13997 .flags = GENL_UNS_ADMIN_PERM,
13998 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
13999 NL80211_FLAG_NEED_RTNL,
14002 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
14003 .doit = nl80211_crit_protocol_stop,
14004 .policy = nl80211_policy,
14005 .flags = GENL_UNS_ADMIN_PERM,
14006 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14007 NL80211_FLAG_NEED_RTNL,
14010 .cmd = NL80211_CMD_GET_COALESCE,
14011 .doit = nl80211_get_coalesce,
14012 .policy = nl80211_policy,
14013 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14014 NL80211_FLAG_NEED_RTNL,
14017 .cmd = NL80211_CMD_SET_COALESCE,
14018 .doit = nl80211_set_coalesce,
14019 .policy = nl80211_policy,
14020 .flags = GENL_UNS_ADMIN_PERM,
14021 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14022 NL80211_FLAG_NEED_RTNL,
14025 .cmd = NL80211_CMD_CHANNEL_SWITCH,
14026 .doit = nl80211_channel_switch,
14027 .policy = nl80211_policy,
14028 .flags = GENL_UNS_ADMIN_PERM,
14029 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14030 NL80211_FLAG_NEED_RTNL,
14033 .cmd = NL80211_CMD_VENDOR,
14034 .doit = nl80211_vendor_cmd,
14035 .dumpit = nl80211_vendor_cmd_dump,
14036 .policy = nl80211_policy,
14037 .flags = GENL_UNS_ADMIN_PERM,
14038 .internal_flags = NL80211_FLAG_NEED_WIPHY |
14039 NL80211_FLAG_NEED_RTNL,
14042 .cmd = NL80211_CMD_SET_QOS_MAP,
14043 .doit = nl80211_set_qos_map,
14044 .policy = nl80211_policy,
14045 .flags = GENL_UNS_ADMIN_PERM,
14046 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14047 NL80211_FLAG_NEED_RTNL,
14050 .cmd = NL80211_CMD_ADD_TX_TS,
14051 .doit = nl80211_add_tx_ts,
14052 .policy = nl80211_policy,
14053 .flags = GENL_UNS_ADMIN_PERM,
14054 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14055 NL80211_FLAG_NEED_RTNL,
14058 .cmd = NL80211_CMD_DEL_TX_TS,
14059 .doit = nl80211_del_tx_ts,
14060 .policy = nl80211_policy,
14061 .flags = GENL_UNS_ADMIN_PERM,
14062 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14063 NL80211_FLAG_NEED_RTNL,
14066 .cmd = NL80211_CMD_TDLS_CHANNEL_SWITCH,
14067 .doit = nl80211_tdls_channel_switch,
14068 .policy = nl80211_policy,
14069 .flags = GENL_UNS_ADMIN_PERM,
14070 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14071 NL80211_FLAG_NEED_RTNL,
14074 .cmd = NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH,
14075 .doit = nl80211_tdls_cancel_channel_switch,
14076 .policy = nl80211_policy,
14077 .flags = GENL_UNS_ADMIN_PERM,
14078 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14079 NL80211_FLAG_NEED_RTNL,
14082 .cmd = NL80211_CMD_SET_MULTICAST_TO_UNICAST,
14083 .doit = nl80211_set_multicast_to_unicast,
14084 .policy = nl80211_policy,
14085 .flags = GENL_UNS_ADMIN_PERM,
14086 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14087 NL80211_FLAG_NEED_RTNL,
14090 .cmd = NL80211_CMD_SET_PMK,
14091 .doit = nl80211_set_pmk,
14092 .policy = nl80211_policy,
14093 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14094 NL80211_FLAG_NEED_RTNL,
14097 .cmd = NL80211_CMD_DEL_PMK,
14098 .doit = nl80211_del_pmk,
14099 .policy = nl80211_policy,
14100 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14101 NL80211_FLAG_NEED_RTNL,
14104 .cmd = NL80211_CMD_EXTERNAL_AUTH,
14105 .doit = nl80211_external_auth,
14106 .policy = nl80211_policy,
14107 .flags = GENL_ADMIN_PERM,
14108 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14109 NL80211_FLAG_NEED_RTNL,
14112 .cmd = NL80211_CMD_CONTROL_PORT_FRAME,
14113 .doit = nl80211_tx_control_port,
14114 .policy = nl80211_policy,
14115 .flags = GENL_UNS_ADMIN_PERM,
14116 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14117 NL80211_FLAG_NEED_RTNL,
14120 .cmd = NL80211_CMD_GET_FTM_RESPONDER_STATS,
14121 .doit = nl80211_get_ftm_responder_stats,
14122 .policy = nl80211_policy,
14123 .internal_flags = NL80211_FLAG_NEED_NETDEV |
14124 NL80211_FLAG_NEED_RTNL,
14127 .cmd = NL80211_CMD_PEER_MEASUREMENT_START,
14128 .doit = nl80211_pmsr_start,
14129 .policy = nl80211_policy,
14130 .flags = GENL_UNS_ADMIN_PERM,
14131 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
14132 NL80211_FLAG_NEED_RTNL,
14135 .cmd = NL80211_CMD_NOTIFY_RADAR,
14136 .doit = nl80211_notify_radar_detection,
14137 .policy = nl80211_policy,
14138 .flags = GENL_UNS_ADMIN_PERM,
14139 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
14140 NL80211_FLAG_NEED_RTNL,
14144 static struct genl_family nl80211_fam __ro_after_init = {
14145 .name = NL80211_GENL_NAME, /* have users key off the name instead */
14146 .hdrsize = 0, /* no private header */
14147 .version = 1, /* no particular meaning now */
14148 .maxattr = NL80211_ATTR_MAX,
14150 .pre_doit = nl80211_pre_doit,
14151 .post_doit = nl80211_post_doit,
14152 .module = THIS_MODULE,
14153 .ops = nl80211_ops,
14154 .n_ops = ARRAY_SIZE(nl80211_ops),
14155 .mcgrps = nl80211_mcgrps,
14156 .n_mcgrps = ARRAY_SIZE(nl80211_mcgrps),
14159 /* notification functions */
14161 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
14162 enum nl80211_commands cmd)
14164 struct sk_buff *msg;
14165 struct nl80211_dump_wiphy_state state = {};
14167 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
14168 cmd != NL80211_CMD_DEL_WIPHY);
14170 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14174 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
14179 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14180 NL80211_MCGRP_CONFIG, GFP_KERNEL);
14183 void nl80211_notify_iface(struct cfg80211_registered_device *rdev,
14184 struct wireless_dev *wdev,
14185 enum nl80211_commands cmd)
14187 struct sk_buff *msg;
14189 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14193 if (nl80211_send_iface(msg, 0, 0, 0, rdev, wdev, cmd) < 0) {
14198 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14199 NL80211_MCGRP_CONFIG, GFP_KERNEL);
14202 static int nl80211_add_scan_req(struct sk_buff *msg,
14203 struct cfg80211_registered_device *rdev)
14205 struct cfg80211_scan_request *req = rdev->scan_req;
14206 struct nlattr *nest;
14212 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
14214 goto nla_put_failure;
14215 for (i = 0; i < req->n_ssids; i++) {
14216 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
14217 goto nla_put_failure;
14219 nla_nest_end(msg, nest);
14221 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
14223 goto nla_put_failure;
14224 for (i = 0; i < req->n_channels; i++) {
14225 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
14226 goto nla_put_failure;
14228 nla_nest_end(msg, nest);
14231 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
14232 goto nla_put_failure;
14235 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
14236 goto nla_put_failure;
14238 if (req->info.scan_start_tsf &&
14239 (nla_put_u64_64bit(msg, NL80211_ATTR_SCAN_START_TIME_TSF,
14240 req->info.scan_start_tsf, NL80211_BSS_PAD) ||
14241 nla_put(msg, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID, ETH_ALEN,
14242 req->info.tsf_bssid)))
14243 goto nla_put_failure;
14250 static int nl80211_prep_scan_msg(struct sk_buff *msg,
14251 struct cfg80211_registered_device *rdev,
14252 struct wireless_dev *wdev,
14253 u32 portid, u32 seq, int flags,
14258 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
14262 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14263 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14264 wdev->netdev->ifindex)) ||
14265 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14267 goto nla_put_failure;
14269 /* ignore errors and send incomplete event anyway */
14270 nl80211_add_scan_req(msg, rdev);
14272 genlmsg_end(msg, hdr);
14276 genlmsg_cancel(msg, hdr);
14281 nl80211_prep_sched_scan_msg(struct sk_buff *msg,
14282 struct cfg80211_sched_scan_request *req, u32 cmd)
14286 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14290 if (nla_put_u32(msg, NL80211_ATTR_WIPHY,
14291 wiphy_to_rdev(req->wiphy)->wiphy_idx) ||
14292 nla_put_u32(msg, NL80211_ATTR_IFINDEX, req->dev->ifindex) ||
14293 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, req->reqid,
14295 goto nla_put_failure;
14297 genlmsg_end(msg, hdr);
14301 genlmsg_cancel(msg, hdr);
14305 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
14306 struct wireless_dev *wdev)
14308 struct sk_buff *msg;
14310 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14314 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
14315 NL80211_CMD_TRIGGER_SCAN) < 0) {
14320 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14321 NL80211_MCGRP_SCAN, GFP_KERNEL);
14324 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
14325 struct wireless_dev *wdev, bool aborted)
14327 struct sk_buff *msg;
14329 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14333 if (nl80211_prep_scan_msg(msg, rdev, wdev, 0, 0, 0,
14334 aborted ? NL80211_CMD_SCAN_ABORTED :
14335 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
14343 /* send message created by nl80211_build_scan_msg() */
14344 void nl80211_send_scan_msg(struct cfg80211_registered_device *rdev,
14345 struct sk_buff *msg)
14350 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14351 NL80211_MCGRP_SCAN, GFP_KERNEL);
14354 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request *req, u32 cmd)
14356 struct sk_buff *msg;
14358 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14362 if (nl80211_prep_sched_scan_msg(msg, req, cmd) < 0) {
14367 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(req->wiphy), msg, 0,
14368 NL80211_MCGRP_SCAN, GFP_KERNEL);
14371 static bool nl80211_reg_change_event_fill(struct sk_buff *msg,
14372 struct regulatory_request *request)
14374 /* Userspace can always count this one always being set */
14375 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
14376 goto nla_put_failure;
14378 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
14379 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14380 NL80211_REGDOM_TYPE_WORLD))
14381 goto nla_put_failure;
14382 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
14383 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14384 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
14385 goto nla_put_failure;
14386 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
14387 request->intersect) {
14388 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14389 NL80211_REGDOM_TYPE_INTERSECTION))
14390 goto nla_put_failure;
14392 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
14393 NL80211_REGDOM_TYPE_COUNTRY) ||
14394 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
14396 goto nla_put_failure;
14399 if (request->wiphy_idx != WIPHY_IDX_INVALID) {
14400 struct wiphy *wiphy = wiphy_idx_to_wiphy(request->wiphy_idx);
14403 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
14404 goto nla_put_failure;
14407 wiphy->regulatory_flags & REGULATORY_WIPHY_SELF_MANAGED &&
14408 nla_put_flag(msg, NL80211_ATTR_WIPHY_SELF_MANAGED_REG))
14409 goto nla_put_failure;
14419 * This can happen on global regulatory changes or device specific settings
14420 * based on custom regulatory domains.
14422 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id,
14423 struct regulatory_request *request)
14425 struct sk_buff *msg;
14428 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14432 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd_id);
14438 if (nl80211_reg_change_event_fill(msg, request) == false)
14439 goto nla_put_failure;
14441 genlmsg_end(msg, hdr);
14444 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
14445 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
14454 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
14455 struct net_device *netdev,
14456 const u8 *buf, size_t len,
14457 enum nl80211_commands cmd, gfp_t gfp,
14460 struct sk_buff *msg;
14463 msg = nlmsg_new(100 + len, gfp);
14467 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14473 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14474 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14475 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
14476 goto nla_put_failure;
14478 if (uapsd_queues >= 0) {
14479 struct nlattr *nla_wmm =
14480 nla_nest_start(msg, NL80211_ATTR_STA_WME);
14482 goto nla_put_failure;
14484 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
14486 goto nla_put_failure;
14488 nla_nest_end(msg, nla_wmm);
14491 genlmsg_end(msg, hdr);
14493 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14494 NL80211_MCGRP_MLME, gfp);
14501 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
14502 struct net_device *netdev, const u8 *buf,
14503 size_t len, gfp_t gfp)
14505 nl80211_send_mlme_event(rdev, netdev, buf, len,
14506 NL80211_CMD_AUTHENTICATE, gfp, -1);
14509 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
14510 struct net_device *netdev, const u8 *buf,
14511 size_t len, gfp_t gfp, int uapsd_queues)
14513 nl80211_send_mlme_event(rdev, netdev, buf, len,
14514 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
14517 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
14518 struct net_device *netdev, const u8 *buf,
14519 size_t len, gfp_t gfp)
14521 nl80211_send_mlme_event(rdev, netdev, buf, len,
14522 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
14525 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
14526 struct net_device *netdev, const u8 *buf,
14527 size_t len, gfp_t gfp)
14529 nl80211_send_mlme_event(rdev, netdev, buf, len,
14530 NL80211_CMD_DISASSOCIATE, gfp, -1);
14533 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
14536 struct wireless_dev *wdev = dev->ieee80211_ptr;
14537 struct wiphy *wiphy = wdev->wiphy;
14538 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
14539 const struct ieee80211_mgmt *mgmt = (void *)buf;
14542 if (WARN_ON(len < 2))
14545 if (ieee80211_is_deauth(mgmt->frame_control))
14546 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
14548 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
14550 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
14551 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
14553 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
14555 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
14556 struct net_device *netdev, int cmd,
14557 const u8 *addr, gfp_t gfp)
14559 struct sk_buff *msg;
14562 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14566 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14572 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14573 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14574 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
14575 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
14576 goto nla_put_failure;
14578 genlmsg_end(msg, hdr);
14580 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14581 NL80211_MCGRP_MLME, gfp);
14588 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
14589 struct net_device *netdev, const u8 *addr,
14592 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
14596 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
14597 struct net_device *netdev, const u8 *addr,
14600 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
14604 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
14605 struct net_device *netdev,
14606 struct cfg80211_connect_resp_params *cr,
14609 struct sk_buff *msg;
14612 msg = nlmsg_new(100 + cr->req_ie_len + cr->resp_ie_len +
14613 cr->fils.kek_len + cr->fils.pmk_len +
14614 (cr->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
14618 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
14624 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14625 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14627 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, cr->bssid)) ||
14628 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE,
14629 cr->status < 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE :
14632 (nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
14633 nla_put_u32(msg, NL80211_ATTR_TIMEOUT_REASON,
14634 cr->timeout_reason))) ||
14636 nla_put(msg, NL80211_ATTR_REQ_IE, cr->req_ie_len, cr->req_ie)) ||
14638 nla_put(msg, NL80211_ATTR_RESP_IE, cr->resp_ie_len,
14640 (cr->fils.update_erp_next_seq_num &&
14641 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
14642 cr->fils.erp_next_seq_num)) ||
14643 (cr->status == WLAN_STATUS_SUCCESS &&
14645 nla_put(msg, NL80211_ATTR_FILS_KEK, cr->fils.kek_len,
14648 nla_put(msg, NL80211_ATTR_PMK, cr->fils.pmk_len, cr->fils.pmk)) ||
14650 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, cr->fils.pmkid)))))
14651 goto nla_put_failure;
14653 genlmsg_end(msg, hdr);
14655 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14656 NL80211_MCGRP_MLME, gfp);
14663 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
14664 struct net_device *netdev,
14665 struct cfg80211_roam_info *info, gfp_t gfp)
14667 struct sk_buff *msg;
14669 const u8 *bssid = info->bss ? info->bss->bssid : info->bssid;
14671 msg = nlmsg_new(100 + info->req_ie_len + info->resp_ie_len +
14672 info->fils.kek_len + info->fils.pmk_len +
14673 (info->fils.pmkid ? WLAN_PMKID_LEN : 0), gfp);
14677 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
14683 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14684 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14685 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
14687 nla_put(msg, NL80211_ATTR_REQ_IE, info->req_ie_len,
14690 nla_put(msg, NL80211_ATTR_RESP_IE, info->resp_ie_len,
14692 (info->fils.update_erp_next_seq_num &&
14693 nla_put_u16(msg, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM,
14694 info->fils.erp_next_seq_num)) ||
14696 nla_put(msg, NL80211_ATTR_FILS_KEK, info->fils.kek_len,
14697 info->fils.kek)) ||
14699 nla_put(msg, NL80211_ATTR_PMK, info->fils.pmk_len, info->fils.pmk)) ||
14700 (info->fils.pmkid &&
14701 nla_put(msg, NL80211_ATTR_PMKID, WLAN_PMKID_LEN, info->fils.pmkid)))
14702 goto nla_put_failure;
14704 genlmsg_end(msg, hdr);
14706 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14707 NL80211_MCGRP_MLME, gfp);
14714 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
14715 struct net_device *netdev, const u8 *bssid)
14717 struct sk_buff *msg;
14720 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
14724 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED);
14730 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14731 goto nla_put_failure;
14733 genlmsg_end(msg, hdr);
14735 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14736 NL80211_MCGRP_MLME, GFP_KERNEL);
14743 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
14744 struct net_device *netdev, u16 reason,
14745 const u8 *ie, size_t ie_len, bool from_ap)
14747 struct sk_buff *msg;
14750 msg = nlmsg_new(100 + ie_len, GFP_KERNEL);
14754 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
14760 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14761 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14763 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
14765 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
14766 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
14767 goto nla_put_failure;
14769 genlmsg_end(msg, hdr);
14771 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14772 NL80211_MCGRP_MLME, GFP_KERNEL);
14779 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
14780 struct net_device *netdev, const u8 *bssid,
14783 struct sk_buff *msg;
14786 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14790 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
14796 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14797 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14798 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
14799 goto nla_put_failure;
14801 genlmsg_end(msg, hdr);
14803 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14804 NL80211_MCGRP_MLME, gfp);
14811 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
14812 const u8 *ie, u8 ie_len,
14813 int sig_dbm, gfp_t gfp)
14815 struct wireless_dev *wdev = dev->ieee80211_ptr;
14816 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
14817 struct sk_buff *msg;
14820 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
14823 trace_cfg80211_notify_new_peer_candidate(dev, addr);
14825 msg = nlmsg_new(100 + ie_len, gfp);
14829 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
14835 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14836 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
14837 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
14839 nla_put(msg, NL80211_ATTR_IE, ie_len, ie)) ||
14841 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)))
14842 goto nla_put_failure;
14844 genlmsg_end(msg, hdr);
14846 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14847 NL80211_MCGRP_MLME, gfp);
14853 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
14855 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
14856 struct net_device *netdev, const u8 *addr,
14857 enum nl80211_key_type key_type, int key_id,
14858 const u8 *tsc, gfp_t gfp)
14860 struct sk_buff *msg;
14863 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14867 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
14873 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14874 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
14875 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
14876 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
14878 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
14879 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
14880 goto nla_put_failure;
14882 genlmsg_end(msg, hdr);
14884 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14885 NL80211_MCGRP_MLME, gfp);
14892 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
14893 struct ieee80211_channel *channel_before,
14894 struct ieee80211_channel *channel_after)
14896 struct sk_buff *msg;
14898 struct nlattr *nl_freq;
14900 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
14904 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
14911 * Since we are applying the beacon hint to a wiphy we know its
14912 * wiphy_idx is valid
14914 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
14915 goto nla_put_failure;
14918 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
14920 goto nla_put_failure;
14922 if (nl80211_msg_put_channel(msg, wiphy, channel_before, false))
14923 goto nla_put_failure;
14924 nla_nest_end(msg, nl_freq);
14927 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
14929 goto nla_put_failure;
14931 if (nl80211_msg_put_channel(msg, wiphy, channel_after, false))
14932 goto nla_put_failure;
14933 nla_nest_end(msg, nl_freq);
14935 genlmsg_end(msg, hdr);
14938 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
14939 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
14948 static void nl80211_send_remain_on_chan_event(
14949 int cmd, struct cfg80211_registered_device *rdev,
14950 struct wireless_dev *wdev, u64 cookie,
14951 struct ieee80211_channel *chan,
14952 unsigned int duration, gfp_t gfp)
14954 struct sk_buff *msg;
14957 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
14961 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
14967 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
14968 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
14969 wdev->netdev->ifindex)) ||
14970 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
14971 NL80211_ATTR_PAD) ||
14972 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
14973 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
14974 NL80211_CHAN_NO_HT) ||
14975 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
14977 goto nla_put_failure;
14979 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
14980 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
14981 goto nla_put_failure;
14983 genlmsg_end(msg, hdr);
14985 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
14986 NL80211_MCGRP_MLME, gfp);
14993 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
14994 struct ieee80211_channel *chan,
14995 unsigned int duration, gfp_t gfp)
14997 struct wiphy *wiphy = wdev->wiphy;
14998 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15000 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
15001 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
15002 rdev, wdev, cookie, chan,
15005 EXPORT_SYMBOL(cfg80211_ready_on_channel);
15007 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
15008 struct ieee80211_channel *chan,
15011 struct wiphy *wiphy = wdev->wiphy;
15012 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15014 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
15015 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
15016 rdev, wdev, cookie, chan, 0, gfp);
15018 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
15020 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
15021 struct station_info *sinfo, gfp_t gfp)
15023 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15024 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15025 struct sk_buff *msg;
15027 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
15029 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15033 if (nl80211_send_station(msg, NL80211_CMD_NEW_STATION, 0, 0, 0,
15034 rdev, dev, mac_addr, sinfo) < 0) {
15039 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15040 NL80211_MCGRP_MLME, gfp);
15042 EXPORT_SYMBOL(cfg80211_new_sta);
15044 void cfg80211_del_sta_sinfo(struct net_device *dev, const u8 *mac_addr,
15045 struct station_info *sinfo, gfp_t gfp)
15047 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15048 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15049 struct sk_buff *msg;
15050 struct station_info empty_sinfo = {};
15053 sinfo = &empty_sinfo;
15055 trace_cfg80211_del_sta(dev, mac_addr);
15057 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15059 cfg80211_sinfo_release_content(sinfo);
15063 if (nl80211_send_station(msg, NL80211_CMD_DEL_STATION, 0, 0, 0,
15064 rdev, dev, mac_addr, sinfo) < 0) {
15069 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15070 NL80211_MCGRP_MLME, gfp);
15072 EXPORT_SYMBOL(cfg80211_del_sta_sinfo);
15074 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
15075 enum nl80211_connect_failed_reason reason,
15078 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
15079 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15080 struct sk_buff *msg;
15083 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
15087 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
15093 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15094 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
15095 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
15096 goto nla_put_failure;
15098 genlmsg_end(msg, hdr);
15100 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15101 NL80211_MCGRP_MLME, gfp);
15107 EXPORT_SYMBOL(cfg80211_conn_failed);
15109 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
15110 const u8 *addr, gfp_t gfp)
15112 struct wireless_dev *wdev = dev->ieee80211_ptr;
15113 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15114 struct sk_buff *msg;
15116 u32 nlportid = READ_ONCE(wdev->ap_unexpected_nlportid);
15121 msg = nlmsg_new(100, gfp);
15125 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
15131 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15132 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15133 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
15134 goto nla_put_failure;
15136 genlmsg_end(msg, hdr);
15137 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15145 bool cfg80211_rx_spurious_frame(struct net_device *dev,
15146 const u8 *addr, gfp_t gfp)
15148 struct wireless_dev *wdev = dev->ieee80211_ptr;
15151 trace_cfg80211_rx_spurious_frame(dev, addr);
15153 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
15154 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
15155 trace_cfg80211_return_bool(false);
15158 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
15160 trace_cfg80211_return_bool(ret);
15163 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
15165 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
15166 const u8 *addr, gfp_t gfp)
15168 struct wireless_dev *wdev = dev->ieee80211_ptr;
15171 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
15173 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
15174 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
15175 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
15176 trace_cfg80211_return_bool(false);
15179 ret = __nl80211_unexpected_frame(dev,
15180 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
15182 trace_cfg80211_return_bool(ret);
15185 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
15187 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
15188 struct wireless_dev *wdev, u32 nlportid,
15189 int freq, int sig_dbm,
15190 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
15192 struct net_device *netdev = wdev->netdev;
15193 struct sk_buff *msg;
15196 msg = nlmsg_new(100 + len, gfp);
15200 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
15206 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15207 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15208 netdev->ifindex)) ||
15209 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15210 NL80211_ATTR_PAD) ||
15211 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
15213 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
15214 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
15216 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
15217 goto nla_put_failure;
15219 genlmsg_end(msg, hdr);
15221 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15228 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
15229 const u8 *buf, size_t len, bool ack, gfp_t gfp)
15231 struct wiphy *wiphy = wdev->wiphy;
15232 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15233 struct net_device *netdev = wdev->netdev;
15234 struct sk_buff *msg;
15237 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
15239 msg = nlmsg_new(100 + len, gfp);
15243 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
15249 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15250 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15251 netdev->ifindex)) ||
15252 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15253 NL80211_ATTR_PAD) ||
15254 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
15255 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
15256 NL80211_ATTR_PAD) ||
15257 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
15258 goto nla_put_failure;
15260 genlmsg_end(msg, hdr);
15262 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15263 NL80211_MCGRP_MLME, gfp);
15269 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
15271 static int __nl80211_rx_control_port(struct net_device *dev,
15272 struct sk_buff *skb,
15273 bool unencrypted, gfp_t gfp)
15275 struct wireless_dev *wdev = dev->ieee80211_ptr;
15276 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15277 struct ethhdr *ehdr = eth_hdr(skb);
15278 const u8 *addr = ehdr->h_source;
15279 u16 proto = be16_to_cpu(skb->protocol);
15280 struct sk_buff *msg;
15282 struct nlattr *frame;
15284 u32 nlportid = READ_ONCE(wdev->conn_owner_nlportid);
15289 msg = nlmsg_new(100 + skb->len, gfp);
15293 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME);
15299 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15300 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15301 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15302 NL80211_ATTR_PAD) ||
15303 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
15304 nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) ||
15305 (unencrypted && nla_put_flag(msg,
15306 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
15307 goto nla_put_failure;
15309 frame = nla_reserve(msg, NL80211_ATTR_FRAME, skb->len);
15311 goto nla_put_failure;
15313 skb_copy_bits(skb, 0, nla_data(frame), skb->len);
15314 genlmsg_end(msg, hdr);
15316 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
15323 bool cfg80211_rx_control_port(struct net_device *dev,
15324 struct sk_buff *skb, bool unencrypted)
15328 trace_cfg80211_rx_control_port(dev, skb, unencrypted);
15329 ret = __nl80211_rx_control_port(dev, skb, unencrypted, GFP_ATOMIC);
15330 trace_cfg80211_return_bool(ret == 0);
15333 EXPORT_SYMBOL(cfg80211_rx_control_port);
15335 static struct sk_buff *cfg80211_prepare_cqm(struct net_device *dev,
15336 const char *mac, gfp_t gfp)
15338 struct wireless_dev *wdev = dev->ieee80211_ptr;
15339 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15340 struct sk_buff *msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15346 cb = (void **)msg->cb;
15348 cb[0] = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
15354 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15355 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
15356 goto nla_put_failure;
15358 if (mac && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
15359 goto nla_put_failure;
15361 cb[1] = nla_nest_start(msg, NL80211_ATTR_CQM);
15363 goto nla_put_failure;
15373 static void cfg80211_send_cqm(struct sk_buff *msg, gfp_t gfp)
15375 void **cb = (void **)msg->cb;
15376 struct cfg80211_registered_device *rdev = cb[2];
15378 nla_nest_end(msg, cb[1]);
15379 genlmsg_end(msg, cb[0]);
15381 memset(msg->cb, 0, sizeof(msg->cb));
15383 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15384 NL80211_MCGRP_MLME, gfp);
15387 void cfg80211_cqm_rssi_notify(struct net_device *dev,
15388 enum nl80211_cqm_rssi_threshold_event rssi_event,
15389 s32 rssi_level, gfp_t gfp)
15391 struct sk_buff *msg;
15392 struct wireless_dev *wdev = dev->ieee80211_ptr;
15393 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15395 trace_cfg80211_cqm_rssi_notify(dev, rssi_event, rssi_level);
15397 if (WARN_ON(rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW &&
15398 rssi_event != NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH))
15401 if (wdev->cqm_config) {
15402 wdev->cqm_config->last_rssi_event_value = rssi_level;
15404 cfg80211_cqm_rssi_update(rdev, dev);
15406 if (rssi_level == 0)
15407 rssi_level = wdev->cqm_config->last_rssi_event_value;
15410 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
15414 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
15416 goto nla_put_failure;
15418 if (rssi_level && nla_put_s32(msg, NL80211_ATTR_CQM_RSSI_LEVEL,
15420 goto nla_put_failure;
15422 cfg80211_send_cqm(msg, gfp);
15429 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
15431 void cfg80211_cqm_txe_notify(struct net_device *dev,
15432 const u8 *peer, u32 num_packets,
15433 u32 rate, u32 intvl, gfp_t gfp)
15435 struct sk_buff *msg;
15437 msg = cfg80211_prepare_cqm(dev, peer, gfp);
15441 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
15442 goto nla_put_failure;
15444 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
15445 goto nla_put_failure;
15447 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
15448 goto nla_put_failure;
15450 cfg80211_send_cqm(msg, gfp);
15456 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
15458 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
15459 const u8 *peer, u32 num_packets, gfp_t gfp)
15461 struct sk_buff *msg;
15463 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
15465 msg = cfg80211_prepare_cqm(dev, peer, gfp);
15469 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
15470 goto nla_put_failure;
15472 cfg80211_send_cqm(msg, gfp);
15478 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
15480 void cfg80211_cqm_beacon_loss_notify(struct net_device *dev, gfp_t gfp)
15482 struct sk_buff *msg;
15484 msg = cfg80211_prepare_cqm(dev, NULL, gfp);
15488 if (nla_put_flag(msg, NL80211_ATTR_CQM_BEACON_LOSS_EVENT))
15489 goto nla_put_failure;
15491 cfg80211_send_cqm(msg, gfp);
15497 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify);
15499 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
15500 struct net_device *netdev, const u8 *bssid,
15501 const u8 *replay_ctr, gfp_t gfp)
15503 struct sk_buff *msg;
15504 struct nlattr *rekey_attr;
15507 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15511 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
15517 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15518 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15519 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
15520 goto nla_put_failure;
15522 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
15524 goto nla_put_failure;
15526 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
15527 NL80211_REPLAY_CTR_LEN, replay_ctr))
15528 goto nla_put_failure;
15530 nla_nest_end(msg, rekey_attr);
15532 genlmsg_end(msg, hdr);
15534 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15535 NL80211_MCGRP_MLME, gfp);
15542 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
15543 const u8 *replay_ctr, gfp_t gfp)
15545 struct wireless_dev *wdev = dev->ieee80211_ptr;
15546 struct wiphy *wiphy = wdev->wiphy;
15547 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15549 trace_cfg80211_gtk_rekey_notify(dev, bssid);
15550 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
15552 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
15555 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
15556 struct net_device *netdev, int index,
15557 const u8 *bssid, bool preauth, gfp_t gfp)
15559 struct sk_buff *msg;
15560 struct nlattr *attr;
15563 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15567 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
15573 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15574 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
15575 goto nla_put_failure;
15577 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
15579 goto nla_put_failure;
15581 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
15582 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
15584 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
15585 goto nla_put_failure;
15587 nla_nest_end(msg, attr);
15589 genlmsg_end(msg, hdr);
15591 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15592 NL80211_MCGRP_MLME, gfp);
15599 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
15600 const u8 *bssid, bool preauth, gfp_t gfp)
15602 struct wireless_dev *wdev = dev->ieee80211_ptr;
15603 struct wiphy *wiphy = wdev->wiphy;
15604 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15606 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
15607 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
15609 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
15611 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
15612 struct net_device *netdev,
15613 struct cfg80211_chan_def *chandef,
15615 enum nl80211_commands notif,
15618 struct sk_buff *msg;
15621 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15625 hdr = nl80211hdr_put(msg, 0, 0, 0, notif);
15631 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
15632 goto nla_put_failure;
15634 if (nl80211_send_chandef(msg, chandef))
15635 goto nla_put_failure;
15637 if ((notif == NL80211_CMD_CH_SWITCH_STARTED_NOTIFY) &&
15638 (nla_put_u32(msg, NL80211_ATTR_CH_SWITCH_COUNT, count)))
15639 goto nla_put_failure;
15641 genlmsg_end(msg, hdr);
15643 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15644 NL80211_MCGRP_MLME, gfp);
15651 void cfg80211_ch_switch_notify(struct net_device *dev,
15652 struct cfg80211_chan_def *chandef)
15654 struct wireless_dev *wdev = dev->ieee80211_ptr;
15655 struct wiphy *wiphy = wdev->wiphy;
15656 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15658 ASSERT_WDEV_LOCK(wdev);
15660 trace_cfg80211_ch_switch_notify(dev, chandef);
15662 wdev->chandef = *chandef;
15663 wdev->preset_chandef = *chandef;
15664 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
15665 NL80211_CMD_CH_SWITCH_NOTIFY, 0);
15667 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
15669 void cfg80211_ch_switch_started_notify(struct net_device *dev,
15670 struct cfg80211_chan_def *chandef,
15673 struct wireless_dev *wdev = dev->ieee80211_ptr;
15674 struct wiphy *wiphy = wdev->wiphy;
15675 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15677 trace_cfg80211_ch_switch_started_notify(dev, chandef);
15679 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL,
15680 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY, count);
15682 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify);
15685 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
15686 const struct cfg80211_chan_def *chandef,
15687 enum nl80211_radar_event event,
15688 struct net_device *netdev, gfp_t gfp)
15690 struct sk_buff *msg;
15693 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15697 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
15703 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
15704 goto nla_put_failure;
15706 /* NOP and radar events don't need a netdev parameter */
15708 struct wireless_dev *wdev = netdev->ieee80211_ptr;
15710 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
15711 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15713 goto nla_put_failure;
15716 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
15717 goto nla_put_failure;
15719 if (nl80211_send_chandef(msg, chandef))
15720 goto nla_put_failure;
15722 genlmsg_end(msg, hdr);
15724 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15725 NL80211_MCGRP_MLME, gfp);
15732 void cfg80211_sta_opmode_change_notify(struct net_device *dev, const u8 *mac,
15733 struct sta_opmode_info *sta_opmode,
15736 struct sk_buff *msg;
15737 struct wireless_dev *wdev = dev->ieee80211_ptr;
15738 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15744 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15748 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED);
15754 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
15755 goto nla_put_failure;
15757 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
15758 goto nla_put_failure;
15760 if (nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac))
15761 goto nla_put_failure;
15763 if ((sta_opmode->changed & STA_OPMODE_SMPS_MODE_CHANGED) &&
15764 nla_put_u8(msg, NL80211_ATTR_SMPS_MODE, sta_opmode->smps_mode))
15765 goto nla_put_failure;
15767 if ((sta_opmode->changed & STA_OPMODE_MAX_BW_CHANGED) &&
15768 nla_put_u8(msg, NL80211_ATTR_CHANNEL_WIDTH, sta_opmode->bw))
15769 goto nla_put_failure;
15771 if ((sta_opmode->changed & STA_OPMODE_N_SS_CHANGED) &&
15772 nla_put_u8(msg, NL80211_ATTR_NSS, sta_opmode->rx_nss))
15773 goto nla_put_failure;
15775 genlmsg_end(msg, hdr);
15777 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15778 NL80211_MCGRP_MLME, gfp);
15785 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify);
15787 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
15788 u64 cookie, bool acked, s32 ack_signal,
15789 bool is_valid_ack_signal, gfp_t gfp)
15791 struct wireless_dev *wdev = dev->ieee80211_ptr;
15792 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15793 struct sk_buff *msg;
15796 trace_cfg80211_probe_status(dev, addr, cookie, acked);
15798 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
15803 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
15809 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15810 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
15811 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
15812 nla_put_u64_64bit(msg, NL80211_ATTR_COOKIE, cookie,
15813 NL80211_ATTR_PAD) ||
15814 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)) ||
15815 (is_valid_ack_signal && nla_put_s32(msg, NL80211_ATTR_ACK_SIGNAL,
15817 goto nla_put_failure;
15819 genlmsg_end(msg, hdr);
15821 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
15822 NL80211_MCGRP_MLME, gfp);
15828 EXPORT_SYMBOL(cfg80211_probe_status);
15830 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
15831 const u8 *frame, size_t len,
15832 int freq, int sig_dbm)
15834 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
15835 struct sk_buff *msg;
15837 struct cfg80211_beacon_registration *reg;
15839 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
15841 spin_lock_bh(&rdev->beacon_registrations_lock);
15842 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
15843 msg = nlmsg_new(len + 100, GFP_ATOMIC);
15845 spin_unlock_bh(&rdev->beacon_registrations_lock);
15849 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
15851 goto nla_put_failure;
15853 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15855 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
15857 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
15858 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
15859 goto nla_put_failure;
15861 genlmsg_end(msg, hdr);
15863 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
15865 spin_unlock_bh(&rdev->beacon_registrations_lock);
15869 spin_unlock_bh(&rdev->beacon_registrations_lock);
15872 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
15875 static int cfg80211_net_detect_results(struct sk_buff *msg,
15876 struct cfg80211_wowlan_wakeup *wakeup)
15878 struct cfg80211_wowlan_nd_info *nd = wakeup->net_detect;
15879 struct nlattr *nl_results, *nl_match, *nl_freqs;
15882 nl_results = nla_nest_start(
15883 msg, NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS);
15887 for (i = 0; i < nd->n_matches; i++) {
15888 struct cfg80211_wowlan_nd_match *match = nd->matches[i];
15890 nl_match = nla_nest_start(msg, i);
15894 /* The SSID attribute is optional in nl80211, but for
15895 * simplicity reasons it's always present in the
15896 * cfg80211 structure. If a driver can't pass the
15897 * SSID, that needs to be changed. A zero length SSID
15898 * is still a valid SSID (wildcard), so it cannot be
15899 * used for this purpose.
15901 if (nla_put(msg, NL80211_ATTR_SSID, match->ssid.ssid_len,
15902 match->ssid.ssid)) {
15903 nla_nest_cancel(msg, nl_match);
15907 if (match->n_channels) {
15908 nl_freqs = nla_nest_start(
15909 msg, NL80211_ATTR_SCAN_FREQUENCIES);
15911 nla_nest_cancel(msg, nl_match);
15915 for (j = 0; j < match->n_channels; j++) {
15916 if (nla_put_u32(msg, j, match->channels[j])) {
15917 nla_nest_cancel(msg, nl_freqs);
15918 nla_nest_cancel(msg, nl_match);
15923 nla_nest_end(msg, nl_freqs);
15926 nla_nest_end(msg, nl_match);
15930 nla_nest_end(msg, nl_results);
15934 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
15935 struct cfg80211_wowlan_wakeup *wakeup,
15938 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
15939 struct sk_buff *msg;
15943 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
15946 size += wakeup->packet_present_len;
15948 msg = nlmsg_new(size, gfp);
15952 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
15956 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
15957 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
15961 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
15962 wdev->netdev->ifindex))
15966 struct nlattr *reasons;
15968 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
15972 if (wakeup->disconnect &&
15973 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
15975 if (wakeup->magic_pkt &&
15976 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
15978 if (wakeup->gtk_rekey_failure &&
15979 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
15981 if (wakeup->eap_identity_req &&
15982 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
15984 if (wakeup->four_way_handshake &&
15985 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
15987 if (wakeup->rfkill_release &&
15988 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
15991 if (wakeup->pattern_idx >= 0 &&
15992 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
15993 wakeup->pattern_idx))
15996 if (wakeup->tcp_match &&
15997 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
16000 if (wakeup->tcp_connlost &&
16001 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
16004 if (wakeup->tcp_nomoretokens &&
16006 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
16009 if (wakeup->packet) {
16010 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
16011 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
16013 if (!wakeup->packet_80211) {
16015 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
16017 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
16020 if (wakeup->packet_len &&
16021 nla_put_u32(msg, len_attr, wakeup->packet_len))
16024 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
16029 if (wakeup->net_detect &&
16030 cfg80211_net_detect_results(msg, wakeup))
16033 nla_nest_end(msg, reasons);
16036 genlmsg_end(msg, hdr);
16038 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16039 NL80211_MCGRP_MLME, gfp);
16045 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
16048 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
16049 enum nl80211_tdls_operation oper,
16050 u16 reason_code, gfp_t gfp)
16052 struct wireless_dev *wdev = dev->ieee80211_ptr;
16053 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16054 struct sk_buff *msg;
16057 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
16060 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16064 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
16070 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16071 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16072 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
16073 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
16074 (reason_code > 0 &&
16075 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
16076 goto nla_put_failure;
16078 genlmsg_end(msg, hdr);
16080 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16081 NL80211_MCGRP_MLME, gfp);
16087 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
16089 static int nl80211_netlink_notify(struct notifier_block * nb,
16090 unsigned long state,
16093 struct netlink_notify *notify = _notify;
16094 struct cfg80211_registered_device *rdev;
16095 struct wireless_dev *wdev;
16096 struct cfg80211_beacon_registration *reg, *tmp;
16098 if (state != NETLINK_URELEASE || notify->protocol != NETLINK_GENERIC)
16099 return NOTIFY_DONE;
16103 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
16104 struct cfg80211_sched_scan_request *sched_scan_req;
16106 list_for_each_entry_rcu(sched_scan_req,
16107 &rdev->sched_scan_req_list,
16109 if (sched_scan_req->owner_nlportid == notify->portid) {
16110 sched_scan_req->nl_owner_dead = true;
16111 schedule_work(&rdev->sched_scan_stop_wk);
16115 list_for_each_entry_rcu(wdev, &rdev->wiphy.wdev_list, list) {
16116 cfg80211_mlme_unregister_socket(wdev, notify->portid);
16118 if (wdev->owner_nlportid == notify->portid) {
16119 wdev->nl_owner_dead = true;
16120 schedule_work(&rdev->destroy_work);
16121 } else if (wdev->conn_owner_nlportid == notify->portid) {
16122 schedule_work(&wdev->disconnect_wk);
16125 cfg80211_release_pmsr(wdev, notify->portid);
16128 spin_lock_bh(&rdev->beacon_registrations_lock);
16129 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
16131 if (reg->nlportid == notify->portid) {
16132 list_del(®->list);
16137 spin_unlock_bh(&rdev->beacon_registrations_lock);
16143 * It is possible that the user space process that is controlling the
16144 * indoor setting disappeared, so notify the regulatory core.
16146 regulatory_netlink_notify(notify->portid);
16150 static struct notifier_block nl80211_netlink_notifier = {
16151 .notifier_call = nl80211_netlink_notify,
16154 void cfg80211_ft_event(struct net_device *netdev,
16155 struct cfg80211_ft_event_params *ft_event)
16157 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
16158 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16159 struct sk_buff *msg;
16162 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
16164 if (!ft_event->target_ap)
16167 msg = nlmsg_new(100 + ft_event->ies_len + ft_event->ric_ies_len,
16172 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
16176 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16177 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
16178 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
16181 if (ft_event->ies &&
16182 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
16184 if (ft_event->ric_ies &&
16185 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
16186 ft_event->ric_ies))
16189 genlmsg_end(msg, hdr);
16191 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
16192 NL80211_MCGRP_MLME, GFP_KERNEL);
16197 EXPORT_SYMBOL(cfg80211_ft_event);
16199 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
16201 struct cfg80211_registered_device *rdev;
16202 struct sk_buff *msg;
16206 rdev = wiphy_to_rdev(wdev->wiphy);
16207 if (!rdev->crit_proto_nlportid)
16210 nlportid = rdev->crit_proto_nlportid;
16211 rdev->crit_proto_nlportid = 0;
16213 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16217 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
16219 goto nla_put_failure;
16221 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16222 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16224 goto nla_put_failure;
16226 genlmsg_end(msg, hdr);
16228 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
16234 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
16236 void nl80211_send_ap_stopped(struct wireless_dev *wdev)
16238 struct wiphy *wiphy = wdev->wiphy;
16239 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
16240 struct sk_buff *msg;
16243 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
16247 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
16251 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16252 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
16253 nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
16257 genlmsg_end(msg, hdr);
16259 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
16260 NL80211_MCGRP_MLME, GFP_KERNEL);
16266 int cfg80211_external_auth_request(struct net_device *dev,
16267 struct cfg80211_external_auth_params *params,
16270 struct wireless_dev *wdev = dev->ieee80211_ptr;
16271 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
16272 struct sk_buff *msg;
16275 if (!wdev->conn_owner_nlportid)
16278 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
16282 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH);
16284 goto nla_put_failure;
16286 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
16287 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
16288 nla_put_u32(msg, NL80211_ATTR_AKM_SUITES, params->key_mgmt_suite) ||
16289 nla_put_u32(msg, NL80211_ATTR_EXTERNAL_AUTH_ACTION,
16291 nla_put(msg, NL80211_ATTR_BSSID, ETH_ALEN, params->bssid) ||
16292 nla_put(msg, NL80211_ATTR_SSID, params->ssid.ssid_len,
16293 params->ssid.ssid))
16294 goto nla_put_failure;
16296 genlmsg_end(msg, hdr);
16297 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg,
16298 wdev->conn_owner_nlportid);
16305 EXPORT_SYMBOL(cfg80211_external_auth_request);
16307 /* initialisation/exit functions */
16309 int __init nl80211_init(void)
16313 err = genl_register_family(&nl80211_fam);
16317 err = netlink_register_notifier(&nl80211_netlink_notifier);
16323 genl_unregister_family(&nl80211_fam);
16327 void nl80211_exit(void)
16329 netlink_unregister_notifier(&nl80211_netlink_notifier);
16330 genl_unregister_family(&nl80211_fam);