1 // SPDX-License-Identifier: GPL-2.0-only
3 * This is the new netlink-based wireless configuration interface.
5 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
6 * Copyright 2013-2014 Intel Mobile Communications GmbH
7 * Copyright 2015-2017 Intel Deutschland GmbH
8 * Copyright (C) 2018-2021 Intel Corporation
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/slab.h>
15 #include <linux/list.h>
16 #include <linux/if_ether.h>
17 #include <linux/ieee80211.h>
18 #include <linux/nl80211.h>
19 #include <linux/rtnetlink.h>
20 #include <linux/netlink.h>
21 #include <linux/nospec.h>
22 #include <linux/etherdevice.h>
23 #include <linux/if_vlan.h>
24 #include <net/net_namespace.h>
25 #include <net/genetlink.h>
26 #include <net/cfg80211.h>
28 #include <net/inet_connection_sock.h>
34 static int nl80211_crypto_settings(struct cfg80211_registered_device
*rdev
,
35 struct genl_info
*info
,
36 struct cfg80211_crypto_settings
*settings
,
39 /* the netlink family */
40 static struct genl_family nl80211_fam
;
42 /* multicast groups */
43 enum nl80211_multicast_groups
{
46 NL80211_MCGRP_REGULATORY
,
50 NL80211_MCGRP_TESTMODE
/* keep last - ifdef! */
53 static const struct genl_multicast_group nl80211_mcgrps
[] = {
54 [NL80211_MCGRP_CONFIG
] = { .name
= NL80211_MULTICAST_GROUP_CONFIG
},
55 [NL80211_MCGRP_SCAN
] = { .name
= NL80211_MULTICAST_GROUP_SCAN
},
56 [NL80211_MCGRP_REGULATORY
] = { .name
= NL80211_MULTICAST_GROUP_REG
},
57 [NL80211_MCGRP_MLME
] = { .name
= NL80211_MULTICAST_GROUP_MLME
},
58 [NL80211_MCGRP_VENDOR
] = { .name
= NL80211_MULTICAST_GROUP_VENDOR
},
59 [NL80211_MCGRP_NAN
] = { .name
= NL80211_MULTICAST_GROUP_NAN
},
60 #ifdef CONFIG_NL80211_TESTMODE
61 [NL80211_MCGRP_TESTMODE
] = { .name
= NL80211_MULTICAST_GROUP_TESTMODE
}
65 /* returns ERR_PTR values */
66 static struct wireless_dev
*
67 __cfg80211_wdev_from_attrs(struct cfg80211_registered_device
*rdev
,
68 struct net
*netns
, struct nlattr
**attrs
)
70 struct wireless_dev
*result
= NULL
;
71 bool have_ifidx
= attrs
[NL80211_ATTR_IFINDEX
];
72 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;
88 struct wireless_dev
*wdev
;
90 lockdep_assert_held(&rdev
->wiphy
.mtx
);
92 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
93 if (have_ifidx
&& wdev
->netdev
&&
94 wdev
->netdev
->ifindex
== ifidx
) {
98 if (have_wdev_id
&& wdev
->identifier
== (u32
)wdev_id
) {
104 return result
?: ERR_PTR(-ENODEV
);
109 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
110 struct wireless_dev
*wdev
;
112 if (wiphy_net(&rdev
->wiphy
) != netns
)
115 if (have_wdev_id
&& rdev
->wiphy_idx
!= wiphy_idx
)
118 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
119 if (have_ifidx
&& wdev
->netdev
&&
120 wdev
->netdev
->ifindex
== ifidx
) {
124 if (have_wdev_id
&& wdev
->identifier
== (u32
)wdev_id
) {
136 return ERR_PTR(-ENODEV
);
139 static struct cfg80211_registered_device
*
140 __cfg80211_rdev_from_attrs(struct net
*netns
, struct nlattr
**attrs
)
142 struct cfg80211_registered_device
*rdev
= NULL
, *tmp
;
143 struct net_device
*netdev
;
147 if (!attrs
[NL80211_ATTR_WIPHY
] &&
148 !attrs
[NL80211_ATTR_IFINDEX
] &&
149 !attrs
[NL80211_ATTR_WDEV
])
150 return ERR_PTR(-EINVAL
);
152 if (attrs
[NL80211_ATTR_WIPHY
])
153 rdev
= cfg80211_rdev_by_wiphy_idx(
154 nla_get_u32(attrs
[NL80211_ATTR_WIPHY
]));
156 if (attrs
[NL80211_ATTR_WDEV
]) {
157 u64 wdev_id
= nla_get_u64(attrs
[NL80211_ATTR_WDEV
]);
158 struct wireless_dev
*wdev
;
161 tmp
= cfg80211_rdev_by_wiphy_idx(wdev_id
>> 32);
163 /* make sure wdev exists */
164 list_for_each_entry(wdev
, &tmp
->wiphy
.wdev_list
, list
) {
165 if (wdev
->identifier
!= (u32
)wdev_id
)
174 if (rdev
&& tmp
!= rdev
)
175 return ERR_PTR(-EINVAL
);
180 if (attrs
[NL80211_ATTR_IFINDEX
]) {
181 int ifindex
= nla_get_u32(attrs
[NL80211_ATTR_IFINDEX
]);
183 netdev
= __dev_get_by_index(netns
, ifindex
);
185 if (netdev
->ieee80211_ptr
)
187 netdev
->ieee80211_ptr
->wiphy
);
191 /* not wireless device -- return error */
193 return ERR_PTR(-EINVAL
);
195 /* mismatch -- return error */
196 if (rdev
&& tmp
!= rdev
)
197 return ERR_PTR(-EINVAL
);
204 return ERR_PTR(-ENODEV
);
206 if (netns
!= wiphy_net(&rdev
->wiphy
))
207 return ERR_PTR(-ENODEV
);
213 * This function returns a pointer to the driver
214 * that the genl_info item that is passed refers to.
216 * The result of this can be a PTR_ERR and hence must
217 * be checked with IS_ERR() for errors.
219 static struct cfg80211_registered_device
*
220 cfg80211_get_dev_from_info(struct net
*netns
, struct genl_info
*info
)
222 return __cfg80211_rdev_from_attrs(netns
, info
->attrs
);
225 static int validate_beacon_head(const struct nlattr
*attr
,
226 struct netlink_ext_ack
*extack
)
228 const u8
*data
= nla_data(attr
);
229 unsigned int len
= nla_len(attr
);
230 const struct element
*elem
;
231 const struct ieee80211_mgmt
*mgmt
= (void *)data
;
232 unsigned int fixedlen
, hdrlen
;
235 if (len
< offsetofend(typeof(*mgmt
), frame_control
))
238 s1g_bcn
= ieee80211_is_s1g_beacon(mgmt
->frame_control
);
240 fixedlen
= offsetof(struct ieee80211_ext
,
241 u
.s1g_beacon
.variable
);
242 hdrlen
= offsetof(struct ieee80211_ext
, u
.s1g_beacon
);
244 fixedlen
= offsetof(struct ieee80211_mgmt
,
246 hdrlen
= offsetof(struct ieee80211_mgmt
, u
.beacon
);
252 if (ieee80211_hdrlen(mgmt
->frame_control
) != hdrlen
)
258 for_each_element(elem
, data
, len
) {
262 if (for_each_element_completed(elem
, data
, len
))
266 NL_SET_ERR_MSG_ATTR(extack
, attr
, "malformed beacon head");
270 static int validate_ie_attr(const struct nlattr
*attr
,
271 struct netlink_ext_ack
*extack
)
273 const u8
*data
= nla_data(attr
);
274 unsigned int len
= nla_len(attr
);
275 const struct element
*elem
;
277 for_each_element(elem
, data
, len
) {
281 if (for_each_element_completed(elem
, data
, len
))
284 NL_SET_ERR_MSG_ATTR(extack
, attr
, "malformed information elements");
288 /* policy for the attributes */
289 static const struct nla_policy nl80211_policy
[NUM_NL80211_ATTR
];
291 static const struct nla_policy
292 nl80211_ftm_responder_policy
[NL80211_FTM_RESP_ATTR_MAX
+ 1] = {
293 [NL80211_FTM_RESP_ATTR_ENABLED
] = { .type
= NLA_FLAG
, },
294 [NL80211_FTM_RESP_ATTR_LCI
] = { .type
= NLA_BINARY
,
296 [NL80211_FTM_RESP_ATTR_CIVICLOC
] = { .type
= NLA_BINARY
,
300 static const struct nla_policy
301 nl80211_pmsr_ftm_req_attr_policy
[NL80211_PMSR_FTM_REQ_ATTR_MAX
+ 1] = {
302 [NL80211_PMSR_FTM_REQ_ATTR_ASAP
] = { .type
= NLA_FLAG
},
303 [NL80211_PMSR_FTM_REQ_ATTR_PREAMBLE
] = { .type
= NLA_U32
},
304 [NL80211_PMSR_FTM_REQ_ATTR_NUM_BURSTS_EXP
] =
305 NLA_POLICY_MAX(NLA_U8
, 15),
306 [NL80211_PMSR_FTM_REQ_ATTR_BURST_PERIOD
] = { .type
= NLA_U16
},
307 [NL80211_PMSR_FTM_REQ_ATTR_BURST_DURATION
] =
308 NLA_POLICY_MAX(NLA_U8
, 15),
309 [NL80211_PMSR_FTM_REQ_ATTR_FTMS_PER_BURST
] =
310 NLA_POLICY_MAX(NLA_U8
, 31),
311 [NL80211_PMSR_FTM_REQ_ATTR_NUM_FTMR_RETRIES
] = { .type
= NLA_U8
},
312 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_LCI
] = { .type
= NLA_FLAG
},
313 [NL80211_PMSR_FTM_REQ_ATTR_REQUEST_CIVICLOC
] = { .type
= NLA_FLAG
},
314 [NL80211_PMSR_FTM_REQ_ATTR_TRIGGER_BASED
] = { .type
= NLA_FLAG
},
315 [NL80211_PMSR_FTM_REQ_ATTR_NON_TRIGGER_BASED
] = { .type
= NLA_FLAG
},
316 [NL80211_PMSR_FTM_REQ_ATTR_LMR_FEEDBACK
] = { .type
= NLA_FLAG
},
319 static const struct nla_policy
320 nl80211_pmsr_req_data_policy
[NL80211_PMSR_TYPE_MAX
+ 1] = {
321 [NL80211_PMSR_TYPE_FTM
] =
322 NLA_POLICY_NESTED(nl80211_pmsr_ftm_req_attr_policy
),
325 static const struct nla_policy
326 nl80211_pmsr_req_attr_policy
[NL80211_PMSR_REQ_ATTR_MAX
+ 1] = {
327 [NL80211_PMSR_REQ_ATTR_DATA
] =
328 NLA_POLICY_NESTED(nl80211_pmsr_req_data_policy
),
329 [NL80211_PMSR_REQ_ATTR_GET_AP_TSF
] = { .type
= NLA_FLAG
},
332 static const struct nla_policy
333 nl80211_psmr_peer_attr_policy
[NL80211_PMSR_PEER_ATTR_MAX
+ 1] = {
334 [NL80211_PMSR_PEER_ATTR_ADDR
] = NLA_POLICY_ETH_ADDR
,
335 [NL80211_PMSR_PEER_ATTR_CHAN
] = NLA_POLICY_NESTED(nl80211_policy
),
336 [NL80211_PMSR_PEER_ATTR_REQ
] =
337 NLA_POLICY_NESTED(nl80211_pmsr_req_attr_policy
),
338 [NL80211_PMSR_PEER_ATTR_RESP
] = { .type
= NLA_REJECT
},
341 static const struct nla_policy
342 nl80211_pmsr_attr_policy
[NL80211_PMSR_ATTR_MAX
+ 1] = {
343 [NL80211_PMSR_ATTR_MAX_PEERS
] = { .type
= NLA_REJECT
},
344 [NL80211_PMSR_ATTR_REPORT_AP_TSF
] = { .type
= NLA_REJECT
},
345 [NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR
] = { .type
= NLA_REJECT
},
346 [NL80211_PMSR_ATTR_TYPE_CAPA
] = { .type
= NLA_REJECT
},
347 [NL80211_PMSR_ATTR_PEERS
] =
348 NLA_POLICY_NESTED_ARRAY(nl80211_psmr_peer_attr_policy
),
351 static const struct nla_policy
352 he_obss_pd_policy
[NL80211_HE_OBSS_PD_ATTR_MAX
+ 1] = {
353 [NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET
] =
354 NLA_POLICY_RANGE(NLA_U8
, 1, 20),
355 [NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET
] =
356 NLA_POLICY_RANGE(NLA_U8
, 1, 20),
357 [NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET
] =
358 NLA_POLICY_RANGE(NLA_U8
, 1, 20),
359 [NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP
] =
360 NLA_POLICY_EXACT_LEN(8),
361 [NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP
] =
362 NLA_POLICY_EXACT_LEN(8),
363 [NL80211_HE_OBSS_PD_ATTR_SR_CTRL
] = { .type
= NLA_U8
},
366 static const struct nla_policy
367 he_bss_color_policy
[NL80211_HE_BSS_COLOR_ATTR_MAX
+ 1] = {
368 [NL80211_HE_BSS_COLOR_ATTR_COLOR
] = NLA_POLICY_RANGE(NLA_U8
, 1, 63),
369 [NL80211_HE_BSS_COLOR_ATTR_DISABLED
] = { .type
= NLA_FLAG
},
370 [NL80211_HE_BSS_COLOR_ATTR_PARTIAL
] = { .type
= NLA_FLAG
},
373 static const struct nla_policy nl80211_txattr_policy
[NL80211_TXRATE_MAX
+ 1] = {
374 [NL80211_TXRATE_LEGACY
] = { .type
= NLA_BINARY
,
375 .len
= NL80211_MAX_SUPP_RATES
},
376 [NL80211_TXRATE_HT
] = { .type
= NLA_BINARY
,
377 .len
= NL80211_MAX_SUPP_HT_RATES
},
378 [NL80211_TXRATE_VHT
] = NLA_POLICY_EXACT_LEN_WARN(sizeof(struct nl80211_txrate_vht
)),
379 [NL80211_TXRATE_GI
] = { .type
= NLA_U8
},
380 [NL80211_TXRATE_HE
] = NLA_POLICY_EXACT_LEN(sizeof(struct nl80211_txrate_he
)),
381 [NL80211_TXRATE_HE_GI
] = NLA_POLICY_RANGE(NLA_U8
,
382 NL80211_RATE_INFO_HE_GI_0_8
,
383 NL80211_RATE_INFO_HE_GI_3_2
),
384 [NL80211_TXRATE_HE_LTF
] = NLA_POLICY_RANGE(NLA_U8
,
385 NL80211_RATE_INFO_HE_1XLTF
,
386 NL80211_RATE_INFO_HE_4XLTF
),
389 static const struct nla_policy
390 nl80211_tid_config_attr_policy
[NL80211_TID_CONFIG_ATTR_MAX
+ 1] = {
391 [NL80211_TID_CONFIG_ATTR_VIF_SUPP
] = { .type
= NLA_U64
},
392 [NL80211_TID_CONFIG_ATTR_PEER_SUPP
] = { .type
= NLA_U64
},
393 [NL80211_TID_CONFIG_ATTR_OVERRIDE
] = { .type
= NLA_FLAG
},
394 [NL80211_TID_CONFIG_ATTR_TIDS
] = NLA_POLICY_RANGE(NLA_U16
, 1, 0xff),
395 [NL80211_TID_CONFIG_ATTR_NOACK
] =
396 NLA_POLICY_MAX(NLA_U8
, NL80211_TID_CONFIG_DISABLE
),
397 [NL80211_TID_CONFIG_ATTR_RETRY_SHORT
] = NLA_POLICY_MIN(NLA_U8
, 1),
398 [NL80211_TID_CONFIG_ATTR_RETRY_LONG
] = NLA_POLICY_MIN(NLA_U8
, 1),
399 [NL80211_TID_CONFIG_ATTR_AMPDU_CTRL
] =
400 NLA_POLICY_MAX(NLA_U8
, NL80211_TID_CONFIG_DISABLE
),
401 [NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL
] =
402 NLA_POLICY_MAX(NLA_U8
, NL80211_TID_CONFIG_DISABLE
),
403 [NL80211_TID_CONFIG_ATTR_AMSDU_CTRL
] =
404 NLA_POLICY_MAX(NLA_U8
, NL80211_TID_CONFIG_DISABLE
),
405 [NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE
] =
406 NLA_POLICY_MAX(NLA_U8
, NL80211_TX_RATE_FIXED
),
407 [NL80211_TID_CONFIG_ATTR_TX_RATE
] =
408 NLA_POLICY_NESTED(nl80211_txattr_policy
),
411 static const struct nla_policy
412 nl80211_fils_discovery_policy
[NL80211_FILS_DISCOVERY_ATTR_MAX
+ 1] = {
413 [NL80211_FILS_DISCOVERY_ATTR_INT_MIN
] = NLA_POLICY_MAX(NLA_U32
, 10000),
414 [NL80211_FILS_DISCOVERY_ATTR_INT_MAX
] = NLA_POLICY_MAX(NLA_U32
, 10000),
415 [NL80211_FILS_DISCOVERY_ATTR_TMPL
] =
416 NLA_POLICY_RANGE(NLA_BINARY
,
417 NL80211_FILS_DISCOVERY_TMPL_MIN_LEN
,
418 IEEE80211_MAX_DATA_LEN
),
421 static const struct nla_policy
422 nl80211_unsol_bcast_probe_resp_policy
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX
+ 1] = {
423 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT
] = NLA_POLICY_MAX(NLA_U32
, 20),
424 [NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL
] = { .type
= NLA_BINARY
,
425 .len
= IEEE80211_MAX_DATA_LEN
}
428 static const struct nla_policy
429 sar_specs_policy
[NL80211_SAR_ATTR_SPECS_MAX
+ 1] = {
430 [NL80211_SAR_ATTR_SPECS_POWER
] = { .type
= NLA_S32
},
431 [NL80211_SAR_ATTR_SPECS_RANGE_INDEX
] = {.type
= NLA_U32
},
434 static const struct nla_policy
435 sar_policy
[NL80211_SAR_ATTR_MAX
+ 1] = {
436 [NL80211_SAR_ATTR_TYPE
] = NLA_POLICY_MAX(NLA_U32
, NUM_NL80211_SAR_TYPE
),
437 [NL80211_SAR_ATTR_SPECS
] = NLA_POLICY_NESTED_ARRAY(sar_specs_policy
),
440 static const struct nla_policy nl80211_policy
[NUM_NL80211_ATTR
] = {
441 [0] = { .strict_start_type
= NL80211_ATTR_HE_OBSS_PD
},
442 [NL80211_ATTR_WIPHY
] = { .type
= NLA_U32
},
443 [NL80211_ATTR_WIPHY_NAME
] = { .type
= NLA_NUL_STRING
,
445 [NL80211_ATTR_WIPHY_TXQ_PARAMS
] = { .type
= NLA_NESTED
},
447 [NL80211_ATTR_WIPHY_FREQ
] = { .type
= NLA_U32
},
448 [NL80211_ATTR_WIPHY_CHANNEL_TYPE
] = { .type
= NLA_U32
},
449 [NL80211_ATTR_WIPHY_EDMG_CHANNELS
] = NLA_POLICY_RANGE(NLA_U8
,
450 NL80211_EDMG_CHANNELS_MIN
,
451 NL80211_EDMG_CHANNELS_MAX
),
452 [NL80211_ATTR_WIPHY_EDMG_BW_CONFIG
] = NLA_POLICY_RANGE(NLA_U8
,
453 NL80211_EDMG_BW_CONFIG_MIN
,
454 NL80211_EDMG_BW_CONFIG_MAX
),
456 [NL80211_ATTR_CHANNEL_WIDTH
] = { .type
= NLA_U32
},
457 [NL80211_ATTR_CENTER_FREQ1
] = { .type
= NLA_U32
},
458 [NL80211_ATTR_CENTER_FREQ1_OFFSET
] = NLA_POLICY_RANGE(NLA_U32
, 0, 999),
459 [NL80211_ATTR_CENTER_FREQ2
] = { .type
= NLA_U32
},
461 [NL80211_ATTR_WIPHY_RETRY_SHORT
] = NLA_POLICY_MIN(NLA_U8
, 1),
462 [NL80211_ATTR_WIPHY_RETRY_LONG
] = NLA_POLICY_MIN(NLA_U8
, 1),
463 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD
] = { .type
= NLA_U32
},
464 [NL80211_ATTR_WIPHY_RTS_THRESHOLD
] = { .type
= NLA_U32
},
465 [NL80211_ATTR_WIPHY_COVERAGE_CLASS
] = { .type
= NLA_U8
},
466 [NL80211_ATTR_WIPHY_DYN_ACK
] = { .type
= NLA_FLAG
},
468 [NL80211_ATTR_IFTYPE
] = NLA_POLICY_MAX(NLA_U32
, NL80211_IFTYPE_MAX
),
469 [NL80211_ATTR_IFINDEX
] = { .type
= NLA_U32
},
470 [NL80211_ATTR_IFNAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
-1 },
472 [NL80211_ATTR_MAC
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
473 [NL80211_ATTR_PREV_BSSID
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
475 [NL80211_ATTR_KEY
] = { .type
= NLA_NESTED
, },
476 [NL80211_ATTR_KEY_DATA
] = { .type
= NLA_BINARY
,
477 .len
= WLAN_MAX_KEY_LEN
},
478 [NL80211_ATTR_KEY_IDX
] = NLA_POLICY_MAX(NLA_U8
, 7),
479 [NL80211_ATTR_KEY_CIPHER
] = { .type
= NLA_U32
},
480 [NL80211_ATTR_KEY_DEFAULT
] = { .type
= NLA_FLAG
},
481 [NL80211_ATTR_KEY_SEQ
] = { .type
= NLA_BINARY
, .len
= 16 },
482 [NL80211_ATTR_KEY_TYPE
] =
483 NLA_POLICY_MAX(NLA_U32
, NUM_NL80211_KEYTYPES
),
485 [NL80211_ATTR_BEACON_INTERVAL
] = { .type
= NLA_U32
},
486 [NL80211_ATTR_DTIM_PERIOD
] = { .type
= NLA_U32
},
487 [NL80211_ATTR_BEACON_HEAD
] =
488 NLA_POLICY_VALIDATE_FN(NLA_BINARY
, validate_beacon_head
,
489 IEEE80211_MAX_DATA_LEN
),
490 [NL80211_ATTR_BEACON_TAIL
] =
491 NLA_POLICY_VALIDATE_FN(NLA_BINARY
, validate_ie_attr
,
492 IEEE80211_MAX_DATA_LEN
),
493 [NL80211_ATTR_STA_AID
] =
494 NLA_POLICY_RANGE(NLA_U16
, 1, IEEE80211_MAX_AID
),
495 [NL80211_ATTR_STA_FLAGS
] = { .type
= NLA_NESTED
},
496 [NL80211_ATTR_STA_LISTEN_INTERVAL
] = { .type
= NLA_U16
},
497 [NL80211_ATTR_STA_SUPPORTED_RATES
] = { .type
= NLA_BINARY
,
498 .len
= NL80211_MAX_SUPP_RATES
},
499 [NL80211_ATTR_STA_PLINK_ACTION
] =
500 NLA_POLICY_MAX(NLA_U8
, NUM_NL80211_PLINK_ACTIONS
- 1),
501 [NL80211_ATTR_STA_TX_POWER_SETTING
] =
502 NLA_POLICY_RANGE(NLA_U8
,
503 NL80211_TX_POWER_AUTOMATIC
,
504 NL80211_TX_POWER_FIXED
),
505 [NL80211_ATTR_STA_TX_POWER
] = { .type
= NLA_S16
},
506 [NL80211_ATTR_STA_VLAN
] = { .type
= NLA_U32
},
507 [NL80211_ATTR_MNTR_FLAGS
] = { /* NLA_NESTED can't be empty */ },
508 [NL80211_ATTR_MESH_ID
] = { .type
= NLA_BINARY
,
509 .len
= IEEE80211_MAX_MESH_ID_LEN
},
510 [NL80211_ATTR_MPATH_NEXT_HOP
] = NLA_POLICY_ETH_ADDR_COMPAT
,
512 [NL80211_ATTR_REG_ALPHA2
] = { .type
= NLA_STRING
, .len
= 2 },
513 [NL80211_ATTR_REG_RULES
] = { .type
= NLA_NESTED
},
515 [NL80211_ATTR_BSS_CTS_PROT
] = { .type
= NLA_U8
},
516 [NL80211_ATTR_BSS_SHORT_PREAMBLE
] = { .type
= NLA_U8
},
517 [NL80211_ATTR_BSS_SHORT_SLOT_TIME
] = { .type
= NLA_U8
},
518 [NL80211_ATTR_BSS_BASIC_RATES
] = { .type
= NLA_BINARY
,
519 .len
= NL80211_MAX_SUPP_RATES
},
520 [NL80211_ATTR_BSS_HT_OPMODE
] = { .type
= NLA_U16
},
522 [NL80211_ATTR_MESH_CONFIG
] = { .type
= NLA_NESTED
},
523 [NL80211_ATTR_SUPPORT_MESH_AUTH
] = { .type
= NLA_FLAG
},
525 [NL80211_ATTR_HT_CAPABILITY
] = NLA_POLICY_EXACT_LEN_WARN(NL80211_HT_CAPABILITY_LEN
),
527 [NL80211_ATTR_MGMT_SUBTYPE
] = { .type
= NLA_U8
},
528 [NL80211_ATTR_IE
] = NLA_POLICY_VALIDATE_FN(NLA_BINARY
,
530 IEEE80211_MAX_DATA_LEN
),
531 [NL80211_ATTR_SCAN_FREQUENCIES
] = { .type
= NLA_NESTED
},
532 [NL80211_ATTR_SCAN_SSIDS
] = { .type
= NLA_NESTED
},
534 [NL80211_ATTR_SSID
] = { .type
= NLA_BINARY
,
535 .len
= IEEE80211_MAX_SSID_LEN
},
536 [NL80211_ATTR_AUTH_TYPE
] = { .type
= NLA_U32
},
537 [NL80211_ATTR_REASON_CODE
] = { .type
= NLA_U16
},
538 [NL80211_ATTR_FREQ_FIXED
] = { .type
= NLA_FLAG
},
539 [NL80211_ATTR_TIMED_OUT
] = { .type
= NLA_FLAG
},
540 [NL80211_ATTR_USE_MFP
] = NLA_POLICY_RANGE(NLA_U32
,
542 NL80211_MFP_OPTIONAL
),
543 [NL80211_ATTR_STA_FLAGS2
] = {
544 .len
= sizeof(struct nl80211_sta_flag_update
),
546 [NL80211_ATTR_CONTROL_PORT
] = { .type
= NLA_FLAG
},
547 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE
] = { .type
= NLA_U16
},
548 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
] = { .type
= NLA_FLAG
},
549 [NL80211_ATTR_CONTROL_PORT_OVER_NL80211
] = { .type
= NLA_FLAG
},
550 [NL80211_ATTR_PRIVACY
] = { .type
= NLA_FLAG
},
551 [NL80211_ATTR_STATUS_CODE
] = { .type
= NLA_U16
},
552 [NL80211_ATTR_CIPHER_SUITE_GROUP
] = { .type
= NLA_U32
},
553 [NL80211_ATTR_WPA_VERSIONS
] = { .type
= NLA_U32
},
554 [NL80211_ATTR_PID
] = { .type
= NLA_U32
},
555 [NL80211_ATTR_4ADDR
] = { .type
= NLA_U8
},
556 [NL80211_ATTR_PMKID
] = NLA_POLICY_EXACT_LEN_WARN(WLAN_PMKID_LEN
),
557 [NL80211_ATTR_DURATION
] = { .type
= NLA_U32
},
558 [NL80211_ATTR_COOKIE
] = { .type
= NLA_U64
},
559 [NL80211_ATTR_TX_RATES
] = { .type
= NLA_NESTED
},
560 [NL80211_ATTR_FRAME
] = { .type
= NLA_BINARY
,
561 .len
= IEEE80211_MAX_DATA_LEN
},
562 [NL80211_ATTR_FRAME_MATCH
] = { .type
= NLA_BINARY
, },
563 [NL80211_ATTR_PS_STATE
] = NLA_POLICY_RANGE(NLA_U32
,
566 [NL80211_ATTR_CQM
] = { .type
= NLA_NESTED
, },
567 [NL80211_ATTR_LOCAL_STATE_CHANGE
] = { .type
= NLA_FLAG
},
568 [NL80211_ATTR_AP_ISOLATE
] = { .type
= NLA_U8
},
569 [NL80211_ATTR_WIPHY_TX_POWER_SETTING
] = { .type
= NLA_U32
},
570 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL
] = { .type
= NLA_U32
},
571 [NL80211_ATTR_FRAME_TYPE
] = { .type
= NLA_U16
},
572 [NL80211_ATTR_WIPHY_ANTENNA_TX
] = { .type
= NLA_U32
},
573 [NL80211_ATTR_WIPHY_ANTENNA_RX
] = { .type
= NLA_U32
},
574 [NL80211_ATTR_MCAST_RATE
] = { .type
= NLA_U32
},
575 [NL80211_ATTR_OFFCHANNEL_TX_OK
] = { .type
= NLA_FLAG
},
576 [NL80211_ATTR_KEY_DEFAULT_TYPES
] = { .type
= NLA_NESTED
},
577 [NL80211_ATTR_WOWLAN_TRIGGERS
] = { .type
= NLA_NESTED
},
578 [NL80211_ATTR_STA_PLINK_STATE
] =
579 NLA_POLICY_MAX(NLA_U8
, NUM_NL80211_PLINK_STATES
- 1),
580 [NL80211_ATTR_MEASUREMENT_DURATION
] = { .type
= NLA_U16
},
581 [NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY
] = { .type
= NLA_FLAG
},
582 [NL80211_ATTR_MESH_PEER_AID
] =
583 NLA_POLICY_RANGE(NLA_U16
, 1, IEEE80211_MAX_AID
),
584 [NL80211_ATTR_SCHED_SCAN_INTERVAL
] = { .type
= NLA_U32
},
585 [NL80211_ATTR_REKEY_DATA
] = { .type
= NLA_NESTED
},
586 [NL80211_ATTR_SCAN_SUPP_RATES
] = { .type
= NLA_NESTED
},
587 [NL80211_ATTR_HIDDEN_SSID
] =
588 NLA_POLICY_RANGE(NLA_U32
,
589 NL80211_HIDDEN_SSID_NOT_IN_USE
,
590 NL80211_HIDDEN_SSID_ZERO_CONTENTS
),
591 [NL80211_ATTR_IE_PROBE_RESP
] =
592 NLA_POLICY_VALIDATE_FN(NLA_BINARY
, validate_ie_attr
,
593 IEEE80211_MAX_DATA_LEN
),
594 [NL80211_ATTR_IE_ASSOC_RESP
] =
595 NLA_POLICY_VALIDATE_FN(NLA_BINARY
, validate_ie_attr
,
596 IEEE80211_MAX_DATA_LEN
),
597 [NL80211_ATTR_ROAM_SUPPORT
] = { .type
= NLA_FLAG
},
598 [NL80211_ATTR_SCHED_SCAN_MATCH
] = { .type
= NLA_NESTED
},
599 [NL80211_ATTR_TX_NO_CCK_RATE
] = { .type
= NLA_FLAG
},
600 [NL80211_ATTR_TDLS_ACTION
] = { .type
= NLA_U8
},
601 [NL80211_ATTR_TDLS_DIALOG_TOKEN
] = { .type
= NLA_U8
},
602 [NL80211_ATTR_TDLS_OPERATION
] = { .type
= NLA_U8
},
603 [NL80211_ATTR_TDLS_SUPPORT
] = { .type
= NLA_FLAG
},
604 [NL80211_ATTR_TDLS_EXTERNAL_SETUP
] = { .type
= NLA_FLAG
},
605 [NL80211_ATTR_TDLS_INITIATOR
] = { .type
= NLA_FLAG
},
606 [NL80211_ATTR_DONT_WAIT_FOR_ACK
] = { .type
= NLA_FLAG
},
607 [NL80211_ATTR_PROBE_RESP
] = { .type
= NLA_BINARY
,
608 .len
= IEEE80211_MAX_DATA_LEN
},
609 [NL80211_ATTR_DFS_REGION
] = { .type
= NLA_U8
},
610 [NL80211_ATTR_DISABLE_HT
] = { .type
= NLA_FLAG
},
611 [NL80211_ATTR_HT_CAPABILITY_MASK
] = {
612 .len
= NL80211_HT_CAPABILITY_LEN
614 [NL80211_ATTR_NOACK_MAP
] = { .type
= NLA_U16
},
615 [NL80211_ATTR_INACTIVITY_TIMEOUT
] = { .type
= NLA_U16
},
616 [NL80211_ATTR_BG_SCAN_PERIOD
] = { .type
= NLA_U16
},
617 [NL80211_ATTR_WDEV
] = { .type
= NLA_U64
},
618 [NL80211_ATTR_USER_REG_HINT_TYPE
] = { .type
= NLA_U32
},
620 /* need to include at least Auth Transaction and Status Code */
621 [NL80211_ATTR_AUTH_DATA
] = NLA_POLICY_MIN_LEN(4),
623 [NL80211_ATTR_VHT_CAPABILITY
] = NLA_POLICY_EXACT_LEN_WARN(NL80211_VHT_CAPABILITY_LEN
),
624 [NL80211_ATTR_SCAN_FLAGS
] = { .type
= NLA_U32
},
625 [NL80211_ATTR_P2P_CTWINDOW
] = NLA_POLICY_MAX(NLA_U8
, 127),
626 [NL80211_ATTR_P2P_OPPPS
] = NLA_POLICY_MAX(NLA_U8
, 1),
627 [NL80211_ATTR_LOCAL_MESH_POWER_MODE
] =
628 NLA_POLICY_RANGE(NLA_U32
,
629 NL80211_MESH_POWER_UNKNOWN
+ 1,
630 NL80211_MESH_POWER_MAX
),
631 [NL80211_ATTR_ACL_POLICY
] = {. type
= NLA_U32
},
632 [NL80211_ATTR_MAC_ADDRS
] = { .type
= NLA_NESTED
},
633 [NL80211_ATTR_STA_CAPABILITY
] = { .type
= NLA_U16
},
634 [NL80211_ATTR_STA_EXT_CAPABILITY
] = { .type
= NLA_BINARY
, },
635 [NL80211_ATTR_SPLIT_WIPHY_DUMP
] = { .type
= NLA_FLAG
, },
636 [NL80211_ATTR_DISABLE_VHT
] = { .type
= NLA_FLAG
},
637 [NL80211_ATTR_VHT_CAPABILITY_MASK
] = {
638 .len
= NL80211_VHT_CAPABILITY_LEN
,
640 [NL80211_ATTR_MDID
] = { .type
= NLA_U16
},
641 [NL80211_ATTR_IE_RIC
] = { .type
= NLA_BINARY
,
642 .len
= IEEE80211_MAX_DATA_LEN
},
643 [NL80211_ATTR_CRIT_PROT_ID
] = { .type
= NLA_U16
},
644 [NL80211_ATTR_MAX_CRIT_PROT_DURATION
] =
645 NLA_POLICY_MAX(NLA_U16
, NL80211_CRIT_PROTO_MAX_DURATION
),
646 [NL80211_ATTR_PEER_AID
] =
647 NLA_POLICY_RANGE(NLA_U16
, 1, IEEE80211_MAX_AID
),
648 [NL80211_ATTR_CH_SWITCH_COUNT
] = { .type
= NLA_U32
},
649 [NL80211_ATTR_CH_SWITCH_BLOCK_TX
] = { .type
= NLA_FLAG
},
650 [NL80211_ATTR_CSA_IES
] = { .type
= NLA_NESTED
},
651 [NL80211_ATTR_CNTDWN_OFFS_BEACON
] = { .type
= NLA_BINARY
},
652 [NL80211_ATTR_CNTDWN_OFFS_PRESP
] = { .type
= NLA_BINARY
},
653 [NL80211_ATTR_STA_SUPPORTED_CHANNELS
] = NLA_POLICY_MIN_LEN(2),
655 * The value of the Length field of the Supported Operating
656 * Classes element is between 2 and 253.
658 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
] =
659 NLA_POLICY_RANGE(NLA_BINARY
, 2, 253),
660 [NL80211_ATTR_HANDLE_DFS
] = { .type
= NLA_FLAG
},
661 [NL80211_ATTR_OPMODE_NOTIF
] = { .type
= NLA_U8
},
662 [NL80211_ATTR_VENDOR_ID
] = { .type
= NLA_U32
},
663 [NL80211_ATTR_VENDOR_SUBCMD
] = { .type
= NLA_U32
},
664 [NL80211_ATTR_VENDOR_DATA
] = { .type
= NLA_BINARY
},
665 [NL80211_ATTR_QOS_MAP
] = NLA_POLICY_RANGE(NLA_BINARY
,
666 IEEE80211_QOS_MAP_LEN_MIN
,
667 IEEE80211_QOS_MAP_LEN_MAX
),
668 [NL80211_ATTR_MAC_HINT
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
669 [NL80211_ATTR_WIPHY_FREQ_HINT
] = { .type
= NLA_U32
},
670 [NL80211_ATTR_TDLS_PEER_CAPABILITY
] = { .type
= NLA_U32
},
671 [NL80211_ATTR_SOCKET_OWNER
] = { .type
= NLA_FLAG
},
672 [NL80211_ATTR_CSA_C_OFFSETS_TX
] = { .type
= NLA_BINARY
},
673 [NL80211_ATTR_USE_RRM
] = { .type
= NLA_FLAG
},
674 [NL80211_ATTR_TSID
] = NLA_POLICY_MAX(NLA_U8
, IEEE80211_NUM_TIDS
- 1),
675 [NL80211_ATTR_USER_PRIO
] =
676 NLA_POLICY_MAX(NLA_U8
, IEEE80211_NUM_UPS
- 1),
677 [NL80211_ATTR_ADMITTED_TIME
] = { .type
= NLA_U16
},
678 [NL80211_ATTR_SMPS_MODE
] = { .type
= NLA_U8
},
679 [NL80211_ATTR_OPER_CLASS
] = { .type
= NLA_U8
},
680 [NL80211_ATTR_MAC_MASK
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
681 [NL80211_ATTR_WIPHY_SELF_MANAGED_REG
] = { .type
= NLA_FLAG
},
682 [NL80211_ATTR_NETNS_FD
] = { .type
= NLA_U32
},
683 [NL80211_ATTR_SCHED_SCAN_DELAY
] = { .type
= NLA_U32
},
684 [NL80211_ATTR_REG_INDOOR
] = { .type
= NLA_FLAG
},
685 [NL80211_ATTR_PBSS
] = { .type
= NLA_FLAG
},
686 [NL80211_ATTR_BSS_SELECT
] = { .type
= NLA_NESTED
},
687 [NL80211_ATTR_STA_SUPPORT_P2P_PS
] =
688 NLA_POLICY_MAX(NLA_U8
, NUM_NL80211_P2P_PS_STATUS
- 1),
689 [NL80211_ATTR_MU_MIMO_GROUP_DATA
] = {
690 .len
= VHT_MUMIMO_GROUPS_DATA_LEN
692 [NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
693 [NL80211_ATTR_NAN_MASTER_PREF
] = NLA_POLICY_MIN(NLA_U8
, 1),
694 [NL80211_ATTR_BANDS
] = { .type
= NLA_U32
},
695 [NL80211_ATTR_NAN_FUNC
] = { .type
= NLA_NESTED
},
696 [NL80211_ATTR_FILS_KEK
] = { .type
= NLA_BINARY
,
697 .len
= FILS_MAX_KEK_LEN
},
698 [NL80211_ATTR_FILS_NONCES
] = NLA_POLICY_EXACT_LEN_WARN(2 * FILS_NONCE_LEN
),
699 [NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED
] = { .type
= NLA_FLAG
, },
700 [NL80211_ATTR_BSSID
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
701 [NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI
] = { .type
= NLA_S8
},
702 [NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST
] = {
703 .len
= sizeof(struct nl80211_bss_select_rssi_adjust
)
705 [NL80211_ATTR_TIMEOUT_REASON
] = { .type
= NLA_U32
},
706 [NL80211_ATTR_FILS_ERP_USERNAME
] = { .type
= NLA_BINARY
,
707 .len
= FILS_ERP_MAX_USERNAME_LEN
},
708 [NL80211_ATTR_FILS_ERP_REALM
] = { .type
= NLA_BINARY
,
709 .len
= FILS_ERP_MAX_REALM_LEN
},
710 [NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
] = { .type
= NLA_U16
},
711 [NL80211_ATTR_FILS_ERP_RRK
] = { .type
= NLA_BINARY
,
712 .len
= FILS_ERP_MAX_RRK_LEN
},
713 [NL80211_ATTR_FILS_CACHE_ID
] = NLA_POLICY_EXACT_LEN_WARN(2),
714 [NL80211_ATTR_PMK
] = { .type
= NLA_BINARY
, .len
= PMK_MAX_LEN
},
715 [NL80211_ATTR_PMKR0_NAME
] = NLA_POLICY_EXACT_LEN(WLAN_PMK_NAME_LEN
),
716 [NL80211_ATTR_SCHED_SCAN_MULTI
] = { .type
= NLA_FLAG
},
717 [NL80211_ATTR_EXTERNAL_AUTH_SUPPORT
] = { .type
= NLA_FLAG
},
719 [NL80211_ATTR_TXQ_LIMIT
] = { .type
= NLA_U32
},
720 [NL80211_ATTR_TXQ_MEMORY_LIMIT
] = { .type
= NLA_U32
},
721 [NL80211_ATTR_TXQ_QUANTUM
] = { .type
= NLA_U32
},
722 [NL80211_ATTR_HE_CAPABILITY
] =
723 NLA_POLICY_RANGE(NLA_BINARY
,
724 NL80211_HE_MIN_CAPABILITY_LEN
,
725 NL80211_HE_MAX_CAPABILITY_LEN
),
726 [NL80211_ATTR_FTM_RESPONDER
] =
727 NLA_POLICY_NESTED(nl80211_ftm_responder_policy
),
728 [NL80211_ATTR_TIMEOUT
] = NLA_POLICY_MIN(NLA_U32
, 1),
729 [NL80211_ATTR_PEER_MEASUREMENTS
] =
730 NLA_POLICY_NESTED(nl80211_pmsr_attr_policy
),
731 [NL80211_ATTR_AIRTIME_WEIGHT
] = NLA_POLICY_MIN(NLA_U16
, 1),
732 [NL80211_ATTR_SAE_PASSWORD
] = { .type
= NLA_BINARY
,
733 .len
= SAE_PASSWORD_MAX_LEN
},
734 [NL80211_ATTR_TWT_RESPONDER
] = { .type
= NLA_FLAG
},
735 [NL80211_ATTR_HE_OBSS_PD
] = NLA_POLICY_NESTED(he_obss_pd_policy
),
736 [NL80211_ATTR_VLAN_ID
] = NLA_POLICY_RANGE(NLA_U16
, 1, VLAN_N_VID
- 2),
737 [NL80211_ATTR_HE_BSS_COLOR
] = NLA_POLICY_NESTED(he_bss_color_policy
),
738 [NL80211_ATTR_TID_CONFIG
] =
739 NLA_POLICY_NESTED_ARRAY(nl80211_tid_config_attr_policy
),
740 [NL80211_ATTR_CONTROL_PORT_NO_PREAUTH
] = { .type
= NLA_FLAG
},
741 [NL80211_ATTR_PMK_LIFETIME
] = NLA_POLICY_MIN(NLA_U32
, 1),
742 [NL80211_ATTR_PMK_REAUTH_THRESHOLD
] = NLA_POLICY_RANGE(NLA_U8
, 1, 100),
743 [NL80211_ATTR_RECEIVE_MULTICAST
] = { .type
= NLA_FLAG
},
744 [NL80211_ATTR_WIPHY_FREQ_OFFSET
] = NLA_POLICY_RANGE(NLA_U32
, 0, 999),
745 [NL80211_ATTR_SCAN_FREQ_KHZ
] = { .type
= NLA_NESTED
},
746 [NL80211_ATTR_HE_6GHZ_CAPABILITY
] =
747 NLA_POLICY_EXACT_LEN(sizeof(struct ieee80211_he_6ghz_capa
)),
748 [NL80211_ATTR_FILS_DISCOVERY
] =
749 NLA_POLICY_NESTED(nl80211_fils_discovery_policy
),
750 [NL80211_ATTR_UNSOL_BCAST_PROBE_RESP
] =
751 NLA_POLICY_NESTED(nl80211_unsol_bcast_probe_resp_policy
),
752 [NL80211_ATTR_S1G_CAPABILITY
] =
753 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN
),
754 [NL80211_ATTR_S1G_CAPABILITY_MASK
] =
755 NLA_POLICY_EXACT_LEN(IEEE80211_S1G_CAPABILITY_LEN
),
756 [NL80211_ATTR_SAE_PWE
] =
757 NLA_POLICY_RANGE(NLA_U8
, NL80211_SAE_PWE_HUNT_AND_PECK
,
758 NL80211_SAE_PWE_BOTH
),
759 [NL80211_ATTR_RECONNECT_REQUESTED
] = { .type
= NLA_REJECT
},
760 [NL80211_ATTR_SAR_SPEC
] = NLA_POLICY_NESTED(sar_policy
),
761 [NL80211_ATTR_DISABLE_HE
] = { .type
= NLA_FLAG
},
764 /* policy for the key attributes */
765 static const struct nla_policy nl80211_key_policy
[NL80211_KEY_MAX
+ 1] = {
766 [NL80211_KEY_DATA
] = { .type
= NLA_BINARY
, .len
= WLAN_MAX_KEY_LEN
},
767 [NL80211_KEY_IDX
] = { .type
= NLA_U8
},
768 [NL80211_KEY_CIPHER
] = { .type
= NLA_U32
},
769 [NL80211_KEY_SEQ
] = { .type
= NLA_BINARY
, .len
= 16 },
770 [NL80211_KEY_DEFAULT
] = { .type
= NLA_FLAG
},
771 [NL80211_KEY_DEFAULT_MGMT
] = { .type
= NLA_FLAG
},
772 [NL80211_KEY_TYPE
] = NLA_POLICY_MAX(NLA_U32
, NUM_NL80211_KEYTYPES
- 1),
773 [NL80211_KEY_DEFAULT_TYPES
] = { .type
= NLA_NESTED
},
774 [NL80211_KEY_MODE
] = NLA_POLICY_RANGE(NLA_U8
, 0, NL80211_KEY_SET_TX
),
777 /* policy for the key default flags */
778 static const struct nla_policy
779 nl80211_key_default_policy
[NUM_NL80211_KEY_DEFAULT_TYPES
] = {
780 [NL80211_KEY_DEFAULT_TYPE_UNICAST
] = { .type
= NLA_FLAG
},
781 [NL80211_KEY_DEFAULT_TYPE_MULTICAST
] = { .type
= NLA_FLAG
},
785 /* policy for WoWLAN attributes */
786 static const struct nla_policy
787 nl80211_wowlan_policy
[NUM_NL80211_WOWLAN_TRIG
] = {
788 [NL80211_WOWLAN_TRIG_ANY
] = { .type
= NLA_FLAG
},
789 [NL80211_WOWLAN_TRIG_DISCONNECT
] = { .type
= NLA_FLAG
},
790 [NL80211_WOWLAN_TRIG_MAGIC_PKT
] = { .type
= NLA_FLAG
},
791 [NL80211_WOWLAN_TRIG_PKT_PATTERN
] = { .type
= NLA_NESTED
},
792 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
] = { .type
= NLA_FLAG
},
793 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
] = { .type
= NLA_FLAG
},
794 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
] = { .type
= NLA_FLAG
},
795 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE
] = { .type
= NLA_FLAG
},
796 [NL80211_WOWLAN_TRIG_TCP_CONNECTION
] = { .type
= NLA_NESTED
},
797 [NL80211_WOWLAN_TRIG_NET_DETECT
] = { .type
= NLA_NESTED
},
800 static const struct nla_policy
801 nl80211_wowlan_tcp_policy
[NUM_NL80211_WOWLAN_TCP
] = {
802 [NL80211_WOWLAN_TCP_SRC_IPV4
] = { .type
= NLA_U32
},
803 [NL80211_WOWLAN_TCP_DST_IPV4
] = { .type
= NLA_U32
},
804 [NL80211_WOWLAN_TCP_DST_MAC
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
805 [NL80211_WOWLAN_TCP_SRC_PORT
] = { .type
= NLA_U16
},
806 [NL80211_WOWLAN_TCP_DST_PORT
] = { .type
= NLA_U16
},
807 [NL80211_WOWLAN_TCP_DATA_PAYLOAD
] = NLA_POLICY_MIN_LEN(1),
808 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
] = {
809 .len
= sizeof(struct nl80211_wowlan_tcp_data_seq
)
811 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
] = {
812 .len
= sizeof(struct nl80211_wowlan_tcp_data_token
)
814 [NL80211_WOWLAN_TCP_DATA_INTERVAL
] = { .type
= NLA_U32
},
815 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD
] = NLA_POLICY_MIN_LEN(1),
816 [NL80211_WOWLAN_TCP_WAKE_MASK
] = NLA_POLICY_MIN_LEN(1),
818 #endif /* CONFIG_PM */
820 /* policy for coalesce rule attributes */
821 static const struct nla_policy
822 nl80211_coalesce_policy
[NUM_NL80211_ATTR_COALESCE_RULE
] = {
823 [NL80211_ATTR_COALESCE_RULE_DELAY
] = { .type
= NLA_U32
},
824 [NL80211_ATTR_COALESCE_RULE_CONDITION
] =
825 NLA_POLICY_RANGE(NLA_U32
,
826 NL80211_COALESCE_CONDITION_MATCH
,
827 NL80211_COALESCE_CONDITION_NO_MATCH
),
828 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
] = { .type
= NLA_NESTED
},
831 /* policy for GTK rekey offload attributes */
832 static const struct nla_policy
833 nl80211_rekey_policy
[NUM_NL80211_REKEY_DATA
] = {
834 [NL80211_REKEY_DATA_KEK
] = {
836 .len
= NL80211_KEK_EXT_LEN
838 [NL80211_REKEY_DATA_KCK
] = {
840 .len
= NL80211_KCK_EXT_LEN
842 [NL80211_REKEY_DATA_REPLAY_CTR
] = NLA_POLICY_EXACT_LEN(NL80211_REPLAY_CTR_LEN
),
843 [NL80211_REKEY_DATA_AKM
] = { .type
= NLA_U32
},
846 static const struct nla_policy
847 nl80211_match_band_rssi_policy
[NUM_NL80211_BANDS
] = {
848 [NL80211_BAND_2GHZ
] = { .type
= NLA_S32
},
849 [NL80211_BAND_5GHZ
] = { .type
= NLA_S32
},
850 [NL80211_BAND_6GHZ
] = { .type
= NLA_S32
},
851 [NL80211_BAND_60GHZ
] = { .type
= NLA_S32
},
854 static const struct nla_policy
855 nl80211_match_policy
[NL80211_SCHED_SCAN_MATCH_ATTR_MAX
+ 1] = {
856 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID
] = { .type
= NLA_BINARY
,
857 .len
= IEEE80211_MAX_SSID_LEN
},
858 [NL80211_SCHED_SCAN_MATCH_ATTR_BSSID
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
859 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
] = { .type
= NLA_U32
},
860 [NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI
] =
861 NLA_POLICY_NESTED(nl80211_match_band_rssi_policy
),
864 static const struct nla_policy
865 nl80211_plan_policy
[NL80211_SCHED_SCAN_PLAN_MAX
+ 1] = {
866 [NL80211_SCHED_SCAN_PLAN_INTERVAL
] = { .type
= NLA_U32
},
867 [NL80211_SCHED_SCAN_PLAN_ITERATIONS
] = { .type
= NLA_U32
},
870 static const struct nla_policy
871 nl80211_bss_select_policy
[NL80211_BSS_SELECT_ATTR_MAX
+ 1] = {
872 [NL80211_BSS_SELECT_ATTR_RSSI
] = { .type
= NLA_FLAG
},
873 [NL80211_BSS_SELECT_ATTR_BAND_PREF
] = { .type
= NLA_U32
},
874 [NL80211_BSS_SELECT_ATTR_RSSI_ADJUST
] = {
875 .len
= sizeof(struct nl80211_bss_select_rssi_adjust
)
879 /* policy for NAN function attributes */
880 static const struct nla_policy
881 nl80211_nan_func_policy
[NL80211_NAN_FUNC_ATTR_MAX
+ 1] = {
882 [NL80211_NAN_FUNC_TYPE
] =
883 NLA_POLICY_MAX(NLA_U8
, NL80211_NAN_FUNC_MAX_TYPE
),
884 [NL80211_NAN_FUNC_SERVICE_ID
] = {
885 .len
= NL80211_NAN_FUNC_SERVICE_ID_LEN
},
886 [NL80211_NAN_FUNC_PUBLISH_TYPE
] = { .type
= NLA_U8
},
887 [NL80211_NAN_FUNC_PUBLISH_BCAST
] = { .type
= NLA_FLAG
},
888 [NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE
] = { .type
= NLA_FLAG
},
889 [NL80211_NAN_FUNC_FOLLOW_UP_ID
] = { .type
= NLA_U8
},
890 [NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID
] = { .type
= NLA_U8
},
891 [NL80211_NAN_FUNC_FOLLOW_UP_DEST
] = NLA_POLICY_EXACT_LEN_WARN(ETH_ALEN
),
892 [NL80211_NAN_FUNC_CLOSE_RANGE
] = { .type
= NLA_FLAG
},
893 [NL80211_NAN_FUNC_TTL
] = { .type
= NLA_U32
},
894 [NL80211_NAN_FUNC_SERVICE_INFO
] = { .type
= NLA_BINARY
,
895 .len
= NL80211_NAN_FUNC_SERVICE_SPEC_INFO_MAX_LEN
},
896 [NL80211_NAN_FUNC_SRF
] = { .type
= NLA_NESTED
},
897 [NL80211_NAN_FUNC_RX_MATCH_FILTER
] = { .type
= NLA_NESTED
},
898 [NL80211_NAN_FUNC_TX_MATCH_FILTER
] = { .type
= NLA_NESTED
},
899 [NL80211_NAN_FUNC_INSTANCE_ID
] = { .type
= NLA_U8
},
900 [NL80211_NAN_FUNC_TERM_REASON
] = { .type
= NLA_U8
},
903 /* policy for Service Response Filter attributes */
904 static const struct nla_policy
905 nl80211_nan_srf_policy
[NL80211_NAN_SRF_ATTR_MAX
+ 1] = {
906 [NL80211_NAN_SRF_INCLUDE
] = { .type
= NLA_FLAG
},
907 [NL80211_NAN_SRF_BF
] = { .type
= NLA_BINARY
,
908 .len
= NL80211_NAN_FUNC_SRF_MAX_LEN
},
909 [NL80211_NAN_SRF_BF_IDX
] = { .type
= NLA_U8
},
910 [NL80211_NAN_SRF_MAC_ADDRS
] = { .type
= NLA_NESTED
},
913 /* policy for packet pattern attributes */
914 static const struct nla_policy
915 nl80211_packet_pattern_policy
[MAX_NL80211_PKTPAT
+ 1] = {
916 [NL80211_PKTPAT_MASK
] = { .type
= NLA_BINARY
, },
917 [NL80211_PKTPAT_PATTERN
] = { .type
= NLA_BINARY
, },
918 [NL80211_PKTPAT_OFFSET
] = { .type
= NLA_U32
},
921 int nl80211_prepare_wdev_dump(struct netlink_callback
*cb
,
922 struct cfg80211_registered_device
**rdev
,
923 struct wireless_dev
**wdev
)
928 struct nlattr
**attrbuf
;
930 attrbuf
= kcalloc(NUM_NL80211_ATTR
, sizeof(*attrbuf
),
935 err
= nlmsg_parse_deprecated(cb
->nlh
,
936 GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
937 attrbuf
, nl80211_fam
.maxattr
,
938 nl80211_policy
, NULL
);
945 *wdev
= __cfg80211_wdev_from_attrs(NULL
, sock_net(cb
->skb
->sk
),
950 return PTR_ERR(*wdev
);
952 *rdev
= wiphy_to_rdev((*wdev
)->wiphy
);
953 mutex_lock(&(*rdev
)->wiphy
.mtx
);
955 /* 0 is the first index - add 1 to parse only once */
956 cb
->args
[0] = (*rdev
)->wiphy_idx
+ 1;
957 cb
->args
[1] = (*wdev
)->identifier
;
959 /* subtract the 1 again here */
961 struct wireless_dev
*tmp
;
964 wiphy
= wiphy_idx_to_wiphy(cb
->args
[0] - 1);
969 *rdev
= wiphy_to_rdev(wiphy
);
972 list_for_each_entry(tmp
, &(*rdev
)->wiphy
.wdev_list
, list
) {
973 if (tmp
->identifier
== cb
->args
[1]) {
983 mutex_lock(&(*rdev
)->wiphy
.mtx
);
990 /* message building helper */
991 void *nl80211hdr_put(struct sk_buff
*skb
, u32 portid
, u32 seq
,
994 /* since there is no private header just add the generic one */
995 return genlmsg_put(skb
, portid
, seq
, &nl80211_fam
, flags
, cmd
);
998 static int nl80211_msg_put_wmm_rules(struct sk_buff
*msg
,
999 const struct ieee80211_reg_rule
*rule
)
1002 struct nlattr
*nl_wmm_rules
=
1003 nla_nest_start_noflag(msg
, NL80211_FREQUENCY_ATTR_WMM
);
1006 goto nla_put_failure
;
1008 for (j
= 0; j
< IEEE80211_NUM_ACS
; j
++) {
1009 struct nlattr
*nl_wmm_rule
= nla_nest_start_noflag(msg
, j
);
1012 goto nla_put_failure
;
1014 if (nla_put_u16(msg
, NL80211_WMMR_CW_MIN
,
1015 rule
->wmm_rule
.client
[j
].cw_min
) ||
1016 nla_put_u16(msg
, NL80211_WMMR_CW_MAX
,
1017 rule
->wmm_rule
.client
[j
].cw_max
) ||
1018 nla_put_u8(msg
, NL80211_WMMR_AIFSN
,
1019 rule
->wmm_rule
.client
[j
].aifsn
) ||
1020 nla_put_u16(msg
, NL80211_WMMR_TXOP
,
1021 rule
->wmm_rule
.client
[j
].cot
))
1022 goto nla_put_failure
;
1024 nla_nest_end(msg
, nl_wmm_rule
);
1026 nla_nest_end(msg
, nl_wmm_rules
);
1034 static int nl80211_msg_put_channel(struct sk_buff
*msg
, struct wiphy
*wiphy
,
1035 struct ieee80211_channel
*chan
,
1038 /* Some channels must be completely excluded from the
1039 * list to protect old user-space tools from breaking
1041 if (!large
&& chan
->flags
&
1042 (IEEE80211_CHAN_NO_10MHZ
| IEEE80211_CHAN_NO_20MHZ
))
1044 if (!large
&& chan
->freq_offset
)
1047 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_FREQ
,
1049 goto nla_put_failure
;
1051 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_OFFSET
, chan
->freq_offset
))
1052 goto nla_put_failure
;
1054 if ((chan
->flags
& IEEE80211_CHAN_DISABLED
) &&
1055 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_DISABLED
))
1056 goto nla_put_failure
;
1057 if (chan
->flags
& IEEE80211_CHAN_NO_IR
) {
1058 if (nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_IR
))
1059 goto nla_put_failure
;
1060 if (nla_put_flag(msg
, __NL80211_FREQUENCY_ATTR_NO_IBSS
))
1061 goto nla_put_failure
;
1063 if (chan
->flags
& IEEE80211_CHAN_RADAR
) {
1064 if (nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_RADAR
))
1065 goto nla_put_failure
;
1069 time
= elapsed_jiffies_msecs(chan
->dfs_state_entered
);
1071 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_DFS_STATE
,
1073 goto nla_put_failure
;
1074 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_DFS_TIME
,
1076 goto nla_put_failure
;
1077 if (nla_put_u32(msg
,
1078 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME
,
1080 goto nla_put_failure
;
1085 if ((chan
->flags
& IEEE80211_CHAN_NO_HT40MINUS
) &&
1086 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS
))
1087 goto nla_put_failure
;
1088 if ((chan
->flags
& IEEE80211_CHAN_NO_HT40PLUS
) &&
1089 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS
))
1090 goto nla_put_failure
;
1091 if ((chan
->flags
& IEEE80211_CHAN_NO_80MHZ
) &&
1092 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_80MHZ
))
1093 goto nla_put_failure
;
1094 if ((chan
->flags
& IEEE80211_CHAN_NO_160MHZ
) &&
1095 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_160MHZ
))
1096 goto nla_put_failure
;
1097 if ((chan
->flags
& IEEE80211_CHAN_INDOOR_ONLY
) &&
1098 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_INDOOR_ONLY
))
1099 goto nla_put_failure
;
1100 if ((chan
->flags
& IEEE80211_CHAN_IR_CONCURRENT
) &&
1101 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_IR_CONCURRENT
))
1102 goto nla_put_failure
;
1103 if ((chan
->flags
& IEEE80211_CHAN_NO_20MHZ
) &&
1104 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_20MHZ
))
1105 goto nla_put_failure
;
1106 if ((chan
->flags
& IEEE80211_CHAN_NO_10MHZ
) &&
1107 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_10MHZ
))
1108 goto nla_put_failure
;
1109 if ((chan
->flags
& IEEE80211_CHAN_NO_HE
) &&
1110 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_HE
))
1111 goto nla_put_failure
;
1112 if ((chan
->flags
& IEEE80211_CHAN_1MHZ
) &&
1113 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_1MHZ
))
1114 goto nla_put_failure
;
1115 if ((chan
->flags
& IEEE80211_CHAN_2MHZ
) &&
1116 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_2MHZ
))
1117 goto nla_put_failure
;
1118 if ((chan
->flags
& IEEE80211_CHAN_4MHZ
) &&
1119 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_4MHZ
))
1120 goto nla_put_failure
;
1121 if ((chan
->flags
& IEEE80211_CHAN_8MHZ
) &&
1122 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_8MHZ
))
1123 goto nla_put_failure
;
1124 if ((chan
->flags
& IEEE80211_CHAN_16MHZ
) &&
1125 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_16MHZ
))
1126 goto nla_put_failure
;
1129 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_MAX_TX_POWER
,
1130 DBM_TO_MBM(chan
->max_power
)))
1131 goto nla_put_failure
;
1134 const struct ieee80211_reg_rule
*rule
=
1135 freq_reg_info(wiphy
, MHZ_TO_KHZ(chan
->center_freq
));
1137 if (!IS_ERR_OR_NULL(rule
) && rule
->has_wmm
) {
1138 if (nl80211_msg_put_wmm_rules(msg
, rule
))
1139 goto nla_put_failure
;
1149 static bool nl80211_put_txq_stats(struct sk_buff
*msg
,
1150 struct cfg80211_txq_stats
*txqstats
,
1153 struct nlattr
*txqattr
;
1155 #define PUT_TXQVAL_U32(attr, memb) do { \
1156 if (txqstats->filled & BIT(NL80211_TXQ_STATS_ ## attr) && \
1157 nla_put_u32(msg, NL80211_TXQ_STATS_ ## attr, txqstats->memb)) \
1161 txqattr
= nla_nest_start_noflag(msg
, attrtype
);
1165 PUT_TXQVAL_U32(BACKLOG_BYTES
, backlog_bytes
);
1166 PUT_TXQVAL_U32(BACKLOG_PACKETS
, backlog_packets
);
1167 PUT_TXQVAL_U32(FLOWS
, flows
);
1168 PUT_TXQVAL_U32(DROPS
, drops
);
1169 PUT_TXQVAL_U32(ECN_MARKS
, ecn_marks
);
1170 PUT_TXQVAL_U32(OVERLIMIT
, overlimit
);
1171 PUT_TXQVAL_U32(OVERMEMORY
, overmemory
);
1172 PUT_TXQVAL_U32(COLLISIONS
, collisions
);
1173 PUT_TXQVAL_U32(TX_BYTES
, tx_bytes
);
1174 PUT_TXQVAL_U32(TX_PACKETS
, tx_packets
);
1175 PUT_TXQVAL_U32(MAX_FLOWS
, max_flows
);
1176 nla_nest_end(msg
, txqattr
);
1178 #undef PUT_TXQVAL_U32
1182 /* netlink command implementations */
1185 struct key_params p
;
1188 bool def
, defmgmt
, defbeacon
;
1189 bool def_uni
, def_multi
;
1192 static int nl80211_parse_key_new(struct genl_info
*info
, struct nlattr
*key
,
1193 struct key_parse
*k
)
1195 struct nlattr
*tb
[NL80211_KEY_MAX
+ 1];
1196 int err
= nla_parse_nested_deprecated(tb
, NL80211_KEY_MAX
, key
,
1202 k
->def
= !!tb
[NL80211_KEY_DEFAULT
];
1203 k
->defmgmt
= !!tb
[NL80211_KEY_DEFAULT_MGMT
];
1204 k
->defbeacon
= !!tb
[NL80211_KEY_DEFAULT_BEACON
];
1208 k
->def_multi
= true;
1210 if (k
->defmgmt
|| k
->defbeacon
)
1211 k
->def_multi
= true;
1213 if (tb
[NL80211_KEY_IDX
])
1214 k
->idx
= nla_get_u8(tb
[NL80211_KEY_IDX
]);
1216 if (tb
[NL80211_KEY_DATA
]) {
1217 k
->p
.key
= nla_data(tb
[NL80211_KEY_DATA
]);
1218 k
->p
.key_len
= nla_len(tb
[NL80211_KEY_DATA
]);
1221 if (tb
[NL80211_KEY_SEQ
]) {
1222 k
->p
.seq
= nla_data(tb
[NL80211_KEY_SEQ
]);
1223 k
->p
.seq_len
= nla_len(tb
[NL80211_KEY_SEQ
]);
1226 if (tb
[NL80211_KEY_CIPHER
])
1227 k
->p
.cipher
= nla_get_u32(tb
[NL80211_KEY_CIPHER
]);
1229 if (tb
[NL80211_KEY_TYPE
])
1230 k
->type
= nla_get_u32(tb
[NL80211_KEY_TYPE
]);
1232 if (tb
[NL80211_KEY_DEFAULT_TYPES
]) {
1233 struct nlattr
*kdt
[NUM_NL80211_KEY_DEFAULT_TYPES
];
1235 err
= nla_parse_nested_deprecated(kdt
,
1236 NUM_NL80211_KEY_DEFAULT_TYPES
- 1,
1237 tb
[NL80211_KEY_DEFAULT_TYPES
],
1238 nl80211_key_default_policy
,
1243 k
->def_uni
= kdt
[NL80211_KEY_DEFAULT_TYPE_UNICAST
];
1244 k
->def_multi
= kdt
[NL80211_KEY_DEFAULT_TYPE_MULTICAST
];
1247 if (tb
[NL80211_KEY_MODE
])
1248 k
->p
.mode
= nla_get_u8(tb
[NL80211_KEY_MODE
]);
1253 static int nl80211_parse_key_old(struct genl_info
*info
, struct key_parse
*k
)
1255 if (info
->attrs
[NL80211_ATTR_KEY_DATA
]) {
1256 k
->p
.key
= nla_data(info
->attrs
[NL80211_ATTR_KEY_DATA
]);
1257 k
->p
.key_len
= nla_len(info
->attrs
[NL80211_ATTR_KEY_DATA
]);
1260 if (info
->attrs
[NL80211_ATTR_KEY_SEQ
]) {
1261 k
->p
.seq
= nla_data(info
->attrs
[NL80211_ATTR_KEY_SEQ
]);
1262 k
->p
.seq_len
= nla_len(info
->attrs
[NL80211_ATTR_KEY_SEQ
]);
1265 if (info
->attrs
[NL80211_ATTR_KEY_IDX
])
1266 k
->idx
= nla_get_u8(info
->attrs
[NL80211_ATTR_KEY_IDX
]);
1268 if (info
->attrs
[NL80211_ATTR_KEY_CIPHER
])
1269 k
->p
.cipher
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_CIPHER
]);
1271 k
->def
= !!info
->attrs
[NL80211_ATTR_KEY_DEFAULT
];
1272 k
->defmgmt
= !!info
->attrs
[NL80211_ATTR_KEY_DEFAULT_MGMT
];
1276 k
->def_multi
= true;
1279 k
->def_multi
= true;
1281 if (info
->attrs
[NL80211_ATTR_KEY_TYPE
])
1282 k
->type
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_TYPE
]);
1284 if (info
->attrs
[NL80211_ATTR_KEY_DEFAULT_TYPES
]) {
1285 struct nlattr
*kdt
[NUM_NL80211_KEY_DEFAULT_TYPES
];
1286 int err
= nla_parse_nested_deprecated(kdt
,
1287 NUM_NL80211_KEY_DEFAULT_TYPES
- 1,
1288 info
->attrs
[NL80211_ATTR_KEY_DEFAULT_TYPES
],
1289 nl80211_key_default_policy
,
1294 k
->def_uni
= kdt
[NL80211_KEY_DEFAULT_TYPE_UNICAST
];
1295 k
->def_multi
= kdt
[NL80211_KEY_DEFAULT_TYPE_MULTICAST
];
1301 static int nl80211_parse_key(struct genl_info
*info
, struct key_parse
*k
)
1305 memset(k
, 0, sizeof(*k
));
1309 if (info
->attrs
[NL80211_ATTR_KEY
])
1310 err
= nl80211_parse_key_new(info
, info
->attrs
[NL80211_ATTR_KEY
], k
);
1312 err
= nl80211_parse_key_old(info
, k
);
1317 if ((k
->def
? 1 : 0) + (k
->defmgmt
? 1 : 0) +
1318 (k
->defbeacon
? 1 : 0) > 1) {
1319 GENL_SET_ERR_MSG(info
,
1320 "key with multiple default flags is invalid");
1324 if (k
->defmgmt
|| k
->defbeacon
) {
1325 if (k
->def_uni
|| !k
->def_multi
) {
1326 GENL_SET_ERR_MSG(info
,
1327 "defmgmt/defbeacon key must be mcast");
1334 if (k
->idx
< 4 || k
->idx
> 5) {
1335 GENL_SET_ERR_MSG(info
,
1336 "defmgmt key idx not 4 or 5");
1339 } else if (k
->defbeacon
) {
1340 if (k
->idx
< 6 || k
->idx
> 7) {
1341 GENL_SET_ERR_MSG(info
,
1342 "defbeacon key idx not 6 or 7");
1345 } else if (k
->def
) {
1346 if (k
->idx
< 0 || k
->idx
> 3) {
1347 GENL_SET_ERR_MSG(info
, "def key idx not 0-3");
1351 if (k
->idx
< 0 || k
->idx
> 7) {
1352 GENL_SET_ERR_MSG(info
, "key idx not 0-7");
1361 static struct cfg80211_cached_keys
*
1362 nl80211_parse_connkeys(struct cfg80211_registered_device
*rdev
,
1363 struct genl_info
*info
, bool *no_ht
)
1365 struct nlattr
*keys
= info
->attrs
[NL80211_ATTR_KEYS
];
1366 struct key_parse parse
;
1368 struct cfg80211_cached_keys
*result
;
1369 int rem
, err
, def
= 0;
1370 bool have_key
= false;
1372 nla_for_each_nested(key
, keys
, rem
) {
1380 result
= kzalloc(sizeof(*result
), GFP_KERNEL
);
1382 return ERR_PTR(-ENOMEM
);
1386 nla_for_each_nested(key
, keys
, rem
) {
1387 memset(&parse
, 0, sizeof(parse
));
1390 err
= nl80211_parse_key_new(info
, key
, &parse
);
1396 if (parse
.idx
< 0 || parse
.idx
> 3) {
1397 GENL_SET_ERR_MSG(info
, "key index out of range [0-3]");
1402 GENL_SET_ERR_MSG(info
,
1403 "only one key can be default");
1407 result
->def
= parse
.idx
;
1408 if (!parse
.def_uni
|| !parse
.def_multi
)
1410 } else if (parse
.defmgmt
)
1412 err
= cfg80211_validate_key_settings(rdev
, &parse
.p
,
1413 parse
.idx
, false, NULL
);
1416 if (parse
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP40
&&
1417 parse
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP104
) {
1418 GENL_SET_ERR_MSG(info
, "connect key must be WEP");
1422 result
->params
[parse
.idx
].cipher
= parse
.p
.cipher
;
1423 result
->params
[parse
.idx
].key_len
= parse
.p
.key_len
;
1424 result
->params
[parse
.idx
].key
= result
->data
[parse
.idx
];
1425 memcpy(result
->data
[parse
.idx
], parse
.p
.key
, parse
.p
.key_len
);
1427 /* must be WEP key if we got here */
1432 if (result
->def
< 0) {
1434 GENL_SET_ERR_MSG(info
, "need a default/TX key");
1441 return ERR_PTR(err
);
1444 static int nl80211_key_allowed(struct wireless_dev
*wdev
)
1446 ASSERT_WDEV_LOCK(wdev
);
1448 switch (wdev
->iftype
) {
1449 case NL80211_IFTYPE_AP
:
1450 case NL80211_IFTYPE_AP_VLAN
:
1451 case NL80211_IFTYPE_P2P_GO
:
1452 case NL80211_IFTYPE_MESH_POINT
:
1454 case NL80211_IFTYPE_ADHOC
:
1455 case NL80211_IFTYPE_STATION
:
1456 case NL80211_IFTYPE_P2P_CLIENT
:
1457 if (!wdev
->current_bss
)
1460 case NL80211_IFTYPE_UNSPECIFIED
:
1461 case NL80211_IFTYPE_OCB
:
1462 case NL80211_IFTYPE_MONITOR
:
1463 case NL80211_IFTYPE_NAN
:
1464 case NL80211_IFTYPE_P2P_DEVICE
:
1465 case NL80211_IFTYPE_WDS
:
1466 case NUM_NL80211_IFTYPES
:
1473 static struct ieee80211_channel
*nl80211_get_valid_chan(struct wiphy
*wiphy
,
1476 struct ieee80211_channel
*chan
;
1478 chan
= ieee80211_get_channel_khz(wiphy
, freq
);
1479 if (!chan
|| chan
->flags
& IEEE80211_CHAN_DISABLED
)
1484 static int nl80211_put_iftypes(struct sk_buff
*msg
, u32 attr
, u16 ifmodes
)
1486 struct nlattr
*nl_modes
= nla_nest_start_noflag(msg
, attr
);
1490 goto nla_put_failure
;
1494 if ((ifmodes
& 1) && nla_put_flag(msg
, i
))
1495 goto nla_put_failure
;
1500 nla_nest_end(msg
, nl_modes
);
1507 static int nl80211_put_iface_combinations(struct wiphy
*wiphy
,
1508 struct sk_buff
*msg
,
1511 struct nlattr
*nl_combis
;
1514 nl_combis
= nla_nest_start_noflag(msg
,
1515 NL80211_ATTR_INTERFACE_COMBINATIONS
);
1517 goto nla_put_failure
;
1519 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
1520 const struct ieee80211_iface_combination
*c
;
1521 struct nlattr
*nl_combi
, *nl_limits
;
1523 c
= &wiphy
->iface_combinations
[i
];
1525 nl_combi
= nla_nest_start_noflag(msg
, i
+ 1);
1527 goto nla_put_failure
;
1529 nl_limits
= nla_nest_start_noflag(msg
,
1530 NL80211_IFACE_COMB_LIMITS
);
1532 goto nla_put_failure
;
1534 for (j
= 0; j
< c
->n_limits
; j
++) {
1535 struct nlattr
*nl_limit
;
1537 nl_limit
= nla_nest_start_noflag(msg
, j
+ 1);
1539 goto nla_put_failure
;
1540 if (nla_put_u32(msg
, NL80211_IFACE_LIMIT_MAX
,
1542 goto nla_put_failure
;
1543 if (nl80211_put_iftypes(msg
, NL80211_IFACE_LIMIT_TYPES
,
1544 c
->limits
[j
].types
))
1545 goto nla_put_failure
;
1546 nla_nest_end(msg
, nl_limit
);
1549 nla_nest_end(msg
, nl_limits
);
1551 if (c
->beacon_int_infra_match
&&
1552 nla_put_flag(msg
, NL80211_IFACE_COMB_STA_AP_BI_MATCH
))
1553 goto nla_put_failure
;
1554 if (nla_put_u32(msg
, NL80211_IFACE_COMB_NUM_CHANNELS
,
1555 c
->num_different_channels
) ||
1556 nla_put_u32(msg
, NL80211_IFACE_COMB_MAXNUM
,
1558 goto nla_put_failure
;
1560 (nla_put_u32(msg
, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS
,
1561 c
->radar_detect_widths
) ||
1562 nla_put_u32(msg
, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS
,
1563 c
->radar_detect_regions
)))
1564 goto nla_put_failure
;
1565 if (c
->beacon_int_min_gcd
&&
1566 nla_put_u32(msg
, NL80211_IFACE_COMB_BI_MIN_GCD
,
1567 c
->beacon_int_min_gcd
))
1568 goto nla_put_failure
;
1570 nla_nest_end(msg
, nl_combi
);
1573 nla_nest_end(msg
, nl_combis
);
1581 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device
*rdev
,
1582 struct sk_buff
*msg
)
1584 const struct wiphy_wowlan_tcp_support
*tcp
= rdev
->wiphy
.wowlan
->tcp
;
1585 struct nlattr
*nl_tcp
;
1590 nl_tcp
= nla_nest_start_noflag(msg
,
1591 NL80211_WOWLAN_TRIG_TCP_CONNECTION
);
1595 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD
,
1596 tcp
->data_payload_max
))
1599 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD
,
1600 tcp
->data_payload_max
))
1603 if (tcp
->seq
&& nla_put_flag(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
))
1606 if (tcp
->tok
&& nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
,
1607 sizeof(*tcp
->tok
), tcp
->tok
))
1610 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_INTERVAL
,
1611 tcp
->data_interval_max
))
1614 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_WAKE_PAYLOAD
,
1615 tcp
->wake_payload_max
))
1618 nla_nest_end(msg
, nl_tcp
);
1622 static int nl80211_send_wowlan(struct sk_buff
*msg
,
1623 struct cfg80211_registered_device
*rdev
,
1626 struct nlattr
*nl_wowlan
;
1628 if (!rdev
->wiphy
.wowlan
)
1631 nl_wowlan
= nla_nest_start_noflag(msg
,
1632 NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED
);
1636 if (((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_ANY
) &&
1637 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_ANY
)) ||
1638 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_DISCONNECT
) &&
1639 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
)) ||
1640 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_MAGIC_PKT
) &&
1641 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
)) ||
1642 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
) &&
1643 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED
)) ||
1644 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
1645 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
)) ||
1646 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_EAP_IDENTITY_REQ
) &&
1647 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
)) ||
1648 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_4WAY_HANDSHAKE
) &&
1649 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
)) ||
1650 ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_RFKILL_RELEASE
) &&
1651 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
)))
1654 if (rdev
->wiphy
.wowlan
->n_patterns
) {
1655 struct nl80211_pattern_support pat
= {
1656 .max_patterns
= rdev
->wiphy
.wowlan
->n_patterns
,
1657 .min_pattern_len
= rdev
->wiphy
.wowlan
->pattern_min_len
,
1658 .max_pattern_len
= rdev
->wiphy
.wowlan
->pattern_max_len
,
1659 .max_pkt_offset
= rdev
->wiphy
.wowlan
->max_pkt_offset
,
1662 if (nla_put(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
,
1667 if ((rdev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_NET_DETECT
) &&
1668 nla_put_u32(msg
, NL80211_WOWLAN_TRIG_NET_DETECT
,
1669 rdev
->wiphy
.wowlan
->max_nd_match_sets
))
1672 if (large
&& nl80211_send_wowlan_tcp_caps(rdev
, msg
))
1675 nla_nest_end(msg
, nl_wowlan
);
1681 static int nl80211_send_coalesce(struct sk_buff
*msg
,
1682 struct cfg80211_registered_device
*rdev
)
1684 struct nl80211_coalesce_rule_support rule
;
1686 if (!rdev
->wiphy
.coalesce
)
1689 rule
.max_rules
= rdev
->wiphy
.coalesce
->n_rules
;
1690 rule
.max_delay
= rdev
->wiphy
.coalesce
->max_delay
;
1691 rule
.pat
.max_patterns
= rdev
->wiphy
.coalesce
->n_patterns
;
1692 rule
.pat
.min_pattern_len
= rdev
->wiphy
.coalesce
->pattern_min_len
;
1693 rule
.pat
.max_pattern_len
= rdev
->wiphy
.coalesce
->pattern_max_len
;
1694 rule
.pat
.max_pkt_offset
= rdev
->wiphy
.coalesce
->max_pkt_offset
;
1696 if (nla_put(msg
, NL80211_ATTR_COALESCE_RULE
, sizeof(rule
), &rule
))
1703 nl80211_send_iftype_data(struct sk_buff
*msg
,
1704 const struct ieee80211_supported_band
*sband
,
1705 const struct ieee80211_sband_iftype_data
*iftdata
)
1707 const struct ieee80211_sta_he_cap
*he_cap
= &iftdata
->he_cap
;
1709 if (nl80211_put_iftypes(msg
, NL80211_BAND_IFTYPE_ATTR_IFTYPES
,
1710 iftdata
->types_mask
))
1713 if (he_cap
->has_he
) {
1714 if (nla_put(msg
, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MAC
,
1715 sizeof(he_cap
->he_cap_elem
.mac_cap_info
),
1716 he_cap
->he_cap_elem
.mac_cap_info
) ||
1717 nla_put(msg
, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PHY
,
1718 sizeof(he_cap
->he_cap_elem
.phy_cap_info
),
1719 he_cap
->he_cap_elem
.phy_cap_info
) ||
1720 nla_put(msg
, NL80211_BAND_IFTYPE_ATTR_HE_CAP_MCS_SET
,
1721 sizeof(he_cap
->he_mcs_nss_supp
),
1722 &he_cap
->he_mcs_nss_supp
) ||
1723 nla_put(msg
, NL80211_BAND_IFTYPE_ATTR_HE_CAP_PPE
,
1724 sizeof(he_cap
->ppe_thres
), he_cap
->ppe_thres
))
1728 if (sband
->band
== NL80211_BAND_6GHZ
&&
1729 nla_put(msg
, NL80211_BAND_IFTYPE_ATTR_HE_6GHZ_CAPA
,
1730 sizeof(iftdata
->he_6ghz_capa
),
1731 &iftdata
->he_6ghz_capa
))
1737 static int nl80211_send_band_rateinfo(struct sk_buff
*msg
,
1738 struct ieee80211_supported_band
*sband
,
1741 struct nlattr
*nl_rates
, *nl_rate
;
1742 struct ieee80211_rate
*rate
;
1746 if (sband
->ht_cap
.ht_supported
&&
1747 (nla_put(msg
, NL80211_BAND_ATTR_HT_MCS_SET
,
1748 sizeof(sband
->ht_cap
.mcs
),
1749 &sband
->ht_cap
.mcs
) ||
1750 nla_put_u16(msg
, NL80211_BAND_ATTR_HT_CAPA
,
1751 sband
->ht_cap
.cap
) ||
1752 nla_put_u8(msg
, NL80211_BAND_ATTR_HT_AMPDU_FACTOR
,
1753 sband
->ht_cap
.ampdu_factor
) ||
1754 nla_put_u8(msg
, NL80211_BAND_ATTR_HT_AMPDU_DENSITY
,
1755 sband
->ht_cap
.ampdu_density
)))
1759 if (sband
->vht_cap
.vht_supported
&&
1760 (nla_put(msg
, NL80211_BAND_ATTR_VHT_MCS_SET
,
1761 sizeof(sband
->vht_cap
.vht_mcs
),
1762 &sband
->vht_cap
.vht_mcs
) ||
1763 nla_put_u32(msg
, NL80211_BAND_ATTR_VHT_CAPA
,
1764 sband
->vht_cap
.cap
)))
1767 if (large
&& sband
->n_iftype_data
) {
1768 struct nlattr
*nl_iftype_data
=
1769 nla_nest_start_noflag(msg
,
1770 NL80211_BAND_ATTR_IFTYPE_DATA
);
1773 if (!nl_iftype_data
)
1776 for (i
= 0; i
< sband
->n_iftype_data
; i
++) {
1777 struct nlattr
*iftdata
;
1779 iftdata
= nla_nest_start_noflag(msg
, i
+ 1);
1783 err
= nl80211_send_iftype_data(msg
, sband
,
1784 &sband
->iftype_data
[i
]);
1788 nla_nest_end(msg
, iftdata
);
1791 nla_nest_end(msg
, nl_iftype_data
);
1795 if (large
&& sband
->edmg_cap
.channels
&&
1796 (nla_put_u8(msg
, NL80211_BAND_ATTR_EDMG_CHANNELS
,
1797 sband
->edmg_cap
.channels
) ||
1798 nla_put_u8(msg
, NL80211_BAND_ATTR_EDMG_BW_CONFIG
,
1799 sband
->edmg_cap
.bw_config
)))
1804 nl_rates
= nla_nest_start_noflag(msg
, NL80211_BAND_ATTR_RATES
);
1808 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
1809 nl_rate
= nla_nest_start_noflag(msg
, i
);
1813 rate
= &sband
->bitrates
[i
];
1814 if (nla_put_u32(msg
, NL80211_BITRATE_ATTR_RATE
,
1817 if ((rate
->flags
& IEEE80211_RATE_SHORT_PREAMBLE
) &&
1819 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE
))
1822 nla_nest_end(msg
, nl_rate
);
1825 nla_nest_end(msg
, nl_rates
);
1831 nl80211_send_mgmt_stypes(struct sk_buff
*msg
,
1832 const struct ieee80211_txrx_stypes
*mgmt_stypes
)
1835 struct nlattr
*nl_ftypes
, *nl_ifs
;
1836 enum nl80211_iftype ift
;
1842 nl_ifs
= nla_nest_start_noflag(msg
, NL80211_ATTR_TX_FRAME_TYPES
);
1846 for (ift
= 0; ift
< NUM_NL80211_IFTYPES
; ift
++) {
1847 nl_ftypes
= nla_nest_start_noflag(msg
, ift
);
1851 stypes
= mgmt_stypes
[ift
].tx
;
1854 nla_put_u16(msg
, NL80211_ATTR_FRAME_TYPE
,
1855 (i
<< 4) | IEEE80211_FTYPE_MGMT
))
1860 nla_nest_end(msg
, nl_ftypes
);
1863 nla_nest_end(msg
, nl_ifs
);
1865 nl_ifs
= nla_nest_start_noflag(msg
, NL80211_ATTR_RX_FRAME_TYPES
);
1869 for (ift
= 0; ift
< NUM_NL80211_IFTYPES
; ift
++) {
1870 nl_ftypes
= nla_nest_start_noflag(msg
, ift
);
1874 stypes
= mgmt_stypes
[ift
].rx
;
1877 nla_put_u16(msg
, NL80211_ATTR_FRAME_TYPE
,
1878 (i
<< 4) | IEEE80211_FTYPE_MGMT
))
1883 nla_nest_end(msg
, nl_ftypes
);
1885 nla_nest_end(msg
, nl_ifs
);
1890 #define CMD(op, n) \
1892 if (rdev->ops->op) { \
1894 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1895 goto nla_put_failure; \
1899 static int nl80211_add_commands_unsplit(struct cfg80211_registered_device
*rdev
,
1900 struct sk_buff
*msg
)
1905 * do *NOT* add anything into this function, new things need to be
1906 * advertised only to new versions of userspace that can deal with
1907 * the split (and they can't possibly care about new features...
1909 CMD(add_virtual_intf
, NEW_INTERFACE
);
1910 CMD(change_virtual_intf
, SET_INTERFACE
);
1911 CMD(add_key
, NEW_KEY
);
1912 CMD(start_ap
, START_AP
);
1913 CMD(add_station
, NEW_STATION
);
1914 CMD(add_mpath
, NEW_MPATH
);
1915 CMD(update_mesh_config
, SET_MESH_CONFIG
);
1916 CMD(change_bss
, SET_BSS
);
1917 CMD(auth
, AUTHENTICATE
);
1918 CMD(assoc
, ASSOCIATE
);
1919 CMD(deauth
, DEAUTHENTICATE
);
1920 CMD(disassoc
, DISASSOCIATE
);
1921 CMD(join_ibss
, JOIN_IBSS
);
1922 CMD(join_mesh
, JOIN_MESH
);
1923 CMD(set_pmksa
, SET_PMKSA
);
1924 CMD(del_pmksa
, DEL_PMKSA
);
1925 CMD(flush_pmksa
, FLUSH_PMKSA
);
1926 if (rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
)
1927 CMD(remain_on_channel
, REMAIN_ON_CHANNEL
);
1928 CMD(set_bitrate_mask
, SET_TX_BITRATE_MASK
);
1929 CMD(mgmt_tx
, FRAME
);
1930 CMD(mgmt_tx_cancel_wait
, FRAME_WAIT_CANCEL
);
1931 if (rdev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
) {
1933 if (nla_put_u32(msg
, i
, NL80211_CMD_SET_WIPHY_NETNS
))
1934 goto nla_put_failure
;
1936 if (rdev
->ops
->set_monitor_channel
|| rdev
->ops
->start_ap
||
1937 rdev
->ops
->join_mesh
) {
1939 if (nla_put_u32(msg
, i
, NL80211_CMD_SET_CHANNEL
))
1940 goto nla_put_failure
;
1942 if (rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) {
1943 CMD(tdls_mgmt
, TDLS_MGMT
);
1944 CMD(tdls_oper
, TDLS_OPER
);
1946 if (rdev
->wiphy
.max_sched_scan_reqs
)
1947 CMD(sched_scan_start
, START_SCHED_SCAN
);
1948 CMD(probe_client
, PROBE_CLIENT
);
1949 CMD(set_noack_map
, SET_NOACK_MAP
);
1950 if (rdev
->wiphy
.flags
& WIPHY_FLAG_REPORTS_OBSS
) {
1952 if (nla_put_u32(msg
, i
, NL80211_CMD_REGISTER_BEACONS
))
1953 goto nla_put_failure
;
1955 CMD(start_p2p_device
, START_P2P_DEVICE
);
1956 CMD(set_mcast_rate
, SET_MCAST_RATE
);
1957 #ifdef CONFIG_NL80211_TESTMODE
1958 CMD(testmode_cmd
, TESTMODE
);
1961 if (rdev
->ops
->connect
|| rdev
->ops
->auth
) {
1963 if (nla_put_u32(msg
, i
, NL80211_CMD_CONNECT
))
1964 goto nla_put_failure
;
1967 if (rdev
->ops
->disconnect
|| rdev
->ops
->deauth
) {
1969 if (nla_put_u32(msg
, i
, NL80211_CMD_DISCONNECT
))
1970 goto nla_put_failure
;
1979 nl80211_send_pmsr_ftm_capa(const struct cfg80211_pmsr_capabilities
*cap
,
1980 struct sk_buff
*msg
)
1984 if (!cap
->ftm
.supported
)
1987 ftm
= nla_nest_start_noflag(msg
, NL80211_PMSR_TYPE_FTM
);
1991 if (cap
->ftm
.asap
&& nla_put_flag(msg
, NL80211_PMSR_FTM_CAPA_ATTR_ASAP
))
1993 if (cap
->ftm
.non_asap
&&
1994 nla_put_flag(msg
, NL80211_PMSR_FTM_CAPA_ATTR_NON_ASAP
))
1996 if (cap
->ftm
.request_lci
&&
1997 nla_put_flag(msg
, NL80211_PMSR_FTM_CAPA_ATTR_REQ_LCI
))
1999 if (cap
->ftm
.request_civicloc
&&
2000 nla_put_flag(msg
, NL80211_PMSR_FTM_CAPA_ATTR_REQ_CIVICLOC
))
2002 if (nla_put_u32(msg
, NL80211_PMSR_FTM_CAPA_ATTR_PREAMBLES
,
2003 cap
->ftm
.preambles
))
2005 if (nla_put_u32(msg
, NL80211_PMSR_FTM_CAPA_ATTR_BANDWIDTHS
,
2006 cap
->ftm
.bandwidths
))
2008 if (cap
->ftm
.max_bursts_exponent
>= 0 &&
2009 nla_put_u32(msg
, NL80211_PMSR_FTM_CAPA_ATTR_MAX_BURSTS_EXPONENT
,
2010 cap
->ftm
.max_bursts_exponent
))
2012 if (cap
->ftm
.max_ftms_per_burst
&&
2013 nla_put_u32(msg
, NL80211_PMSR_FTM_CAPA_ATTR_MAX_FTMS_PER_BURST
,
2014 cap
->ftm
.max_ftms_per_burst
))
2016 if (cap
->ftm
.trigger_based
&&
2017 nla_put_flag(msg
, NL80211_PMSR_FTM_CAPA_ATTR_TRIGGER_BASED
))
2019 if (cap
->ftm
.non_trigger_based
&&
2020 nla_put_flag(msg
, NL80211_PMSR_FTM_CAPA_ATTR_NON_TRIGGER_BASED
))
2023 nla_nest_end(msg
, ftm
);
2027 static int nl80211_send_pmsr_capa(struct cfg80211_registered_device
*rdev
,
2028 struct sk_buff
*msg
)
2030 const struct cfg80211_pmsr_capabilities
*cap
= rdev
->wiphy
.pmsr_capa
;
2031 struct nlattr
*pmsr
, *caps
;
2037 * we don't need to clean up anything here since the caller
2038 * will genlmsg_cancel() if we fail
2041 pmsr
= nla_nest_start_noflag(msg
, NL80211_ATTR_PEER_MEASUREMENTS
);
2045 if (nla_put_u32(msg
, NL80211_PMSR_ATTR_MAX_PEERS
, cap
->max_peers
))
2048 if (cap
->report_ap_tsf
&&
2049 nla_put_flag(msg
, NL80211_PMSR_ATTR_REPORT_AP_TSF
))
2052 if (cap
->randomize_mac_addr
&&
2053 nla_put_flag(msg
, NL80211_PMSR_ATTR_RANDOMIZE_MAC_ADDR
))
2056 caps
= nla_nest_start_noflag(msg
, NL80211_PMSR_ATTR_TYPE_CAPA
);
2060 if (nl80211_send_pmsr_ftm_capa(cap
, msg
))
2063 nla_nest_end(msg
, caps
);
2064 nla_nest_end(msg
, pmsr
);
2070 nl80211_put_iftype_akm_suites(struct cfg80211_registered_device
*rdev
,
2071 struct sk_buff
*msg
)
2074 struct nlattr
*nested
, *nested_akms
;
2075 const struct wiphy_iftype_akm_suites
*iftype_akms
;
2077 if (!rdev
->wiphy
.num_iftype_akm_suites
||
2078 !rdev
->wiphy
.iftype_akm_suites
)
2081 nested
= nla_nest_start(msg
, NL80211_ATTR_IFTYPE_AKM_SUITES
);
2085 for (i
= 0; i
< rdev
->wiphy
.num_iftype_akm_suites
; i
++) {
2086 nested_akms
= nla_nest_start(msg
, i
+ 1);
2090 iftype_akms
= &rdev
->wiphy
.iftype_akm_suites
[i
];
2092 if (nl80211_put_iftypes(msg
, NL80211_IFTYPE_AKM_ATTR_IFTYPES
,
2093 iftype_akms
->iftypes_mask
))
2096 if (nla_put(msg
, NL80211_IFTYPE_AKM_ATTR_SUITES
,
2097 sizeof(u32
) * iftype_akms
->n_akm_suites
,
2098 iftype_akms
->akm_suites
)) {
2101 nla_nest_end(msg
, nested_akms
);
2104 nla_nest_end(msg
, nested
);
2110 nl80211_put_tid_config_support(struct cfg80211_registered_device
*rdev
,
2111 struct sk_buff
*msg
)
2113 struct nlattr
*supp
;
2115 if (!rdev
->wiphy
.tid_config_support
.vif
&&
2116 !rdev
->wiphy
.tid_config_support
.peer
)
2119 supp
= nla_nest_start(msg
, NL80211_ATTR_TID_CONFIG
);
2123 if (rdev
->wiphy
.tid_config_support
.vif
&&
2124 nla_put_u64_64bit(msg
, NL80211_TID_CONFIG_ATTR_VIF_SUPP
,
2125 rdev
->wiphy
.tid_config_support
.vif
,
2126 NL80211_TID_CONFIG_ATTR_PAD
))
2129 if (rdev
->wiphy
.tid_config_support
.peer
&&
2130 nla_put_u64_64bit(msg
, NL80211_TID_CONFIG_ATTR_PEER_SUPP
,
2131 rdev
->wiphy
.tid_config_support
.peer
,
2132 NL80211_TID_CONFIG_ATTR_PAD
))
2135 /* for now we just use the same value ... makes more sense */
2136 if (nla_put_u8(msg
, NL80211_TID_CONFIG_ATTR_RETRY_SHORT
,
2137 rdev
->wiphy
.tid_config_support
.max_retry
))
2139 if (nla_put_u8(msg
, NL80211_TID_CONFIG_ATTR_RETRY_LONG
,
2140 rdev
->wiphy
.tid_config_support
.max_retry
))
2143 nla_nest_end(msg
, supp
);
2147 nla_nest_cancel(msg
, supp
);
2152 nl80211_put_sar_specs(struct cfg80211_registered_device
*rdev
,
2153 struct sk_buff
*msg
)
2155 struct nlattr
*sar_capa
, *specs
, *sub_freq_range
;
2159 if (!rdev
->wiphy
.sar_capa
)
2162 num_freq_ranges
= rdev
->wiphy
.sar_capa
->num_freq_ranges
;
2164 sar_capa
= nla_nest_start(msg
, NL80211_ATTR_SAR_SPEC
);
2168 if (nla_put_u32(msg
, NL80211_SAR_ATTR_TYPE
, rdev
->wiphy
.sar_capa
->type
))
2171 specs
= nla_nest_start(msg
, NL80211_SAR_ATTR_SPECS
);
2175 /* report supported freq_ranges */
2176 for (i
= 0; i
< num_freq_ranges
; i
++) {
2177 sub_freq_range
= nla_nest_start(msg
, i
+ 1);
2178 if (!sub_freq_range
)
2181 if (nla_put_u32(msg
, NL80211_SAR_ATTR_SPECS_START_FREQ
,
2182 rdev
->wiphy
.sar_capa
->freq_ranges
[i
].start_freq
))
2185 if (nla_put_u32(msg
, NL80211_SAR_ATTR_SPECS_END_FREQ
,
2186 rdev
->wiphy
.sar_capa
->freq_ranges
[i
].end_freq
))
2189 nla_nest_end(msg
, sub_freq_range
);
2192 nla_nest_end(msg
, specs
);
2193 nla_nest_end(msg
, sar_capa
);
2197 nla_nest_cancel(msg
, sar_capa
);
2201 struct nl80211_dump_wiphy_state
{
2204 long split_start
, band_start
, chan_start
, capa_start
;
2208 static int nl80211_send_wiphy(struct cfg80211_registered_device
*rdev
,
2209 enum nl80211_commands cmd
,
2210 struct sk_buff
*msg
, u32 portid
, u32 seq
,
2211 int flags
, struct nl80211_dump_wiphy_state
*state
)
2214 struct nlattr
*nl_bands
, *nl_band
;
2215 struct nlattr
*nl_freqs
, *nl_freq
;
2216 struct nlattr
*nl_cmds
;
2217 enum nl80211_band band
;
2218 struct ieee80211_channel
*chan
;
2220 const struct ieee80211_txrx_stypes
*mgmt_stypes
=
2221 rdev
->wiphy
.mgmt_stypes
;
2224 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, cmd
);
2228 if (WARN_ON(!state
))
2231 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
2232 nla_put_string(msg
, NL80211_ATTR_WIPHY_NAME
,
2233 wiphy_name(&rdev
->wiphy
)) ||
2234 nla_put_u32(msg
, NL80211_ATTR_GENERATION
,
2235 cfg80211_rdev_list_generation
))
2236 goto nla_put_failure
;
2238 if (cmd
!= NL80211_CMD_NEW_WIPHY
)
2241 switch (state
->split_start
) {
2243 if (nla_put_u8(msg
, NL80211_ATTR_WIPHY_RETRY_SHORT
,
2244 rdev
->wiphy
.retry_short
) ||
2245 nla_put_u8(msg
, NL80211_ATTR_WIPHY_RETRY_LONG
,
2246 rdev
->wiphy
.retry_long
) ||
2247 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FRAG_THRESHOLD
,
2248 rdev
->wiphy
.frag_threshold
) ||
2249 nla_put_u32(msg
, NL80211_ATTR_WIPHY_RTS_THRESHOLD
,
2250 rdev
->wiphy
.rts_threshold
) ||
2251 nla_put_u8(msg
, NL80211_ATTR_WIPHY_COVERAGE_CLASS
,
2252 rdev
->wiphy
.coverage_class
) ||
2253 nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_SCAN_SSIDS
,
2254 rdev
->wiphy
.max_scan_ssids
) ||
2255 nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS
,
2256 rdev
->wiphy
.max_sched_scan_ssids
) ||
2257 nla_put_u16(msg
, NL80211_ATTR_MAX_SCAN_IE_LEN
,
2258 rdev
->wiphy
.max_scan_ie_len
) ||
2259 nla_put_u16(msg
, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN
,
2260 rdev
->wiphy
.max_sched_scan_ie_len
) ||
2261 nla_put_u8(msg
, NL80211_ATTR_MAX_MATCH_SETS
,
2262 rdev
->wiphy
.max_match_sets
))
2263 goto nla_put_failure
;
2265 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
) &&
2266 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_IBSS_RSN
))
2267 goto nla_put_failure
;
2268 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_MESH_AUTH
) &&
2269 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_MESH_AUTH
))
2270 goto nla_put_failure
;
2271 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_AP_UAPSD
) &&
2272 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_AP_UAPSD
))
2273 goto nla_put_failure
;
2274 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
) &&
2275 nla_put_flag(msg
, NL80211_ATTR_ROAM_SUPPORT
))
2276 goto nla_put_failure
;
2277 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) &&
2278 nla_put_flag(msg
, NL80211_ATTR_TDLS_SUPPORT
))
2279 goto nla_put_failure
;
2280 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_TDLS_EXTERNAL_SETUP
) &&
2281 nla_put_flag(msg
, NL80211_ATTR_TDLS_EXTERNAL_SETUP
))
2282 goto nla_put_failure
;
2283 state
->split_start
++;
2288 if (nla_put(msg
, NL80211_ATTR_CIPHER_SUITES
,
2289 sizeof(u32
) * rdev
->wiphy
.n_cipher_suites
,
2290 rdev
->wiphy
.cipher_suites
))
2291 goto nla_put_failure
;
2293 if (nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_PMKIDS
,
2294 rdev
->wiphy
.max_num_pmkids
))
2295 goto nla_put_failure
;
2297 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_CONTROL_PORT_PROTOCOL
) &&
2298 nla_put_flag(msg
, NL80211_ATTR_CONTROL_PORT_ETHERTYPE
))
2299 goto nla_put_failure
;
2301 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX
,
2302 rdev
->wiphy
.available_antennas_tx
) ||
2303 nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX
,
2304 rdev
->wiphy
.available_antennas_rx
))
2305 goto nla_put_failure
;
2307 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
) &&
2308 nla_put_u32(msg
, NL80211_ATTR_PROBE_RESP_OFFLOAD
,
2309 rdev
->wiphy
.probe_resp_offload
))
2310 goto nla_put_failure
;
2312 if ((rdev
->wiphy
.available_antennas_tx
||
2313 rdev
->wiphy
.available_antennas_rx
) &&
2314 rdev
->ops
->get_antenna
) {
2315 u32 tx_ant
= 0, rx_ant
= 0;
2318 res
= rdev_get_antenna(rdev
, &tx_ant
, &rx_ant
);
2320 if (nla_put_u32(msg
,
2321 NL80211_ATTR_WIPHY_ANTENNA_TX
,
2324 NL80211_ATTR_WIPHY_ANTENNA_RX
,
2326 goto nla_put_failure
;
2330 state
->split_start
++;
2335 if (nl80211_put_iftypes(msg
, NL80211_ATTR_SUPPORTED_IFTYPES
,
2336 rdev
->wiphy
.interface_modes
))
2337 goto nla_put_failure
;
2338 state
->split_start
++;
2343 nl_bands
= nla_nest_start_noflag(msg
,
2344 NL80211_ATTR_WIPHY_BANDS
);
2346 goto nla_put_failure
;
2348 for (band
= state
->band_start
;
2349 band
< NUM_NL80211_BANDS
; band
++) {
2350 struct ieee80211_supported_band
*sband
;
2352 /* omit higher bands for ancient software */
2353 if (band
> NL80211_BAND_5GHZ
&& !state
->split
)
2356 sband
= rdev
->wiphy
.bands
[band
];
2361 nl_band
= nla_nest_start_noflag(msg
, band
);
2363 goto nla_put_failure
;
2365 switch (state
->chan_start
) {
2367 if (nl80211_send_band_rateinfo(msg
, sband
,
2369 goto nla_put_failure
;
2370 state
->chan_start
++;
2375 /* add frequencies */
2376 nl_freqs
= nla_nest_start_noflag(msg
,
2377 NL80211_BAND_ATTR_FREQS
);
2379 goto nla_put_failure
;
2381 for (i
= state
->chan_start
- 1;
2382 i
< sband
->n_channels
;
2384 nl_freq
= nla_nest_start_noflag(msg
,
2387 goto nla_put_failure
;
2389 chan
= &sband
->channels
[i
];
2391 if (nl80211_msg_put_channel(
2392 msg
, &rdev
->wiphy
, chan
,
2394 goto nla_put_failure
;
2396 nla_nest_end(msg
, nl_freq
);
2400 if (i
< sband
->n_channels
)
2401 state
->chan_start
= i
+ 2;
2403 state
->chan_start
= 0;
2404 nla_nest_end(msg
, nl_freqs
);
2407 nla_nest_end(msg
, nl_band
);
2410 /* start again here */
2411 if (state
->chan_start
)
2416 nla_nest_end(msg
, nl_bands
);
2418 if (band
< NUM_NL80211_BANDS
)
2419 state
->band_start
= band
+ 1;
2421 state
->band_start
= 0;
2423 /* if bands & channels are done, continue outside */
2424 if (state
->band_start
== 0 && state
->chan_start
== 0)
2425 state
->split_start
++;
2430 nl_cmds
= nla_nest_start_noflag(msg
,
2431 NL80211_ATTR_SUPPORTED_COMMANDS
);
2433 goto nla_put_failure
;
2435 i
= nl80211_add_commands_unsplit(rdev
, msg
);
2437 goto nla_put_failure
;
2439 CMD(crit_proto_start
, CRIT_PROTOCOL_START
);
2440 CMD(crit_proto_stop
, CRIT_PROTOCOL_STOP
);
2441 if (rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_CHANNEL_SWITCH
)
2442 CMD(channel_switch
, CHANNEL_SWITCH
);
2443 CMD(set_qos_map
, SET_QOS_MAP
);
2444 if (rdev
->wiphy
.features
&
2445 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION
)
2446 CMD(add_tx_ts
, ADD_TX_TS
);
2447 CMD(set_multicast_to_unicast
, SET_MULTICAST_TO_UNICAST
);
2448 CMD(update_connect_params
, UPDATE_CONNECT_PARAMS
);
2449 CMD(update_ft_ies
, UPDATE_FT_IES
);
2450 if (rdev
->wiphy
.sar_capa
)
2451 CMD(set_sar_specs
, SET_SAR_SPECS
);
2455 nla_nest_end(msg
, nl_cmds
);
2456 state
->split_start
++;
2461 if (rdev
->ops
->remain_on_channel
&&
2462 (rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
) &&
2464 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION
,
2465 rdev
->wiphy
.max_remain_on_channel_duration
))
2466 goto nla_put_failure
;
2468 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
) &&
2469 nla_put_flag(msg
, NL80211_ATTR_OFFCHANNEL_TX_OK
))
2470 goto nla_put_failure
;
2472 state
->split_start
++;
2478 if (nl80211_send_wowlan(msg
, rdev
, state
->split
))
2479 goto nla_put_failure
;
2480 state
->split_start
++;
2484 state
->split_start
++;
2488 if (nl80211_put_iftypes(msg
, NL80211_ATTR_SOFTWARE_IFTYPES
,
2489 rdev
->wiphy
.software_iftypes
))
2490 goto nla_put_failure
;
2492 if (nl80211_put_iface_combinations(&rdev
->wiphy
, msg
,
2494 goto nla_put_failure
;
2496 state
->split_start
++;
2501 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_HAVE_AP_SME
) &&
2502 nla_put_u32(msg
, NL80211_ATTR_DEVICE_AP_SME
,
2503 rdev
->wiphy
.ap_sme_capa
))
2504 goto nla_put_failure
;
2506 features
= rdev
->wiphy
.features
;
2508 * We can only add the per-channel limit information if the
2509 * dump is split, otherwise it makes it too big. Therefore
2510 * only advertise it in that case.
2513 features
|= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS
;
2514 if (nla_put_u32(msg
, NL80211_ATTR_FEATURE_FLAGS
, features
))
2515 goto nla_put_failure
;
2517 if (rdev
->wiphy
.ht_capa_mod_mask
&&
2518 nla_put(msg
, NL80211_ATTR_HT_CAPABILITY_MASK
,
2519 sizeof(*rdev
->wiphy
.ht_capa_mod_mask
),
2520 rdev
->wiphy
.ht_capa_mod_mask
))
2521 goto nla_put_failure
;
2523 if (rdev
->wiphy
.flags
& WIPHY_FLAG_HAVE_AP_SME
&&
2524 rdev
->wiphy
.max_acl_mac_addrs
&&
2525 nla_put_u32(msg
, NL80211_ATTR_MAC_ACL_MAX
,
2526 rdev
->wiphy
.max_acl_mac_addrs
))
2527 goto nla_put_failure
;
2530 * Any information below this point is only available to
2531 * applications that can deal with it being split. This
2532 * helps ensure that newly added capabilities don't break
2533 * older tools by overrunning their buffers.
2535 * We still increment split_start so that in the split
2536 * case we'll continue with more data in the next round,
2537 * but break unconditionally so unsplit data stops here.
2540 state
->split_start
++;
2542 state
->split_start
= 0;
2545 if (nl80211_send_mgmt_stypes(msg
, mgmt_stypes
))
2546 goto nla_put_failure
;
2548 if (nla_put_u32(msg
, NL80211_ATTR_MAX_NUM_SCHED_SCAN_PLANS
,
2549 rdev
->wiphy
.max_sched_scan_plans
) ||
2550 nla_put_u32(msg
, NL80211_ATTR_MAX_SCAN_PLAN_INTERVAL
,
2551 rdev
->wiphy
.max_sched_scan_plan_interval
) ||
2552 nla_put_u32(msg
, NL80211_ATTR_MAX_SCAN_PLAN_ITERATIONS
,
2553 rdev
->wiphy
.max_sched_scan_plan_iterations
))
2554 goto nla_put_failure
;
2556 if (rdev
->wiphy
.extended_capabilities
&&
2557 (nla_put(msg
, NL80211_ATTR_EXT_CAPA
,
2558 rdev
->wiphy
.extended_capabilities_len
,
2559 rdev
->wiphy
.extended_capabilities
) ||
2560 nla_put(msg
, NL80211_ATTR_EXT_CAPA_MASK
,
2561 rdev
->wiphy
.extended_capabilities_len
,
2562 rdev
->wiphy
.extended_capabilities_mask
)))
2563 goto nla_put_failure
;
2565 if (rdev
->wiphy
.vht_capa_mod_mask
&&
2566 nla_put(msg
, NL80211_ATTR_VHT_CAPABILITY_MASK
,
2567 sizeof(*rdev
->wiphy
.vht_capa_mod_mask
),
2568 rdev
->wiphy
.vht_capa_mod_mask
))
2569 goto nla_put_failure
;
2571 if (nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
,
2572 rdev
->wiphy
.perm_addr
))
2573 goto nla_put_failure
;
2575 if (!is_zero_ether_addr(rdev
->wiphy
.addr_mask
) &&
2576 nla_put(msg
, NL80211_ATTR_MAC_MASK
, ETH_ALEN
,
2577 rdev
->wiphy
.addr_mask
))
2578 goto nla_put_failure
;
2580 if (rdev
->wiphy
.n_addresses
> 1) {
2583 attr
= nla_nest_start(msg
, NL80211_ATTR_MAC_ADDRS
);
2585 goto nla_put_failure
;
2587 for (i
= 0; i
< rdev
->wiphy
.n_addresses
; i
++)
2588 if (nla_put(msg
, i
+ 1, ETH_ALEN
,
2589 rdev
->wiphy
.addresses
[i
].addr
))
2590 goto nla_put_failure
;
2592 nla_nest_end(msg
, attr
);
2595 state
->split_start
++;
2598 if (nl80211_send_coalesce(msg
, rdev
))
2599 goto nla_put_failure
;
2601 if ((rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_5_10_MHZ
) &&
2602 (nla_put_flag(msg
, NL80211_ATTR_SUPPORT_5_MHZ
) ||
2603 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_10_MHZ
)))
2604 goto nla_put_failure
;
2606 if (rdev
->wiphy
.max_ap_assoc_sta
&&
2607 nla_put_u32(msg
, NL80211_ATTR_MAX_AP_ASSOC_STA
,
2608 rdev
->wiphy
.max_ap_assoc_sta
))
2609 goto nla_put_failure
;
2611 state
->split_start
++;
2614 if (rdev
->wiphy
.n_vendor_commands
) {
2615 const struct nl80211_vendor_cmd_info
*info
;
2616 struct nlattr
*nested
;
2618 nested
= nla_nest_start_noflag(msg
,
2619 NL80211_ATTR_VENDOR_DATA
);
2621 goto nla_put_failure
;
2623 for (i
= 0; i
< rdev
->wiphy
.n_vendor_commands
; i
++) {
2624 info
= &rdev
->wiphy
.vendor_commands
[i
].info
;
2625 if (nla_put(msg
, i
+ 1, sizeof(*info
), info
))
2626 goto nla_put_failure
;
2628 nla_nest_end(msg
, nested
);
2631 if (rdev
->wiphy
.n_vendor_events
) {
2632 const struct nl80211_vendor_cmd_info
*info
;
2633 struct nlattr
*nested
;
2635 nested
= nla_nest_start_noflag(msg
,
2636 NL80211_ATTR_VENDOR_EVENTS
);
2638 goto nla_put_failure
;
2640 for (i
= 0; i
< rdev
->wiphy
.n_vendor_events
; i
++) {
2641 info
= &rdev
->wiphy
.vendor_events
[i
];
2642 if (nla_put(msg
, i
+ 1, sizeof(*info
), info
))
2643 goto nla_put_failure
;
2645 nla_nest_end(msg
, nested
);
2647 state
->split_start
++;
2650 if (rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_CHANNEL_SWITCH
&&
2651 nla_put_u8(msg
, NL80211_ATTR_MAX_CSA_COUNTERS
,
2652 rdev
->wiphy
.max_num_csa_counters
))
2653 goto nla_put_failure
;
2655 if (rdev
->wiphy
.regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
&&
2656 nla_put_flag(msg
, NL80211_ATTR_WIPHY_SELF_MANAGED_REG
))
2657 goto nla_put_failure
;
2659 if (rdev
->wiphy
.max_sched_scan_reqs
&&
2660 nla_put_u32(msg
, NL80211_ATTR_SCHED_SCAN_MAX_REQS
,
2661 rdev
->wiphy
.max_sched_scan_reqs
))
2662 goto nla_put_failure
;
2664 if (nla_put(msg
, NL80211_ATTR_EXT_FEATURES
,
2665 sizeof(rdev
->wiphy
.ext_features
),
2666 rdev
->wiphy
.ext_features
))
2667 goto nla_put_failure
;
2669 if (rdev
->wiphy
.bss_select_support
) {
2670 struct nlattr
*nested
;
2671 u32 bss_select_support
= rdev
->wiphy
.bss_select_support
;
2673 nested
= nla_nest_start_noflag(msg
,
2674 NL80211_ATTR_BSS_SELECT
);
2676 goto nla_put_failure
;
2679 while (bss_select_support
) {
2680 if ((bss_select_support
& 1) &&
2681 nla_put_flag(msg
, i
))
2682 goto nla_put_failure
;
2684 bss_select_support
>>= 1;
2686 nla_nest_end(msg
, nested
);
2689 state
->split_start
++;
2692 if (rdev
->wiphy
.num_iftype_ext_capab
&&
2693 rdev
->wiphy
.iftype_ext_capab
) {
2694 struct nlattr
*nested_ext_capab
, *nested
;
2696 nested
= nla_nest_start_noflag(msg
,
2697 NL80211_ATTR_IFTYPE_EXT_CAPA
);
2699 goto nla_put_failure
;
2701 for (i
= state
->capa_start
;
2702 i
< rdev
->wiphy
.num_iftype_ext_capab
; i
++) {
2703 const struct wiphy_iftype_ext_capab
*capab
;
2705 capab
= &rdev
->wiphy
.iftype_ext_capab
[i
];
2707 nested_ext_capab
= nla_nest_start_noflag(msg
,
2709 if (!nested_ext_capab
||
2710 nla_put_u32(msg
, NL80211_ATTR_IFTYPE
,
2712 nla_put(msg
, NL80211_ATTR_EXT_CAPA
,
2713 capab
->extended_capabilities_len
,
2714 capab
->extended_capabilities
) ||
2715 nla_put(msg
, NL80211_ATTR_EXT_CAPA_MASK
,
2716 capab
->extended_capabilities_len
,
2717 capab
->extended_capabilities_mask
))
2718 goto nla_put_failure
;
2720 nla_nest_end(msg
, nested_ext_capab
);
2724 nla_nest_end(msg
, nested
);
2725 if (i
< rdev
->wiphy
.num_iftype_ext_capab
) {
2726 state
->capa_start
= i
+ 1;
2731 if (nla_put_u32(msg
, NL80211_ATTR_BANDS
,
2732 rdev
->wiphy
.nan_supported_bands
))
2733 goto nla_put_failure
;
2735 if (wiphy_ext_feature_isset(&rdev
->wiphy
,
2736 NL80211_EXT_FEATURE_TXQS
)) {
2737 struct cfg80211_txq_stats txqstats
= {};
2740 res
= rdev_get_txq_stats(rdev
, NULL
, &txqstats
);
2742 !nl80211_put_txq_stats(msg
, &txqstats
,
2743 NL80211_ATTR_TXQ_STATS
))
2744 goto nla_put_failure
;
2746 if (nla_put_u32(msg
, NL80211_ATTR_TXQ_LIMIT
,
2747 rdev
->wiphy
.txq_limit
))
2748 goto nla_put_failure
;
2749 if (nla_put_u32(msg
, NL80211_ATTR_TXQ_MEMORY_LIMIT
,
2750 rdev
->wiphy
.txq_memory_limit
))
2751 goto nla_put_failure
;
2752 if (nla_put_u32(msg
, NL80211_ATTR_TXQ_QUANTUM
,
2753 rdev
->wiphy
.txq_quantum
))
2754 goto nla_put_failure
;
2757 state
->split_start
++;
2760 if (nl80211_send_pmsr_capa(rdev
, msg
))
2761 goto nla_put_failure
;
2763 state
->split_start
++;
2766 if (rdev
->wiphy
.akm_suites
&&
2767 nla_put(msg
, NL80211_ATTR_AKM_SUITES
,
2768 sizeof(u32
) * rdev
->wiphy
.n_akm_suites
,
2769 rdev
->wiphy
.akm_suites
))
2770 goto nla_put_failure
;
2772 if (nl80211_put_iftype_akm_suites(rdev
, msg
))
2773 goto nla_put_failure
;
2775 if (nl80211_put_tid_config_support(rdev
, msg
))
2776 goto nla_put_failure
;
2777 state
->split_start
++;
2780 if (nl80211_put_sar_specs(rdev
, msg
))
2781 goto nla_put_failure
;
2784 state
->split_start
= 0;
2788 genlmsg_end(msg
, hdr
);
2792 genlmsg_cancel(msg
, hdr
);
2796 static int nl80211_dump_wiphy_parse(struct sk_buff
*skb
,
2797 struct netlink_callback
*cb
,
2798 struct nl80211_dump_wiphy_state
*state
)
2800 struct nlattr
**tb
= kcalloc(NUM_NL80211_ATTR
, sizeof(*tb
), GFP_KERNEL
);
2806 ret
= nlmsg_parse_deprecated(cb
->nlh
,
2807 GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
2808 tb
, nl80211_fam
.maxattr
,
2809 nl80211_policy
, NULL
);
2810 /* ignore parse errors for backward compatibility */
2816 state
->split
= tb
[NL80211_ATTR_SPLIT_WIPHY_DUMP
];
2817 if (tb
[NL80211_ATTR_WIPHY
])
2818 state
->filter_wiphy
= nla_get_u32(tb
[NL80211_ATTR_WIPHY
]);
2819 if (tb
[NL80211_ATTR_WDEV
])
2820 state
->filter_wiphy
= nla_get_u64(tb
[NL80211_ATTR_WDEV
]) >> 32;
2821 if (tb
[NL80211_ATTR_IFINDEX
]) {
2822 struct net_device
*netdev
;
2823 struct cfg80211_registered_device
*rdev
;
2824 int ifidx
= nla_get_u32(tb
[NL80211_ATTR_IFINDEX
]);
2826 netdev
= __dev_get_by_index(sock_net(skb
->sk
), ifidx
);
2831 if (netdev
->ieee80211_ptr
) {
2832 rdev
= wiphy_to_rdev(
2833 netdev
->ieee80211_ptr
->wiphy
);
2834 state
->filter_wiphy
= rdev
->wiphy_idx
;
2844 static int nl80211_dump_wiphy(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2847 struct nl80211_dump_wiphy_state
*state
= (void *)cb
->args
[0];
2848 struct cfg80211_registered_device
*rdev
;
2852 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
2857 state
->filter_wiphy
= -1;
2858 ret
= nl80211_dump_wiphy_parse(skb
, cb
, state
);
2864 cb
->args
[0] = (long)state
;
2867 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
2868 if (!net_eq(wiphy_net(&rdev
->wiphy
), sock_net(skb
->sk
)))
2870 if (++idx
<= state
->start
)
2872 if (state
->filter_wiphy
!= -1 &&
2873 state
->filter_wiphy
!= rdev
->wiphy_idx
)
2875 /* attempt to fit multiple wiphy data chunks into the skb */
2877 ret
= nl80211_send_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
,
2879 NETLINK_CB(cb
->skb
).portid
,
2881 NLM_F_MULTI
, state
);
2884 * If sending the wiphy data didn't fit (ENOBUFS
2885 * or EMSGSIZE returned), this SKB is still
2886 * empty (so it's not too big because another
2887 * wiphy dataset is already in the skb) and
2888 * we've not tried to adjust the dump allocation
2889 * yet ... then adjust the alloc size to be
2890 * bigger, and return 1 but with the empty skb.
2891 * This results in an empty message being RX'ed
2892 * in userspace, but that is ignored.
2894 * We can then retry with the larger buffer.
2896 if ((ret
== -ENOBUFS
|| ret
== -EMSGSIZE
) &&
2897 !skb
->len
&& !state
->split
&&
2898 cb
->min_dump_alloc
< 4096) {
2899 cb
->min_dump_alloc
= 4096;
2900 state
->split_start
= 0;
2907 } while (state
->split_start
> 0);
2917 static int nl80211_dump_wiphy_done(struct netlink_callback
*cb
)
2919 kfree((void *)cb
->args
[0]);
2923 static int nl80211_get_wiphy(struct sk_buff
*skb
, struct genl_info
*info
)
2925 struct sk_buff
*msg
;
2926 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2927 struct nl80211_dump_wiphy_state state
= {};
2929 msg
= nlmsg_new(4096, GFP_KERNEL
);
2933 if (nl80211_send_wiphy(rdev
, NL80211_CMD_NEW_WIPHY
, msg
,
2934 info
->snd_portid
, info
->snd_seq
, 0,
2940 return genlmsg_reply(msg
, info
);
2943 static const struct nla_policy txq_params_policy
[NL80211_TXQ_ATTR_MAX
+ 1] = {
2944 [NL80211_TXQ_ATTR_QUEUE
] = { .type
= NLA_U8
},
2945 [NL80211_TXQ_ATTR_TXOP
] = { .type
= NLA_U16
},
2946 [NL80211_TXQ_ATTR_CWMIN
] = { .type
= NLA_U16
},
2947 [NL80211_TXQ_ATTR_CWMAX
] = { .type
= NLA_U16
},
2948 [NL80211_TXQ_ATTR_AIFS
] = { .type
= NLA_U8
},
2951 static int parse_txq_params(struct nlattr
*tb
[],
2952 struct ieee80211_txq_params
*txq_params
)
2956 if (!tb
[NL80211_TXQ_ATTR_AC
] || !tb
[NL80211_TXQ_ATTR_TXOP
] ||
2957 !tb
[NL80211_TXQ_ATTR_CWMIN
] || !tb
[NL80211_TXQ_ATTR_CWMAX
] ||
2958 !tb
[NL80211_TXQ_ATTR_AIFS
])
2961 ac
= nla_get_u8(tb
[NL80211_TXQ_ATTR_AC
]);
2962 txq_params
->txop
= nla_get_u16(tb
[NL80211_TXQ_ATTR_TXOP
]);
2963 txq_params
->cwmin
= nla_get_u16(tb
[NL80211_TXQ_ATTR_CWMIN
]);
2964 txq_params
->cwmax
= nla_get_u16(tb
[NL80211_TXQ_ATTR_CWMAX
]);
2965 txq_params
->aifs
= nla_get_u8(tb
[NL80211_TXQ_ATTR_AIFS
]);
2967 if (ac
>= NL80211_NUM_ACS
)
2969 txq_params
->ac
= array_index_nospec(ac
, NL80211_NUM_ACS
);
2973 static bool nl80211_can_set_dev_channel(struct wireless_dev
*wdev
)
2976 * You can only set the channel explicitly for some interfaces,
2977 * most have their channel managed via their respective
2978 * "establish a connection" command (connect, join, ...)
2980 * For AP/GO and mesh mode, the channel can be set with the
2981 * channel userspace API, but is only stored and passed to the
2982 * low-level driver when the AP starts or the mesh is joined.
2983 * This is for backward compatibility, userspace can also give
2984 * the channel in the start-ap or join-mesh commands instead.
2986 * Monitors are special as they are normally slaved to
2987 * whatever else is going on, so they have their own special
2988 * operation to set the monitor channel if possible.
2991 wdev
->iftype
== NL80211_IFTYPE_AP
||
2992 wdev
->iftype
== NL80211_IFTYPE_MESH_POINT
||
2993 wdev
->iftype
== NL80211_IFTYPE_MONITOR
||
2994 wdev
->iftype
== NL80211_IFTYPE_P2P_GO
;
2997 int nl80211_parse_chandef(struct cfg80211_registered_device
*rdev
,
2998 struct genl_info
*info
,
2999 struct cfg80211_chan_def
*chandef
)
3001 struct netlink_ext_ack
*extack
= info
->extack
;
3002 struct nlattr
**attrs
= info
->attrs
;
3005 if (!attrs
[NL80211_ATTR_WIPHY_FREQ
])
3008 control_freq
= MHZ_TO_KHZ(
3009 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
3010 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
])
3012 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
]);
3014 memset(chandef
, 0, sizeof(*chandef
));
3015 chandef
->chan
= ieee80211_get_channel_khz(&rdev
->wiphy
, control_freq
);
3016 chandef
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
3017 chandef
->center_freq1
= KHZ_TO_MHZ(control_freq
);
3018 chandef
->freq1_offset
= control_freq
% 1000;
3019 chandef
->center_freq2
= 0;
3021 /* Primary channel not allowed */
3022 if (!chandef
->chan
|| chandef
->chan
->flags
& IEEE80211_CHAN_DISABLED
) {
3023 NL_SET_ERR_MSG_ATTR(extack
, attrs
[NL80211_ATTR_WIPHY_FREQ
],
3024 "Channel is disabled");
3028 if (attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
3029 enum nl80211_channel_type chantype
;
3031 chantype
= nla_get_u32(attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
3034 case NL80211_CHAN_NO_HT
:
3035 case NL80211_CHAN_HT20
:
3036 case NL80211_CHAN_HT40PLUS
:
3037 case NL80211_CHAN_HT40MINUS
:
3038 cfg80211_chandef_create(chandef
, chandef
->chan
,
3040 /* user input for center_freq is incorrect */
3041 if (attrs
[NL80211_ATTR_CENTER_FREQ1
] &&
3042 chandef
->center_freq1
!= nla_get_u32(attrs
[NL80211_ATTR_CENTER_FREQ1
])) {
3043 NL_SET_ERR_MSG_ATTR(extack
,
3044 attrs
[NL80211_ATTR_CENTER_FREQ1
],
3045 "bad center frequency 1");
3048 /* center_freq2 must be zero */
3049 if (attrs
[NL80211_ATTR_CENTER_FREQ2
] &&
3050 nla_get_u32(attrs
[NL80211_ATTR_CENTER_FREQ2
])) {
3051 NL_SET_ERR_MSG_ATTR(extack
,
3052 attrs
[NL80211_ATTR_CENTER_FREQ2
],
3053 "center frequency 2 can't be used");
3058 NL_SET_ERR_MSG_ATTR(extack
,
3059 attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
],
3060 "invalid channel type");
3063 } else if (attrs
[NL80211_ATTR_CHANNEL_WIDTH
]) {
3065 nla_get_u32(attrs
[NL80211_ATTR_CHANNEL_WIDTH
]);
3066 if (attrs
[NL80211_ATTR_CENTER_FREQ1
]) {
3067 chandef
->center_freq1
=
3068 nla_get_u32(attrs
[NL80211_ATTR_CENTER_FREQ1
]);
3069 if (attrs
[NL80211_ATTR_CENTER_FREQ1_OFFSET
])
3070 chandef
->freq1_offset
= nla_get_u32(
3071 attrs
[NL80211_ATTR_CENTER_FREQ1_OFFSET
]);
3073 chandef
->freq1_offset
= 0;
3075 if (attrs
[NL80211_ATTR_CENTER_FREQ2
])
3076 chandef
->center_freq2
=
3077 nla_get_u32(attrs
[NL80211_ATTR_CENTER_FREQ2
]);
3080 if (info
->attrs
[NL80211_ATTR_WIPHY_EDMG_CHANNELS
]) {
3081 chandef
->edmg
.channels
=
3082 nla_get_u8(info
->attrs
[NL80211_ATTR_WIPHY_EDMG_CHANNELS
]);
3084 if (info
->attrs
[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG
])
3085 chandef
->edmg
.bw_config
=
3086 nla_get_u8(info
->attrs
[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG
]);
3088 chandef
->edmg
.bw_config
= 0;
3089 chandef
->edmg
.channels
= 0;
3092 if (!cfg80211_chandef_valid(chandef
)) {
3093 NL_SET_ERR_MSG(extack
, "invalid channel definition");
3097 if (!cfg80211_chandef_usable(&rdev
->wiphy
, chandef
,
3098 IEEE80211_CHAN_DISABLED
)) {
3099 NL_SET_ERR_MSG(extack
, "(extension) channel is disabled");
3103 if ((chandef
->width
== NL80211_CHAN_WIDTH_5
||
3104 chandef
->width
== NL80211_CHAN_WIDTH_10
) &&
3105 !(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_5_10_MHZ
)) {
3106 NL_SET_ERR_MSG(extack
, "5/10 MHz not supported");
3113 static int __nl80211_set_channel(struct cfg80211_registered_device
*rdev
,
3114 struct net_device
*dev
,
3115 struct genl_info
*info
)
3117 struct cfg80211_chan_def chandef
;
3119 enum nl80211_iftype iftype
= NL80211_IFTYPE_MONITOR
;
3120 struct wireless_dev
*wdev
= NULL
;
3123 wdev
= dev
->ieee80211_ptr
;
3124 if (!nl80211_can_set_dev_channel(wdev
))
3127 iftype
= wdev
->iftype
;
3129 result
= nl80211_parse_chandef(rdev
, info
, &chandef
);
3134 case NL80211_IFTYPE_AP
:
3135 case NL80211_IFTYPE_P2P_GO
:
3136 if (!cfg80211_reg_can_beacon_relax(&rdev
->wiphy
, &chandef
,
3141 if (wdev
->beacon_interval
) {
3142 if (!dev
|| !rdev
->ops
->set_ap_chanwidth
||
3143 !(rdev
->wiphy
.features
&
3144 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE
)) {
3149 /* Only allow dynamic channel width changes */
3150 if (chandef
.chan
!= wdev
->preset_chandef
.chan
) {
3154 result
= rdev_set_ap_chanwidth(rdev
, dev
, &chandef
);
3158 wdev
->preset_chandef
= chandef
;
3161 case NL80211_IFTYPE_MESH_POINT
:
3162 result
= cfg80211_set_mesh_channel(rdev
, wdev
, &chandef
);
3164 case NL80211_IFTYPE_MONITOR
:
3165 result
= cfg80211_set_monitor_channel(rdev
, &chandef
);
3174 static int nl80211_set_channel(struct sk_buff
*skb
, struct genl_info
*info
)
3176 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3177 struct net_device
*netdev
= info
->user_ptr
[1];
3179 return __nl80211_set_channel(rdev
, netdev
, info
);
3182 static int nl80211_set_wiphy(struct sk_buff
*skb
, struct genl_info
*info
)
3184 struct cfg80211_registered_device
*rdev
= NULL
;
3185 struct net_device
*netdev
= NULL
;
3186 struct wireless_dev
*wdev
;
3187 int result
= 0, rem_txq_params
= 0;
3188 struct nlattr
*nl_txq_params
;
3190 u8 retry_short
= 0, retry_long
= 0;
3191 u32 frag_threshold
= 0, rts_threshold
= 0;
3192 u8 coverage_class
= 0;
3193 u32 txq_limit
= 0, txq_memory_limit
= 0, txq_quantum
= 0;
3197 * Try to find the wiphy and netdev. Normally this
3198 * function shouldn't need the netdev, but this is
3199 * done for backward compatibility -- previously
3200 * setting the channel was done per wiphy, but now
3201 * it is per netdev. Previous userland like hostapd
3202 * also passed a netdev to set_wiphy, so that it is
3203 * possible to let that go to the right netdev!
3206 if (info
->attrs
[NL80211_ATTR_IFINDEX
]) {
3207 int ifindex
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFINDEX
]);
3209 netdev
= __dev_get_by_index(genl_info_net(info
), ifindex
);
3210 if (netdev
&& netdev
->ieee80211_ptr
)
3211 rdev
= wiphy_to_rdev(netdev
->ieee80211_ptr
->wiphy
);
3217 rdev
= __cfg80211_rdev_from_attrs(genl_info_net(info
),
3221 return PTR_ERR(rdev
);
3227 wdev
= netdev
->ieee80211_ptr
;
3229 wiphy_lock(&rdev
->wiphy
);
3232 * end workaround code, by now the rdev is available
3233 * and locked, and wdev may or may not be NULL.
3236 if (info
->attrs
[NL80211_ATTR_WIPHY_NAME
])
3237 result
= cfg80211_dev_rename(
3238 rdev
, nla_data(info
->attrs
[NL80211_ATTR_WIPHY_NAME
]));
3244 if (info
->attrs
[NL80211_ATTR_WIPHY_TXQ_PARAMS
]) {
3245 struct ieee80211_txq_params txq_params
;
3246 struct nlattr
*tb
[NL80211_TXQ_ATTR_MAX
+ 1];
3248 if (!rdev
->ops
->set_txq_params
) {
3249 result
= -EOPNOTSUPP
;
3258 if (netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
3259 netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
) {
3264 if (!netif_running(netdev
)) {
3269 nla_for_each_nested(nl_txq_params
,
3270 info
->attrs
[NL80211_ATTR_WIPHY_TXQ_PARAMS
],
3272 result
= nla_parse_nested_deprecated(tb
,
3273 NL80211_TXQ_ATTR_MAX
,
3279 result
= parse_txq_params(tb
, &txq_params
);
3283 result
= rdev_set_txq_params(rdev
, netdev
,
3290 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
3291 result
= __nl80211_set_channel(
3293 nl80211_can_set_dev_channel(wdev
) ? netdev
: NULL
,
3299 if (info
->attrs
[NL80211_ATTR_WIPHY_TX_POWER_SETTING
]) {
3300 struct wireless_dev
*txp_wdev
= wdev
;
3301 enum nl80211_tx_power_setting type
;
3304 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_VIF_TXPOWER
))
3307 if (!rdev
->ops
->set_tx_power
) {
3308 result
= -EOPNOTSUPP
;
3312 idx
= NL80211_ATTR_WIPHY_TX_POWER_SETTING
;
3313 type
= nla_get_u32(info
->attrs
[idx
]);
3315 if (!info
->attrs
[NL80211_ATTR_WIPHY_TX_POWER_LEVEL
] &&
3316 (type
!= NL80211_TX_POWER_AUTOMATIC
)) {
3321 if (type
!= NL80211_TX_POWER_AUTOMATIC
) {
3322 idx
= NL80211_ATTR_WIPHY_TX_POWER_LEVEL
;
3323 mbm
= nla_get_u32(info
->attrs
[idx
]);
3326 result
= rdev_set_tx_power(rdev
, txp_wdev
, type
, mbm
);
3331 if (info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_TX
] &&
3332 info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_RX
]) {
3335 if ((!rdev
->wiphy
.available_antennas_tx
&&
3336 !rdev
->wiphy
.available_antennas_rx
) ||
3337 !rdev
->ops
->set_antenna
) {
3338 result
= -EOPNOTSUPP
;
3342 tx_ant
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_TX
]);
3343 rx_ant
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_RX
]);
3345 /* reject antenna configurations which don't match the
3346 * available antenna masks, except for the "all" mask */
3347 if ((~tx_ant
&& (tx_ant
& ~rdev
->wiphy
.available_antennas_tx
)) ||
3348 (~rx_ant
&& (rx_ant
& ~rdev
->wiphy
.available_antennas_rx
))) {
3353 tx_ant
= tx_ant
& rdev
->wiphy
.available_antennas_tx
;
3354 rx_ant
= rx_ant
& rdev
->wiphy
.available_antennas_rx
;
3356 result
= rdev_set_antenna(rdev
, tx_ant
, rx_ant
);
3363 if (info
->attrs
[NL80211_ATTR_WIPHY_RETRY_SHORT
]) {
3364 retry_short
= nla_get_u8(
3365 info
->attrs
[NL80211_ATTR_WIPHY_RETRY_SHORT
]);
3367 changed
|= WIPHY_PARAM_RETRY_SHORT
;
3370 if (info
->attrs
[NL80211_ATTR_WIPHY_RETRY_LONG
]) {
3371 retry_long
= nla_get_u8(
3372 info
->attrs
[NL80211_ATTR_WIPHY_RETRY_LONG
]);
3374 changed
|= WIPHY_PARAM_RETRY_LONG
;
3377 if (info
->attrs
[NL80211_ATTR_WIPHY_FRAG_THRESHOLD
]) {
3378 frag_threshold
= nla_get_u32(
3379 info
->attrs
[NL80211_ATTR_WIPHY_FRAG_THRESHOLD
]);
3380 if (frag_threshold
< 256) {
3385 if (frag_threshold
!= (u32
) -1) {
3387 * Fragments (apart from the last one) are required to
3388 * have even length. Make the fragmentation code
3389 * simpler by stripping LSB should someone try to use
3390 * odd threshold value.
3392 frag_threshold
&= ~0x1;
3394 changed
|= WIPHY_PARAM_FRAG_THRESHOLD
;
3397 if (info
->attrs
[NL80211_ATTR_WIPHY_RTS_THRESHOLD
]) {
3398 rts_threshold
= nla_get_u32(
3399 info
->attrs
[NL80211_ATTR_WIPHY_RTS_THRESHOLD
]);
3400 changed
|= WIPHY_PARAM_RTS_THRESHOLD
;
3403 if (info
->attrs
[NL80211_ATTR_WIPHY_COVERAGE_CLASS
]) {
3404 if (info
->attrs
[NL80211_ATTR_WIPHY_DYN_ACK
]) {
3409 coverage_class
= nla_get_u8(
3410 info
->attrs
[NL80211_ATTR_WIPHY_COVERAGE_CLASS
]);
3411 changed
|= WIPHY_PARAM_COVERAGE_CLASS
;
3414 if (info
->attrs
[NL80211_ATTR_WIPHY_DYN_ACK
]) {
3415 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_ACKTO_ESTIMATION
)) {
3416 result
= -EOPNOTSUPP
;
3420 changed
|= WIPHY_PARAM_DYN_ACK
;
3423 if (info
->attrs
[NL80211_ATTR_TXQ_LIMIT
]) {
3424 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
3425 NL80211_EXT_FEATURE_TXQS
)) {
3426 result
= -EOPNOTSUPP
;
3429 txq_limit
= nla_get_u32(
3430 info
->attrs
[NL80211_ATTR_TXQ_LIMIT
]);
3431 changed
|= WIPHY_PARAM_TXQ_LIMIT
;
3434 if (info
->attrs
[NL80211_ATTR_TXQ_MEMORY_LIMIT
]) {
3435 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
3436 NL80211_EXT_FEATURE_TXQS
)) {
3437 result
= -EOPNOTSUPP
;
3440 txq_memory_limit
= nla_get_u32(
3441 info
->attrs
[NL80211_ATTR_TXQ_MEMORY_LIMIT
]);
3442 changed
|= WIPHY_PARAM_TXQ_MEMORY_LIMIT
;
3445 if (info
->attrs
[NL80211_ATTR_TXQ_QUANTUM
]) {
3446 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
3447 NL80211_EXT_FEATURE_TXQS
)) {
3448 result
= -EOPNOTSUPP
;
3451 txq_quantum
= nla_get_u32(
3452 info
->attrs
[NL80211_ATTR_TXQ_QUANTUM
]);
3453 changed
|= WIPHY_PARAM_TXQ_QUANTUM
;
3457 u8 old_retry_short
, old_retry_long
;
3458 u32 old_frag_threshold
, old_rts_threshold
;
3459 u8 old_coverage_class
;
3460 u32 old_txq_limit
, old_txq_memory_limit
, old_txq_quantum
;
3462 if (!rdev
->ops
->set_wiphy_params
) {
3463 result
= -EOPNOTSUPP
;
3467 old_retry_short
= rdev
->wiphy
.retry_short
;
3468 old_retry_long
= rdev
->wiphy
.retry_long
;
3469 old_frag_threshold
= rdev
->wiphy
.frag_threshold
;
3470 old_rts_threshold
= rdev
->wiphy
.rts_threshold
;
3471 old_coverage_class
= rdev
->wiphy
.coverage_class
;
3472 old_txq_limit
= rdev
->wiphy
.txq_limit
;
3473 old_txq_memory_limit
= rdev
->wiphy
.txq_memory_limit
;
3474 old_txq_quantum
= rdev
->wiphy
.txq_quantum
;
3476 if (changed
& WIPHY_PARAM_RETRY_SHORT
)
3477 rdev
->wiphy
.retry_short
= retry_short
;
3478 if (changed
& WIPHY_PARAM_RETRY_LONG
)
3479 rdev
->wiphy
.retry_long
= retry_long
;
3480 if (changed
& WIPHY_PARAM_FRAG_THRESHOLD
)
3481 rdev
->wiphy
.frag_threshold
= frag_threshold
;
3482 if (changed
& WIPHY_PARAM_RTS_THRESHOLD
)
3483 rdev
->wiphy
.rts_threshold
= rts_threshold
;
3484 if (changed
& WIPHY_PARAM_COVERAGE_CLASS
)
3485 rdev
->wiphy
.coverage_class
= coverage_class
;
3486 if (changed
& WIPHY_PARAM_TXQ_LIMIT
)
3487 rdev
->wiphy
.txq_limit
= txq_limit
;
3488 if (changed
& WIPHY_PARAM_TXQ_MEMORY_LIMIT
)
3489 rdev
->wiphy
.txq_memory_limit
= txq_memory_limit
;
3490 if (changed
& WIPHY_PARAM_TXQ_QUANTUM
)
3491 rdev
->wiphy
.txq_quantum
= txq_quantum
;
3493 result
= rdev_set_wiphy_params(rdev
, changed
);
3495 rdev
->wiphy
.retry_short
= old_retry_short
;
3496 rdev
->wiphy
.retry_long
= old_retry_long
;
3497 rdev
->wiphy
.frag_threshold
= old_frag_threshold
;
3498 rdev
->wiphy
.rts_threshold
= old_rts_threshold
;
3499 rdev
->wiphy
.coverage_class
= old_coverage_class
;
3500 rdev
->wiphy
.txq_limit
= old_txq_limit
;
3501 rdev
->wiphy
.txq_memory_limit
= old_txq_memory_limit
;
3502 rdev
->wiphy
.txq_quantum
= old_txq_quantum
;
3510 wiphy_unlock(&rdev
->wiphy
);
3514 static int nl80211_send_chandef(struct sk_buff
*msg
,
3515 const struct cfg80211_chan_def
*chandef
)
3517 if (WARN_ON(!cfg80211_chandef_valid(chandef
)))
3520 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
,
3521 chandef
->chan
->center_freq
))
3523 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ_OFFSET
,
3524 chandef
->chan
->freq_offset
))
3526 switch (chandef
->width
) {
3527 case NL80211_CHAN_WIDTH_20_NOHT
:
3528 case NL80211_CHAN_WIDTH_20
:
3529 case NL80211_CHAN_WIDTH_40
:
3530 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
3531 cfg80211_get_chandef_type(chandef
)))
3537 if (nla_put_u32(msg
, NL80211_ATTR_CHANNEL_WIDTH
, chandef
->width
))
3539 if (nla_put_u32(msg
, NL80211_ATTR_CENTER_FREQ1
, chandef
->center_freq1
))
3541 if (chandef
->center_freq2
&&
3542 nla_put_u32(msg
, NL80211_ATTR_CENTER_FREQ2
, chandef
->center_freq2
))
3547 static int nl80211_send_iface(struct sk_buff
*msg
, u32 portid
, u32 seq
, int flags
,
3548 struct cfg80211_registered_device
*rdev
,
3549 struct wireless_dev
*wdev
,
3550 enum nl80211_commands cmd
)
3552 struct net_device
*dev
= wdev
->netdev
;
3555 WARN_ON(cmd
!= NL80211_CMD_NEW_INTERFACE
&&
3556 cmd
!= NL80211_CMD_DEL_INTERFACE
&&
3557 cmd
!= NL80211_CMD_SET_INTERFACE
);
3559 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, cmd
);
3564 (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
3565 nla_put_string(msg
, NL80211_ATTR_IFNAME
, dev
->name
)))
3566 goto nla_put_failure
;
3568 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
3569 nla_put_u32(msg
, NL80211_ATTR_IFTYPE
, wdev
->iftype
) ||
3570 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
3571 NL80211_ATTR_PAD
) ||
3572 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, wdev_address(wdev
)) ||
3573 nla_put_u32(msg
, NL80211_ATTR_GENERATION
,
3574 rdev
->devlist_generation
^
3575 (cfg80211_rdev_list_generation
<< 2)) ||
3576 nla_put_u8(msg
, NL80211_ATTR_4ADDR
, wdev
->use_4addr
))
3577 goto nla_put_failure
;
3579 if (rdev
->ops
->get_channel
) {
3581 struct cfg80211_chan_def chandef
= {};
3583 ret
= rdev_get_channel(rdev
, wdev
, &chandef
);
3585 if (nl80211_send_chandef(msg
, &chandef
))
3586 goto nla_put_failure
;
3590 if (rdev
->ops
->get_tx_power
) {
3593 ret
= rdev_get_tx_power(rdev
, wdev
, &dbm
);
3595 nla_put_u32(msg
, NL80211_ATTR_WIPHY_TX_POWER_LEVEL
,
3597 goto nla_put_failure
;
3601 switch (wdev
->iftype
) {
3602 case NL80211_IFTYPE_AP
:
3603 if (wdev
->ssid_len
&&
3604 nla_put(msg
, NL80211_ATTR_SSID
, wdev
->ssid_len
, wdev
->ssid
))
3605 goto nla_put_failure_locked
;
3607 case NL80211_IFTYPE_STATION
:
3608 case NL80211_IFTYPE_P2P_CLIENT
:
3609 case NL80211_IFTYPE_ADHOC
: {
3611 if (!wdev
->current_bss
)
3614 ssid_ie
= ieee80211_bss_get_ie(&wdev
->current_bss
->pub
,
3617 nla_put(msg
, NL80211_ATTR_SSID
, ssid_ie
[1], ssid_ie
+ 2))
3618 goto nla_put_failure_rcu_locked
;
3628 if (rdev
->ops
->get_txq_stats
) {
3629 struct cfg80211_txq_stats txqstats
= {};
3630 int ret
= rdev_get_txq_stats(rdev
, wdev
, &txqstats
);
3633 !nl80211_put_txq_stats(msg
, &txqstats
,
3634 NL80211_ATTR_TXQ_STATS
))
3635 goto nla_put_failure
;
3638 genlmsg_end(msg
, hdr
);
3641 nla_put_failure_rcu_locked
:
3643 nla_put_failure_locked
:
3646 genlmsg_cancel(msg
, hdr
);
3650 static int nl80211_dump_interface(struct sk_buff
*skb
, struct netlink_callback
*cb
)
3654 int wp_start
= cb
->args
[0];
3655 int if_start
= cb
->args
[1];
3656 int filter_wiphy
= -1;
3657 struct cfg80211_registered_device
*rdev
;
3658 struct wireless_dev
*wdev
;
3663 struct nl80211_dump_wiphy_state state
= {
3667 ret
= nl80211_dump_wiphy_parse(skb
, cb
, &state
);
3671 filter_wiphy
= state
.filter_wiphy
;
3674 * if filtering, set cb->args[2] to +1 since 0 is the default
3675 * value needed to determine that parsing is necessary.
3677 if (filter_wiphy
>= 0)
3678 cb
->args
[2] = filter_wiphy
+ 1;
3681 } else if (cb
->args
[2] > 0) {
3682 filter_wiphy
= cb
->args
[2] - 1;
3685 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
3686 if (!net_eq(wiphy_net(&rdev
->wiphy
), sock_net(skb
->sk
)))
3688 if (wp_idx
< wp_start
) {
3693 if (filter_wiphy
>= 0 && filter_wiphy
!= rdev
->wiphy_idx
)
3698 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
3699 if (if_idx
< if_start
) {
3703 if (nl80211_send_iface(skb
, NETLINK_CB(cb
->skb
).portid
,
3704 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
3706 NL80211_CMD_NEW_INTERFACE
) < 0) {
3715 cb
->args
[0] = wp_idx
;
3716 cb
->args
[1] = if_idx
;
3725 static int nl80211_get_interface(struct sk_buff
*skb
, struct genl_info
*info
)
3727 struct sk_buff
*msg
;
3728 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3729 struct wireless_dev
*wdev
= info
->user_ptr
[1];
3731 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3735 if (nl80211_send_iface(msg
, info
->snd_portid
, info
->snd_seq
, 0,
3736 rdev
, wdev
, NL80211_CMD_NEW_INTERFACE
) < 0) {
3741 return genlmsg_reply(msg
, info
);
3744 static const struct nla_policy mntr_flags_policy
[NL80211_MNTR_FLAG_MAX
+ 1] = {
3745 [NL80211_MNTR_FLAG_FCSFAIL
] = { .type
= NLA_FLAG
},
3746 [NL80211_MNTR_FLAG_PLCPFAIL
] = { .type
= NLA_FLAG
},
3747 [NL80211_MNTR_FLAG_CONTROL
] = { .type
= NLA_FLAG
},
3748 [NL80211_MNTR_FLAG_OTHER_BSS
] = { .type
= NLA_FLAG
},
3749 [NL80211_MNTR_FLAG_COOK_FRAMES
] = { .type
= NLA_FLAG
},
3750 [NL80211_MNTR_FLAG_ACTIVE
] = { .type
= NLA_FLAG
},
3753 static int parse_monitor_flags(struct nlattr
*nla
, u32
*mntrflags
)
3755 struct nlattr
*flags
[NL80211_MNTR_FLAG_MAX
+ 1];
3763 if (nla_parse_nested_deprecated(flags
, NL80211_MNTR_FLAG_MAX
, nla
, mntr_flags_policy
, NULL
))
3766 for (flag
= 1; flag
<= NL80211_MNTR_FLAG_MAX
; flag
++)
3768 *mntrflags
|= (1<<flag
);
3770 *mntrflags
|= MONITOR_FLAG_CHANGED
;
3775 static int nl80211_parse_mon_options(struct cfg80211_registered_device
*rdev
,
3776 enum nl80211_iftype type
,
3777 struct genl_info
*info
,
3778 struct vif_params
*params
)
3780 bool change
= false;
3783 if (info
->attrs
[NL80211_ATTR_MNTR_FLAGS
]) {
3784 if (type
!= NL80211_IFTYPE_MONITOR
)
3787 err
= parse_monitor_flags(info
->attrs
[NL80211_ATTR_MNTR_FLAGS
],
3795 if (params
->flags
& MONITOR_FLAG_ACTIVE
&&
3796 !(rdev
->wiphy
.features
& NL80211_FEATURE_ACTIVE_MONITOR
))
3799 if (info
->attrs
[NL80211_ATTR_MU_MIMO_GROUP_DATA
]) {
3800 const u8
*mumimo_groups
;
3801 u32 cap_flag
= NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER
;
3803 if (type
!= NL80211_IFTYPE_MONITOR
)
3806 if (!wiphy_ext_feature_isset(&rdev
->wiphy
, cap_flag
))
3810 nla_data(info
->attrs
[NL80211_ATTR_MU_MIMO_GROUP_DATA
]);
3812 /* bits 0 and 63 are reserved and must be zero */
3813 if ((mumimo_groups
[0] & BIT(0)) ||
3814 (mumimo_groups
[VHT_MUMIMO_GROUPS_DATA_LEN
- 1] & BIT(7)))
3817 params
->vht_mumimo_groups
= mumimo_groups
;
3821 if (info
->attrs
[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR
]) {
3822 u32 cap_flag
= NL80211_EXT_FEATURE_MU_MIMO_AIR_SNIFFER
;
3824 if (type
!= NL80211_IFTYPE_MONITOR
)
3827 if (!wiphy_ext_feature_isset(&rdev
->wiphy
, cap_flag
))
3830 params
->vht_mumimo_follow_addr
=
3831 nla_data(info
->attrs
[NL80211_ATTR_MU_MIMO_FOLLOW_MAC_ADDR
]);
3835 return change
? 1 : 0;
3838 static int nl80211_valid_4addr(struct cfg80211_registered_device
*rdev
,
3839 struct net_device
*netdev
, u8 use_4addr
,
3840 enum nl80211_iftype iftype
)
3843 if (netdev
&& netif_is_bridge_port(netdev
))
3849 case NL80211_IFTYPE_AP_VLAN
:
3850 if (rdev
->wiphy
.flags
& WIPHY_FLAG_4ADDR_AP
)
3853 case NL80211_IFTYPE_STATION
:
3854 if (rdev
->wiphy
.flags
& WIPHY_FLAG_4ADDR_STATION
)
3864 static int nl80211_set_interface(struct sk_buff
*skb
, struct genl_info
*info
)
3866 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3867 struct vif_params params
;
3869 enum nl80211_iftype otype
, ntype
;
3870 struct net_device
*dev
= info
->user_ptr
[1];
3871 bool change
= false;
3873 memset(¶ms
, 0, sizeof(params
));
3875 otype
= ntype
= dev
->ieee80211_ptr
->iftype
;
3877 if (info
->attrs
[NL80211_ATTR_IFTYPE
]) {
3878 ntype
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFTYPE
]);
3883 if (info
->attrs
[NL80211_ATTR_MESH_ID
]) {
3884 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
3886 if (ntype
!= NL80211_IFTYPE_MESH_POINT
)
3888 if (netif_running(dev
))
3892 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN
!=
3893 IEEE80211_MAX_MESH_ID_LEN
);
3894 wdev
->mesh_id_up_len
=
3895 nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
3896 memcpy(wdev
->ssid
, nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]),
3897 wdev
->mesh_id_up_len
);
3901 if (info
->attrs
[NL80211_ATTR_4ADDR
]) {
3902 params
.use_4addr
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_4ADDR
]);
3904 err
= nl80211_valid_4addr(rdev
, dev
, params
.use_4addr
, ntype
);
3908 params
.use_4addr
= -1;
3911 err
= nl80211_parse_mon_options(rdev
, ntype
, info
, ¶ms
);
3918 err
= cfg80211_change_iface(rdev
, dev
, ntype
, ¶ms
);
3922 if (!err
&& params
.use_4addr
!= -1)
3923 dev
->ieee80211_ptr
->use_4addr
= params
.use_4addr
;
3925 if (change
&& !err
) {
3926 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
3928 nl80211_notify_iface(rdev
, wdev
, NL80211_CMD_SET_INTERFACE
);
3934 static int _nl80211_new_interface(struct sk_buff
*skb
, struct genl_info
*info
)
3936 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3937 struct vif_params params
;
3938 struct wireless_dev
*wdev
;
3939 struct sk_buff
*msg
;
3941 enum nl80211_iftype type
= NL80211_IFTYPE_UNSPECIFIED
;
3943 memset(¶ms
, 0, sizeof(params
));
3945 if (!info
->attrs
[NL80211_ATTR_IFNAME
])
3948 if (info
->attrs
[NL80211_ATTR_IFTYPE
])
3949 type
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFTYPE
]);
3951 if (!rdev
->ops
->add_virtual_intf
)
3954 if ((type
== NL80211_IFTYPE_P2P_DEVICE
|| type
== NL80211_IFTYPE_NAN
||
3955 rdev
->wiphy
.features
& NL80211_FEATURE_MAC_ON_CREATE
) &&
3956 info
->attrs
[NL80211_ATTR_MAC
]) {
3957 nla_memcpy(params
.macaddr
, info
->attrs
[NL80211_ATTR_MAC
],
3959 if (!is_valid_ether_addr(params
.macaddr
))
3960 return -EADDRNOTAVAIL
;
3963 if (info
->attrs
[NL80211_ATTR_4ADDR
]) {
3964 params
.use_4addr
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_4ADDR
]);
3965 err
= nl80211_valid_4addr(rdev
, NULL
, params
.use_4addr
, type
);
3970 if (!cfg80211_iftype_allowed(&rdev
->wiphy
, type
, params
.use_4addr
, 0))
3973 err
= nl80211_parse_mon_options(rdev
, type
, info
, ¶ms
);
3977 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3981 wdev
= rdev_add_virtual_intf(rdev
,
3982 nla_data(info
->attrs
[NL80211_ATTR_IFNAME
]),
3983 NET_NAME_USER
, type
, ¶ms
);
3984 if (WARN_ON(!wdev
)) {
3987 } else if (IS_ERR(wdev
)) {
3989 return PTR_ERR(wdev
);
3992 if (info
->attrs
[NL80211_ATTR_SOCKET_OWNER
])
3993 wdev
->owner_nlportid
= info
->snd_portid
;
3996 case NL80211_IFTYPE_MESH_POINT
:
3997 if (!info
->attrs
[NL80211_ATTR_MESH_ID
])
4000 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN
!=
4001 IEEE80211_MAX_MESH_ID_LEN
);
4002 wdev
->mesh_id_up_len
=
4003 nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
4004 memcpy(wdev
->ssid
, nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]),
4005 wdev
->mesh_id_up_len
);
4008 case NL80211_IFTYPE_NAN
:
4009 case NL80211_IFTYPE_P2P_DEVICE
:
4011 * P2P Device and NAN do not have a netdev, so don't go
4012 * through the netdev notifier and must be added here
4014 cfg80211_init_wdev(wdev
);
4015 cfg80211_register_wdev(rdev
, wdev
);
4021 if (nl80211_send_iface(msg
, info
->snd_portid
, info
->snd_seq
, 0,
4022 rdev
, wdev
, NL80211_CMD_NEW_INTERFACE
) < 0) {
4027 return genlmsg_reply(msg
, info
);
4030 static int nl80211_new_interface(struct sk_buff
*skb
, struct genl_info
*info
)
4032 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4035 /* to avoid failing a new interface creation due to pending removal */
4036 cfg80211_destroy_ifaces(rdev
);
4038 wiphy_lock(&rdev
->wiphy
);
4039 ret
= _nl80211_new_interface(skb
, info
);
4040 wiphy_unlock(&rdev
->wiphy
);
4045 static int nl80211_del_interface(struct sk_buff
*skb
, struct genl_info
*info
)
4047 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4048 struct wireless_dev
*wdev
= info
->user_ptr
[1];
4050 if (!rdev
->ops
->del_virtual_intf
)
4054 * We hold RTNL, so this is safe, without RTNL opencount cannot
4055 * reach 0, and thus the rdev cannot be deleted.
4057 * We need to do it for the dev_close(), since that will call
4058 * the netdev notifiers, and we need to acquire the mutex there
4059 * but don't know if we get there from here or from some other
4060 * place (e.g. "ip link set ... down").
4062 mutex_unlock(&rdev
->wiphy
.mtx
);
4065 * If we remove a wireless device without a netdev then clear
4066 * user_ptr[1] so that nl80211_post_doit won't dereference it
4067 * to check if it needs to do dev_put(). Otherwise it crashes
4068 * since the wdev has been freed, unlike with a netdev where
4069 * we need the dev_put() for the netdev to really be freed.
4072 info
->user_ptr
[1] = NULL
;
4074 dev_close(wdev
->netdev
);
4076 mutex_lock(&rdev
->wiphy
.mtx
);
4078 return rdev_del_virtual_intf(rdev
, wdev
);
4081 static int nl80211_set_noack_map(struct sk_buff
*skb
, struct genl_info
*info
)
4083 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4084 struct net_device
*dev
= info
->user_ptr
[1];
4087 if (!info
->attrs
[NL80211_ATTR_NOACK_MAP
])
4090 if (!rdev
->ops
->set_noack_map
)
4093 noack_map
= nla_get_u16(info
->attrs
[NL80211_ATTR_NOACK_MAP
]);
4095 return rdev_set_noack_map(rdev
, dev
, noack_map
);
4098 struct get_key_cookie
{
4099 struct sk_buff
*msg
;
4104 static void get_key_callback(void *c
, struct key_params
*params
)
4107 struct get_key_cookie
*cookie
= c
;
4110 nla_put(cookie
->msg
, NL80211_ATTR_KEY_DATA
,
4111 params
->key_len
, params
->key
)) ||
4113 nla_put(cookie
->msg
, NL80211_ATTR_KEY_SEQ
,
4114 params
->seq_len
, params
->seq
)) ||
4116 nla_put_u32(cookie
->msg
, NL80211_ATTR_KEY_CIPHER
,
4118 goto nla_put_failure
;
4120 key
= nla_nest_start_noflag(cookie
->msg
, NL80211_ATTR_KEY
);
4122 goto nla_put_failure
;
4125 nla_put(cookie
->msg
, NL80211_KEY_DATA
,
4126 params
->key_len
, params
->key
)) ||
4128 nla_put(cookie
->msg
, NL80211_KEY_SEQ
,
4129 params
->seq_len
, params
->seq
)) ||
4131 nla_put_u32(cookie
->msg
, NL80211_KEY_CIPHER
,
4133 goto nla_put_failure
;
4135 if (nla_put_u8(cookie
->msg
, NL80211_KEY_IDX
, cookie
->idx
))
4136 goto nla_put_failure
;
4138 nla_nest_end(cookie
->msg
, key
);
4145 static int nl80211_get_key(struct sk_buff
*skb
, struct genl_info
*info
)
4147 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4149 struct net_device
*dev
= info
->user_ptr
[1];
4151 const u8
*mac_addr
= NULL
;
4153 struct get_key_cookie cookie
= {
4157 struct sk_buff
*msg
;
4158 bool bigtk_support
= false;
4160 if (wiphy_ext_feature_isset(&rdev
->wiphy
,
4161 NL80211_EXT_FEATURE_BEACON_PROTECTION
))
4162 bigtk_support
= true;
4164 if ((dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_STATION
||
4165 dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_P2P_CLIENT
) &&
4166 wiphy_ext_feature_isset(&rdev
->wiphy
,
4167 NL80211_EXT_FEATURE_BEACON_PROTECTION_CLIENT
))
4168 bigtk_support
= true;
4170 if (info
->attrs
[NL80211_ATTR_KEY_IDX
]) {
4171 key_idx
= nla_get_u8(info
->attrs
[NL80211_ATTR_KEY_IDX
]);
4173 if (key_idx
>= 6 && key_idx
<= 7 && !bigtk_support
) {
4174 GENL_SET_ERR_MSG(info
, "BIGTK not supported");
4179 if (info
->attrs
[NL80211_ATTR_MAC
])
4180 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4182 pairwise
= !!mac_addr
;
4183 if (info
->attrs
[NL80211_ATTR_KEY_TYPE
]) {
4184 u32 kt
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_TYPE
]);
4186 if (kt
!= NL80211_KEYTYPE_GROUP
&&
4187 kt
!= NL80211_KEYTYPE_PAIRWISE
)
4189 pairwise
= kt
== NL80211_KEYTYPE_PAIRWISE
;
4192 if (!rdev
->ops
->get_key
)
4195 if (!pairwise
&& mac_addr
&& !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
4198 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
4202 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
4203 NL80211_CMD_NEW_KEY
);
4205 goto nla_put_failure
;
4208 cookie
.idx
= key_idx
;
4210 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
4211 nla_put_u8(msg
, NL80211_ATTR_KEY_IDX
, key_idx
))
4212 goto nla_put_failure
;
4214 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
))
4215 goto nla_put_failure
;
4217 err
= rdev_get_key(rdev
, dev
, key_idx
, pairwise
, mac_addr
, &cookie
,
4224 goto nla_put_failure
;
4226 genlmsg_end(msg
, hdr
);
4227 return genlmsg_reply(msg
, info
);
4236 static int nl80211_set_key(struct sk_buff
*skb
, struct genl_info
*info
)
4238 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4239 struct key_parse key
;
4241 struct net_device
*dev
= info
->user_ptr
[1];
4243 err
= nl80211_parse_key(info
, &key
);
4250 /* Only support setting default key and
4251 * Extended Key ID action NL80211_KEY_SET_TX.
4253 if (!key
.def
&& !key
.defmgmt
&& !key
.defbeacon
&&
4254 !(key
.p
.mode
== NL80211_KEY_SET_TX
))
4257 wdev_lock(dev
->ieee80211_ptr
);
4260 if (!rdev
->ops
->set_default_key
) {
4265 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
4269 err
= rdev_set_default_key(rdev
, dev
, key
.idx
,
4270 key
.def_uni
, key
.def_multi
);
4275 #ifdef CONFIG_CFG80211_WEXT
4276 dev
->ieee80211_ptr
->wext
.default_key
= key
.idx
;
4278 } else if (key
.defmgmt
) {
4279 if (key
.def_uni
|| !key
.def_multi
) {
4284 if (!rdev
->ops
->set_default_mgmt_key
) {
4289 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
4293 err
= rdev_set_default_mgmt_key(rdev
, dev
, key
.idx
);
4297 #ifdef CONFIG_CFG80211_WEXT
4298 dev
->ieee80211_ptr
->wext
.default_mgmt_key
= key
.idx
;
4300 } else if (key
.defbeacon
) {
4301 if (key
.def_uni
|| !key
.def_multi
) {
4306 if (!rdev
->ops
->set_default_beacon_key
) {
4311 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
4315 err
= rdev_set_default_beacon_key(rdev
, dev
, key
.idx
);
4318 } else if (key
.p
.mode
== NL80211_KEY_SET_TX
&&
4319 wiphy_ext_feature_isset(&rdev
->wiphy
,
4320 NL80211_EXT_FEATURE_EXT_KEY_ID
)) {
4321 u8
*mac_addr
= NULL
;
4323 if (info
->attrs
[NL80211_ATTR_MAC
])
4324 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4326 if (!mac_addr
|| key
.idx
< 0 || key
.idx
> 1) {
4331 err
= rdev_add_key(rdev
, dev
, key
.idx
,
4332 NL80211_KEYTYPE_PAIRWISE
,
4338 wdev_unlock(dev
->ieee80211_ptr
);
4343 static int nl80211_new_key(struct sk_buff
*skb
, struct genl_info
*info
)
4345 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4347 struct net_device
*dev
= info
->user_ptr
[1];
4348 struct key_parse key
;
4349 const u8
*mac_addr
= NULL
;
4351 err
= nl80211_parse_key(info
, &key
);
4356 GENL_SET_ERR_MSG(info
, "no key");
4360 if (info
->attrs
[NL80211_ATTR_MAC
])
4361 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4363 if (key
.type
== -1) {
4365 key
.type
= NL80211_KEYTYPE_PAIRWISE
;
4367 key
.type
= NL80211_KEYTYPE_GROUP
;
4371 if (key
.type
!= NL80211_KEYTYPE_PAIRWISE
&&
4372 key
.type
!= NL80211_KEYTYPE_GROUP
) {
4373 GENL_SET_ERR_MSG(info
, "key type not pairwise or group");
4377 if (key
.type
== NL80211_KEYTYPE_GROUP
&&
4378 info
->attrs
[NL80211_ATTR_VLAN_ID
])
4379 key
.p
.vlan_id
= nla_get_u16(info
->attrs
[NL80211_ATTR_VLAN_ID
]);
4381 if (!rdev
->ops
->add_key
)
4384 if (cfg80211_validate_key_settings(rdev
, &key
.p
, key
.idx
,
4385 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
4387 GENL_SET_ERR_MSG(info
, "key setting validation failed");
4391 wdev_lock(dev
->ieee80211_ptr
);
4392 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
4394 GENL_SET_ERR_MSG(info
, "key not allowed");
4396 err
= rdev_add_key(rdev
, dev
, key
.idx
,
4397 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
4400 GENL_SET_ERR_MSG(info
, "key addition failed");
4402 wdev_unlock(dev
->ieee80211_ptr
);
4407 static int nl80211_del_key(struct sk_buff
*skb
, struct genl_info
*info
)
4409 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4411 struct net_device
*dev
= info
->user_ptr
[1];
4412 u8
*mac_addr
= NULL
;
4413 struct key_parse key
;
4415 err
= nl80211_parse_key(info
, &key
);
4419 if (info
->attrs
[NL80211_ATTR_MAC
])
4420 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4422 if (key
.type
== -1) {
4424 key
.type
= NL80211_KEYTYPE_PAIRWISE
;
4426 key
.type
= NL80211_KEYTYPE_GROUP
;
4430 if (key
.type
!= NL80211_KEYTYPE_PAIRWISE
&&
4431 key
.type
!= NL80211_KEYTYPE_GROUP
)
4434 if (!cfg80211_valid_key_idx(rdev
, key
.idx
,
4435 key
.type
== NL80211_KEYTYPE_PAIRWISE
))
4438 if (!rdev
->ops
->del_key
)
4441 wdev_lock(dev
->ieee80211_ptr
);
4442 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
4444 if (key
.type
== NL80211_KEYTYPE_GROUP
&& mac_addr
&&
4445 !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
4449 err
= rdev_del_key(rdev
, dev
, key
.idx
,
4450 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
4453 #ifdef CONFIG_CFG80211_WEXT
4455 if (key
.idx
== dev
->ieee80211_ptr
->wext
.default_key
)
4456 dev
->ieee80211_ptr
->wext
.default_key
= -1;
4457 else if (key
.idx
== dev
->ieee80211_ptr
->wext
.default_mgmt_key
)
4458 dev
->ieee80211_ptr
->wext
.default_mgmt_key
= -1;
4461 wdev_unlock(dev
->ieee80211_ptr
);
4466 /* This function returns an error or the number of nested attributes */
4467 static int validate_acl_mac_addrs(struct nlattr
*nl_attr
)
4469 struct nlattr
*attr
;
4470 int n_entries
= 0, tmp
;
4472 nla_for_each_nested(attr
, nl_attr
, tmp
) {
4473 if (nla_len(attr
) != ETH_ALEN
)
4483 * This function parses ACL information and allocates memory for ACL data.
4484 * On successful return, the calling function is responsible to free the
4485 * ACL buffer returned by this function.
4487 static struct cfg80211_acl_data
*parse_acl_data(struct wiphy
*wiphy
,
4488 struct genl_info
*info
)
4490 enum nl80211_acl_policy acl_policy
;
4491 struct nlattr
*attr
;
4492 struct cfg80211_acl_data
*acl
;
4493 int i
= 0, n_entries
, tmp
;
4495 if (!wiphy
->max_acl_mac_addrs
)
4496 return ERR_PTR(-EOPNOTSUPP
);
4498 if (!info
->attrs
[NL80211_ATTR_ACL_POLICY
])
4499 return ERR_PTR(-EINVAL
);
4501 acl_policy
= nla_get_u32(info
->attrs
[NL80211_ATTR_ACL_POLICY
]);
4502 if (acl_policy
!= NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED
&&
4503 acl_policy
!= NL80211_ACL_POLICY_DENY_UNLESS_LISTED
)
4504 return ERR_PTR(-EINVAL
);
4506 if (!info
->attrs
[NL80211_ATTR_MAC_ADDRS
])
4507 return ERR_PTR(-EINVAL
);
4509 n_entries
= validate_acl_mac_addrs(info
->attrs
[NL80211_ATTR_MAC_ADDRS
]);
4511 return ERR_PTR(n_entries
);
4513 if (n_entries
> wiphy
->max_acl_mac_addrs
)
4514 return ERR_PTR(-ENOTSUPP
);
4516 acl
= kzalloc(struct_size(acl
, mac_addrs
, n_entries
), GFP_KERNEL
);
4518 return ERR_PTR(-ENOMEM
);
4520 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_MAC_ADDRS
], tmp
) {
4521 memcpy(acl
->mac_addrs
[i
].addr
, nla_data(attr
), ETH_ALEN
);
4525 acl
->n_acl_entries
= n_entries
;
4526 acl
->acl_policy
= acl_policy
;
4531 static int nl80211_set_mac_acl(struct sk_buff
*skb
, struct genl_info
*info
)
4533 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4534 struct net_device
*dev
= info
->user_ptr
[1];
4535 struct cfg80211_acl_data
*acl
;
4538 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
4539 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
4542 if (!dev
->ieee80211_ptr
->beacon_interval
)
4545 acl
= parse_acl_data(&rdev
->wiphy
, info
);
4547 return PTR_ERR(acl
);
4549 err
= rdev_set_mac_acl(rdev
, dev
, acl
);
4556 static u32
rateset_to_mask(struct ieee80211_supported_band
*sband
,
4557 u8
*rates
, u8 rates_len
)
4562 for (i
= 0; i
< rates_len
; i
++) {
4563 int rate
= (rates
[i
] & 0x7f) * 5;
4566 for (ridx
= 0; ridx
< sband
->n_bitrates
; ridx
++) {
4567 struct ieee80211_rate
*srate
=
4568 &sband
->bitrates
[ridx
];
4569 if (rate
== srate
->bitrate
) {
4574 if (ridx
== sband
->n_bitrates
)
4575 return 0; /* rate not found */
4581 static bool ht_rateset_to_mask(struct ieee80211_supported_band
*sband
,
4582 u8
*rates
, u8 rates_len
,
4583 u8 mcs
[IEEE80211_HT_MCS_MASK_LEN
])
4587 memset(mcs
, 0, IEEE80211_HT_MCS_MASK_LEN
);
4589 for (i
= 0; i
< rates_len
; i
++) {
4592 ridx
= rates
[i
] / 8;
4593 rbit
= BIT(rates
[i
] % 8);
4595 /* check validity */
4596 if ((ridx
< 0) || (ridx
>= IEEE80211_HT_MCS_MASK_LEN
))
4599 /* check availability */
4600 ridx
= array_index_nospec(ridx
, IEEE80211_HT_MCS_MASK_LEN
);
4601 if (sband
->ht_cap
.mcs
.rx_mask
[ridx
] & rbit
)
4610 static u16
vht_mcs_map_to_mcs_mask(u8 vht_mcs_map
)
4614 switch (vht_mcs_map
) {
4615 case IEEE80211_VHT_MCS_NOT_SUPPORTED
:
4617 case IEEE80211_VHT_MCS_SUPPORT_0_7
:
4620 case IEEE80211_VHT_MCS_SUPPORT_0_8
:
4623 case IEEE80211_VHT_MCS_SUPPORT_0_9
:
4633 static void vht_build_mcs_mask(u16 vht_mcs_map
,
4634 u16 vht_mcs_mask
[NL80211_VHT_NSS_MAX
])
4638 for (nss
= 0; nss
< NL80211_VHT_NSS_MAX
; nss
++) {
4639 vht_mcs_mask
[nss
] = vht_mcs_map_to_mcs_mask(vht_mcs_map
& 0x03);
4644 static bool vht_set_mcs_mask(struct ieee80211_supported_band
*sband
,
4645 struct nl80211_txrate_vht
*txrate
,
4646 u16 mcs
[NL80211_VHT_NSS_MAX
])
4648 u16 tx_mcs_map
= le16_to_cpu(sband
->vht_cap
.vht_mcs
.tx_mcs_map
);
4649 u16 tx_mcs_mask
[NL80211_VHT_NSS_MAX
] = {};
4652 if (!sband
->vht_cap
.vht_supported
)
4655 memset(mcs
, 0, sizeof(u16
) * NL80211_VHT_NSS_MAX
);
4657 /* Build vht_mcs_mask from VHT capabilities */
4658 vht_build_mcs_mask(tx_mcs_map
, tx_mcs_mask
);
4660 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++) {
4661 if ((tx_mcs_mask
[i
] & txrate
->mcs
[i
]) == txrate
->mcs
[i
])
4662 mcs
[i
] = txrate
->mcs
[i
];
4670 static u16
he_mcs_map_to_mcs_mask(u8 he_mcs_map
)
4672 switch (he_mcs_map
) {
4673 case IEEE80211_HE_MCS_NOT_SUPPORTED
:
4675 case IEEE80211_HE_MCS_SUPPORT_0_7
:
4677 case IEEE80211_HE_MCS_SUPPORT_0_9
:
4679 case IEEE80211_HE_MCS_SUPPORT_0_11
:
4687 static void he_build_mcs_mask(u16 he_mcs_map
,
4688 u16 he_mcs_mask
[NL80211_HE_NSS_MAX
])
4692 for (nss
= 0; nss
< NL80211_HE_NSS_MAX
; nss
++) {
4693 he_mcs_mask
[nss
] = he_mcs_map_to_mcs_mask(he_mcs_map
& 0x03);
4698 static u16
he_get_txmcsmap(struct genl_info
*info
,
4699 const struct ieee80211_sta_he_cap
*he_cap
)
4701 struct net_device
*dev
= info
->user_ptr
[1];
4702 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
4705 switch (wdev
->chandef
.width
) {
4706 case NL80211_CHAN_WIDTH_80P80
:
4707 tx_mcs
= he_cap
->he_mcs_nss_supp
.tx_mcs_80p80
;
4709 case NL80211_CHAN_WIDTH_160
:
4710 tx_mcs
= he_cap
->he_mcs_nss_supp
.tx_mcs_160
;
4713 tx_mcs
= he_cap
->he_mcs_nss_supp
.tx_mcs_80
;
4716 return le16_to_cpu(tx_mcs
);
4719 static bool he_set_mcs_mask(struct genl_info
*info
,
4720 struct wireless_dev
*wdev
,
4721 struct ieee80211_supported_band
*sband
,
4722 struct nl80211_txrate_he
*txrate
,
4723 u16 mcs
[NL80211_HE_NSS_MAX
])
4725 const struct ieee80211_sta_he_cap
*he_cap
;
4726 u16 tx_mcs_mask
[NL80211_HE_NSS_MAX
] = {};
4730 he_cap
= ieee80211_get_he_iftype_cap(sband
, wdev
->iftype
);
4734 memset(mcs
, 0, sizeof(u16
) * NL80211_HE_NSS_MAX
);
4736 tx_mcs_map
= he_get_txmcsmap(info
, he_cap
);
4738 /* Build he_mcs_mask from HE capabilities */
4739 he_build_mcs_mask(tx_mcs_map
, tx_mcs_mask
);
4741 for (i
= 0; i
< NL80211_HE_NSS_MAX
; i
++) {
4742 if ((tx_mcs_mask
[i
] & txrate
->mcs
[i
]) == txrate
->mcs
[i
])
4743 mcs
[i
] = txrate
->mcs
[i
];
4751 static int nl80211_parse_tx_bitrate_mask(struct genl_info
*info
,
4752 struct nlattr
*attrs
[],
4753 enum nl80211_attrs attr
,
4754 struct cfg80211_bitrate_mask
*mask
,
4755 struct net_device
*dev
,
4756 bool default_all_enabled
)
4758 struct nlattr
*tb
[NL80211_TXRATE_MAX
+ 1];
4759 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4760 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
4762 struct nlattr
*tx_rates
;
4763 struct ieee80211_supported_band
*sband
;
4764 u16 vht_tx_mcs_map
, he_tx_mcs_map
;
4766 memset(mask
, 0, sizeof(*mask
));
4767 /* Default to all rates enabled */
4768 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++) {
4769 const struct ieee80211_sta_he_cap
*he_cap
;
4771 if (!default_all_enabled
)
4774 sband
= rdev
->wiphy
.bands
[i
];
4779 mask
->control
[i
].legacy
= (1 << sband
->n_bitrates
) - 1;
4780 memcpy(mask
->control
[i
].ht_mcs
,
4781 sband
->ht_cap
.mcs
.rx_mask
,
4782 sizeof(mask
->control
[i
].ht_mcs
));
4784 if (!sband
->vht_cap
.vht_supported
)
4787 vht_tx_mcs_map
= le16_to_cpu(sband
->vht_cap
.vht_mcs
.tx_mcs_map
);
4788 vht_build_mcs_mask(vht_tx_mcs_map
, mask
->control
[i
].vht_mcs
);
4790 he_cap
= ieee80211_get_he_iftype_cap(sband
, wdev
->iftype
);
4794 he_tx_mcs_map
= he_get_txmcsmap(info
, he_cap
);
4795 he_build_mcs_mask(he_tx_mcs_map
, mask
->control
[i
].he_mcs
);
4797 mask
->control
[i
].he_gi
= 0xFF;
4798 mask
->control
[i
].he_ltf
= 0xFF;
4801 /* if no rates are given set it back to the defaults */
4805 /* The nested attribute uses enum nl80211_band as the index. This maps
4806 * directly to the enum nl80211_band values used in cfg80211.
4808 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES
> IEEE80211_HT_MCS_MASK_LEN
* 8);
4809 nla_for_each_nested(tx_rates
, attrs
[attr
], rem
) {
4810 enum nl80211_band band
= nla_type(tx_rates
);
4813 if (band
< 0 || band
>= NUM_NL80211_BANDS
)
4815 sband
= rdev
->wiphy
.bands
[band
];
4818 err
= nla_parse_nested_deprecated(tb
, NL80211_TXRATE_MAX
,
4820 nl80211_txattr_policy
,
4824 if (tb
[NL80211_TXRATE_LEGACY
]) {
4825 mask
->control
[band
].legacy
= rateset_to_mask(
4827 nla_data(tb
[NL80211_TXRATE_LEGACY
]),
4828 nla_len(tb
[NL80211_TXRATE_LEGACY
]));
4829 if ((mask
->control
[band
].legacy
== 0) &&
4830 nla_len(tb
[NL80211_TXRATE_LEGACY
]))
4833 if (tb
[NL80211_TXRATE_HT
]) {
4834 if (!ht_rateset_to_mask(
4836 nla_data(tb
[NL80211_TXRATE_HT
]),
4837 nla_len(tb
[NL80211_TXRATE_HT
]),
4838 mask
->control
[band
].ht_mcs
))
4842 if (tb
[NL80211_TXRATE_VHT
]) {
4843 if (!vht_set_mcs_mask(
4845 nla_data(tb
[NL80211_TXRATE_VHT
]),
4846 mask
->control
[band
].vht_mcs
))
4850 if (tb
[NL80211_TXRATE_GI
]) {
4851 mask
->control
[band
].gi
=
4852 nla_get_u8(tb
[NL80211_TXRATE_GI
]);
4853 if (mask
->control
[band
].gi
> NL80211_TXRATE_FORCE_LGI
)
4856 if (tb
[NL80211_TXRATE_HE
] &&
4857 !he_set_mcs_mask(info
, wdev
, sband
,
4858 nla_data(tb
[NL80211_TXRATE_HE
]),
4859 mask
->control
[band
].he_mcs
))
4862 if (tb
[NL80211_TXRATE_HE_GI
])
4863 mask
->control
[band
].he_gi
=
4864 nla_get_u8(tb
[NL80211_TXRATE_HE_GI
]);
4865 if (tb
[NL80211_TXRATE_HE_LTF
])
4866 mask
->control
[band
].he_ltf
=
4867 nla_get_u8(tb
[NL80211_TXRATE_HE_LTF
]);
4869 if (mask
->control
[band
].legacy
== 0) {
4870 /* don't allow empty legacy rates if HT, VHT or HE
4871 * are not even supported.
4873 if (!(rdev
->wiphy
.bands
[band
]->ht_cap
.ht_supported
||
4874 rdev
->wiphy
.bands
[band
]->vht_cap
.vht_supported
||
4875 ieee80211_get_he_iftype_cap(sband
, wdev
->iftype
)))
4878 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++)
4879 if (mask
->control
[band
].ht_mcs
[i
])
4882 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++)
4883 if (mask
->control
[band
].vht_mcs
[i
])
4886 for (i
= 0; i
< NL80211_HE_NSS_MAX
; i
++)
4887 if (mask
->control
[band
].he_mcs
[i
])
4890 /* legacy and mcs rates may not be both empty */
4899 static int validate_beacon_tx_rate(struct cfg80211_registered_device
*rdev
,
4900 enum nl80211_band band
,
4901 struct cfg80211_bitrate_mask
*beacon_rate
)
4903 u32 count_ht
, count_vht
, count_he
, i
;
4904 u32 rate
= beacon_rate
->control
[band
].legacy
;
4906 /* Allow only one rate */
4907 if (hweight32(rate
) > 1)
4911 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++) {
4912 if (hweight8(beacon_rate
->control
[band
].ht_mcs
[i
]) > 1) {
4914 } else if (beacon_rate
->control
[band
].ht_mcs
[i
]) {
4919 if (count_ht
&& rate
)
4924 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++) {
4925 if (hweight16(beacon_rate
->control
[band
].vht_mcs
[i
]) > 1) {
4927 } else if (beacon_rate
->control
[band
].vht_mcs
[i
]) {
4932 if (count_vht
&& rate
)
4937 for (i
= 0; i
< NL80211_HE_NSS_MAX
; i
++) {
4938 if (hweight16(beacon_rate
->control
[band
].he_mcs
[i
]) > 1) {
4940 } else if (beacon_rate
->control
[band
].he_mcs
[i
]) {
4945 if (count_he
&& rate
)
4949 if ((count_ht
&& count_vht
&& count_he
) ||
4950 (!rate
&& !count_ht
&& !count_vht
&& !count_he
))
4954 !wiphy_ext_feature_isset(&rdev
->wiphy
,
4955 NL80211_EXT_FEATURE_BEACON_RATE_LEGACY
))
4958 !wiphy_ext_feature_isset(&rdev
->wiphy
,
4959 NL80211_EXT_FEATURE_BEACON_RATE_HT
))
4962 !wiphy_ext_feature_isset(&rdev
->wiphy
,
4963 NL80211_EXT_FEATURE_BEACON_RATE_VHT
))
4966 !wiphy_ext_feature_isset(&rdev
->wiphy
,
4967 NL80211_EXT_FEATURE_BEACON_RATE_HE
))
4973 static int nl80211_parse_beacon(struct cfg80211_registered_device
*rdev
,
4974 struct nlattr
*attrs
[],
4975 struct cfg80211_beacon_data
*bcn
)
4977 bool haveinfo
= false;
4980 memset(bcn
, 0, sizeof(*bcn
));
4982 if (attrs
[NL80211_ATTR_BEACON_HEAD
]) {
4983 bcn
->head
= nla_data(attrs
[NL80211_ATTR_BEACON_HEAD
]);
4984 bcn
->head_len
= nla_len(attrs
[NL80211_ATTR_BEACON_HEAD
]);
4990 if (attrs
[NL80211_ATTR_BEACON_TAIL
]) {
4991 bcn
->tail
= nla_data(attrs
[NL80211_ATTR_BEACON_TAIL
]);
4992 bcn
->tail_len
= nla_len(attrs
[NL80211_ATTR_BEACON_TAIL
]);
4999 if (attrs
[NL80211_ATTR_IE
]) {
5000 bcn
->beacon_ies
= nla_data(attrs
[NL80211_ATTR_IE
]);
5001 bcn
->beacon_ies_len
= nla_len(attrs
[NL80211_ATTR_IE
]);
5004 if (attrs
[NL80211_ATTR_IE_PROBE_RESP
]) {
5005 bcn
->proberesp_ies
=
5006 nla_data(attrs
[NL80211_ATTR_IE_PROBE_RESP
]);
5007 bcn
->proberesp_ies_len
=
5008 nla_len(attrs
[NL80211_ATTR_IE_PROBE_RESP
]);
5011 if (attrs
[NL80211_ATTR_IE_ASSOC_RESP
]) {
5012 bcn
->assocresp_ies
=
5013 nla_data(attrs
[NL80211_ATTR_IE_ASSOC_RESP
]);
5014 bcn
->assocresp_ies_len
=
5015 nla_len(attrs
[NL80211_ATTR_IE_ASSOC_RESP
]);
5018 if (attrs
[NL80211_ATTR_PROBE_RESP
]) {
5019 bcn
->probe_resp
= nla_data(attrs
[NL80211_ATTR_PROBE_RESP
]);
5020 bcn
->probe_resp_len
= nla_len(attrs
[NL80211_ATTR_PROBE_RESP
]);
5023 if (attrs
[NL80211_ATTR_FTM_RESPONDER
]) {
5024 struct nlattr
*tb
[NL80211_FTM_RESP_ATTR_MAX
+ 1];
5026 err
= nla_parse_nested_deprecated(tb
,
5027 NL80211_FTM_RESP_ATTR_MAX
,
5028 attrs
[NL80211_ATTR_FTM_RESPONDER
],
5033 if (tb
[NL80211_FTM_RESP_ATTR_ENABLED
] &&
5034 wiphy_ext_feature_isset(&rdev
->wiphy
,
5035 NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER
))
5036 bcn
->ftm_responder
= 1;
5040 if (tb
[NL80211_FTM_RESP_ATTR_LCI
]) {
5041 bcn
->lci
= nla_data(tb
[NL80211_FTM_RESP_ATTR_LCI
]);
5042 bcn
->lci_len
= nla_len(tb
[NL80211_FTM_RESP_ATTR_LCI
]);
5045 if (tb
[NL80211_FTM_RESP_ATTR_CIVICLOC
]) {
5046 bcn
->civicloc
= nla_data(tb
[NL80211_FTM_RESP_ATTR_CIVICLOC
]);
5047 bcn
->civicloc_len
= nla_len(tb
[NL80211_FTM_RESP_ATTR_CIVICLOC
]);
5050 bcn
->ftm_responder
= -1;
5056 static int nl80211_parse_he_obss_pd(struct nlattr
*attrs
,
5057 struct ieee80211_he_obss_pd
*he_obss_pd
)
5059 struct nlattr
*tb
[NL80211_HE_OBSS_PD_ATTR_MAX
+ 1];
5062 err
= nla_parse_nested(tb
, NL80211_HE_OBSS_PD_ATTR_MAX
, attrs
,
5063 he_obss_pd_policy
, NULL
);
5067 if (!tb
[NL80211_HE_OBSS_PD_ATTR_SR_CTRL
])
5070 he_obss_pd
->sr_ctrl
= nla_get_u8(tb
[NL80211_HE_OBSS_PD_ATTR_SR_CTRL
]);
5072 if (tb
[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET
])
5073 he_obss_pd
->min_offset
=
5074 nla_get_u8(tb
[NL80211_HE_OBSS_PD_ATTR_MIN_OFFSET
]);
5075 if (tb
[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET
])
5076 he_obss_pd
->max_offset
=
5077 nla_get_u8(tb
[NL80211_HE_OBSS_PD_ATTR_MAX_OFFSET
]);
5078 if (tb
[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET
])
5079 he_obss_pd
->non_srg_max_offset
=
5080 nla_get_u8(tb
[NL80211_HE_OBSS_PD_ATTR_NON_SRG_MAX_OFFSET
]);
5082 if (he_obss_pd
->min_offset
> he_obss_pd
->max_offset
)
5085 if (tb
[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP
])
5086 memcpy(he_obss_pd
->bss_color_bitmap
,
5087 nla_data(tb
[NL80211_HE_OBSS_PD_ATTR_BSS_COLOR_BITMAP
]),
5088 sizeof(he_obss_pd
->bss_color_bitmap
));
5090 if (tb
[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP
])
5091 memcpy(he_obss_pd
->partial_bssid_bitmap
,
5092 nla_data(tb
[NL80211_HE_OBSS_PD_ATTR_PARTIAL_BSSID_BITMAP
]),
5093 sizeof(he_obss_pd
->partial_bssid_bitmap
));
5095 he_obss_pd
->enable
= true;
5100 static int nl80211_parse_he_bss_color(struct nlattr
*attrs
,
5101 struct cfg80211_he_bss_color
*he_bss_color
)
5103 struct nlattr
*tb
[NL80211_HE_BSS_COLOR_ATTR_MAX
+ 1];
5106 err
= nla_parse_nested(tb
, NL80211_HE_BSS_COLOR_ATTR_MAX
, attrs
,
5107 he_bss_color_policy
, NULL
);
5111 if (!tb
[NL80211_HE_BSS_COLOR_ATTR_COLOR
])
5114 he_bss_color
->color
=
5115 nla_get_u8(tb
[NL80211_HE_BSS_COLOR_ATTR_COLOR
]);
5116 he_bss_color
->enabled
=
5117 !nla_get_flag(tb
[NL80211_HE_BSS_COLOR_ATTR_DISABLED
]);
5118 he_bss_color
->partial
=
5119 nla_get_flag(tb
[NL80211_HE_BSS_COLOR_ATTR_PARTIAL
]);
5124 static int nl80211_parse_fils_discovery(struct cfg80211_registered_device
*rdev
,
5125 struct nlattr
*attrs
,
5126 struct cfg80211_ap_settings
*params
)
5128 struct nlattr
*tb
[NL80211_FILS_DISCOVERY_ATTR_MAX
+ 1];
5130 struct cfg80211_fils_discovery
*fd
= ¶ms
->fils_discovery
;
5132 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
5133 NL80211_EXT_FEATURE_FILS_DISCOVERY
))
5136 ret
= nla_parse_nested(tb
, NL80211_FILS_DISCOVERY_ATTR_MAX
, attrs
,
5141 if (!tb
[NL80211_FILS_DISCOVERY_ATTR_INT_MIN
] ||
5142 !tb
[NL80211_FILS_DISCOVERY_ATTR_INT_MAX
] ||
5143 !tb
[NL80211_FILS_DISCOVERY_ATTR_TMPL
])
5146 fd
->tmpl_len
= nla_len(tb
[NL80211_FILS_DISCOVERY_ATTR_TMPL
]);
5147 fd
->tmpl
= nla_data(tb
[NL80211_FILS_DISCOVERY_ATTR_TMPL
]);
5148 fd
->min_interval
= nla_get_u32(tb
[NL80211_FILS_DISCOVERY_ATTR_INT_MIN
]);
5149 fd
->max_interval
= nla_get_u32(tb
[NL80211_FILS_DISCOVERY_ATTR_INT_MAX
]);
5155 nl80211_parse_unsol_bcast_probe_resp(struct cfg80211_registered_device
*rdev
,
5156 struct nlattr
*attrs
,
5157 struct cfg80211_ap_settings
*params
)
5159 struct nlattr
*tb
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX
+ 1];
5161 struct cfg80211_unsol_bcast_probe_resp
*presp
=
5162 ¶ms
->unsol_bcast_probe_resp
;
5164 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
5165 NL80211_EXT_FEATURE_UNSOL_BCAST_PROBE_RESP
))
5168 ret
= nla_parse_nested(tb
, NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_MAX
,
5173 if (!tb
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT
] ||
5174 !tb
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL
])
5177 presp
->tmpl
= nla_data(tb
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL
]);
5178 presp
->tmpl_len
= nla_len(tb
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_TMPL
]);
5179 presp
->interval
= nla_get_u32(tb
[NL80211_UNSOL_BCAST_PROBE_RESP_ATTR_INT
]);
5183 static void nl80211_check_ap_rate_selectors(struct cfg80211_ap_settings
*params
,
5191 for (i
= 0; i
< rates
[1]; i
++) {
5192 if (rates
[2 + i
] == BSS_MEMBERSHIP_SELECTOR_HT_PHY
)
5193 params
->ht_required
= true;
5194 if (rates
[2 + i
] == BSS_MEMBERSHIP_SELECTOR_VHT_PHY
)
5195 params
->vht_required
= true;
5196 if (rates
[2 + i
] == BSS_MEMBERSHIP_SELECTOR_HE_PHY
)
5197 params
->he_required
= true;
5198 if (rates
[2 + i
] == BSS_MEMBERSHIP_SELECTOR_SAE_H2E
)
5199 params
->sae_h2e_required
= true;
5204 * Since the nl80211 API didn't include, from the beginning, attributes about
5205 * HT/VHT requirements/capabilities, we parse them out of the IEs for the
5206 * benefit of drivers that rebuild IEs in the firmware.
5208 static void nl80211_calculate_ap_params(struct cfg80211_ap_settings
*params
)
5210 const struct cfg80211_beacon_data
*bcn
= ¶ms
->beacon
;
5211 size_t ies_len
= bcn
->tail_len
;
5212 const u8
*ies
= bcn
->tail
;
5216 rates
= cfg80211_find_ie(WLAN_EID_SUPP_RATES
, ies
, ies_len
);
5217 nl80211_check_ap_rate_selectors(params
, rates
);
5219 rates
= cfg80211_find_ie(WLAN_EID_EXT_SUPP_RATES
, ies
, ies_len
);
5220 nl80211_check_ap_rate_selectors(params
, rates
);
5222 cap
= cfg80211_find_ie(WLAN_EID_HT_CAPABILITY
, ies
, ies_len
);
5223 if (cap
&& cap
[1] >= sizeof(*params
->ht_cap
))
5224 params
->ht_cap
= (void *)(cap
+ 2);
5225 cap
= cfg80211_find_ie(WLAN_EID_VHT_CAPABILITY
, ies
, ies_len
);
5226 if (cap
&& cap
[1] >= sizeof(*params
->vht_cap
))
5227 params
->vht_cap
= (void *)(cap
+ 2);
5228 cap
= cfg80211_find_ext_ie(WLAN_EID_EXT_HE_CAPABILITY
, ies
, ies_len
);
5229 if (cap
&& cap
[1] >= sizeof(*params
->he_cap
) + 1)
5230 params
->he_cap
= (void *)(cap
+ 3);
5231 cap
= cfg80211_find_ext_ie(WLAN_EID_EXT_HE_OPERATION
, ies
, ies_len
);
5232 if (cap
&& cap
[1] >= sizeof(*params
->he_oper
) + 1)
5233 params
->he_oper
= (void *)(cap
+ 3);
5236 static bool nl80211_get_ap_channel(struct cfg80211_registered_device
*rdev
,
5237 struct cfg80211_ap_settings
*params
)
5239 struct wireless_dev
*wdev
;
5242 list_for_each_entry(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
5243 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
5244 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5247 if (!wdev
->preset_chandef
.chan
)
5250 params
->chandef
= wdev
->preset_chandef
;
5258 static bool nl80211_valid_auth_type(struct cfg80211_registered_device
*rdev
,
5259 enum nl80211_auth_type auth_type
,
5260 enum nl80211_commands cmd
)
5262 if (auth_type
> NL80211_AUTHTYPE_MAX
)
5266 case NL80211_CMD_AUTHENTICATE
:
5267 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_SAE
) &&
5268 auth_type
== NL80211_AUTHTYPE_SAE
)
5270 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
5271 NL80211_EXT_FEATURE_FILS_STA
) &&
5272 (auth_type
== NL80211_AUTHTYPE_FILS_SK
||
5273 auth_type
== NL80211_AUTHTYPE_FILS_SK_PFS
||
5274 auth_type
== NL80211_AUTHTYPE_FILS_PK
))
5277 case NL80211_CMD_CONNECT
:
5278 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_SAE
) &&
5279 !wiphy_ext_feature_isset(&rdev
->wiphy
,
5280 NL80211_EXT_FEATURE_SAE_OFFLOAD
) &&
5281 auth_type
== NL80211_AUTHTYPE_SAE
)
5284 /* FILS with SK PFS or PK not supported yet */
5285 if (auth_type
== NL80211_AUTHTYPE_FILS_SK_PFS
||
5286 auth_type
== NL80211_AUTHTYPE_FILS_PK
)
5288 if (!wiphy_ext_feature_isset(
5290 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD
) &&
5291 auth_type
== NL80211_AUTHTYPE_FILS_SK
)
5294 case NL80211_CMD_START_AP
:
5295 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
5296 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP
) &&
5297 auth_type
== NL80211_AUTHTYPE_SAE
)
5299 /* FILS not supported yet */
5300 if (auth_type
== NL80211_AUTHTYPE_FILS_SK
||
5301 auth_type
== NL80211_AUTHTYPE_FILS_SK_PFS
||
5302 auth_type
== NL80211_AUTHTYPE_FILS_PK
)
5310 static int nl80211_start_ap(struct sk_buff
*skb
, struct genl_info
*info
)
5312 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5313 struct net_device
*dev
= info
->user_ptr
[1];
5314 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
5315 struct cfg80211_ap_settings params
;
5318 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
5319 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5322 if (!rdev
->ops
->start_ap
)
5325 if (wdev
->beacon_interval
)
5328 memset(¶ms
, 0, sizeof(params
));
5330 /* these are required for START_AP */
5331 if (!info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
] ||
5332 !info
->attrs
[NL80211_ATTR_DTIM_PERIOD
] ||
5333 !info
->attrs
[NL80211_ATTR_BEACON_HEAD
])
5336 err
= nl80211_parse_beacon(rdev
, info
->attrs
, ¶ms
.beacon
);
5340 params
.beacon_interval
=
5341 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
5342 params
.dtim_period
=
5343 nla_get_u32(info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]);
5345 err
= cfg80211_validate_beacon_int(rdev
, dev
->ieee80211_ptr
->iftype
,
5346 params
.beacon_interval
);
5351 * In theory, some of these attributes should be required here
5352 * but since they were not used when the command was originally
5353 * added, keep them optional for old user space programs to let
5354 * them continue to work with drivers that do not need the
5355 * additional information -- drivers must check!
5357 if (info
->attrs
[NL80211_ATTR_SSID
]) {
5358 params
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
5360 nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
5361 if (params
.ssid_len
== 0)
5365 if (info
->attrs
[NL80211_ATTR_HIDDEN_SSID
])
5366 params
.hidden_ssid
= nla_get_u32(
5367 info
->attrs
[NL80211_ATTR_HIDDEN_SSID
]);
5369 params
.privacy
= !!info
->attrs
[NL80211_ATTR_PRIVACY
];
5371 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
5372 params
.auth_type
= nla_get_u32(
5373 info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
5374 if (!nl80211_valid_auth_type(rdev
, params
.auth_type
,
5375 NL80211_CMD_START_AP
))
5378 params
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
5380 err
= nl80211_crypto_settings(rdev
, info
, ¶ms
.crypto
,
5381 NL80211_MAX_NR_CIPHER_SUITES
);
5385 if (info
->attrs
[NL80211_ATTR_INACTIVITY_TIMEOUT
]) {
5386 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_INACTIVITY_TIMER
))
5388 params
.inactivity_timeout
= nla_get_u16(
5389 info
->attrs
[NL80211_ATTR_INACTIVITY_TIMEOUT
]);
5392 if (info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]) {
5393 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5395 params
.p2p_ctwindow
=
5396 nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]);
5397 if (params
.p2p_ctwindow
!= 0 &&
5398 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_CTWIN
))
5402 if (info
->attrs
[NL80211_ATTR_P2P_OPPPS
]) {
5405 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5407 tmp
= nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_OPPPS
]);
5408 params
.p2p_opp_ps
= tmp
;
5409 if (params
.p2p_opp_ps
!= 0 &&
5410 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_OPPPS
))
5414 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
5415 err
= nl80211_parse_chandef(rdev
, info
, ¶ms
.chandef
);
5418 } else if (wdev
->preset_chandef
.chan
) {
5419 params
.chandef
= wdev
->preset_chandef
;
5420 } else if (!nl80211_get_ap_channel(rdev
, ¶ms
))
5423 if (!cfg80211_reg_can_beacon_relax(&rdev
->wiphy
, ¶ms
.chandef
,
5427 if (info
->attrs
[NL80211_ATTR_TX_RATES
]) {
5428 err
= nl80211_parse_tx_bitrate_mask(info
, info
->attrs
,
5429 NL80211_ATTR_TX_RATES
,
5430 ¶ms
.beacon_rate
,
5435 err
= validate_beacon_tx_rate(rdev
, params
.chandef
.chan
->band
,
5436 ¶ms
.beacon_rate
);
5441 if (info
->attrs
[NL80211_ATTR_SMPS_MODE
]) {
5443 nla_get_u8(info
->attrs
[NL80211_ATTR_SMPS_MODE
]);
5444 switch (params
.smps_mode
) {
5445 case NL80211_SMPS_OFF
:
5447 case NL80211_SMPS_STATIC
:
5448 if (!(rdev
->wiphy
.features
&
5449 NL80211_FEATURE_STATIC_SMPS
))
5452 case NL80211_SMPS_DYNAMIC
:
5453 if (!(rdev
->wiphy
.features
&
5454 NL80211_FEATURE_DYNAMIC_SMPS
))
5461 params
.smps_mode
= NL80211_SMPS_OFF
;
5464 params
.pbss
= nla_get_flag(info
->attrs
[NL80211_ATTR_PBSS
]);
5465 if (params
.pbss
&& !rdev
->wiphy
.bands
[NL80211_BAND_60GHZ
])
5468 if (info
->attrs
[NL80211_ATTR_ACL_POLICY
]) {
5469 params
.acl
= parse_acl_data(&rdev
->wiphy
, info
);
5470 if (IS_ERR(params
.acl
))
5471 return PTR_ERR(params
.acl
);
5474 params
.twt_responder
=
5475 nla_get_flag(info
->attrs
[NL80211_ATTR_TWT_RESPONDER
]);
5477 if (info
->attrs
[NL80211_ATTR_HE_OBSS_PD
]) {
5478 err
= nl80211_parse_he_obss_pd(
5479 info
->attrs
[NL80211_ATTR_HE_OBSS_PD
],
5480 ¶ms
.he_obss_pd
);
5485 if (info
->attrs
[NL80211_ATTR_HE_BSS_COLOR
]) {
5486 err
= nl80211_parse_he_bss_color(
5487 info
->attrs
[NL80211_ATTR_HE_BSS_COLOR
],
5488 ¶ms
.he_bss_color
);
5493 if (info
->attrs
[NL80211_ATTR_FILS_DISCOVERY
]) {
5494 err
= nl80211_parse_fils_discovery(rdev
,
5495 info
->attrs
[NL80211_ATTR_FILS_DISCOVERY
],
5501 if (info
->attrs
[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP
]) {
5502 err
= nl80211_parse_unsol_bcast_probe_resp(
5503 rdev
, info
->attrs
[NL80211_ATTR_UNSOL_BCAST_PROBE_RESP
],
5509 nl80211_calculate_ap_params(¶ms
);
5511 if (info
->attrs
[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT
])
5512 params
.flags
|= AP_SETTINGS_EXTERNAL_AUTH_SUPPORT
;
5515 err
= rdev_start_ap(rdev
, dev
, ¶ms
);
5517 wdev
->preset_chandef
= params
.chandef
;
5518 wdev
->beacon_interval
= params
.beacon_interval
;
5519 wdev
->chandef
= params
.chandef
;
5520 wdev
->ssid_len
= params
.ssid_len
;
5521 memcpy(wdev
->ssid
, params
.ssid
, wdev
->ssid_len
);
5523 if (info
->attrs
[NL80211_ATTR_SOCKET_OWNER
])
5524 wdev
->conn_owner_nlportid
= info
->snd_portid
;
5534 static int nl80211_set_beacon(struct sk_buff
*skb
, struct genl_info
*info
)
5536 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5537 struct net_device
*dev
= info
->user_ptr
[1];
5538 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
5539 struct cfg80211_beacon_data params
;
5542 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
5543 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
5546 if (!rdev
->ops
->change_beacon
)
5549 if (!wdev
->beacon_interval
)
5552 err
= nl80211_parse_beacon(rdev
, info
->attrs
, ¶ms
);
5557 err
= rdev_change_beacon(rdev
, dev
, ¶ms
);
5563 static int nl80211_stop_ap(struct sk_buff
*skb
, struct genl_info
*info
)
5565 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5566 struct net_device
*dev
= info
->user_ptr
[1];
5568 return cfg80211_stop_ap(rdev
, dev
, false);
5571 static const struct nla_policy sta_flags_policy
[NL80211_STA_FLAG_MAX
+ 1] = {
5572 [NL80211_STA_FLAG_AUTHORIZED
] = { .type
= NLA_FLAG
},
5573 [NL80211_STA_FLAG_SHORT_PREAMBLE
] = { .type
= NLA_FLAG
},
5574 [NL80211_STA_FLAG_WME
] = { .type
= NLA_FLAG
},
5575 [NL80211_STA_FLAG_MFP
] = { .type
= NLA_FLAG
},
5576 [NL80211_STA_FLAG_AUTHENTICATED
] = { .type
= NLA_FLAG
},
5577 [NL80211_STA_FLAG_TDLS_PEER
] = { .type
= NLA_FLAG
},
5580 static int parse_station_flags(struct genl_info
*info
,
5581 enum nl80211_iftype iftype
,
5582 struct station_parameters
*params
)
5584 struct nlattr
*flags
[NL80211_STA_FLAG_MAX
+ 1];
5589 * Try parsing the new attribute first so userspace
5590 * can specify both for older kernels.
5592 nla
= info
->attrs
[NL80211_ATTR_STA_FLAGS2
];
5594 struct nl80211_sta_flag_update
*sta_flags
;
5596 sta_flags
= nla_data(nla
);
5597 params
->sta_flags_mask
= sta_flags
->mask
;
5598 params
->sta_flags_set
= sta_flags
->set
;
5599 params
->sta_flags_set
&= params
->sta_flags_mask
;
5600 if ((params
->sta_flags_mask
|
5601 params
->sta_flags_set
) & BIT(__NL80211_STA_FLAG_INVALID
))
5606 /* if present, parse the old attribute */
5608 nla
= info
->attrs
[NL80211_ATTR_STA_FLAGS
];
5612 if (nla_parse_nested_deprecated(flags
, NL80211_STA_FLAG_MAX
, nla
, sta_flags_policy
, info
->extack
))
5616 * Only allow certain flags for interface types so that
5617 * other attributes are silently ignored. Remember that
5618 * this is backward compatibility code with old userspace
5619 * and shouldn't be hit in other cases anyway.
5622 case NL80211_IFTYPE_AP
:
5623 case NL80211_IFTYPE_AP_VLAN
:
5624 case NL80211_IFTYPE_P2P_GO
:
5625 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
) |
5626 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
) |
5627 BIT(NL80211_STA_FLAG_WME
) |
5628 BIT(NL80211_STA_FLAG_MFP
);
5630 case NL80211_IFTYPE_P2P_CLIENT
:
5631 case NL80211_IFTYPE_STATION
:
5632 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
) |
5633 BIT(NL80211_STA_FLAG_TDLS_PEER
);
5635 case NL80211_IFTYPE_MESH_POINT
:
5636 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
5637 BIT(NL80211_STA_FLAG_MFP
) |
5638 BIT(NL80211_STA_FLAG_AUTHORIZED
);
5644 for (flag
= 1; flag
<= NL80211_STA_FLAG_MAX
; flag
++) {
5646 params
->sta_flags_set
|= (1<<flag
);
5648 /* no longer support new API additions in old API */
5649 if (flag
> NL80211_STA_FLAG_MAX_OLD_API
)
5657 bool nl80211_put_sta_rate(struct sk_buff
*msg
, struct rate_info
*info
, int attr
)
5659 struct nlattr
*rate
;
5662 enum nl80211_rate_info rate_flg
;
5664 rate
= nla_nest_start_noflag(msg
, attr
);
5668 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
5669 bitrate
= cfg80211_calculate_bitrate(info
);
5670 /* report 16-bit bitrate only if we can */
5671 bitrate_compat
= bitrate
< (1UL << 16) ? bitrate
: 0;
5673 nla_put_u32(msg
, NL80211_RATE_INFO_BITRATE32
, bitrate
))
5675 if (bitrate_compat
> 0 &&
5676 nla_put_u16(msg
, NL80211_RATE_INFO_BITRATE
, bitrate_compat
))
5680 case RATE_INFO_BW_5
:
5681 rate_flg
= NL80211_RATE_INFO_5_MHZ_WIDTH
;
5683 case RATE_INFO_BW_10
:
5684 rate_flg
= NL80211_RATE_INFO_10_MHZ_WIDTH
;
5689 case RATE_INFO_BW_20
:
5692 case RATE_INFO_BW_40
:
5693 rate_flg
= NL80211_RATE_INFO_40_MHZ_WIDTH
;
5695 case RATE_INFO_BW_80
:
5696 rate_flg
= NL80211_RATE_INFO_80_MHZ_WIDTH
;
5698 case RATE_INFO_BW_160
:
5699 rate_flg
= NL80211_RATE_INFO_160_MHZ_WIDTH
;
5701 case RATE_INFO_BW_HE_RU
:
5703 WARN_ON(!(info
->flags
& RATE_INFO_FLAGS_HE_MCS
));
5706 if (rate_flg
&& nla_put_flag(msg
, rate_flg
))
5709 if (info
->flags
& RATE_INFO_FLAGS_MCS
) {
5710 if (nla_put_u8(msg
, NL80211_RATE_INFO_MCS
, info
->mcs
))
5712 if (info
->flags
& RATE_INFO_FLAGS_SHORT_GI
&&
5713 nla_put_flag(msg
, NL80211_RATE_INFO_SHORT_GI
))
5715 } else if (info
->flags
& RATE_INFO_FLAGS_VHT_MCS
) {
5716 if (nla_put_u8(msg
, NL80211_RATE_INFO_VHT_MCS
, info
->mcs
))
5718 if (nla_put_u8(msg
, NL80211_RATE_INFO_VHT_NSS
, info
->nss
))
5720 if (info
->flags
& RATE_INFO_FLAGS_SHORT_GI
&&
5721 nla_put_flag(msg
, NL80211_RATE_INFO_SHORT_GI
))
5723 } else if (info
->flags
& RATE_INFO_FLAGS_HE_MCS
) {
5724 if (nla_put_u8(msg
, NL80211_RATE_INFO_HE_MCS
, info
->mcs
))
5726 if (nla_put_u8(msg
, NL80211_RATE_INFO_HE_NSS
, info
->nss
))
5728 if (nla_put_u8(msg
, NL80211_RATE_INFO_HE_GI
, info
->he_gi
))
5730 if (nla_put_u8(msg
, NL80211_RATE_INFO_HE_DCM
, info
->he_dcm
))
5732 if (info
->bw
== RATE_INFO_BW_HE_RU
&&
5733 nla_put_u8(msg
, NL80211_RATE_INFO_HE_RU_ALLOC
,
5738 nla_nest_end(msg
, rate
);
5742 static bool nl80211_put_signal(struct sk_buff
*msg
, u8 mask
, s8
*signal
,
5751 attr
= nla_nest_start_noflag(msg
, id
);
5755 for (i
= 0; i
< IEEE80211_MAX_CHAINS
; i
++) {
5756 if (!(mask
& BIT(i
)))
5759 if (nla_put_u8(msg
, i
, signal
[i
]))
5763 nla_nest_end(msg
, attr
);
5768 static int nl80211_send_station(struct sk_buff
*msg
, u32 cmd
, u32 portid
,
5770 struct cfg80211_registered_device
*rdev
,
5771 struct net_device
*dev
,
5772 const u8
*mac_addr
, struct station_info
*sinfo
)
5775 struct nlattr
*sinfoattr
, *bss_param
;
5777 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, cmd
);
5779 cfg80211_sinfo_release_content(sinfo
);
5783 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
5784 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
) ||
5785 nla_put_u32(msg
, NL80211_ATTR_GENERATION
, sinfo
->generation
))
5786 goto nla_put_failure
;
5788 sinfoattr
= nla_nest_start_noflag(msg
, NL80211_ATTR_STA_INFO
);
5790 goto nla_put_failure
;
5792 #define PUT_SINFO(attr, memb, type) do { \
5793 BUILD_BUG_ON(sizeof(type) == sizeof(u64)); \
5794 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5795 nla_put_ ## type(msg, NL80211_STA_INFO_ ## attr, \
5797 goto nla_put_failure; \
5799 #define PUT_SINFO_U64(attr, memb) do { \
5800 if (sinfo->filled & BIT_ULL(NL80211_STA_INFO_ ## attr) && \
5801 nla_put_u64_64bit(msg, NL80211_STA_INFO_ ## attr, \
5802 sinfo->memb, NL80211_STA_INFO_PAD)) \
5803 goto nla_put_failure; \
5806 PUT_SINFO(CONNECTED_TIME
, connected_time
, u32
);
5807 PUT_SINFO(INACTIVE_TIME
, inactive_time
, u32
);
5808 PUT_SINFO_U64(ASSOC_AT_BOOTTIME
, assoc_at
);
5810 if (sinfo
->filled
& (BIT_ULL(NL80211_STA_INFO_RX_BYTES
) |
5811 BIT_ULL(NL80211_STA_INFO_RX_BYTES64
)) &&
5812 nla_put_u32(msg
, NL80211_STA_INFO_RX_BYTES
,
5813 (u32
)sinfo
->rx_bytes
))
5814 goto nla_put_failure
;
5816 if (sinfo
->filled
& (BIT_ULL(NL80211_STA_INFO_TX_BYTES
) |
5817 BIT_ULL(NL80211_STA_INFO_TX_BYTES64
)) &&
5818 nla_put_u32(msg
, NL80211_STA_INFO_TX_BYTES
,
5819 (u32
)sinfo
->tx_bytes
))
5820 goto nla_put_failure
;
5822 PUT_SINFO_U64(RX_BYTES64
, rx_bytes
);
5823 PUT_SINFO_U64(TX_BYTES64
, tx_bytes
);
5824 PUT_SINFO(LLID
, llid
, u16
);
5825 PUT_SINFO(PLID
, plid
, u16
);
5826 PUT_SINFO(PLINK_STATE
, plink_state
, u8
);
5827 PUT_SINFO_U64(RX_DURATION
, rx_duration
);
5828 PUT_SINFO_U64(TX_DURATION
, tx_duration
);
5830 if (wiphy_ext_feature_isset(&rdev
->wiphy
,
5831 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS
))
5832 PUT_SINFO(AIRTIME_WEIGHT
, airtime_weight
, u16
);
5834 switch (rdev
->wiphy
.signal_type
) {
5835 case CFG80211_SIGNAL_TYPE_MBM
:
5836 PUT_SINFO(SIGNAL
, signal
, u8
);
5837 PUT_SINFO(SIGNAL_AVG
, signal_avg
, u8
);
5842 if (sinfo
->filled
& BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL
)) {
5843 if (!nl80211_put_signal(msg
, sinfo
->chains
,
5844 sinfo
->chain_signal
,
5845 NL80211_STA_INFO_CHAIN_SIGNAL
))
5846 goto nla_put_failure
;
5848 if (sinfo
->filled
& BIT_ULL(NL80211_STA_INFO_CHAIN_SIGNAL_AVG
)) {
5849 if (!nl80211_put_signal(msg
, sinfo
->chains
,
5850 sinfo
->chain_signal_avg
,
5851 NL80211_STA_INFO_CHAIN_SIGNAL_AVG
))
5852 goto nla_put_failure
;
5854 if (sinfo
->filled
& BIT_ULL(NL80211_STA_INFO_TX_BITRATE
)) {
5855 if (!nl80211_put_sta_rate(msg
, &sinfo
->txrate
,
5856 NL80211_STA_INFO_TX_BITRATE
))
5857 goto nla_put_failure
;
5859 if (sinfo
->filled
& BIT_ULL(NL80211_STA_INFO_RX_BITRATE
)) {
5860 if (!nl80211_put_sta_rate(msg
, &sinfo
->rxrate
,
5861 NL80211_STA_INFO_RX_BITRATE
))
5862 goto nla_put_failure
;
5865 PUT_SINFO(RX_PACKETS
, rx_packets
, u32
);
5866 PUT_SINFO(TX_PACKETS
, tx_packets
, u32
);
5867 PUT_SINFO(TX_RETRIES
, tx_retries
, u32
);
5868 PUT_SINFO(TX_FAILED
, tx_failed
, u32
);
5869 PUT_SINFO(EXPECTED_THROUGHPUT
, expected_throughput
, u32
);
5870 PUT_SINFO(AIRTIME_LINK_METRIC
, airtime_link_metric
, u32
);
5871 PUT_SINFO(BEACON_LOSS
, beacon_loss_count
, u32
);
5872 PUT_SINFO(LOCAL_PM
, local_pm
, u32
);
5873 PUT_SINFO(PEER_PM
, peer_pm
, u32
);
5874 PUT_SINFO(NONPEER_PM
, nonpeer_pm
, u32
);
5875 PUT_SINFO(CONNECTED_TO_GATE
, connected_to_gate
, u8
);
5876 PUT_SINFO(CONNECTED_TO_AS
, connected_to_as
, u8
);
5878 if (sinfo
->filled
& BIT_ULL(NL80211_STA_INFO_BSS_PARAM
)) {
5879 bss_param
= nla_nest_start_noflag(msg
,
5880 NL80211_STA_INFO_BSS_PARAM
);
5882 goto nla_put_failure
;
5884 if (((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_CTS_PROT
) &&
5885 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_CTS_PROT
)) ||
5886 ((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_SHORT_PREAMBLE
) &&
5887 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE
)) ||
5888 ((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_SHORT_SLOT_TIME
) &&
5889 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME
)) ||
5890 nla_put_u8(msg
, NL80211_STA_BSS_PARAM_DTIM_PERIOD
,
5891 sinfo
->bss_param
.dtim_period
) ||
5892 nla_put_u16(msg
, NL80211_STA_BSS_PARAM_BEACON_INTERVAL
,
5893 sinfo
->bss_param
.beacon_interval
))
5894 goto nla_put_failure
;
5896 nla_nest_end(msg
, bss_param
);
5898 if ((sinfo
->filled
& BIT_ULL(NL80211_STA_INFO_STA_FLAGS
)) &&
5899 nla_put(msg
, NL80211_STA_INFO_STA_FLAGS
,
5900 sizeof(struct nl80211_sta_flag_update
),
5902 goto nla_put_failure
;
5904 PUT_SINFO_U64(T_OFFSET
, t_offset
);
5905 PUT_SINFO_U64(RX_DROP_MISC
, rx_dropped_misc
);
5906 PUT_SINFO_U64(BEACON_RX
, rx_beacon
);
5907 PUT_SINFO(BEACON_SIGNAL_AVG
, rx_beacon_signal_avg
, u8
);
5908 PUT_SINFO(RX_MPDUS
, rx_mpdu_count
, u32
);
5909 PUT_SINFO(FCS_ERROR_COUNT
, fcs_err_count
, u32
);
5910 if (wiphy_ext_feature_isset(&rdev
->wiphy
,
5911 NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT
)) {
5912 PUT_SINFO(ACK_SIGNAL
, ack_signal
, u8
);
5913 PUT_SINFO(ACK_SIGNAL_AVG
, avg_ack_signal
, s8
);
5917 #undef PUT_SINFO_U64
5919 if (sinfo
->pertid
) {
5920 struct nlattr
*tidsattr
;
5923 tidsattr
= nla_nest_start_noflag(msg
,
5924 NL80211_STA_INFO_TID_STATS
);
5926 goto nla_put_failure
;
5928 for (tid
= 0; tid
< IEEE80211_NUM_TIDS
+ 1; tid
++) {
5929 struct cfg80211_tid_stats
*tidstats
;
5930 struct nlattr
*tidattr
;
5932 tidstats
= &sinfo
->pertid
[tid
];
5934 if (!tidstats
->filled
)
5937 tidattr
= nla_nest_start_noflag(msg
, tid
+ 1);
5939 goto nla_put_failure
;
5941 #define PUT_TIDVAL_U64(attr, memb) do { \
5942 if (tidstats->filled & BIT(NL80211_TID_STATS_ ## attr) && \
5943 nla_put_u64_64bit(msg, NL80211_TID_STATS_ ## attr, \
5944 tidstats->memb, NL80211_TID_STATS_PAD)) \
5945 goto nla_put_failure; \
5948 PUT_TIDVAL_U64(RX_MSDU
, rx_msdu
);
5949 PUT_TIDVAL_U64(TX_MSDU
, tx_msdu
);
5950 PUT_TIDVAL_U64(TX_MSDU_RETRIES
, tx_msdu_retries
);
5951 PUT_TIDVAL_U64(TX_MSDU_FAILED
, tx_msdu_failed
);
5953 #undef PUT_TIDVAL_U64
5954 if ((tidstats
->filled
&
5955 BIT(NL80211_TID_STATS_TXQ_STATS
)) &&
5956 !nl80211_put_txq_stats(msg
, &tidstats
->txq_stats
,
5957 NL80211_TID_STATS_TXQ_STATS
))
5958 goto nla_put_failure
;
5960 nla_nest_end(msg
, tidattr
);
5963 nla_nest_end(msg
, tidsattr
);
5966 nla_nest_end(msg
, sinfoattr
);
5968 if (sinfo
->assoc_req_ies_len
&&
5969 nla_put(msg
, NL80211_ATTR_IE
, sinfo
->assoc_req_ies_len
,
5970 sinfo
->assoc_req_ies
))
5971 goto nla_put_failure
;
5973 cfg80211_sinfo_release_content(sinfo
);
5974 genlmsg_end(msg
, hdr
);
5978 cfg80211_sinfo_release_content(sinfo
);
5979 genlmsg_cancel(msg
, hdr
);
5983 static int nl80211_dump_station(struct sk_buff
*skb
,
5984 struct netlink_callback
*cb
)
5986 struct station_info sinfo
;
5987 struct cfg80211_registered_device
*rdev
;
5988 struct wireless_dev
*wdev
;
5989 u8 mac_addr
[ETH_ALEN
];
5990 int sta_idx
= cb
->args
[2];
5993 err
= nl80211_prepare_wdev_dump(cb
, &rdev
, &wdev
);
5996 /* nl80211_prepare_wdev_dump acquired it in the successful case */
5997 __acquire(&rdev
->wiphy
.mtx
);
5999 if (!wdev
->netdev
) {
6004 if (!rdev
->ops
->dump_station
) {
6010 memset(&sinfo
, 0, sizeof(sinfo
));
6011 err
= rdev_dump_station(rdev
, wdev
->netdev
, sta_idx
,
6018 if (nl80211_send_station(skb
, NL80211_CMD_NEW_STATION
,
6019 NETLINK_CB(cb
->skb
).portid
,
6020 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
6021 rdev
, wdev
->netdev
, mac_addr
,
6029 cb
->args
[2] = sta_idx
;
6032 wiphy_unlock(&rdev
->wiphy
);
6037 static int nl80211_get_station(struct sk_buff
*skb
, struct genl_info
*info
)
6039 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6040 struct net_device
*dev
= info
->user_ptr
[1];
6041 struct station_info sinfo
;
6042 struct sk_buff
*msg
;
6043 u8
*mac_addr
= NULL
;
6046 memset(&sinfo
, 0, sizeof(sinfo
));
6048 if (!info
->attrs
[NL80211_ATTR_MAC
])
6051 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6053 if (!rdev
->ops
->get_station
)
6056 err
= rdev_get_station(rdev
, dev
, mac_addr
, &sinfo
);
6060 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
6062 cfg80211_sinfo_release_content(&sinfo
);
6066 if (nl80211_send_station(msg
, NL80211_CMD_NEW_STATION
,
6067 info
->snd_portid
, info
->snd_seq
, 0,
6068 rdev
, dev
, mac_addr
, &sinfo
) < 0) {
6073 return genlmsg_reply(msg
, info
);
6076 int cfg80211_check_station_change(struct wiphy
*wiphy
,
6077 struct station_parameters
*params
,
6078 enum cfg80211_station_type statype
)
6080 if (params
->listen_interval
!= -1 &&
6081 statype
!= CFG80211_STA_AP_CLIENT_UNASSOC
)
6084 if (params
->support_p2p_ps
!= -1 &&
6085 statype
!= CFG80211_STA_AP_CLIENT_UNASSOC
)
6089 !(params
->sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)) &&
6090 statype
!= CFG80211_STA_AP_CLIENT_UNASSOC
)
6093 /* When you run into this, adjust the code below for the new flag */
6094 BUILD_BUG_ON(NL80211_STA_FLAG_MAX
!= 7);
6097 case CFG80211_STA_MESH_PEER_KERNEL
:
6098 case CFG80211_STA_MESH_PEER_USER
:
6100 * No ignoring the TDLS flag here -- the userspace mesh
6101 * code doesn't have the bug of including TDLS in the
6104 if (params
->sta_flags_mask
&
6105 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
6106 BIT(NL80211_STA_FLAG_MFP
) |
6107 BIT(NL80211_STA_FLAG_AUTHORIZED
)))
6110 case CFG80211_STA_TDLS_PEER_SETUP
:
6111 case CFG80211_STA_TDLS_PEER_ACTIVE
:
6112 if (!(params
->sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)))
6114 /* ignore since it can't change */
6115 params
->sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
6118 /* disallow mesh-specific things */
6119 if (params
->plink_action
!= NL80211_PLINK_ACTION_NO_ACTION
)
6121 if (params
->local_pm
)
6123 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_PLINK_STATE
)
6127 if (statype
!= CFG80211_STA_TDLS_PEER_SETUP
&&
6128 statype
!= CFG80211_STA_TDLS_PEER_ACTIVE
) {
6129 /* TDLS can't be set, ... */
6130 if (params
->sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
))
6133 * ... but don't bother the driver with it. This works around
6134 * a hostapd/wpa_supplicant issue -- it always includes the
6135 * TLDS_PEER flag in the mask even for AP mode.
6137 params
->sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
6140 if (statype
!= CFG80211_STA_TDLS_PEER_SETUP
&&
6141 statype
!= CFG80211_STA_AP_CLIENT_UNASSOC
) {
6142 /* reject other things that can't change */
6143 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_UAPSD
)
6145 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_CAPABILITY
)
6147 if (params
->supported_rates
)
6149 if (params
->ext_capab
|| params
->ht_capa
|| params
->vht_capa
||
6154 if (statype
!= CFG80211_STA_AP_CLIENT
&&
6155 statype
!= CFG80211_STA_AP_CLIENT_UNASSOC
) {
6161 case CFG80211_STA_AP_MLME_CLIENT
:
6162 /* Use this only for authorizing/unauthorizing a station */
6163 if (!(params
->sta_flags_mask
& BIT(NL80211_STA_FLAG_AUTHORIZED
)))
6166 case CFG80211_STA_AP_CLIENT
:
6167 case CFG80211_STA_AP_CLIENT_UNASSOC
:
6168 /* accept only the listed bits */
6169 if (params
->sta_flags_mask
&
6170 ~(BIT(NL80211_STA_FLAG_AUTHORIZED
) |
6171 BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
6172 BIT(NL80211_STA_FLAG_ASSOCIATED
) |
6173 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
) |
6174 BIT(NL80211_STA_FLAG_WME
) |
6175 BIT(NL80211_STA_FLAG_MFP
)))
6178 /* but authenticated/associated only if driver handles it */
6179 if (!(wiphy
->features
& NL80211_FEATURE_FULL_AP_CLIENT_STATE
) &&
6180 params
->sta_flags_mask
&
6181 (BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
6182 BIT(NL80211_STA_FLAG_ASSOCIATED
)))
6185 case CFG80211_STA_IBSS
:
6186 case CFG80211_STA_AP_STA
:
6187 /* reject any changes other than AUTHORIZED */
6188 if (params
->sta_flags_mask
& ~BIT(NL80211_STA_FLAG_AUTHORIZED
))
6191 case CFG80211_STA_TDLS_PEER_SETUP
:
6192 /* reject any changes other than AUTHORIZED or WME */
6193 if (params
->sta_flags_mask
& ~(BIT(NL80211_STA_FLAG_AUTHORIZED
) |
6194 BIT(NL80211_STA_FLAG_WME
)))
6196 /* force (at least) rates when authorizing */
6197 if (params
->sta_flags_set
& BIT(NL80211_STA_FLAG_AUTHORIZED
) &&
6198 !params
->supported_rates
)
6201 case CFG80211_STA_TDLS_PEER_ACTIVE
:
6202 /* reject any changes */
6204 case CFG80211_STA_MESH_PEER_KERNEL
:
6205 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_PLINK_STATE
)
6208 case CFG80211_STA_MESH_PEER_USER
:
6209 if (params
->plink_action
!= NL80211_PLINK_ACTION_NO_ACTION
&&
6210 params
->plink_action
!= NL80211_PLINK_ACTION_BLOCK
)
6216 * Older kernel versions ignored this attribute entirely, so don't
6217 * reject attempts to update it but mark it as unused instead so the
6218 * driver won't look at the data.
6220 if (statype
!= CFG80211_STA_AP_CLIENT_UNASSOC
&&
6221 statype
!= CFG80211_STA_TDLS_PEER_SETUP
)
6222 params
->opmode_notif_used
= false;
6226 EXPORT_SYMBOL(cfg80211_check_station_change
);
6229 * Get vlan interface making sure it is running and on the right wiphy.
6231 static struct net_device
*get_vlan(struct genl_info
*info
,
6232 struct cfg80211_registered_device
*rdev
)
6234 struct nlattr
*vlanattr
= info
->attrs
[NL80211_ATTR_STA_VLAN
];
6235 struct net_device
*v
;
6241 v
= dev_get_by_index(genl_info_net(info
), nla_get_u32(vlanattr
));
6243 return ERR_PTR(-ENODEV
);
6245 if (!v
->ieee80211_ptr
|| v
->ieee80211_ptr
->wiphy
!= &rdev
->wiphy
) {
6250 if (v
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
6251 v
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
6252 v
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
) {
6257 if (!netif_running(v
)) {
6265 return ERR_PTR(ret
);
6268 static const struct nla_policy
6269 nl80211_sta_wme_policy
[NL80211_STA_WME_MAX
+ 1] = {
6270 [NL80211_STA_WME_UAPSD_QUEUES
] = { .type
= NLA_U8
},
6271 [NL80211_STA_WME_MAX_SP
] = { .type
= NLA_U8
},
6274 static int nl80211_parse_sta_wme(struct genl_info
*info
,
6275 struct station_parameters
*params
)
6277 struct nlattr
*tb
[NL80211_STA_WME_MAX
+ 1];
6281 /* parse WME attributes if present */
6282 if (!info
->attrs
[NL80211_ATTR_STA_WME
])
6285 nla
= info
->attrs
[NL80211_ATTR_STA_WME
];
6286 err
= nla_parse_nested_deprecated(tb
, NL80211_STA_WME_MAX
, nla
,
6287 nl80211_sta_wme_policy
,
6292 if (tb
[NL80211_STA_WME_UAPSD_QUEUES
])
6293 params
->uapsd_queues
= nla_get_u8(
6294 tb
[NL80211_STA_WME_UAPSD_QUEUES
]);
6295 if (params
->uapsd_queues
& ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK
)
6298 if (tb
[NL80211_STA_WME_MAX_SP
])
6299 params
->max_sp
= nla_get_u8(tb
[NL80211_STA_WME_MAX_SP
]);
6301 if (params
->max_sp
& ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK
)
6304 params
->sta_modify_mask
|= STATION_PARAM_APPLY_UAPSD
;
6309 static int nl80211_parse_sta_channel_info(struct genl_info
*info
,
6310 struct station_parameters
*params
)
6312 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_CHANNELS
]) {
6313 params
->supported_channels
=
6314 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_CHANNELS
]);
6315 params
->supported_channels_len
=
6316 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_CHANNELS
]);
6318 * Need to include at least one (first channel, number of
6319 * channels) tuple for each subband (checked in policy),
6320 * and must have proper tuples for the rest of the data as well.
6322 if (params
->supported_channels_len
% 2)
6326 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
]) {
6327 params
->supported_oper_classes
=
6328 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
]);
6329 params
->supported_oper_classes_len
=
6330 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
]);
6335 static int nl80211_set_station_tdls(struct genl_info
*info
,
6336 struct station_parameters
*params
)
6339 /* Dummy STA entry gets updated once the peer capabilities are known */
6340 if (info
->attrs
[NL80211_ATTR_PEER_AID
])
6341 params
->aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_PEER_AID
]);
6342 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
])
6344 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
6345 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
])
6347 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]);
6348 if (info
->attrs
[NL80211_ATTR_HE_CAPABILITY
]) {
6350 nla_data(info
->attrs
[NL80211_ATTR_HE_CAPABILITY
]);
6351 params
->he_capa_len
=
6352 nla_len(info
->attrs
[NL80211_ATTR_HE_CAPABILITY
]);
6355 err
= nl80211_parse_sta_channel_info(info
, params
);
6359 return nl80211_parse_sta_wme(info
, params
);
6362 static int nl80211_parse_sta_txpower_setting(struct genl_info
*info
,
6363 struct station_parameters
*params
)
6365 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6368 if (info
->attrs
[NL80211_ATTR_STA_TX_POWER_SETTING
]) {
6369 if (!rdev
->ops
->set_tx_power
||
6370 !wiphy_ext_feature_isset(&rdev
->wiphy
,
6371 NL80211_EXT_FEATURE_STA_TX_PWR
))
6374 idx
= NL80211_ATTR_STA_TX_POWER_SETTING
;
6375 params
->txpwr
.type
= nla_get_u8(info
->attrs
[idx
]);
6377 if (params
->txpwr
.type
== NL80211_TX_POWER_LIMITED
) {
6378 idx
= NL80211_ATTR_STA_TX_POWER
;
6380 if (info
->attrs
[idx
])
6381 params
->txpwr
.power
=
6382 nla_get_s16(info
->attrs
[idx
]);
6386 params
->sta_modify_mask
|= STATION_PARAM_APPLY_STA_TXPOWER
;
6392 static int nl80211_set_station(struct sk_buff
*skb
, struct genl_info
*info
)
6394 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6395 struct net_device
*dev
= info
->user_ptr
[1];
6396 struct station_parameters params
;
6400 memset(¶ms
, 0, sizeof(params
));
6402 if (!rdev
->ops
->change_station
)
6406 * AID and listen_interval properties can be set only for unassociated
6407 * station. Include these parameters here and will check them in
6408 * cfg80211_check_station_change().
6410 if (info
->attrs
[NL80211_ATTR_STA_AID
])
6411 params
.aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_STA_AID
]);
6413 if (info
->attrs
[NL80211_ATTR_VLAN_ID
])
6414 params
.vlan_id
= nla_get_u16(info
->attrs
[NL80211_ATTR_VLAN_ID
]);
6416 if (info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
])
6417 params
.listen_interval
=
6418 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
]);
6420 params
.listen_interval
= -1;
6422 if (info
->attrs
[NL80211_ATTR_STA_SUPPORT_P2P_PS
])
6423 params
.support_p2p_ps
=
6424 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_SUPPORT_P2P_PS
]);
6426 params
.support_p2p_ps
= -1;
6428 if (!info
->attrs
[NL80211_ATTR_MAC
])
6431 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6433 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]) {
6434 params
.supported_rates
=
6435 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
6436 params
.supported_rates_len
=
6437 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
6440 if (info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]) {
6442 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]);
6443 params
.sta_modify_mask
|= STATION_PARAM_APPLY_CAPABILITY
;
6446 if (info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]) {
6448 nla_data(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
6449 params
.ext_capab_len
=
6450 nla_len(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
6453 if (parse_station_flags(info
, dev
->ieee80211_ptr
->iftype
, ¶ms
))
6456 if (info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
])
6457 params
.plink_action
=
6458 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]);
6460 if (info
->attrs
[NL80211_ATTR_STA_PLINK_STATE
]) {
6461 params
.plink_state
=
6462 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_STATE
]);
6463 if (info
->attrs
[NL80211_ATTR_MESH_PEER_AID
])
6464 params
.peer_aid
= nla_get_u16(
6465 info
->attrs
[NL80211_ATTR_MESH_PEER_AID
]);
6466 params
.sta_modify_mask
|= STATION_PARAM_APPLY_PLINK_STATE
;
6469 if (info
->attrs
[NL80211_ATTR_LOCAL_MESH_POWER_MODE
])
6470 params
.local_pm
= nla_get_u32(
6471 info
->attrs
[NL80211_ATTR_LOCAL_MESH_POWER_MODE
]);
6473 if (info
->attrs
[NL80211_ATTR_OPMODE_NOTIF
]) {
6474 params
.opmode_notif_used
= true;
6475 params
.opmode_notif
=
6476 nla_get_u8(info
->attrs
[NL80211_ATTR_OPMODE_NOTIF
]);
6479 if (info
->attrs
[NL80211_ATTR_HE_6GHZ_CAPABILITY
])
6480 params
.he_6ghz_capa
=
6481 nla_data(info
->attrs
[NL80211_ATTR_HE_6GHZ_CAPABILITY
]);
6483 if (info
->attrs
[NL80211_ATTR_AIRTIME_WEIGHT
])
6484 params
.airtime_weight
=
6485 nla_get_u16(info
->attrs
[NL80211_ATTR_AIRTIME_WEIGHT
]);
6487 if (params
.airtime_weight
&&
6488 !wiphy_ext_feature_isset(&rdev
->wiphy
,
6489 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS
))
6492 err
= nl80211_parse_sta_txpower_setting(info
, ¶ms
);
6496 /* Include parameters for TDLS peer (will check later) */
6497 err
= nl80211_set_station_tdls(info
, ¶ms
);
6501 params
.vlan
= get_vlan(info
, rdev
);
6502 if (IS_ERR(params
.vlan
))
6503 return PTR_ERR(params
.vlan
);
6505 switch (dev
->ieee80211_ptr
->iftype
) {
6506 case NL80211_IFTYPE_AP
:
6507 case NL80211_IFTYPE_AP_VLAN
:
6508 case NL80211_IFTYPE_P2P_GO
:
6509 case NL80211_IFTYPE_P2P_CLIENT
:
6510 case NL80211_IFTYPE_STATION
:
6511 case NL80211_IFTYPE_ADHOC
:
6512 case NL80211_IFTYPE_MESH_POINT
:
6519 /* driver will call cfg80211_check_station_change() */
6520 err
= rdev_change_station(rdev
, dev
, mac_addr
, ¶ms
);
6524 dev_put(params
.vlan
);
6529 static int nl80211_new_station(struct sk_buff
*skb
, struct genl_info
*info
)
6531 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6533 struct net_device
*dev
= info
->user_ptr
[1];
6534 struct station_parameters params
;
6535 u8
*mac_addr
= NULL
;
6536 u32 auth_assoc
= BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
6537 BIT(NL80211_STA_FLAG_ASSOCIATED
);
6539 memset(¶ms
, 0, sizeof(params
));
6541 if (!rdev
->ops
->add_station
)
6544 if (!info
->attrs
[NL80211_ATTR_MAC
])
6547 if (!info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
])
6550 if (!info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
])
6553 if (!info
->attrs
[NL80211_ATTR_STA_AID
] &&
6554 !info
->attrs
[NL80211_ATTR_PEER_AID
])
6557 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6558 params
.supported_rates
=
6559 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
6560 params
.supported_rates_len
=
6561 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
6562 params
.listen_interval
=
6563 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
]);
6565 if (info
->attrs
[NL80211_ATTR_VLAN_ID
])
6566 params
.vlan_id
= nla_get_u16(info
->attrs
[NL80211_ATTR_VLAN_ID
]);
6568 if (info
->attrs
[NL80211_ATTR_STA_SUPPORT_P2P_PS
]) {
6569 params
.support_p2p_ps
=
6570 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_SUPPORT_P2P_PS
]);
6573 * if not specified, assume it's supported for P2P GO interface,
6574 * and is NOT supported for AP interface
6576 params
.support_p2p_ps
=
6577 dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_P2P_GO
;
6580 if (info
->attrs
[NL80211_ATTR_PEER_AID
])
6581 params
.aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_PEER_AID
]);
6583 params
.aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_STA_AID
]);
6585 if (info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]) {
6587 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]);
6588 params
.sta_modify_mask
|= STATION_PARAM_APPLY_CAPABILITY
;
6591 if (info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]) {
6593 nla_data(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
6594 params
.ext_capab_len
=
6595 nla_len(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
6598 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
])
6600 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
6602 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
])
6604 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]);
6606 if (info
->attrs
[NL80211_ATTR_HE_CAPABILITY
]) {
6608 nla_data(info
->attrs
[NL80211_ATTR_HE_CAPABILITY
]);
6609 params
.he_capa_len
=
6610 nla_len(info
->attrs
[NL80211_ATTR_HE_CAPABILITY
]);
6613 if (info
->attrs
[NL80211_ATTR_HE_6GHZ_CAPABILITY
])
6614 params
.he_6ghz_capa
=
6615 nla_data(info
->attrs
[NL80211_ATTR_HE_6GHZ_CAPABILITY
]);
6617 if (info
->attrs
[NL80211_ATTR_OPMODE_NOTIF
]) {
6618 params
.opmode_notif_used
= true;
6619 params
.opmode_notif
=
6620 nla_get_u8(info
->attrs
[NL80211_ATTR_OPMODE_NOTIF
]);
6623 if (info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
])
6624 params
.plink_action
=
6625 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]);
6627 if (info
->attrs
[NL80211_ATTR_AIRTIME_WEIGHT
])
6628 params
.airtime_weight
=
6629 nla_get_u16(info
->attrs
[NL80211_ATTR_AIRTIME_WEIGHT
]);
6631 if (params
.airtime_weight
&&
6632 !wiphy_ext_feature_isset(&rdev
->wiphy
,
6633 NL80211_EXT_FEATURE_AIRTIME_FAIRNESS
))
6636 err
= nl80211_parse_sta_txpower_setting(info
, ¶ms
);
6640 err
= nl80211_parse_sta_channel_info(info
, ¶ms
);
6644 err
= nl80211_parse_sta_wme(info
, ¶ms
);
6648 if (parse_station_flags(info
, dev
->ieee80211_ptr
->iftype
, ¶ms
))
6651 /* HT/VHT requires QoS, but if we don't have that just ignore HT/VHT
6652 * as userspace might just pass through the capabilities from the IEs
6653 * directly, rather than enforcing this restriction and returning an
6654 * error in this case.
6656 if (!(params
.sta_flags_set
& BIT(NL80211_STA_FLAG_WME
))) {
6657 params
.ht_capa
= NULL
;
6658 params
.vht_capa
= NULL
;
6660 /* HE requires WME */
6661 if (params
.he_capa_len
|| params
.he_6ghz_capa
)
6665 /* Ensure that HT/VHT capabilities are not set for 6 GHz HE STA */
6666 if (params
.he_6ghz_capa
&& (params
.ht_capa
|| params
.vht_capa
))
6669 /* When you run into this, adjust the code below for the new flag */
6670 BUILD_BUG_ON(NL80211_STA_FLAG_MAX
!= 7);
6672 switch (dev
->ieee80211_ptr
->iftype
) {
6673 case NL80211_IFTYPE_AP
:
6674 case NL80211_IFTYPE_AP_VLAN
:
6675 case NL80211_IFTYPE_P2P_GO
:
6676 /* ignore WME attributes if iface/sta is not capable */
6677 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_AP_UAPSD
) ||
6678 !(params
.sta_flags_set
& BIT(NL80211_STA_FLAG_WME
)))
6679 params
.sta_modify_mask
&= ~STATION_PARAM_APPLY_UAPSD
;
6681 /* TDLS peers cannot be added */
6682 if ((params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)) ||
6683 info
->attrs
[NL80211_ATTR_PEER_AID
])
6685 /* but don't bother the driver with it */
6686 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
6688 /* allow authenticated/associated only if driver handles it */
6689 if (!(rdev
->wiphy
.features
&
6690 NL80211_FEATURE_FULL_AP_CLIENT_STATE
) &&
6691 params
.sta_flags_mask
& auth_assoc
)
6694 /* Older userspace, or userspace wanting to be compatible with
6695 * !NL80211_FEATURE_FULL_AP_CLIENT_STATE, will not set the auth
6696 * and assoc flags in the mask, but assumes the station will be
6697 * added as associated anyway since this was the required driver
6698 * behaviour before NL80211_FEATURE_FULL_AP_CLIENT_STATE was
6700 * In order to not bother drivers with this quirk in the API
6701 * set the flags in both the mask and set for new stations in
6704 if (!(params
.sta_flags_mask
& auth_assoc
)) {
6705 params
.sta_flags_mask
|= auth_assoc
;
6706 params
.sta_flags_set
|= auth_assoc
;
6709 /* must be last in here for error handling */
6710 params
.vlan
= get_vlan(info
, rdev
);
6711 if (IS_ERR(params
.vlan
))
6712 return PTR_ERR(params
.vlan
);
6714 case NL80211_IFTYPE_MESH_POINT
:
6715 /* ignore uAPSD data */
6716 params
.sta_modify_mask
&= ~STATION_PARAM_APPLY_UAPSD
;
6718 /* associated is disallowed */
6719 if (params
.sta_flags_mask
& BIT(NL80211_STA_FLAG_ASSOCIATED
))
6721 /* TDLS peers cannot be added */
6722 if ((params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)) ||
6723 info
->attrs
[NL80211_ATTR_PEER_AID
])
6726 case NL80211_IFTYPE_STATION
:
6727 case NL80211_IFTYPE_P2P_CLIENT
:
6728 /* ignore uAPSD data */
6729 params
.sta_modify_mask
&= ~STATION_PARAM_APPLY_UAPSD
;
6731 /* these are disallowed */
6732 if (params
.sta_flags_mask
&
6733 (BIT(NL80211_STA_FLAG_ASSOCIATED
) |
6734 BIT(NL80211_STA_FLAG_AUTHENTICATED
)))
6736 /* Only TDLS peers can be added */
6737 if (!(params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)))
6739 /* Can only add if TDLS ... */
6740 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
))
6742 /* ... with external setup is supported */
6743 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_TDLS_EXTERNAL_SETUP
))
6746 * Older wpa_supplicant versions always mark the TDLS peer
6747 * as authorized, but it shouldn't yet be.
6749 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_AUTHORIZED
);
6755 /* be aware of params.vlan when changing code here */
6757 err
= rdev_add_station(rdev
, dev
, mac_addr
, ¶ms
);
6760 dev_put(params
.vlan
);
6764 static int nl80211_del_station(struct sk_buff
*skb
, struct genl_info
*info
)
6766 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6767 struct net_device
*dev
= info
->user_ptr
[1];
6768 struct station_del_parameters params
;
6770 memset(¶ms
, 0, sizeof(params
));
6772 if (info
->attrs
[NL80211_ATTR_MAC
])
6773 params
.mac
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6775 switch (dev
->ieee80211_ptr
->iftype
) {
6776 case NL80211_IFTYPE_AP
:
6777 case NL80211_IFTYPE_AP_VLAN
:
6778 case NL80211_IFTYPE_MESH_POINT
:
6779 case NL80211_IFTYPE_P2P_GO
:
6780 /* always accept these */
6782 case NL80211_IFTYPE_ADHOC
:
6783 /* conditionally accept */
6784 if (wiphy_ext_feature_isset(&rdev
->wiphy
,
6785 NL80211_EXT_FEATURE_DEL_IBSS_STA
))
6792 if (!rdev
->ops
->del_station
)
6795 if (info
->attrs
[NL80211_ATTR_MGMT_SUBTYPE
]) {
6797 nla_get_u8(info
->attrs
[NL80211_ATTR_MGMT_SUBTYPE
]);
6798 if (params
.subtype
!= IEEE80211_STYPE_DISASSOC
>> 4 &&
6799 params
.subtype
!= IEEE80211_STYPE_DEAUTH
>> 4)
6802 /* Default to Deauthentication frame */
6803 params
.subtype
= IEEE80211_STYPE_DEAUTH
>> 4;
6806 if (info
->attrs
[NL80211_ATTR_REASON_CODE
]) {
6807 params
.reason_code
=
6808 nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
6809 if (params
.reason_code
== 0)
6810 return -EINVAL
; /* 0 is reserved */
6812 /* Default to reason code 2 */
6813 params
.reason_code
= WLAN_REASON_PREV_AUTH_NOT_VALID
;
6816 return rdev_del_station(rdev
, dev
, ¶ms
);
6819 static int nl80211_send_mpath(struct sk_buff
*msg
, u32 portid
, u32 seq
,
6820 int flags
, struct net_device
*dev
,
6821 u8
*dst
, u8
*next_hop
,
6822 struct mpath_info
*pinfo
)
6825 struct nlattr
*pinfoattr
;
6827 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, NL80211_CMD_NEW_MPATH
);
6831 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
6832 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, dst
) ||
6833 nla_put(msg
, NL80211_ATTR_MPATH_NEXT_HOP
, ETH_ALEN
, next_hop
) ||
6834 nla_put_u32(msg
, NL80211_ATTR_GENERATION
, pinfo
->generation
))
6835 goto nla_put_failure
;
6837 pinfoattr
= nla_nest_start_noflag(msg
, NL80211_ATTR_MPATH_INFO
);
6839 goto nla_put_failure
;
6840 if ((pinfo
->filled
& MPATH_INFO_FRAME_QLEN
) &&
6841 nla_put_u32(msg
, NL80211_MPATH_INFO_FRAME_QLEN
,
6843 goto nla_put_failure
;
6844 if (((pinfo
->filled
& MPATH_INFO_SN
) &&
6845 nla_put_u32(msg
, NL80211_MPATH_INFO_SN
, pinfo
->sn
)) ||
6846 ((pinfo
->filled
& MPATH_INFO_METRIC
) &&
6847 nla_put_u32(msg
, NL80211_MPATH_INFO_METRIC
,
6849 ((pinfo
->filled
& MPATH_INFO_EXPTIME
) &&
6850 nla_put_u32(msg
, NL80211_MPATH_INFO_EXPTIME
,
6852 ((pinfo
->filled
& MPATH_INFO_FLAGS
) &&
6853 nla_put_u8(msg
, NL80211_MPATH_INFO_FLAGS
,
6855 ((pinfo
->filled
& MPATH_INFO_DISCOVERY_TIMEOUT
) &&
6856 nla_put_u32(msg
, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT
,
6857 pinfo
->discovery_timeout
)) ||
6858 ((pinfo
->filled
& MPATH_INFO_DISCOVERY_RETRIES
) &&
6859 nla_put_u8(msg
, NL80211_MPATH_INFO_DISCOVERY_RETRIES
,
6860 pinfo
->discovery_retries
)) ||
6861 ((pinfo
->filled
& MPATH_INFO_HOP_COUNT
) &&
6862 nla_put_u8(msg
, NL80211_MPATH_INFO_HOP_COUNT
,
6863 pinfo
->hop_count
)) ||
6864 ((pinfo
->filled
& MPATH_INFO_PATH_CHANGE
) &&
6865 nla_put_u32(msg
, NL80211_MPATH_INFO_PATH_CHANGE
,
6866 pinfo
->path_change_count
)))
6867 goto nla_put_failure
;
6869 nla_nest_end(msg
, pinfoattr
);
6871 genlmsg_end(msg
, hdr
);
6875 genlmsg_cancel(msg
, hdr
);
6879 static int nl80211_dump_mpath(struct sk_buff
*skb
,
6880 struct netlink_callback
*cb
)
6882 struct mpath_info pinfo
;
6883 struct cfg80211_registered_device
*rdev
;
6884 struct wireless_dev
*wdev
;
6886 u8 next_hop
[ETH_ALEN
];
6887 int path_idx
= cb
->args
[2];
6890 err
= nl80211_prepare_wdev_dump(cb
, &rdev
, &wdev
);
6893 /* nl80211_prepare_wdev_dump acquired it in the successful case */
6894 __acquire(&rdev
->wiphy
.mtx
);
6896 if (!rdev
->ops
->dump_mpath
) {
6901 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
) {
6907 err
= rdev_dump_mpath(rdev
, wdev
->netdev
, path_idx
, dst
,
6914 if (nl80211_send_mpath(skb
, NETLINK_CB(cb
->skb
).portid
,
6915 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
6916 wdev
->netdev
, dst
, next_hop
,
6924 cb
->args
[2] = path_idx
;
6927 wiphy_unlock(&rdev
->wiphy
);
6931 static int nl80211_get_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
6933 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6935 struct net_device
*dev
= info
->user_ptr
[1];
6936 struct mpath_info pinfo
;
6937 struct sk_buff
*msg
;
6939 u8 next_hop
[ETH_ALEN
];
6941 memset(&pinfo
, 0, sizeof(pinfo
));
6943 if (!info
->attrs
[NL80211_ATTR_MAC
])
6946 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6948 if (!rdev
->ops
->get_mpath
)
6951 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
6954 err
= rdev_get_mpath(rdev
, dev
, dst
, next_hop
, &pinfo
);
6958 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
6962 if (nl80211_send_mpath(msg
, info
->snd_portid
, info
->snd_seq
, 0,
6963 dev
, dst
, next_hop
, &pinfo
) < 0) {
6968 return genlmsg_reply(msg
, info
);
6971 static int nl80211_set_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
6973 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6974 struct net_device
*dev
= info
->user_ptr
[1];
6976 u8
*next_hop
= NULL
;
6978 if (!info
->attrs
[NL80211_ATTR_MAC
])
6981 if (!info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
])
6984 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6985 next_hop
= nla_data(info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
]);
6987 if (!rdev
->ops
->change_mpath
)
6990 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
6993 return rdev_change_mpath(rdev
, dev
, dst
, next_hop
);
6996 static int nl80211_new_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
6998 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6999 struct net_device
*dev
= info
->user_ptr
[1];
7001 u8
*next_hop
= NULL
;
7003 if (!info
->attrs
[NL80211_ATTR_MAC
])
7006 if (!info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
])
7009 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
7010 next_hop
= nla_data(info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
]);
7012 if (!rdev
->ops
->add_mpath
)
7015 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
7018 return rdev_add_mpath(rdev
, dev
, dst
, next_hop
);
7021 static int nl80211_del_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
7023 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7024 struct net_device
*dev
= info
->user_ptr
[1];
7027 if (info
->attrs
[NL80211_ATTR_MAC
])
7028 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
7030 if (!rdev
->ops
->del_mpath
)
7033 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
7036 return rdev_del_mpath(rdev
, dev
, dst
);
7039 static int nl80211_get_mpp(struct sk_buff
*skb
, struct genl_info
*info
)
7041 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7043 struct net_device
*dev
= info
->user_ptr
[1];
7044 struct mpath_info pinfo
;
7045 struct sk_buff
*msg
;
7049 memset(&pinfo
, 0, sizeof(pinfo
));
7051 if (!info
->attrs
[NL80211_ATTR_MAC
])
7054 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
7056 if (!rdev
->ops
->get_mpp
)
7059 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
7062 err
= rdev_get_mpp(rdev
, dev
, dst
, mpp
, &pinfo
);
7066 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7070 if (nl80211_send_mpath(msg
, info
->snd_portid
, info
->snd_seq
, 0,
7071 dev
, dst
, mpp
, &pinfo
) < 0) {
7076 return genlmsg_reply(msg
, info
);
7079 static int nl80211_dump_mpp(struct sk_buff
*skb
,
7080 struct netlink_callback
*cb
)
7082 struct mpath_info pinfo
;
7083 struct cfg80211_registered_device
*rdev
;
7084 struct wireless_dev
*wdev
;
7087 int path_idx
= cb
->args
[2];
7090 err
= nl80211_prepare_wdev_dump(cb
, &rdev
, &wdev
);
7093 /* nl80211_prepare_wdev_dump acquired it in the successful case */
7094 __acquire(&rdev
->wiphy
.mtx
);
7096 if (!rdev
->ops
->dump_mpp
) {
7101 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
) {
7107 err
= rdev_dump_mpp(rdev
, wdev
->netdev
, path_idx
, dst
,
7114 if (nl80211_send_mpath(skb
, NETLINK_CB(cb
->skb
).portid
,
7115 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
7116 wdev
->netdev
, dst
, mpp
,
7124 cb
->args
[2] = path_idx
;
7127 wiphy_unlock(&rdev
->wiphy
);
7131 static int nl80211_set_bss(struct sk_buff
*skb
, struct genl_info
*info
)
7133 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7134 struct net_device
*dev
= info
->user_ptr
[1];
7135 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
7136 struct bss_parameters params
;
7139 memset(¶ms
, 0, sizeof(params
));
7140 /* default to not changing parameters */
7141 params
.use_cts_prot
= -1;
7142 params
.use_short_preamble
= -1;
7143 params
.use_short_slot_time
= -1;
7144 params
.ap_isolate
= -1;
7145 params
.ht_opmode
= -1;
7146 params
.p2p_ctwindow
= -1;
7147 params
.p2p_opp_ps
= -1;
7149 if (info
->attrs
[NL80211_ATTR_BSS_CTS_PROT
])
7150 params
.use_cts_prot
=
7151 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_CTS_PROT
]);
7152 if (info
->attrs
[NL80211_ATTR_BSS_SHORT_PREAMBLE
])
7153 params
.use_short_preamble
=
7154 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_SHORT_PREAMBLE
]);
7155 if (info
->attrs
[NL80211_ATTR_BSS_SHORT_SLOT_TIME
])
7156 params
.use_short_slot_time
=
7157 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_SHORT_SLOT_TIME
]);
7158 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
7159 params
.basic_rates
=
7160 nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
7161 params
.basic_rates_len
=
7162 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
7164 if (info
->attrs
[NL80211_ATTR_AP_ISOLATE
])
7165 params
.ap_isolate
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_AP_ISOLATE
]);
7166 if (info
->attrs
[NL80211_ATTR_BSS_HT_OPMODE
])
7168 nla_get_u16(info
->attrs
[NL80211_ATTR_BSS_HT_OPMODE
]);
7170 if (info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]) {
7171 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
7173 params
.p2p_ctwindow
=
7174 nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]);
7175 if (params
.p2p_ctwindow
!= 0 &&
7176 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_CTWIN
))
7180 if (info
->attrs
[NL80211_ATTR_P2P_OPPPS
]) {
7183 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
7185 tmp
= nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_OPPPS
]);
7186 params
.p2p_opp_ps
= tmp
;
7187 if (params
.p2p_opp_ps
&&
7188 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_OPPPS
))
7192 if (!rdev
->ops
->change_bss
)
7195 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
7196 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
7200 err
= rdev_change_bss(rdev
, dev
, ¶ms
);
7206 static int nl80211_req_set_reg(struct sk_buff
*skb
, struct genl_info
*info
)
7210 enum nl80211_user_reg_hint_type user_reg_hint_type
;
7214 * You should only get this when cfg80211 hasn't yet initialized
7215 * completely when built-in to the kernel right between the time
7216 * window between nl80211_init() and regulatory_init(), if that is
7219 if (unlikely(!rcu_access_pointer(cfg80211_regdomain
)))
7220 return -EINPROGRESS
;
7222 if (info
->attrs
[NL80211_ATTR_USER_REG_HINT_TYPE
])
7223 user_reg_hint_type
=
7224 nla_get_u32(info
->attrs
[NL80211_ATTR_USER_REG_HINT_TYPE
]);
7226 user_reg_hint_type
= NL80211_USER_REG_HINT_USER
;
7228 switch (user_reg_hint_type
) {
7229 case NL80211_USER_REG_HINT_USER
:
7230 case NL80211_USER_REG_HINT_CELL_BASE
:
7231 if (!info
->attrs
[NL80211_ATTR_REG_ALPHA2
])
7234 data
= nla_data(info
->attrs
[NL80211_ATTR_REG_ALPHA2
]);
7235 return regulatory_hint_user(data
, user_reg_hint_type
);
7236 case NL80211_USER_REG_HINT_INDOOR
:
7237 if (info
->attrs
[NL80211_ATTR_SOCKET_OWNER
]) {
7238 owner_nlportid
= info
->snd_portid
;
7239 is_indoor
= !!info
->attrs
[NL80211_ATTR_REG_INDOOR
];
7245 return regulatory_hint_indoor(is_indoor
, owner_nlportid
);
7251 static int nl80211_reload_regdb(struct sk_buff
*skb
, struct genl_info
*info
)
7253 return reg_reload_regdb();
7256 static int nl80211_get_mesh_config(struct sk_buff
*skb
,
7257 struct genl_info
*info
)
7259 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7260 struct net_device
*dev
= info
->user_ptr
[1];
7261 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
7262 struct mesh_config cur_params
;
7265 struct nlattr
*pinfoattr
;
7266 struct sk_buff
*msg
;
7268 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
7271 if (!rdev
->ops
->get_mesh_config
)
7275 /* If not connected, get default parameters */
7276 if (!wdev
->mesh_id_len
)
7277 memcpy(&cur_params
, &default_mesh_config
, sizeof(cur_params
));
7279 err
= rdev_get_mesh_config(rdev
, dev
, &cur_params
);
7285 /* Draw up a netlink message to send back */
7286 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7289 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
7290 NL80211_CMD_GET_MESH_CONFIG
);
7293 pinfoattr
= nla_nest_start_noflag(msg
, NL80211_ATTR_MESH_CONFIG
);
7295 goto nla_put_failure
;
7296 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
7297 nla_put_u16(msg
, NL80211_MESHCONF_RETRY_TIMEOUT
,
7298 cur_params
.dot11MeshRetryTimeout
) ||
7299 nla_put_u16(msg
, NL80211_MESHCONF_CONFIRM_TIMEOUT
,
7300 cur_params
.dot11MeshConfirmTimeout
) ||
7301 nla_put_u16(msg
, NL80211_MESHCONF_HOLDING_TIMEOUT
,
7302 cur_params
.dot11MeshHoldingTimeout
) ||
7303 nla_put_u16(msg
, NL80211_MESHCONF_MAX_PEER_LINKS
,
7304 cur_params
.dot11MeshMaxPeerLinks
) ||
7305 nla_put_u8(msg
, NL80211_MESHCONF_MAX_RETRIES
,
7306 cur_params
.dot11MeshMaxRetries
) ||
7307 nla_put_u8(msg
, NL80211_MESHCONF_TTL
,
7308 cur_params
.dot11MeshTTL
) ||
7309 nla_put_u8(msg
, NL80211_MESHCONF_ELEMENT_TTL
,
7310 cur_params
.element_ttl
) ||
7311 nla_put_u8(msg
, NL80211_MESHCONF_AUTO_OPEN_PLINKS
,
7312 cur_params
.auto_open_plinks
) ||
7313 nla_put_u32(msg
, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
,
7314 cur_params
.dot11MeshNbrOffsetMaxNeighbor
) ||
7315 nla_put_u8(msg
, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
,
7316 cur_params
.dot11MeshHWMPmaxPREQretries
) ||
7317 nla_put_u32(msg
, NL80211_MESHCONF_PATH_REFRESH_TIME
,
7318 cur_params
.path_refresh_time
) ||
7319 nla_put_u16(msg
, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
,
7320 cur_params
.min_discovery_timeout
) ||
7321 nla_put_u32(msg
, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
,
7322 cur_params
.dot11MeshHWMPactivePathTimeout
) ||
7323 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
,
7324 cur_params
.dot11MeshHWMPpreqMinInterval
) ||
7325 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
,
7326 cur_params
.dot11MeshHWMPperrMinInterval
) ||
7327 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
,
7328 cur_params
.dot11MeshHWMPnetDiameterTraversalTime
) ||
7329 nla_put_u8(msg
, NL80211_MESHCONF_HWMP_ROOTMODE
,
7330 cur_params
.dot11MeshHWMPRootMode
) ||
7331 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_RANN_INTERVAL
,
7332 cur_params
.dot11MeshHWMPRannInterval
) ||
7333 nla_put_u8(msg
, NL80211_MESHCONF_GATE_ANNOUNCEMENTS
,
7334 cur_params
.dot11MeshGateAnnouncementProtocol
) ||
7335 nla_put_u8(msg
, NL80211_MESHCONF_FORWARDING
,
7336 cur_params
.dot11MeshForwarding
) ||
7337 nla_put_s32(msg
, NL80211_MESHCONF_RSSI_THRESHOLD
,
7338 cur_params
.rssi_threshold
) ||
7339 nla_put_u32(msg
, NL80211_MESHCONF_HT_OPMODE
,
7340 cur_params
.ht_opmode
) ||
7341 nla_put_u32(msg
, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
,
7342 cur_params
.dot11MeshHWMPactivePathToRootTimeout
) ||
7343 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_ROOT_INTERVAL
,
7344 cur_params
.dot11MeshHWMProotInterval
) ||
7345 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL
,
7346 cur_params
.dot11MeshHWMPconfirmationInterval
) ||
7347 nla_put_u32(msg
, NL80211_MESHCONF_POWER_MODE
,
7348 cur_params
.power_mode
) ||
7349 nla_put_u16(msg
, NL80211_MESHCONF_AWAKE_WINDOW
,
7350 cur_params
.dot11MeshAwakeWindowDuration
) ||
7351 nla_put_u32(msg
, NL80211_MESHCONF_PLINK_TIMEOUT
,
7352 cur_params
.plink_timeout
) ||
7353 nla_put_u8(msg
, NL80211_MESHCONF_CONNECTED_TO_GATE
,
7354 cur_params
.dot11MeshConnectedToMeshGate
) ||
7355 nla_put_u8(msg
, NL80211_MESHCONF_NOLEARN
,
7356 cur_params
.dot11MeshNolearn
) ||
7357 nla_put_u8(msg
, NL80211_MESHCONF_CONNECTED_TO_AS
,
7358 cur_params
.dot11MeshConnectedToAuthServer
))
7359 goto nla_put_failure
;
7360 nla_nest_end(msg
, pinfoattr
);
7361 genlmsg_end(msg
, hdr
);
7362 return genlmsg_reply(msg
, info
);
7370 static const struct nla_policy
7371 nl80211_meshconf_params_policy
[NL80211_MESHCONF_ATTR_MAX
+1] = {
7372 [NL80211_MESHCONF_RETRY_TIMEOUT
] =
7373 NLA_POLICY_RANGE(NLA_U16
, 1, 255),
7374 [NL80211_MESHCONF_CONFIRM_TIMEOUT
] =
7375 NLA_POLICY_RANGE(NLA_U16
, 1, 255),
7376 [NL80211_MESHCONF_HOLDING_TIMEOUT
] =
7377 NLA_POLICY_RANGE(NLA_U16
, 1, 255),
7378 [NL80211_MESHCONF_MAX_PEER_LINKS
] =
7379 NLA_POLICY_RANGE(NLA_U16
, 0, 255),
7380 [NL80211_MESHCONF_MAX_RETRIES
] = NLA_POLICY_MAX(NLA_U8
, 16),
7381 [NL80211_MESHCONF_TTL
] = NLA_POLICY_MIN(NLA_U8
, 1),
7382 [NL80211_MESHCONF_ELEMENT_TTL
] = NLA_POLICY_MIN(NLA_U8
, 1),
7383 [NL80211_MESHCONF_AUTO_OPEN_PLINKS
] = NLA_POLICY_MAX(NLA_U8
, 1),
7384 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
] =
7385 NLA_POLICY_RANGE(NLA_U32
, 1, 255),
7386 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
] = { .type
= NLA_U8
},
7387 [NL80211_MESHCONF_PATH_REFRESH_TIME
] = { .type
= NLA_U32
},
7388 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
] = NLA_POLICY_MIN(NLA_U16
, 1),
7389 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
] = { .type
= NLA_U32
},
7390 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
] =
7391 NLA_POLICY_MIN(NLA_U16
, 1),
7392 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
] =
7393 NLA_POLICY_MIN(NLA_U16
, 1),
7394 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
] =
7395 NLA_POLICY_MIN(NLA_U16
, 1),
7396 [NL80211_MESHCONF_HWMP_ROOTMODE
] = NLA_POLICY_MAX(NLA_U8
, 4),
7397 [NL80211_MESHCONF_HWMP_RANN_INTERVAL
] =
7398 NLA_POLICY_MIN(NLA_U16
, 1),
7399 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS
] = NLA_POLICY_MAX(NLA_U8
, 1),
7400 [NL80211_MESHCONF_FORWARDING
] = NLA_POLICY_MAX(NLA_U8
, 1),
7401 [NL80211_MESHCONF_RSSI_THRESHOLD
] =
7402 NLA_POLICY_RANGE(NLA_S32
, -255, 0),
7403 [NL80211_MESHCONF_HT_OPMODE
] = { .type
= NLA_U16
},
7404 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
] = { .type
= NLA_U32
},
7405 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL
] =
7406 NLA_POLICY_MIN(NLA_U16
, 1),
7407 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL
] =
7408 NLA_POLICY_MIN(NLA_U16
, 1),
7409 [NL80211_MESHCONF_POWER_MODE
] =
7410 NLA_POLICY_RANGE(NLA_U32
,
7411 NL80211_MESH_POWER_ACTIVE
,
7412 NL80211_MESH_POWER_MAX
),
7413 [NL80211_MESHCONF_AWAKE_WINDOW
] = { .type
= NLA_U16
},
7414 [NL80211_MESHCONF_PLINK_TIMEOUT
] = { .type
= NLA_U32
},
7415 [NL80211_MESHCONF_CONNECTED_TO_GATE
] = NLA_POLICY_RANGE(NLA_U8
, 0, 1),
7416 [NL80211_MESHCONF_NOLEARN
] = NLA_POLICY_RANGE(NLA_U8
, 0, 1),
7417 [NL80211_MESHCONF_CONNECTED_TO_AS
] = NLA_POLICY_RANGE(NLA_U8
, 0, 1),
7420 static const struct nla_policy
7421 nl80211_mesh_setup_params_policy
[NL80211_MESH_SETUP_ATTR_MAX
+1] = {
7422 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
] = { .type
= NLA_U8
},
7423 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
] = { .type
= NLA_U8
},
7424 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
] = { .type
= NLA_U8
},
7425 [NL80211_MESH_SETUP_USERSPACE_AUTH
] = { .type
= NLA_FLAG
},
7426 [NL80211_MESH_SETUP_AUTH_PROTOCOL
] = { .type
= NLA_U8
},
7427 [NL80211_MESH_SETUP_USERSPACE_MPM
] = { .type
= NLA_FLAG
},
7428 [NL80211_MESH_SETUP_IE
] =
7429 NLA_POLICY_VALIDATE_FN(NLA_BINARY
, validate_ie_attr
,
7430 IEEE80211_MAX_DATA_LEN
),
7431 [NL80211_MESH_SETUP_USERSPACE_AMPE
] = { .type
= NLA_FLAG
},
7434 static int nl80211_parse_mesh_config(struct genl_info
*info
,
7435 struct mesh_config
*cfg
,
7438 struct nlattr
*tb
[NL80211_MESHCONF_ATTR_MAX
+ 1];
7442 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, mask, attr, fn) \
7445 cfg->param = fn(tb[attr]); \
7446 mask |= BIT((attr) - 1); \
7450 if (!info
->attrs
[NL80211_ATTR_MESH_CONFIG
])
7452 if (nla_parse_nested_deprecated(tb
, NL80211_MESHCONF_ATTR_MAX
, info
->attrs
[NL80211_ATTR_MESH_CONFIG
], nl80211_meshconf_params_policy
, info
->extack
))
7455 /* This makes sure that there aren't more than 32 mesh config
7456 * parameters (otherwise our bitfield scheme would not work.) */
7457 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX
> 32);
7459 /* Fill in the params struct */
7460 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshRetryTimeout
, mask
,
7461 NL80211_MESHCONF_RETRY_TIMEOUT
, nla_get_u16
);
7462 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshConfirmTimeout
, mask
,
7463 NL80211_MESHCONF_CONFIRM_TIMEOUT
,
7465 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHoldingTimeout
, mask
,
7466 NL80211_MESHCONF_HOLDING_TIMEOUT
,
7468 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshMaxPeerLinks
, mask
,
7469 NL80211_MESHCONF_MAX_PEER_LINKS
,
7471 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshMaxRetries
, mask
,
7472 NL80211_MESHCONF_MAX_RETRIES
, nla_get_u8
);
7473 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshTTL
, mask
,
7474 NL80211_MESHCONF_TTL
, nla_get_u8
);
7475 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, element_ttl
, mask
,
7476 NL80211_MESHCONF_ELEMENT_TTL
, nla_get_u8
);
7477 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, auto_open_plinks
, mask
,
7478 NL80211_MESHCONF_AUTO_OPEN_PLINKS
,
7480 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshNbrOffsetMaxNeighbor
,
7482 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
,
7484 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPmaxPREQretries
, mask
,
7485 NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
,
7487 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, path_refresh_time
, mask
,
7488 NL80211_MESHCONF_PATH_REFRESH_TIME
,
7490 if (mask
& BIT(NL80211_MESHCONF_PATH_REFRESH_TIME
) &&
7491 (cfg
->path_refresh_time
< 1 || cfg
->path_refresh_time
> 65535))
7493 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, min_discovery_timeout
, mask
,
7494 NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
,
7496 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPactivePathTimeout
,
7498 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
,
7500 if (mask
& BIT(NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
) &&
7501 (cfg
->dot11MeshHWMPactivePathTimeout
< 1 ||
7502 cfg
->dot11MeshHWMPactivePathTimeout
> 65535))
7504 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPpreqMinInterval
, mask
,
7505 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
,
7507 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPperrMinInterval
, mask
,
7508 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
,
7510 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
7511 dot11MeshHWMPnetDiameterTraversalTime
, mask
,
7512 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
,
7514 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPRootMode
, mask
,
7515 NL80211_MESHCONF_HWMP_ROOTMODE
, nla_get_u8
);
7516 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPRannInterval
, mask
,
7517 NL80211_MESHCONF_HWMP_RANN_INTERVAL
,
7519 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshGateAnnouncementProtocol
,
7520 mask
, NL80211_MESHCONF_GATE_ANNOUNCEMENTS
,
7522 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshForwarding
, mask
,
7523 NL80211_MESHCONF_FORWARDING
, nla_get_u8
);
7524 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, rssi_threshold
, mask
,
7525 NL80211_MESHCONF_RSSI_THRESHOLD
,
7527 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshConnectedToMeshGate
, mask
,
7528 NL80211_MESHCONF_CONNECTED_TO_GATE
,
7530 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshConnectedToAuthServer
, mask
,
7531 NL80211_MESHCONF_CONNECTED_TO_AS
,
7534 * Check HT operation mode based on
7535 * IEEE 802.11-2016 9.4.2.57 HT Operation element.
7537 if (tb
[NL80211_MESHCONF_HT_OPMODE
]) {
7538 ht_opmode
= nla_get_u16(tb
[NL80211_MESHCONF_HT_OPMODE
]);
7540 if (ht_opmode
& ~(IEEE80211_HT_OP_MODE_PROTECTION
|
7541 IEEE80211_HT_OP_MODE_NON_GF_STA_PRSNT
|
7542 IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT
))
7545 /* NON_HT_STA bit is reserved, but some programs set it */
7546 ht_opmode
&= ~IEEE80211_HT_OP_MODE_NON_HT_STA_PRSNT
;
7548 cfg
->ht_opmode
= ht_opmode
;
7549 mask
|= (1 << (NL80211_MESHCONF_HT_OPMODE
- 1));
7551 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
7552 dot11MeshHWMPactivePathToRootTimeout
, mask
,
7553 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
,
7555 if (mask
& BIT(NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
) &&
7556 (cfg
->dot11MeshHWMPactivePathToRootTimeout
< 1 ||
7557 cfg
->dot11MeshHWMPactivePathToRootTimeout
> 65535))
7559 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMProotInterval
, mask
,
7560 NL80211_MESHCONF_HWMP_ROOT_INTERVAL
,
7562 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPconfirmationInterval
,
7564 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL
,
7566 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, power_mode
, mask
,
7567 NL80211_MESHCONF_POWER_MODE
, nla_get_u32
);
7568 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshAwakeWindowDuration
, mask
,
7569 NL80211_MESHCONF_AWAKE_WINDOW
, nla_get_u16
);
7570 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, plink_timeout
, mask
,
7571 NL80211_MESHCONF_PLINK_TIMEOUT
, nla_get_u32
);
7572 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshNolearn
, mask
,
7573 NL80211_MESHCONF_NOLEARN
, nla_get_u8
);
7579 #undef FILL_IN_MESH_PARAM_IF_SET
7582 static int nl80211_parse_mesh_setup(struct genl_info
*info
,
7583 struct mesh_setup
*setup
)
7585 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7586 struct nlattr
*tb
[NL80211_MESH_SETUP_ATTR_MAX
+ 1];
7588 if (!info
->attrs
[NL80211_ATTR_MESH_SETUP
])
7590 if (nla_parse_nested_deprecated(tb
, NL80211_MESH_SETUP_ATTR_MAX
, info
->attrs
[NL80211_ATTR_MESH_SETUP
], nl80211_mesh_setup_params_policy
, info
->extack
))
7593 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
])
7594 setup
->sync_method
=
7595 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
])) ?
7596 IEEE80211_SYNC_METHOD_VENDOR
:
7597 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET
;
7599 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
])
7600 setup
->path_sel_proto
=
7601 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
])) ?
7602 IEEE80211_PATH_PROTOCOL_VENDOR
:
7603 IEEE80211_PATH_PROTOCOL_HWMP
;
7605 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
])
7606 setup
->path_metric
=
7607 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
])) ?
7608 IEEE80211_PATH_METRIC_VENDOR
:
7609 IEEE80211_PATH_METRIC_AIRTIME
;
7611 if (tb
[NL80211_MESH_SETUP_IE
]) {
7612 struct nlattr
*ieattr
=
7613 tb
[NL80211_MESH_SETUP_IE
];
7614 setup
->ie
= nla_data(ieattr
);
7615 setup
->ie_len
= nla_len(ieattr
);
7617 if (tb
[NL80211_MESH_SETUP_USERSPACE_MPM
] &&
7618 !(rdev
->wiphy
.features
& NL80211_FEATURE_USERSPACE_MPM
))
7620 setup
->user_mpm
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_MPM
]);
7621 setup
->is_authenticated
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_AUTH
]);
7622 setup
->is_secure
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_AMPE
]);
7623 if (setup
->is_secure
)
7624 setup
->user_mpm
= true;
7626 if (tb
[NL80211_MESH_SETUP_AUTH_PROTOCOL
]) {
7627 if (!setup
->user_mpm
)
7630 nla_get_u8(tb
[NL80211_MESH_SETUP_AUTH_PROTOCOL
]);
7636 static int nl80211_update_mesh_config(struct sk_buff
*skb
,
7637 struct genl_info
*info
)
7639 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7640 struct net_device
*dev
= info
->user_ptr
[1];
7641 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
7642 struct mesh_config cfg
;
7646 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
7649 if (!rdev
->ops
->update_mesh_config
)
7652 err
= nl80211_parse_mesh_config(info
, &cfg
, &mask
);
7657 if (!wdev
->mesh_id_len
)
7661 err
= rdev_update_mesh_config(rdev
, dev
, mask
, &cfg
);
7668 static int nl80211_put_regdom(const struct ieee80211_regdomain
*regdom
,
7669 struct sk_buff
*msg
)
7671 struct nlattr
*nl_reg_rules
;
7674 if (nla_put_string(msg
, NL80211_ATTR_REG_ALPHA2
, regdom
->alpha2
) ||
7675 (regdom
->dfs_region
&&
7676 nla_put_u8(msg
, NL80211_ATTR_DFS_REGION
, regdom
->dfs_region
)))
7677 goto nla_put_failure
;
7679 nl_reg_rules
= nla_nest_start_noflag(msg
, NL80211_ATTR_REG_RULES
);
7681 goto nla_put_failure
;
7683 for (i
= 0; i
< regdom
->n_reg_rules
; i
++) {
7684 struct nlattr
*nl_reg_rule
;
7685 const struct ieee80211_reg_rule
*reg_rule
;
7686 const struct ieee80211_freq_range
*freq_range
;
7687 const struct ieee80211_power_rule
*power_rule
;
7688 unsigned int max_bandwidth_khz
;
7690 reg_rule
= ®dom
->reg_rules
[i
];
7691 freq_range
= ®_rule
->freq_range
;
7692 power_rule
= ®_rule
->power_rule
;
7694 nl_reg_rule
= nla_nest_start_noflag(msg
, i
);
7696 goto nla_put_failure
;
7698 max_bandwidth_khz
= freq_range
->max_bandwidth_khz
;
7699 if (!max_bandwidth_khz
)
7700 max_bandwidth_khz
= reg_get_max_bandwidth(regdom
,
7703 if (nla_put_u32(msg
, NL80211_ATTR_REG_RULE_FLAGS
,
7705 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_START
,
7706 freq_range
->start_freq_khz
) ||
7707 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_END
,
7708 freq_range
->end_freq_khz
) ||
7709 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_MAX_BW
,
7710 max_bandwidth_khz
) ||
7711 nla_put_u32(msg
, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
,
7712 power_rule
->max_antenna_gain
) ||
7713 nla_put_u32(msg
, NL80211_ATTR_POWER_RULE_MAX_EIRP
,
7714 power_rule
->max_eirp
) ||
7715 nla_put_u32(msg
, NL80211_ATTR_DFS_CAC_TIME
,
7716 reg_rule
->dfs_cac_ms
))
7717 goto nla_put_failure
;
7719 nla_nest_end(msg
, nl_reg_rule
);
7722 nla_nest_end(msg
, nl_reg_rules
);
7729 static int nl80211_get_reg_do(struct sk_buff
*skb
, struct genl_info
*info
)
7731 const struct ieee80211_regdomain
*regdom
= NULL
;
7732 struct cfg80211_registered_device
*rdev
;
7733 struct wiphy
*wiphy
= NULL
;
7734 struct sk_buff
*msg
;
7737 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7741 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
7742 NL80211_CMD_GET_REG
);
7748 if (info
->attrs
[NL80211_ATTR_WIPHY
]) {
7751 rdev
= cfg80211_get_dev_from_info(genl_info_net(info
), info
);
7755 return PTR_ERR(rdev
);
7758 wiphy
= &rdev
->wiphy
;
7759 self_managed
= wiphy
->regulatory_flags
&
7760 REGULATORY_WIPHY_SELF_MANAGED
;
7761 regdom
= get_wiphy_regdom(wiphy
);
7763 /* a self-managed-reg device must have a private regdom */
7764 if (WARN_ON(!regdom
&& self_managed
)) {
7771 nla_put_u32(msg
, NL80211_ATTR_WIPHY
, get_wiphy_idx(wiphy
)))
7772 goto nla_put_failure
;
7775 if (!wiphy
&& reg_last_request_cell_base() &&
7776 nla_put_u32(msg
, NL80211_ATTR_USER_REG_HINT_TYPE
,
7777 NL80211_USER_REG_HINT_CELL_BASE
))
7778 goto nla_put_failure
;
7783 regdom
= rcu_dereference(cfg80211_regdomain
);
7785 if (nl80211_put_regdom(regdom
, msg
))
7786 goto nla_put_failure_rcu
;
7790 genlmsg_end(msg
, hdr
);
7792 return genlmsg_reply(msg
, info
);
7794 nla_put_failure_rcu
:
7803 static int nl80211_send_regdom(struct sk_buff
*msg
, struct netlink_callback
*cb
,
7804 u32 seq
, int flags
, struct wiphy
*wiphy
,
7805 const struct ieee80211_regdomain
*regdom
)
7807 void *hdr
= nl80211hdr_put(msg
, NETLINK_CB(cb
->skb
).portid
, seq
, flags
,
7808 NL80211_CMD_GET_REG
);
7813 genl_dump_check_consistent(cb
, hdr
);
7815 if (nl80211_put_regdom(regdom
, msg
))
7816 goto nla_put_failure
;
7818 if (!wiphy
&& reg_last_request_cell_base() &&
7819 nla_put_u32(msg
, NL80211_ATTR_USER_REG_HINT_TYPE
,
7820 NL80211_USER_REG_HINT_CELL_BASE
))
7821 goto nla_put_failure
;
7824 nla_put_u32(msg
, NL80211_ATTR_WIPHY
, get_wiphy_idx(wiphy
)))
7825 goto nla_put_failure
;
7827 if (wiphy
&& wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
&&
7828 nla_put_flag(msg
, NL80211_ATTR_WIPHY_SELF_MANAGED_REG
))
7829 goto nla_put_failure
;
7831 genlmsg_end(msg
, hdr
);
7835 genlmsg_cancel(msg
, hdr
);
7839 static int nl80211_get_reg_dump(struct sk_buff
*skb
,
7840 struct netlink_callback
*cb
)
7842 const struct ieee80211_regdomain
*regdom
= NULL
;
7843 struct cfg80211_registered_device
*rdev
;
7844 int err
, reg_idx
, start
= cb
->args
[2];
7848 if (cfg80211_regdomain
&& start
== 0) {
7849 err
= nl80211_send_regdom(skb
, cb
, cb
->nlh
->nlmsg_seq
,
7851 rtnl_dereference(cfg80211_regdomain
));
7856 /* the global regdom is idx 0 */
7858 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
7859 regdom
= get_wiphy_regdom(&rdev
->wiphy
);
7863 if (++reg_idx
<= start
)
7866 err
= nl80211_send_regdom(skb
, cb
, cb
->nlh
->nlmsg_seq
,
7867 NLM_F_MULTI
, &rdev
->wiphy
, regdom
);
7874 cb
->args
[2] = reg_idx
;
7881 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
7882 static const struct nla_policy reg_rule_policy
[NL80211_REG_RULE_ATTR_MAX
+ 1] = {
7883 [NL80211_ATTR_REG_RULE_FLAGS
] = { .type
= NLA_U32
},
7884 [NL80211_ATTR_FREQ_RANGE_START
] = { .type
= NLA_U32
},
7885 [NL80211_ATTR_FREQ_RANGE_END
] = { .type
= NLA_U32
},
7886 [NL80211_ATTR_FREQ_RANGE_MAX_BW
] = { .type
= NLA_U32
},
7887 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
] = { .type
= NLA_U32
},
7888 [NL80211_ATTR_POWER_RULE_MAX_EIRP
] = { .type
= NLA_U32
},
7889 [NL80211_ATTR_DFS_CAC_TIME
] = { .type
= NLA_U32
},
7892 static int parse_reg_rule(struct nlattr
*tb
[],
7893 struct ieee80211_reg_rule
*reg_rule
)
7895 struct ieee80211_freq_range
*freq_range
= ®_rule
->freq_range
;
7896 struct ieee80211_power_rule
*power_rule
= ®_rule
->power_rule
;
7898 if (!tb
[NL80211_ATTR_REG_RULE_FLAGS
])
7900 if (!tb
[NL80211_ATTR_FREQ_RANGE_START
])
7902 if (!tb
[NL80211_ATTR_FREQ_RANGE_END
])
7904 if (!tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
])
7906 if (!tb
[NL80211_ATTR_POWER_RULE_MAX_EIRP
])
7909 reg_rule
->flags
= nla_get_u32(tb
[NL80211_ATTR_REG_RULE_FLAGS
]);
7911 freq_range
->start_freq_khz
=
7912 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_START
]);
7913 freq_range
->end_freq_khz
=
7914 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_END
]);
7915 freq_range
->max_bandwidth_khz
=
7916 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
]);
7918 power_rule
->max_eirp
=
7919 nla_get_u32(tb
[NL80211_ATTR_POWER_RULE_MAX_EIRP
]);
7921 if (tb
[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
])
7922 power_rule
->max_antenna_gain
=
7923 nla_get_u32(tb
[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
]);
7925 if (tb
[NL80211_ATTR_DFS_CAC_TIME
])
7926 reg_rule
->dfs_cac_ms
=
7927 nla_get_u32(tb
[NL80211_ATTR_DFS_CAC_TIME
]);
7932 static int nl80211_set_reg(struct sk_buff
*skb
, struct genl_info
*info
)
7934 struct nlattr
*tb
[NL80211_REG_RULE_ATTR_MAX
+ 1];
7935 struct nlattr
*nl_reg_rule
;
7937 int rem_reg_rules
, r
;
7938 u32 num_rules
= 0, rule_idx
= 0;
7939 enum nl80211_dfs_regions dfs_region
= NL80211_DFS_UNSET
;
7940 struct ieee80211_regdomain
*rd
;
7942 if (!info
->attrs
[NL80211_ATTR_REG_ALPHA2
])
7945 if (!info
->attrs
[NL80211_ATTR_REG_RULES
])
7948 alpha2
= nla_data(info
->attrs
[NL80211_ATTR_REG_ALPHA2
]);
7950 if (info
->attrs
[NL80211_ATTR_DFS_REGION
])
7951 dfs_region
= nla_get_u8(info
->attrs
[NL80211_ATTR_DFS_REGION
]);
7953 nla_for_each_nested(nl_reg_rule
, info
->attrs
[NL80211_ATTR_REG_RULES
],
7956 if (num_rules
> NL80211_MAX_SUPP_REG_RULES
)
7961 if (!reg_is_valid_request(alpha2
)) {
7966 rd
= kzalloc(struct_size(rd
, reg_rules
, num_rules
), GFP_KERNEL
);
7972 rd
->n_reg_rules
= num_rules
;
7973 rd
->alpha2
[0] = alpha2
[0];
7974 rd
->alpha2
[1] = alpha2
[1];
7977 * Disable DFS master mode if the DFS region was
7978 * not supported or known on this kernel.
7980 if (reg_supported_dfs_region(dfs_region
))
7981 rd
->dfs_region
= dfs_region
;
7983 nla_for_each_nested(nl_reg_rule
, info
->attrs
[NL80211_ATTR_REG_RULES
],
7985 r
= nla_parse_nested_deprecated(tb
, NL80211_REG_RULE_ATTR_MAX
,
7986 nl_reg_rule
, reg_rule_policy
,
7990 r
= parse_reg_rule(tb
, &rd
->reg_rules
[rule_idx
]);
7996 if (rule_idx
> NL80211_MAX_SUPP_REG_RULES
) {
8002 r
= set_regdom(rd
, REGD_SOURCE_CRDA
);
8003 /* set_regdom takes ownership of rd */
8011 #endif /* CONFIG_CFG80211_CRDA_SUPPORT */
8013 static int validate_scan_freqs(struct nlattr
*freqs
)
8015 struct nlattr
*attr1
, *attr2
;
8016 int n_channels
= 0, tmp1
, tmp2
;
8018 nla_for_each_nested(attr1
, freqs
, tmp1
)
8019 if (nla_len(attr1
) != sizeof(u32
))
8022 nla_for_each_nested(attr1
, freqs
, tmp1
) {
8025 * Some hardware has a limited channel list for
8026 * scanning, and it is pretty much nonsensical
8027 * to scan for a channel twice, so disallow that
8028 * and don't require drivers to check that the
8029 * channel list they get isn't longer than what
8030 * they can scan, as long as they can scan all
8031 * the channels they registered at once.
8033 nla_for_each_nested(attr2
, freqs
, tmp2
)
8034 if (attr1
!= attr2
&&
8035 nla_get_u32(attr1
) == nla_get_u32(attr2
))
8042 static bool is_band_valid(struct wiphy
*wiphy
, enum nl80211_band b
)
8044 return b
< NUM_NL80211_BANDS
&& wiphy
->bands
[b
];
8047 static int parse_bss_select(struct nlattr
*nla
, struct wiphy
*wiphy
,
8048 struct cfg80211_bss_selection
*bss_select
)
8050 struct nlattr
*attr
[NL80211_BSS_SELECT_ATTR_MAX
+ 1];
8051 struct nlattr
*nest
;
8056 /* only process one nested attribute */
8057 nest
= nla_data(nla
);
8058 if (!nla_ok(nest
, nla_len(nest
)))
8061 err
= nla_parse_nested_deprecated(attr
, NL80211_BSS_SELECT_ATTR_MAX
,
8062 nest
, nl80211_bss_select_policy
,
8067 /* only one attribute may be given */
8068 for (i
= 0; i
<= NL80211_BSS_SELECT_ATTR_MAX
; i
++) {
8076 bss_select
->behaviour
= __NL80211_BSS_SELECT_ATTR_INVALID
;
8078 if (attr
[NL80211_BSS_SELECT_ATTR_RSSI
])
8079 bss_select
->behaviour
= NL80211_BSS_SELECT_ATTR_RSSI
;
8081 if (attr
[NL80211_BSS_SELECT_ATTR_BAND_PREF
]) {
8082 bss_select
->behaviour
= NL80211_BSS_SELECT_ATTR_BAND_PREF
;
8083 bss_select
->param
.band_pref
=
8084 nla_get_u32(attr
[NL80211_BSS_SELECT_ATTR_BAND_PREF
]);
8085 if (!is_band_valid(wiphy
, bss_select
->param
.band_pref
))
8089 if (attr
[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST
]) {
8090 struct nl80211_bss_select_rssi_adjust
*adj_param
;
8092 adj_param
= nla_data(attr
[NL80211_BSS_SELECT_ATTR_RSSI_ADJUST
]);
8093 bss_select
->behaviour
= NL80211_BSS_SELECT_ATTR_RSSI_ADJUST
;
8094 bss_select
->param
.adjust
.band
= adj_param
->band
;
8095 bss_select
->param
.adjust
.delta
= adj_param
->delta
;
8096 if (!is_band_valid(wiphy
, bss_select
->param
.adjust
.band
))
8100 /* user-space did not provide behaviour attribute */
8101 if (bss_select
->behaviour
== __NL80211_BSS_SELECT_ATTR_INVALID
)
8104 if (!(wiphy
->bss_select_support
& BIT(bss_select
->behaviour
)))
8110 int nl80211_parse_random_mac(struct nlattr
**attrs
,
8111 u8
*mac_addr
, u8
*mac_addr_mask
)
8115 if (!attrs
[NL80211_ATTR_MAC
] && !attrs
[NL80211_ATTR_MAC_MASK
]) {
8116 eth_zero_addr(mac_addr
);
8117 eth_zero_addr(mac_addr_mask
);
8119 mac_addr_mask
[0] = 0x3;
8124 /* need both or none */
8125 if (!attrs
[NL80211_ATTR_MAC
] || !attrs
[NL80211_ATTR_MAC_MASK
])
8128 memcpy(mac_addr
, nla_data(attrs
[NL80211_ATTR_MAC
]), ETH_ALEN
);
8129 memcpy(mac_addr_mask
, nla_data(attrs
[NL80211_ATTR_MAC_MASK
]), ETH_ALEN
);
8131 /* don't allow or configure an mcast address */
8132 if (!is_multicast_ether_addr(mac_addr_mask
) ||
8133 is_multicast_ether_addr(mac_addr
))
8137 * allow users to pass a MAC address that has bits set outside
8138 * of the mask, but don't bother drivers with having to deal
8141 for (i
= 0; i
< ETH_ALEN
; i
++)
8142 mac_addr
[i
] &= mac_addr_mask
[i
];
8147 static bool cfg80211_off_channel_oper_allowed(struct wireless_dev
*wdev
)
8149 ASSERT_WDEV_LOCK(wdev
);
8151 if (!cfg80211_beaconing_iface_active(wdev
))
8154 if (!(wdev
->chandef
.chan
->flags
& IEEE80211_CHAN_RADAR
))
8157 return regulatory_pre_cac_allowed(wdev
->wiphy
);
8160 static bool nl80211_check_scan_feat(struct wiphy
*wiphy
, u32 flags
, u32 flag
,
8161 enum nl80211_ext_feature_index feat
)
8163 if (!(flags
& flag
))
8165 if (wiphy_ext_feature_isset(wiphy
, feat
))
8171 nl80211_check_scan_flags(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
8172 void *request
, struct nlattr
**attrs
,
8175 u8
*mac_addr
, *mac_addr_mask
;
8177 enum nl80211_feature_flags randomness_flag
;
8179 if (!attrs
[NL80211_ATTR_SCAN_FLAGS
])
8182 if (is_sched_scan
) {
8183 struct cfg80211_sched_scan_request
*req
= request
;
8185 randomness_flag
= wdev
?
8186 NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR
:
8187 NL80211_FEATURE_ND_RANDOM_MAC_ADDR
;
8188 flags
= &req
->flags
;
8189 mac_addr
= req
->mac_addr
;
8190 mac_addr_mask
= req
->mac_addr_mask
;
8192 struct cfg80211_scan_request
*req
= request
;
8194 randomness_flag
= NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR
;
8195 flags
= &req
->flags
;
8196 mac_addr
= req
->mac_addr
;
8197 mac_addr_mask
= req
->mac_addr_mask
;
8200 *flags
= nla_get_u32(attrs
[NL80211_ATTR_SCAN_FLAGS
]);
8202 if (((*flags
& NL80211_SCAN_FLAG_LOW_PRIORITY
) &&
8203 !(wiphy
->features
& NL80211_FEATURE_LOW_PRIORITY_SCAN
)) ||
8204 !nl80211_check_scan_feat(wiphy
, *flags
,
8205 NL80211_SCAN_FLAG_LOW_SPAN
,
8206 NL80211_EXT_FEATURE_LOW_SPAN_SCAN
) ||
8207 !nl80211_check_scan_feat(wiphy
, *flags
,
8208 NL80211_SCAN_FLAG_LOW_POWER
,
8209 NL80211_EXT_FEATURE_LOW_POWER_SCAN
) ||
8210 !nl80211_check_scan_feat(wiphy
, *flags
,
8211 NL80211_SCAN_FLAG_HIGH_ACCURACY
,
8212 NL80211_EXT_FEATURE_HIGH_ACCURACY_SCAN
) ||
8213 !nl80211_check_scan_feat(wiphy
, *flags
,
8214 NL80211_SCAN_FLAG_FILS_MAX_CHANNEL_TIME
,
8215 NL80211_EXT_FEATURE_FILS_MAX_CHANNEL_TIME
) ||
8216 !nl80211_check_scan_feat(wiphy
, *flags
,
8217 NL80211_SCAN_FLAG_ACCEPT_BCAST_PROBE_RESP
,
8218 NL80211_EXT_FEATURE_ACCEPT_BCAST_PROBE_RESP
) ||
8219 !nl80211_check_scan_feat(wiphy
, *flags
,
8220 NL80211_SCAN_FLAG_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION
,
8221 NL80211_EXT_FEATURE_OCE_PROBE_REQ_DEFERRAL_SUPPRESSION
) ||
8222 !nl80211_check_scan_feat(wiphy
, *flags
,
8223 NL80211_SCAN_FLAG_OCE_PROBE_REQ_HIGH_TX_RATE
,
8224 NL80211_EXT_FEATURE_OCE_PROBE_REQ_HIGH_TX_RATE
) ||
8225 !nl80211_check_scan_feat(wiphy
, *flags
,
8226 NL80211_SCAN_FLAG_RANDOM_SN
,
8227 NL80211_EXT_FEATURE_SCAN_RANDOM_SN
) ||
8228 !nl80211_check_scan_feat(wiphy
, *flags
,
8229 NL80211_SCAN_FLAG_MIN_PREQ_CONTENT
,
8230 NL80211_EXT_FEATURE_SCAN_MIN_PREQ_CONTENT
))
8233 if (*flags
& NL80211_SCAN_FLAG_RANDOM_ADDR
) {
8236 if (!(wiphy
->features
& randomness_flag
) ||
8237 (wdev
&& wdev
->current_bss
))
8240 err
= nl80211_parse_random_mac(attrs
, mac_addr
, mac_addr_mask
);
8248 static int nl80211_trigger_scan(struct sk_buff
*skb
, struct genl_info
*info
)
8250 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8251 struct wireless_dev
*wdev
= info
->user_ptr
[1];
8252 struct cfg80211_scan_request
*request
;
8253 struct nlattr
*scan_freqs
= NULL
;
8254 bool scan_freqs_khz
= false;
8255 struct nlattr
*attr
;
8256 struct wiphy
*wiphy
;
8257 int err
, tmp
, n_ssids
= 0, n_channels
, i
;
8260 wiphy
= &rdev
->wiphy
;
8262 if (wdev
->iftype
== NL80211_IFTYPE_NAN
)
8265 if (!rdev
->ops
->scan
)
8268 if (rdev
->scan_req
|| rdev
->scan_msg
)
8271 if (info
->attrs
[NL80211_ATTR_SCAN_FREQ_KHZ
]) {
8272 if (!wiphy_ext_feature_isset(wiphy
,
8273 NL80211_EXT_FEATURE_SCAN_FREQ_KHZ
))
8275 scan_freqs
= info
->attrs
[NL80211_ATTR_SCAN_FREQ_KHZ
];
8276 scan_freqs_khz
= true;
8277 } else if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
])
8278 scan_freqs
= info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
];
8281 n_channels
= validate_scan_freqs(scan_freqs
);
8285 n_channels
= ieee80211_get_num_supported_channels(wiphy
);
8288 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
])
8289 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
], tmp
)
8292 if (n_ssids
> wiphy
->max_scan_ssids
)
8295 if (info
->attrs
[NL80211_ATTR_IE
])
8296 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
8300 if (ie_len
> wiphy
->max_scan_ie_len
)
8303 request
= kzalloc(sizeof(*request
)
8304 + sizeof(*request
->ssids
) * n_ssids
8305 + sizeof(*request
->channels
) * n_channels
8306 + ie_len
, GFP_KERNEL
);
8311 request
->ssids
= (void *)&request
->channels
[n_channels
];
8312 request
->n_ssids
= n_ssids
;
8315 request
->ie
= (void *)(request
->ssids
+ n_ssids
);
8317 request
->ie
= (void *)(request
->channels
+ n_channels
);
8322 /* user specified, bail out if channel not found */
8323 nla_for_each_nested(attr
, scan_freqs
, tmp
) {
8324 struct ieee80211_channel
*chan
;
8325 int freq
= nla_get_u32(attr
);
8327 if (!scan_freqs_khz
)
8328 freq
= MHZ_TO_KHZ(freq
);
8330 chan
= ieee80211_get_channel_khz(wiphy
, freq
);
8336 /* ignore disabled channels */
8337 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
8340 request
->channels
[i
] = chan
;
8344 enum nl80211_band band
;
8347 for (band
= 0; band
< NUM_NL80211_BANDS
; band
++) {
8350 if (!wiphy
->bands
[band
])
8352 for (j
= 0; j
< wiphy
->bands
[band
]->n_channels
; j
++) {
8353 struct ieee80211_channel
*chan
;
8355 chan
= &wiphy
->bands
[band
]->channels
[j
];
8357 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
8360 request
->channels
[i
] = chan
;
8371 request
->n_channels
= i
;
8374 if (!cfg80211_off_channel_oper_allowed(wdev
)) {
8375 struct ieee80211_channel
*chan
;
8377 if (request
->n_channels
!= 1) {
8383 chan
= request
->channels
[0];
8384 if (chan
->center_freq
!= wdev
->chandef
.chan
->center_freq
) {
8394 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
], tmp
) {
8395 if (nla_len(attr
) > IEEE80211_MAX_SSID_LEN
) {
8399 request
->ssids
[i
].ssid_len
= nla_len(attr
);
8400 memcpy(request
->ssids
[i
].ssid
, nla_data(attr
), nla_len(attr
));
8405 if (info
->attrs
[NL80211_ATTR_IE
]) {
8406 request
->ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
8407 memcpy((void *)request
->ie
,
8408 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
8412 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++)
8413 if (wiphy
->bands
[i
])
8415 (1 << wiphy
->bands
[i
]->n_bitrates
) - 1;
8417 if (info
->attrs
[NL80211_ATTR_SCAN_SUPP_RATES
]) {
8418 nla_for_each_nested(attr
,
8419 info
->attrs
[NL80211_ATTR_SCAN_SUPP_RATES
],
8421 enum nl80211_band band
= nla_type(attr
);
8423 if (band
< 0 || band
>= NUM_NL80211_BANDS
) {
8428 if (!wiphy
->bands
[band
])
8431 err
= ieee80211_get_ratemask(wiphy
->bands
[band
],
8434 &request
->rates
[band
]);
8440 if (info
->attrs
[NL80211_ATTR_MEASUREMENT_DURATION
]) {
8442 nla_get_u16(info
->attrs
[NL80211_ATTR_MEASUREMENT_DURATION
]);
8443 request
->duration_mandatory
=
8444 nla_get_flag(info
->attrs
[NL80211_ATTR_MEASUREMENT_DURATION_MANDATORY
]);
8447 err
= nl80211_check_scan_flags(wiphy
, wdev
, request
, info
->attrs
,
8453 nla_get_flag(info
->attrs
[NL80211_ATTR_TX_NO_CCK_RATE
]);
8455 /* Initial implementation used NL80211_ATTR_MAC to set the specific
8456 * BSSID to scan for. This was problematic because that same attribute
8457 * was already used for another purpose (local random MAC address). The
8458 * NL80211_ATTR_BSSID attribute was added to fix this. For backwards
8459 * compatibility with older userspace components, also use the
8460 * NL80211_ATTR_MAC value here if it can be determined to be used for
8461 * the specific BSSID use case instead of the random MAC address
8462 * (NL80211_ATTR_SCAN_FLAGS is used to enable random MAC address use).
8464 if (info
->attrs
[NL80211_ATTR_BSSID
])
8465 memcpy(request
->bssid
,
8466 nla_data(info
->attrs
[NL80211_ATTR_BSSID
]), ETH_ALEN
);
8467 else if (!(request
->flags
& NL80211_SCAN_FLAG_RANDOM_ADDR
) &&
8468 info
->attrs
[NL80211_ATTR_MAC
])
8469 memcpy(request
->bssid
, nla_data(info
->attrs
[NL80211_ATTR_MAC
]),
8472 eth_broadcast_addr(request
->bssid
);
8474 request
->wdev
= wdev
;
8475 request
->wiphy
= &rdev
->wiphy
;
8476 request
->scan_start
= jiffies
;
8478 rdev
->scan_req
= request
;
8479 err
= cfg80211_scan(rdev
);
8484 nl80211_send_scan_start(rdev
, wdev
);
8486 dev_hold(wdev
->netdev
);
8491 rdev
->scan_req
= NULL
;
8497 static int nl80211_abort_scan(struct sk_buff
*skb
, struct genl_info
*info
)
8499 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8500 struct wireless_dev
*wdev
= info
->user_ptr
[1];
8502 if (!rdev
->ops
->abort_scan
)
8508 if (!rdev
->scan_req
)
8511 rdev_abort_scan(rdev
, wdev
);
8516 nl80211_parse_sched_scan_plans(struct wiphy
*wiphy
, int n_plans
,
8517 struct cfg80211_sched_scan_request
*request
,
8518 struct nlattr
**attrs
)
8520 int tmp
, err
, i
= 0;
8521 struct nlattr
*attr
;
8523 if (!attrs
[NL80211_ATTR_SCHED_SCAN_PLANS
]) {
8527 * If scan plans are not specified,
8528 * %NL80211_ATTR_SCHED_SCAN_INTERVAL will be specified. In this
8529 * case one scan plan will be set with the specified scan
8530 * interval and infinite number of iterations.
8532 interval
= nla_get_u32(attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
]);
8536 request
->scan_plans
[0].interval
=
8537 DIV_ROUND_UP(interval
, MSEC_PER_SEC
);
8538 if (!request
->scan_plans
[0].interval
)
8541 if (request
->scan_plans
[0].interval
>
8542 wiphy
->max_sched_scan_plan_interval
)
8543 request
->scan_plans
[0].interval
=
8544 wiphy
->max_sched_scan_plan_interval
;
8549 nla_for_each_nested(attr
, attrs
[NL80211_ATTR_SCHED_SCAN_PLANS
], tmp
) {
8550 struct nlattr
*plan
[NL80211_SCHED_SCAN_PLAN_MAX
+ 1];
8552 if (WARN_ON(i
>= n_plans
))
8555 err
= nla_parse_nested_deprecated(plan
,
8556 NL80211_SCHED_SCAN_PLAN_MAX
,
8557 attr
, nl80211_plan_policy
,
8562 if (!plan
[NL80211_SCHED_SCAN_PLAN_INTERVAL
])
8565 request
->scan_plans
[i
].interval
=
8566 nla_get_u32(plan
[NL80211_SCHED_SCAN_PLAN_INTERVAL
]);
8567 if (!request
->scan_plans
[i
].interval
||
8568 request
->scan_plans
[i
].interval
>
8569 wiphy
->max_sched_scan_plan_interval
)
8572 if (plan
[NL80211_SCHED_SCAN_PLAN_ITERATIONS
]) {
8573 request
->scan_plans
[i
].iterations
=
8574 nla_get_u32(plan
[NL80211_SCHED_SCAN_PLAN_ITERATIONS
]);
8575 if (!request
->scan_plans
[i
].iterations
||
8576 (request
->scan_plans
[i
].iterations
>
8577 wiphy
->max_sched_scan_plan_iterations
))
8579 } else if (i
< n_plans
- 1) {
8581 * All scan plans but the last one must specify
8582 * a finite number of iterations
8591 * The last scan plan must not specify the number of
8592 * iterations, it is supposed to run infinitely
8594 if (request
->scan_plans
[n_plans
- 1].iterations
)
8601 nl80211_parse_sched_scan_per_band_rssi(struct wiphy
*wiphy
,
8602 struct cfg80211_match_set
*match_sets
,
8603 struct nlattr
*tb_band_rssi
,
8606 struct nlattr
*attr
;
8607 int i
, tmp
, ret
= 0;
8609 if (!wiphy_ext_feature_isset(wiphy
,
8610 NL80211_EXT_FEATURE_SCHED_SCAN_BAND_SPECIFIC_RSSI_THOLD
)) {
8614 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++)
8615 match_sets
->per_band_rssi_thold
[i
] =
8616 NL80211_SCAN_RSSI_THOLD_OFF
;
8620 for (i
= 0; i
< NUM_NL80211_BANDS
; i
++)
8621 match_sets
->per_band_rssi_thold
[i
] = rssi_thold
;
8623 nla_for_each_nested(attr
, tb_band_rssi
, tmp
) {
8624 enum nl80211_band band
= nla_type(attr
);
8626 if (band
< 0 || band
>= NUM_NL80211_BANDS
)
8629 match_sets
->per_band_rssi_thold
[band
] = nla_get_s32(attr
);
8635 static struct cfg80211_sched_scan_request
*
8636 nl80211_parse_sched_scan(struct wiphy
*wiphy
, struct wireless_dev
*wdev
,
8637 struct nlattr
**attrs
, int max_match_sets
)
8639 struct cfg80211_sched_scan_request
*request
;
8640 struct nlattr
*attr
;
8641 int err
, tmp
, n_ssids
= 0, n_match_sets
= 0, n_channels
, i
, n_plans
= 0;
8642 enum nl80211_band band
;
8644 struct nlattr
*tb
[NL80211_SCHED_SCAN_MATCH_ATTR_MAX
+ 1];
8645 s32 default_match_rssi
= NL80211_SCAN_RSSI_THOLD_OFF
;
8647 if (attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
8648 n_channels
= validate_scan_freqs(
8649 attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]);
8651 return ERR_PTR(-EINVAL
);
8653 n_channels
= ieee80211_get_num_supported_channels(wiphy
);
8656 if (attrs
[NL80211_ATTR_SCAN_SSIDS
])
8657 nla_for_each_nested(attr
, attrs
[NL80211_ATTR_SCAN_SSIDS
],
8661 if (n_ssids
> wiphy
->max_sched_scan_ssids
)
8662 return ERR_PTR(-EINVAL
);
8665 * First, count the number of 'real' matchsets. Due to an issue with
8666 * the old implementation, matchsets containing only the RSSI attribute
8667 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
8668 * RSSI for all matchsets, rather than their own matchset for reporting
8669 * all APs with a strong RSSI. This is needed to be compatible with
8670 * older userspace that treated a matchset with only the RSSI as the
8671 * global RSSI for all other matchsets - if there are other matchsets.
8673 if (attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
]) {
8674 nla_for_each_nested(attr
,
8675 attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
],
8677 struct nlattr
*rssi
;
8679 err
= nla_parse_nested_deprecated(tb
,
8680 NL80211_SCHED_SCAN_MATCH_ATTR_MAX
,
8682 nl80211_match_policy
,
8685 return ERR_PTR(err
);
8687 /* SSID and BSSID are mutually exclusive */
8688 if (tb
[NL80211_SCHED_SCAN_MATCH_ATTR_SSID
] &&
8689 tb
[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID
])
8690 return ERR_PTR(-EINVAL
);
8692 /* add other standalone attributes here */
8693 if (tb
[NL80211_SCHED_SCAN_MATCH_ATTR_SSID
] ||
8694 tb
[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID
]) {
8698 rssi
= tb
[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
];
8700 default_match_rssi
= nla_get_s32(rssi
);
8704 /* However, if there's no other matchset, add the RSSI one */
8705 if (!n_match_sets
&& default_match_rssi
!= NL80211_SCAN_RSSI_THOLD_OFF
)
8708 if (n_match_sets
> max_match_sets
)
8709 return ERR_PTR(-EINVAL
);
8711 if (attrs
[NL80211_ATTR_IE
])
8712 ie_len
= nla_len(attrs
[NL80211_ATTR_IE
]);
8716 if (ie_len
> wiphy
->max_sched_scan_ie_len
)
8717 return ERR_PTR(-EINVAL
);
8719 if (attrs
[NL80211_ATTR_SCHED_SCAN_PLANS
]) {
8721 * NL80211_ATTR_SCHED_SCAN_INTERVAL must not be specified since
8722 * each scan plan already specifies its own interval
8724 if (attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
])
8725 return ERR_PTR(-EINVAL
);
8727 nla_for_each_nested(attr
,
8728 attrs
[NL80211_ATTR_SCHED_SCAN_PLANS
], tmp
)
8732 * The scan interval attribute is kept for backward
8733 * compatibility. If no scan plans are specified and sched scan
8734 * interval is specified, one scan plan will be set with this
8735 * scan interval and infinite number of iterations.
8737 if (!attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
])
8738 return ERR_PTR(-EINVAL
);
8743 if (!n_plans
|| n_plans
> wiphy
->max_sched_scan_plans
)
8744 return ERR_PTR(-EINVAL
);
8746 if (!wiphy_ext_feature_isset(
8747 wiphy
, NL80211_EXT_FEATURE_SCHED_SCAN_RELATIVE_RSSI
) &&
8748 (attrs
[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI
] ||
8749 attrs
[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST
]))
8750 return ERR_PTR(-EINVAL
);
8752 request
= kzalloc(sizeof(*request
)
8753 + sizeof(*request
->ssids
) * n_ssids
8754 + sizeof(*request
->match_sets
) * n_match_sets
8755 + sizeof(*request
->scan_plans
) * n_plans
8756 + sizeof(*request
->channels
) * n_channels
8757 + ie_len
, GFP_KERNEL
);
8759 return ERR_PTR(-ENOMEM
);
8762 request
->ssids
= (void *)&request
->channels
[n_channels
];
8763 request
->n_ssids
= n_ssids
;
8766 request
->ie
= (void *)(request
->ssids
+ n_ssids
);
8768 request
->ie
= (void *)(request
->channels
+ n_channels
);
8773 request
->match_sets
= (void *)(request
->ie
+ ie_len
);
8775 request
->match_sets
=
8776 (void *)(request
->ssids
+ n_ssids
);
8778 request
->match_sets
=
8779 (void *)(request
->channels
+ n_channels
);
8781 request
->n_match_sets
= n_match_sets
;
8784 request
->scan_plans
= (void *)(request
->match_sets
+
8786 else if (request
->ie
)
8787 request
->scan_plans
= (void *)(request
->ie
+ ie_len
);
8789 request
->scan_plans
= (void *)(request
->ssids
+ n_ssids
);
8791 request
->scan_plans
= (void *)(request
->channels
+ n_channels
);
8793 request
->n_scan_plans
= n_plans
;
8796 if (attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
8797 /* user specified, bail out if channel not found */
8798 nla_for_each_nested(attr
,
8799 attrs
[NL80211_ATTR_SCAN_FREQUENCIES
],
8801 struct ieee80211_channel
*chan
;
8803 chan
= ieee80211_get_channel(wiphy
, nla_get_u32(attr
));
8810 /* ignore disabled channels */
8811 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
8814 request
->channels
[i
] = chan
;
8819 for (band
= 0; band
< NUM_NL80211_BANDS
; band
++) {
8822 if (!wiphy
->bands
[band
])
8824 for (j
= 0; j
< wiphy
->bands
[band
]->n_channels
; j
++) {
8825 struct ieee80211_channel
*chan
;
8827 chan
= &wiphy
->bands
[band
]->channels
[j
];
8829 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
8832 request
->channels
[i
] = chan
;
8843 request
->n_channels
= i
;
8847 nla_for_each_nested(attr
, attrs
[NL80211_ATTR_SCAN_SSIDS
],
8849 if (nla_len(attr
) > IEEE80211_MAX_SSID_LEN
) {
8853 request
->ssids
[i
].ssid_len
= nla_len(attr
);
8854 memcpy(request
->ssids
[i
].ssid
, nla_data(attr
),
8861 if (attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
]) {
8862 nla_for_each_nested(attr
,
8863 attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
],
8865 struct nlattr
*ssid
, *bssid
, *rssi
;
8867 err
= nla_parse_nested_deprecated(tb
,
8868 NL80211_SCHED_SCAN_MATCH_ATTR_MAX
,
8870 nl80211_match_policy
,
8874 ssid
= tb
[NL80211_SCHED_SCAN_MATCH_ATTR_SSID
];
8875 bssid
= tb
[NL80211_SCHED_SCAN_MATCH_ATTR_BSSID
];
8877 if (!ssid
&& !bssid
) {
8882 if (WARN_ON(i
>= n_match_sets
)) {
8883 /* this indicates a programming error,
8884 * the loop above should have verified
8892 memcpy(request
->match_sets
[i
].ssid
.ssid
,
8893 nla_data(ssid
), nla_len(ssid
));
8894 request
->match_sets
[i
].ssid
.ssid_len
=
8898 memcpy(request
->match_sets
[i
].bssid
,
8899 nla_data(bssid
), ETH_ALEN
);
8901 /* special attribute - old implementation w/a */
8902 request
->match_sets
[i
].rssi_thold
= default_match_rssi
;
8903 rssi
= tb
[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
];
8905 request
->match_sets
[i
].rssi_thold
=
8908 /* Parse per band RSSI attribute */
8909 err
= nl80211_parse_sched_scan_per_band_rssi(wiphy
,
8910 &request
->match_sets
[i
],
8911 tb
[NL80211_SCHED_SCAN_MATCH_PER_BAND_RSSI
],
8912 request
->match_sets
[i
].rssi_thold
);
8919 /* there was no other matchset, so the RSSI one is alone */
8920 if (i
== 0 && n_match_sets
)
8921 request
->match_sets
[0].rssi_thold
= default_match_rssi
;
8923 request
->min_rssi_thold
= INT_MAX
;
8924 for (i
= 0; i
< n_match_sets
; i
++)
8925 request
->min_rssi_thold
=
8926 min(request
->match_sets
[i
].rssi_thold
,
8927 request
->min_rssi_thold
);
8929 request
->min_rssi_thold
= NL80211_SCAN_RSSI_THOLD_OFF
;
8933 request
->ie_len
= ie_len
;
8934 memcpy((void *)request
->ie
,
8935 nla_data(attrs
[NL80211_ATTR_IE
]),
8939 err
= nl80211_check_scan_flags(wiphy
, wdev
, request
, attrs
, true);
8943 if (attrs
[NL80211_ATTR_SCHED_SCAN_DELAY
])
8945 nla_get_u32(attrs
[NL80211_ATTR_SCHED_SCAN_DELAY
]);
8947 if (attrs
[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI
]) {
8948 request
->relative_rssi
= nla_get_s8(
8949 attrs
[NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI
]);
8950 request
->relative_rssi_set
= true;
8953 if (request
->relative_rssi_set
&&
8954 attrs
[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST
]) {
8955 struct nl80211_bss_select_rssi_adjust
*rssi_adjust
;
8957 rssi_adjust
= nla_data(
8958 attrs
[NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST
]);
8959 request
->rssi_adjust
.band
= rssi_adjust
->band
;
8960 request
->rssi_adjust
.delta
= rssi_adjust
->delta
;
8961 if (!is_band_valid(wiphy
, request
->rssi_adjust
.band
)) {
8967 err
= nl80211_parse_sched_scan_plans(wiphy
, n_plans
, request
, attrs
);
8971 request
->scan_start
= jiffies
;
8977 return ERR_PTR(err
);
8980 static int nl80211_start_sched_scan(struct sk_buff
*skb
,
8981 struct genl_info
*info
)
8983 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8984 struct net_device
*dev
= info
->user_ptr
[1];
8985 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
8986 struct cfg80211_sched_scan_request
*sched_scan_req
;
8990 if (!rdev
->wiphy
.max_sched_scan_reqs
|| !rdev
->ops
->sched_scan_start
)
8993 want_multi
= info
->attrs
[NL80211_ATTR_SCHED_SCAN_MULTI
];
8994 err
= cfg80211_sched_scan_req_possible(rdev
, want_multi
);
8998 sched_scan_req
= nl80211_parse_sched_scan(&rdev
->wiphy
, wdev
,
9000 rdev
->wiphy
.max_match_sets
);
9002 err
= PTR_ERR_OR_ZERO(sched_scan_req
);
9006 /* leave request id zero for legacy request
9007 * or if driver does not support multi-scheduled scan
9009 if (want_multi
&& rdev
->wiphy
.max_sched_scan_reqs
> 1)
9010 sched_scan_req
->reqid
= cfg80211_assign_cookie(rdev
);
9012 err
= rdev_sched_scan_start(rdev
, dev
, sched_scan_req
);
9016 sched_scan_req
->dev
= dev
;
9017 sched_scan_req
->wiphy
= &rdev
->wiphy
;
9019 if (info
->attrs
[NL80211_ATTR_SOCKET_OWNER
])
9020 sched_scan_req
->owner_nlportid
= info
->snd_portid
;
9022 cfg80211_add_sched_scan_req(rdev
, sched_scan_req
);
9024 nl80211_send_sched_scan(sched_scan_req
, NL80211_CMD_START_SCHED_SCAN
);
9028 kfree(sched_scan_req
);
9033 static int nl80211_stop_sched_scan(struct sk_buff
*skb
,
9034 struct genl_info
*info
)
9036 struct cfg80211_sched_scan_request
*req
;
9037 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9040 if (!rdev
->wiphy
.max_sched_scan_reqs
|| !rdev
->ops
->sched_scan_stop
)
9043 if (info
->attrs
[NL80211_ATTR_COOKIE
]) {
9044 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
9045 return __cfg80211_stop_sched_scan(rdev
, cookie
, false);
9048 req
= list_first_or_null_rcu(&rdev
->sched_scan_req_list
,
9049 struct cfg80211_sched_scan_request
,
9051 if (!req
|| req
->reqid
||
9052 (req
->owner_nlportid
&&
9053 req
->owner_nlportid
!= info
->snd_portid
))
9056 return cfg80211_stop_sched_scan_req(rdev
, req
, false);
9059 static int nl80211_start_radar_detection(struct sk_buff
*skb
,
9060 struct genl_info
*info
)
9062 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9063 struct net_device
*dev
= info
->user_ptr
[1];
9064 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
9065 struct wiphy
*wiphy
= wdev
->wiphy
;
9066 struct cfg80211_chan_def chandef
;
9067 enum nl80211_dfs_regions dfs_region
;
9068 unsigned int cac_time_ms
;
9071 dfs_region
= reg_get_dfs_region(wiphy
);
9072 if (dfs_region
== NL80211_DFS_UNSET
)
9075 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
9079 if (netif_carrier_ok(dev
))
9082 if (wdev
->cac_started
)
9085 err
= cfg80211_chandef_dfs_required(wiphy
, &chandef
, wdev
->iftype
);
9092 if (!cfg80211_chandef_dfs_usable(wiphy
, &chandef
))
9095 /* CAC start is offloaded to HW and can't be started manually */
9096 if (wiphy_ext_feature_isset(wiphy
, NL80211_EXT_FEATURE_DFS_OFFLOAD
))
9099 if (!rdev
->ops
->start_radar_detection
)
9102 cac_time_ms
= cfg80211_chandef_dfs_cac_time(&rdev
->wiphy
, &chandef
);
9103 if (WARN_ON(!cac_time_ms
))
9104 cac_time_ms
= IEEE80211_DFS_MIN_CAC_TIME_MS
;
9106 err
= rdev_start_radar_detection(rdev
, dev
, &chandef
, cac_time_ms
);
9108 wdev
->chandef
= chandef
;
9109 wdev
->cac_started
= true;
9110 wdev
->cac_start_time
= jiffies
;
9111 wdev
->cac_time_ms
= cac_time_ms
;
9116 static int nl80211_notify_radar_detection(struct sk_buff
*skb
,
9117 struct genl_info
*info
)
9119 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9120 struct net_device
*dev
= info
->user_ptr
[1];
9121 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
9122 struct wiphy
*wiphy
= wdev
->wiphy
;
9123 struct cfg80211_chan_def chandef
;
9124 enum nl80211_dfs_regions dfs_region
;
9127 dfs_region
= reg_get_dfs_region(wiphy
);
9128 if (dfs_region
== NL80211_DFS_UNSET
) {
9129 GENL_SET_ERR_MSG(info
,
9130 "DFS Region is not set. Unexpected Radar indication");
9134 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
9136 GENL_SET_ERR_MSG(info
, "Unable to extract chandef info");
9140 err
= cfg80211_chandef_dfs_required(wiphy
, &chandef
, wdev
->iftype
);
9142 GENL_SET_ERR_MSG(info
, "chandef is invalid");
9147 GENL_SET_ERR_MSG(info
,
9148 "Unexpected Radar indication for chandef/iftype");
9152 /* Do not process this notification if radar is already detected
9153 * by kernel on this channel, and return success.
9155 if (chandef
.chan
->dfs_state
== NL80211_DFS_UNAVAILABLE
)
9158 cfg80211_set_dfs_state(wiphy
, &chandef
, NL80211_DFS_UNAVAILABLE
);
9160 cfg80211_sched_dfs_chan_update(rdev
);
9162 rdev
->radar_chandef
= chandef
;
9164 /* Propagate this notification to other radios as well */
9165 queue_work(cfg80211_wq
, &rdev
->propagate_radar_detect_wk
);
9170 static int nl80211_channel_switch(struct sk_buff
*skb
, struct genl_info
*info
)
9172 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9173 struct net_device
*dev
= info
->user_ptr
[1];
9174 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
9175 struct cfg80211_csa_settings params
;
9176 struct nlattr
**csa_attrs
= NULL
;
9178 bool need_new_beacon
= false;
9179 bool need_handle_dfs_flag
= true;
9183 if (!rdev
->ops
->channel_switch
||
9184 !(rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_CHANNEL_SWITCH
))
9187 switch (dev
->ieee80211_ptr
->iftype
) {
9188 case NL80211_IFTYPE_AP
:
9189 case NL80211_IFTYPE_P2P_GO
:
9190 need_new_beacon
= true;
9191 /* For all modes except AP the handle_dfs flag needs to be
9192 * supplied to tell the kernel that userspace will handle radar
9193 * events when they happen. Otherwise a switch to a channel
9194 * requiring DFS will be rejected.
9196 need_handle_dfs_flag
= false;
9198 /* useless if AP is not running */
9199 if (!wdev
->beacon_interval
)
9202 case NL80211_IFTYPE_ADHOC
:
9203 if (!wdev
->ssid_len
)
9206 case NL80211_IFTYPE_MESH_POINT
:
9207 if (!wdev
->mesh_id_len
)
9214 memset(¶ms
, 0, sizeof(params
));
9215 params
.beacon_csa
.ftm_responder
= -1;
9217 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
] ||
9218 !info
->attrs
[NL80211_ATTR_CH_SWITCH_COUNT
])
9221 /* only important for AP, IBSS and mesh create IEs internally */
9222 if (need_new_beacon
&& !info
->attrs
[NL80211_ATTR_CSA_IES
])
9225 /* Even though the attribute is u32, the specification says
9226 * u8, so let's make sure we don't overflow.
9228 cs_count
= nla_get_u32(info
->attrs
[NL80211_ATTR_CH_SWITCH_COUNT
]);
9232 params
.count
= cs_count
;
9234 if (!need_new_beacon
)
9237 err
= nl80211_parse_beacon(rdev
, info
->attrs
, ¶ms
.beacon_after
);
9241 csa_attrs
= kcalloc(NL80211_ATTR_MAX
+ 1, sizeof(*csa_attrs
),
9246 err
= nla_parse_nested_deprecated(csa_attrs
, NL80211_ATTR_MAX
,
9247 info
->attrs
[NL80211_ATTR_CSA_IES
],
9248 nl80211_policy
, info
->extack
);
9252 err
= nl80211_parse_beacon(rdev
, csa_attrs
, ¶ms
.beacon_csa
);
9256 if (!csa_attrs
[NL80211_ATTR_CNTDWN_OFFS_BEACON
]) {
9261 len
= nla_len(csa_attrs
[NL80211_ATTR_CNTDWN_OFFS_BEACON
]);
9262 if (!len
|| (len
% sizeof(u16
))) {
9267 params
.n_counter_offsets_beacon
= len
/ sizeof(u16
);
9268 if (rdev
->wiphy
.max_num_csa_counters
&&
9269 (params
.n_counter_offsets_beacon
>
9270 rdev
->wiphy
.max_num_csa_counters
)) {
9275 params
.counter_offsets_beacon
=
9276 nla_data(csa_attrs
[NL80211_ATTR_CNTDWN_OFFS_BEACON
]);
9278 /* sanity checks - counters should fit and be the same */
9279 for (i
= 0; i
< params
.n_counter_offsets_beacon
; i
++) {
9280 u16 offset
= params
.counter_offsets_beacon
[i
];
9282 if (offset
>= params
.beacon_csa
.tail_len
) {
9287 if (params
.beacon_csa
.tail
[offset
] != params
.count
) {
9293 if (csa_attrs
[NL80211_ATTR_CNTDWN_OFFS_PRESP
]) {
9294 len
= nla_len(csa_attrs
[NL80211_ATTR_CNTDWN_OFFS_PRESP
]);
9295 if (!len
|| (len
% sizeof(u16
))) {
9300 params
.n_counter_offsets_presp
= len
/ sizeof(u16
);
9301 if (rdev
->wiphy
.max_num_csa_counters
&&
9302 (params
.n_counter_offsets_presp
>
9303 rdev
->wiphy
.max_num_csa_counters
)) {
9308 params
.counter_offsets_presp
=
9309 nla_data(csa_attrs
[NL80211_ATTR_CNTDWN_OFFS_PRESP
]);
9311 /* sanity checks - counters should fit and be the same */
9312 for (i
= 0; i
< params
.n_counter_offsets_presp
; i
++) {
9313 u16 offset
= params
.counter_offsets_presp
[i
];
9315 if (offset
>= params
.beacon_csa
.probe_resp_len
) {
9320 if (params
.beacon_csa
.probe_resp
[offset
] !=
9329 err
= nl80211_parse_chandef(rdev
, info
, ¶ms
.chandef
);
9333 if (!cfg80211_reg_can_beacon_relax(&rdev
->wiphy
, ¶ms
.chandef
,
9339 err
= cfg80211_chandef_dfs_required(wdev
->wiphy
,
9346 params
.radar_required
= true;
9347 if (need_handle_dfs_flag
&&
9348 !nla_get_flag(info
->attrs
[NL80211_ATTR_HANDLE_DFS
])) {
9354 if (info
->attrs
[NL80211_ATTR_CH_SWITCH_BLOCK_TX
])
9355 params
.block_tx
= true;
9358 err
= rdev_channel_switch(rdev
, dev
, ¶ms
);
9366 static int nl80211_send_bss(struct sk_buff
*msg
, struct netlink_callback
*cb
,
9368 struct cfg80211_registered_device
*rdev
,
9369 struct wireless_dev
*wdev
,
9370 struct cfg80211_internal_bss
*intbss
)
9372 struct cfg80211_bss
*res
= &intbss
->pub
;
9373 const struct cfg80211_bss_ies
*ies
;
9377 ASSERT_WDEV_LOCK(wdev
);
9379 hdr
= nl80211hdr_put(msg
, NETLINK_CB(cb
->skb
).portid
, seq
, flags
,
9380 NL80211_CMD_NEW_SCAN_RESULTS
);
9384 genl_dump_check_consistent(cb
, hdr
);
9386 if (nla_put_u32(msg
, NL80211_ATTR_GENERATION
, rdev
->bss_generation
))
9387 goto nla_put_failure
;
9389 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, wdev
->netdev
->ifindex
))
9390 goto nla_put_failure
;
9391 if (nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
9393 goto nla_put_failure
;
9395 bss
= nla_nest_start_noflag(msg
, NL80211_ATTR_BSS
);
9397 goto nla_put_failure
;
9398 if ((!is_zero_ether_addr(res
->bssid
) &&
9399 nla_put(msg
, NL80211_BSS_BSSID
, ETH_ALEN
, res
->bssid
)))
9400 goto nla_put_failure
;
9403 /* indicate whether we have probe response data or not */
9404 if (rcu_access_pointer(res
->proberesp_ies
) &&
9405 nla_put_flag(msg
, NL80211_BSS_PRESP_DATA
))
9406 goto fail_unlock_rcu
;
9408 /* this pointer prefers to be pointed to probe response data
9409 * but is always valid
9411 ies
= rcu_dereference(res
->ies
);
9413 if (nla_put_u64_64bit(msg
, NL80211_BSS_TSF
, ies
->tsf
,
9415 goto fail_unlock_rcu
;
9416 if (ies
->len
&& nla_put(msg
, NL80211_BSS_INFORMATION_ELEMENTS
,
9417 ies
->len
, ies
->data
))
9418 goto fail_unlock_rcu
;
9421 /* and this pointer is always (unless driver didn't know) beacon data */
9422 ies
= rcu_dereference(res
->beacon_ies
);
9423 if (ies
&& ies
->from_beacon
) {
9424 if (nla_put_u64_64bit(msg
, NL80211_BSS_BEACON_TSF
, ies
->tsf
,
9426 goto fail_unlock_rcu
;
9427 if (ies
->len
&& nla_put(msg
, NL80211_BSS_BEACON_IES
,
9428 ies
->len
, ies
->data
))
9429 goto fail_unlock_rcu
;
9433 if (res
->beacon_interval
&&
9434 nla_put_u16(msg
, NL80211_BSS_BEACON_INTERVAL
, res
->beacon_interval
))
9435 goto nla_put_failure
;
9436 if (nla_put_u16(msg
, NL80211_BSS_CAPABILITY
, res
->capability
) ||
9437 nla_put_u32(msg
, NL80211_BSS_FREQUENCY
, res
->channel
->center_freq
) ||
9438 nla_put_u32(msg
, NL80211_BSS_FREQUENCY_OFFSET
,
9439 res
->channel
->freq_offset
) ||
9440 nla_put_u32(msg
, NL80211_BSS_CHAN_WIDTH
, res
->scan_width
) ||
9441 nla_put_u32(msg
, NL80211_BSS_SEEN_MS_AGO
,
9442 jiffies_to_msecs(jiffies
- intbss
->ts
)))
9443 goto nla_put_failure
;
9445 if (intbss
->parent_tsf
&&
9446 (nla_put_u64_64bit(msg
, NL80211_BSS_PARENT_TSF
,
9447 intbss
->parent_tsf
, NL80211_BSS_PAD
) ||
9448 nla_put(msg
, NL80211_BSS_PARENT_BSSID
, ETH_ALEN
,
9449 intbss
->parent_bssid
)))
9450 goto nla_put_failure
;
9452 if (intbss
->ts_boottime
&&
9453 nla_put_u64_64bit(msg
, NL80211_BSS_LAST_SEEN_BOOTTIME
,
9454 intbss
->ts_boottime
, NL80211_BSS_PAD
))
9455 goto nla_put_failure
;
9457 if (!nl80211_put_signal(msg
, intbss
->pub
.chains
,
9458 intbss
->pub
.chain_signal
,
9459 NL80211_BSS_CHAIN_SIGNAL
))
9460 goto nla_put_failure
;
9462 switch (rdev
->wiphy
.signal_type
) {
9463 case CFG80211_SIGNAL_TYPE_MBM
:
9464 if (nla_put_u32(msg
, NL80211_BSS_SIGNAL_MBM
, res
->signal
))
9465 goto nla_put_failure
;
9467 case CFG80211_SIGNAL_TYPE_UNSPEC
:
9468 if (nla_put_u8(msg
, NL80211_BSS_SIGNAL_UNSPEC
, res
->signal
))
9469 goto nla_put_failure
;
9475 switch (wdev
->iftype
) {
9476 case NL80211_IFTYPE_P2P_CLIENT
:
9477 case NL80211_IFTYPE_STATION
:
9478 if (intbss
== wdev
->current_bss
&&
9479 nla_put_u32(msg
, NL80211_BSS_STATUS
,
9480 NL80211_BSS_STATUS_ASSOCIATED
))
9481 goto nla_put_failure
;
9483 case NL80211_IFTYPE_ADHOC
:
9484 if (intbss
== wdev
->current_bss
&&
9485 nla_put_u32(msg
, NL80211_BSS_STATUS
,
9486 NL80211_BSS_STATUS_IBSS_JOINED
))
9487 goto nla_put_failure
;
9493 nla_nest_end(msg
, bss
);
9495 genlmsg_end(msg
, hdr
);
9501 genlmsg_cancel(msg
, hdr
);
9505 static int nl80211_dump_scan(struct sk_buff
*skb
, struct netlink_callback
*cb
)
9507 struct cfg80211_registered_device
*rdev
;
9508 struct cfg80211_internal_bss
*scan
;
9509 struct wireless_dev
*wdev
;
9510 int start
= cb
->args
[2], idx
= 0;
9513 err
= nl80211_prepare_wdev_dump(cb
, &rdev
, &wdev
);
9516 /* nl80211_prepare_wdev_dump acquired it in the successful case */
9517 __acquire(&rdev
->wiphy
.mtx
);
9520 spin_lock_bh(&rdev
->bss_lock
);
9523 * dump_scan will be called multiple times to break up the scan results
9524 * into multiple messages. It is unlikely that any more bss-es will be
9525 * expired after the first call, so only call only call this on the
9526 * first dump_scan invocation.
9529 cfg80211_bss_expire(rdev
);
9531 cb
->seq
= rdev
->bss_generation
;
9533 list_for_each_entry(scan
, &rdev
->bss_list
, list
) {
9536 if (nl80211_send_bss(skb
, cb
,
9537 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
9538 rdev
, wdev
, scan
) < 0) {
9544 spin_unlock_bh(&rdev
->bss_lock
);
9548 wiphy_unlock(&rdev
->wiphy
);
9553 static int nl80211_send_survey(struct sk_buff
*msg
, u32 portid
, u32 seq
,
9554 int flags
, struct net_device
*dev
,
9555 bool allow_radio_stats
,
9556 struct survey_info
*survey
)
9559 struct nlattr
*infoattr
;
9561 /* skip radio stats if userspace didn't request them */
9562 if (!survey
->channel
&& !allow_radio_stats
)
9565 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
,
9566 NL80211_CMD_NEW_SURVEY_RESULTS
);
9570 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
9571 goto nla_put_failure
;
9573 infoattr
= nla_nest_start_noflag(msg
, NL80211_ATTR_SURVEY_INFO
);
9575 goto nla_put_failure
;
9577 if (survey
->channel
&&
9578 nla_put_u32(msg
, NL80211_SURVEY_INFO_FREQUENCY
,
9579 survey
->channel
->center_freq
))
9580 goto nla_put_failure
;
9582 if (survey
->channel
&& survey
->channel
->freq_offset
&&
9583 nla_put_u32(msg
, NL80211_SURVEY_INFO_FREQUENCY_OFFSET
,
9584 survey
->channel
->freq_offset
))
9585 goto nla_put_failure
;
9587 if ((survey
->filled
& SURVEY_INFO_NOISE_DBM
) &&
9588 nla_put_u8(msg
, NL80211_SURVEY_INFO_NOISE
, survey
->noise
))
9589 goto nla_put_failure
;
9590 if ((survey
->filled
& SURVEY_INFO_IN_USE
) &&
9591 nla_put_flag(msg
, NL80211_SURVEY_INFO_IN_USE
))
9592 goto nla_put_failure
;
9593 if ((survey
->filled
& SURVEY_INFO_TIME
) &&
9594 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME
,
9595 survey
->time
, NL80211_SURVEY_INFO_PAD
))
9596 goto nla_put_failure
;
9597 if ((survey
->filled
& SURVEY_INFO_TIME_BUSY
) &&
9598 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME_BUSY
,
9599 survey
->time_busy
, NL80211_SURVEY_INFO_PAD
))
9600 goto nla_put_failure
;
9601 if ((survey
->filled
& SURVEY_INFO_TIME_EXT_BUSY
) &&
9602 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME_EXT_BUSY
,
9603 survey
->time_ext_busy
, NL80211_SURVEY_INFO_PAD
))
9604 goto nla_put_failure
;
9605 if ((survey
->filled
& SURVEY_INFO_TIME_RX
) &&
9606 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME_RX
,
9607 survey
->time_rx
, NL80211_SURVEY_INFO_PAD
))
9608 goto nla_put_failure
;
9609 if ((survey
->filled
& SURVEY_INFO_TIME_TX
) &&
9610 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME_TX
,
9611 survey
->time_tx
, NL80211_SURVEY_INFO_PAD
))
9612 goto nla_put_failure
;
9613 if ((survey
->filled
& SURVEY_INFO_TIME_SCAN
) &&
9614 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME_SCAN
,
9615 survey
->time_scan
, NL80211_SURVEY_INFO_PAD
))
9616 goto nla_put_failure
;
9617 if ((survey
->filled
& SURVEY_INFO_TIME_BSS_RX
) &&
9618 nla_put_u64_64bit(msg
, NL80211_SURVEY_INFO_TIME_BSS_RX
,
9619 survey
->time_bss_rx
, NL80211_SURVEY_INFO_PAD
))
9620 goto nla_put_failure
;
9622 nla_nest_end(msg
, infoattr
);
9624 genlmsg_end(msg
, hdr
);
9628 genlmsg_cancel(msg
, hdr
);
9632 static int nl80211_dump_survey(struct sk_buff
*skb
, struct netlink_callback
*cb
)
9634 struct nlattr
**attrbuf
;
9635 struct survey_info survey
;
9636 struct cfg80211_registered_device
*rdev
;
9637 struct wireless_dev
*wdev
;
9638 int survey_idx
= cb
->args
[2];
9642 attrbuf
= kcalloc(NUM_NL80211_ATTR
, sizeof(*attrbuf
), GFP_KERNEL
);
9646 res
= nl80211_prepare_wdev_dump(cb
, &rdev
, &wdev
);
9651 /* nl80211_prepare_wdev_dump acquired it in the successful case */
9652 __acquire(&rdev
->wiphy
.mtx
);
9654 /* prepare_wdev_dump parsed the attributes */
9655 radio_stats
= attrbuf
[NL80211_ATTR_SURVEY_RADIO_STATS
];
9657 if (!wdev
->netdev
) {
9662 if (!rdev
->ops
->dump_survey
) {
9668 res
= rdev_dump_survey(rdev
, wdev
->netdev
, survey_idx
, &survey
);
9674 /* don't send disabled channels, but do send non-channel data */
9675 if (survey
.channel
&&
9676 survey
.channel
->flags
& IEEE80211_CHAN_DISABLED
) {
9681 if (nl80211_send_survey(skb
,
9682 NETLINK_CB(cb
->skb
).portid
,
9683 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
9684 wdev
->netdev
, radio_stats
, &survey
) < 0)
9690 cb
->args
[2] = survey_idx
;
9694 wiphy_unlock(&rdev
->wiphy
);
9698 static bool nl80211_valid_wpa_versions(u32 wpa_versions
)
9700 return !(wpa_versions
& ~(NL80211_WPA_VERSION_1
|
9701 NL80211_WPA_VERSION_2
|
9702 NL80211_WPA_VERSION_3
));
9705 static int nl80211_authenticate(struct sk_buff
*skb
, struct genl_info
*info
)
9707 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9708 struct net_device
*dev
= info
->user_ptr
[1];
9709 struct ieee80211_channel
*chan
;
9710 const u8
*bssid
, *ssid
, *ie
= NULL
, *auth_data
= NULL
;
9711 int err
, ssid_len
, ie_len
= 0, auth_data_len
= 0;
9712 enum nl80211_auth_type auth_type
;
9713 struct key_parse key
;
9714 bool local_state_change
;
9717 if (!info
->attrs
[NL80211_ATTR_MAC
])
9720 if (!info
->attrs
[NL80211_ATTR_AUTH_TYPE
])
9723 if (!info
->attrs
[NL80211_ATTR_SSID
])
9726 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
9729 err
= nl80211_parse_key(info
, &key
);
9734 if (key
.type
!= -1 && key
.type
!= NL80211_KEYTYPE_GROUP
)
9736 if (!key
.p
.key
|| !key
.p
.key_len
)
9738 if ((key
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP40
||
9739 key
.p
.key_len
!= WLAN_KEY_LEN_WEP40
) &&
9740 (key
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP104
||
9741 key
.p
.key_len
!= WLAN_KEY_LEN_WEP104
))
9754 for (i
= 0; i
< rdev
->wiphy
.n_cipher_suites
; i
++) {
9755 if (key
.p
.cipher
== rdev
->wiphy
.cipher_suites
[i
]) {
9764 if (!rdev
->ops
->auth
)
9767 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
9768 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
9771 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
9772 freq
= MHZ_TO_KHZ(nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
9773 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
])
9775 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
]);
9777 chan
= nl80211_get_valid_chan(&rdev
->wiphy
, freq
);
9781 ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
9782 ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
9784 if (info
->attrs
[NL80211_ATTR_IE
]) {
9785 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
9786 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
9789 auth_type
= nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
9790 if (!nl80211_valid_auth_type(rdev
, auth_type
, NL80211_CMD_AUTHENTICATE
))
9793 if ((auth_type
== NL80211_AUTHTYPE_SAE
||
9794 auth_type
== NL80211_AUTHTYPE_FILS_SK
||
9795 auth_type
== NL80211_AUTHTYPE_FILS_SK_PFS
||
9796 auth_type
== NL80211_AUTHTYPE_FILS_PK
) &&
9797 !info
->attrs
[NL80211_ATTR_AUTH_DATA
])
9800 if (info
->attrs
[NL80211_ATTR_AUTH_DATA
]) {
9801 if (auth_type
!= NL80211_AUTHTYPE_SAE
&&
9802 auth_type
!= NL80211_AUTHTYPE_FILS_SK
&&
9803 auth_type
!= NL80211_AUTHTYPE_FILS_SK_PFS
&&
9804 auth_type
!= NL80211_AUTHTYPE_FILS_PK
)
9806 auth_data
= nla_data(info
->attrs
[NL80211_ATTR_AUTH_DATA
]);
9807 auth_data_len
= nla_len(info
->attrs
[NL80211_ATTR_AUTH_DATA
]);
9810 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
9813 * Since we no longer track auth state, ignore
9814 * requests to only change local state.
9816 if (local_state_change
)
9819 wdev_lock(dev
->ieee80211_ptr
);
9820 err
= cfg80211_mlme_auth(rdev
, dev
, chan
, auth_type
, bssid
,
9821 ssid
, ssid_len
, ie
, ie_len
,
9822 key
.p
.key
, key
.p
.key_len
, key
.idx
,
9823 auth_data
, auth_data_len
);
9824 wdev_unlock(dev
->ieee80211_ptr
);
9828 static int validate_pae_over_nl80211(struct cfg80211_registered_device
*rdev
,
9829 struct genl_info
*info
)
9831 if (!info
->attrs
[NL80211_ATTR_SOCKET_OWNER
]) {
9832 GENL_SET_ERR_MSG(info
, "SOCKET_OWNER not set");
9836 if (!rdev
->ops
->tx_control_port
||
9837 !wiphy_ext_feature_isset(&rdev
->wiphy
,
9838 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211
))
9844 static int nl80211_crypto_settings(struct cfg80211_registered_device
*rdev
,
9845 struct genl_info
*info
,
9846 struct cfg80211_crypto_settings
*settings
,
9849 memset(settings
, 0, sizeof(*settings
));
9851 settings
->control_port
= info
->attrs
[NL80211_ATTR_CONTROL_PORT
];
9853 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]) {
9856 proto
= nla_get_u16(
9857 info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]);
9858 settings
->control_port_ethertype
= cpu_to_be16(proto
);
9859 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_CONTROL_PORT_PROTOCOL
) &&
9862 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
])
9863 settings
->control_port_no_encrypt
= true;
9865 settings
->control_port_ethertype
= cpu_to_be16(ETH_P_PAE
);
9867 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_OVER_NL80211
]) {
9868 int r
= validate_pae_over_nl80211(rdev
, info
);
9873 settings
->control_port_over_nl80211
= true;
9875 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_NO_PREAUTH
])
9876 settings
->control_port_no_preauth
= true;
9879 if (info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]) {
9883 data
= nla_data(info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]);
9884 len
= nla_len(info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]);
9885 settings
->n_ciphers_pairwise
= len
/ sizeof(u32
);
9887 if (len
% sizeof(u32
))
9890 if (settings
->n_ciphers_pairwise
> cipher_limit
)
9893 memcpy(settings
->ciphers_pairwise
, data
, len
);
9895 for (i
= 0; i
< settings
->n_ciphers_pairwise
; i
++)
9896 if (!cfg80211_supported_cipher_suite(
9898 settings
->ciphers_pairwise
[i
]))
9902 if (info
->attrs
[NL80211_ATTR_CIPHER_SUITE_GROUP
]) {
9903 settings
->cipher_group
=
9904 nla_get_u32(info
->attrs
[NL80211_ATTR_CIPHER_SUITE_GROUP
]);
9905 if (!cfg80211_supported_cipher_suite(&rdev
->wiphy
,
9906 settings
->cipher_group
))
9910 if (info
->attrs
[NL80211_ATTR_WPA_VERSIONS
]) {
9911 settings
->wpa_versions
=
9912 nla_get_u32(info
->attrs
[NL80211_ATTR_WPA_VERSIONS
]);
9913 if (!nl80211_valid_wpa_versions(settings
->wpa_versions
))
9917 if (info
->attrs
[NL80211_ATTR_AKM_SUITES
]) {
9921 data
= nla_data(info
->attrs
[NL80211_ATTR_AKM_SUITES
]);
9922 len
= nla_len(info
->attrs
[NL80211_ATTR_AKM_SUITES
]);
9923 settings
->n_akm_suites
= len
/ sizeof(u32
);
9925 if (len
% sizeof(u32
))
9928 if (settings
->n_akm_suites
> NL80211_MAX_NR_AKM_SUITES
)
9931 memcpy(settings
->akm_suites
, data
, len
);
9934 if (info
->attrs
[NL80211_ATTR_PMK
]) {
9935 if (nla_len(info
->attrs
[NL80211_ATTR_PMK
]) != WLAN_PMK_LEN
)
9937 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
9938 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_PSK
) &&
9939 !wiphy_ext_feature_isset(&rdev
->wiphy
,
9940 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_AP_PSK
))
9942 settings
->psk
= nla_data(info
->attrs
[NL80211_ATTR_PMK
]);
9945 if (info
->attrs
[NL80211_ATTR_SAE_PASSWORD
]) {
9946 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
9947 NL80211_EXT_FEATURE_SAE_OFFLOAD
) &&
9948 !wiphy_ext_feature_isset(&rdev
->wiphy
,
9949 NL80211_EXT_FEATURE_SAE_OFFLOAD_AP
))
9952 nla_data(info
->attrs
[NL80211_ATTR_SAE_PASSWORD
]);
9953 settings
->sae_pwd_len
=
9954 nla_len(info
->attrs
[NL80211_ATTR_SAE_PASSWORD
]);
9957 if (info
->attrs
[NL80211_ATTR_SAE_PWE
])
9959 nla_get_u8(info
->attrs
[NL80211_ATTR_SAE_PWE
]);
9961 settings
->sae_pwe
= NL80211_SAE_PWE_UNSPECIFIED
;
9966 static int nl80211_associate(struct sk_buff
*skb
, struct genl_info
*info
)
9968 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9969 struct net_device
*dev
= info
->user_ptr
[1];
9970 struct ieee80211_channel
*chan
;
9971 struct cfg80211_assoc_request req
= {};
9972 const u8
*bssid
, *ssid
;
9973 int err
, ssid_len
= 0;
9976 if (dev
->ieee80211_ptr
->conn_owner_nlportid
&&
9977 dev
->ieee80211_ptr
->conn_owner_nlportid
!= info
->snd_portid
)
9980 if (!info
->attrs
[NL80211_ATTR_MAC
] ||
9981 !info
->attrs
[NL80211_ATTR_SSID
] ||
9982 !info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
9985 if (!rdev
->ops
->assoc
)
9988 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
9989 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
9992 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
9994 freq
= MHZ_TO_KHZ(nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
9995 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
])
9997 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
]);
9998 chan
= nl80211_get_valid_chan(&rdev
->wiphy
, freq
);
10002 ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
10003 ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
10005 if (info
->attrs
[NL80211_ATTR_IE
]) {
10006 req
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
10007 req
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
10010 if (info
->attrs
[NL80211_ATTR_USE_MFP
]) {
10011 enum nl80211_mfp mfp
=
10012 nla_get_u32(info
->attrs
[NL80211_ATTR_USE_MFP
]);
10013 if (mfp
== NL80211_MFP_REQUIRED
)
10014 req
.use_mfp
= true;
10015 else if (mfp
!= NL80211_MFP_NO
)
10019 if (info
->attrs
[NL80211_ATTR_PREV_BSSID
])
10020 req
.prev_bssid
= nla_data(info
->attrs
[NL80211_ATTR_PREV_BSSID
]);
10022 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HT
]))
10023 req
.flags
|= ASSOC_REQ_DISABLE_HT
;
10025 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
10026 memcpy(&req
.ht_capa_mask
,
10027 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
10028 sizeof(req
.ht_capa_mask
));
10030 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
10031 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
10033 memcpy(&req
.ht_capa
,
10034 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
10035 sizeof(req
.ht_capa
));
10038 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_VHT
]))
10039 req
.flags
|= ASSOC_REQ_DISABLE_VHT
;
10041 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HE
]))
10042 req
.flags
|= ASSOC_REQ_DISABLE_HE
;
10044 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
])
10045 memcpy(&req
.vht_capa_mask
,
10046 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
]),
10047 sizeof(req
.vht_capa_mask
));
10049 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]) {
10050 if (!info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
])
10052 memcpy(&req
.vht_capa
,
10053 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]),
10054 sizeof(req
.vht_capa
));
10057 if (nla_get_flag(info
->attrs
[NL80211_ATTR_USE_RRM
])) {
10058 if (!((rdev
->wiphy
.features
&
10059 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES
) &&
10060 (rdev
->wiphy
.features
& NL80211_FEATURE_QUIET
)) &&
10061 !wiphy_ext_feature_isset(&rdev
->wiphy
,
10062 NL80211_EXT_FEATURE_RRM
))
10064 req
.flags
|= ASSOC_REQ_USE_RRM
;
10067 if (info
->attrs
[NL80211_ATTR_FILS_KEK
]) {
10068 req
.fils_kek
= nla_data(info
->attrs
[NL80211_ATTR_FILS_KEK
]);
10069 req
.fils_kek_len
= nla_len(info
->attrs
[NL80211_ATTR_FILS_KEK
]);
10070 if (!info
->attrs
[NL80211_ATTR_FILS_NONCES
])
10073 nla_data(info
->attrs
[NL80211_ATTR_FILS_NONCES
]);
10076 if (info
->attrs
[NL80211_ATTR_S1G_CAPABILITY_MASK
]) {
10077 if (!info
->attrs
[NL80211_ATTR_S1G_CAPABILITY
])
10079 memcpy(&req
.s1g_capa_mask
,
10080 nla_data(info
->attrs
[NL80211_ATTR_S1G_CAPABILITY_MASK
]),
10081 sizeof(req
.s1g_capa_mask
));
10084 if (info
->attrs
[NL80211_ATTR_S1G_CAPABILITY
]) {
10085 if (!info
->attrs
[NL80211_ATTR_S1G_CAPABILITY_MASK
])
10087 memcpy(&req
.s1g_capa
,
10088 nla_data(info
->attrs
[NL80211_ATTR_S1G_CAPABILITY
]),
10089 sizeof(req
.s1g_capa
));
10092 err
= nl80211_crypto_settings(rdev
, info
, &req
.crypto
, 1);
10094 wdev_lock(dev
->ieee80211_ptr
);
10096 err
= cfg80211_mlme_assoc(rdev
, dev
, chan
, bssid
,
10097 ssid
, ssid_len
, &req
);
10099 if (!err
&& info
->attrs
[NL80211_ATTR_SOCKET_OWNER
]) {
10100 dev
->ieee80211_ptr
->conn_owner_nlportid
=
10102 memcpy(dev
->ieee80211_ptr
->disconnect_bssid
,
10106 wdev_unlock(dev
->ieee80211_ptr
);
10112 static int nl80211_deauthenticate(struct sk_buff
*skb
, struct genl_info
*info
)
10114 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10115 struct net_device
*dev
= info
->user_ptr
[1];
10116 const u8
*ie
= NULL
, *bssid
;
10117 int ie_len
= 0, err
;
10119 bool local_state_change
;
10121 if (dev
->ieee80211_ptr
->conn_owner_nlportid
&&
10122 dev
->ieee80211_ptr
->conn_owner_nlportid
!= info
->snd_portid
)
10125 if (!info
->attrs
[NL80211_ATTR_MAC
])
10128 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
10131 if (!rdev
->ops
->deauth
)
10132 return -EOPNOTSUPP
;
10134 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
10135 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
10136 return -EOPNOTSUPP
;
10138 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
10140 reason_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
10141 if (reason_code
== 0) {
10142 /* Reason Code 0 is reserved */
10146 if (info
->attrs
[NL80211_ATTR_IE
]) {
10147 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
10148 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
10151 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
10153 wdev_lock(dev
->ieee80211_ptr
);
10154 err
= cfg80211_mlme_deauth(rdev
, dev
, bssid
, ie
, ie_len
, reason_code
,
10155 local_state_change
);
10156 wdev_unlock(dev
->ieee80211_ptr
);
10160 static int nl80211_disassociate(struct sk_buff
*skb
, struct genl_info
*info
)
10162 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10163 struct net_device
*dev
= info
->user_ptr
[1];
10164 const u8
*ie
= NULL
, *bssid
;
10165 int ie_len
= 0, err
;
10167 bool local_state_change
;
10169 if (dev
->ieee80211_ptr
->conn_owner_nlportid
&&
10170 dev
->ieee80211_ptr
->conn_owner_nlportid
!= info
->snd_portid
)
10173 if (!info
->attrs
[NL80211_ATTR_MAC
])
10176 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
10179 if (!rdev
->ops
->disassoc
)
10180 return -EOPNOTSUPP
;
10182 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
10183 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
10184 return -EOPNOTSUPP
;
10186 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
10188 reason_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
10189 if (reason_code
== 0) {
10190 /* Reason Code 0 is reserved */
10194 if (info
->attrs
[NL80211_ATTR_IE
]) {
10195 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
10196 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
10199 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
10201 wdev_lock(dev
->ieee80211_ptr
);
10202 err
= cfg80211_mlme_disassoc(rdev
, dev
, bssid
, ie
, ie_len
, reason_code
,
10203 local_state_change
);
10204 wdev_unlock(dev
->ieee80211_ptr
);
10209 nl80211_parse_mcast_rate(struct cfg80211_registered_device
*rdev
,
10210 int mcast_rate
[NUM_NL80211_BANDS
],
10213 struct wiphy
*wiphy
= &rdev
->wiphy
;
10214 bool found
= false;
10217 for (band
= 0; band
< NUM_NL80211_BANDS
; band
++) {
10218 struct ieee80211_supported_band
*sband
;
10220 sband
= wiphy
->bands
[band
];
10224 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
10225 if (sband
->bitrates
[i
].bitrate
== rateval
) {
10226 mcast_rate
[band
] = i
+ 1;
10236 static int nl80211_join_ibss(struct sk_buff
*skb
, struct genl_info
*info
)
10238 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10239 struct net_device
*dev
= info
->user_ptr
[1];
10240 struct cfg80211_ibss_params ibss
;
10241 struct wiphy
*wiphy
;
10242 struct cfg80211_cached_keys
*connkeys
= NULL
;
10245 memset(&ibss
, 0, sizeof(ibss
));
10247 if (!info
->attrs
[NL80211_ATTR_SSID
] ||
10248 !nla_len(info
->attrs
[NL80211_ATTR_SSID
]))
10251 ibss
.beacon_interval
= 100;
10253 if (info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
])
10254 ibss
.beacon_interval
=
10255 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
10257 err
= cfg80211_validate_beacon_int(rdev
, NL80211_IFTYPE_ADHOC
,
10258 ibss
.beacon_interval
);
10262 if (!rdev
->ops
->join_ibss
)
10263 return -EOPNOTSUPP
;
10265 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
)
10266 return -EOPNOTSUPP
;
10268 wiphy
= &rdev
->wiphy
;
10270 if (info
->attrs
[NL80211_ATTR_MAC
]) {
10271 ibss
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
10273 if (!is_valid_ether_addr(ibss
.bssid
))
10276 ibss
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
10277 ibss
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
10279 if (info
->attrs
[NL80211_ATTR_IE
]) {
10280 ibss
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
10281 ibss
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
10284 err
= nl80211_parse_chandef(rdev
, info
, &ibss
.chandef
);
10288 if (!cfg80211_reg_can_beacon(&rdev
->wiphy
, &ibss
.chandef
,
10289 NL80211_IFTYPE_ADHOC
))
10292 switch (ibss
.chandef
.width
) {
10293 case NL80211_CHAN_WIDTH_5
:
10294 case NL80211_CHAN_WIDTH_10
:
10295 case NL80211_CHAN_WIDTH_20_NOHT
:
10297 case NL80211_CHAN_WIDTH_20
:
10298 case NL80211_CHAN_WIDTH_40
:
10299 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_HT_IBSS
))
10302 case NL80211_CHAN_WIDTH_80
:
10303 case NL80211_CHAN_WIDTH_80P80
:
10304 case NL80211_CHAN_WIDTH_160
:
10305 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_HT_IBSS
))
10307 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
10308 NL80211_EXT_FEATURE_VHT_IBSS
))
10315 ibss
.channel_fixed
= !!info
->attrs
[NL80211_ATTR_FREQ_FIXED
];
10316 ibss
.privacy
= !!info
->attrs
[NL80211_ATTR_PRIVACY
];
10318 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
10320 nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
10322 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
10323 struct ieee80211_supported_band
*sband
=
10324 wiphy
->bands
[ibss
.chandef
.chan
->band
];
10326 err
= ieee80211_get_ratemask(sband
, rates
, n_rates
,
10327 &ibss
.basic_rates
);
10332 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
10333 memcpy(&ibss
.ht_capa_mask
,
10334 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
10335 sizeof(ibss
.ht_capa_mask
));
10337 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
10338 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
10340 memcpy(&ibss
.ht_capa
,
10341 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
10342 sizeof(ibss
.ht_capa
));
10345 if (info
->attrs
[NL80211_ATTR_MCAST_RATE
] &&
10346 !nl80211_parse_mcast_rate(rdev
, ibss
.mcast_rate
,
10347 nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
])))
10350 if (ibss
.privacy
&& info
->attrs
[NL80211_ATTR_KEYS
]) {
10351 bool no_ht
= false;
10353 connkeys
= nl80211_parse_connkeys(rdev
, info
, &no_ht
);
10354 if (IS_ERR(connkeys
))
10355 return PTR_ERR(connkeys
);
10357 if ((ibss
.chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
) &&
10359 kfree_sensitive(connkeys
);
10364 ibss
.control_port
=
10365 nla_get_flag(info
->attrs
[NL80211_ATTR_CONTROL_PORT
]);
10367 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_OVER_NL80211
]) {
10368 int r
= validate_pae_over_nl80211(rdev
, info
);
10371 kfree_sensitive(connkeys
);
10375 ibss
.control_port_over_nl80211
= true;
10378 ibss
.userspace_handles_dfs
=
10379 nla_get_flag(info
->attrs
[NL80211_ATTR_HANDLE_DFS
]);
10381 wdev_lock(dev
->ieee80211_ptr
);
10382 err
= __cfg80211_join_ibss(rdev
, dev
, &ibss
, connkeys
);
10384 kfree_sensitive(connkeys
);
10385 else if (info
->attrs
[NL80211_ATTR_SOCKET_OWNER
])
10386 dev
->ieee80211_ptr
->conn_owner_nlportid
= info
->snd_portid
;
10387 wdev_unlock(dev
->ieee80211_ptr
);
10392 static int nl80211_leave_ibss(struct sk_buff
*skb
, struct genl_info
*info
)
10394 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10395 struct net_device
*dev
= info
->user_ptr
[1];
10397 if (!rdev
->ops
->leave_ibss
)
10398 return -EOPNOTSUPP
;
10400 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
)
10401 return -EOPNOTSUPP
;
10403 return cfg80211_leave_ibss(rdev
, dev
, false);
10406 static int nl80211_set_mcast_rate(struct sk_buff
*skb
, struct genl_info
*info
)
10408 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10409 struct net_device
*dev
= info
->user_ptr
[1];
10410 int mcast_rate
[NUM_NL80211_BANDS
];
10414 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
&&
10415 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
&&
10416 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_OCB
)
10417 return -EOPNOTSUPP
;
10419 if (!rdev
->ops
->set_mcast_rate
)
10420 return -EOPNOTSUPP
;
10422 memset(mcast_rate
, 0, sizeof(mcast_rate
));
10424 if (!info
->attrs
[NL80211_ATTR_MCAST_RATE
])
10427 nla_rate
= nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
]);
10428 if (!nl80211_parse_mcast_rate(rdev
, mcast_rate
, nla_rate
))
10431 err
= rdev_set_mcast_rate(rdev
, dev
, mcast_rate
);
10436 static struct sk_buff
*
10437 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device
*rdev
,
10438 struct wireless_dev
*wdev
, int approxlen
,
10439 u32 portid
, u32 seq
, enum nl80211_commands cmd
,
10440 enum nl80211_attrs attr
,
10441 const struct nl80211_vendor_cmd_info
*info
,
10444 struct sk_buff
*skb
;
10446 struct nlattr
*data
;
10448 skb
= nlmsg_new(approxlen
+ 100, gfp
);
10452 hdr
= nl80211hdr_put(skb
, portid
, seq
, 0, cmd
);
10458 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
))
10459 goto nla_put_failure
;
10462 if (nla_put_u32(skb
, NL80211_ATTR_VENDOR_ID
,
10464 goto nla_put_failure
;
10465 if (nla_put_u32(skb
, NL80211_ATTR_VENDOR_SUBCMD
,
10467 goto nla_put_failure
;
10471 if (nla_put_u64_64bit(skb
, NL80211_ATTR_WDEV
,
10472 wdev_id(wdev
), NL80211_ATTR_PAD
))
10473 goto nla_put_failure
;
10474 if (wdev
->netdev
&&
10475 nla_put_u32(skb
, NL80211_ATTR_IFINDEX
,
10476 wdev
->netdev
->ifindex
))
10477 goto nla_put_failure
;
10480 data
= nla_nest_start_noflag(skb
, attr
);
10482 goto nla_put_failure
;
10484 ((void **)skb
->cb
)[0] = rdev
;
10485 ((void **)skb
->cb
)[1] = hdr
;
10486 ((void **)skb
->cb
)[2] = data
;
10495 struct sk_buff
*__cfg80211_alloc_event_skb(struct wiphy
*wiphy
,
10496 struct wireless_dev
*wdev
,
10497 enum nl80211_commands cmd
,
10498 enum nl80211_attrs attr
,
10499 unsigned int portid
,
10500 int vendor_event_idx
,
10501 int approxlen
, gfp_t gfp
)
10503 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
10504 const struct nl80211_vendor_cmd_info
*info
;
10507 case NL80211_CMD_TESTMODE
:
10508 if (WARN_ON(vendor_event_idx
!= -1))
10512 case NL80211_CMD_VENDOR
:
10513 if (WARN_ON(vendor_event_idx
< 0 ||
10514 vendor_event_idx
>= wiphy
->n_vendor_events
))
10516 info
= &wiphy
->vendor_events
[vendor_event_idx
];
10523 return __cfg80211_alloc_vendor_skb(rdev
, wdev
, approxlen
, portid
, 0,
10524 cmd
, attr
, info
, gfp
);
10526 EXPORT_SYMBOL(__cfg80211_alloc_event_skb
);
10528 void __cfg80211_send_event_skb(struct sk_buff
*skb
, gfp_t gfp
)
10530 struct cfg80211_registered_device
*rdev
= ((void **)skb
->cb
)[0];
10531 void *hdr
= ((void **)skb
->cb
)[1];
10532 struct nlmsghdr
*nlhdr
= nlmsg_hdr(skb
);
10533 struct nlattr
*data
= ((void **)skb
->cb
)[2];
10534 enum nl80211_multicast_groups mcgrp
= NL80211_MCGRP_TESTMODE
;
10536 /* clear CB data for netlink core to own from now on */
10537 memset(skb
->cb
, 0, sizeof(skb
->cb
));
10539 nla_nest_end(skb
, data
);
10540 genlmsg_end(skb
, hdr
);
10542 if (nlhdr
->nlmsg_pid
) {
10543 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), skb
,
10546 if (data
->nla_type
== NL80211_ATTR_VENDOR_DATA
)
10547 mcgrp
= NL80211_MCGRP_VENDOR
;
10549 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
),
10550 skb
, 0, mcgrp
, gfp
);
10553 EXPORT_SYMBOL(__cfg80211_send_event_skb
);
10555 #ifdef CONFIG_NL80211_TESTMODE
10556 static int nl80211_testmode_do(struct sk_buff
*skb
, struct genl_info
*info
)
10558 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10559 struct wireless_dev
*wdev
;
10562 lockdep_assert_held(&rdev
->wiphy
.mtx
);
10564 wdev
= __cfg80211_wdev_from_attrs(rdev
, genl_info_net(info
),
10567 if (!rdev
->ops
->testmode_cmd
)
10568 return -EOPNOTSUPP
;
10570 if (IS_ERR(wdev
)) {
10571 err
= PTR_ERR(wdev
);
10572 if (err
!= -EINVAL
)
10575 } else if (wdev
->wiphy
!= &rdev
->wiphy
) {
10579 if (!info
->attrs
[NL80211_ATTR_TESTDATA
])
10582 rdev
->cur_cmd_info
= info
;
10583 err
= rdev_testmode_cmd(rdev
, wdev
,
10584 nla_data(info
->attrs
[NL80211_ATTR_TESTDATA
]),
10585 nla_len(info
->attrs
[NL80211_ATTR_TESTDATA
]));
10586 rdev
->cur_cmd_info
= NULL
;
10591 static int nl80211_testmode_dump(struct sk_buff
*skb
,
10592 struct netlink_callback
*cb
)
10594 struct cfg80211_registered_device
*rdev
;
10595 struct nlattr
**attrbuf
= NULL
;
10605 * 0 is a valid index, but not valid for args[0],
10606 * so we need to offset by 1.
10608 phy_idx
= cb
->args
[0] - 1;
10610 rdev
= cfg80211_rdev_by_wiphy_idx(phy_idx
);
10616 attrbuf
= kcalloc(NUM_NL80211_ATTR
, sizeof(*attrbuf
),
10623 err
= nlmsg_parse_deprecated(cb
->nlh
,
10624 GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
10625 attrbuf
, nl80211_fam
.maxattr
,
10626 nl80211_policy
, NULL
);
10630 rdev
= __cfg80211_rdev_from_attrs(sock_net(skb
->sk
), attrbuf
);
10631 if (IS_ERR(rdev
)) {
10632 err
= PTR_ERR(rdev
);
10635 phy_idx
= rdev
->wiphy_idx
;
10637 if (attrbuf
[NL80211_ATTR_TESTDATA
])
10638 cb
->args
[1] = (long)attrbuf
[NL80211_ATTR_TESTDATA
];
10642 data
= nla_data((void *)cb
->args
[1]);
10643 data_len
= nla_len((void *)cb
->args
[1]);
10646 if (!rdev
->ops
->testmode_dump
) {
10652 void *hdr
= nl80211hdr_put(skb
, NETLINK_CB(cb
->skb
).portid
,
10653 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
10654 NL80211_CMD_TESTMODE
);
10655 struct nlattr
*tmdata
;
10660 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, phy_idx
)) {
10661 genlmsg_cancel(skb
, hdr
);
10665 tmdata
= nla_nest_start_noflag(skb
, NL80211_ATTR_TESTDATA
);
10667 genlmsg_cancel(skb
, hdr
);
10670 err
= rdev_testmode_dump(rdev
, skb
, cb
, data
, data_len
);
10671 nla_nest_end(skb
, tmdata
);
10673 if (err
== -ENOBUFS
|| err
== -ENOENT
) {
10674 genlmsg_cancel(skb
, hdr
);
10677 genlmsg_cancel(skb
, hdr
);
10681 genlmsg_end(skb
, hdr
);
10686 cb
->args
[0] = phy_idx
+ 1;
10694 static int nl80211_connect(struct sk_buff
*skb
, struct genl_info
*info
)
10696 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10697 struct net_device
*dev
= info
->user_ptr
[1];
10698 struct cfg80211_connect_params connect
;
10699 struct wiphy
*wiphy
;
10700 struct cfg80211_cached_keys
*connkeys
= NULL
;
10704 memset(&connect
, 0, sizeof(connect
));
10706 if (!info
->attrs
[NL80211_ATTR_SSID
] ||
10707 !nla_len(info
->attrs
[NL80211_ATTR_SSID
]))
10710 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
10711 connect
.auth_type
=
10712 nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
10713 if (!nl80211_valid_auth_type(rdev
, connect
.auth_type
,
10714 NL80211_CMD_CONNECT
))
10717 connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
10719 connect
.privacy
= info
->attrs
[NL80211_ATTR_PRIVACY
];
10721 if (info
->attrs
[NL80211_ATTR_WANT_1X_4WAY_HS
] &&
10722 !wiphy_ext_feature_isset(&rdev
->wiphy
,
10723 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X
))
10725 connect
.want_1x
= info
->attrs
[NL80211_ATTR_WANT_1X_4WAY_HS
];
10727 err
= nl80211_crypto_settings(rdev
, info
, &connect
.crypto
,
10728 NL80211_MAX_NR_CIPHER_SUITES
);
10732 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
10733 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
10734 return -EOPNOTSUPP
;
10736 wiphy
= &rdev
->wiphy
;
10738 connect
.bg_scan_period
= -1;
10739 if (info
->attrs
[NL80211_ATTR_BG_SCAN_PERIOD
] &&
10740 (wiphy
->flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
)) {
10741 connect
.bg_scan_period
=
10742 nla_get_u16(info
->attrs
[NL80211_ATTR_BG_SCAN_PERIOD
]);
10745 if (info
->attrs
[NL80211_ATTR_MAC
])
10746 connect
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
10747 else if (info
->attrs
[NL80211_ATTR_MAC_HINT
])
10748 connect
.bssid_hint
=
10749 nla_data(info
->attrs
[NL80211_ATTR_MAC_HINT
]);
10750 connect
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
10751 connect
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
10753 if (info
->attrs
[NL80211_ATTR_IE
]) {
10754 connect
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
10755 connect
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
10758 if (info
->attrs
[NL80211_ATTR_USE_MFP
]) {
10759 connect
.mfp
= nla_get_u32(info
->attrs
[NL80211_ATTR_USE_MFP
]);
10760 if (connect
.mfp
== NL80211_MFP_OPTIONAL
&&
10761 !wiphy_ext_feature_isset(&rdev
->wiphy
,
10762 NL80211_EXT_FEATURE_MFP_OPTIONAL
))
10763 return -EOPNOTSUPP
;
10765 connect
.mfp
= NL80211_MFP_NO
;
10768 if (info
->attrs
[NL80211_ATTR_PREV_BSSID
])
10769 connect
.prev_bssid
=
10770 nla_data(info
->attrs
[NL80211_ATTR_PREV_BSSID
]);
10772 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
10773 freq
= MHZ_TO_KHZ(nla_get_u32(
10774 info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
10775 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
])
10777 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ_OFFSET
]);
10780 connect
.channel
= nl80211_get_valid_chan(wiphy
, freq
);
10781 if (!connect
.channel
)
10783 } else if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ_HINT
]) {
10784 freq
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ_HINT
]);
10785 freq
= MHZ_TO_KHZ(freq
);
10786 connect
.channel_hint
= nl80211_get_valid_chan(wiphy
, freq
);
10787 if (!connect
.channel_hint
)
10791 if (info
->attrs
[NL80211_ATTR_WIPHY_EDMG_CHANNELS
]) {
10792 connect
.edmg
.channels
=
10793 nla_get_u8(info
->attrs
[NL80211_ATTR_WIPHY_EDMG_CHANNELS
]);
10795 if (info
->attrs
[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG
])
10796 connect
.edmg
.bw_config
=
10797 nla_get_u8(info
->attrs
[NL80211_ATTR_WIPHY_EDMG_BW_CONFIG
]);
10800 if (connect
.privacy
&& info
->attrs
[NL80211_ATTR_KEYS
]) {
10801 connkeys
= nl80211_parse_connkeys(rdev
, info
, NULL
);
10802 if (IS_ERR(connkeys
))
10803 return PTR_ERR(connkeys
);
10806 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HT
]))
10807 connect
.flags
|= ASSOC_REQ_DISABLE_HT
;
10809 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
10810 memcpy(&connect
.ht_capa_mask
,
10811 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
10812 sizeof(connect
.ht_capa_mask
));
10814 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
10815 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]) {
10816 kfree_sensitive(connkeys
);
10819 memcpy(&connect
.ht_capa
,
10820 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
10821 sizeof(connect
.ht_capa
));
10824 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_VHT
]))
10825 connect
.flags
|= ASSOC_REQ_DISABLE_VHT
;
10827 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HE
]))
10828 connect
.flags
|= ASSOC_REQ_DISABLE_HE
;
10830 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
])
10831 memcpy(&connect
.vht_capa_mask
,
10832 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
]),
10833 sizeof(connect
.vht_capa_mask
));
10835 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]) {
10836 if (!info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
]) {
10837 kfree_sensitive(connkeys
);
10840 memcpy(&connect
.vht_capa
,
10841 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]),
10842 sizeof(connect
.vht_capa
));
10845 if (nla_get_flag(info
->attrs
[NL80211_ATTR_USE_RRM
])) {
10846 if (!((rdev
->wiphy
.features
&
10847 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES
) &&
10848 (rdev
->wiphy
.features
& NL80211_FEATURE_QUIET
)) &&
10849 !wiphy_ext_feature_isset(&rdev
->wiphy
,
10850 NL80211_EXT_FEATURE_RRM
)) {
10851 kfree_sensitive(connkeys
);
10854 connect
.flags
|= ASSOC_REQ_USE_RRM
;
10857 connect
.pbss
= nla_get_flag(info
->attrs
[NL80211_ATTR_PBSS
]);
10858 if (connect
.pbss
&& !rdev
->wiphy
.bands
[NL80211_BAND_60GHZ
]) {
10859 kfree_sensitive(connkeys
);
10860 return -EOPNOTSUPP
;
10863 if (info
->attrs
[NL80211_ATTR_BSS_SELECT
]) {
10864 /* bss selection makes no sense if bssid is set */
10865 if (connect
.bssid
) {
10866 kfree_sensitive(connkeys
);
10870 err
= parse_bss_select(info
->attrs
[NL80211_ATTR_BSS_SELECT
],
10871 wiphy
, &connect
.bss_select
);
10873 kfree_sensitive(connkeys
);
10878 if (wiphy_ext_feature_isset(&rdev
->wiphy
,
10879 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD
) &&
10880 info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
] &&
10881 info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
] &&
10882 info
->attrs
[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
] &&
10883 info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]) {
10884 connect
.fils_erp_username
=
10885 nla_data(info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
]);
10886 connect
.fils_erp_username_len
=
10887 nla_len(info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
]);
10888 connect
.fils_erp_realm
=
10889 nla_data(info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
]);
10890 connect
.fils_erp_realm_len
=
10891 nla_len(info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
]);
10892 connect
.fils_erp_next_seq_num
=
10894 info
->attrs
[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
]);
10895 connect
.fils_erp_rrk
=
10896 nla_data(info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]);
10897 connect
.fils_erp_rrk_len
=
10898 nla_len(info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]);
10899 } else if (info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
] ||
10900 info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
] ||
10901 info
->attrs
[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
] ||
10902 info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]) {
10903 kfree_sensitive(connkeys
);
10907 if (nla_get_flag(info
->attrs
[NL80211_ATTR_EXTERNAL_AUTH_SUPPORT
])) {
10908 if (!info
->attrs
[NL80211_ATTR_SOCKET_OWNER
]) {
10909 kfree_sensitive(connkeys
);
10910 GENL_SET_ERR_MSG(info
,
10911 "external auth requires connection ownership");
10914 connect
.flags
|= CONNECT_REQ_EXTERNAL_AUTH_SUPPORT
;
10917 wdev_lock(dev
->ieee80211_ptr
);
10919 err
= cfg80211_connect(rdev
, dev
, &connect
, connkeys
,
10920 connect
.prev_bssid
);
10922 kfree_sensitive(connkeys
);
10924 if (!err
&& info
->attrs
[NL80211_ATTR_SOCKET_OWNER
]) {
10925 dev
->ieee80211_ptr
->conn_owner_nlportid
= info
->snd_portid
;
10927 memcpy(dev
->ieee80211_ptr
->disconnect_bssid
,
10928 connect
.bssid
, ETH_ALEN
);
10930 eth_zero_addr(dev
->ieee80211_ptr
->disconnect_bssid
);
10933 wdev_unlock(dev
->ieee80211_ptr
);
10938 static int nl80211_update_connect_params(struct sk_buff
*skb
,
10939 struct genl_info
*info
)
10941 struct cfg80211_connect_params connect
= {};
10942 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
10943 struct net_device
*dev
= info
->user_ptr
[1];
10944 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10945 bool fils_sk_offload
;
10950 if (!rdev
->ops
->update_connect_params
)
10951 return -EOPNOTSUPP
;
10953 if (info
->attrs
[NL80211_ATTR_IE
]) {
10954 connect
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
10955 connect
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
10956 changed
|= UPDATE_ASSOC_IES
;
10959 fils_sk_offload
= wiphy_ext_feature_isset(&rdev
->wiphy
,
10960 NL80211_EXT_FEATURE_FILS_SK_OFFLOAD
);
10963 * when driver supports fils-sk offload all attributes must be
10964 * provided. So the else covers "fils-sk-not-all" and
10965 * "no-fils-sk-any".
10967 if (fils_sk_offload
&&
10968 info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
] &&
10969 info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
] &&
10970 info
->attrs
[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
] &&
10971 info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]) {
10972 connect
.fils_erp_username
=
10973 nla_data(info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
]);
10974 connect
.fils_erp_username_len
=
10975 nla_len(info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
]);
10976 connect
.fils_erp_realm
=
10977 nla_data(info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
]);
10978 connect
.fils_erp_realm_len
=
10979 nla_len(info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
]);
10980 connect
.fils_erp_next_seq_num
=
10982 info
->attrs
[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
]);
10983 connect
.fils_erp_rrk
=
10984 nla_data(info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]);
10985 connect
.fils_erp_rrk_len
=
10986 nla_len(info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]);
10987 changed
|= UPDATE_FILS_ERP_INFO
;
10988 } else if (info
->attrs
[NL80211_ATTR_FILS_ERP_USERNAME
] ||
10989 info
->attrs
[NL80211_ATTR_FILS_ERP_REALM
] ||
10990 info
->attrs
[NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
] ||
10991 info
->attrs
[NL80211_ATTR_FILS_ERP_RRK
]) {
10995 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
10996 auth_type
= nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
10997 if (!nl80211_valid_auth_type(rdev
, auth_type
,
10998 NL80211_CMD_CONNECT
))
11001 if (auth_type
== NL80211_AUTHTYPE_FILS_SK
&&
11002 fils_sk_offload
&& !(changed
& UPDATE_FILS_ERP_INFO
))
11005 connect
.auth_type
= auth_type
;
11006 changed
|= UPDATE_AUTH_TYPE
;
11009 wdev_lock(dev
->ieee80211_ptr
);
11010 if (!wdev
->current_bss
)
11013 ret
= rdev_update_connect_params(rdev
, dev
, &connect
, changed
);
11014 wdev_unlock(dev
->ieee80211_ptr
);
11019 static int nl80211_disconnect(struct sk_buff
*skb
, struct genl_info
*info
)
11021 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11022 struct net_device
*dev
= info
->user_ptr
[1];
11026 if (dev
->ieee80211_ptr
->conn_owner_nlportid
&&
11027 dev
->ieee80211_ptr
->conn_owner_nlportid
!= info
->snd_portid
)
11030 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
11031 reason
= WLAN_REASON_DEAUTH_LEAVING
;
11033 reason
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
11038 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
11039 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
11040 return -EOPNOTSUPP
;
11042 wdev_lock(dev
->ieee80211_ptr
);
11043 ret
= cfg80211_disconnect(rdev
, dev
, reason
, true);
11044 wdev_unlock(dev
->ieee80211_ptr
);
11048 static int nl80211_wiphy_netns(struct sk_buff
*skb
, struct genl_info
*info
)
11050 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11054 if (info
->attrs
[NL80211_ATTR_PID
]) {
11055 u32 pid
= nla_get_u32(info
->attrs
[NL80211_ATTR_PID
]);
11057 net
= get_net_ns_by_pid(pid
);
11058 } else if (info
->attrs
[NL80211_ATTR_NETNS_FD
]) {
11059 u32 fd
= nla_get_u32(info
->attrs
[NL80211_ATTR_NETNS_FD
]);
11061 net
= get_net_ns_by_fd(fd
);
11067 return PTR_ERR(net
);
11071 /* check if anything to do */
11072 if (!net_eq(wiphy_net(&rdev
->wiphy
), net
))
11073 err
= cfg80211_switch_netns(rdev
, net
);
11079 static int nl80211_setdel_pmksa(struct sk_buff
*skb
, struct genl_info
*info
)
11081 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11082 int (*rdev_ops
)(struct wiphy
*wiphy
, struct net_device
*dev
,
11083 struct cfg80211_pmksa
*pmksa
) = NULL
;
11084 struct net_device
*dev
= info
->user_ptr
[1];
11085 struct cfg80211_pmksa pmksa
;
11087 memset(&pmksa
, 0, sizeof(struct cfg80211_pmksa
));
11089 if (!info
->attrs
[NL80211_ATTR_PMKID
])
11092 pmksa
.pmkid
= nla_data(info
->attrs
[NL80211_ATTR_PMKID
]);
11094 if (info
->attrs
[NL80211_ATTR_MAC
]) {
11095 pmksa
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
11096 } else if (info
->attrs
[NL80211_ATTR_SSID
] &&
11097 info
->attrs
[NL80211_ATTR_FILS_CACHE_ID
] &&
11098 (info
->genlhdr
->cmd
== NL80211_CMD_DEL_PMKSA
||
11099 info
->attrs
[NL80211_ATTR_PMK
])) {
11100 pmksa
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
11101 pmksa
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
11103 nla_data(info
->attrs
[NL80211_ATTR_FILS_CACHE_ID
]);
11107 if (info
->attrs
[NL80211_ATTR_PMK
]) {
11108 pmksa
.pmk
= nla_data(info
->attrs
[NL80211_ATTR_PMK
]);
11109 pmksa
.pmk_len
= nla_len(info
->attrs
[NL80211_ATTR_PMK
]);
11112 if (info
->attrs
[NL80211_ATTR_PMK_LIFETIME
])
11113 pmksa
.pmk_lifetime
=
11114 nla_get_u32(info
->attrs
[NL80211_ATTR_PMK_LIFETIME
]);
11116 if (info
->attrs
[NL80211_ATTR_PMK_REAUTH_THRESHOLD
])
11117 pmksa
.pmk_reauth_threshold
=
11119 info
->attrs
[NL80211_ATTR_PMK_REAUTH_THRESHOLD
]);
11121 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
11122 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
&&
11123 !(dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_AP
&&
11124 wiphy_ext_feature_isset(&rdev
->wiphy
,
11125 NL80211_EXT_FEATURE_AP_PMKSA_CACHING
)))
11126 return -EOPNOTSUPP
;
11128 switch (info
->genlhdr
->cmd
) {
11129 case NL80211_CMD_SET_PMKSA
:
11130 rdev_ops
= rdev
->ops
->set_pmksa
;
11132 case NL80211_CMD_DEL_PMKSA
:
11133 rdev_ops
= rdev
->ops
->del_pmksa
;
11141 return -EOPNOTSUPP
;
11143 return rdev_ops(&rdev
->wiphy
, dev
, &pmksa
);
11146 static int nl80211_flush_pmksa(struct sk_buff
*skb
, struct genl_info
*info
)
11148 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11149 struct net_device
*dev
= info
->user_ptr
[1];
11151 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
11152 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
11153 return -EOPNOTSUPP
;
11155 if (!rdev
->ops
->flush_pmksa
)
11156 return -EOPNOTSUPP
;
11158 return rdev_flush_pmksa(rdev
, dev
);
11161 static int nl80211_tdls_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
11163 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11164 struct net_device
*dev
= info
->user_ptr
[1];
11165 u8 action_code
, dialog_token
;
11166 u32 peer_capability
= 0;
11171 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) ||
11172 !rdev
->ops
->tdls_mgmt
)
11173 return -EOPNOTSUPP
;
11175 if (!info
->attrs
[NL80211_ATTR_TDLS_ACTION
] ||
11176 !info
->attrs
[NL80211_ATTR_STATUS_CODE
] ||
11177 !info
->attrs
[NL80211_ATTR_TDLS_DIALOG_TOKEN
] ||
11178 !info
->attrs
[NL80211_ATTR_IE
] ||
11179 !info
->attrs
[NL80211_ATTR_MAC
])
11182 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
11183 action_code
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_ACTION
]);
11184 status_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_STATUS_CODE
]);
11185 dialog_token
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_DIALOG_TOKEN
]);
11186 initiator
= nla_get_flag(info
->attrs
[NL80211_ATTR_TDLS_INITIATOR
]);
11187 if (info
->attrs
[NL80211_ATTR_TDLS_PEER_CAPABILITY
])
11189 nla_get_u32(info
->attrs
[NL80211_ATTR_TDLS_PEER_CAPABILITY
]);
11191 return rdev_tdls_mgmt(rdev
, dev
, peer
, action_code
,
11192 dialog_token
, status_code
, peer_capability
,
11194 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
11195 nla_len(info
->attrs
[NL80211_ATTR_IE
]));
11198 static int nl80211_tdls_oper(struct sk_buff
*skb
, struct genl_info
*info
)
11200 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11201 struct net_device
*dev
= info
->user_ptr
[1];
11202 enum nl80211_tdls_operation operation
;
11205 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) ||
11206 !rdev
->ops
->tdls_oper
)
11207 return -EOPNOTSUPP
;
11209 if (!info
->attrs
[NL80211_ATTR_TDLS_OPERATION
] ||
11210 !info
->attrs
[NL80211_ATTR_MAC
])
11213 operation
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_OPERATION
]);
11214 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
11216 return rdev_tdls_oper(rdev
, dev
, peer
, operation
);
11219 static int nl80211_remain_on_channel(struct sk_buff
*skb
,
11220 struct genl_info
*info
)
11222 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11223 struct wireless_dev
*wdev
= info
->user_ptr
[1];
11224 struct cfg80211_chan_def chandef
;
11225 const struct cfg80211_chan_def
*compat_chandef
;
11226 struct sk_buff
*msg
;
11232 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
] ||
11233 !info
->attrs
[NL80211_ATTR_DURATION
])
11236 duration
= nla_get_u32(info
->attrs
[NL80211_ATTR_DURATION
]);
11238 if (!rdev
->ops
->remain_on_channel
||
11239 !(rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
))
11240 return -EOPNOTSUPP
;
11243 * We should be on that channel for at least a minimum amount of
11244 * time (10ms) but no longer than the driver supports.
11246 if (duration
< NL80211_MIN_REMAIN_ON_CHANNEL_TIME
||
11247 duration
> rdev
->wiphy
.max_remain_on_channel_duration
)
11250 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
11255 if (!cfg80211_off_channel_oper_allowed(wdev
) &&
11256 !cfg80211_chandef_identical(&wdev
->chandef
, &chandef
)) {
11257 compat_chandef
= cfg80211_chandef_compatible(&wdev
->chandef
,
11259 if (compat_chandef
!= &chandef
) {
11266 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
11270 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
11271 NL80211_CMD_REMAIN_ON_CHANNEL
);
11277 err
= rdev_remain_on_channel(rdev
, wdev
, chandef
.chan
,
11278 duration
, &cookie
);
11283 if (nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
11285 goto nla_put_failure
;
11287 genlmsg_end(msg
, hdr
);
11289 return genlmsg_reply(msg
, info
);
11298 static int nl80211_cancel_remain_on_channel(struct sk_buff
*skb
,
11299 struct genl_info
*info
)
11301 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11302 struct wireless_dev
*wdev
= info
->user_ptr
[1];
11305 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
11308 if (!rdev
->ops
->cancel_remain_on_channel
)
11309 return -EOPNOTSUPP
;
11311 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
11313 return rdev_cancel_remain_on_channel(rdev
, wdev
, cookie
);
11316 static int nl80211_set_tx_bitrate_mask(struct sk_buff
*skb
,
11317 struct genl_info
*info
)
11319 struct cfg80211_bitrate_mask mask
;
11320 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11321 struct net_device
*dev
= info
->user_ptr
[1];
11324 if (!rdev
->ops
->set_bitrate_mask
)
11325 return -EOPNOTSUPP
;
11327 err
= nl80211_parse_tx_bitrate_mask(info
, info
->attrs
,
11328 NL80211_ATTR_TX_RATES
, &mask
,
11333 return rdev_set_bitrate_mask(rdev
, dev
, NULL
, &mask
);
11336 static int nl80211_register_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
11338 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11339 struct wireless_dev
*wdev
= info
->user_ptr
[1];
11340 u16 frame_type
= IEEE80211_FTYPE_MGMT
| IEEE80211_STYPE_ACTION
;
11342 if (!info
->attrs
[NL80211_ATTR_FRAME_MATCH
])
11345 if (info
->attrs
[NL80211_ATTR_FRAME_TYPE
])
11346 frame_type
= nla_get_u16(info
->attrs
[NL80211_ATTR_FRAME_TYPE
]);
11348 switch (wdev
->iftype
) {
11349 case NL80211_IFTYPE_STATION
:
11350 case NL80211_IFTYPE_ADHOC
:
11351 case NL80211_IFTYPE_P2P_CLIENT
:
11352 case NL80211_IFTYPE_AP
:
11353 case NL80211_IFTYPE_AP_VLAN
:
11354 case NL80211_IFTYPE_MESH_POINT
:
11355 case NL80211_IFTYPE_P2P_GO
:
11356 case NL80211_IFTYPE_P2P_DEVICE
:
11358 case NL80211_IFTYPE_NAN
:
11360 return -EOPNOTSUPP
;
11363 /* not much point in registering if we can't reply */
11364 if (!rdev
->ops
->mgmt_tx
)
11365 return -EOPNOTSUPP
;
11367 if (info
->attrs
[NL80211_ATTR_RECEIVE_MULTICAST
] &&
11368 !wiphy_ext_feature_isset(&rdev
->wiphy
,
11369 NL80211_EXT_FEATURE_MULTICAST_REGISTRATIONS
)) {
11370 GENL_SET_ERR_MSG(info
,
11371 "multicast RX registrations are not supported");
11372 return -EOPNOTSUPP
;
11375 return cfg80211_mlme_register_mgmt(wdev
, info
->snd_portid
, frame_type
,
11376 nla_data(info
->attrs
[NL80211_ATTR_FRAME_MATCH
]),
11377 nla_len(info
->attrs
[NL80211_ATTR_FRAME_MATCH
]),
11378 info
->attrs
[NL80211_ATTR_RECEIVE_MULTICAST
],
11382 static int nl80211_tx_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
11384 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11385 struct wireless_dev
*wdev
= info
->user_ptr
[1];
11386 struct cfg80211_chan_def chandef
;
11390 struct sk_buff
*msg
= NULL
;
11391 struct cfg80211_mgmt_tx_params params
= {
11392 .dont_wait_for_ack
=
11393 info
->attrs
[NL80211_ATTR_DONT_WAIT_FOR_ACK
],
11396 if (!info
->attrs
[NL80211_ATTR_FRAME
])
11399 if (!rdev
->ops
->mgmt_tx
)
11400 return -EOPNOTSUPP
;
11402 switch (wdev
->iftype
) {
11403 case NL80211_IFTYPE_P2P_DEVICE
:
11404 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
11407 case NL80211_IFTYPE_STATION
:
11408 case NL80211_IFTYPE_ADHOC
:
11409 case NL80211_IFTYPE_P2P_CLIENT
:
11410 case NL80211_IFTYPE_AP
:
11411 case NL80211_IFTYPE_AP_VLAN
:
11412 case NL80211_IFTYPE_MESH_POINT
:
11413 case NL80211_IFTYPE_P2P_GO
:
11415 case NL80211_IFTYPE_NAN
:
11417 return -EOPNOTSUPP
;
11420 if (info
->attrs
[NL80211_ATTR_DURATION
]) {
11421 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
))
11423 params
.wait
= nla_get_u32(info
->attrs
[NL80211_ATTR_DURATION
]);
11426 * We should wait on the channel for at least a minimum amount
11427 * of time (10ms) but no longer than the driver supports.
11429 if (params
.wait
< NL80211_MIN_REMAIN_ON_CHANNEL_TIME
||
11430 params
.wait
> rdev
->wiphy
.max_remain_on_channel_duration
)
11434 params
.offchan
= info
->attrs
[NL80211_ATTR_OFFCHANNEL_TX_OK
];
11436 if (params
.offchan
&& !(rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
))
11439 params
.no_cck
= nla_get_flag(info
->attrs
[NL80211_ATTR_TX_NO_CCK_RATE
]);
11441 /* get the channel if any has been specified, otherwise pass NULL to
11442 * the driver. The latter will use the current one
11444 chandef
.chan
= NULL
;
11445 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
11446 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
11451 if (!chandef
.chan
&& params
.offchan
)
11455 if (params
.offchan
&& !cfg80211_off_channel_oper_allowed(wdev
)) {
11461 params
.buf
= nla_data(info
->attrs
[NL80211_ATTR_FRAME
]);
11462 params
.len
= nla_len(info
->attrs
[NL80211_ATTR_FRAME
]);
11464 if (info
->attrs
[NL80211_ATTR_CSA_C_OFFSETS_TX
]) {
11465 int len
= nla_len(info
->attrs
[NL80211_ATTR_CSA_C_OFFSETS_TX
]);
11468 if (len
% sizeof(u16
))
11471 params
.n_csa_offsets
= len
/ sizeof(u16
);
11472 params
.csa_offsets
=
11473 nla_data(info
->attrs
[NL80211_ATTR_CSA_C_OFFSETS_TX
]);
11475 /* check that all the offsets fit the frame */
11476 for (i
= 0; i
< params
.n_csa_offsets
; i
++) {
11477 if (params
.csa_offsets
[i
] >= params
.len
)
11482 if (!params
.dont_wait_for_ack
) {
11483 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
11487 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
11488 NL80211_CMD_FRAME
);
11495 params
.chan
= chandef
.chan
;
11496 err
= cfg80211_mlme_mgmt_tx(rdev
, wdev
, ¶ms
, &cookie
);
11501 if (nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
11503 goto nla_put_failure
;
11505 genlmsg_end(msg
, hdr
);
11506 return genlmsg_reply(msg
, info
);
11518 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff
*skb
, struct genl_info
*info
)
11520 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11521 struct wireless_dev
*wdev
= info
->user_ptr
[1];
11524 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
11527 if (!rdev
->ops
->mgmt_tx_cancel_wait
)
11528 return -EOPNOTSUPP
;
11530 switch (wdev
->iftype
) {
11531 case NL80211_IFTYPE_STATION
:
11532 case NL80211_IFTYPE_ADHOC
:
11533 case NL80211_IFTYPE_P2P_CLIENT
:
11534 case NL80211_IFTYPE_AP
:
11535 case NL80211_IFTYPE_AP_VLAN
:
11536 case NL80211_IFTYPE_P2P_GO
:
11537 case NL80211_IFTYPE_P2P_DEVICE
:
11539 case NL80211_IFTYPE_NAN
:
11541 return -EOPNOTSUPP
;
11544 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
11546 return rdev_mgmt_tx_cancel_wait(rdev
, wdev
, cookie
);
11549 static int nl80211_set_power_save(struct sk_buff
*skb
, struct genl_info
*info
)
11551 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11552 struct wireless_dev
*wdev
;
11553 struct net_device
*dev
= info
->user_ptr
[1];
11558 if (!info
->attrs
[NL80211_ATTR_PS_STATE
])
11561 ps_state
= nla_get_u32(info
->attrs
[NL80211_ATTR_PS_STATE
]);
11563 wdev
= dev
->ieee80211_ptr
;
11565 if (!rdev
->ops
->set_power_mgmt
)
11566 return -EOPNOTSUPP
;
11568 state
= (ps_state
== NL80211_PS_ENABLED
) ? true : false;
11570 if (state
== wdev
->ps
)
11573 err
= rdev_set_power_mgmt(rdev
, dev
, state
, wdev
->ps_timeout
);
11579 static int nl80211_get_power_save(struct sk_buff
*skb
, struct genl_info
*info
)
11581 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11582 enum nl80211_ps_state ps_state
;
11583 struct wireless_dev
*wdev
;
11584 struct net_device
*dev
= info
->user_ptr
[1];
11585 struct sk_buff
*msg
;
11589 wdev
= dev
->ieee80211_ptr
;
11591 if (!rdev
->ops
->set_power_mgmt
)
11592 return -EOPNOTSUPP
;
11594 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
11598 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
11599 NL80211_CMD_GET_POWER_SAVE
);
11606 ps_state
= NL80211_PS_ENABLED
;
11608 ps_state
= NL80211_PS_DISABLED
;
11610 if (nla_put_u32(msg
, NL80211_ATTR_PS_STATE
, ps_state
))
11611 goto nla_put_failure
;
11613 genlmsg_end(msg
, hdr
);
11614 return genlmsg_reply(msg
, info
);
11623 static const struct nla_policy
11624 nl80211_attr_cqm_policy
[NL80211_ATTR_CQM_MAX
+ 1] = {
11625 [NL80211_ATTR_CQM_RSSI_THOLD
] = { .type
= NLA_BINARY
},
11626 [NL80211_ATTR_CQM_RSSI_HYST
] = { .type
= NLA_U32
},
11627 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
] = { .type
= NLA_U32
},
11628 [NL80211_ATTR_CQM_TXE_RATE
] = { .type
= NLA_U32
},
11629 [NL80211_ATTR_CQM_TXE_PKTS
] = { .type
= NLA_U32
},
11630 [NL80211_ATTR_CQM_TXE_INTVL
] = { .type
= NLA_U32
},
11631 [NL80211_ATTR_CQM_RSSI_LEVEL
] = { .type
= NLA_S32
},
11634 static int nl80211_set_cqm_txe(struct genl_info
*info
,
11635 u32 rate
, u32 pkts
, u32 intvl
)
11637 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11638 struct net_device
*dev
= info
->user_ptr
[1];
11639 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11641 if (rate
> 100 || intvl
> NL80211_CQM_TXE_MAX_INTVL
)
11644 if (!rdev
->ops
->set_cqm_txe_config
)
11645 return -EOPNOTSUPP
;
11647 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
11648 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
11649 return -EOPNOTSUPP
;
11651 return rdev_set_cqm_txe_config(rdev
, dev
, rate
, pkts
, intvl
);
11654 static int cfg80211_cqm_rssi_update(struct cfg80211_registered_device
*rdev
,
11655 struct net_device
*dev
)
11657 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11658 s32 last
, low
, high
;
11660 int i
, n
, low_index
;
11663 /* RSSI reporting disabled? */
11664 if (!wdev
->cqm_config
)
11665 return rdev_set_cqm_rssi_range_config(rdev
, dev
, 0, 0);
11668 * Obtain current RSSI value if possible, if not and no RSSI threshold
11669 * event has been received yet, we should receive an event after a
11670 * connection is established and enough beacons received to calculate
11673 if (!wdev
->cqm_config
->last_rssi_event_value
&& wdev
->current_bss
&&
11674 rdev
->ops
->get_station
) {
11675 struct station_info sinfo
= {};
11678 mac_addr
= wdev
->current_bss
->pub
.bssid
;
11680 err
= rdev_get_station(rdev
, dev
, mac_addr
, &sinfo
);
11684 cfg80211_sinfo_release_content(&sinfo
);
11685 if (sinfo
.filled
& BIT_ULL(NL80211_STA_INFO_BEACON_SIGNAL_AVG
))
11686 wdev
->cqm_config
->last_rssi_event_value
=
11687 (s8
) sinfo
.rx_beacon_signal_avg
;
11690 last
= wdev
->cqm_config
->last_rssi_event_value
;
11691 hyst
= wdev
->cqm_config
->rssi_hyst
;
11692 n
= wdev
->cqm_config
->n_rssi_thresholds
;
11694 for (i
= 0; i
< n
; i
++) {
11695 i
= array_index_nospec(i
, n
);
11696 if (last
< wdev
->cqm_config
->rssi_thresholds
[i
])
11701 if (low_index
>= 0) {
11702 low_index
= array_index_nospec(low_index
, n
);
11703 low
= wdev
->cqm_config
->rssi_thresholds
[low_index
] - hyst
;
11708 i
= array_index_nospec(i
, n
);
11709 high
= wdev
->cqm_config
->rssi_thresholds
[i
] + hyst
- 1;
11714 return rdev_set_cqm_rssi_range_config(rdev
, dev
, low
, high
);
11717 static int nl80211_set_cqm_rssi(struct genl_info
*info
,
11718 const s32
*thresholds
, int n_thresholds
,
11721 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11722 struct net_device
*dev
= info
->user_ptr
[1];
11723 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11725 s32 prev
= S32_MIN
;
11727 /* Check all values negative and sorted */
11728 for (i
= 0; i
< n_thresholds
; i
++) {
11729 if (thresholds
[i
] > 0 || thresholds
[i
] <= prev
)
11732 prev
= thresholds
[i
];
11735 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
11736 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
11737 return -EOPNOTSUPP
;
11740 cfg80211_cqm_config_free(wdev
);
11743 if (n_thresholds
<= 1 && rdev
->ops
->set_cqm_rssi_config
) {
11744 if (n_thresholds
== 0 || thresholds
[0] == 0) /* Disabling */
11745 return rdev_set_cqm_rssi_config(rdev
, dev
, 0, 0);
11747 return rdev_set_cqm_rssi_config(rdev
, dev
,
11748 thresholds
[0], hysteresis
);
11751 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
11752 NL80211_EXT_FEATURE_CQM_RSSI_LIST
))
11753 return -EOPNOTSUPP
;
11755 if (n_thresholds
== 1 && thresholds
[0] == 0) /* Disabling */
11759 if (n_thresholds
) {
11760 struct cfg80211_cqm_config
*cqm_config
;
11762 cqm_config
= kzalloc(sizeof(struct cfg80211_cqm_config
) +
11763 n_thresholds
* sizeof(s32
), GFP_KERNEL
);
11769 cqm_config
->rssi_hyst
= hysteresis
;
11770 cqm_config
->n_rssi_thresholds
= n_thresholds
;
11771 memcpy(cqm_config
->rssi_thresholds
, thresholds
,
11772 n_thresholds
* sizeof(s32
));
11774 wdev
->cqm_config
= cqm_config
;
11777 err
= cfg80211_cqm_rssi_update(rdev
, dev
);
11785 static int nl80211_set_cqm(struct sk_buff
*skb
, struct genl_info
*info
)
11787 struct nlattr
*attrs
[NL80211_ATTR_CQM_MAX
+ 1];
11788 struct nlattr
*cqm
;
11791 cqm
= info
->attrs
[NL80211_ATTR_CQM
];
11795 err
= nla_parse_nested_deprecated(attrs
, NL80211_ATTR_CQM_MAX
, cqm
,
11796 nl80211_attr_cqm_policy
,
11801 if (attrs
[NL80211_ATTR_CQM_RSSI_THOLD
] &&
11802 attrs
[NL80211_ATTR_CQM_RSSI_HYST
]) {
11803 const s32
*thresholds
=
11804 nla_data(attrs
[NL80211_ATTR_CQM_RSSI_THOLD
]);
11805 int len
= nla_len(attrs
[NL80211_ATTR_CQM_RSSI_THOLD
]);
11806 u32 hysteresis
= nla_get_u32(attrs
[NL80211_ATTR_CQM_RSSI_HYST
]);
11811 return nl80211_set_cqm_rssi(info
, thresholds
, len
/ 4,
11815 if (attrs
[NL80211_ATTR_CQM_TXE_RATE
] &&
11816 attrs
[NL80211_ATTR_CQM_TXE_PKTS
] &&
11817 attrs
[NL80211_ATTR_CQM_TXE_INTVL
]) {
11818 u32 rate
= nla_get_u32(attrs
[NL80211_ATTR_CQM_TXE_RATE
]);
11819 u32 pkts
= nla_get_u32(attrs
[NL80211_ATTR_CQM_TXE_PKTS
]);
11820 u32 intvl
= nla_get_u32(attrs
[NL80211_ATTR_CQM_TXE_INTVL
]);
11822 return nl80211_set_cqm_txe(info
, rate
, pkts
, intvl
);
11828 static int nl80211_join_ocb(struct sk_buff
*skb
, struct genl_info
*info
)
11830 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11831 struct net_device
*dev
= info
->user_ptr
[1];
11832 struct ocb_setup setup
= {};
11835 err
= nl80211_parse_chandef(rdev
, info
, &setup
.chandef
);
11839 return cfg80211_join_ocb(rdev
, dev
, &setup
);
11842 static int nl80211_leave_ocb(struct sk_buff
*skb
, struct genl_info
*info
)
11844 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11845 struct net_device
*dev
= info
->user_ptr
[1];
11847 return cfg80211_leave_ocb(rdev
, dev
);
11850 static int nl80211_join_mesh(struct sk_buff
*skb
, struct genl_info
*info
)
11852 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11853 struct net_device
*dev
= info
->user_ptr
[1];
11854 struct mesh_config cfg
;
11855 struct mesh_setup setup
;
11858 /* start with default */
11859 memcpy(&cfg
, &default_mesh_config
, sizeof(cfg
));
11860 memcpy(&setup
, &default_mesh_setup
, sizeof(setup
));
11862 if (info
->attrs
[NL80211_ATTR_MESH_CONFIG
]) {
11863 /* and parse parameters if given */
11864 err
= nl80211_parse_mesh_config(info
, &cfg
, NULL
);
11869 if (!info
->attrs
[NL80211_ATTR_MESH_ID
] ||
11870 !nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]))
11873 setup
.mesh_id
= nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]);
11874 setup
.mesh_id_len
= nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
11876 if (info
->attrs
[NL80211_ATTR_MCAST_RATE
] &&
11877 !nl80211_parse_mcast_rate(rdev
, setup
.mcast_rate
,
11878 nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
])))
11881 if (info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]) {
11882 setup
.beacon_interval
=
11883 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
11885 err
= cfg80211_validate_beacon_int(rdev
,
11886 NL80211_IFTYPE_MESH_POINT
,
11887 setup
.beacon_interval
);
11892 if (info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]) {
11893 setup
.dtim_period
=
11894 nla_get_u32(info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]);
11895 if (setup
.dtim_period
< 1 || setup
.dtim_period
> 100)
11899 if (info
->attrs
[NL80211_ATTR_MESH_SETUP
]) {
11900 /* parse additional setup parameters if given */
11901 err
= nl80211_parse_mesh_setup(info
, &setup
);
11906 if (setup
.user_mpm
)
11907 cfg
.auto_open_plinks
= false;
11909 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
11910 err
= nl80211_parse_chandef(rdev
, info
, &setup
.chandef
);
11914 /* __cfg80211_join_mesh() will sort it out */
11915 setup
.chandef
.chan
= NULL
;
11918 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
11919 u8
*rates
= nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
11921 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
11922 struct ieee80211_supported_band
*sband
;
11924 if (!setup
.chandef
.chan
)
11927 sband
= rdev
->wiphy
.bands
[setup
.chandef
.chan
->band
];
11929 err
= ieee80211_get_ratemask(sband
, rates
, n_rates
,
11930 &setup
.basic_rates
);
11935 if (info
->attrs
[NL80211_ATTR_TX_RATES
]) {
11936 err
= nl80211_parse_tx_bitrate_mask(info
, info
->attrs
,
11937 NL80211_ATTR_TX_RATES
,
11938 &setup
.beacon_rate
,
11943 if (!setup
.chandef
.chan
)
11946 err
= validate_beacon_tx_rate(rdev
, setup
.chandef
.chan
->band
,
11947 &setup
.beacon_rate
);
11952 setup
.userspace_handles_dfs
=
11953 nla_get_flag(info
->attrs
[NL80211_ATTR_HANDLE_DFS
]);
11955 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_OVER_NL80211
]) {
11956 int r
= validate_pae_over_nl80211(rdev
, info
);
11961 setup
.control_port_over_nl80211
= true;
11964 wdev_lock(dev
->ieee80211_ptr
);
11965 err
= __cfg80211_join_mesh(rdev
, dev
, &setup
, &cfg
);
11966 if (!err
&& info
->attrs
[NL80211_ATTR_SOCKET_OWNER
])
11967 dev
->ieee80211_ptr
->conn_owner_nlportid
= info
->snd_portid
;
11968 wdev_unlock(dev
->ieee80211_ptr
);
11973 static int nl80211_leave_mesh(struct sk_buff
*skb
, struct genl_info
*info
)
11975 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
11976 struct net_device
*dev
= info
->user_ptr
[1];
11978 return cfg80211_leave_mesh(rdev
, dev
);
11982 static int nl80211_send_wowlan_patterns(struct sk_buff
*msg
,
11983 struct cfg80211_registered_device
*rdev
)
11985 struct cfg80211_wowlan
*wowlan
= rdev
->wiphy
.wowlan_config
;
11986 struct nlattr
*nl_pats
, *nl_pat
;
11989 if (!wowlan
->n_patterns
)
11992 nl_pats
= nla_nest_start_noflag(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
);
11996 for (i
= 0; i
< wowlan
->n_patterns
; i
++) {
11997 nl_pat
= nla_nest_start_noflag(msg
, i
+ 1);
12000 pat_len
= wowlan
->patterns
[i
].pattern_len
;
12001 if (nla_put(msg
, NL80211_PKTPAT_MASK
, DIV_ROUND_UP(pat_len
, 8),
12002 wowlan
->patterns
[i
].mask
) ||
12003 nla_put(msg
, NL80211_PKTPAT_PATTERN
, pat_len
,
12004 wowlan
->patterns
[i
].pattern
) ||
12005 nla_put_u32(msg
, NL80211_PKTPAT_OFFSET
,
12006 wowlan
->patterns
[i
].pkt_offset
))
12008 nla_nest_end(msg
, nl_pat
);
12010 nla_nest_end(msg
, nl_pats
);
12015 static int nl80211_send_wowlan_tcp(struct sk_buff
*msg
,
12016 struct cfg80211_wowlan_tcp
*tcp
)
12018 struct nlattr
*nl_tcp
;
12023 nl_tcp
= nla_nest_start_noflag(msg
,
12024 NL80211_WOWLAN_TRIG_TCP_CONNECTION
);
12028 if (nla_put_in_addr(msg
, NL80211_WOWLAN_TCP_SRC_IPV4
, tcp
->src
) ||
12029 nla_put_in_addr(msg
, NL80211_WOWLAN_TCP_DST_IPV4
, tcp
->dst
) ||
12030 nla_put(msg
, NL80211_WOWLAN_TCP_DST_MAC
, ETH_ALEN
, tcp
->dst_mac
) ||
12031 nla_put_u16(msg
, NL80211_WOWLAN_TCP_SRC_PORT
, tcp
->src_port
) ||
12032 nla_put_u16(msg
, NL80211_WOWLAN_TCP_DST_PORT
, tcp
->dst_port
) ||
12033 nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD
,
12034 tcp
->payload_len
, tcp
->payload
) ||
12035 nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_INTERVAL
,
12036 tcp
->data_interval
) ||
12037 nla_put(msg
, NL80211_WOWLAN_TCP_WAKE_PAYLOAD
,
12038 tcp
->wake_len
, tcp
->wake_data
) ||
12039 nla_put(msg
, NL80211_WOWLAN_TCP_WAKE_MASK
,
12040 DIV_ROUND_UP(tcp
->wake_len
, 8), tcp
->wake_mask
))
12043 if (tcp
->payload_seq
.len
&&
12044 nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
,
12045 sizeof(tcp
->payload_seq
), &tcp
->payload_seq
))
12048 if (tcp
->payload_tok
.len
&&
12049 nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
,
12050 sizeof(tcp
->payload_tok
) + tcp
->tokens_size
,
12051 &tcp
->payload_tok
))
12054 nla_nest_end(msg
, nl_tcp
);
12059 static int nl80211_send_wowlan_nd(struct sk_buff
*msg
,
12060 struct cfg80211_sched_scan_request
*req
)
12062 struct nlattr
*nd
, *freqs
, *matches
, *match
, *scan_plans
, *scan_plan
;
12068 nd
= nla_nest_start_noflag(msg
, NL80211_WOWLAN_TRIG_NET_DETECT
);
12072 if (req
->n_scan_plans
== 1 &&
12073 nla_put_u32(msg
, NL80211_ATTR_SCHED_SCAN_INTERVAL
,
12074 req
->scan_plans
[0].interval
* 1000))
12077 if (nla_put_u32(msg
, NL80211_ATTR_SCHED_SCAN_DELAY
, req
->delay
))
12080 if (req
->relative_rssi_set
) {
12081 struct nl80211_bss_select_rssi_adjust rssi_adjust
;
12083 if (nla_put_s8(msg
, NL80211_ATTR_SCHED_SCAN_RELATIVE_RSSI
,
12084 req
->relative_rssi
))
12087 rssi_adjust
.band
= req
->rssi_adjust
.band
;
12088 rssi_adjust
.delta
= req
->rssi_adjust
.delta
;
12089 if (nla_put(msg
, NL80211_ATTR_SCHED_SCAN_RSSI_ADJUST
,
12090 sizeof(rssi_adjust
), &rssi_adjust
))
12094 freqs
= nla_nest_start_noflag(msg
, NL80211_ATTR_SCAN_FREQUENCIES
);
12098 for (i
= 0; i
< req
->n_channels
; i
++) {
12099 if (nla_put_u32(msg
, i
, req
->channels
[i
]->center_freq
))
12103 nla_nest_end(msg
, freqs
);
12105 if (req
->n_match_sets
) {
12106 matches
= nla_nest_start_noflag(msg
,
12107 NL80211_ATTR_SCHED_SCAN_MATCH
);
12111 for (i
= 0; i
< req
->n_match_sets
; i
++) {
12112 match
= nla_nest_start_noflag(msg
, i
);
12116 if (nla_put(msg
, NL80211_SCHED_SCAN_MATCH_ATTR_SSID
,
12117 req
->match_sets
[i
].ssid
.ssid_len
,
12118 req
->match_sets
[i
].ssid
.ssid
))
12120 nla_nest_end(msg
, match
);
12122 nla_nest_end(msg
, matches
);
12125 scan_plans
= nla_nest_start_noflag(msg
, NL80211_ATTR_SCHED_SCAN_PLANS
);
12129 for (i
= 0; i
< req
->n_scan_plans
; i
++) {
12130 scan_plan
= nla_nest_start_noflag(msg
, i
+ 1);
12134 if (nla_put_u32(msg
, NL80211_SCHED_SCAN_PLAN_INTERVAL
,
12135 req
->scan_plans
[i
].interval
) ||
12136 (req
->scan_plans
[i
].iterations
&&
12137 nla_put_u32(msg
, NL80211_SCHED_SCAN_PLAN_ITERATIONS
,
12138 req
->scan_plans
[i
].iterations
)))
12140 nla_nest_end(msg
, scan_plan
);
12142 nla_nest_end(msg
, scan_plans
);
12144 nla_nest_end(msg
, nd
);
12149 static int nl80211_get_wowlan(struct sk_buff
*skb
, struct genl_info
*info
)
12151 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12152 struct sk_buff
*msg
;
12154 u32 size
= NLMSG_DEFAULT_SIZE
;
12156 if (!rdev
->wiphy
.wowlan
)
12157 return -EOPNOTSUPP
;
12159 if (rdev
->wiphy
.wowlan_config
&& rdev
->wiphy
.wowlan_config
->tcp
) {
12160 /* adjust size to have room for all the data */
12161 size
+= rdev
->wiphy
.wowlan_config
->tcp
->tokens_size
+
12162 rdev
->wiphy
.wowlan_config
->tcp
->payload_len
+
12163 rdev
->wiphy
.wowlan_config
->tcp
->wake_len
+
12164 rdev
->wiphy
.wowlan_config
->tcp
->wake_len
/ 8;
12167 msg
= nlmsg_new(size
, GFP_KERNEL
);
12171 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
12172 NL80211_CMD_GET_WOWLAN
);
12174 goto nla_put_failure
;
12176 if (rdev
->wiphy
.wowlan_config
) {
12177 struct nlattr
*nl_wowlan
;
12179 nl_wowlan
= nla_nest_start_noflag(msg
,
12180 NL80211_ATTR_WOWLAN_TRIGGERS
);
12182 goto nla_put_failure
;
12184 if ((rdev
->wiphy
.wowlan_config
->any
&&
12185 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_ANY
)) ||
12186 (rdev
->wiphy
.wowlan_config
->disconnect
&&
12187 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
)) ||
12188 (rdev
->wiphy
.wowlan_config
->magic_pkt
&&
12189 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
)) ||
12190 (rdev
->wiphy
.wowlan_config
->gtk_rekey_failure
&&
12191 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
)) ||
12192 (rdev
->wiphy
.wowlan_config
->eap_identity_req
&&
12193 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
)) ||
12194 (rdev
->wiphy
.wowlan_config
->four_way_handshake
&&
12195 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
)) ||
12196 (rdev
->wiphy
.wowlan_config
->rfkill_release
&&
12197 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
)))
12198 goto nla_put_failure
;
12200 if (nl80211_send_wowlan_patterns(msg
, rdev
))
12201 goto nla_put_failure
;
12203 if (nl80211_send_wowlan_tcp(msg
,
12204 rdev
->wiphy
.wowlan_config
->tcp
))
12205 goto nla_put_failure
;
12207 if (nl80211_send_wowlan_nd(
12209 rdev
->wiphy
.wowlan_config
->nd_config
))
12210 goto nla_put_failure
;
12212 nla_nest_end(msg
, nl_wowlan
);
12215 genlmsg_end(msg
, hdr
);
12216 return genlmsg_reply(msg
, info
);
12223 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device
*rdev
,
12224 struct nlattr
*attr
,
12225 struct cfg80211_wowlan
*trig
)
12227 struct nlattr
*tb
[NUM_NL80211_WOWLAN_TCP
];
12228 struct cfg80211_wowlan_tcp
*cfg
;
12229 struct nl80211_wowlan_tcp_data_token
*tok
= NULL
;
12230 struct nl80211_wowlan_tcp_data_seq
*seq
= NULL
;
12232 u32 data_size
, wake_size
, tokens_size
= 0, wake_mask_size
;
12235 if (!rdev
->wiphy
.wowlan
->tcp
)
12238 err
= nla_parse_nested_deprecated(tb
, MAX_NL80211_WOWLAN_TCP
, attr
,
12239 nl80211_wowlan_tcp_policy
, NULL
);
12243 if (!tb
[NL80211_WOWLAN_TCP_SRC_IPV4
] ||
12244 !tb
[NL80211_WOWLAN_TCP_DST_IPV4
] ||
12245 !tb
[NL80211_WOWLAN_TCP_DST_MAC
] ||
12246 !tb
[NL80211_WOWLAN_TCP_DST_PORT
] ||
12247 !tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD
] ||
12248 !tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
] ||
12249 !tb
[NL80211_WOWLAN_TCP_WAKE_PAYLOAD
] ||
12250 !tb
[NL80211_WOWLAN_TCP_WAKE_MASK
])
12253 data_size
= nla_len(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD
]);
12254 if (data_size
> rdev
->wiphy
.wowlan
->tcp
->data_payload_max
)
12257 if (nla_get_u32(tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
]) >
12258 rdev
->wiphy
.wowlan
->tcp
->data_interval_max
||
12259 nla_get_u32(tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
]) == 0)
12262 wake_size
= nla_len(tb
[NL80211_WOWLAN_TCP_WAKE_PAYLOAD
]);
12263 if (wake_size
> rdev
->wiphy
.wowlan
->tcp
->wake_payload_max
)
12266 wake_mask_size
= nla_len(tb
[NL80211_WOWLAN_TCP_WAKE_MASK
]);
12267 if (wake_mask_size
!= DIV_ROUND_UP(wake_size
, 8))
12270 if (tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
]) {
12271 u32 tokln
= nla_len(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
]);
12273 tok
= nla_data(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
]);
12274 tokens_size
= tokln
- sizeof(*tok
);
12276 if (!tok
->len
|| tokens_size
% tok
->len
)
12278 if (!rdev
->wiphy
.wowlan
->tcp
->tok
)
12280 if (tok
->len
> rdev
->wiphy
.wowlan
->tcp
->tok
->max_len
)
12282 if (tok
->len
< rdev
->wiphy
.wowlan
->tcp
->tok
->min_len
)
12284 if (tokens_size
> rdev
->wiphy
.wowlan
->tcp
->tok
->bufsize
)
12286 if (tok
->offset
+ tok
->len
> data_size
)
12290 if (tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
]) {
12291 seq
= nla_data(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
]);
12292 if (!rdev
->wiphy
.wowlan
->tcp
->seq
)
12294 if (seq
->len
== 0 || seq
->len
> 4)
12296 if (seq
->len
+ seq
->offset
> data_size
)
12300 size
= sizeof(*cfg
);
12302 size
+= wake_size
+ wake_mask_size
;
12303 size
+= tokens_size
;
12305 cfg
= kzalloc(size
, GFP_KERNEL
);
12308 cfg
->src
= nla_get_in_addr(tb
[NL80211_WOWLAN_TCP_SRC_IPV4
]);
12309 cfg
->dst
= nla_get_in_addr(tb
[NL80211_WOWLAN_TCP_DST_IPV4
]);
12310 memcpy(cfg
->dst_mac
, nla_data(tb
[NL80211_WOWLAN_TCP_DST_MAC
]),
12312 if (tb
[NL80211_WOWLAN_TCP_SRC_PORT
])
12313 port
= nla_get_u16(tb
[NL80211_WOWLAN_TCP_SRC_PORT
]);
12317 /* allocate a socket and port for it and use it */
12318 err
= __sock_create(wiphy_net(&rdev
->wiphy
), PF_INET
, SOCK_STREAM
,
12319 IPPROTO_TCP
, &cfg
->sock
, 1);
12324 if (inet_csk_get_port(cfg
->sock
->sk
, port
)) {
12325 sock_release(cfg
->sock
);
12327 return -EADDRINUSE
;
12329 cfg
->src_port
= inet_sk(cfg
->sock
->sk
)->inet_num
;
12335 cfg
->src_port
= port
;
12338 cfg
->dst_port
= nla_get_u16(tb
[NL80211_WOWLAN_TCP_DST_PORT
]);
12339 cfg
->payload_len
= data_size
;
12340 cfg
->payload
= (u8
*)cfg
+ sizeof(*cfg
) + tokens_size
;
12341 memcpy((void *)cfg
->payload
,
12342 nla_data(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD
]),
12345 cfg
->payload_seq
= *seq
;
12346 cfg
->data_interval
= nla_get_u32(tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
]);
12347 cfg
->wake_len
= wake_size
;
12348 cfg
->wake_data
= (u8
*)cfg
+ sizeof(*cfg
) + tokens_size
+ data_size
;
12349 memcpy((void *)cfg
->wake_data
,
12350 nla_data(tb
[NL80211_WOWLAN_TCP_WAKE_PAYLOAD
]),
12352 cfg
->wake_mask
= (u8
*)cfg
+ sizeof(*cfg
) + tokens_size
+
12353 data_size
+ wake_size
;
12354 memcpy((void *)cfg
->wake_mask
,
12355 nla_data(tb
[NL80211_WOWLAN_TCP_WAKE_MASK
]),
12358 cfg
->tokens_size
= tokens_size
;
12359 memcpy(&cfg
->payload_tok
, tok
, sizeof(*tok
) + tokens_size
);
12367 static int nl80211_parse_wowlan_nd(struct cfg80211_registered_device
*rdev
,
12368 const struct wiphy_wowlan_support
*wowlan
,
12369 struct nlattr
*attr
,
12370 struct cfg80211_wowlan
*trig
)
12372 struct nlattr
**tb
;
12375 tb
= kcalloc(NUM_NL80211_ATTR
, sizeof(*tb
), GFP_KERNEL
);
12379 if (!(wowlan
->flags
& WIPHY_WOWLAN_NET_DETECT
)) {
12384 err
= nla_parse_nested_deprecated(tb
, NL80211_ATTR_MAX
, attr
,
12385 nl80211_policy
, NULL
);
12389 trig
->nd_config
= nl80211_parse_sched_scan(&rdev
->wiphy
, NULL
, tb
,
12390 wowlan
->max_nd_match_sets
);
12391 err
= PTR_ERR_OR_ZERO(trig
->nd_config
);
12393 trig
->nd_config
= NULL
;
12400 static int nl80211_set_wowlan(struct sk_buff
*skb
, struct genl_info
*info
)
12402 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12403 struct nlattr
*tb
[NUM_NL80211_WOWLAN_TRIG
];
12404 struct cfg80211_wowlan new_triggers
= {};
12405 struct cfg80211_wowlan
*ntrig
;
12406 const struct wiphy_wowlan_support
*wowlan
= rdev
->wiphy
.wowlan
;
12408 bool prev_enabled
= rdev
->wiphy
.wowlan_config
;
12409 bool regular
= false;
12412 return -EOPNOTSUPP
;
12414 if (!info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
]) {
12415 cfg80211_rdev_free_wowlan(rdev
);
12416 rdev
->wiphy
.wowlan_config
= NULL
;
12420 err
= nla_parse_nested_deprecated(tb
, MAX_NL80211_WOWLAN_TRIG
,
12421 info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
],
12422 nl80211_wowlan_policy
, info
->extack
);
12426 if (tb
[NL80211_WOWLAN_TRIG_ANY
]) {
12427 if (!(wowlan
->flags
& WIPHY_WOWLAN_ANY
))
12429 new_triggers
.any
= true;
12432 if (tb
[NL80211_WOWLAN_TRIG_DISCONNECT
]) {
12433 if (!(wowlan
->flags
& WIPHY_WOWLAN_DISCONNECT
))
12435 new_triggers
.disconnect
= true;
12439 if (tb
[NL80211_WOWLAN_TRIG_MAGIC_PKT
]) {
12440 if (!(wowlan
->flags
& WIPHY_WOWLAN_MAGIC_PKT
))
12442 new_triggers
.magic_pkt
= true;
12446 if (tb
[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED
])
12449 if (tb
[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
]) {
12450 if (!(wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
))
12452 new_triggers
.gtk_rekey_failure
= true;
12456 if (tb
[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
]) {
12457 if (!(wowlan
->flags
& WIPHY_WOWLAN_EAP_IDENTITY_REQ
))
12459 new_triggers
.eap_identity_req
= true;
12463 if (tb
[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
]) {
12464 if (!(wowlan
->flags
& WIPHY_WOWLAN_4WAY_HANDSHAKE
))
12466 new_triggers
.four_way_handshake
= true;
12470 if (tb
[NL80211_WOWLAN_TRIG_RFKILL_RELEASE
]) {
12471 if (!(wowlan
->flags
& WIPHY_WOWLAN_RFKILL_RELEASE
))
12473 new_triggers
.rfkill_release
= true;
12477 if (tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
]) {
12478 struct nlattr
*pat
;
12479 int n_patterns
= 0;
12480 int rem
, pat_len
, mask_len
, pkt_offset
;
12481 struct nlattr
*pat_tb
[NUM_NL80211_PKTPAT
];
12485 nla_for_each_nested(pat
, tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
],
12488 if (n_patterns
> wowlan
->n_patterns
)
12491 new_triggers
.patterns
= kcalloc(n_patterns
,
12492 sizeof(new_triggers
.patterns
[0]),
12494 if (!new_triggers
.patterns
)
12497 new_triggers
.n_patterns
= n_patterns
;
12500 nla_for_each_nested(pat
, tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
],
12504 err
= nla_parse_nested_deprecated(pat_tb
,
12505 MAX_NL80211_PKTPAT
,
12507 nl80211_packet_pattern_policy
,
12513 if (!pat_tb
[NL80211_PKTPAT_MASK
] ||
12514 !pat_tb
[NL80211_PKTPAT_PATTERN
])
12516 pat_len
= nla_len(pat_tb
[NL80211_PKTPAT_PATTERN
]);
12517 mask_len
= DIV_ROUND_UP(pat_len
, 8);
12518 if (nla_len(pat_tb
[NL80211_PKTPAT_MASK
]) != mask_len
)
12520 if (pat_len
> wowlan
->pattern_max_len
||
12521 pat_len
< wowlan
->pattern_min_len
)
12524 if (!pat_tb
[NL80211_PKTPAT_OFFSET
])
12527 pkt_offset
= nla_get_u32(
12528 pat_tb
[NL80211_PKTPAT_OFFSET
]);
12529 if (pkt_offset
> wowlan
->max_pkt_offset
)
12531 new_triggers
.patterns
[i
].pkt_offset
= pkt_offset
;
12533 mask_pat
= kmalloc(mask_len
+ pat_len
, GFP_KERNEL
);
12538 new_triggers
.patterns
[i
].mask
= mask_pat
;
12539 memcpy(mask_pat
, nla_data(pat_tb
[NL80211_PKTPAT_MASK
]),
12541 mask_pat
+= mask_len
;
12542 new_triggers
.patterns
[i
].pattern
= mask_pat
;
12543 new_triggers
.patterns
[i
].pattern_len
= pat_len
;
12545 nla_data(pat_tb
[NL80211_PKTPAT_PATTERN
]),
12551 if (tb
[NL80211_WOWLAN_TRIG_TCP_CONNECTION
]) {
12553 err
= nl80211_parse_wowlan_tcp(
12554 rdev
, tb
[NL80211_WOWLAN_TRIG_TCP_CONNECTION
],
12560 if (tb
[NL80211_WOWLAN_TRIG_NET_DETECT
]) {
12562 err
= nl80211_parse_wowlan_nd(
12563 rdev
, wowlan
, tb
[NL80211_WOWLAN_TRIG_NET_DETECT
],
12569 /* The 'any' trigger means the device continues operating more or less
12570 * as in its normal operation mode and wakes up the host on most of the
12571 * normal interrupts (like packet RX, ...)
12572 * It therefore makes little sense to combine with the more constrained
12573 * wakeup trigger modes.
12575 if (new_triggers
.any
&& regular
) {
12580 ntrig
= kmemdup(&new_triggers
, sizeof(new_triggers
), GFP_KERNEL
);
12585 cfg80211_rdev_free_wowlan(rdev
);
12586 rdev
->wiphy
.wowlan_config
= ntrig
;
12589 if (rdev
->ops
->set_wakeup
&&
12590 prev_enabled
!= !!rdev
->wiphy
.wowlan_config
)
12591 rdev_set_wakeup(rdev
, rdev
->wiphy
.wowlan_config
);
12595 for (i
= 0; i
< new_triggers
.n_patterns
; i
++)
12596 kfree(new_triggers
.patterns
[i
].mask
);
12597 kfree(new_triggers
.patterns
);
12598 if (new_triggers
.tcp
&& new_triggers
.tcp
->sock
)
12599 sock_release(new_triggers
.tcp
->sock
);
12600 kfree(new_triggers
.tcp
);
12601 kfree(new_triggers
.nd_config
);
12606 static int nl80211_send_coalesce_rules(struct sk_buff
*msg
,
12607 struct cfg80211_registered_device
*rdev
)
12609 struct nlattr
*nl_pats
, *nl_pat
, *nl_rule
, *nl_rules
;
12611 struct cfg80211_coalesce_rules
*rule
;
12613 if (!rdev
->coalesce
->n_rules
)
12616 nl_rules
= nla_nest_start_noflag(msg
, NL80211_ATTR_COALESCE_RULE
);
12620 for (i
= 0; i
< rdev
->coalesce
->n_rules
; i
++) {
12621 nl_rule
= nla_nest_start_noflag(msg
, i
+ 1);
12625 rule
= &rdev
->coalesce
->rules
[i
];
12626 if (nla_put_u32(msg
, NL80211_ATTR_COALESCE_RULE_DELAY
,
12630 if (nla_put_u32(msg
, NL80211_ATTR_COALESCE_RULE_CONDITION
,
12634 nl_pats
= nla_nest_start_noflag(msg
,
12635 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
);
12639 for (j
= 0; j
< rule
->n_patterns
; j
++) {
12640 nl_pat
= nla_nest_start_noflag(msg
, j
+ 1);
12643 pat_len
= rule
->patterns
[j
].pattern_len
;
12644 if (nla_put(msg
, NL80211_PKTPAT_MASK
,
12645 DIV_ROUND_UP(pat_len
, 8),
12646 rule
->patterns
[j
].mask
) ||
12647 nla_put(msg
, NL80211_PKTPAT_PATTERN
, pat_len
,
12648 rule
->patterns
[j
].pattern
) ||
12649 nla_put_u32(msg
, NL80211_PKTPAT_OFFSET
,
12650 rule
->patterns
[j
].pkt_offset
))
12652 nla_nest_end(msg
, nl_pat
);
12654 nla_nest_end(msg
, nl_pats
);
12655 nla_nest_end(msg
, nl_rule
);
12657 nla_nest_end(msg
, nl_rules
);
12662 static int nl80211_get_coalesce(struct sk_buff
*skb
, struct genl_info
*info
)
12664 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12665 struct sk_buff
*msg
;
12668 if (!rdev
->wiphy
.coalesce
)
12669 return -EOPNOTSUPP
;
12671 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
12675 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
12676 NL80211_CMD_GET_COALESCE
);
12678 goto nla_put_failure
;
12680 if (rdev
->coalesce
&& nl80211_send_coalesce_rules(msg
, rdev
))
12681 goto nla_put_failure
;
12683 genlmsg_end(msg
, hdr
);
12684 return genlmsg_reply(msg
, info
);
12691 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device
*rdev
)
12693 struct cfg80211_coalesce
*coalesce
= rdev
->coalesce
;
12695 struct cfg80211_coalesce_rules
*rule
;
12700 for (i
= 0; i
< coalesce
->n_rules
; i
++) {
12701 rule
= &coalesce
->rules
[i
];
12702 for (j
= 0; j
< rule
->n_patterns
; j
++)
12703 kfree(rule
->patterns
[j
].mask
);
12704 kfree(rule
->patterns
);
12706 kfree(coalesce
->rules
);
12708 rdev
->coalesce
= NULL
;
12711 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device
*rdev
,
12712 struct nlattr
*rule
,
12713 struct cfg80211_coalesce_rules
*new_rule
)
12716 const struct wiphy_coalesce_support
*coalesce
= rdev
->wiphy
.coalesce
;
12717 struct nlattr
*tb
[NUM_NL80211_ATTR_COALESCE_RULE
], *pat
;
12718 int rem
, pat_len
, mask_len
, pkt_offset
, n_patterns
= 0;
12719 struct nlattr
*pat_tb
[NUM_NL80211_PKTPAT
];
12721 err
= nla_parse_nested_deprecated(tb
, NL80211_ATTR_COALESCE_RULE_MAX
,
12722 rule
, nl80211_coalesce_policy
, NULL
);
12726 if (tb
[NL80211_ATTR_COALESCE_RULE_DELAY
])
12728 nla_get_u32(tb
[NL80211_ATTR_COALESCE_RULE_DELAY
]);
12729 if (new_rule
->delay
> coalesce
->max_delay
)
12732 if (tb
[NL80211_ATTR_COALESCE_RULE_CONDITION
])
12733 new_rule
->condition
=
12734 nla_get_u32(tb
[NL80211_ATTR_COALESCE_RULE_CONDITION
]);
12736 if (!tb
[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
])
12739 nla_for_each_nested(pat
, tb
[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
],
12742 if (n_patterns
> coalesce
->n_patterns
)
12745 new_rule
->patterns
= kcalloc(n_patterns
, sizeof(new_rule
->patterns
[0]),
12747 if (!new_rule
->patterns
)
12750 new_rule
->n_patterns
= n_patterns
;
12753 nla_for_each_nested(pat
, tb
[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
],
12757 err
= nla_parse_nested_deprecated(pat_tb
, MAX_NL80211_PKTPAT
,
12759 nl80211_packet_pattern_policy
,
12764 if (!pat_tb
[NL80211_PKTPAT_MASK
] ||
12765 !pat_tb
[NL80211_PKTPAT_PATTERN
])
12767 pat_len
= nla_len(pat_tb
[NL80211_PKTPAT_PATTERN
]);
12768 mask_len
= DIV_ROUND_UP(pat_len
, 8);
12769 if (nla_len(pat_tb
[NL80211_PKTPAT_MASK
]) != mask_len
)
12771 if (pat_len
> coalesce
->pattern_max_len
||
12772 pat_len
< coalesce
->pattern_min_len
)
12775 if (!pat_tb
[NL80211_PKTPAT_OFFSET
])
12778 pkt_offset
= nla_get_u32(pat_tb
[NL80211_PKTPAT_OFFSET
]);
12779 if (pkt_offset
> coalesce
->max_pkt_offset
)
12781 new_rule
->patterns
[i
].pkt_offset
= pkt_offset
;
12783 mask_pat
= kmalloc(mask_len
+ pat_len
, GFP_KERNEL
);
12787 new_rule
->patterns
[i
].mask
= mask_pat
;
12788 memcpy(mask_pat
, nla_data(pat_tb
[NL80211_PKTPAT_MASK
]),
12791 mask_pat
+= mask_len
;
12792 new_rule
->patterns
[i
].pattern
= mask_pat
;
12793 new_rule
->patterns
[i
].pattern_len
= pat_len
;
12794 memcpy(mask_pat
, nla_data(pat_tb
[NL80211_PKTPAT_PATTERN
]),
12802 static int nl80211_set_coalesce(struct sk_buff
*skb
, struct genl_info
*info
)
12804 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12805 const struct wiphy_coalesce_support
*coalesce
= rdev
->wiphy
.coalesce
;
12806 struct cfg80211_coalesce new_coalesce
= {};
12807 struct cfg80211_coalesce
*n_coalesce
;
12808 int err
, rem_rule
, n_rules
= 0, i
, j
;
12809 struct nlattr
*rule
;
12810 struct cfg80211_coalesce_rules
*tmp_rule
;
12812 if (!rdev
->wiphy
.coalesce
|| !rdev
->ops
->set_coalesce
)
12813 return -EOPNOTSUPP
;
12815 if (!info
->attrs
[NL80211_ATTR_COALESCE_RULE
]) {
12816 cfg80211_rdev_free_coalesce(rdev
);
12817 rdev_set_coalesce(rdev
, NULL
);
12821 nla_for_each_nested(rule
, info
->attrs
[NL80211_ATTR_COALESCE_RULE
],
12824 if (n_rules
> coalesce
->n_rules
)
12827 new_coalesce
.rules
= kcalloc(n_rules
, sizeof(new_coalesce
.rules
[0]),
12829 if (!new_coalesce
.rules
)
12832 new_coalesce
.n_rules
= n_rules
;
12835 nla_for_each_nested(rule
, info
->attrs
[NL80211_ATTR_COALESCE_RULE
],
12837 err
= nl80211_parse_coalesce_rule(rdev
, rule
,
12838 &new_coalesce
.rules
[i
]);
12845 err
= rdev_set_coalesce(rdev
, &new_coalesce
);
12849 n_coalesce
= kmemdup(&new_coalesce
, sizeof(new_coalesce
), GFP_KERNEL
);
12854 cfg80211_rdev_free_coalesce(rdev
);
12855 rdev
->coalesce
= n_coalesce
;
12859 for (i
= 0; i
< new_coalesce
.n_rules
; i
++) {
12860 tmp_rule
= &new_coalesce
.rules
[i
];
12861 for (j
= 0; j
< tmp_rule
->n_patterns
; j
++)
12862 kfree(tmp_rule
->patterns
[j
].mask
);
12863 kfree(tmp_rule
->patterns
);
12865 kfree(new_coalesce
.rules
);
12870 static int nl80211_set_rekey_data(struct sk_buff
*skb
, struct genl_info
*info
)
12872 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12873 struct net_device
*dev
= info
->user_ptr
[1];
12874 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
12875 struct nlattr
*tb
[NUM_NL80211_REKEY_DATA
];
12876 struct cfg80211_gtk_rekey_data rekey_data
= {};
12879 if (!info
->attrs
[NL80211_ATTR_REKEY_DATA
])
12882 err
= nla_parse_nested_deprecated(tb
, MAX_NL80211_REKEY_DATA
,
12883 info
->attrs
[NL80211_ATTR_REKEY_DATA
],
12884 nl80211_rekey_policy
, info
->extack
);
12888 if (!tb
[NL80211_REKEY_DATA_REPLAY_CTR
] || !tb
[NL80211_REKEY_DATA_KEK
] ||
12889 !tb
[NL80211_REKEY_DATA_KCK
])
12891 if (nla_len(tb
[NL80211_REKEY_DATA_KEK
]) != NL80211_KEK_LEN
&&
12892 !(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK
&&
12893 nla_len(tb
[NL80211_REKEY_DATA_KEK
]) == NL80211_KEK_EXT_LEN
))
12895 if (nla_len(tb
[NL80211_REKEY_DATA_KCK
]) != NL80211_KCK_LEN
&&
12896 !(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_EXT_KEK_KCK
&&
12897 nla_len(tb
[NL80211_REKEY_DATA_KEK
]) == NL80211_KCK_EXT_LEN
))
12900 rekey_data
.kek
= nla_data(tb
[NL80211_REKEY_DATA_KEK
]);
12901 rekey_data
.kck
= nla_data(tb
[NL80211_REKEY_DATA_KCK
]);
12902 rekey_data
.replay_ctr
= nla_data(tb
[NL80211_REKEY_DATA_REPLAY_CTR
]);
12903 rekey_data
.kek_len
= nla_len(tb
[NL80211_REKEY_DATA_KEK
]);
12904 rekey_data
.kck_len
= nla_len(tb
[NL80211_REKEY_DATA_KCK
]);
12905 if (tb
[NL80211_REKEY_DATA_AKM
])
12906 rekey_data
.akm
= nla_get_u32(tb
[NL80211_REKEY_DATA_AKM
]);
12909 if (!wdev
->current_bss
) {
12914 if (!rdev
->ops
->set_rekey_data
) {
12919 err
= rdev_set_rekey_data(rdev
, dev
, &rekey_data
);
12925 static int nl80211_register_unexpected_frame(struct sk_buff
*skb
,
12926 struct genl_info
*info
)
12928 struct net_device
*dev
= info
->user_ptr
[1];
12929 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
12931 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
12932 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
12935 if (wdev
->ap_unexpected_nlportid
)
12938 wdev
->ap_unexpected_nlportid
= info
->snd_portid
;
12942 static int nl80211_probe_client(struct sk_buff
*skb
,
12943 struct genl_info
*info
)
12945 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12946 struct net_device
*dev
= info
->user_ptr
[1];
12947 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
12948 struct sk_buff
*msg
;
12954 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
12955 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
12956 return -EOPNOTSUPP
;
12958 if (!info
->attrs
[NL80211_ATTR_MAC
])
12961 if (!rdev
->ops
->probe_client
)
12962 return -EOPNOTSUPP
;
12964 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
12968 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
12969 NL80211_CMD_PROBE_CLIENT
);
12975 addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
12977 err
= rdev_probe_client(rdev
, dev
, addr
, &cookie
);
12981 if (nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
12983 goto nla_put_failure
;
12985 genlmsg_end(msg
, hdr
);
12987 return genlmsg_reply(msg
, info
);
12996 static int nl80211_register_beacons(struct sk_buff
*skb
, struct genl_info
*info
)
12998 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
12999 struct cfg80211_beacon_registration
*reg
, *nreg
;
13002 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_REPORTS_OBSS
))
13003 return -EOPNOTSUPP
;
13005 nreg
= kzalloc(sizeof(*nreg
), GFP_KERNEL
);
13009 /* First, check if already registered. */
13010 spin_lock_bh(&rdev
->beacon_registrations_lock
);
13011 list_for_each_entry(reg
, &rdev
->beacon_registrations
, list
) {
13012 if (reg
->nlportid
== info
->snd_portid
) {
13017 /* Add it to the list */
13018 nreg
->nlportid
= info
->snd_portid
;
13019 list_add(&nreg
->list
, &rdev
->beacon_registrations
);
13021 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
13025 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
13030 static int nl80211_start_p2p_device(struct sk_buff
*skb
, struct genl_info
*info
)
13032 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13033 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13036 if (!rdev
->ops
->start_p2p_device
)
13037 return -EOPNOTSUPP
;
13039 if (wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
)
13040 return -EOPNOTSUPP
;
13042 if (wdev_running(wdev
))
13045 if (rfkill_blocked(rdev
->rfkill
))
13048 err
= rdev_start_p2p_device(rdev
, wdev
);
13052 wdev
->is_running
= true;
13058 static int nl80211_stop_p2p_device(struct sk_buff
*skb
, struct genl_info
*info
)
13060 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13061 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13063 if (wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
)
13064 return -EOPNOTSUPP
;
13066 if (!rdev
->ops
->stop_p2p_device
)
13067 return -EOPNOTSUPP
;
13069 cfg80211_stop_p2p_device(rdev
, wdev
);
13074 static int nl80211_start_nan(struct sk_buff
*skb
, struct genl_info
*info
)
13076 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13077 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13078 struct cfg80211_nan_conf conf
= {};
13081 if (wdev
->iftype
!= NL80211_IFTYPE_NAN
)
13082 return -EOPNOTSUPP
;
13084 if (wdev_running(wdev
))
13087 if (rfkill_blocked(rdev
->rfkill
))
13090 if (!info
->attrs
[NL80211_ATTR_NAN_MASTER_PREF
])
13094 nla_get_u8(info
->attrs
[NL80211_ATTR_NAN_MASTER_PREF
]);
13096 if (info
->attrs
[NL80211_ATTR_BANDS
]) {
13097 u32 bands
= nla_get_u32(info
->attrs
[NL80211_ATTR_BANDS
]);
13099 if (bands
& ~(u32
)wdev
->wiphy
->nan_supported_bands
)
13100 return -EOPNOTSUPP
;
13102 if (bands
&& !(bands
& BIT(NL80211_BAND_2GHZ
)))
13105 conf
.bands
= bands
;
13108 err
= rdev_start_nan(rdev
, wdev
, &conf
);
13112 wdev
->is_running
= true;
13118 static int nl80211_stop_nan(struct sk_buff
*skb
, struct genl_info
*info
)
13120 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13121 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13123 if (wdev
->iftype
!= NL80211_IFTYPE_NAN
)
13124 return -EOPNOTSUPP
;
13126 cfg80211_stop_nan(rdev
, wdev
);
13131 static int validate_nan_filter(struct nlattr
*filter_attr
)
13133 struct nlattr
*attr
;
13134 int len
= 0, n_entries
= 0, rem
;
13136 nla_for_each_nested(attr
, filter_attr
, rem
) {
13137 len
+= nla_len(attr
);
13147 static int handle_nan_filter(struct nlattr
*attr_filter
,
13148 struct cfg80211_nan_func
*func
,
13151 struct nlattr
*attr
;
13152 int n_entries
, rem
, i
;
13153 struct cfg80211_nan_func_filter
*filter
;
13155 n_entries
= validate_nan_filter(attr_filter
);
13159 BUILD_BUG_ON(sizeof(*func
->rx_filters
) != sizeof(*func
->tx_filters
));
13161 filter
= kcalloc(n_entries
, sizeof(*func
->rx_filters
), GFP_KERNEL
);
13166 nla_for_each_nested(attr
, attr_filter
, rem
) {
13167 filter
[i
].filter
= nla_memdup(attr
, GFP_KERNEL
);
13168 filter
[i
].len
= nla_len(attr
);
13172 func
->num_tx_filters
= n_entries
;
13173 func
->tx_filters
= filter
;
13175 func
->num_rx_filters
= n_entries
;
13176 func
->rx_filters
= filter
;
13182 static int nl80211_nan_add_func(struct sk_buff
*skb
,
13183 struct genl_info
*info
)
13185 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13186 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13187 struct nlattr
*tb
[NUM_NL80211_NAN_FUNC_ATTR
], *func_attr
;
13188 struct cfg80211_nan_func
*func
;
13189 struct sk_buff
*msg
= NULL
;
13193 if (wdev
->iftype
!= NL80211_IFTYPE_NAN
)
13194 return -EOPNOTSUPP
;
13196 if (!wdev_running(wdev
))
13199 if (!info
->attrs
[NL80211_ATTR_NAN_FUNC
])
13202 err
= nla_parse_nested_deprecated(tb
, NL80211_NAN_FUNC_ATTR_MAX
,
13203 info
->attrs
[NL80211_ATTR_NAN_FUNC
],
13204 nl80211_nan_func_policy
,
13209 func
= kzalloc(sizeof(*func
), GFP_KERNEL
);
13213 func
->cookie
= cfg80211_assign_cookie(rdev
);
13215 if (!tb
[NL80211_NAN_FUNC_TYPE
]) {
13221 func
->type
= nla_get_u8(tb
[NL80211_NAN_FUNC_TYPE
]);
13223 if (!tb
[NL80211_NAN_FUNC_SERVICE_ID
]) {
13228 memcpy(func
->service_id
, nla_data(tb
[NL80211_NAN_FUNC_SERVICE_ID
]),
13229 sizeof(func
->service_id
));
13231 func
->close_range
=
13232 nla_get_flag(tb
[NL80211_NAN_FUNC_CLOSE_RANGE
]);
13234 if (tb
[NL80211_NAN_FUNC_SERVICE_INFO
]) {
13235 func
->serv_spec_info_len
=
13236 nla_len(tb
[NL80211_NAN_FUNC_SERVICE_INFO
]);
13237 func
->serv_spec_info
=
13238 kmemdup(nla_data(tb
[NL80211_NAN_FUNC_SERVICE_INFO
]),
13239 func
->serv_spec_info_len
,
13241 if (!func
->serv_spec_info
) {
13247 if (tb
[NL80211_NAN_FUNC_TTL
])
13248 func
->ttl
= nla_get_u32(tb
[NL80211_NAN_FUNC_TTL
]);
13250 switch (func
->type
) {
13251 case NL80211_NAN_FUNC_PUBLISH
:
13252 if (!tb
[NL80211_NAN_FUNC_PUBLISH_TYPE
]) {
13257 func
->publish_type
=
13258 nla_get_u8(tb
[NL80211_NAN_FUNC_PUBLISH_TYPE
]);
13259 func
->publish_bcast
=
13260 nla_get_flag(tb
[NL80211_NAN_FUNC_PUBLISH_BCAST
]);
13262 if ((!(func
->publish_type
& NL80211_NAN_SOLICITED_PUBLISH
)) &&
13263 func
->publish_bcast
) {
13268 case NL80211_NAN_FUNC_SUBSCRIBE
:
13269 func
->subscribe_active
=
13270 nla_get_flag(tb
[NL80211_NAN_FUNC_SUBSCRIBE_ACTIVE
]);
13272 case NL80211_NAN_FUNC_FOLLOW_UP
:
13273 if (!tb
[NL80211_NAN_FUNC_FOLLOW_UP_ID
] ||
13274 !tb
[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID
] ||
13275 !tb
[NL80211_NAN_FUNC_FOLLOW_UP_DEST
]) {
13280 func
->followup_id
=
13281 nla_get_u8(tb
[NL80211_NAN_FUNC_FOLLOW_UP_ID
]);
13282 func
->followup_reqid
=
13283 nla_get_u8(tb
[NL80211_NAN_FUNC_FOLLOW_UP_REQ_ID
]);
13284 memcpy(func
->followup_dest
.addr
,
13285 nla_data(tb
[NL80211_NAN_FUNC_FOLLOW_UP_DEST
]),
13286 sizeof(func
->followup_dest
.addr
));
13297 if (tb
[NL80211_NAN_FUNC_SRF
]) {
13298 struct nlattr
*srf_tb
[NUM_NL80211_NAN_SRF_ATTR
];
13300 err
= nla_parse_nested_deprecated(srf_tb
,
13301 NL80211_NAN_SRF_ATTR_MAX
,
13302 tb
[NL80211_NAN_FUNC_SRF
],
13303 nl80211_nan_srf_policy
,
13308 func
->srf_include
=
13309 nla_get_flag(srf_tb
[NL80211_NAN_SRF_INCLUDE
]);
13311 if (srf_tb
[NL80211_NAN_SRF_BF
]) {
13312 if (srf_tb
[NL80211_NAN_SRF_MAC_ADDRS
] ||
13313 !srf_tb
[NL80211_NAN_SRF_BF_IDX
]) {
13319 nla_len(srf_tb
[NL80211_NAN_SRF_BF
]);
13321 kmemdup(nla_data(srf_tb
[NL80211_NAN_SRF_BF
]),
13322 func
->srf_bf_len
, GFP_KERNEL
);
13323 if (!func
->srf_bf
) {
13329 nla_get_u8(srf_tb
[NL80211_NAN_SRF_BF_IDX
]);
13331 struct nlattr
*attr
, *mac_attr
=
13332 srf_tb
[NL80211_NAN_SRF_MAC_ADDRS
];
13333 int n_entries
, rem
, i
= 0;
13340 n_entries
= validate_acl_mac_addrs(mac_attr
);
13341 if (n_entries
<= 0) {
13346 func
->srf_num_macs
= n_entries
;
13348 kcalloc(n_entries
, sizeof(*func
->srf_macs
),
13350 if (!func
->srf_macs
) {
13355 nla_for_each_nested(attr
, mac_attr
, rem
)
13356 memcpy(func
->srf_macs
[i
++].addr
, nla_data(attr
),
13357 sizeof(*func
->srf_macs
));
13361 if (tb
[NL80211_NAN_FUNC_TX_MATCH_FILTER
]) {
13362 err
= handle_nan_filter(tb
[NL80211_NAN_FUNC_TX_MATCH_FILTER
],
13368 if (tb
[NL80211_NAN_FUNC_RX_MATCH_FILTER
]) {
13369 err
= handle_nan_filter(tb
[NL80211_NAN_FUNC_RX_MATCH_FILTER
],
13375 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
13381 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
13382 NL80211_CMD_ADD_NAN_FUNCTION
);
13383 /* This can't really happen - we just allocated 4KB */
13384 if (WARN_ON(!hdr
)) {
13389 err
= rdev_add_nan_func(rdev
, wdev
, func
);
13392 cfg80211_free_nan_func(func
);
13397 /* propagate the instance id and cookie to userspace */
13398 if (nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, func
->cookie
,
13400 goto nla_put_failure
;
13402 func_attr
= nla_nest_start_noflag(msg
, NL80211_ATTR_NAN_FUNC
);
13404 goto nla_put_failure
;
13406 if (nla_put_u8(msg
, NL80211_NAN_FUNC_INSTANCE_ID
,
13407 func
->instance_id
))
13408 goto nla_put_failure
;
13410 nla_nest_end(msg
, func_attr
);
13412 genlmsg_end(msg
, hdr
);
13413 return genlmsg_reply(msg
, info
);
13420 static int nl80211_nan_del_func(struct sk_buff
*skb
,
13421 struct genl_info
*info
)
13423 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13424 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13427 if (wdev
->iftype
!= NL80211_IFTYPE_NAN
)
13428 return -EOPNOTSUPP
;
13430 if (!wdev_running(wdev
))
13433 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
13436 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
13438 rdev_del_nan_func(rdev
, wdev
, cookie
);
13443 static int nl80211_nan_change_config(struct sk_buff
*skb
,
13444 struct genl_info
*info
)
13446 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13447 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13448 struct cfg80211_nan_conf conf
= {};
13451 if (wdev
->iftype
!= NL80211_IFTYPE_NAN
)
13452 return -EOPNOTSUPP
;
13454 if (!wdev_running(wdev
))
13457 if (info
->attrs
[NL80211_ATTR_NAN_MASTER_PREF
]) {
13459 nla_get_u8(info
->attrs
[NL80211_ATTR_NAN_MASTER_PREF
]);
13460 if (conf
.master_pref
<= 1 || conf
.master_pref
== 255)
13463 changed
|= CFG80211_NAN_CONF_CHANGED_PREF
;
13466 if (info
->attrs
[NL80211_ATTR_BANDS
]) {
13467 u32 bands
= nla_get_u32(info
->attrs
[NL80211_ATTR_BANDS
]);
13469 if (bands
& ~(u32
)wdev
->wiphy
->nan_supported_bands
)
13470 return -EOPNOTSUPP
;
13472 if (bands
&& !(bands
& BIT(NL80211_BAND_2GHZ
)))
13475 conf
.bands
= bands
;
13476 changed
|= CFG80211_NAN_CONF_CHANGED_BANDS
;
13482 return rdev_nan_change_conf(rdev
, wdev
, &conf
, changed
);
13485 void cfg80211_nan_match(struct wireless_dev
*wdev
,
13486 struct cfg80211_nan_match_params
*match
, gfp_t gfp
)
13488 struct wiphy
*wiphy
= wdev
->wiphy
;
13489 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
13490 struct nlattr
*match_attr
, *local_func_attr
, *peer_func_attr
;
13491 struct sk_buff
*msg
;
13494 if (WARN_ON(!match
->inst_id
|| !match
->peer_inst_id
|| !match
->addr
))
13497 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
13501 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NAN_MATCH
);
13507 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
13508 (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
13509 wdev
->netdev
->ifindex
)) ||
13510 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
13512 goto nla_put_failure
;
13514 if (nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, match
->cookie
,
13515 NL80211_ATTR_PAD
) ||
13516 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, match
->addr
))
13517 goto nla_put_failure
;
13519 match_attr
= nla_nest_start_noflag(msg
, NL80211_ATTR_NAN_MATCH
);
13521 goto nla_put_failure
;
13523 local_func_attr
= nla_nest_start_noflag(msg
,
13524 NL80211_NAN_MATCH_FUNC_LOCAL
);
13525 if (!local_func_attr
)
13526 goto nla_put_failure
;
13528 if (nla_put_u8(msg
, NL80211_NAN_FUNC_INSTANCE_ID
, match
->inst_id
))
13529 goto nla_put_failure
;
13531 nla_nest_end(msg
, local_func_attr
);
13533 peer_func_attr
= nla_nest_start_noflag(msg
,
13534 NL80211_NAN_MATCH_FUNC_PEER
);
13535 if (!peer_func_attr
)
13536 goto nla_put_failure
;
13538 if (nla_put_u8(msg
, NL80211_NAN_FUNC_TYPE
, match
->type
) ||
13539 nla_put_u8(msg
, NL80211_NAN_FUNC_INSTANCE_ID
, match
->peer_inst_id
))
13540 goto nla_put_failure
;
13542 if (match
->info
&& match
->info_len
&&
13543 nla_put(msg
, NL80211_NAN_FUNC_SERVICE_INFO
, match
->info_len
,
13545 goto nla_put_failure
;
13547 nla_nest_end(msg
, peer_func_attr
);
13548 nla_nest_end(msg
, match_attr
);
13549 genlmsg_end(msg
, hdr
);
13551 if (!wdev
->owner_nlportid
)
13552 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
),
13553 msg
, 0, NL80211_MCGRP_NAN
, gfp
);
13555 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
,
13556 wdev
->owner_nlportid
);
13563 EXPORT_SYMBOL(cfg80211_nan_match
);
13565 void cfg80211_nan_func_terminated(struct wireless_dev
*wdev
,
13567 enum nl80211_nan_func_term_reason reason
,
13568 u64 cookie
, gfp_t gfp
)
13570 struct wiphy
*wiphy
= wdev
->wiphy
;
13571 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
13572 struct sk_buff
*msg
;
13573 struct nlattr
*func_attr
;
13576 if (WARN_ON(!inst_id
))
13579 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
13583 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_DEL_NAN_FUNCTION
);
13589 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
13590 (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
13591 wdev
->netdev
->ifindex
)) ||
13592 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
13594 goto nla_put_failure
;
13596 if (nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
13598 goto nla_put_failure
;
13600 func_attr
= nla_nest_start_noflag(msg
, NL80211_ATTR_NAN_FUNC
);
13602 goto nla_put_failure
;
13604 if (nla_put_u8(msg
, NL80211_NAN_FUNC_INSTANCE_ID
, inst_id
) ||
13605 nla_put_u8(msg
, NL80211_NAN_FUNC_TERM_REASON
, reason
))
13606 goto nla_put_failure
;
13608 nla_nest_end(msg
, func_attr
);
13609 genlmsg_end(msg
, hdr
);
13611 if (!wdev
->owner_nlportid
)
13612 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
),
13613 msg
, 0, NL80211_MCGRP_NAN
, gfp
);
13615 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
,
13616 wdev
->owner_nlportid
);
13623 EXPORT_SYMBOL(cfg80211_nan_func_terminated
);
13625 static int nl80211_get_protocol_features(struct sk_buff
*skb
,
13626 struct genl_info
*info
)
13629 struct sk_buff
*msg
;
13631 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
13635 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
13636 NL80211_CMD_GET_PROTOCOL_FEATURES
);
13638 goto nla_put_failure
;
13640 if (nla_put_u32(msg
, NL80211_ATTR_PROTOCOL_FEATURES
,
13641 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP
))
13642 goto nla_put_failure
;
13644 genlmsg_end(msg
, hdr
);
13645 return genlmsg_reply(msg
, info
);
13652 static int nl80211_update_ft_ies(struct sk_buff
*skb
, struct genl_info
*info
)
13654 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13655 struct cfg80211_update_ft_ies_params ft_params
;
13656 struct net_device
*dev
= info
->user_ptr
[1];
13658 if (!rdev
->ops
->update_ft_ies
)
13659 return -EOPNOTSUPP
;
13661 if (!info
->attrs
[NL80211_ATTR_MDID
] ||
13662 !info
->attrs
[NL80211_ATTR_IE
])
13665 memset(&ft_params
, 0, sizeof(ft_params
));
13666 ft_params
.md
= nla_get_u16(info
->attrs
[NL80211_ATTR_MDID
]);
13667 ft_params
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
13668 ft_params
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
13670 return rdev_update_ft_ies(rdev
, dev
, &ft_params
);
13673 static int nl80211_crit_protocol_start(struct sk_buff
*skb
,
13674 struct genl_info
*info
)
13676 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13677 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13678 enum nl80211_crit_proto_id proto
= NL80211_CRIT_PROTO_UNSPEC
;
13682 if (!rdev
->ops
->crit_proto_start
)
13683 return -EOPNOTSUPP
;
13685 if (WARN_ON(!rdev
->ops
->crit_proto_stop
))
13688 if (rdev
->crit_proto_nlportid
)
13691 /* determine protocol if provided */
13692 if (info
->attrs
[NL80211_ATTR_CRIT_PROT_ID
])
13693 proto
= nla_get_u16(info
->attrs
[NL80211_ATTR_CRIT_PROT_ID
]);
13695 if (proto
>= NUM_NL80211_CRIT_PROTO
)
13698 /* timeout must be provided */
13699 if (!info
->attrs
[NL80211_ATTR_MAX_CRIT_PROT_DURATION
])
13703 nla_get_u16(info
->attrs
[NL80211_ATTR_MAX_CRIT_PROT_DURATION
]);
13705 ret
= rdev_crit_proto_start(rdev
, wdev
, proto
, duration
);
13707 rdev
->crit_proto_nlportid
= info
->snd_portid
;
13712 static int nl80211_crit_protocol_stop(struct sk_buff
*skb
,
13713 struct genl_info
*info
)
13715 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13716 struct wireless_dev
*wdev
= info
->user_ptr
[1];
13718 if (!rdev
->ops
->crit_proto_stop
)
13719 return -EOPNOTSUPP
;
13721 if (rdev
->crit_proto_nlportid
) {
13722 rdev
->crit_proto_nlportid
= 0;
13723 rdev_crit_proto_stop(rdev
, wdev
);
13728 static int nl80211_vendor_check_policy(const struct wiphy_vendor_command
*vcmd
,
13729 struct nlattr
*attr
,
13730 struct netlink_ext_ack
*extack
)
13732 if (vcmd
->policy
== VENDOR_CMD_RAW_DATA
) {
13733 if (attr
->nla_type
& NLA_F_NESTED
) {
13734 NL_SET_ERR_MSG_ATTR(extack
, attr
,
13735 "unexpected nested data");
13742 if (!(attr
->nla_type
& NLA_F_NESTED
)) {
13743 NL_SET_ERR_MSG_ATTR(extack
, attr
, "expected nested data");
13747 return nla_validate_nested(attr
, vcmd
->maxattr
, vcmd
->policy
, extack
);
13750 static int nl80211_vendor_cmd(struct sk_buff
*skb
, struct genl_info
*info
)
13752 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
13753 struct wireless_dev
*wdev
=
13754 __cfg80211_wdev_from_attrs(rdev
, genl_info_net(info
),
13759 if (!rdev
->wiphy
.vendor_commands
)
13760 return -EOPNOTSUPP
;
13762 if (IS_ERR(wdev
)) {
13763 err
= PTR_ERR(wdev
);
13764 if (err
!= -EINVAL
)
13767 } else if (wdev
->wiphy
!= &rdev
->wiphy
) {
13771 if (!info
->attrs
[NL80211_ATTR_VENDOR_ID
] ||
13772 !info
->attrs
[NL80211_ATTR_VENDOR_SUBCMD
])
13775 vid
= nla_get_u32(info
->attrs
[NL80211_ATTR_VENDOR_ID
]);
13776 subcmd
= nla_get_u32(info
->attrs
[NL80211_ATTR_VENDOR_SUBCMD
]);
13777 for (i
= 0; i
< rdev
->wiphy
.n_vendor_commands
; i
++) {
13778 const struct wiphy_vendor_command
*vcmd
;
13782 vcmd
= &rdev
->wiphy
.vendor_commands
[i
];
13784 if (vcmd
->info
.vendor_id
!= vid
|| vcmd
->info
.subcmd
!= subcmd
)
13787 if (vcmd
->flags
& (WIPHY_VENDOR_CMD_NEED_WDEV
|
13788 WIPHY_VENDOR_CMD_NEED_NETDEV
)) {
13791 if (vcmd
->flags
& WIPHY_VENDOR_CMD_NEED_NETDEV
&&
13795 if (vcmd
->flags
& WIPHY_VENDOR_CMD_NEED_RUNNING
) {
13796 if (!wdev_running(wdev
))
13804 return -EOPNOTSUPP
;
13806 if (info
->attrs
[NL80211_ATTR_VENDOR_DATA
]) {
13807 data
= nla_data(info
->attrs
[NL80211_ATTR_VENDOR_DATA
]);
13808 len
= nla_len(info
->attrs
[NL80211_ATTR_VENDOR_DATA
]);
13810 err
= nl80211_vendor_check_policy(vcmd
,
13811 info
->attrs
[NL80211_ATTR_VENDOR_DATA
],
13817 rdev
->cur_cmd_info
= info
;
13818 err
= vcmd
->doit(&rdev
->wiphy
, wdev
, data
, len
);
13819 rdev
->cur_cmd_info
= NULL
;
13823 return -EOPNOTSUPP
;
13826 static int nl80211_prepare_vendor_dump(struct sk_buff
*skb
,
13827 struct netlink_callback
*cb
,
13828 struct cfg80211_registered_device
**rdev
,
13829 struct wireless_dev
**wdev
)
13831 struct nlattr
**attrbuf
;
13837 unsigned int data_len
= 0;
13840 /* subtract the 1 again here */
13841 struct wiphy
*wiphy
= wiphy_idx_to_wiphy(cb
->args
[0] - 1);
13842 struct wireless_dev
*tmp
;
13846 *rdev
= wiphy_to_rdev(wiphy
);
13850 list_for_each_entry(tmp
, &wiphy
->wdev_list
, list
) {
13851 if (tmp
->identifier
== cb
->args
[1] - 1) {
13858 /* keep rtnl locked in successful case */
13862 attrbuf
= kcalloc(NUM_NL80211_ATTR
, sizeof(*attrbuf
), GFP_KERNEL
);
13866 err
= nlmsg_parse_deprecated(cb
->nlh
,
13867 GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
13868 attrbuf
, nl80211_fam
.maxattr
,
13869 nl80211_policy
, NULL
);
13873 if (!attrbuf
[NL80211_ATTR_VENDOR_ID
] ||
13874 !attrbuf
[NL80211_ATTR_VENDOR_SUBCMD
]) {
13879 *wdev
= __cfg80211_wdev_from_attrs(NULL
, sock_net(skb
->sk
), attrbuf
);
13883 *rdev
= __cfg80211_rdev_from_attrs(sock_net(skb
->sk
), attrbuf
);
13884 if (IS_ERR(*rdev
)) {
13885 err
= PTR_ERR(*rdev
);
13889 vid
= nla_get_u32(attrbuf
[NL80211_ATTR_VENDOR_ID
]);
13890 subcmd
= nla_get_u32(attrbuf
[NL80211_ATTR_VENDOR_SUBCMD
]);
13892 for (i
= 0; i
< (*rdev
)->wiphy
.n_vendor_commands
; i
++) {
13893 const struct wiphy_vendor_command
*vcmd
;
13895 vcmd
= &(*rdev
)->wiphy
.vendor_commands
[i
];
13897 if (vcmd
->info
.vendor_id
!= vid
|| vcmd
->info
.subcmd
!= subcmd
)
13900 if (!vcmd
->dumpit
) {
13909 if (vcmd_idx
< 0) {
13914 if (attrbuf
[NL80211_ATTR_VENDOR_DATA
]) {
13915 data
= nla_data(attrbuf
[NL80211_ATTR_VENDOR_DATA
]);
13916 data_len
= nla_len(attrbuf
[NL80211_ATTR_VENDOR_DATA
]);
13918 err
= nl80211_vendor_check_policy(
13919 &(*rdev
)->wiphy
.vendor_commands
[vcmd_idx
],
13920 attrbuf
[NL80211_ATTR_VENDOR_DATA
],
13926 /* 0 is the first index - add 1 to parse only once */
13927 cb
->args
[0] = (*rdev
)->wiphy_idx
+ 1;
13928 /* add 1 to know if it was NULL */
13929 cb
->args
[1] = *wdev
? (*wdev
)->identifier
+ 1 : 0;
13930 cb
->args
[2] = vcmd_idx
;
13931 cb
->args
[3] = (unsigned long)data
;
13932 cb
->args
[4] = data_len
;
13934 /* keep rtnl locked in successful case */
13941 static int nl80211_vendor_cmd_dump(struct sk_buff
*skb
,
13942 struct netlink_callback
*cb
)
13944 struct cfg80211_registered_device
*rdev
;
13945 struct wireless_dev
*wdev
;
13946 unsigned int vcmd_idx
;
13947 const struct wiphy_vendor_command
*vcmd
;
13951 struct nlattr
*vendor_data
;
13954 err
= nl80211_prepare_vendor_dump(skb
, cb
, &rdev
, &wdev
);
13958 vcmd_idx
= cb
->args
[2];
13959 data
= (void *)cb
->args
[3];
13960 data_len
= cb
->args
[4];
13961 vcmd
= &rdev
->wiphy
.vendor_commands
[vcmd_idx
];
13963 if (vcmd
->flags
& (WIPHY_VENDOR_CMD_NEED_WDEV
|
13964 WIPHY_VENDOR_CMD_NEED_NETDEV
)) {
13969 if (vcmd
->flags
& WIPHY_VENDOR_CMD_NEED_NETDEV
&&
13975 if (vcmd
->flags
& WIPHY_VENDOR_CMD_NEED_RUNNING
) {
13976 if (!wdev_running(wdev
)) {
13984 void *hdr
= nl80211hdr_put(skb
, NETLINK_CB(cb
->skb
).portid
,
13985 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
13986 NL80211_CMD_VENDOR
);
13990 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
13991 (wdev
&& nla_put_u64_64bit(skb
, NL80211_ATTR_WDEV
,
13993 NL80211_ATTR_PAD
))) {
13994 genlmsg_cancel(skb
, hdr
);
13998 vendor_data
= nla_nest_start_noflag(skb
,
13999 NL80211_ATTR_VENDOR_DATA
);
14000 if (!vendor_data
) {
14001 genlmsg_cancel(skb
, hdr
);
14005 err
= vcmd
->dumpit(&rdev
->wiphy
, wdev
, skb
, data
, data_len
,
14006 (unsigned long *)&cb
->args
[5]);
14007 nla_nest_end(skb
, vendor_data
);
14009 if (err
== -ENOBUFS
|| err
== -ENOENT
) {
14010 genlmsg_cancel(skb
, hdr
);
14012 } else if (err
<= 0) {
14013 genlmsg_cancel(skb
, hdr
);
14017 genlmsg_end(skb
, hdr
);
14026 struct sk_buff
*__cfg80211_alloc_reply_skb(struct wiphy
*wiphy
,
14027 enum nl80211_commands cmd
,
14028 enum nl80211_attrs attr
,
14031 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
14033 if (WARN_ON(!rdev
->cur_cmd_info
))
14036 return __cfg80211_alloc_vendor_skb(rdev
, NULL
, approxlen
,
14037 rdev
->cur_cmd_info
->snd_portid
,
14038 rdev
->cur_cmd_info
->snd_seq
,
14039 cmd
, attr
, NULL
, GFP_KERNEL
);
14041 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb
);
14043 int cfg80211_vendor_cmd_reply(struct sk_buff
*skb
)
14045 struct cfg80211_registered_device
*rdev
= ((void **)skb
->cb
)[0];
14046 void *hdr
= ((void **)skb
->cb
)[1];
14047 struct nlattr
*data
= ((void **)skb
->cb
)[2];
14049 /* clear CB data for netlink core to own from now on */
14050 memset(skb
->cb
, 0, sizeof(skb
->cb
));
14052 if (WARN_ON(!rdev
->cur_cmd_info
)) {
14057 nla_nest_end(skb
, data
);
14058 genlmsg_end(skb
, hdr
);
14059 return genlmsg_reply(skb
, rdev
->cur_cmd_info
);
14061 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply
);
14063 unsigned int cfg80211_vendor_cmd_get_sender(struct wiphy
*wiphy
)
14065 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
14067 if (WARN_ON(!rdev
->cur_cmd_info
))
14070 return rdev
->cur_cmd_info
->snd_portid
;
14072 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_get_sender
);
14074 static int nl80211_set_qos_map(struct sk_buff
*skb
,
14075 struct genl_info
*info
)
14077 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14078 struct cfg80211_qos_map
*qos_map
= NULL
;
14079 struct net_device
*dev
= info
->user_ptr
[1];
14080 u8
*pos
, len
, num_des
, des_len
, des
;
14083 if (!rdev
->ops
->set_qos_map
)
14084 return -EOPNOTSUPP
;
14086 if (info
->attrs
[NL80211_ATTR_QOS_MAP
]) {
14087 pos
= nla_data(info
->attrs
[NL80211_ATTR_QOS_MAP
]);
14088 len
= nla_len(info
->attrs
[NL80211_ATTR_QOS_MAP
]);
14093 qos_map
= kzalloc(sizeof(struct cfg80211_qos_map
), GFP_KERNEL
);
14097 num_des
= (len
- IEEE80211_QOS_MAP_LEN_MIN
) >> 1;
14099 des_len
= num_des
*
14100 sizeof(struct cfg80211_dscp_exception
);
14101 memcpy(qos_map
->dscp_exception
, pos
, des_len
);
14102 qos_map
->num_des
= num_des
;
14103 for (des
= 0; des
< num_des
; des
++) {
14104 if (qos_map
->dscp_exception
[des
].up
> 7) {
14111 memcpy(qos_map
->up
, pos
, IEEE80211_QOS_MAP_LEN_MIN
);
14114 wdev_lock(dev
->ieee80211_ptr
);
14115 ret
= nl80211_key_allowed(dev
->ieee80211_ptr
);
14117 ret
= rdev_set_qos_map(rdev
, dev
, qos_map
);
14118 wdev_unlock(dev
->ieee80211_ptr
);
14124 static int nl80211_add_tx_ts(struct sk_buff
*skb
, struct genl_info
*info
)
14126 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14127 struct net_device
*dev
= info
->user_ptr
[1];
14128 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14131 u16 admitted_time
= 0;
14134 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_SUPPORTS_WMM_ADMISSION
))
14135 return -EOPNOTSUPP
;
14137 if (!info
->attrs
[NL80211_ATTR_TSID
] || !info
->attrs
[NL80211_ATTR_MAC
] ||
14138 !info
->attrs
[NL80211_ATTR_USER_PRIO
])
14141 tsid
= nla_get_u8(info
->attrs
[NL80211_ATTR_TSID
]);
14142 up
= nla_get_u8(info
->attrs
[NL80211_ATTR_USER_PRIO
]);
14144 /* WMM uses TIDs 0-7 even for TSPEC */
14145 if (tsid
>= IEEE80211_FIRST_TSPEC_TSID
) {
14146 /* TODO: handle 802.11 TSPEC/admission control
14147 * need more attributes for that (e.g. BA session requirement);
14148 * change the WMM adminssion test above to allow both then
14153 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14155 if (info
->attrs
[NL80211_ATTR_ADMITTED_TIME
]) {
14157 nla_get_u16(info
->attrs
[NL80211_ATTR_ADMITTED_TIME
]);
14158 if (!admitted_time
)
14163 switch (wdev
->iftype
) {
14164 case NL80211_IFTYPE_STATION
:
14165 case NL80211_IFTYPE_P2P_CLIENT
:
14166 if (wdev
->current_bss
)
14175 err
= rdev_add_tx_ts(rdev
, dev
, tsid
, peer
, up
, admitted_time
);
14182 static int nl80211_del_tx_ts(struct sk_buff
*skb
, struct genl_info
*info
)
14184 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14185 struct net_device
*dev
= info
->user_ptr
[1];
14186 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14191 if (!info
->attrs
[NL80211_ATTR_TSID
] || !info
->attrs
[NL80211_ATTR_MAC
])
14194 tsid
= nla_get_u8(info
->attrs
[NL80211_ATTR_TSID
]);
14195 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14198 err
= rdev_del_tx_ts(rdev
, dev
, tsid
, peer
);
14204 static int nl80211_tdls_channel_switch(struct sk_buff
*skb
,
14205 struct genl_info
*info
)
14207 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14208 struct net_device
*dev
= info
->user_ptr
[1];
14209 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14210 struct cfg80211_chan_def chandef
= {};
14215 if (!rdev
->ops
->tdls_channel_switch
||
14216 !(rdev
->wiphy
.features
& NL80211_FEATURE_TDLS_CHANNEL_SWITCH
))
14217 return -EOPNOTSUPP
;
14219 switch (dev
->ieee80211_ptr
->iftype
) {
14220 case NL80211_IFTYPE_STATION
:
14221 case NL80211_IFTYPE_P2P_CLIENT
:
14224 return -EOPNOTSUPP
;
14227 if (!info
->attrs
[NL80211_ATTR_MAC
] ||
14228 !info
->attrs
[NL80211_ATTR_OPER_CLASS
])
14231 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
14236 * Don't allow wide channels on the 2.4Ghz band, as per IEEE802.11-2012
14237 * section 10.22.6.2.1. Disallow 5/10Mhz channels as well for now, the
14238 * specification is not defined for them.
14240 if (chandef
.chan
->band
== NL80211_BAND_2GHZ
&&
14241 chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
&&
14242 chandef
.width
!= NL80211_CHAN_WIDTH_20
)
14245 /* we will be active on the TDLS link */
14246 if (!cfg80211_reg_can_beacon_relax(&rdev
->wiphy
, &chandef
,
14250 /* don't allow switching to DFS channels */
14251 if (cfg80211_chandef_dfs_required(wdev
->wiphy
, &chandef
, wdev
->iftype
))
14254 addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14255 oper_class
= nla_get_u8(info
->attrs
[NL80211_ATTR_OPER_CLASS
]);
14258 err
= rdev_tdls_channel_switch(rdev
, dev
, addr
, oper_class
, &chandef
);
14264 static int nl80211_tdls_cancel_channel_switch(struct sk_buff
*skb
,
14265 struct genl_info
*info
)
14267 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14268 struct net_device
*dev
= info
->user_ptr
[1];
14269 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14272 if (!rdev
->ops
->tdls_channel_switch
||
14273 !rdev
->ops
->tdls_cancel_channel_switch
||
14274 !(rdev
->wiphy
.features
& NL80211_FEATURE_TDLS_CHANNEL_SWITCH
))
14275 return -EOPNOTSUPP
;
14277 switch (dev
->ieee80211_ptr
->iftype
) {
14278 case NL80211_IFTYPE_STATION
:
14279 case NL80211_IFTYPE_P2P_CLIENT
:
14282 return -EOPNOTSUPP
;
14285 if (!info
->attrs
[NL80211_ATTR_MAC
])
14288 addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14291 rdev_tdls_cancel_channel_switch(rdev
, dev
, addr
);
14297 static int nl80211_set_multicast_to_unicast(struct sk_buff
*skb
,
14298 struct genl_info
*info
)
14300 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14301 struct net_device
*dev
= info
->user_ptr
[1];
14302 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14303 const struct nlattr
*nla
;
14306 if (!rdev
->ops
->set_multicast_to_unicast
)
14307 return -EOPNOTSUPP
;
14309 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
14310 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
14311 return -EOPNOTSUPP
;
14313 nla
= info
->attrs
[NL80211_ATTR_MULTICAST_TO_UNICAST_ENABLED
];
14314 enabled
= nla_get_flag(nla
);
14316 return rdev_set_multicast_to_unicast(rdev
, dev
, enabled
);
14319 static int nl80211_set_pmk(struct sk_buff
*skb
, struct genl_info
*info
)
14321 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14322 struct net_device
*dev
= info
->user_ptr
[1];
14323 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14324 struct cfg80211_pmk_conf pmk_conf
= {};
14327 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
14328 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
14329 return -EOPNOTSUPP
;
14331 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
14332 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X
))
14333 return -EOPNOTSUPP
;
14335 if (!info
->attrs
[NL80211_ATTR_MAC
] || !info
->attrs
[NL80211_ATTR_PMK
])
14339 if (!wdev
->current_bss
) {
14344 pmk_conf
.aa
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14345 if (memcmp(pmk_conf
.aa
, wdev
->current_bss
->pub
.bssid
, ETH_ALEN
)) {
14350 pmk_conf
.pmk
= nla_data(info
->attrs
[NL80211_ATTR_PMK
]);
14351 pmk_conf
.pmk_len
= nla_len(info
->attrs
[NL80211_ATTR_PMK
]);
14352 if (pmk_conf
.pmk_len
!= WLAN_PMK_LEN
&&
14353 pmk_conf
.pmk_len
!= WLAN_PMK_LEN_SUITE_B_192
) {
14358 if (info
->attrs
[NL80211_ATTR_PMKR0_NAME
])
14359 pmk_conf
.pmk_r0_name
=
14360 nla_data(info
->attrs
[NL80211_ATTR_PMKR0_NAME
]);
14362 ret
= rdev_set_pmk(rdev
, dev
, &pmk_conf
);
14368 static int nl80211_del_pmk(struct sk_buff
*skb
, struct genl_info
*info
)
14370 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14371 struct net_device
*dev
= info
->user_ptr
[1];
14372 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14376 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
14377 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
14378 return -EOPNOTSUPP
;
14380 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
14381 NL80211_EXT_FEATURE_4WAY_HANDSHAKE_STA_1X
))
14382 return -EOPNOTSUPP
;
14384 if (!info
->attrs
[NL80211_ATTR_MAC
])
14388 aa
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14389 ret
= rdev_del_pmk(rdev
, dev
, aa
);
14395 static int nl80211_external_auth(struct sk_buff
*skb
, struct genl_info
*info
)
14397 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14398 struct net_device
*dev
= info
->user_ptr
[1];
14399 struct cfg80211_external_auth_params params
;
14401 if (!rdev
->ops
->external_auth
)
14402 return -EOPNOTSUPP
;
14404 if (!info
->attrs
[NL80211_ATTR_SSID
] &&
14405 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
14406 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
14409 if (!info
->attrs
[NL80211_ATTR_BSSID
])
14412 if (!info
->attrs
[NL80211_ATTR_STATUS_CODE
])
14415 memset(¶ms
, 0, sizeof(params
));
14417 if (info
->attrs
[NL80211_ATTR_SSID
]) {
14418 params
.ssid
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
14419 if (params
.ssid
.ssid_len
== 0)
14421 memcpy(params
.ssid
.ssid
,
14422 nla_data(info
->attrs
[NL80211_ATTR_SSID
]),
14423 params
.ssid
.ssid_len
);
14426 memcpy(params
.bssid
, nla_data(info
->attrs
[NL80211_ATTR_BSSID
]),
14429 params
.status
= nla_get_u16(info
->attrs
[NL80211_ATTR_STATUS_CODE
]);
14431 if (info
->attrs
[NL80211_ATTR_PMKID
])
14432 params
.pmkid
= nla_data(info
->attrs
[NL80211_ATTR_PMKID
]);
14434 return rdev_external_auth(rdev
, dev
, ¶ms
);
14437 static int nl80211_tx_control_port(struct sk_buff
*skb
, struct genl_info
*info
)
14439 bool dont_wait_for_ack
= info
->attrs
[NL80211_ATTR_DONT_WAIT_FOR_ACK
];
14440 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14441 struct net_device
*dev
= info
->user_ptr
[1];
14442 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14451 if (!wiphy_ext_feature_isset(&rdev
->wiphy
,
14452 NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211
))
14453 return -EOPNOTSUPP
;
14455 if (!rdev
->ops
->tx_control_port
)
14456 return -EOPNOTSUPP
;
14458 if (!info
->attrs
[NL80211_ATTR_FRAME
] ||
14459 !info
->attrs
[NL80211_ATTR_MAC
] ||
14460 !info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]) {
14461 GENL_SET_ERR_MSG(info
, "Frame, MAC or ethertype missing");
14467 switch (wdev
->iftype
) {
14468 case NL80211_IFTYPE_AP
:
14469 case NL80211_IFTYPE_P2P_GO
:
14470 case NL80211_IFTYPE_MESH_POINT
:
14472 case NL80211_IFTYPE_ADHOC
:
14473 case NL80211_IFTYPE_STATION
:
14474 case NL80211_IFTYPE_P2P_CLIENT
:
14475 if (wdev
->current_bss
)
14486 buf
= nla_data(info
->attrs
[NL80211_ATTR_FRAME
]);
14487 len
= nla_len(info
->attrs
[NL80211_ATTR_FRAME
]);
14488 dest
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14489 proto
= nla_get_u16(info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]);
14491 nla_get_flag(info
->attrs
[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
]);
14493 err
= rdev_tx_control_port(rdev
, dev
, buf
, len
,
14494 dest
, cpu_to_be16(proto
), noencrypt
,
14495 dont_wait_for_ack
? NULL
: &cookie
);
14496 if (!err
&& !dont_wait_for_ack
)
14497 nl_set_extack_cookie_u64(info
->extack
, cookie
);
14504 static int nl80211_get_ftm_responder_stats(struct sk_buff
*skb
,
14505 struct genl_info
*info
)
14507 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14508 struct net_device
*dev
= info
->user_ptr
[1];
14509 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14510 struct cfg80211_ftm_responder_stats ftm_stats
= {};
14511 struct sk_buff
*msg
;
14513 struct nlattr
*ftm_stats_attr
;
14516 if (wdev
->iftype
!= NL80211_IFTYPE_AP
|| !wdev
->beacon_interval
)
14517 return -EOPNOTSUPP
;
14519 err
= rdev_get_ftm_responder_stats(rdev
, dev
, &ftm_stats
);
14523 if (!ftm_stats
.filled
)
14526 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
14530 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
14531 NL80211_CMD_GET_FTM_RESPONDER_STATS
);
14533 goto nla_put_failure
;
14535 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
14536 goto nla_put_failure
;
14538 ftm_stats_attr
= nla_nest_start_noflag(msg
,
14539 NL80211_ATTR_FTM_RESPONDER_STATS
);
14540 if (!ftm_stats_attr
)
14541 goto nla_put_failure
;
14543 #define SET_FTM(field, name, type) \
14544 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
14545 nla_put_ ## type(msg, NL80211_FTM_STATS_ ## name, \
14546 ftm_stats.field)) \
14547 goto nla_put_failure; } while (0)
14548 #define SET_FTM_U64(field, name) \
14549 do { if ((ftm_stats.filled & BIT(NL80211_FTM_STATS_ ## name)) && \
14550 nla_put_u64_64bit(msg, NL80211_FTM_STATS_ ## name, \
14551 ftm_stats.field, NL80211_FTM_STATS_PAD)) \
14552 goto nla_put_failure; } while (0)
14554 SET_FTM(success_num
, SUCCESS_NUM
, u32
);
14555 SET_FTM(partial_num
, PARTIAL_NUM
, u32
);
14556 SET_FTM(failed_num
, FAILED_NUM
, u32
);
14557 SET_FTM(asap_num
, ASAP_NUM
, u32
);
14558 SET_FTM(non_asap_num
, NON_ASAP_NUM
, u32
);
14559 SET_FTM_U64(total_duration_ms
, TOTAL_DURATION_MSEC
);
14560 SET_FTM(unknown_triggers_num
, UNKNOWN_TRIGGERS_NUM
, u32
);
14561 SET_FTM(reschedule_requests_num
, RESCHEDULE_REQUESTS_NUM
, u32
);
14562 SET_FTM(out_of_window_triggers_num
, OUT_OF_WINDOW_TRIGGERS_NUM
, u32
);
14565 nla_nest_end(msg
, ftm_stats_attr
);
14567 genlmsg_end(msg
, hdr
);
14568 return genlmsg_reply(msg
, info
);
14575 static int nl80211_update_owe_info(struct sk_buff
*skb
, struct genl_info
*info
)
14577 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14578 struct cfg80211_update_owe_info owe_info
;
14579 struct net_device
*dev
= info
->user_ptr
[1];
14581 if (!rdev
->ops
->update_owe_info
)
14582 return -EOPNOTSUPP
;
14584 if (!info
->attrs
[NL80211_ATTR_STATUS_CODE
] ||
14585 !info
->attrs
[NL80211_ATTR_MAC
])
14588 memset(&owe_info
, 0, sizeof(owe_info
));
14589 owe_info
.status
= nla_get_u16(info
->attrs
[NL80211_ATTR_STATUS_CODE
]);
14590 nla_memcpy(owe_info
.peer
, info
->attrs
[NL80211_ATTR_MAC
], ETH_ALEN
);
14592 if (info
->attrs
[NL80211_ATTR_IE
]) {
14593 owe_info
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
14594 owe_info
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
14597 return rdev_update_owe_info(rdev
, dev
, &owe_info
);
14600 static int nl80211_probe_mesh_link(struct sk_buff
*skb
, struct genl_info
*info
)
14602 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14603 struct net_device
*dev
= info
->user_ptr
[1];
14604 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
14605 struct station_info sinfo
= {};
14611 if (!rdev
->ops
->probe_mesh_link
|| !rdev
->ops
->get_station
)
14612 return -EOPNOTSUPP
;
14614 if (!info
->attrs
[NL80211_ATTR_MAC
] ||
14615 !info
->attrs
[NL80211_ATTR_FRAME
]) {
14616 GENL_SET_ERR_MSG(info
, "Frame or MAC missing");
14620 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
14621 return -EOPNOTSUPP
;
14623 dest
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14624 buf
= nla_data(info
->attrs
[NL80211_ATTR_FRAME
]);
14625 len
= nla_len(info
->attrs
[NL80211_ATTR_FRAME
]);
14627 if (len
< sizeof(struct ethhdr
))
14630 if (!ether_addr_equal(buf
, dest
) || is_multicast_ether_addr(buf
) ||
14631 !ether_addr_equal(buf
+ ETH_ALEN
, dev
->dev_addr
))
14634 err
= rdev_get_station(rdev
, dev
, dest
, &sinfo
);
14638 cfg80211_sinfo_release_content(&sinfo
);
14640 return rdev_probe_mesh_link(rdev
, dev
, dest
, buf
, len
);
14643 static int parse_tid_conf(struct cfg80211_registered_device
*rdev
,
14644 struct nlattr
*attrs
[], struct net_device
*dev
,
14645 struct cfg80211_tid_cfg
*tid_conf
,
14646 struct genl_info
*info
, const u8
*peer
)
14648 struct netlink_ext_ack
*extack
= info
->extack
;
14652 if (!attrs
[NL80211_TID_CONFIG_ATTR_TIDS
])
14655 tid_conf
->config_override
=
14656 nla_get_flag(attrs
[NL80211_TID_CONFIG_ATTR_OVERRIDE
]);
14657 tid_conf
->tids
= nla_get_u16(attrs
[NL80211_TID_CONFIG_ATTR_TIDS
]);
14659 if (tid_conf
->config_override
) {
14660 if (rdev
->ops
->reset_tid_config
) {
14661 err
= rdev_reset_tid_config(rdev
, dev
, peer
,
14670 if (attrs
[NL80211_TID_CONFIG_ATTR_NOACK
]) {
14671 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_NOACK
);
14673 nla_get_u8(attrs
[NL80211_TID_CONFIG_ATTR_NOACK
]);
14676 if (attrs
[NL80211_TID_CONFIG_ATTR_RETRY_SHORT
]) {
14677 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT
);
14678 tid_conf
->retry_short
=
14679 nla_get_u8(attrs
[NL80211_TID_CONFIG_ATTR_RETRY_SHORT
]);
14681 if (tid_conf
->retry_short
> rdev
->wiphy
.max_data_retry_count
)
14685 if (attrs
[NL80211_TID_CONFIG_ATTR_RETRY_LONG
]) {
14686 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG
);
14687 tid_conf
->retry_long
=
14688 nla_get_u8(attrs
[NL80211_TID_CONFIG_ATTR_RETRY_LONG
]);
14690 if (tid_conf
->retry_long
> rdev
->wiphy
.max_data_retry_count
)
14694 if (attrs
[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL
]) {
14695 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL
);
14697 nla_get_u8(attrs
[NL80211_TID_CONFIG_ATTR_AMPDU_CTRL
]);
14700 if (attrs
[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL
]) {
14701 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL
);
14703 nla_get_u8(attrs
[NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL
]);
14706 if (attrs
[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL
]) {
14707 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_AMSDU_CTRL
);
14709 nla_get_u8(attrs
[NL80211_TID_CONFIG_ATTR_AMSDU_CTRL
]);
14712 if (attrs
[NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE
]) {
14713 u32 idx
= NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE
, attr
;
14715 tid_conf
->txrate_type
= nla_get_u8(attrs
[idx
]);
14717 if (tid_conf
->txrate_type
!= NL80211_TX_RATE_AUTOMATIC
) {
14718 attr
= NL80211_TID_CONFIG_ATTR_TX_RATE
;
14719 err
= nl80211_parse_tx_bitrate_mask(info
, attrs
, attr
,
14720 &tid_conf
->txrate_mask
, dev
,
14725 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE
);
14727 tid_conf
->mask
|= BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE
);
14731 mask
= rdev
->wiphy
.tid_config_support
.peer
;
14733 mask
= rdev
->wiphy
.tid_config_support
.vif
;
14735 if (tid_conf
->mask
& ~mask
) {
14736 NL_SET_ERR_MSG(extack
, "unsupported TID configuration");
14743 static int nl80211_set_tid_config(struct sk_buff
*skb
,
14744 struct genl_info
*info
)
14746 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14747 struct nlattr
*attrs
[NL80211_TID_CONFIG_ATTR_MAX
+ 1];
14748 struct net_device
*dev
= info
->user_ptr
[1];
14749 struct cfg80211_tid_config
*tid_config
;
14750 struct nlattr
*tid
;
14751 int conf_idx
= 0, rem_conf
;
14755 if (!info
->attrs
[NL80211_ATTR_TID_CONFIG
])
14758 if (!rdev
->ops
->set_tid_config
)
14759 return -EOPNOTSUPP
;
14761 nla_for_each_nested(tid
, info
->attrs
[NL80211_ATTR_TID_CONFIG
],
14765 tid_config
= kzalloc(struct_size(tid_config
, tid_conf
, num_conf
),
14770 tid_config
->n_tid_conf
= num_conf
;
14772 if (info
->attrs
[NL80211_ATTR_MAC
])
14773 tid_config
->peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
14775 nla_for_each_nested(tid
, info
->attrs
[NL80211_ATTR_TID_CONFIG
],
14777 ret
= nla_parse_nested(attrs
, NL80211_TID_CONFIG_ATTR_MAX
,
14783 ret
= parse_tid_conf(rdev
, attrs
, dev
,
14784 &tid_config
->tid_conf
[conf_idx
],
14785 info
, tid_config
->peer
);
14792 ret
= rdev_set_tid_config(rdev
, dev
, tid_config
);
14799 #define NL80211_FLAG_NEED_WIPHY 0x01
14800 #define NL80211_FLAG_NEED_NETDEV 0x02
14801 #define NL80211_FLAG_NEED_RTNL 0x04
14802 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
14803 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
14804 NL80211_FLAG_CHECK_NETDEV_UP)
14805 #define NL80211_FLAG_NEED_WDEV 0x10
14806 /* If a netdev is associated, it must be UP, P2P must be started */
14807 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
14808 NL80211_FLAG_CHECK_NETDEV_UP)
14809 #define NL80211_FLAG_CLEAR_SKB 0x20
14810 #define NL80211_FLAG_NO_WIPHY_MTX 0x40
14812 static int nl80211_pre_doit(const struct genl_ops
*ops
, struct sk_buff
*skb
,
14813 struct genl_info
*info
)
14815 struct cfg80211_registered_device
*rdev
= NULL
;
14816 struct wireless_dev
*wdev
;
14817 struct net_device
*dev
;
14820 if (ops
->internal_flags
& NL80211_FLAG_NEED_WIPHY
) {
14821 rdev
= cfg80211_get_dev_from_info(genl_info_net(info
), info
);
14822 if (IS_ERR(rdev
)) {
14824 return PTR_ERR(rdev
);
14826 info
->user_ptr
[0] = rdev
;
14827 } else if (ops
->internal_flags
& NL80211_FLAG_NEED_NETDEV
||
14828 ops
->internal_flags
& NL80211_FLAG_NEED_WDEV
) {
14829 wdev
= __cfg80211_wdev_from_attrs(NULL
, genl_info_net(info
),
14831 if (IS_ERR(wdev
)) {
14833 return PTR_ERR(wdev
);
14836 dev
= wdev
->netdev
;
14837 rdev
= wiphy_to_rdev(wdev
->wiphy
);
14839 if (ops
->internal_flags
& NL80211_FLAG_NEED_NETDEV
) {
14845 info
->user_ptr
[1] = dev
;
14847 info
->user_ptr
[1] = wdev
;
14850 if (ops
->internal_flags
& NL80211_FLAG_CHECK_NETDEV_UP
&&
14851 !wdev_running(wdev
)) {
14859 info
->user_ptr
[0] = rdev
;
14862 if (rdev
&& !(ops
->internal_flags
& NL80211_FLAG_NO_WIPHY_MTX
)) {
14863 wiphy_lock(&rdev
->wiphy
);
14864 /* we keep the mutex locked until post_doit */
14865 __release(&rdev
->wiphy
.mtx
);
14867 if (!(ops
->internal_flags
& NL80211_FLAG_NEED_RTNL
))
14873 static void nl80211_post_doit(const struct genl_ops
*ops
, struct sk_buff
*skb
,
14874 struct genl_info
*info
)
14876 if (info
->user_ptr
[1]) {
14877 if (ops
->internal_flags
& NL80211_FLAG_NEED_WDEV
) {
14878 struct wireless_dev
*wdev
= info
->user_ptr
[1];
14881 dev_put(wdev
->netdev
);
14883 dev_put(info
->user_ptr
[1]);
14887 if (info
->user_ptr
[0] &&
14888 !(ops
->internal_flags
& NL80211_FLAG_NO_WIPHY_MTX
)) {
14889 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14891 /* we kept the mutex locked since pre_doit */
14892 __acquire(&rdev
->wiphy
.mtx
);
14893 wiphy_unlock(&rdev
->wiphy
);
14896 if (ops
->internal_flags
& NL80211_FLAG_NEED_RTNL
)
14899 /* If needed, clear the netlink message payload from the SKB
14900 * as it might contain key data that shouldn't stick around on
14901 * the heap after the SKB is freed. The netlink message header
14902 * is still needed for further processing, so leave it intact.
14904 if (ops
->internal_flags
& NL80211_FLAG_CLEAR_SKB
) {
14905 struct nlmsghdr
*nlh
= nlmsg_hdr(skb
);
14907 memset(nlmsg_data(nlh
), 0, nlmsg_len(nlh
));
14911 static int nl80211_set_sar_sub_specs(struct cfg80211_registered_device
*rdev
,
14912 struct cfg80211_sar_specs
*sar_specs
,
14913 struct nlattr
*spec
[], int index
)
14915 u32 range_index
, i
;
14917 if (!sar_specs
|| !spec
)
14920 if (!spec
[NL80211_SAR_ATTR_SPECS_POWER
] ||
14921 !spec
[NL80211_SAR_ATTR_SPECS_RANGE_INDEX
])
14924 range_index
= nla_get_u32(spec
[NL80211_SAR_ATTR_SPECS_RANGE_INDEX
]);
14926 /* check if range_index exceeds num_freq_ranges */
14927 if (range_index
>= rdev
->wiphy
.sar_capa
->num_freq_ranges
)
14930 /* check if range_index duplicates */
14931 for (i
= 0; i
< index
; i
++) {
14932 if (sar_specs
->sub_specs
[i
].freq_range_index
== range_index
)
14936 sar_specs
->sub_specs
[index
].power
=
14937 nla_get_s32(spec
[NL80211_SAR_ATTR_SPECS_POWER
]);
14939 sar_specs
->sub_specs
[index
].freq_range_index
= range_index
;
14944 static int nl80211_set_sar_specs(struct sk_buff
*skb
, struct genl_info
*info
)
14946 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
14947 struct nlattr
*spec
[NL80211_SAR_ATTR_SPECS_MAX
+ 1];
14948 struct nlattr
*tb
[NL80211_SAR_ATTR_MAX
+ 1];
14949 struct cfg80211_sar_specs
*sar_spec
;
14950 enum nl80211_sar_type type
;
14951 struct nlattr
*spec_list
;
14955 if (!rdev
->wiphy
.sar_capa
|| !rdev
->ops
->set_sar_specs
)
14956 return -EOPNOTSUPP
;
14958 if (!info
->attrs
[NL80211_ATTR_SAR_SPEC
])
14961 nla_parse_nested(tb
, NL80211_SAR_ATTR_MAX
,
14962 info
->attrs
[NL80211_ATTR_SAR_SPEC
],
14965 if (!tb
[NL80211_SAR_ATTR_TYPE
] || !tb
[NL80211_SAR_ATTR_SPECS
])
14968 type
= nla_get_u32(tb
[NL80211_SAR_ATTR_TYPE
]);
14969 if (type
!= rdev
->wiphy
.sar_capa
->type
)
14973 nla_for_each_nested(spec_list
, tb
[NL80211_SAR_ATTR_SPECS
], rem
)
14976 if (specs
> rdev
->wiphy
.sar_capa
->num_freq_ranges
)
14979 sar_spec
= kzalloc(sizeof(*sar_spec
) +
14980 specs
* sizeof(struct cfg80211_sar_sub_specs
),
14985 sar_spec
->type
= type
;
14987 nla_for_each_nested(spec_list
, tb
[NL80211_SAR_ATTR_SPECS
], rem
) {
14988 nla_parse_nested(spec
, NL80211_SAR_ATTR_SPECS_MAX
,
14989 spec_list
, NULL
, NULL
);
14992 case NL80211_SAR_TYPE_POWER
:
14993 if (nl80211_set_sar_sub_specs(rdev
, sar_spec
,
15006 sar_spec
->num_sub_specs
= specs
;
15008 rdev
->cur_cmd_info
= info
;
15009 err
= rdev_set_sar_specs(rdev
, sar_spec
);
15010 rdev
->cur_cmd_info
= NULL
;
15016 static const struct genl_ops nl80211_ops
[] = {
15018 .cmd
= NL80211_CMD_GET_WIPHY
,
15019 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15020 .doit
= nl80211_get_wiphy
,
15021 .dumpit
= nl80211_dump_wiphy
,
15022 .done
= nl80211_dump_wiphy_done
,
15023 /* can be retrieved by unprivileged users */
15024 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15028 static const struct genl_small_ops nl80211_small_ops
[] = {
15030 .cmd
= NL80211_CMD_SET_WIPHY
,
15031 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15032 .doit
= nl80211_set_wiphy
,
15033 .flags
= GENL_UNS_ADMIN_PERM
,
15036 .cmd
= NL80211_CMD_GET_INTERFACE
,
15037 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15038 .doit
= nl80211_get_interface
,
15039 .dumpit
= nl80211_dump_interface
,
15040 /* can be retrieved by unprivileged users */
15041 .internal_flags
= NL80211_FLAG_NEED_WDEV
,
15044 .cmd
= NL80211_CMD_SET_INTERFACE
,
15045 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15046 .doit
= nl80211_set_interface
,
15047 .flags
= GENL_UNS_ADMIN_PERM
,
15048 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
15049 NL80211_FLAG_NEED_RTNL
,
15052 .cmd
= NL80211_CMD_NEW_INTERFACE
,
15053 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15054 .doit
= nl80211_new_interface
,
15055 .flags
= GENL_UNS_ADMIN_PERM
,
15056 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
15057 NL80211_FLAG_NEED_RTNL
|
15058 /* we take the wiphy mutex later ourselves */
15059 NL80211_FLAG_NO_WIPHY_MTX
,
15062 .cmd
= NL80211_CMD_DEL_INTERFACE
,
15063 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15064 .doit
= nl80211_del_interface
,
15065 .flags
= GENL_UNS_ADMIN_PERM
,
15066 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
15067 NL80211_FLAG_NEED_RTNL
,
15070 .cmd
= NL80211_CMD_GET_KEY
,
15071 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15072 .doit
= nl80211_get_key
,
15073 .flags
= GENL_UNS_ADMIN_PERM
,
15074 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15077 .cmd
= NL80211_CMD_SET_KEY
,
15078 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15079 .doit
= nl80211_set_key
,
15080 .flags
= GENL_UNS_ADMIN_PERM
,
15081 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15082 NL80211_FLAG_CLEAR_SKB
,
15085 .cmd
= NL80211_CMD_NEW_KEY
,
15086 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15087 .doit
= nl80211_new_key
,
15088 .flags
= GENL_UNS_ADMIN_PERM
,
15089 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15090 NL80211_FLAG_CLEAR_SKB
,
15093 .cmd
= NL80211_CMD_DEL_KEY
,
15094 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15095 .doit
= nl80211_del_key
,
15096 .flags
= GENL_UNS_ADMIN_PERM
,
15097 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15100 .cmd
= NL80211_CMD_SET_BEACON
,
15101 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15102 .flags
= GENL_UNS_ADMIN_PERM
,
15103 .doit
= nl80211_set_beacon
,
15104 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15107 .cmd
= NL80211_CMD_START_AP
,
15108 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15109 .flags
= GENL_UNS_ADMIN_PERM
,
15110 .doit
= nl80211_start_ap
,
15111 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15114 .cmd
= NL80211_CMD_STOP_AP
,
15115 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15116 .flags
= GENL_UNS_ADMIN_PERM
,
15117 .doit
= nl80211_stop_ap
,
15118 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15121 .cmd
= NL80211_CMD_GET_STATION
,
15122 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15123 .doit
= nl80211_get_station
,
15124 .dumpit
= nl80211_dump_station
,
15125 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15128 .cmd
= NL80211_CMD_SET_STATION
,
15129 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15130 .doit
= nl80211_set_station
,
15131 .flags
= GENL_UNS_ADMIN_PERM
,
15132 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15135 .cmd
= NL80211_CMD_NEW_STATION
,
15136 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15137 .doit
= nl80211_new_station
,
15138 .flags
= GENL_UNS_ADMIN_PERM
,
15139 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15142 .cmd
= NL80211_CMD_DEL_STATION
,
15143 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15144 .doit
= nl80211_del_station
,
15145 .flags
= GENL_UNS_ADMIN_PERM
,
15146 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15149 .cmd
= NL80211_CMD_GET_MPATH
,
15150 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15151 .doit
= nl80211_get_mpath
,
15152 .dumpit
= nl80211_dump_mpath
,
15153 .flags
= GENL_UNS_ADMIN_PERM
,
15154 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15157 .cmd
= NL80211_CMD_GET_MPP
,
15158 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15159 .doit
= nl80211_get_mpp
,
15160 .dumpit
= nl80211_dump_mpp
,
15161 .flags
= GENL_UNS_ADMIN_PERM
,
15162 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15165 .cmd
= NL80211_CMD_SET_MPATH
,
15166 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15167 .doit
= nl80211_set_mpath
,
15168 .flags
= GENL_UNS_ADMIN_PERM
,
15169 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15172 .cmd
= NL80211_CMD_NEW_MPATH
,
15173 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15174 .doit
= nl80211_new_mpath
,
15175 .flags
= GENL_UNS_ADMIN_PERM
,
15176 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15179 .cmd
= NL80211_CMD_DEL_MPATH
,
15180 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15181 .doit
= nl80211_del_mpath
,
15182 .flags
= GENL_UNS_ADMIN_PERM
,
15183 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15186 .cmd
= NL80211_CMD_SET_BSS
,
15187 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15188 .doit
= nl80211_set_bss
,
15189 .flags
= GENL_UNS_ADMIN_PERM
,
15190 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15193 .cmd
= NL80211_CMD_GET_REG
,
15194 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15195 .doit
= nl80211_get_reg_do
,
15196 .dumpit
= nl80211_get_reg_dump
,
15197 .internal_flags
= 0,
15198 /* can be retrieved by unprivileged users */
15200 #ifdef CONFIG_CFG80211_CRDA_SUPPORT
15202 .cmd
= NL80211_CMD_SET_REG
,
15203 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15204 .doit
= nl80211_set_reg
,
15205 .flags
= GENL_ADMIN_PERM
,
15206 .internal_flags
= 0,
15210 .cmd
= NL80211_CMD_REQ_SET_REG
,
15211 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15212 .doit
= nl80211_req_set_reg
,
15213 .flags
= GENL_ADMIN_PERM
,
15216 .cmd
= NL80211_CMD_RELOAD_REGDB
,
15217 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15218 .doit
= nl80211_reload_regdb
,
15219 .flags
= GENL_ADMIN_PERM
,
15222 .cmd
= NL80211_CMD_GET_MESH_CONFIG
,
15223 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15224 .doit
= nl80211_get_mesh_config
,
15225 /* can be retrieved by unprivileged users */
15226 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15229 .cmd
= NL80211_CMD_SET_MESH_CONFIG
,
15230 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15231 .doit
= nl80211_update_mesh_config
,
15232 .flags
= GENL_UNS_ADMIN_PERM
,
15233 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15236 .cmd
= NL80211_CMD_TRIGGER_SCAN
,
15237 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15238 .doit
= nl80211_trigger_scan
,
15239 .flags
= GENL_UNS_ADMIN_PERM
,
15240 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15243 .cmd
= NL80211_CMD_ABORT_SCAN
,
15244 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15245 .doit
= nl80211_abort_scan
,
15246 .flags
= GENL_UNS_ADMIN_PERM
,
15247 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15250 .cmd
= NL80211_CMD_GET_SCAN
,
15251 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15252 .dumpit
= nl80211_dump_scan
,
15255 .cmd
= NL80211_CMD_START_SCHED_SCAN
,
15256 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15257 .doit
= nl80211_start_sched_scan
,
15258 .flags
= GENL_UNS_ADMIN_PERM
,
15259 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15262 .cmd
= NL80211_CMD_STOP_SCHED_SCAN
,
15263 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15264 .doit
= nl80211_stop_sched_scan
,
15265 .flags
= GENL_UNS_ADMIN_PERM
,
15266 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15269 .cmd
= NL80211_CMD_AUTHENTICATE
,
15270 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15271 .doit
= nl80211_authenticate
,
15272 .flags
= GENL_UNS_ADMIN_PERM
,
15273 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15275 NL80211_FLAG_CLEAR_SKB
,
15278 .cmd
= NL80211_CMD_ASSOCIATE
,
15279 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15280 .doit
= nl80211_associate
,
15281 .flags
= GENL_UNS_ADMIN_PERM
,
15282 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15284 NL80211_FLAG_CLEAR_SKB
,
15287 .cmd
= NL80211_CMD_DEAUTHENTICATE
,
15288 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15289 .doit
= nl80211_deauthenticate
,
15290 .flags
= GENL_UNS_ADMIN_PERM
,
15291 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15294 .cmd
= NL80211_CMD_DISASSOCIATE
,
15295 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15296 .doit
= nl80211_disassociate
,
15297 .flags
= GENL_UNS_ADMIN_PERM
,
15298 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15301 .cmd
= NL80211_CMD_JOIN_IBSS
,
15302 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15303 .doit
= nl80211_join_ibss
,
15304 .flags
= GENL_UNS_ADMIN_PERM
,
15305 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15308 .cmd
= NL80211_CMD_LEAVE_IBSS
,
15309 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15310 .doit
= nl80211_leave_ibss
,
15311 .flags
= GENL_UNS_ADMIN_PERM
,
15312 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15314 #ifdef CONFIG_NL80211_TESTMODE
15316 .cmd
= NL80211_CMD_TESTMODE
,
15317 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15318 .doit
= nl80211_testmode_do
,
15319 .dumpit
= nl80211_testmode_dump
,
15320 .flags
= GENL_UNS_ADMIN_PERM
,
15321 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15325 .cmd
= NL80211_CMD_CONNECT
,
15326 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15327 .doit
= nl80211_connect
,
15328 .flags
= GENL_UNS_ADMIN_PERM
,
15329 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15331 NL80211_FLAG_CLEAR_SKB
,
15334 .cmd
= NL80211_CMD_UPDATE_CONNECT_PARAMS
,
15335 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15336 .doit
= nl80211_update_connect_params
,
15337 .flags
= GENL_ADMIN_PERM
,
15338 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15340 NL80211_FLAG_CLEAR_SKB
,
15343 .cmd
= NL80211_CMD_DISCONNECT
,
15344 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15345 .doit
= nl80211_disconnect
,
15346 .flags
= GENL_UNS_ADMIN_PERM
,
15347 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15350 .cmd
= NL80211_CMD_SET_WIPHY_NETNS
,
15351 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15352 .doit
= nl80211_wiphy_netns
,
15353 .flags
= GENL_UNS_ADMIN_PERM
,
15354 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
15355 NL80211_FLAG_NEED_RTNL
|
15356 NL80211_FLAG_NO_WIPHY_MTX
,
15359 .cmd
= NL80211_CMD_GET_SURVEY
,
15360 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15361 .dumpit
= nl80211_dump_survey
,
15364 .cmd
= NL80211_CMD_SET_PMKSA
,
15365 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15366 .doit
= nl80211_setdel_pmksa
,
15367 .flags
= GENL_UNS_ADMIN_PERM
,
15368 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15370 NL80211_FLAG_CLEAR_SKB
,
15373 .cmd
= NL80211_CMD_DEL_PMKSA
,
15374 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15375 .doit
= nl80211_setdel_pmksa
,
15376 .flags
= GENL_UNS_ADMIN_PERM
,
15377 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15380 .cmd
= NL80211_CMD_FLUSH_PMKSA
,
15381 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15382 .doit
= nl80211_flush_pmksa
,
15383 .flags
= GENL_UNS_ADMIN_PERM
,
15384 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15387 .cmd
= NL80211_CMD_REMAIN_ON_CHANNEL
,
15388 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15389 .doit
= nl80211_remain_on_channel
,
15390 .flags
= GENL_UNS_ADMIN_PERM
,
15391 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15394 .cmd
= NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
,
15395 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15396 .doit
= nl80211_cancel_remain_on_channel
,
15397 .flags
= GENL_UNS_ADMIN_PERM
,
15398 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15401 .cmd
= NL80211_CMD_SET_TX_BITRATE_MASK
,
15402 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15403 .doit
= nl80211_set_tx_bitrate_mask
,
15404 .flags
= GENL_UNS_ADMIN_PERM
,
15405 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15408 .cmd
= NL80211_CMD_REGISTER_FRAME
,
15409 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15410 .doit
= nl80211_register_mgmt
,
15411 .flags
= GENL_UNS_ADMIN_PERM
,
15412 .internal_flags
= NL80211_FLAG_NEED_WDEV
,
15415 .cmd
= NL80211_CMD_FRAME
,
15416 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15417 .doit
= nl80211_tx_mgmt
,
15418 .flags
= GENL_UNS_ADMIN_PERM
,
15419 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15422 .cmd
= NL80211_CMD_FRAME_WAIT_CANCEL
,
15423 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15424 .doit
= nl80211_tx_mgmt_cancel_wait
,
15425 .flags
= GENL_UNS_ADMIN_PERM
,
15426 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15429 .cmd
= NL80211_CMD_SET_POWER_SAVE
,
15430 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15431 .doit
= nl80211_set_power_save
,
15432 .flags
= GENL_UNS_ADMIN_PERM
,
15433 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15436 .cmd
= NL80211_CMD_GET_POWER_SAVE
,
15437 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15438 .doit
= nl80211_get_power_save
,
15439 /* can be retrieved by unprivileged users */
15440 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15443 .cmd
= NL80211_CMD_SET_CQM
,
15444 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15445 .doit
= nl80211_set_cqm
,
15446 .flags
= GENL_UNS_ADMIN_PERM
,
15447 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15450 .cmd
= NL80211_CMD_SET_CHANNEL
,
15451 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15452 .doit
= nl80211_set_channel
,
15453 .flags
= GENL_UNS_ADMIN_PERM
,
15454 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15457 .cmd
= NL80211_CMD_JOIN_MESH
,
15458 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15459 .doit
= nl80211_join_mesh
,
15460 .flags
= GENL_UNS_ADMIN_PERM
,
15461 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15464 .cmd
= NL80211_CMD_LEAVE_MESH
,
15465 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15466 .doit
= nl80211_leave_mesh
,
15467 .flags
= GENL_UNS_ADMIN_PERM
,
15468 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15471 .cmd
= NL80211_CMD_JOIN_OCB
,
15472 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15473 .doit
= nl80211_join_ocb
,
15474 .flags
= GENL_UNS_ADMIN_PERM
,
15475 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15478 .cmd
= NL80211_CMD_LEAVE_OCB
,
15479 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15480 .doit
= nl80211_leave_ocb
,
15481 .flags
= GENL_UNS_ADMIN_PERM
,
15482 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15486 .cmd
= NL80211_CMD_GET_WOWLAN
,
15487 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15488 .doit
= nl80211_get_wowlan
,
15489 /* can be retrieved by unprivileged users */
15490 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15493 .cmd
= NL80211_CMD_SET_WOWLAN
,
15494 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15495 .doit
= nl80211_set_wowlan
,
15496 .flags
= GENL_UNS_ADMIN_PERM
,
15497 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15501 .cmd
= NL80211_CMD_SET_REKEY_OFFLOAD
,
15502 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15503 .doit
= nl80211_set_rekey_data
,
15504 .flags
= GENL_UNS_ADMIN_PERM
,
15505 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15507 NL80211_FLAG_CLEAR_SKB
,
15510 .cmd
= NL80211_CMD_TDLS_MGMT
,
15511 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15512 .doit
= nl80211_tdls_mgmt
,
15513 .flags
= GENL_UNS_ADMIN_PERM
,
15514 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15517 .cmd
= NL80211_CMD_TDLS_OPER
,
15518 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15519 .doit
= nl80211_tdls_oper
,
15520 .flags
= GENL_UNS_ADMIN_PERM
,
15521 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15524 .cmd
= NL80211_CMD_UNEXPECTED_FRAME
,
15525 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15526 .doit
= nl80211_register_unexpected_frame
,
15527 .flags
= GENL_UNS_ADMIN_PERM
,
15528 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15531 .cmd
= NL80211_CMD_PROBE_CLIENT
,
15532 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15533 .doit
= nl80211_probe_client
,
15534 .flags
= GENL_UNS_ADMIN_PERM
,
15535 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15538 .cmd
= NL80211_CMD_REGISTER_BEACONS
,
15539 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15540 .doit
= nl80211_register_beacons
,
15541 .flags
= GENL_UNS_ADMIN_PERM
,
15542 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15545 .cmd
= NL80211_CMD_SET_NOACK_MAP
,
15546 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15547 .doit
= nl80211_set_noack_map
,
15548 .flags
= GENL_UNS_ADMIN_PERM
,
15549 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15552 .cmd
= NL80211_CMD_START_P2P_DEVICE
,
15553 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15554 .doit
= nl80211_start_p2p_device
,
15555 .flags
= GENL_UNS_ADMIN_PERM
,
15556 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
15557 NL80211_FLAG_NEED_RTNL
,
15560 .cmd
= NL80211_CMD_STOP_P2P_DEVICE
,
15561 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15562 .doit
= nl80211_stop_p2p_device
,
15563 .flags
= GENL_UNS_ADMIN_PERM
,
15564 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
15565 NL80211_FLAG_NEED_RTNL
,
15568 .cmd
= NL80211_CMD_START_NAN
,
15569 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15570 .doit
= nl80211_start_nan
,
15571 .flags
= GENL_ADMIN_PERM
,
15572 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
15573 NL80211_FLAG_NEED_RTNL
,
15576 .cmd
= NL80211_CMD_STOP_NAN
,
15577 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15578 .doit
= nl80211_stop_nan
,
15579 .flags
= GENL_ADMIN_PERM
,
15580 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
15581 NL80211_FLAG_NEED_RTNL
,
15584 .cmd
= NL80211_CMD_ADD_NAN_FUNCTION
,
15585 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15586 .doit
= nl80211_nan_add_func
,
15587 .flags
= GENL_ADMIN_PERM
,
15588 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15591 .cmd
= NL80211_CMD_DEL_NAN_FUNCTION
,
15592 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15593 .doit
= nl80211_nan_del_func
,
15594 .flags
= GENL_ADMIN_PERM
,
15595 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15598 .cmd
= NL80211_CMD_CHANGE_NAN_CONFIG
,
15599 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15600 .doit
= nl80211_nan_change_config
,
15601 .flags
= GENL_ADMIN_PERM
,
15602 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15605 .cmd
= NL80211_CMD_SET_MCAST_RATE
,
15606 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15607 .doit
= nl80211_set_mcast_rate
,
15608 .flags
= GENL_UNS_ADMIN_PERM
,
15609 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15612 .cmd
= NL80211_CMD_SET_MAC_ACL
,
15613 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15614 .doit
= nl80211_set_mac_acl
,
15615 .flags
= GENL_UNS_ADMIN_PERM
,
15616 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15619 .cmd
= NL80211_CMD_RADAR_DETECT
,
15620 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15621 .doit
= nl80211_start_radar_detection
,
15622 .flags
= GENL_UNS_ADMIN_PERM
,
15623 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15626 .cmd
= NL80211_CMD_GET_PROTOCOL_FEATURES
,
15627 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15628 .doit
= nl80211_get_protocol_features
,
15631 .cmd
= NL80211_CMD_UPDATE_FT_IES
,
15632 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15633 .doit
= nl80211_update_ft_ies
,
15634 .flags
= GENL_UNS_ADMIN_PERM
,
15635 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15638 .cmd
= NL80211_CMD_CRIT_PROTOCOL_START
,
15639 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15640 .doit
= nl80211_crit_protocol_start
,
15641 .flags
= GENL_UNS_ADMIN_PERM
,
15642 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15645 .cmd
= NL80211_CMD_CRIT_PROTOCOL_STOP
,
15646 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15647 .doit
= nl80211_crit_protocol_stop
,
15648 .flags
= GENL_UNS_ADMIN_PERM
,
15649 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15652 .cmd
= NL80211_CMD_GET_COALESCE
,
15653 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15654 .doit
= nl80211_get_coalesce
,
15655 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15658 .cmd
= NL80211_CMD_SET_COALESCE
,
15659 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15660 .doit
= nl80211_set_coalesce
,
15661 .flags
= GENL_UNS_ADMIN_PERM
,
15662 .internal_flags
= NL80211_FLAG_NEED_WIPHY
,
15665 .cmd
= NL80211_CMD_CHANNEL_SWITCH
,
15666 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15667 .doit
= nl80211_channel_switch
,
15668 .flags
= GENL_UNS_ADMIN_PERM
,
15669 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15672 .cmd
= NL80211_CMD_VENDOR
,
15673 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15674 .doit
= nl80211_vendor_cmd
,
15675 .dumpit
= nl80211_vendor_cmd_dump
,
15676 .flags
= GENL_UNS_ADMIN_PERM
,
15677 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
15679 NL80211_FLAG_CLEAR_SKB
,
15682 .cmd
= NL80211_CMD_SET_QOS_MAP
,
15683 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15684 .doit
= nl80211_set_qos_map
,
15685 .flags
= GENL_UNS_ADMIN_PERM
,
15686 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15689 .cmd
= NL80211_CMD_ADD_TX_TS
,
15690 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15691 .doit
= nl80211_add_tx_ts
,
15692 .flags
= GENL_UNS_ADMIN_PERM
,
15693 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15696 .cmd
= NL80211_CMD_DEL_TX_TS
,
15697 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15698 .doit
= nl80211_del_tx_ts
,
15699 .flags
= GENL_UNS_ADMIN_PERM
,
15700 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15703 .cmd
= NL80211_CMD_TDLS_CHANNEL_SWITCH
,
15704 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15705 .doit
= nl80211_tdls_channel_switch
,
15706 .flags
= GENL_UNS_ADMIN_PERM
,
15707 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15710 .cmd
= NL80211_CMD_TDLS_CANCEL_CHANNEL_SWITCH
,
15711 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15712 .doit
= nl80211_tdls_cancel_channel_switch
,
15713 .flags
= GENL_UNS_ADMIN_PERM
,
15714 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15717 .cmd
= NL80211_CMD_SET_MULTICAST_TO_UNICAST
,
15718 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15719 .doit
= nl80211_set_multicast_to_unicast
,
15720 .flags
= GENL_UNS_ADMIN_PERM
,
15721 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15724 .cmd
= NL80211_CMD_SET_PMK
,
15725 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15726 .doit
= nl80211_set_pmk
,
15727 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
15729 NL80211_FLAG_CLEAR_SKB
,
15732 .cmd
= NL80211_CMD_DEL_PMK
,
15733 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15734 .doit
= nl80211_del_pmk
,
15735 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15738 .cmd
= NL80211_CMD_EXTERNAL_AUTH
,
15739 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15740 .doit
= nl80211_external_auth
,
15741 .flags
= GENL_ADMIN_PERM
,
15742 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15745 .cmd
= NL80211_CMD_CONTROL_PORT_FRAME
,
15746 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15747 .doit
= nl80211_tx_control_port
,
15748 .flags
= GENL_UNS_ADMIN_PERM
,
15749 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15752 .cmd
= NL80211_CMD_GET_FTM_RESPONDER_STATS
,
15753 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15754 .doit
= nl80211_get_ftm_responder_stats
,
15755 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15758 .cmd
= NL80211_CMD_PEER_MEASUREMENT_START
,
15759 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15760 .doit
= nl80211_pmsr_start
,
15761 .flags
= GENL_UNS_ADMIN_PERM
,
15762 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
,
15765 .cmd
= NL80211_CMD_NOTIFY_RADAR
,
15766 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15767 .doit
= nl80211_notify_radar_detection
,
15768 .flags
= GENL_UNS_ADMIN_PERM
,
15769 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15772 .cmd
= NL80211_CMD_UPDATE_OWE_INFO
,
15773 .doit
= nl80211_update_owe_info
,
15774 .flags
= GENL_ADMIN_PERM
,
15775 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15778 .cmd
= NL80211_CMD_PROBE_MESH_LINK
,
15779 .doit
= nl80211_probe_mesh_link
,
15780 .flags
= GENL_UNS_ADMIN_PERM
,
15781 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
,
15784 .cmd
= NL80211_CMD_SET_TID_CONFIG
,
15785 .doit
= nl80211_set_tid_config
,
15786 .flags
= GENL_UNS_ADMIN_PERM
,
15787 .internal_flags
= NL80211_FLAG_NEED_NETDEV
,
15790 .cmd
= NL80211_CMD_SET_SAR_SPECS
,
15791 .validate
= GENL_DONT_VALIDATE_STRICT
| GENL_DONT_VALIDATE_DUMP
,
15792 .doit
= nl80211_set_sar_specs
,
15793 .flags
= GENL_UNS_ADMIN_PERM
,
15794 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
15795 NL80211_FLAG_NEED_RTNL
,
15799 static struct genl_family nl80211_fam __ro_after_init
= {
15800 .name
= NL80211_GENL_NAME
, /* have users key off the name instead */
15801 .hdrsize
= 0, /* no private header */
15802 .version
= 1, /* no particular meaning now */
15803 .maxattr
= NL80211_ATTR_MAX
,
15804 .policy
= nl80211_policy
,
15806 .pre_doit
= nl80211_pre_doit
,
15807 .post_doit
= nl80211_post_doit
,
15808 .module
= THIS_MODULE
,
15809 .ops
= nl80211_ops
,
15810 .n_ops
= ARRAY_SIZE(nl80211_ops
),
15811 .small_ops
= nl80211_small_ops
,
15812 .n_small_ops
= ARRAY_SIZE(nl80211_small_ops
),
15813 .mcgrps
= nl80211_mcgrps
,
15814 .n_mcgrps
= ARRAY_SIZE(nl80211_mcgrps
),
15815 .parallel_ops
= true,
15818 /* notification functions */
15820 void nl80211_notify_wiphy(struct cfg80211_registered_device
*rdev
,
15821 enum nl80211_commands cmd
)
15823 struct sk_buff
*msg
;
15824 struct nl80211_dump_wiphy_state state
= {};
15826 WARN_ON(cmd
!= NL80211_CMD_NEW_WIPHY
&&
15827 cmd
!= NL80211_CMD_DEL_WIPHY
);
15829 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
15833 if (nl80211_send_wiphy(rdev
, cmd
, msg
, 0, 0, 0, &state
) < 0) {
15838 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
15839 NL80211_MCGRP_CONFIG
, GFP_KERNEL
);
15842 void nl80211_notify_iface(struct cfg80211_registered_device
*rdev
,
15843 struct wireless_dev
*wdev
,
15844 enum nl80211_commands cmd
)
15846 struct sk_buff
*msg
;
15848 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
15852 if (nl80211_send_iface(msg
, 0, 0, 0, rdev
, wdev
, cmd
) < 0) {
15857 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
15858 NL80211_MCGRP_CONFIG
, GFP_KERNEL
);
15861 static int nl80211_add_scan_req(struct sk_buff
*msg
,
15862 struct cfg80211_registered_device
*rdev
)
15864 struct cfg80211_scan_request
*req
= rdev
->scan_req
;
15865 struct nlattr
*nest
;
15867 struct cfg80211_scan_info
*info
;
15872 nest
= nla_nest_start_noflag(msg
, NL80211_ATTR_SCAN_SSIDS
);
15874 goto nla_put_failure
;
15875 for (i
= 0; i
< req
->n_ssids
; i
++) {
15876 if (nla_put(msg
, i
, req
->ssids
[i
].ssid_len
, req
->ssids
[i
].ssid
))
15877 goto nla_put_failure
;
15879 nla_nest_end(msg
, nest
);
15881 if (req
->flags
& NL80211_SCAN_FLAG_FREQ_KHZ
) {
15882 nest
= nla_nest_start(msg
, NL80211_ATTR_SCAN_FREQ_KHZ
);
15884 goto nla_put_failure
;
15885 for (i
= 0; i
< req
->n_channels
; i
++) {
15886 if (nla_put_u32(msg
, i
,
15887 ieee80211_channel_to_khz(req
->channels
[i
])))
15888 goto nla_put_failure
;
15890 nla_nest_end(msg
, nest
);
15892 nest
= nla_nest_start_noflag(msg
,
15893 NL80211_ATTR_SCAN_FREQUENCIES
);
15895 goto nla_put_failure
;
15896 for (i
= 0; i
< req
->n_channels
; i
++) {
15897 if (nla_put_u32(msg
, i
, req
->channels
[i
]->center_freq
))
15898 goto nla_put_failure
;
15900 nla_nest_end(msg
, nest
);
15904 nla_put(msg
, NL80211_ATTR_IE
, req
->ie_len
, req
->ie
))
15905 goto nla_put_failure
;
15908 nla_put_u32(msg
, NL80211_ATTR_SCAN_FLAGS
, req
->flags
))
15909 goto nla_put_failure
;
15911 info
= rdev
->int_scan_req
? &rdev
->int_scan_req
->info
:
15912 &rdev
->scan_req
->info
;
15913 if (info
->scan_start_tsf
&&
15914 (nla_put_u64_64bit(msg
, NL80211_ATTR_SCAN_START_TIME_TSF
,
15915 info
->scan_start_tsf
, NL80211_BSS_PAD
) ||
15916 nla_put(msg
, NL80211_ATTR_SCAN_START_TIME_TSF_BSSID
, ETH_ALEN
,
15918 goto nla_put_failure
;
15925 static int nl80211_prep_scan_msg(struct sk_buff
*msg
,
15926 struct cfg80211_registered_device
*rdev
,
15927 struct wireless_dev
*wdev
,
15928 u32 portid
, u32 seq
, int flags
,
15933 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, cmd
);
15937 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
15938 (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
15939 wdev
->netdev
->ifindex
)) ||
15940 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
15942 goto nla_put_failure
;
15944 /* ignore errors and send incomplete event anyway */
15945 nl80211_add_scan_req(msg
, rdev
);
15947 genlmsg_end(msg
, hdr
);
15951 genlmsg_cancel(msg
, hdr
);
15956 nl80211_prep_sched_scan_msg(struct sk_buff
*msg
,
15957 struct cfg80211_sched_scan_request
*req
, u32 cmd
)
15961 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
15965 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
,
15966 wiphy_to_rdev(req
->wiphy
)->wiphy_idx
) ||
15967 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, req
->dev
->ifindex
) ||
15968 nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, req
->reqid
,
15970 goto nla_put_failure
;
15972 genlmsg_end(msg
, hdr
);
15976 genlmsg_cancel(msg
, hdr
);
15980 void nl80211_send_scan_start(struct cfg80211_registered_device
*rdev
,
15981 struct wireless_dev
*wdev
)
15983 struct sk_buff
*msg
;
15985 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
15989 if (nl80211_prep_scan_msg(msg
, rdev
, wdev
, 0, 0, 0,
15990 NL80211_CMD_TRIGGER_SCAN
) < 0) {
15995 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
15996 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
15999 struct sk_buff
*nl80211_build_scan_msg(struct cfg80211_registered_device
*rdev
,
16000 struct wireless_dev
*wdev
, bool aborted
)
16002 struct sk_buff
*msg
;
16004 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
16008 if (nl80211_prep_scan_msg(msg
, rdev
, wdev
, 0, 0, 0,
16009 aborted
? NL80211_CMD_SCAN_ABORTED
:
16010 NL80211_CMD_NEW_SCAN_RESULTS
) < 0) {
16018 /* send message created by nl80211_build_scan_msg() */
16019 void nl80211_send_scan_msg(struct cfg80211_registered_device
*rdev
,
16020 struct sk_buff
*msg
)
16025 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16026 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
16029 void nl80211_send_sched_scan(struct cfg80211_sched_scan_request
*req
, u32 cmd
)
16031 struct sk_buff
*msg
;
16033 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
16037 if (nl80211_prep_sched_scan_msg(msg
, req
, cmd
) < 0) {
16042 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(req
->wiphy
), msg
, 0,
16043 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
16046 static bool nl80211_reg_change_event_fill(struct sk_buff
*msg
,
16047 struct regulatory_request
*request
)
16049 /* Userspace can always count this one always being set */
16050 if (nla_put_u8(msg
, NL80211_ATTR_REG_INITIATOR
, request
->initiator
))
16051 goto nla_put_failure
;
16053 if (request
->alpha2
[0] == '0' && request
->alpha2
[1] == '0') {
16054 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
16055 NL80211_REGDOM_TYPE_WORLD
))
16056 goto nla_put_failure
;
16057 } else if (request
->alpha2
[0] == '9' && request
->alpha2
[1] == '9') {
16058 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
16059 NL80211_REGDOM_TYPE_CUSTOM_WORLD
))
16060 goto nla_put_failure
;
16061 } else if ((request
->alpha2
[0] == '9' && request
->alpha2
[1] == '8') ||
16062 request
->intersect
) {
16063 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
16064 NL80211_REGDOM_TYPE_INTERSECTION
))
16065 goto nla_put_failure
;
16067 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
16068 NL80211_REGDOM_TYPE_COUNTRY
) ||
16069 nla_put_string(msg
, NL80211_ATTR_REG_ALPHA2
,
16071 goto nla_put_failure
;
16074 if (request
->wiphy_idx
!= WIPHY_IDX_INVALID
) {
16075 struct wiphy
*wiphy
= wiphy_idx_to_wiphy(request
->wiphy_idx
);
16078 nla_put_u32(msg
, NL80211_ATTR_WIPHY
, request
->wiphy_idx
))
16079 goto nla_put_failure
;
16082 wiphy
->regulatory_flags
& REGULATORY_WIPHY_SELF_MANAGED
&&
16083 nla_put_flag(msg
, NL80211_ATTR_WIPHY_SELF_MANAGED_REG
))
16084 goto nla_put_failure
;
16094 * This can happen on global regulatory changes or device specific settings
16095 * based on custom regulatory domains.
16097 void nl80211_common_reg_change_event(enum nl80211_commands cmd_id
,
16098 struct regulatory_request
*request
)
16100 struct sk_buff
*msg
;
16103 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
16107 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd_id
);
16109 goto nla_put_failure
;
16111 if (!nl80211_reg_change_event_fill(msg
, request
))
16112 goto nla_put_failure
;
16114 genlmsg_end(msg
, hdr
);
16117 genlmsg_multicast_allns(&nl80211_fam
, msg
, 0,
16118 NL80211_MCGRP_REGULATORY
, GFP_ATOMIC
);
16127 static void nl80211_send_mlme_event(struct cfg80211_registered_device
*rdev
,
16128 struct net_device
*netdev
,
16129 const u8
*buf
, size_t len
,
16130 enum nl80211_commands cmd
, gfp_t gfp
,
16131 int uapsd_queues
, const u8
*req_ies
,
16132 size_t req_ies_len
, bool reconnect
)
16134 struct sk_buff
*msg
;
16137 msg
= nlmsg_new(100 + len
+ req_ies_len
, gfp
);
16141 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
16147 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16148 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16149 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
) ||
16151 nla_put(msg
, NL80211_ATTR_REQ_IE
, req_ies_len
, req_ies
)))
16152 goto nla_put_failure
;
16154 if (reconnect
&& nla_put_flag(msg
, NL80211_ATTR_RECONNECT_REQUESTED
))
16155 goto nla_put_failure
;
16157 if (uapsd_queues
>= 0) {
16158 struct nlattr
*nla_wmm
=
16159 nla_nest_start_noflag(msg
, NL80211_ATTR_STA_WME
);
16161 goto nla_put_failure
;
16163 if (nla_put_u8(msg
, NL80211_STA_WME_UAPSD_QUEUES
,
16165 goto nla_put_failure
;
16167 nla_nest_end(msg
, nla_wmm
);
16170 genlmsg_end(msg
, hdr
);
16172 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16173 NL80211_MCGRP_MLME
, gfp
);
16180 void nl80211_send_rx_auth(struct cfg80211_registered_device
*rdev
,
16181 struct net_device
*netdev
, const u8
*buf
,
16182 size_t len
, gfp_t gfp
)
16184 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
16185 NL80211_CMD_AUTHENTICATE
, gfp
, -1, NULL
, 0,
16189 void nl80211_send_rx_assoc(struct cfg80211_registered_device
*rdev
,
16190 struct net_device
*netdev
, const u8
*buf
,
16191 size_t len
, gfp_t gfp
, int uapsd_queues
,
16192 const u8
*req_ies
, size_t req_ies_len
)
16194 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
16195 NL80211_CMD_ASSOCIATE
, gfp
, uapsd_queues
,
16196 req_ies
, req_ies_len
, false);
16199 void nl80211_send_deauth(struct cfg80211_registered_device
*rdev
,
16200 struct net_device
*netdev
, const u8
*buf
,
16201 size_t len
, bool reconnect
, gfp_t gfp
)
16203 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
16204 NL80211_CMD_DEAUTHENTICATE
, gfp
, -1, NULL
, 0,
16208 void nl80211_send_disassoc(struct cfg80211_registered_device
*rdev
,
16209 struct net_device
*netdev
, const u8
*buf
,
16210 size_t len
, bool reconnect
, gfp_t gfp
)
16212 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
16213 NL80211_CMD_DISASSOCIATE
, gfp
, -1, NULL
, 0,
16217 void cfg80211_rx_unprot_mlme_mgmt(struct net_device
*dev
, const u8
*buf
,
16220 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
16221 struct wiphy
*wiphy
= wdev
->wiphy
;
16222 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16223 const struct ieee80211_mgmt
*mgmt
= (void *)buf
;
16226 if (WARN_ON(len
< 2))
16229 if (ieee80211_is_deauth(mgmt
->frame_control
)) {
16230 cmd
= NL80211_CMD_UNPROT_DEAUTHENTICATE
;
16231 } else if (ieee80211_is_disassoc(mgmt
->frame_control
)) {
16232 cmd
= NL80211_CMD_UNPROT_DISASSOCIATE
;
16233 } else if (ieee80211_is_beacon(mgmt
->frame_control
)) {
16234 if (wdev
->unprot_beacon_reported
&&
16235 elapsed_jiffies_msecs(wdev
->unprot_beacon_reported
) < 10000)
16237 cmd
= NL80211_CMD_UNPROT_BEACON
;
16238 wdev
->unprot_beacon_reported
= jiffies
;
16243 trace_cfg80211_rx_unprot_mlme_mgmt(dev
, buf
, len
);
16244 nl80211_send_mlme_event(rdev
, dev
, buf
, len
, cmd
, GFP_ATOMIC
, -1,
16247 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt
);
16249 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device
*rdev
,
16250 struct net_device
*netdev
, int cmd
,
16251 const u8
*addr
, gfp_t gfp
)
16253 struct sk_buff
*msg
;
16256 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
16260 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
16266 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16267 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16268 nla_put_flag(msg
, NL80211_ATTR_TIMED_OUT
) ||
16269 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
))
16270 goto nla_put_failure
;
16272 genlmsg_end(msg
, hdr
);
16274 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16275 NL80211_MCGRP_MLME
, gfp
);
16282 void nl80211_send_auth_timeout(struct cfg80211_registered_device
*rdev
,
16283 struct net_device
*netdev
, const u8
*addr
,
16286 nl80211_send_mlme_timeout(rdev
, netdev
, NL80211_CMD_AUTHENTICATE
,
16290 void nl80211_send_assoc_timeout(struct cfg80211_registered_device
*rdev
,
16291 struct net_device
*netdev
, const u8
*addr
,
16294 nl80211_send_mlme_timeout(rdev
, netdev
, NL80211_CMD_ASSOCIATE
,
16298 void nl80211_send_connect_result(struct cfg80211_registered_device
*rdev
,
16299 struct net_device
*netdev
,
16300 struct cfg80211_connect_resp_params
*cr
,
16303 struct sk_buff
*msg
;
16306 msg
= nlmsg_new(100 + cr
->req_ie_len
+ cr
->resp_ie_len
+
16307 cr
->fils
.kek_len
+ cr
->fils
.pmk_len
+
16308 (cr
->fils
.pmkid
? WLAN_PMKID_LEN
: 0), gfp
);
16312 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CONNECT
);
16318 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16319 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16321 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, cr
->bssid
)) ||
16322 nla_put_u16(msg
, NL80211_ATTR_STATUS_CODE
,
16323 cr
->status
< 0 ? WLAN_STATUS_UNSPECIFIED_FAILURE
:
16326 (nla_put_flag(msg
, NL80211_ATTR_TIMED_OUT
) ||
16327 nla_put_u32(msg
, NL80211_ATTR_TIMEOUT_REASON
,
16328 cr
->timeout_reason
))) ||
16330 nla_put(msg
, NL80211_ATTR_REQ_IE
, cr
->req_ie_len
, cr
->req_ie
)) ||
16332 nla_put(msg
, NL80211_ATTR_RESP_IE
, cr
->resp_ie_len
,
16334 (cr
->fils
.update_erp_next_seq_num
&&
16335 nla_put_u16(msg
, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
,
16336 cr
->fils
.erp_next_seq_num
)) ||
16337 (cr
->status
== WLAN_STATUS_SUCCESS
&&
16339 nla_put(msg
, NL80211_ATTR_FILS_KEK
, cr
->fils
.kek_len
,
16342 nla_put(msg
, NL80211_ATTR_PMK
, cr
->fils
.pmk_len
, cr
->fils
.pmk
)) ||
16344 nla_put(msg
, NL80211_ATTR_PMKID
, WLAN_PMKID_LEN
, cr
->fils
.pmkid
)))))
16345 goto nla_put_failure
;
16347 genlmsg_end(msg
, hdr
);
16349 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16350 NL80211_MCGRP_MLME
, gfp
);
16357 void nl80211_send_roamed(struct cfg80211_registered_device
*rdev
,
16358 struct net_device
*netdev
,
16359 struct cfg80211_roam_info
*info
, gfp_t gfp
)
16361 struct sk_buff
*msg
;
16363 const u8
*bssid
= info
->bss
? info
->bss
->bssid
: info
->bssid
;
16365 msg
= nlmsg_new(100 + info
->req_ie_len
+ info
->resp_ie_len
+
16366 info
->fils
.kek_len
+ info
->fils
.pmk_len
+
16367 (info
->fils
.pmkid
? WLAN_PMKID_LEN
: 0), gfp
);
16371 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_ROAM
);
16377 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16378 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16379 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
) ||
16381 nla_put(msg
, NL80211_ATTR_REQ_IE
, info
->req_ie_len
,
16384 nla_put(msg
, NL80211_ATTR_RESP_IE
, info
->resp_ie_len
,
16386 (info
->fils
.update_erp_next_seq_num
&&
16387 nla_put_u16(msg
, NL80211_ATTR_FILS_ERP_NEXT_SEQ_NUM
,
16388 info
->fils
.erp_next_seq_num
)) ||
16390 nla_put(msg
, NL80211_ATTR_FILS_KEK
, info
->fils
.kek_len
,
16391 info
->fils
.kek
)) ||
16393 nla_put(msg
, NL80211_ATTR_PMK
, info
->fils
.pmk_len
, info
->fils
.pmk
)) ||
16394 (info
->fils
.pmkid
&&
16395 nla_put(msg
, NL80211_ATTR_PMKID
, WLAN_PMKID_LEN
, info
->fils
.pmkid
)))
16396 goto nla_put_failure
;
16398 genlmsg_end(msg
, hdr
);
16400 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16401 NL80211_MCGRP_MLME
, gfp
);
16408 void nl80211_send_port_authorized(struct cfg80211_registered_device
*rdev
,
16409 struct net_device
*netdev
, const u8
*bssid
)
16411 struct sk_buff
*msg
;
16414 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
16418 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PORT_AUTHORIZED
);
16424 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16425 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16426 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
16427 goto nla_put_failure
;
16429 genlmsg_end(msg
, hdr
);
16431 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16432 NL80211_MCGRP_MLME
, GFP_KERNEL
);
16439 void nl80211_send_disconnected(struct cfg80211_registered_device
*rdev
,
16440 struct net_device
*netdev
, u16 reason
,
16441 const u8
*ie
, size_t ie_len
, bool from_ap
)
16443 struct sk_buff
*msg
;
16446 msg
= nlmsg_new(100 + ie_len
, GFP_KERNEL
);
16450 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_DISCONNECT
);
16456 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16457 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16459 nla_put_u16(msg
, NL80211_ATTR_REASON_CODE
, reason
)) ||
16461 nla_put_flag(msg
, NL80211_ATTR_DISCONNECTED_BY_AP
)) ||
16462 (ie
&& nla_put(msg
, NL80211_ATTR_IE
, ie_len
, ie
)))
16463 goto nla_put_failure
;
16465 genlmsg_end(msg
, hdr
);
16467 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16468 NL80211_MCGRP_MLME
, GFP_KERNEL
);
16475 void nl80211_send_ibss_bssid(struct cfg80211_registered_device
*rdev
,
16476 struct net_device
*netdev
, const u8
*bssid
,
16479 struct sk_buff
*msg
;
16482 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
16486 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_JOIN_IBSS
);
16492 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16493 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16494 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
16495 goto nla_put_failure
;
16497 genlmsg_end(msg
, hdr
);
16499 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16500 NL80211_MCGRP_MLME
, gfp
);
16507 void cfg80211_notify_new_peer_candidate(struct net_device
*dev
, const u8
*addr
,
16508 const u8
*ie
, u8 ie_len
,
16509 int sig_dbm
, gfp_t gfp
)
16511 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
16512 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
16513 struct sk_buff
*msg
;
16516 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
))
16519 trace_cfg80211_notify_new_peer_candidate(dev
, addr
);
16521 msg
= nlmsg_new(100 + ie_len
, gfp
);
16525 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE
);
16531 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16532 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
16533 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
) ||
16535 nla_put(msg
, NL80211_ATTR_IE
, ie_len
, ie
)) ||
16537 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)))
16538 goto nla_put_failure
;
16540 genlmsg_end(msg
, hdr
);
16542 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16543 NL80211_MCGRP_MLME
, gfp
);
16549 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate
);
16551 void nl80211_michael_mic_failure(struct cfg80211_registered_device
*rdev
,
16552 struct net_device
*netdev
, const u8
*addr
,
16553 enum nl80211_key_type key_type
, int key_id
,
16554 const u8
*tsc
, gfp_t gfp
)
16556 struct sk_buff
*msg
;
16559 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
16563 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE
);
16569 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16570 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
16571 (addr
&& nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
)) ||
16572 nla_put_u32(msg
, NL80211_ATTR_KEY_TYPE
, key_type
) ||
16574 nla_put_u8(msg
, NL80211_ATTR_KEY_IDX
, key_id
)) ||
16575 (tsc
&& nla_put(msg
, NL80211_ATTR_KEY_SEQ
, 6, tsc
)))
16576 goto nla_put_failure
;
16578 genlmsg_end(msg
, hdr
);
16580 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16581 NL80211_MCGRP_MLME
, gfp
);
16588 void nl80211_send_beacon_hint_event(struct wiphy
*wiphy
,
16589 struct ieee80211_channel
*channel_before
,
16590 struct ieee80211_channel
*channel_after
)
16592 struct sk_buff
*msg
;
16594 struct nlattr
*nl_freq
;
16596 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
16600 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT
);
16607 * Since we are applying the beacon hint to a wiphy we know its
16608 * wiphy_idx is valid
16610 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, get_wiphy_idx(wiphy
)))
16611 goto nla_put_failure
;
16614 nl_freq
= nla_nest_start_noflag(msg
, NL80211_ATTR_FREQ_BEFORE
);
16616 goto nla_put_failure
;
16618 if (nl80211_msg_put_channel(msg
, wiphy
, channel_before
, false))
16619 goto nla_put_failure
;
16620 nla_nest_end(msg
, nl_freq
);
16623 nl_freq
= nla_nest_start_noflag(msg
, NL80211_ATTR_FREQ_AFTER
);
16625 goto nla_put_failure
;
16627 if (nl80211_msg_put_channel(msg
, wiphy
, channel_after
, false))
16628 goto nla_put_failure
;
16629 nla_nest_end(msg
, nl_freq
);
16631 genlmsg_end(msg
, hdr
);
16634 genlmsg_multicast_allns(&nl80211_fam
, msg
, 0,
16635 NL80211_MCGRP_REGULATORY
, GFP_ATOMIC
);
16644 static void nl80211_send_remain_on_chan_event(
16645 int cmd
, struct cfg80211_registered_device
*rdev
,
16646 struct wireless_dev
*wdev
, u64 cookie
,
16647 struct ieee80211_channel
*chan
,
16648 unsigned int duration
, gfp_t gfp
)
16650 struct sk_buff
*msg
;
16653 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
16657 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
16663 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16664 (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
16665 wdev
->netdev
->ifindex
)) ||
16666 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
16667 NL80211_ATTR_PAD
) ||
16668 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, chan
->center_freq
) ||
16669 nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
16670 NL80211_CHAN_NO_HT
) ||
16671 nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
16673 goto nla_put_failure
;
16675 if (cmd
== NL80211_CMD_REMAIN_ON_CHANNEL
&&
16676 nla_put_u32(msg
, NL80211_ATTR_DURATION
, duration
))
16677 goto nla_put_failure
;
16679 genlmsg_end(msg
, hdr
);
16681 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16682 NL80211_MCGRP_MLME
, gfp
);
16689 void cfg80211_ready_on_channel(struct wireless_dev
*wdev
, u64 cookie
,
16690 struct ieee80211_channel
*chan
,
16691 unsigned int duration
, gfp_t gfp
)
16693 struct wiphy
*wiphy
= wdev
->wiphy
;
16694 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16696 trace_cfg80211_ready_on_channel(wdev
, cookie
, chan
, duration
);
16697 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL
,
16698 rdev
, wdev
, cookie
, chan
,
16701 EXPORT_SYMBOL(cfg80211_ready_on_channel
);
16703 void cfg80211_remain_on_channel_expired(struct wireless_dev
*wdev
, u64 cookie
,
16704 struct ieee80211_channel
*chan
,
16707 struct wiphy
*wiphy
= wdev
->wiphy
;
16708 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16710 trace_cfg80211_ready_on_channel_expired(wdev
, cookie
, chan
);
16711 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
,
16712 rdev
, wdev
, cookie
, chan
, 0, gfp
);
16714 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired
);
16716 void cfg80211_tx_mgmt_expired(struct wireless_dev
*wdev
, u64 cookie
,
16717 struct ieee80211_channel
*chan
,
16720 struct wiphy
*wiphy
= wdev
->wiphy
;
16721 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16723 trace_cfg80211_tx_mgmt_expired(wdev
, cookie
, chan
);
16724 nl80211_send_remain_on_chan_event(NL80211_CMD_FRAME_WAIT_CANCEL
,
16725 rdev
, wdev
, cookie
, chan
, 0, gfp
);
16727 EXPORT_SYMBOL(cfg80211_tx_mgmt_expired
);
16729 void cfg80211_new_sta(struct net_device
*dev
, const u8
*mac_addr
,
16730 struct station_info
*sinfo
, gfp_t gfp
)
16732 struct wiphy
*wiphy
= dev
->ieee80211_ptr
->wiphy
;
16733 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16734 struct sk_buff
*msg
;
16736 trace_cfg80211_new_sta(dev
, mac_addr
, sinfo
);
16738 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
16742 if (nl80211_send_station(msg
, NL80211_CMD_NEW_STATION
, 0, 0, 0,
16743 rdev
, dev
, mac_addr
, sinfo
) < 0) {
16748 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16749 NL80211_MCGRP_MLME
, gfp
);
16751 EXPORT_SYMBOL(cfg80211_new_sta
);
16753 void cfg80211_del_sta_sinfo(struct net_device
*dev
, const u8
*mac_addr
,
16754 struct station_info
*sinfo
, gfp_t gfp
)
16756 struct wiphy
*wiphy
= dev
->ieee80211_ptr
->wiphy
;
16757 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16758 struct sk_buff
*msg
;
16759 struct station_info empty_sinfo
= {};
16762 sinfo
= &empty_sinfo
;
16764 trace_cfg80211_del_sta(dev
, mac_addr
);
16766 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
16768 cfg80211_sinfo_release_content(sinfo
);
16772 if (nl80211_send_station(msg
, NL80211_CMD_DEL_STATION
, 0, 0, 0,
16773 rdev
, dev
, mac_addr
, sinfo
) < 0) {
16778 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16779 NL80211_MCGRP_MLME
, gfp
);
16781 EXPORT_SYMBOL(cfg80211_del_sta_sinfo
);
16783 void cfg80211_conn_failed(struct net_device
*dev
, const u8
*mac_addr
,
16784 enum nl80211_connect_failed_reason reason
,
16787 struct wiphy
*wiphy
= dev
->ieee80211_ptr
->wiphy
;
16788 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16789 struct sk_buff
*msg
;
16792 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
16796 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CONN_FAILED
);
16802 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
16803 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
) ||
16804 nla_put_u32(msg
, NL80211_ATTR_CONN_FAILED_REASON
, reason
))
16805 goto nla_put_failure
;
16807 genlmsg_end(msg
, hdr
);
16809 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16810 NL80211_MCGRP_MLME
, gfp
);
16816 EXPORT_SYMBOL(cfg80211_conn_failed
);
16818 static bool __nl80211_unexpected_frame(struct net_device
*dev
, u8 cmd
,
16819 const u8
*addr
, gfp_t gfp
)
16821 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
16822 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
16823 struct sk_buff
*msg
;
16825 u32 nlportid
= READ_ONCE(wdev
->ap_unexpected_nlportid
);
16830 msg
= nlmsg_new(100, gfp
);
16834 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
16840 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16841 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
16842 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
))
16843 goto nla_put_failure
;
16845 genlmsg_end(msg
, hdr
);
16846 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
16854 bool cfg80211_rx_spurious_frame(struct net_device
*dev
,
16855 const u8
*addr
, gfp_t gfp
)
16857 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
16860 trace_cfg80211_rx_spurious_frame(dev
, addr
);
16862 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_AP
&&
16863 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)) {
16864 trace_cfg80211_return_bool(false);
16867 ret
= __nl80211_unexpected_frame(dev
, NL80211_CMD_UNEXPECTED_FRAME
,
16869 trace_cfg80211_return_bool(ret
);
16872 EXPORT_SYMBOL(cfg80211_rx_spurious_frame
);
16874 bool cfg80211_rx_unexpected_4addr_frame(struct net_device
*dev
,
16875 const u8
*addr
, gfp_t gfp
)
16877 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
16880 trace_cfg80211_rx_unexpected_4addr_frame(dev
, addr
);
16882 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_AP
&&
16883 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
&&
16884 wdev
->iftype
!= NL80211_IFTYPE_AP_VLAN
)) {
16885 trace_cfg80211_return_bool(false);
16888 ret
= __nl80211_unexpected_frame(dev
,
16889 NL80211_CMD_UNEXPECTED_4ADDR_FRAME
,
16891 trace_cfg80211_return_bool(ret
);
16894 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame
);
16896 int nl80211_send_mgmt(struct cfg80211_registered_device
*rdev
,
16897 struct wireless_dev
*wdev
, u32 nlportid
,
16898 int freq
, int sig_dbm
,
16899 const u8
*buf
, size_t len
, u32 flags
, gfp_t gfp
)
16901 struct net_device
*netdev
= wdev
->netdev
;
16902 struct sk_buff
*msg
;
16905 msg
= nlmsg_new(100 + len
, gfp
);
16909 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME
);
16915 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16916 (netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
16917 netdev
->ifindex
)) ||
16918 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
16919 NL80211_ATTR_PAD
) ||
16920 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, KHZ_TO_MHZ(freq
)) ||
16921 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ_OFFSET
, freq
% 1000) ||
16923 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)) ||
16924 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
) ||
16926 nla_put_u32(msg
, NL80211_ATTR_RXMGMT_FLAGS
, flags
)))
16927 goto nla_put_failure
;
16929 genlmsg_end(msg
, hdr
);
16931 return genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
16938 static void nl80211_frame_tx_status(struct wireless_dev
*wdev
, u64 cookie
,
16939 const u8
*buf
, size_t len
, bool ack
,
16940 gfp_t gfp
, enum nl80211_commands command
)
16942 struct wiphy
*wiphy
= wdev
->wiphy
;
16943 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
16944 struct net_device
*netdev
= wdev
->netdev
;
16945 struct sk_buff
*msg
;
16948 if (command
== NL80211_CMD_FRAME_TX_STATUS
)
16949 trace_cfg80211_mgmt_tx_status(wdev
, cookie
, ack
);
16951 trace_cfg80211_control_port_tx_status(wdev
, cookie
, ack
);
16953 msg
= nlmsg_new(100 + len
, gfp
);
16957 hdr
= nl80211hdr_put(msg
, 0, 0, 0, command
);
16963 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
16964 (netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
16965 netdev
->ifindex
)) ||
16966 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
16967 NL80211_ATTR_PAD
) ||
16968 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
) ||
16969 nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
16970 NL80211_ATTR_PAD
) ||
16971 (ack
&& nla_put_flag(msg
, NL80211_ATTR_ACK
)))
16972 goto nla_put_failure
;
16974 genlmsg_end(msg
, hdr
);
16976 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
16977 NL80211_MCGRP_MLME
, gfp
);
16984 void cfg80211_control_port_tx_status(struct wireless_dev
*wdev
, u64 cookie
,
16985 const u8
*buf
, size_t len
, bool ack
,
16988 nl80211_frame_tx_status(wdev
, cookie
, buf
, len
, ack
, gfp
,
16989 NL80211_CMD_CONTROL_PORT_FRAME_TX_STATUS
);
16991 EXPORT_SYMBOL(cfg80211_control_port_tx_status
);
16993 void cfg80211_mgmt_tx_status(struct wireless_dev
*wdev
, u64 cookie
,
16994 const u8
*buf
, size_t len
, bool ack
, gfp_t gfp
)
16996 nl80211_frame_tx_status(wdev
, cookie
, buf
, len
, ack
, gfp
,
16997 NL80211_CMD_FRAME_TX_STATUS
);
16999 EXPORT_SYMBOL(cfg80211_mgmt_tx_status
);
17001 static int __nl80211_rx_control_port(struct net_device
*dev
,
17002 struct sk_buff
*skb
,
17003 bool unencrypted
, gfp_t gfp
)
17005 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17006 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17007 struct ethhdr
*ehdr
= eth_hdr(skb
);
17008 const u8
*addr
= ehdr
->h_source
;
17009 u16 proto
= be16_to_cpu(skb
->protocol
);
17010 struct sk_buff
*msg
;
17012 struct nlattr
*frame
;
17014 u32 nlportid
= READ_ONCE(wdev
->conn_owner_nlportid
);
17019 msg
= nlmsg_new(100 + skb
->len
, gfp
);
17023 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CONTROL_PORT_FRAME
);
17029 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17030 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
17031 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
17032 NL80211_ATTR_PAD
) ||
17033 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
) ||
17034 nla_put_u16(msg
, NL80211_ATTR_CONTROL_PORT_ETHERTYPE
, proto
) ||
17035 (unencrypted
&& nla_put_flag(msg
,
17036 NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
)))
17037 goto nla_put_failure
;
17039 frame
= nla_reserve(msg
, NL80211_ATTR_FRAME
, skb
->len
);
17041 goto nla_put_failure
;
17043 skb_copy_bits(skb
, 0, nla_data(frame
), skb
->len
);
17044 genlmsg_end(msg
, hdr
);
17046 return genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
17053 bool cfg80211_rx_control_port(struct net_device
*dev
,
17054 struct sk_buff
*skb
, bool unencrypted
)
17058 trace_cfg80211_rx_control_port(dev
, skb
, unencrypted
);
17059 ret
= __nl80211_rx_control_port(dev
, skb
, unencrypted
, GFP_ATOMIC
);
17060 trace_cfg80211_return_bool(ret
== 0);
17063 EXPORT_SYMBOL(cfg80211_rx_control_port
);
17065 static struct sk_buff
*cfg80211_prepare_cqm(struct net_device
*dev
,
17066 const char *mac
, gfp_t gfp
)
17068 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17069 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17070 struct sk_buff
*msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17076 cb
= (void **)msg
->cb
;
17078 cb
[0] = nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NOTIFY_CQM
);
17084 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17085 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
17086 goto nla_put_failure
;
17088 if (mac
&& nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac
))
17089 goto nla_put_failure
;
17091 cb
[1] = nla_nest_start_noflag(msg
, NL80211_ATTR_CQM
);
17093 goto nla_put_failure
;
17103 static void cfg80211_send_cqm(struct sk_buff
*msg
, gfp_t gfp
)
17105 void **cb
= (void **)msg
->cb
;
17106 struct cfg80211_registered_device
*rdev
= cb
[2];
17108 nla_nest_end(msg
, cb
[1]);
17109 genlmsg_end(msg
, cb
[0]);
17111 memset(msg
->cb
, 0, sizeof(msg
->cb
));
17113 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17114 NL80211_MCGRP_MLME
, gfp
);
17117 void cfg80211_cqm_rssi_notify(struct net_device
*dev
,
17118 enum nl80211_cqm_rssi_threshold_event rssi_event
,
17119 s32 rssi_level
, gfp_t gfp
)
17121 struct sk_buff
*msg
;
17122 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17123 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17125 trace_cfg80211_cqm_rssi_notify(dev
, rssi_event
, rssi_level
);
17127 if (WARN_ON(rssi_event
!= NL80211_CQM_RSSI_THRESHOLD_EVENT_LOW
&&
17128 rssi_event
!= NL80211_CQM_RSSI_THRESHOLD_EVENT_HIGH
))
17131 if (wdev
->cqm_config
) {
17132 wdev
->cqm_config
->last_rssi_event_value
= rssi_level
;
17134 cfg80211_cqm_rssi_update(rdev
, dev
);
17136 if (rssi_level
== 0)
17137 rssi_level
= wdev
->cqm_config
->last_rssi_event_value
;
17140 msg
= cfg80211_prepare_cqm(dev
, NULL
, gfp
);
17144 if (nla_put_u32(msg
, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
,
17146 goto nla_put_failure
;
17148 if (rssi_level
&& nla_put_s32(msg
, NL80211_ATTR_CQM_RSSI_LEVEL
,
17150 goto nla_put_failure
;
17152 cfg80211_send_cqm(msg
, gfp
);
17159 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify
);
17161 void cfg80211_cqm_txe_notify(struct net_device
*dev
,
17162 const u8
*peer
, u32 num_packets
,
17163 u32 rate
, u32 intvl
, gfp_t gfp
)
17165 struct sk_buff
*msg
;
17167 msg
= cfg80211_prepare_cqm(dev
, peer
, gfp
);
17171 if (nla_put_u32(msg
, NL80211_ATTR_CQM_TXE_PKTS
, num_packets
))
17172 goto nla_put_failure
;
17174 if (nla_put_u32(msg
, NL80211_ATTR_CQM_TXE_RATE
, rate
))
17175 goto nla_put_failure
;
17177 if (nla_put_u32(msg
, NL80211_ATTR_CQM_TXE_INTVL
, intvl
))
17178 goto nla_put_failure
;
17180 cfg80211_send_cqm(msg
, gfp
);
17186 EXPORT_SYMBOL(cfg80211_cqm_txe_notify
);
17188 void cfg80211_cqm_pktloss_notify(struct net_device
*dev
,
17189 const u8
*peer
, u32 num_packets
, gfp_t gfp
)
17191 struct sk_buff
*msg
;
17193 trace_cfg80211_cqm_pktloss_notify(dev
, peer
, num_packets
);
17195 msg
= cfg80211_prepare_cqm(dev
, peer
, gfp
);
17199 if (nla_put_u32(msg
, NL80211_ATTR_CQM_PKT_LOSS_EVENT
, num_packets
))
17200 goto nla_put_failure
;
17202 cfg80211_send_cqm(msg
, gfp
);
17208 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify
);
17210 void cfg80211_cqm_beacon_loss_notify(struct net_device
*dev
, gfp_t gfp
)
17212 struct sk_buff
*msg
;
17214 msg
= cfg80211_prepare_cqm(dev
, NULL
, gfp
);
17218 if (nla_put_flag(msg
, NL80211_ATTR_CQM_BEACON_LOSS_EVENT
))
17219 goto nla_put_failure
;
17221 cfg80211_send_cqm(msg
, gfp
);
17227 EXPORT_SYMBOL(cfg80211_cqm_beacon_loss_notify
);
17229 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device
*rdev
,
17230 struct net_device
*netdev
, const u8
*bssid
,
17231 const u8
*replay_ctr
, gfp_t gfp
)
17233 struct sk_buff
*msg
;
17234 struct nlattr
*rekey_attr
;
17237 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17241 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD
);
17247 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17248 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
17249 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
17250 goto nla_put_failure
;
17252 rekey_attr
= nla_nest_start_noflag(msg
, NL80211_ATTR_REKEY_DATA
);
17254 goto nla_put_failure
;
17256 if (nla_put(msg
, NL80211_REKEY_DATA_REPLAY_CTR
,
17257 NL80211_REPLAY_CTR_LEN
, replay_ctr
))
17258 goto nla_put_failure
;
17260 nla_nest_end(msg
, rekey_attr
);
17262 genlmsg_end(msg
, hdr
);
17264 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17265 NL80211_MCGRP_MLME
, gfp
);
17272 void cfg80211_gtk_rekey_notify(struct net_device
*dev
, const u8
*bssid
,
17273 const u8
*replay_ctr
, gfp_t gfp
)
17275 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17276 struct wiphy
*wiphy
= wdev
->wiphy
;
17277 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17279 trace_cfg80211_gtk_rekey_notify(dev
, bssid
);
17280 nl80211_gtk_rekey_notify(rdev
, dev
, bssid
, replay_ctr
, gfp
);
17282 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify
);
17285 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device
*rdev
,
17286 struct net_device
*netdev
, int index
,
17287 const u8
*bssid
, bool preauth
, gfp_t gfp
)
17289 struct sk_buff
*msg
;
17290 struct nlattr
*attr
;
17293 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17297 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE
);
17303 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17304 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
17305 goto nla_put_failure
;
17307 attr
= nla_nest_start_noflag(msg
, NL80211_ATTR_PMKSA_CANDIDATE
);
17309 goto nla_put_failure
;
17311 if (nla_put_u32(msg
, NL80211_PMKSA_CANDIDATE_INDEX
, index
) ||
17312 nla_put(msg
, NL80211_PMKSA_CANDIDATE_BSSID
, ETH_ALEN
, bssid
) ||
17314 nla_put_flag(msg
, NL80211_PMKSA_CANDIDATE_PREAUTH
)))
17315 goto nla_put_failure
;
17317 nla_nest_end(msg
, attr
);
17319 genlmsg_end(msg
, hdr
);
17321 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17322 NL80211_MCGRP_MLME
, gfp
);
17329 void cfg80211_pmksa_candidate_notify(struct net_device
*dev
, int index
,
17330 const u8
*bssid
, bool preauth
, gfp_t gfp
)
17332 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17333 struct wiphy
*wiphy
= wdev
->wiphy
;
17334 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17336 trace_cfg80211_pmksa_candidate_notify(dev
, index
, bssid
, preauth
);
17337 nl80211_pmksa_candidate_notify(rdev
, dev
, index
, bssid
, preauth
, gfp
);
17339 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify
);
17341 static void nl80211_ch_switch_notify(struct cfg80211_registered_device
*rdev
,
17342 struct net_device
*netdev
,
17343 struct cfg80211_chan_def
*chandef
,
17345 enum nl80211_commands notif
,
17346 u8 count
, bool quiet
)
17348 struct sk_buff
*msg
;
17351 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17355 hdr
= nl80211hdr_put(msg
, 0, 0, 0, notif
);
17361 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
17362 goto nla_put_failure
;
17364 if (nl80211_send_chandef(msg
, chandef
))
17365 goto nla_put_failure
;
17367 if (notif
== NL80211_CMD_CH_SWITCH_STARTED_NOTIFY
) {
17368 if (nla_put_u32(msg
, NL80211_ATTR_CH_SWITCH_COUNT
, count
))
17369 goto nla_put_failure
;
17371 nla_put_flag(msg
, NL80211_ATTR_CH_SWITCH_BLOCK_TX
))
17372 goto nla_put_failure
;
17375 genlmsg_end(msg
, hdr
);
17377 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17378 NL80211_MCGRP_MLME
, gfp
);
17385 void cfg80211_ch_switch_notify(struct net_device
*dev
,
17386 struct cfg80211_chan_def
*chandef
)
17388 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17389 struct wiphy
*wiphy
= wdev
->wiphy
;
17390 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17392 ASSERT_WDEV_LOCK(wdev
);
17394 trace_cfg80211_ch_switch_notify(dev
, chandef
);
17396 wdev
->chandef
= *chandef
;
17397 wdev
->preset_chandef
= *chandef
;
17399 if (wdev
->iftype
== NL80211_IFTYPE_STATION
&&
17400 !WARN_ON(!wdev
->current_bss
))
17401 cfg80211_update_assoc_bss_entry(wdev
, chandef
->chan
);
17403 cfg80211_sched_dfs_chan_update(rdev
);
17405 nl80211_ch_switch_notify(rdev
, dev
, chandef
, GFP_KERNEL
,
17406 NL80211_CMD_CH_SWITCH_NOTIFY
, 0, false);
17408 EXPORT_SYMBOL(cfg80211_ch_switch_notify
);
17410 void cfg80211_ch_switch_started_notify(struct net_device
*dev
,
17411 struct cfg80211_chan_def
*chandef
,
17412 u8 count
, bool quiet
)
17414 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17415 struct wiphy
*wiphy
= wdev
->wiphy
;
17416 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17418 trace_cfg80211_ch_switch_started_notify(dev
, chandef
);
17420 nl80211_ch_switch_notify(rdev
, dev
, chandef
, GFP_KERNEL
,
17421 NL80211_CMD_CH_SWITCH_STARTED_NOTIFY
,
17424 EXPORT_SYMBOL(cfg80211_ch_switch_started_notify
);
17427 nl80211_radar_notify(struct cfg80211_registered_device
*rdev
,
17428 const struct cfg80211_chan_def
*chandef
,
17429 enum nl80211_radar_event event
,
17430 struct net_device
*netdev
, gfp_t gfp
)
17432 struct sk_buff
*msg
;
17435 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17439 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_RADAR_DETECT
);
17445 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
))
17446 goto nla_put_failure
;
17448 /* NOP and radar events don't need a netdev parameter */
17450 struct wireless_dev
*wdev
= netdev
->ieee80211_ptr
;
17452 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
17453 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
17455 goto nla_put_failure
;
17458 if (nla_put_u32(msg
, NL80211_ATTR_RADAR_EVENT
, event
))
17459 goto nla_put_failure
;
17461 if (nl80211_send_chandef(msg
, chandef
))
17462 goto nla_put_failure
;
17464 genlmsg_end(msg
, hdr
);
17466 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17467 NL80211_MCGRP_MLME
, gfp
);
17474 void cfg80211_sta_opmode_change_notify(struct net_device
*dev
, const u8
*mac
,
17475 struct sta_opmode_info
*sta_opmode
,
17478 struct sk_buff
*msg
;
17479 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17480 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17486 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17490 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_STA_OPMODE_CHANGED
);
17496 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
))
17497 goto nla_put_failure
;
17499 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
17500 goto nla_put_failure
;
17502 if (nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac
))
17503 goto nla_put_failure
;
17505 if ((sta_opmode
->changed
& STA_OPMODE_SMPS_MODE_CHANGED
) &&
17506 nla_put_u8(msg
, NL80211_ATTR_SMPS_MODE
, sta_opmode
->smps_mode
))
17507 goto nla_put_failure
;
17509 if ((sta_opmode
->changed
& STA_OPMODE_MAX_BW_CHANGED
) &&
17510 nla_put_u32(msg
, NL80211_ATTR_CHANNEL_WIDTH
, sta_opmode
->bw
))
17511 goto nla_put_failure
;
17513 if ((sta_opmode
->changed
& STA_OPMODE_N_SS_CHANGED
) &&
17514 nla_put_u8(msg
, NL80211_ATTR_NSS
, sta_opmode
->rx_nss
))
17515 goto nla_put_failure
;
17517 genlmsg_end(msg
, hdr
);
17519 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17520 NL80211_MCGRP_MLME
, gfp
);
17527 EXPORT_SYMBOL(cfg80211_sta_opmode_change_notify
);
17529 void cfg80211_probe_status(struct net_device
*dev
, const u8
*addr
,
17530 u64 cookie
, bool acked
, s32 ack_signal
,
17531 bool is_valid_ack_signal
, gfp_t gfp
)
17533 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17534 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17535 struct sk_buff
*msg
;
17538 trace_cfg80211_probe_status(dev
, addr
, cookie
, acked
);
17540 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17545 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PROBE_CLIENT
);
17551 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17552 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
17553 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
) ||
17554 nla_put_u64_64bit(msg
, NL80211_ATTR_COOKIE
, cookie
,
17555 NL80211_ATTR_PAD
) ||
17556 (acked
&& nla_put_flag(msg
, NL80211_ATTR_ACK
)) ||
17557 (is_valid_ack_signal
&& nla_put_s32(msg
, NL80211_ATTR_ACK_SIGNAL
,
17559 goto nla_put_failure
;
17561 genlmsg_end(msg
, hdr
);
17563 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17564 NL80211_MCGRP_MLME
, gfp
);
17570 EXPORT_SYMBOL(cfg80211_probe_status
);
17572 void cfg80211_report_obss_beacon_khz(struct wiphy
*wiphy
, const u8
*frame
,
17573 size_t len
, int freq
, int sig_dbm
)
17575 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17576 struct sk_buff
*msg
;
17578 struct cfg80211_beacon_registration
*reg
;
17580 trace_cfg80211_report_obss_beacon(wiphy
, frame
, len
, freq
, sig_dbm
);
17582 spin_lock_bh(&rdev
->beacon_registrations_lock
);
17583 list_for_each_entry(reg
, &rdev
->beacon_registrations
, list
) {
17584 msg
= nlmsg_new(len
+ 100, GFP_ATOMIC
);
17586 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
17590 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME
);
17592 goto nla_put_failure
;
17594 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17596 (nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
,
17597 KHZ_TO_MHZ(freq
)) ||
17598 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ_OFFSET
,
17601 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)) ||
17602 nla_put(msg
, NL80211_ATTR_FRAME
, len
, frame
))
17603 goto nla_put_failure
;
17605 genlmsg_end(msg
, hdr
);
17607 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, reg
->nlportid
);
17609 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
17613 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
17616 EXPORT_SYMBOL(cfg80211_report_obss_beacon_khz
);
17619 static int cfg80211_net_detect_results(struct sk_buff
*msg
,
17620 struct cfg80211_wowlan_wakeup
*wakeup
)
17622 struct cfg80211_wowlan_nd_info
*nd
= wakeup
->net_detect
;
17623 struct nlattr
*nl_results
, *nl_match
, *nl_freqs
;
17626 nl_results
= nla_nest_start_noflag(msg
,
17627 NL80211_WOWLAN_TRIG_NET_DETECT_RESULTS
);
17631 for (i
= 0; i
< nd
->n_matches
; i
++) {
17632 struct cfg80211_wowlan_nd_match
*match
= nd
->matches
[i
];
17634 nl_match
= nla_nest_start_noflag(msg
, i
);
17638 /* The SSID attribute is optional in nl80211, but for
17639 * simplicity reasons it's always present in the
17640 * cfg80211 structure. If a driver can't pass the
17641 * SSID, that needs to be changed. A zero length SSID
17642 * is still a valid SSID (wildcard), so it cannot be
17643 * used for this purpose.
17645 if (nla_put(msg
, NL80211_ATTR_SSID
, match
->ssid
.ssid_len
,
17646 match
->ssid
.ssid
)) {
17647 nla_nest_cancel(msg
, nl_match
);
17651 if (match
->n_channels
) {
17652 nl_freqs
= nla_nest_start_noflag(msg
,
17653 NL80211_ATTR_SCAN_FREQUENCIES
);
17655 nla_nest_cancel(msg
, nl_match
);
17659 for (j
= 0; j
< match
->n_channels
; j
++) {
17660 if (nla_put_u32(msg
, j
, match
->channels
[j
])) {
17661 nla_nest_cancel(msg
, nl_freqs
);
17662 nla_nest_cancel(msg
, nl_match
);
17667 nla_nest_end(msg
, nl_freqs
);
17670 nla_nest_end(msg
, nl_match
);
17674 nla_nest_end(msg
, nl_results
);
17678 void cfg80211_report_wowlan_wakeup(struct wireless_dev
*wdev
,
17679 struct cfg80211_wowlan_wakeup
*wakeup
,
17682 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17683 struct sk_buff
*msg
;
17687 trace_cfg80211_report_wowlan_wakeup(wdev
->wiphy
, wdev
, wakeup
);
17690 size
+= wakeup
->packet_present_len
;
17692 msg
= nlmsg_new(size
, gfp
);
17696 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_SET_WOWLAN
);
17700 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17701 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
17705 if (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
17706 wdev
->netdev
->ifindex
))
17710 struct nlattr
*reasons
;
17712 reasons
= nla_nest_start_noflag(msg
,
17713 NL80211_ATTR_WOWLAN_TRIGGERS
);
17717 if (wakeup
->disconnect
&&
17718 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
))
17720 if (wakeup
->magic_pkt
&&
17721 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
))
17723 if (wakeup
->gtk_rekey_failure
&&
17724 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
))
17726 if (wakeup
->eap_identity_req
&&
17727 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
))
17729 if (wakeup
->four_way_handshake
&&
17730 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
))
17732 if (wakeup
->rfkill_release
&&
17733 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
))
17736 if (wakeup
->pattern_idx
>= 0 &&
17737 nla_put_u32(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
,
17738 wakeup
->pattern_idx
))
17741 if (wakeup
->tcp_match
&&
17742 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH
))
17745 if (wakeup
->tcp_connlost
&&
17746 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST
))
17749 if (wakeup
->tcp_nomoretokens
&&
17751 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS
))
17754 if (wakeup
->packet
) {
17755 u32 pkt_attr
= NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211
;
17756 u32 len_attr
= NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN
;
17758 if (!wakeup
->packet_80211
) {
17760 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023
;
17762 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN
;
17765 if (wakeup
->packet_len
&&
17766 nla_put_u32(msg
, len_attr
, wakeup
->packet_len
))
17769 if (nla_put(msg
, pkt_attr
, wakeup
->packet_present_len
,
17774 if (wakeup
->net_detect
&&
17775 cfg80211_net_detect_results(msg
, wakeup
))
17778 nla_nest_end(msg
, reasons
);
17781 genlmsg_end(msg
, hdr
);
17783 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17784 NL80211_MCGRP_MLME
, gfp
);
17790 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup
);
17793 void cfg80211_tdls_oper_request(struct net_device
*dev
, const u8
*peer
,
17794 enum nl80211_tdls_operation oper
,
17795 u16 reason_code
, gfp_t gfp
)
17797 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
17798 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
17799 struct sk_buff
*msg
;
17802 trace_cfg80211_tdls_oper_request(wdev
->wiphy
, dev
, peer
, oper
,
17805 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17809 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_TDLS_OPER
);
17815 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17816 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
17817 nla_put_u8(msg
, NL80211_ATTR_TDLS_OPERATION
, oper
) ||
17818 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, peer
) ||
17819 (reason_code
> 0 &&
17820 nla_put_u16(msg
, NL80211_ATTR_REASON_CODE
, reason_code
)))
17821 goto nla_put_failure
;
17823 genlmsg_end(msg
, hdr
);
17825 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17826 NL80211_MCGRP_MLME
, gfp
);
17832 EXPORT_SYMBOL(cfg80211_tdls_oper_request
);
17834 static int nl80211_netlink_notify(struct notifier_block
* nb
,
17835 unsigned long state
,
17838 struct netlink_notify
*notify
= _notify
;
17839 struct cfg80211_registered_device
*rdev
;
17840 struct wireless_dev
*wdev
;
17841 struct cfg80211_beacon_registration
*reg
, *tmp
;
17843 if (state
!= NETLINK_URELEASE
|| notify
->protocol
!= NETLINK_GENERIC
)
17844 return NOTIFY_DONE
;
17848 list_for_each_entry_rcu(rdev
, &cfg80211_rdev_list
, list
) {
17849 struct cfg80211_sched_scan_request
*sched_scan_req
;
17851 list_for_each_entry_rcu(sched_scan_req
,
17852 &rdev
->sched_scan_req_list
,
17854 if (sched_scan_req
->owner_nlportid
== notify
->portid
) {
17855 sched_scan_req
->nl_owner_dead
= true;
17856 schedule_work(&rdev
->sched_scan_stop_wk
);
17860 list_for_each_entry_rcu(wdev
, &rdev
->wiphy
.wdev_list
, list
) {
17861 cfg80211_mlme_unregister_socket(wdev
, notify
->portid
);
17863 if (wdev
->owner_nlportid
== notify
->portid
) {
17864 wdev
->nl_owner_dead
= true;
17865 schedule_work(&rdev
->destroy_work
);
17866 } else if (wdev
->conn_owner_nlportid
== notify
->portid
) {
17867 schedule_work(&wdev
->disconnect_wk
);
17870 cfg80211_release_pmsr(wdev
, notify
->portid
);
17873 spin_lock_bh(&rdev
->beacon_registrations_lock
);
17874 list_for_each_entry_safe(reg
, tmp
, &rdev
->beacon_registrations
,
17876 if (reg
->nlportid
== notify
->portid
) {
17877 list_del(®
->list
);
17882 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
17888 * It is possible that the user space process that is controlling the
17889 * indoor setting disappeared, so notify the regulatory core.
17891 regulatory_netlink_notify(notify
->portid
);
17895 static struct notifier_block nl80211_netlink_notifier
= {
17896 .notifier_call
= nl80211_netlink_notify
,
17899 void cfg80211_ft_event(struct net_device
*netdev
,
17900 struct cfg80211_ft_event_params
*ft_event
)
17902 struct wiphy
*wiphy
= netdev
->ieee80211_ptr
->wiphy
;
17903 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17904 struct sk_buff
*msg
;
17907 trace_cfg80211_ft_event(wiphy
, netdev
, ft_event
);
17909 if (!ft_event
->target_ap
)
17912 msg
= nlmsg_new(100 + ft_event
->ies_len
+ ft_event
->ric_ies_len
,
17917 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FT_EVENT
);
17921 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17922 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
17923 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, ft_event
->target_ap
))
17926 if (ft_event
->ies
&&
17927 nla_put(msg
, NL80211_ATTR_IE
, ft_event
->ies_len
, ft_event
->ies
))
17929 if (ft_event
->ric_ies
&&
17930 nla_put(msg
, NL80211_ATTR_IE_RIC
, ft_event
->ric_ies_len
,
17931 ft_event
->ric_ies
))
17934 genlmsg_end(msg
, hdr
);
17936 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
17937 NL80211_MCGRP_MLME
, GFP_KERNEL
);
17942 EXPORT_SYMBOL(cfg80211_ft_event
);
17944 void cfg80211_crit_proto_stopped(struct wireless_dev
*wdev
, gfp_t gfp
)
17946 struct cfg80211_registered_device
*rdev
;
17947 struct sk_buff
*msg
;
17951 rdev
= wiphy_to_rdev(wdev
->wiphy
);
17952 if (!rdev
->crit_proto_nlportid
)
17955 nlportid
= rdev
->crit_proto_nlportid
;
17956 rdev
->crit_proto_nlportid
= 0;
17958 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
17962 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP
);
17964 goto nla_put_failure
;
17966 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17967 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
17969 goto nla_put_failure
;
17971 genlmsg_end(msg
, hdr
);
17973 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
17979 EXPORT_SYMBOL(cfg80211_crit_proto_stopped
);
17981 void nl80211_send_ap_stopped(struct wireless_dev
*wdev
)
17983 struct wiphy
*wiphy
= wdev
->wiphy
;
17984 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
17985 struct sk_buff
*msg
;
17988 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
17992 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_STOP_AP
);
17996 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
17997 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, wdev
->netdev
->ifindex
) ||
17998 nla_put_u64_64bit(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
),
18002 genlmsg_end(msg
, hdr
);
18004 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(wiphy
), msg
, 0,
18005 NL80211_MCGRP_MLME
, GFP_KERNEL
);
18011 int cfg80211_external_auth_request(struct net_device
*dev
,
18012 struct cfg80211_external_auth_params
*params
,
18015 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
18016 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wdev
->wiphy
);
18017 struct sk_buff
*msg
;
18020 if (!wdev
->conn_owner_nlportid
)
18023 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
18027 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_EXTERNAL_AUTH
);
18029 goto nla_put_failure
;
18031 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
18032 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
18033 nla_put_u32(msg
, NL80211_ATTR_AKM_SUITES
, params
->key_mgmt_suite
) ||
18034 nla_put_u32(msg
, NL80211_ATTR_EXTERNAL_AUTH_ACTION
,
18036 nla_put(msg
, NL80211_ATTR_BSSID
, ETH_ALEN
, params
->bssid
) ||
18037 nla_put(msg
, NL80211_ATTR_SSID
, params
->ssid
.ssid_len
,
18038 params
->ssid
.ssid
))
18039 goto nla_put_failure
;
18041 genlmsg_end(msg
, hdr
);
18042 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
,
18043 wdev
->conn_owner_nlportid
);
18050 EXPORT_SYMBOL(cfg80211_external_auth_request
);
18052 void cfg80211_update_owe_info_event(struct net_device
*netdev
,
18053 struct cfg80211_update_owe_info
*owe_info
,
18056 struct wiphy
*wiphy
= netdev
->ieee80211_ptr
->wiphy
;
18057 struct cfg80211_registered_device
*rdev
= wiphy_to_rdev(wiphy
);
18058 struct sk_buff
*msg
;
18061 trace_cfg80211_update_owe_info_event(wiphy
, netdev
, owe_info
);
18063 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
18067 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_UPDATE_OWE_INFO
);
18069 goto nla_put_failure
;
18071 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
18072 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
18073 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, owe_info
->peer
))
18074 goto nla_put_failure
;
18076 if (!owe_info
->ie_len
||
18077 nla_put(msg
, NL80211_ATTR_IE
, owe_info
->ie_len
, owe_info
->ie
))
18078 goto nla_put_failure
;
18080 genlmsg_end(msg
, hdr
);
18082 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
18083 NL80211_MCGRP_MLME
, gfp
);
18087 genlmsg_cancel(msg
, hdr
);
18090 EXPORT_SYMBOL(cfg80211_update_owe_info_event
);
18092 /* initialisation/exit functions */
18094 int __init
nl80211_init(void)
18098 err
= genl_register_family(&nl80211_fam
);
18102 err
= netlink_register_notifier(&nl80211_netlink_notifier
);
18108 genl_unregister_family(&nl80211_fam
);
18112 void nl80211_exit(void)
18114 netlink_unregister_notifier(&nl80211_netlink_notifier
);
18115 genl_unregister_family(&nl80211_fam
);