2 * This is the new netlink-based wireless configuration interface.
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
8 #include <linux/module.h>
10 #include <linux/slab.h>
11 #include <linux/list.h>
12 #include <linux/if_ether.h>
13 #include <linux/ieee80211.h>
14 #include <linux/nl80211.h>
15 #include <linux/rtnetlink.h>
16 #include <linux/netlink.h>
17 #include <linux/etherdevice.h>
18 #include <net/net_namespace.h>
19 #include <net/genetlink.h>
20 #include <net/cfg80211.h>
22 #include <net/inet_connection_sock.h>
28 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
29 struct genl_info *info,
30 struct cfg80211_crypto_settings *settings,
33 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
34 struct genl_info *info);
35 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
36 struct genl_info *info);
38 /* the netlink family */
39 static struct genl_family nl80211_fam = {
40 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
41 .name = "nl80211", /* have users key off the name instead */
42 .hdrsize = 0, /* no private header */
43 .version = 1, /* no particular meaning now */
44 .maxattr = NL80211_ATTR_MAX,
46 .pre_doit = nl80211_pre_doit,
47 .post_doit = nl80211_post_doit,
50 /* returns ERR_PTR values */
51 static struct wireless_dev *
52 __cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
54 struct cfg80211_registered_device *rdev;
55 struct wireless_dev *result = NULL;
56 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
57 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
62 assert_cfg80211_lock();
64 if (!have_ifidx && !have_wdev_id)
65 return ERR_PTR(-EINVAL);
68 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
70 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
71 wiphy_idx = wdev_id >> 32;
74 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
75 struct wireless_dev *wdev;
77 if (wiphy_net(&rdev->wiphy) != netns)
80 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
83 mutex_lock(&rdev->devlist_mtx);
84 list_for_each_entry(wdev, &rdev->wdev_list, list) {
85 if (have_ifidx && wdev->netdev &&
86 wdev->netdev->ifindex == ifidx) {
90 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
95 mutex_unlock(&rdev->devlist_mtx);
103 return ERR_PTR(-ENODEV);
106 static struct cfg80211_registered_device *
107 __cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
109 struct cfg80211_registered_device *rdev = NULL, *tmp;
110 struct net_device *netdev;
112 assert_cfg80211_lock();
114 if (!attrs[NL80211_ATTR_WIPHY] &&
115 !attrs[NL80211_ATTR_IFINDEX] &&
116 !attrs[NL80211_ATTR_WDEV])
117 return ERR_PTR(-EINVAL);
119 if (attrs[NL80211_ATTR_WIPHY])
120 rdev = cfg80211_rdev_by_wiphy_idx(
121 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
123 if (attrs[NL80211_ATTR_WDEV]) {
124 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
125 struct wireless_dev *wdev;
128 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
130 /* make sure wdev exists */
131 mutex_lock(&tmp->devlist_mtx);
132 list_for_each_entry(wdev, &tmp->wdev_list, list) {
133 if (wdev->identifier != (u32)wdev_id)
138 mutex_unlock(&tmp->devlist_mtx);
143 if (rdev && tmp != rdev)
144 return ERR_PTR(-EINVAL);
149 if (attrs[NL80211_ATTR_IFINDEX]) {
150 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
151 netdev = dev_get_by_index(netns, ifindex);
153 if (netdev->ieee80211_ptr)
155 netdev->ieee80211_ptr->wiphy);
161 /* not wireless device -- return error */
163 return ERR_PTR(-EINVAL);
165 /* mismatch -- return error */
166 if (rdev && tmp != rdev)
167 return ERR_PTR(-EINVAL);
174 return ERR_PTR(-ENODEV);
176 if (netns != wiphy_net(&rdev->wiphy))
177 return ERR_PTR(-ENODEV);
183 * This function returns a pointer to the driver
184 * that the genl_info item that is passed refers to.
185 * If successful, it returns non-NULL and also locks
186 * the driver's mutex!
188 * This means that you need to call cfg80211_unlock_rdev()
189 * before being allowed to acquire &cfg80211_mutex!
191 * This is necessary because we need to lock the global
192 * mutex to get an item off the list safely, and then
193 * we lock the rdev mutex so it doesn't go away under us.
195 * We don't want to keep cfg80211_mutex locked
196 * for all the time in order to allow requests on
197 * other interfaces to go through at the same time.
199 * The result of this can be a PTR_ERR and hence must
200 * be checked with IS_ERR() for errors.
202 static struct cfg80211_registered_device *
203 cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
205 struct cfg80211_registered_device *rdev;
207 mutex_lock(&cfg80211_mutex);
208 rdev = __cfg80211_rdev_from_attrs(netns, info->attrs);
210 /* if it is not an error we grab the lock on
211 * it to assure it won't be going away while
212 * we operate on it */
214 mutex_lock(&rdev->mtx);
216 mutex_unlock(&cfg80211_mutex);
221 /* policy for the attributes */
222 static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
223 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
224 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
226 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
228 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
229 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
230 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
231 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
232 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
234 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
235 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
236 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
237 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
238 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
240 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
241 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
242 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
244 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
245 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
247 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
248 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
249 .len = WLAN_MAX_KEY_LEN },
250 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
251 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
252 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
253 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
254 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
256 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
257 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
258 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
259 .len = IEEE80211_MAX_DATA_LEN },
260 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
261 .len = IEEE80211_MAX_DATA_LEN },
262 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
263 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
264 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
265 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
266 .len = NL80211_MAX_SUPP_RATES },
267 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
268 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
269 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
270 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
271 .len = IEEE80211_MAX_MESH_ID_LEN },
272 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
274 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
275 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
277 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
278 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
279 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
280 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
281 .len = NL80211_MAX_SUPP_RATES },
282 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
284 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
285 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
287 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
289 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
290 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
291 .len = IEEE80211_MAX_DATA_LEN },
292 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
293 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
295 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
296 .len = IEEE80211_MAX_SSID_LEN },
297 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
298 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
299 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
300 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
301 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
302 [NL80211_ATTR_STA_FLAGS2] = {
303 .len = sizeof(struct nl80211_sta_flag_update),
305 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
306 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
307 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
308 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
309 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
310 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
311 [NL80211_ATTR_PID] = { .type = NLA_U32 },
312 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
313 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
314 .len = WLAN_PMKID_LEN },
315 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
316 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
317 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
318 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
319 .len = IEEE80211_MAX_DATA_LEN },
320 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
321 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
322 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
323 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
324 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
325 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
326 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
327 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
328 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
329 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
330 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
331 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
332 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
333 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
334 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
335 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
336 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
337 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
338 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
339 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
340 .len = IEEE80211_MAX_DATA_LEN },
341 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
342 .len = IEEE80211_MAX_DATA_LEN },
343 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
344 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
345 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
346 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
347 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
348 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
349 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
350 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
351 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
352 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
353 .len = IEEE80211_MAX_DATA_LEN },
354 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
355 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
356 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
357 .len = NL80211_HT_CAPABILITY_LEN
359 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
360 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
361 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
362 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
363 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
364 [NL80211_ATTR_SAE_DATA] = { .type = NLA_BINARY, },
365 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
366 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
367 [NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
368 [NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
369 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
370 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
371 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
372 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
373 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
374 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
375 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
376 .len = NL80211_VHT_CAPABILITY_LEN,
378 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
379 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
380 .len = IEEE80211_MAX_DATA_LEN },
383 /* policy for the key attributes */
384 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
385 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
386 [NL80211_KEY_IDX] = { .type = NLA_U8 },
387 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
388 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
389 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
390 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
391 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
392 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
395 /* policy for the key default flags */
396 static const struct nla_policy
397 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
398 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
399 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
402 /* policy for WoWLAN attributes */
403 static const struct nla_policy
404 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
405 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
406 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
407 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
408 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
409 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
410 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
411 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
412 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
413 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
416 static const struct nla_policy
417 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
418 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
419 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
420 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
421 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
422 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
423 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
424 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
425 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
427 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
428 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
430 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
431 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
432 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
435 /* policy for GTK rekey offload attributes */
436 static const struct nla_policy
437 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
438 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
439 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
440 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
443 static const struct nla_policy
444 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
445 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
446 .len = IEEE80211_MAX_SSID_LEN },
447 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
450 static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
451 struct netlink_callback *cb,
452 struct cfg80211_registered_device **rdev,
453 struct wireless_dev **wdev)
458 mutex_lock(&cfg80211_mutex);
461 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
462 nl80211_fam.attrbuf, nl80211_fam.maxattr,
467 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk),
468 nl80211_fam.attrbuf);
470 err = PTR_ERR(*wdev);
473 *rdev = wiphy_to_dev((*wdev)->wiphy);
474 /* 0 is the first index - add 1 to parse only once */
475 cb->args[0] = (*rdev)->wiphy_idx + 1;
476 cb->args[1] = (*wdev)->identifier;
478 /* subtract the 1 again here */
479 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
480 struct wireless_dev *tmp;
486 *rdev = wiphy_to_dev(wiphy);
489 mutex_lock(&(*rdev)->devlist_mtx);
490 list_for_each_entry(tmp, &(*rdev)->wdev_list, list) {
491 if (tmp->identifier == cb->args[1]) {
496 mutex_unlock(&(*rdev)->devlist_mtx);
504 cfg80211_lock_rdev(*rdev);
506 mutex_unlock(&cfg80211_mutex);
509 mutex_unlock(&cfg80211_mutex);
514 static void nl80211_finish_wdev_dump(struct cfg80211_registered_device *rdev)
516 cfg80211_unlock_rdev(rdev);
521 static bool is_valid_ie_attr(const struct nlattr *attr)
529 pos = nla_data(attr);
550 /* message building helper */
551 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
554 /* since there is no private header just add the generic one */
555 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
558 static int nl80211_msg_put_channel(struct sk_buff *msg,
559 struct ieee80211_channel *chan,
562 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
564 goto nla_put_failure;
566 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
567 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
568 goto nla_put_failure;
569 if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
570 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN))
571 goto nla_put_failure;
572 if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
573 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
574 goto nla_put_failure;
575 if (chan->flags & IEEE80211_CHAN_RADAR) {
576 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
577 goto nla_put_failure;
581 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
583 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
585 goto nla_put_failure;
586 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
588 goto nla_put_failure;
593 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
594 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
595 goto nla_put_failure;
596 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
597 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
598 goto nla_put_failure;
599 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
600 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
601 goto nla_put_failure;
602 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
603 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
604 goto nla_put_failure;
607 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
608 DBM_TO_MBM(chan->max_power)))
609 goto nla_put_failure;
617 /* netlink command implementations */
624 bool def_uni, def_multi;
627 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
629 struct nlattr *tb[NL80211_KEY_MAX + 1];
630 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
635 k->def = !!tb[NL80211_KEY_DEFAULT];
636 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
645 if (tb[NL80211_KEY_IDX])
646 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
648 if (tb[NL80211_KEY_DATA]) {
649 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
650 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
653 if (tb[NL80211_KEY_SEQ]) {
654 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
655 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
658 if (tb[NL80211_KEY_CIPHER])
659 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
661 if (tb[NL80211_KEY_TYPE]) {
662 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
663 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
667 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
668 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
669 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
670 tb[NL80211_KEY_DEFAULT_TYPES],
671 nl80211_key_default_policy);
675 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
676 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
682 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
684 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
685 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
686 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
689 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
690 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
691 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
694 if (info->attrs[NL80211_ATTR_KEY_IDX])
695 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
697 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
698 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
700 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
701 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
710 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
711 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
712 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
716 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
717 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
718 int err = nla_parse_nested(
719 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
720 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
721 nl80211_key_default_policy);
725 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
726 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
732 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
736 memset(k, 0, sizeof(*k));
740 if (info->attrs[NL80211_ATTR_KEY])
741 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
743 err = nl80211_parse_key_old(info, k);
748 if (k->def && k->defmgmt)
752 if (k->def_uni || !k->def_multi)
758 if (k->idx < 4 || k->idx > 5)
761 if (k->idx < 0 || k->idx > 3)
764 if (k->idx < 0 || k->idx > 5)
772 static struct cfg80211_cached_keys *
773 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
774 struct nlattr *keys, bool *no_ht)
776 struct key_parse parse;
778 struct cfg80211_cached_keys *result;
779 int rem, err, def = 0;
781 result = kzalloc(sizeof(*result), GFP_KERNEL);
783 return ERR_PTR(-ENOMEM);
786 result->defmgmt = -1;
788 nla_for_each_nested(key, keys, rem) {
789 memset(&parse, 0, sizeof(parse));
792 err = nl80211_parse_key_new(key, &parse);
798 if (parse.idx < 0 || parse.idx > 4)
804 result->def = parse.idx;
805 if (!parse.def_uni || !parse.def_multi)
807 } else if (parse.defmgmt)
809 err = cfg80211_validate_key_settings(rdev, &parse.p,
810 parse.idx, false, NULL);
813 result->params[parse.idx].cipher = parse.p.cipher;
814 result->params[parse.idx].key_len = parse.p.key_len;
815 result->params[parse.idx].key = result->data[parse.idx];
816 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
818 if (parse.p.cipher == WLAN_CIPHER_SUITE_WEP40 ||
819 parse.p.cipher == WLAN_CIPHER_SUITE_WEP104) {
831 static int nl80211_key_allowed(struct wireless_dev *wdev)
833 ASSERT_WDEV_LOCK(wdev);
835 switch (wdev->iftype) {
836 case NL80211_IFTYPE_AP:
837 case NL80211_IFTYPE_AP_VLAN:
838 case NL80211_IFTYPE_P2P_GO:
839 case NL80211_IFTYPE_MESH_POINT:
841 case NL80211_IFTYPE_ADHOC:
842 if (!wdev->current_bss)
845 case NL80211_IFTYPE_STATION:
846 case NL80211_IFTYPE_P2P_CLIENT:
847 if (wdev->sme_state != CFG80211_SME_CONNECTED)
857 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
859 struct nlattr *nl_modes = nla_nest_start(msg, attr);
863 goto nla_put_failure;
867 if ((ifmodes & 1) && nla_put_flag(msg, i))
868 goto nla_put_failure;
873 nla_nest_end(msg, nl_modes);
880 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
884 struct nlattr *nl_combis;
887 nl_combis = nla_nest_start(msg,
888 NL80211_ATTR_INTERFACE_COMBINATIONS);
890 goto nla_put_failure;
892 for (i = 0; i < wiphy->n_iface_combinations; i++) {
893 const struct ieee80211_iface_combination *c;
894 struct nlattr *nl_combi, *nl_limits;
896 c = &wiphy->iface_combinations[i];
898 nl_combi = nla_nest_start(msg, i + 1);
900 goto nla_put_failure;
902 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
904 goto nla_put_failure;
906 for (j = 0; j < c->n_limits; j++) {
907 struct nlattr *nl_limit;
909 nl_limit = nla_nest_start(msg, j + 1);
911 goto nla_put_failure;
912 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
914 goto nla_put_failure;
915 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
917 goto nla_put_failure;
918 nla_nest_end(msg, nl_limit);
921 nla_nest_end(msg, nl_limits);
923 if (c->beacon_int_infra_match &&
924 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
925 goto nla_put_failure;
926 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
927 c->num_different_channels) ||
928 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
930 goto nla_put_failure;
932 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
933 c->radar_detect_widths))
934 goto nla_put_failure;
936 nla_nest_end(msg, nl_combi);
939 nla_nest_end(msg, nl_combis);
947 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
950 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan.tcp;
951 struct nlattr *nl_tcp;
956 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
960 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
961 tcp->data_payload_max))
964 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
965 tcp->data_payload_max))
968 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
971 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
972 sizeof(*tcp->tok), tcp->tok))
975 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
976 tcp->data_interval_max))
979 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
980 tcp->wake_payload_max))
983 nla_nest_end(msg, nl_tcp);
987 static int nl80211_send_wowlan(struct sk_buff *msg,
988 struct cfg80211_registered_device *dev,
991 struct nlattr *nl_wowlan;
993 if (!dev->wiphy.wowlan.flags && !dev->wiphy.wowlan.n_patterns)
996 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1000 if (((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_ANY) &&
1001 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1002 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_DISCONNECT) &&
1003 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1004 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1005 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1006 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1007 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1008 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1009 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1010 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1011 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1012 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1013 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1014 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1015 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1018 if (dev->wiphy.wowlan.n_patterns) {
1019 struct nl80211_wowlan_pattern_support pat = {
1020 .max_patterns = dev->wiphy.wowlan.n_patterns,
1021 .min_pattern_len = dev->wiphy.wowlan.pattern_min_len,
1022 .max_pattern_len = dev->wiphy.wowlan.pattern_max_len,
1023 .max_pkt_offset = dev->wiphy.wowlan.max_pkt_offset,
1026 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1031 if (large && nl80211_send_wowlan_tcp_caps(dev, msg))
1034 nla_nest_end(msg, nl_wowlan);
1040 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1041 struct ieee80211_supported_band *sband)
1043 struct nlattr *nl_rates, *nl_rate;
1044 struct ieee80211_rate *rate;
1048 if (sband->ht_cap.ht_supported &&
1049 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1050 sizeof(sband->ht_cap.mcs),
1051 &sband->ht_cap.mcs) ||
1052 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1053 sband->ht_cap.cap) ||
1054 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1055 sband->ht_cap.ampdu_factor) ||
1056 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1057 sband->ht_cap.ampdu_density)))
1061 if (sband->vht_cap.vht_supported &&
1062 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1063 sizeof(sband->vht_cap.vht_mcs),
1064 &sband->vht_cap.vht_mcs) ||
1065 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1066 sband->vht_cap.cap)))
1070 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1074 for (i = 0; i < sband->n_bitrates; i++) {
1075 nl_rate = nla_nest_start(msg, i);
1079 rate = &sband->bitrates[i];
1080 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1083 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1085 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1088 nla_nest_end(msg, nl_rate);
1091 nla_nest_end(msg, nl_rates);
1097 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1098 const struct ieee80211_txrx_stypes *mgmt_stypes)
1101 struct nlattr *nl_ftypes, *nl_ifs;
1102 enum nl80211_iftype ift;
1108 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1112 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1113 nl_ftypes = nla_nest_start(msg, ift);
1117 stypes = mgmt_stypes[ift].tx;
1120 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1121 (i << 4) | IEEE80211_FTYPE_MGMT))
1126 nla_nest_end(msg, nl_ftypes);
1129 nla_nest_end(msg, nl_ifs);
1131 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1135 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1136 nl_ftypes = nla_nest_start(msg, ift);
1140 stypes = mgmt_stypes[ift].rx;
1143 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1144 (i << 4) | IEEE80211_FTYPE_MGMT))
1149 nla_nest_end(msg, nl_ftypes);
1151 nla_nest_end(msg, nl_ifs);
1156 static int nl80211_send_wiphy(struct cfg80211_registered_device *dev,
1157 struct sk_buff *msg, u32 portid, u32 seq,
1158 int flags, bool split, long *split_start,
1159 long *band_start, long *chan_start)
1162 struct nlattr *nl_bands, *nl_band;
1163 struct nlattr *nl_freqs, *nl_freq;
1164 struct nlattr *nl_cmds;
1165 enum ieee80211_band band;
1166 struct ieee80211_channel *chan;
1168 const struct ieee80211_txrx_stypes *mgmt_stypes =
1169 dev->wiphy.mgmt_stypes;
1170 long start = 0, start_chan = 0, start_band = 0;
1173 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_WIPHY);
1177 /* allow always using the variables */
1179 split_start = &start;
1180 band_start = &start_band;
1181 chan_start = &start_chan;
1184 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx) ||
1185 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1186 wiphy_name(&dev->wiphy)) ||
1187 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1188 cfg80211_rdev_list_generation))
1189 goto nla_put_failure;
1191 switch (*split_start) {
1193 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1194 dev->wiphy.retry_short) ||
1195 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1196 dev->wiphy.retry_long) ||
1197 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1198 dev->wiphy.frag_threshold) ||
1199 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1200 dev->wiphy.rts_threshold) ||
1201 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1202 dev->wiphy.coverage_class) ||
1203 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1204 dev->wiphy.max_scan_ssids) ||
1205 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1206 dev->wiphy.max_sched_scan_ssids) ||
1207 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1208 dev->wiphy.max_scan_ie_len) ||
1209 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1210 dev->wiphy.max_sched_scan_ie_len) ||
1211 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
1212 dev->wiphy.max_match_sets))
1213 goto nla_put_failure;
1215 if ((dev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
1216 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
1217 goto nla_put_failure;
1218 if ((dev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
1219 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1220 goto nla_put_failure;
1221 if ((dev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
1222 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1223 goto nla_put_failure;
1224 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
1225 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1226 goto nla_put_failure;
1227 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
1228 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1229 goto nla_put_failure;
1230 if ((dev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
1231 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
1232 goto nla_put_failure;
1238 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1239 sizeof(u32) * dev->wiphy.n_cipher_suites,
1240 dev->wiphy.cipher_suites))
1241 goto nla_put_failure;
1243 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1244 dev->wiphy.max_num_pmkids))
1245 goto nla_put_failure;
1247 if ((dev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
1248 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
1249 goto nla_put_failure;
1251 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1252 dev->wiphy.available_antennas_tx) ||
1253 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1254 dev->wiphy.available_antennas_rx))
1255 goto nla_put_failure;
1257 if ((dev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
1258 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1259 dev->wiphy.probe_resp_offload))
1260 goto nla_put_failure;
1262 if ((dev->wiphy.available_antennas_tx ||
1263 dev->wiphy.available_antennas_rx) &&
1264 dev->ops->get_antenna) {
1265 u32 tx_ant = 0, rx_ant = 0;
1267 res = rdev_get_antenna(dev, &tx_ant, &rx_ant);
1269 if (nla_put_u32(msg,
1270 NL80211_ATTR_WIPHY_ANTENNA_TX,
1273 NL80211_ATTR_WIPHY_ANTENNA_RX,
1275 goto nla_put_failure;
1283 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1284 dev->wiphy.interface_modes))
1285 goto nla_put_failure;
1290 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1292 goto nla_put_failure;
1294 for (band = *band_start; band < IEEE80211_NUM_BANDS; band++) {
1295 struct ieee80211_supported_band *sband;
1297 sband = dev->wiphy.bands[band];
1302 nl_band = nla_nest_start(msg, band);
1304 goto nla_put_failure;
1306 switch (*chan_start) {
1308 if (nl80211_send_band_rateinfo(msg, sband))
1309 goto nla_put_failure;
1314 /* add frequencies */
1315 nl_freqs = nla_nest_start(
1316 msg, NL80211_BAND_ATTR_FREQS);
1318 goto nla_put_failure;
1320 for (i = *chan_start - 1;
1321 i < sband->n_channels;
1323 nl_freq = nla_nest_start(msg, i);
1325 goto nla_put_failure;
1327 chan = &sband->channels[i];
1329 if (nl80211_msg_put_channel(msg, chan,
1331 goto nla_put_failure;
1333 nla_nest_end(msg, nl_freq);
1337 if (i < sband->n_channels)
1338 *chan_start = i + 2;
1341 nla_nest_end(msg, nl_freqs);
1344 nla_nest_end(msg, nl_band);
1347 /* start again here */
1353 nla_nest_end(msg, nl_bands);
1355 if (band < IEEE80211_NUM_BANDS)
1356 *band_start = band + 1;
1360 /* if bands & channels are done, continue outside */
1361 if (*band_start == 0 && *chan_start == 0)
1366 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1368 goto nla_put_failure;
1371 #define CMD(op, n) \
1373 if (dev->ops->op) { \
1375 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1376 goto nla_put_failure; \
1380 CMD(add_virtual_intf, NEW_INTERFACE);
1381 CMD(change_virtual_intf, SET_INTERFACE);
1382 CMD(add_key, NEW_KEY);
1383 CMD(start_ap, START_AP);
1384 CMD(add_station, NEW_STATION);
1385 CMD(add_mpath, NEW_MPATH);
1386 CMD(update_mesh_config, SET_MESH_CONFIG);
1387 CMD(change_bss, SET_BSS);
1388 CMD(auth, AUTHENTICATE);
1389 CMD(assoc, ASSOCIATE);
1390 CMD(deauth, DEAUTHENTICATE);
1391 CMD(disassoc, DISASSOCIATE);
1392 CMD(join_ibss, JOIN_IBSS);
1393 CMD(join_mesh, JOIN_MESH);
1394 CMD(set_pmksa, SET_PMKSA);
1395 CMD(del_pmksa, DEL_PMKSA);
1396 CMD(flush_pmksa, FLUSH_PMKSA);
1397 if (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1398 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1399 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1400 CMD(mgmt_tx, FRAME);
1401 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1402 if (dev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1404 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1405 goto nla_put_failure;
1407 if (dev->ops->set_monitor_channel || dev->ops->start_ap ||
1408 dev->ops->join_mesh) {
1410 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1411 goto nla_put_failure;
1413 CMD(set_wds_peer, SET_WDS_PEER);
1414 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1415 CMD(tdls_mgmt, TDLS_MGMT);
1416 CMD(tdls_oper, TDLS_OPER);
1418 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
1419 CMD(sched_scan_start, START_SCHED_SCAN);
1420 CMD(probe_client, PROBE_CLIENT);
1421 CMD(set_noack_map, SET_NOACK_MAP);
1422 if (dev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1424 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1425 goto nla_put_failure;
1427 CMD(start_p2p_device, START_P2P_DEVICE);
1428 CMD(set_mcast_rate, SET_MCAST_RATE);
1430 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1431 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1434 #ifdef CONFIG_NL80211_TESTMODE
1435 CMD(testmode_cmd, TESTMODE);
1440 if (dev->ops->connect || dev->ops->auth) {
1442 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1443 goto nla_put_failure;
1446 if (dev->ops->disconnect || dev->ops->deauth) {
1448 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1449 goto nla_put_failure;
1452 nla_nest_end(msg, nl_cmds);
1457 if (dev->ops->remain_on_channel &&
1458 (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
1460 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1461 dev->wiphy.max_remain_on_channel_duration))
1462 goto nla_put_failure;
1464 if ((dev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
1465 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1466 goto nla_put_failure;
1468 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1469 goto nla_put_failure;
1475 if (nl80211_send_wowlan(msg, dev, split))
1476 goto nla_put_failure;
1484 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1485 dev->wiphy.software_iftypes))
1486 goto nla_put_failure;
1488 if (nl80211_put_iface_combinations(&dev->wiphy, msg, split))
1489 goto nla_put_failure;
1495 if ((dev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
1496 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1497 dev->wiphy.ap_sme_capa))
1498 goto nla_put_failure;
1500 features = dev->wiphy.features;
1502 * We can only add the per-channel limit information if the
1503 * dump is split, otherwise it makes it too big. Therefore
1504 * only advertise it in that case.
1507 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1508 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
1509 goto nla_put_failure;
1511 if (dev->wiphy.ht_capa_mod_mask &&
1512 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1513 sizeof(*dev->wiphy.ht_capa_mod_mask),
1514 dev->wiphy.ht_capa_mod_mask))
1515 goto nla_put_failure;
1517 if (dev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1518 dev->wiphy.max_acl_mac_addrs &&
1519 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1520 dev->wiphy.max_acl_mac_addrs))
1521 goto nla_put_failure;
1524 * Any information below this point is only available to
1525 * applications that can deal with it being split. This
1526 * helps ensure that newly added capabilities don't break
1527 * older tools by overrunning their buffers.
1529 * We still increment split_start so that in the split
1530 * case we'll continue with more data in the next round,
1531 * but break unconditionally so unsplit data stops here.
1536 if (dev->wiphy.extended_capabilities &&
1537 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1538 dev->wiphy.extended_capabilities_len,
1539 dev->wiphy.extended_capabilities) ||
1540 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1541 dev->wiphy.extended_capabilities_len,
1542 dev->wiphy.extended_capabilities_mask)))
1543 goto nla_put_failure;
1545 if (dev->wiphy.vht_capa_mod_mask &&
1546 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1547 sizeof(*dev->wiphy.vht_capa_mod_mask),
1548 dev->wiphy.vht_capa_mod_mask))
1549 goto nla_put_failure;
1555 return genlmsg_end(msg, hdr);
1558 genlmsg_cancel(msg, hdr);
1562 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1565 int start = cb->args[0];
1566 struct cfg80211_registered_device *dev;
1567 s64 filter_wiphy = -1;
1572 /* will be zeroed in nlmsg_parse() */
1573 tb = kmalloc(sizeof(*tb) * (NL80211_ATTR_MAX + 1), GFP_KERNEL);
1577 mutex_lock(&cfg80211_mutex);
1578 res = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1579 tb, NL80211_ATTR_MAX, nl80211_policy);
1581 split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1582 if (tb[NL80211_ATTR_WIPHY])
1583 filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1584 if (tb[NL80211_ATTR_WDEV])
1585 filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1586 if (tb[NL80211_ATTR_IFINDEX]) {
1587 struct net_device *netdev;
1588 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1590 netdev = dev_get_by_index(sock_net(skb->sk), ifidx);
1592 mutex_unlock(&cfg80211_mutex);
1596 if (netdev->ieee80211_ptr) {
1598 netdev->ieee80211_ptr->wiphy);
1599 filter_wiphy = dev->wiphy_idx;
1606 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
1607 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
1611 if (filter_wiphy != -1 && dev->wiphy_idx != filter_wiphy)
1613 /* attempt to fit multiple wiphy data chunks into the skb */
1615 ret = nl80211_send_wiphy(dev, skb,
1616 NETLINK_CB(cb->skb).portid,
1619 split, &cb->args[1],
1624 * If sending the wiphy data didn't fit (ENOBUFS
1625 * or EMSGSIZE returned), this SKB is still
1626 * empty (so it's not too big because another
1627 * wiphy dataset is already in the skb) and
1628 * we've not tried to adjust the dump allocation
1629 * yet ... then adjust the alloc size to be
1630 * bigger, and return 1 but with the empty skb.
1631 * This results in an empty message being RX'ed
1632 * in userspace, but that is ignored.
1634 * We can then retry with the larger buffer.
1636 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
1638 cb->min_dump_alloc < 4096) {
1639 cb->min_dump_alloc = 4096;
1640 mutex_unlock(&cfg80211_mutex);
1646 } while (cb->args[1] > 0);
1649 mutex_unlock(&cfg80211_mutex);
1656 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
1658 struct sk_buff *msg;
1659 struct cfg80211_registered_device *dev = info->user_ptr[0];
1661 msg = nlmsg_new(4096, GFP_KERNEL);
1665 if (nl80211_send_wiphy(dev, msg, info->snd_portid, info->snd_seq, 0,
1666 false, NULL, NULL, NULL) < 0) {
1671 return genlmsg_reply(msg, info);
1674 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
1675 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
1676 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
1677 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
1678 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
1679 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
1682 static int parse_txq_params(struct nlattr *tb[],
1683 struct ieee80211_txq_params *txq_params)
1685 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
1686 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
1687 !tb[NL80211_TXQ_ATTR_AIFS])
1690 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
1691 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
1692 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
1693 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
1694 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
1696 if (txq_params->ac >= NL80211_NUM_ACS)
1702 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
1705 * You can only set the channel explicitly for WDS interfaces,
1706 * all others have their channel managed via their respective
1707 * "establish a connection" command (connect, join, ...)
1709 * For AP/GO and mesh mode, the channel can be set with the
1710 * channel userspace API, but is only stored and passed to the
1711 * low-level driver when the AP starts or the mesh is joined.
1712 * This is for backward compatibility, userspace can also give
1713 * the channel in the start-ap or join-mesh commands instead.
1715 * Monitors are special as they are normally slaved to
1716 * whatever else is going on, so they have their own special
1717 * operation to set the monitor channel if possible.
1720 wdev->iftype == NL80211_IFTYPE_AP ||
1721 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
1722 wdev->iftype == NL80211_IFTYPE_MONITOR ||
1723 wdev->iftype == NL80211_IFTYPE_P2P_GO;
1726 static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
1727 struct genl_info *info,
1728 struct cfg80211_chan_def *chandef)
1732 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
1735 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
1737 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
1738 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
1739 chandef->center_freq1 = control_freq;
1740 chandef->center_freq2 = 0;
1742 /* Primary channel not allowed */
1743 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
1746 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
1747 enum nl80211_channel_type chantype;
1749 chantype = nla_get_u32(
1750 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1753 case NL80211_CHAN_NO_HT:
1754 case NL80211_CHAN_HT20:
1755 case NL80211_CHAN_HT40PLUS:
1756 case NL80211_CHAN_HT40MINUS:
1757 cfg80211_chandef_create(chandef, chandef->chan,
1763 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
1765 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
1766 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
1767 chandef->center_freq1 =
1769 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
1770 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
1771 chandef->center_freq2 =
1773 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
1776 if (!cfg80211_chandef_valid(chandef))
1779 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
1780 IEEE80211_CHAN_DISABLED))
1786 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
1787 struct wireless_dev *wdev,
1788 struct genl_info *info)
1790 struct cfg80211_chan_def chandef;
1792 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
1795 iftype = wdev->iftype;
1797 if (!nl80211_can_set_dev_channel(wdev))
1800 result = nl80211_parse_chandef(rdev, info, &chandef);
1804 mutex_lock(&rdev->devlist_mtx);
1806 case NL80211_IFTYPE_AP:
1807 case NL80211_IFTYPE_P2P_GO:
1808 if (wdev->beacon_interval) {
1812 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef)) {
1816 wdev->preset_chandef = chandef;
1819 case NL80211_IFTYPE_MESH_POINT:
1820 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
1822 case NL80211_IFTYPE_MONITOR:
1823 result = cfg80211_set_monitor_channel(rdev, &chandef);
1828 mutex_unlock(&rdev->devlist_mtx);
1833 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
1835 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1836 struct net_device *netdev = info->user_ptr[1];
1838 return __nl80211_set_channel(rdev, netdev->ieee80211_ptr, info);
1841 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
1843 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1844 struct net_device *dev = info->user_ptr[1];
1845 struct wireless_dev *wdev = dev->ieee80211_ptr;
1848 if (!info->attrs[NL80211_ATTR_MAC])
1851 if (netif_running(dev))
1854 if (!rdev->ops->set_wds_peer)
1857 if (wdev->iftype != NL80211_IFTYPE_WDS)
1860 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1861 return rdev_set_wds_peer(rdev, dev, bssid);
1865 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
1867 struct cfg80211_registered_device *rdev;
1868 struct net_device *netdev = NULL;
1869 struct wireless_dev *wdev;
1870 int result = 0, rem_txq_params = 0;
1871 struct nlattr *nl_txq_params;
1873 u8 retry_short = 0, retry_long = 0;
1874 u32 frag_threshold = 0, rts_threshold = 0;
1875 u8 coverage_class = 0;
1878 * Try to find the wiphy and netdev. Normally this
1879 * function shouldn't need the netdev, but this is
1880 * done for backward compatibility -- previously
1881 * setting the channel was done per wiphy, but now
1882 * it is per netdev. Previous userland like hostapd
1883 * also passed a netdev to set_wiphy, so that it is
1884 * possible to let that go to the right netdev!
1886 mutex_lock(&cfg80211_mutex);
1888 if (info->attrs[NL80211_ATTR_IFINDEX]) {
1889 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
1891 netdev = dev_get_by_index(genl_info_net(info), ifindex);
1892 if (netdev && netdev->ieee80211_ptr) {
1893 rdev = wiphy_to_dev(netdev->ieee80211_ptr->wiphy);
1894 mutex_lock(&rdev->mtx);
1900 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
1903 mutex_unlock(&cfg80211_mutex);
1904 return PTR_ERR(rdev);
1910 mutex_lock(&rdev->mtx);
1912 wdev = netdev->ieee80211_ptr;
1915 * end workaround code, by now the rdev is available
1916 * and locked, and wdev may or may not be NULL.
1919 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
1920 result = cfg80211_dev_rename(
1921 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
1923 mutex_unlock(&cfg80211_mutex);
1928 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
1929 struct ieee80211_txq_params txq_params;
1930 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
1932 if (!rdev->ops->set_txq_params) {
1933 result = -EOPNOTSUPP;
1942 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
1943 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
1948 if (!netif_running(netdev)) {
1953 nla_for_each_nested(nl_txq_params,
1954 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
1956 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
1957 nla_data(nl_txq_params),
1958 nla_len(nl_txq_params),
1960 result = parse_txq_params(tb, &txq_params);
1964 result = rdev_set_txq_params(rdev, netdev,
1971 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
1972 result = __nl80211_set_channel(rdev,
1973 nl80211_can_set_dev_channel(wdev) ? wdev : NULL,
1979 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
1980 struct wireless_dev *txp_wdev = wdev;
1981 enum nl80211_tx_power_setting type;
1984 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
1987 if (!rdev->ops->set_tx_power) {
1988 result = -EOPNOTSUPP;
1992 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
1993 type = nla_get_u32(info->attrs[idx]);
1995 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
1996 (type != NL80211_TX_POWER_AUTOMATIC)) {
2001 if (type != NL80211_TX_POWER_AUTOMATIC) {
2002 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2003 mbm = nla_get_u32(info->attrs[idx]);
2006 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
2011 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2012 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2014 if ((!rdev->wiphy.available_antennas_tx &&
2015 !rdev->wiphy.available_antennas_rx) ||
2016 !rdev->ops->set_antenna) {
2017 result = -EOPNOTSUPP;
2021 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2022 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2024 /* reject antenna configurations which don't match the
2025 * available antenna masks, except for the "all" mask */
2026 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
2027 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) {
2032 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2033 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
2035 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
2042 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2043 retry_short = nla_get_u8(
2044 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
2045 if (retry_short == 0) {
2049 changed |= WIPHY_PARAM_RETRY_SHORT;
2052 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2053 retry_long = nla_get_u8(
2054 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
2055 if (retry_long == 0) {
2059 changed |= WIPHY_PARAM_RETRY_LONG;
2062 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2063 frag_threshold = nla_get_u32(
2064 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
2065 if (frag_threshold < 256) {
2069 if (frag_threshold != (u32) -1) {
2071 * Fragments (apart from the last one) are required to
2072 * have even length. Make the fragmentation code
2073 * simpler by stripping LSB should someone try to use
2074 * odd threshold value.
2076 frag_threshold &= ~0x1;
2078 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2081 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2082 rts_threshold = nla_get_u32(
2083 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2084 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2087 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
2088 coverage_class = nla_get_u8(
2089 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2090 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2094 u8 old_retry_short, old_retry_long;
2095 u32 old_frag_threshold, old_rts_threshold;
2096 u8 old_coverage_class;
2098 if (!rdev->ops->set_wiphy_params) {
2099 result = -EOPNOTSUPP;
2103 old_retry_short = rdev->wiphy.retry_short;
2104 old_retry_long = rdev->wiphy.retry_long;
2105 old_frag_threshold = rdev->wiphy.frag_threshold;
2106 old_rts_threshold = rdev->wiphy.rts_threshold;
2107 old_coverage_class = rdev->wiphy.coverage_class;
2109 if (changed & WIPHY_PARAM_RETRY_SHORT)
2110 rdev->wiphy.retry_short = retry_short;
2111 if (changed & WIPHY_PARAM_RETRY_LONG)
2112 rdev->wiphy.retry_long = retry_long;
2113 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2114 rdev->wiphy.frag_threshold = frag_threshold;
2115 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2116 rdev->wiphy.rts_threshold = rts_threshold;
2117 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2118 rdev->wiphy.coverage_class = coverage_class;
2120 result = rdev_set_wiphy_params(rdev, changed);
2122 rdev->wiphy.retry_short = old_retry_short;
2123 rdev->wiphy.retry_long = old_retry_long;
2124 rdev->wiphy.frag_threshold = old_frag_threshold;
2125 rdev->wiphy.rts_threshold = old_rts_threshold;
2126 rdev->wiphy.coverage_class = old_coverage_class;
2131 mutex_unlock(&rdev->mtx);
2137 static inline u64 wdev_id(struct wireless_dev *wdev)
2139 return (u64)wdev->identifier |
2140 ((u64)wiphy_to_dev(wdev->wiphy)->wiphy_idx << 32);
2143 static int nl80211_send_chandef(struct sk_buff *msg,
2144 struct cfg80211_chan_def *chandef)
2146 WARN_ON(!cfg80211_chandef_valid(chandef));
2148 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2149 chandef->chan->center_freq))
2151 switch (chandef->width) {
2152 case NL80211_CHAN_WIDTH_20_NOHT:
2153 case NL80211_CHAN_WIDTH_20:
2154 case NL80211_CHAN_WIDTH_40:
2155 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2156 cfg80211_get_chandef_type(chandef)))
2162 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2164 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2166 if (chandef->center_freq2 &&
2167 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
2172 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
2173 struct cfg80211_registered_device *rdev,
2174 struct wireless_dev *wdev)
2176 struct net_device *dev = wdev->netdev;
2179 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_INTERFACE);
2184 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2185 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
2186 goto nla_put_failure;
2188 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2189 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2190 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
2191 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
2192 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2193 rdev->devlist_generation ^
2194 (cfg80211_rdev_list_generation << 2)))
2195 goto nla_put_failure;
2197 if (rdev->ops->get_channel) {
2199 struct cfg80211_chan_def chandef;
2201 ret = rdev_get_channel(rdev, wdev, &chandef);
2203 if (nl80211_send_chandef(msg, &chandef))
2204 goto nla_put_failure;
2208 if (wdev->ssid_len) {
2209 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2210 goto nla_put_failure;
2213 return genlmsg_end(msg, hdr);
2216 genlmsg_cancel(msg, hdr);
2220 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2224 int wp_start = cb->args[0];
2225 int if_start = cb->args[1];
2226 struct cfg80211_registered_device *rdev;
2227 struct wireless_dev *wdev;
2229 mutex_lock(&cfg80211_mutex);
2230 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2231 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2233 if (wp_idx < wp_start) {
2239 mutex_lock(&rdev->devlist_mtx);
2240 list_for_each_entry(wdev, &rdev->wdev_list, list) {
2241 if (if_idx < if_start) {
2245 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
2246 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2248 mutex_unlock(&rdev->devlist_mtx);
2253 mutex_unlock(&rdev->devlist_mtx);
2258 mutex_unlock(&cfg80211_mutex);
2260 cb->args[0] = wp_idx;
2261 cb->args[1] = if_idx;
2266 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2268 struct sk_buff *msg;
2269 struct cfg80211_registered_device *dev = info->user_ptr[0];
2270 struct wireless_dev *wdev = info->user_ptr[1];
2272 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2276 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
2282 return genlmsg_reply(msg, info);
2285 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2286 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2287 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2288 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2289 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2290 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
2293 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2295 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2303 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
2304 nla, mntr_flags_policy))
2307 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2309 *mntrflags |= (1<<flag);
2314 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
2315 struct net_device *netdev, u8 use_4addr,
2316 enum nl80211_iftype iftype)
2319 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
2325 case NL80211_IFTYPE_AP_VLAN:
2326 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2329 case NL80211_IFTYPE_STATION:
2330 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2340 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2342 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2343 struct vif_params params;
2345 enum nl80211_iftype otype, ntype;
2346 struct net_device *dev = info->user_ptr[1];
2347 u32 _flags, *flags = NULL;
2348 bool change = false;
2350 memset(¶ms, 0, sizeof(params));
2352 otype = ntype = dev->ieee80211_ptr->iftype;
2354 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2355 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2358 if (ntype > NL80211_IFTYPE_MAX)
2362 if (info->attrs[NL80211_ATTR_MESH_ID]) {
2363 struct wireless_dev *wdev = dev->ieee80211_ptr;
2365 if (ntype != NL80211_IFTYPE_MESH_POINT)
2367 if (netif_running(dev))
2371 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2372 IEEE80211_MAX_MESH_ID_LEN);
2373 wdev->mesh_id_up_len =
2374 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2375 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2376 wdev->mesh_id_up_len);
2380 if (info->attrs[NL80211_ATTR_4ADDR]) {
2381 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2383 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
2387 params.use_4addr = -1;
2390 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2391 if (ntype != NL80211_IFTYPE_MONITOR)
2393 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2403 err = cfg80211_change_iface(rdev, dev, ntype, flags, ¶ms);
2407 if (!err && params.use_4addr != -1)
2408 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2413 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2415 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2416 struct vif_params params;
2417 struct wireless_dev *wdev;
2418 struct sk_buff *msg;
2420 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2423 memset(¶ms, 0, sizeof(params));
2425 if (!info->attrs[NL80211_ATTR_IFNAME])
2428 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2429 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2430 if (type > NL80211_IFTYPE_MAX)
2434 if (!rdev->ops->add_virtual_intf ||
2435 !(rdev->wiphy.interface_modes & (1 << type)))
2438 if (type == NL80211_IFTYPE_P2P_DEVICE && info->attrs[NL80211_ATTR_MAC]) {
2439 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2441 if (!is_valid_ether_addr(params.macaddr))
2442 return -EADDRNOTAVAIL;
2445 if (info->attrs[NL80211_ATTR_4ADDR]) {
2446 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2447 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
2452 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2456 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
2457 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
2459 wdev = rdev_add_virtual_intf(rdev,
2460 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
2461 type, err ? NULL : &flags, ¶ms);
2464 return PTR_ERR(wdev);
2468 case NL80211_IFTYPE_MESH_POINT:
2469 if (!info->attrs[NL80211_ATTR_MESH_ID])
2472 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2473 IEEE80211_MAX_MESH_ID_LEN);
2474 wdev->mesh_id_up_len =
2475 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2476 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2477 wdev->mesh_id_up_len);
2480 case NL80211_IFTYPE_P2P_DEVICE:
2482 * P2P Device doesn't have a netdev, so doesn't go
2483 * through the netdev notifier and must be added here
2485 mutex_init(&wdev->mtx);
2486 INIT_LIST_HEAD(&wdev->event_list);
2487 spin_lock_init(&wdev->event_lock);
2488 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2489 spin_lock_init(&wdev->mgmt_registrations_lock);
2491 mutex_lock(&rdev->devlist_mtx);
2492 wdev->identifier = ++rdev->wdev_id;
2493 list_add_rcu(&wdev->list, &rdev->wdev_list);
2494 rdev->devlist_generation++;
2495 mutex_unlock(&rdev->devlist_mtx);
2501 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
2507 return genlmsg_reply(msg, info);
2510 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
2512 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2513 struct wireless_dev *wdev = info->user_ptr[1];
2515 if (!rdev->ops->del_virtual_intf)
2519 * If we remove a wireless device without a netdev then clear
2520 * user_ptr[1] so that nl80211_post_doit won't dereference it
2521 * to check if it needs to do dev_put(). Otherwise it crashes
2522 * since the wdev has been freed, unlike with a netdev where
2523 * we need the dev_put() for the netdev to really be freed.
2526 info->user_ptr[1] = NULL;
2528 return rdev_del_virtual_intf(rdev, wdev);
2531 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
2533 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2534 struct net_device *dev = info->user_ptr[1];
2537 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
2540 if (!rdev->ops->set_noack_map)
2543 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
2545 return rdev_set_noack_map(rdev, dev, noack_map);
2548 struct get_key_cookie {
2549 struct sk_buff *msg;
2554 static void get_key_callback(void *c, struct key_params *params)
2557 struct get_key_cookie *cookie = c;
2560 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
2561 params->key_len, params->key)) ||
2563 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
2564 params->seq_len, params->seq)) ||
2566 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
2568 goto nla_put_failure;
2570 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
2572 goto nla_put_failure;
2575 nla_put(cookie->msg, NL80211_KEY_DATA,
2576 params->key_len, params->key)) ||
2578 nla_put(cookie->msg, NL80211_KEY_SEQ,
2579 params->seq_len, params->seq)) ||
2581 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
2583 goto nla_put_failure;
2585 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
2586 goto nla_put_failure;
2588 nla_nest_end(cookie->msg, key);
2595 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
2597 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2599 struct net_device *dev = info->user_ptr[1];
2601 const u8 *mac_addr = NULL;
2603 struct get_key_cookie cookie = {
2607 struct sk_buff *msg;
2609 if (info->attrs[NL80211_ATTR_KEY_IDX])
2610 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
2615 if (info->attrs[NL80211_ATTR_MAC])
2616 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2618 pairwise = !!mac_addr;
2619 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
2620 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
2621 if (kt >= NUM_NL80211_KEYTYPES)
2623 if (kt != NL80211_KEYTYPE_GROUP &&
2624 kt != NL80211_KEYTYPE_PAIRWISE)
2626 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
2629 if (!rdev->ops->get_key)
2632 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2636 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
2637 NL80211_CMD_NEW_KEY);
2639 return PTR_ERR(hdr);
2642 cookie.idx = key_idx;
2644 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2645 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
2646 goto nla_put_failure;
2648 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
2649 goto nla_put_failure;
2651 if (pairwise && mac_addr &&
2652 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2655 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
2662 goto nla_put_failure;
2664 genlmsg_end(msg, hdr);
2665 return genlmsg_reply(msg, info);
2674 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
2676 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2677 struct key_parse key;
2679 struct net_device *dev = info->user_ptr[1];
2681 err = nl80211_parse_key(info, &key);
2688 /* only support setting default key */
2689 if (!key.def && !key.defmgmt)
2692 wdev_lock(dev->ieee80211_ptr);
2695 if (!rdev->ops->set_default_key) {
2700 err = nl80211_key_allowed(dev->ieee80211_ptr);
2704 err = rdev_set_default_key(rdev, dev, key.idx,
2705 key.def_uni, key.def_multi);
2710 #ifdef CONFIG_CFG80211_WEXT
2711 dev->ieee80211_ptr->wext.default_key = key.idx;
2714 if (key.def_uni || !key.def_multi) {
2719 if (!rdev->ops->set_default_mgmt_key) {
2724 err = nl80211_key_allowed(dev->ieee80211_ptr);
2728 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
2732 #ifdef CONFIG_CFG80211_WEXT
2733 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
2738 wdev_unlock(dev->ieee80211_ptr);
2743 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
2745 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2747 struct net_device *dev = info->user_ptr[1];
2748 struct key_parse key;
2749 const u8 *mac_addr = NULL;
2751 err = nl80211_parse_key(info, &key);
2758 if (info->attrs[NL80211_ATTR_MAC])
2759 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2761 if (key.type == -1) {
2763 key.type = NL80211_KEYTYPE_PAIRWISE;
2765 key.type = NL80211_KEYTYPE_GROUP;
2769 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2770 key.type != NL80211_KEYTYPE_GROUP)
2773 if (!rdev->ops->add_key)
2776 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
2777 key.type == NL80211_KEYTYPE_PAIRWISE,
2781 wdev_lock(dev->ieee80211_ptr);
2782 err = nl80211_key_allowed(dev->ieee80211_ptr);
2784 err = rdev_add_key(rdev, dev, key.idx,
2785 key.type == NL80211_KEYTYPE_PAIRWISE,
2787 wdev_unlock(dev->ieee80211_ptr);
2792 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
2794 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2796 struct net_device *dev = info->user_ptr[1];
2797 u8 *mac_addr = NULL;
2798 struct key_parse key;
2800 err = nl80211_parse_key(info, &key);
2804 if (info->attrs[NL80211_ATTR_MAC])
2805 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2807 if (key.type == -1) {
2809 key.type = NL80211_KEYTYPE_PAIRWISE;
2811 key.type = NL80211_KEYTYPE_GROUP;
2815 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2816 key.type != NL80211_KEYTYPE_GROUP)
2819 if (!rdev->ops->del_key)
2822 wdev_lock(dev->ieee80211_ptr);
2823 err = nl80211_key_allowed(dev->ieee80211_ptr);
2825 if (key.type == NL80211_KEYTYPE_PAIRWISE && mac_addr &&
2826 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2830 err = rdev_del_key(rdev, dev, key.idx,
2831 key.type == NL80211_KEYTYPE_PAIRWISE,
2834 #ifdef CONFIG_CFG80211_WEXT
2836 if (key.idx == dev->ieee80211_ptr->wext.default_key)
2837 dev->ieee80211_ptr->wext.default_key = -1;
2838 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
2839 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
2842 wdev_unlock(dev->ieee80211_ptr);
2847 /* This function returns an error or the number of nested attributes */
2848 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
2850 struct nlattr *attr;
2851 int n_entries = 0, tmp;
2853 nla_for_each_nested(attr, nl_attr, tmp) {
2854 if (nla_len(attr) != ETH_ALEN)
2864 * This function parses ACL information and allocates memory for ACL data.
2865 * On successful return, the calling function is responsible to free the
2866 * ACL buffer returned by this function.
2868 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
2869 struct genl_info *info)
2871 enum nl80211_acl_policy acl_policy;
2872 struct nlattr *attr;
2873 struct cfg80211_acl_data *acl;
2874 int i = 0, n_entries, tmp;
2876 if (!wiphy->max_acl_mac_addrs)
2877 return ERR_PTR(-EOPNOTSUPP);
2879 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
2880 return ERR_PTR(-EINVAL);
2882 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
2883 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
2884 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
2885 return ERR_PTR(-EINVAL);
2887 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
2888 return ERR_PTR(-EINVAL);
2890 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
2892 return ERR_PTR(n_entries);
2894 if (n_entries > wiphy->max_acl_mac_addrs)
2895 return ERR_PTR(-ENOTSUPP);
2897 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
2900 return ERR_PTR(-ENOMEM);
2902 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
2903 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
2907 acl->n_acl_entries = n_entries;
2908 acl->acl_policy = acl_policy;
2913 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
2915 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2916 struct net_device *dev = info->user_ptr[1];
2917 struct cfg80211_acl_data *acl;
2920 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2921 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2924 if (!dev->ieee80211_ptr->beacon_interval)
2927 acl = parse_acl_data(&rdev->wiphy, info);
2929 return PTR_ERR(acl);
2931 err = rdev_set_mac_acl(rdev, dev, acl);
2938 static int nl80211_parse_beacon(struct genl_info *info,
2939 struct cfg80211_beacon_data *bcn)
2941 bool haveinfo = false;
2943 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]) ||
2944 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]) ||
2945 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
2946 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]))
2949 memset(bcn, 0, sizeof(*bcn));
2951 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
2952 bcn->head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2953 bcn->head_len = nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2959 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
2960 bcn->tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2962 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2969 if (info->attrs[NL80211_ATTR_IE]) {
2970 bcn->beacon_ies = nla_data(info->attrs[NL80211_ATTR_IE]);
2971 bcn->beacon_ies_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2974 if (info->attrs[NL80211_ATTR_IE_PROBE_RESP]) {
2975 bcn->proberesp_ies =
2976 nla_data(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2977 bcn->proberesp_ies_len =
2978 nla_len(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2981 if (info->attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
2982 bcn->assocresp_ies =
2983 nla_data(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2984 bcn->assocresp_ies_len =
2985 nla_len(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2988 if (info->attrs[NL80211_ATTR_PROBE_RESP]) {
2990 nla_data(info->attrs[NL80211_ATTR_PROBE_RESP]);
2991 bcn->probe_resp_len =
2992 nla_len(info->attrs[NL80211_ATTR_PROBE_RESP]);
2998 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
2999 struct cfg80211_ap_settings *params)
3001 struct wireless_dev *wdev;
3004 mutex_lock(&rdev->devlist_mtx);
3006 list_for_each_entry(wdev, &rdev->wdev_list, list) {
3007 if (wdev->iftype != NL80211_IFTYPE_AP &&
3008 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3011 if (!wdev->preset_chandef.chan)
3014 params->chandef = wdev->preset_chandef;
3019 mutex_unlock(&rdev->devlist_mtx);
3024 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3025 enum nl80211_auth_type auth_type,
3026 enum nl80211_commands cmd)
3028 if (auth_type > NL80211_AUTHTYPE_MAX)
3032 case NL80211_CMD_AUTHENTICATE:
3033 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3034 auth_type == NL80211_AUTHTYPE_SAE)
3037 case NL80211_CMD_CONNECT:
3038 case NL80211_CMD_START_AP:
3039 /* SAE not supported yet */
3040 if (auth_type == NL80211_AUTHTYPE_SAE)
3048 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3050 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3051 struct net_device *dev = info->user_ptr[1];
3052 struct wireless_dev *wdev = dev->ieee80211_ptr;
3053 struct cfg80211_ap_settings params;
3055 u8 radar_detect_width = 0;
3057 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3058 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3061 if (!rdev->ops->start_ap)
3064 if (wdev->beacon_interval)
3067 memset(¶ms, 0, sizeof(params));
3069 /* these are required for START_AP */
3070 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3071 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3072 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3075 err = nl80211_parse_beacon(info, ¶ms.beacon);
3079 params.beacon_interval =
3080 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3081 params.dtim_period =
3082 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
3084 err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
3089 * In theory, some of these attributes should be required here
3090 * but since they were not used when the command was originally
3091 * added, keep them optional for old user space programs to let
3092 * them continue to work with drivers that do not need the
3093 * additional information -- drivers must check!
3095 if (info->attrs[NL80211_ATTR_SSID]) {
3096 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3098 nla_len(info->attrs[NL80211_ATTR_SSID]);
3099 if (params.ssid_len == 0 ||
3100 params.ssid_len > IEEE80211_MAX_SSID_LEN)
3104 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
3105 params.hidden_ssid = nla_get_u32(
3106 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
3107 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
3108 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
3109 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
3113 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3115 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3116 params.auth_type = nla_get_u32(
3117 info->attrs[NL80211_ATTR_AUTH_TYPE]);
3118 if (!nl80211_valid_auth_type(rdev, params.auth_type,
3119 NL80211_CMD_START_AP))
3122 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3124 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
3125 NL80211_MAX_NR_CIPHER_SUITES);
3129 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3130 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3132 params.inactivity_timeout = nla_get_u16(
3133 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3136 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3137 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3139 params.p2p_ctwindow =
3140 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3141 if (params.p2p_ctwindow > 127)
3143 if (params.p2p_ctwindow != 0 &&
3144 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3148 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3151 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3153 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3156 params.p2p_opp_ps = tmp;
3157 if (params.p2p_opp_ps != 0 &&
3158 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
3162 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3163 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
3166 } else if (wdev->preset_chandef.chan) {
3167 params.chandef = wdev->preset_chandef;
3168 } else if (!nl80211_get_ap_channel(rdev, ¶ms))
3171 if (!cfg80211_reg_can_beacon(&rdev->wiphy, ¶ms.chandef))
3174 err = cfg80211_chandef_dfs_required(wdev->wiphy, ¶ms.chandef);
3178 radar_detect_width = BIT(params.chandef.width);
3179 params.radar_required = true;
3182 mutex_lock(&rdev->devlist_mtx);
3183 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
3184 params.chandef.chan,
3186 radar_detect_width);
3187 mutex_unlock(&rdev->devlist_mtx);
3192 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
3193 params.acl = parse_acl_data(&rdev->wiphy, info);
3194 if (IS_ERR(params.acl))
3195 return PTR_ERR(params.acl);
3198 err = rdev_start_ap(rdev, dev, ¶ms);
3200 wdev->preset_chandef = params.chandef;
3201 wdev->beacon_interval = params.beacon_interval;
3202 wdev->channel = params.chandef.chan;
3203 wdev->ssid_len = params.ssid_len;
3204 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
3212 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
3214 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3215 struct net_device *dev = info->user_ptr[1];
3216 struct wireless_dev *wdev = dev->ieee80211_ptr;
3217 struct cfg80211_beacon_data params;
3220 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3221 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3224 if (!rdev->ops->change_beacon)
3227 if (!wdev->beacon_interval)
3230 err = nl80211_parse_beacon(info, ¶ms);
3234 return rdev_change_beacon(rdev, dev, ¶ms);
3237 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
3239 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3240 struct net_device *dev = info->user_ptr[1];
3242 return cfg80211_stop_ap(rdev, dev);
3245 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
3246 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
3247 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
3248 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
3249 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
3250 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
3251 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
3254 static int parse_station_flags(struct genl_info *info,
3255 enum nl80211_iftype iftype,
3256 struct station_parameters *params)
3258 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
3263 * Try parsing the new attribute first so userspace
3264 * can specify both for older kernels.
3266 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
3268 struct nl80211_sta_flag_update *sta_flags;
3270 sta_flags = nla_data(nla);
3271 params->sta_flags_mask = sta_flags->mask;
3272 params->sta_flags_set = sta_flags->set;
3273 params->sta_flags_set &= params->sta_flags_mask;
3274 if ((params->sta_flags_mask |
3275 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
3280 /* if present, parse the old attribute */
3282 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
3286 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
3287 nla, sta_flags_policy))
3291 * Only allow certain flags for interface types so that
3292 * other attributes are silently ignored. Remember that
3293 * this is backward compatibility code with old userspace
3294 * and shouldn't be hit in other cases anyway.
3297 case NL80211_IFTYPE_AP:
3298 case NL80211_IFTYPE_AP_VLAN:
3299 case NL80211_IFTYPE_P2P_GO:
3300 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3301 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3302 BIT(NL80211_STA_FLAG_WME) |
3303 BIT(NL80211_STA_FLAG_MFP);
3305 case NL80211_IFTYPE_P2P_CLIENT:
3306 case NL80211_IFTYPE_STATION:
3307 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3308 BIT(NL80211_STA_FLAG_TDLS_PEER);
3310 case NL80211_IFTYPE_MESH_POINT:
3311 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3312 BIT(NL80211_STA_FLAG_MFP) |
3313 BIT(NL80211_STA_FLAG_AUTHORIZED);
3318 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
3320 params->sta_flags_set |= (1<<flag);
3322 /* no longer support new API additions in old API */
3323 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
3331 static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
3334 struct nlattr *rate;
3338 rate = nla_nest_start(msg, attr);
3342 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
3343 bitrate = cfg80211_calculate_bitrate(info);
3344 /* report 16-bit bitrate only if we can */
3345 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
3347 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
3349 if (bitrate_compat > 0 &&
3350 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
3353 if (info->flags & RATE_INFO_FLAGS_MCS) {
3354 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
3356 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3357 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3359 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3360 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3362 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
3363 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
3365 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
3367 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3368 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3370 if (info->flags & RATE_INFO_FLAGS_80_MHZ_WIDTH &&
3371 nla_put_flag(msg, NL80211_RATE_INFO_80_MHZ_WIDTH))
3373 if (info->flags & RATE_INFO_FLAGS_80P80_MHZ_WIDTH &&
3374 nla_put_flag(msg, NL80211_RATE_INFO_80P80_MHZ_WIDTH))
3376 if (info->flags & RATE_INFO_FLAGS_160_MHZ_WIDTH &&
3377 nla_put_flag(msg, NL80211_RATE_INFO_160_MHZ_WIDTH))
3379 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3380 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3384 nla_nest_end(msg, rate);
3388 static int nl80211_send_station(struct sk_buff *msg, u32 portid, u32 seq,
3390 struct cfg80211_registered_device *rdev,
3391 struct net_device *dev,
3392 const u8 *mac_addr, struct station_info *sinfo)
3395 struct nlattr *sinfoattr, *bss_param;
3397 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
3401 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3402 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
3403 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
3404 goto nla_put_failure;
3406 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
3408 goto nla_put_failure;
3409 if ((sinfo->filled & STATION_INFO_CONNECTED_TIME) &&
3410 nla_put_u32(msg, NL80211_STA_INFO_CONNECTED_TIME,
3411 sinfo->connected_time))
3412 goto nla_put_failure;
3413 if ((sinfo->filled & STATION_INFO_INACTIVE_TIME) &&
3414 nla_put_u32(msg, NL80211_STA_INFO_INACTIVE_TIME,
3415 sinfo->inactive_time))
3416 goto nla_put_failure;
3417 if ((sinfo->filled & (STATION_INFO_RX_BYTES |
3418 STATION_INFO_RX_BYTES64)) &&
3419 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
3420 (u32)sinfo->rx_bytes))
3421 goto nla_put_failure;
3422 if ((sinfo->filled & (STATION_INFO_TX_BYTES |
3423 STATION_INFO_TX_BYTES64)) &&
3424 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
3425 (u32)sinfo->tx_bytes))
3426 goto nla_put_failure;
3427 if ((sinfo->filled & STATION_INFO_RX_BYTES64) &&
3428 nla_put_u64(msg, NL80211_STA_INFO_RX_BYTES64,
3430 goto nla_put_failure;
3431 if ((sinfo->filled & STATION_INFO_TX_BYTES64) &&
3432 nla_put_u64(msg, NL80211_STA_INFO_TX_BYTES64,
3434 goto nla_put_failure;
3435 if ((sinfo->filled & STATION_INFO_LLID) &&
3436 nla_put_u16(msg, NL80211_STA_INFO_LLID, sinfo->llid))
3437 goto nla_put_failure;
3438 if ((sinfo->filled & STATION_INFO_PLID) &&
3439 nla_put_u16(msg, NL80211_STA_INFO_PLID, sinfo->plid))
3440 goto nla_put_failure;
3441 if ((sinfo->filled & STATION_INFO_PLINK_STATE) &&
3442 nla_put_u8(msg, NL80211_STA_INFO_PLINK_STATE,
3443 sinfo->plink_state))
3444 goto nla_put_failure;
3445 switch (rdev->wiphy.signal_type) {
3446 case CFG80211_SIGNAL_TYPE_MBM:
3447 if ((sinfo->filled & STATION_INFO_SIGNAL) &&
3448 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL,
3450 goto nla_put_failure;
3451 if ((sinfo->filled & STATION_INFO_SIGNAL_AVG) &&
3452 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL_AVG,
3454 goto nla_put_failure;
3459 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
3460 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
3461 NL80211_STA_INFO_TX_BITRATE))
3462 goto nla_put_failure;
3464 if (sinfo->filled & STATION_INFO_RX_BITRATE) {
3465 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
3466 NL80211_STA_INFO_RX_BITRATE))
3467 goto nla_put_failure;
3469 if ((sinfo->filled & STATION_INFO_RX_PACKETS) &&
3470 nla_put_u32(msg, NL80211_STA_INFO_RX_PACKETS,
3472 goto nla_put_failure;
3473 if ((sinfo->filled & STATION_INFO_TX_PACKETS) &&
3474 nla_put_u32(msg, NL80211_STA_INFO_TX_PACKETS,
3476 goto nla_put_failure;
3477 if ((sinfo->filled & STATION_INFO_TX_RETRIES) &&
3478 nla_put_u32(msg, NL80211_STA_INFO_TX_RETRIES,
3480 goto nla_put_failure;
3481 if ((sinfo->filled & STATION_INFO_TX_FAILED) &&
3482 nla_put_u32(msg, NL80211_STA_INFO_TX_FAILED,
3484 goto nla_put_failure;
3485 if ((sinfo->filled & STATION_INFO_BEACON_LOSS_COUNT) &&
3486 nla_put_u32(msg, NL80211_STA_INFO_BEACON_LOSS,
3487 sinfo->beacon_loss_count))
3488 goto nla_put_failure;
3489 if ((sinfo->filled & STATION_INFO_LOCAL_PM) &&
3490 nla_put_u32(msg, NL80211_STA_INFO_LOCAL_PM,
3492 goto nla_put_failure;
3493 if ((sinfo->filled & STATION_INFO_PEER_PM) &&
3494 nla_put_u32(msg, NL80211_STA_INFO_PEER_PM,
3496 goto nla_put_failure;
3497 if ((sinfo->filled & STATION_INFO_NONPEER_PM) &&
3498 nla_put_u32(msg, NL80211_STA_INFO_NONPEER_PM,
3500 goto nla_put_failure;
3501 if (sinfo->filled & STATION_INFO_BSS_PARAM) {
3502 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
3504 goto nla_put_failure;
3506 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
3507 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
3508 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
3509 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
3510 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
3511 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
3512 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
3513 sinfo->bss_param.dtim_period) ||
3514 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
3515 sinfo->bss_param.beacon_interval))
3516 goto nla_put_failure;
3518 nla_nest_end(msg, bss_param);
3520 if ((sinfo->filled & STATION_INFO_STA_FLAGS) &&
3521 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
3522 sizeof(struct nl80211_sta_flag_update),
3524 goto nla_put_failure;
3525 if ((sinfo->filled & STATION_INFO_T_OFFSET) &&
3526 nla_put_u64(msg, NL80211_STA_INFO_T_OFFSET,
3528 goto nla_put_failure;
3529 nla_nest_end(msg, sinfoattr);
3531 if ((sinfo->filled & STATION_INFO_ASSOC_REQ_IES) &&
3532 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
3533 sinfo->assoc_req_ies))
3534 goto nla_put_failure;
3536 return genlmsg_end(msg, hdr);
3539 genlmsg_cancel(msg, hdr);
3543 static int nl80211_dump_station(struct sk_buff *skb,
3544 struct netlink_callback *cb)
3546 struct station_info sinfo;
3547 struct cfg80211_registered_device *dev;
3548 struct wireless_dev *wdev;
3549 u8 mac_addr[ETH_ALEN];
3550 int sta_idx = cb->args[2];
3553 err = nl80211_prepare_wdev_dump(skb, cb, &dev, &wdev);
3557 if (!wdev->netdev) {
3562 if (!dev->ops->dump_station) {
3568 memset(&sinfo, 0, sizeof(sinfo));
3569 err = rdev_dump_station(dev, wdev->netdev, sta_idx,
3576 if (nl80211_send_station(skb,
3577 NETLINK_CB(cb->skb).portid,
3578 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3579 dev, wdev->netdev, mac_addr,
3588 cb->args[2] = sta_idx;
3591 nl80211_finish_wdev_dump(dev);
3596 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
3598 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3599 struct net_device *dev = info->user_ptr[1];
3600 struct station_info sinfo;
3601 struct sk_buff *msg;
3602 u8 *mac_addr = NULL;
3605 memset(&sinfo, 0, sizeof(sinfo));
3607 if (!info->attrs[NL80211_ATTR_MAC])
3610 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3612 if (!rdev->ops->get_station)
3615 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
3619 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3623 if (nl80211_send_station(msg, info->snd_portid, info->snd_seq, 0,
3624 rdev, dev, mac_addr, &sinfo) < 0) {
3629 return genlmsg_reply(msg, info);
3632 int cfg80211_check_station_change(struct wiphy *wiphy,
3633 struct station_parameters *params,
3634 enum cfg80211_station_type statype)
3636 if (params->listen_interval != -1)
3641 /* When you run into this, adjust the code below for the new flag */
3642 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
3645 case CFG80211_STA_MESH_PEER_KERNEL:
3646 case CFG80211_STA_MESH_PEER_USER:
3648 * No ignoring the TDLS flag here -- the userspace mesh
3649 * code doesn't have the bug of including TDLS in the
3652 if (params->sta_flags_mask &
3653 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3654 BIT(NL80211_STA_FLAG_MFP) |
3655 BIT(NL80211_STA_FLAG_AUTHORIZED)))
3658 case CFG80211_STA_TDLS_PEER_SETUP:
3659 case CFG80211_STA_TDLS_PEER_ACTIVE:
3660 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3662 /* ignore since it can't change */
3663 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3666 /* disallow mesh-specific things */
3667 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3669 if (params->local_pm)
3671 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3675 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
3676 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
3677 /* TDLS can't be set, ... */
3678 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3681 * ... but don't bother the driver with it. This works around
3682 * a hostapd/wpa_supplicant issue -- it always includes the
3683 * TLDS_PEER flag in the mask even for AP mode.
3685 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3688 if (statype != CFG80211_STA_TDLS_PEER_SETUP) {
3689 /* reject other things that can't change */
3690 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
3692 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
3694 if (params->supported_rates)
3696 if (params->ext_capab || params->ht_capa || params->vht_capa)
3700 if (statype != CFG80211_STA_AP_CLIENT) {
3706 case CFG80211_STA_AP_MLME_CLIENT:
3707 /* Use this only for authorizing/unauthorizing a station */
3708 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
3711 case CFG80211_STA_AP_CLIENT:
3712 /* accept only the listed bits */
3713 if (params->sta_flags_mask &
3714 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3715 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3716 BIT(NL80211_STA_FLAG_ASSOCIATED) |
3717 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3718 BIT(NL80211_STA_FLAG_WME) |
3719 BIT(NL80211_STA_FLAG_MFP)))
3722 /* but authenticated/associated only if driver handles it */
3723 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
3724 params->sta_flags_mask &
3725 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3726 BIT(NL80211_STA_FLAG_ASSOCIATED)))
3729 case CFG80211_STA_IBSS:
3730 case CFG80211_STA_AP_STA:
3731 /* reject any changes other than AUTHORIZED */
3732 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
3735 case CFG80211_STA_TDLS_PEER_SETUP:
3736 /* reject any changes other than AUTHORIZED or WME */
3737 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3738 BIT(NL80211_STA_FLAG_WME)))
3740 /* force (at least) rates when authorizing */
3741 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
3742 !params->supported_rates)
3745 case CFG80211_STA_TDLS_PEER_ACTIVE:
3746 /* reject any changes */
3748 case CFG80211_STA_MESH_PEER_KERNEL:
3749 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3752 case CFG80211_STA_MESH_PEER_USER:
3753 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3760 EXPORT_SYMBOL(cfg80211_check_station_change);
3763 * Get vlan interface making sure it is running and on the right wiphy.
3765 static struct net_device *get_vlan(struct genl_info *info,
3766 struct cfg80211_registered_device *rdev)
3768 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
3769 struct net_device *v;
3775 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
3777 return ERR_PTR(-ENODEV);
3779 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
3784 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
3785 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3786 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
3791 if (!netif_running(v)) {
3799 return ERR_PTR(ret);
3802 static struct nla_policy
3803 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] __read_mostly = {
3804 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
3805 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
3808 static int nl80211_parse_sta_wme(struct genl_info *info,
3809 struct station_parameters *params)
3811 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
3815 /* parse WME attributes if present */
3816 if (!info->attrs[NL80211_ATTR_STA_WME])
3819 nla = info->attrs[NL80211_ATTR_STA_WME];
3820 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
3821 nl80211_sta_wme_policy);
3825 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
3826 params->uapsd_queues = nla_get_u8(
3827 tb[NL80211_STA_WME_UAPSD_QUEUES]);
3828 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
3831 if (tb[NL80211_STA_WME_MAX_SP])
3832 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
3834 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
3837 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
3842 static int nl80211_set_station_tdls(struct genl_info *info,
3843 struct station_parameters *params)
3845 /* Dummy STA entry gets updated once the peer capabilities are known */
3846 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
3848 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
3849 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
3851 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
3853 return nl80211_parse_sta_wme(info, params);
3856 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
3858 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3859 struct net_device *dev = info->user_ptr[1];
3860 struct station_parameters params;
3864 memset(¶ms, 0, sizeof(params));
3866 params.listen_interval = -1;
3868 if (!rdev->ops->change_station)
3871 if (info->attrs[NL80211_ATTR_STA_AID])
3874 if (!info->attrs[NL80211_ATTR_MAC])
3877 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3879 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
3880 params.supported_rates =
3881 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3882 params.supported_rates_len =
3883 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3886 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
3888 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
3889 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
3892 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
3894 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
3895 params.ext_capab_len =
3896 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
3899 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
3902 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
3905 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
3906 params.plink_action =
3907 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
3908 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
3912 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
3913 params.plink_state =
3914 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
3915 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
3917 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
3920 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
3921 enum nl80211_mesh_power_mode pm = nla_get_u32(
3922 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
3924 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
3925 pm > NL80211_MESH_POWER_MAX)
3928 params.local_pm = pm;
3931 /* Include parameters for TDLS peer (will check later) */
3932 err = nl80211_set_station_tdls(info, ¶ms);
3936 params.vlan = get_vlan(info, rdev);
3937 if (IS_ERR(params.vlan))
3938 return PTR_ERR(params.vlan);
3940 switch (dev->ieee80211_ptr->iftype) {
3941 case NL80211_IFTYPE_AP:
3942 case NL80211_IFTYPE_AP_VLAN:
3943 case NL80211_IFTYPE_P2P_GO:
3944 case NL80211_IFTYPE_P2P_CLIENT:
3945 case NL80211_IFTYPE_STATION:
3946 case NL80211_IFTYPE_ADHOC:
3947 case NL80211_IFTYPE_MESH_POINT:
3954 /* driver will call cfg80211_check_station_change() */
3955 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
3959 dev_put(params.vlan);
3964 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
3966 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3968 struct net_device *dev = info->user_ptr[1];
3969 struct station_parameters params;
3970 u8 *mac_addr = NULL;
3972 memset(¶ms, 0, sizeof(params));
3974 if (!rdev->ops->add_station)
3977 if (!info->attrs[NL80211_ATTR_MAC])
3980 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
3983 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
3986 if (!info->attrs[NL80211_ATTR_STA_AID])
3989 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3990 params.supported_rates =
3991 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3992 params.supported_rates_len =
3993 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3994 params.listen_interval =
3995 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
3997 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
3998 if (!params.aid || params.aid > IEEE80211_MAX_AID)
4001 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4003 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4004 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4007 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4009 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4010 params.ext_capab_len =
4011 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4014 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4016 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4018 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4020 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4022 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
4023 params.plink_action =
4024 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4025 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4029 err = nl80211_parse_sta_wme(info, ¶ms);
4033 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
4036 /* When you run into this, adjust the code below for the new flag */
4037 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4039 switch (dev->ieee80211_ptr->iftype) {
4040 case NL80211_IFTYPE_AP:
4041 case NL80211_IFTYPE_AP_VLAN:
4042 case NL80211_IFTYPE_P2P_GO:
4043 /* ignore WME attributes if iface/sta is not capable */
4044 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
4045 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
4046 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4048 /* TDLS peers cannot be added */
4049 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4051 /* but don't bother the driver with it */
4052 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4054 /* allow authenticated/associated only if driver handles it */
4055 if (!(rdev->wiphy.features &
4056 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4057 params.sta_flags_mask &
4058 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4059 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4062 /* must be last in here for error handling */
4063 params.vlan = get_vlan(info, rdev);
4064 if (IS_ERR(params.vlan))
4065 return PTR_ERR(params.vlan);
4067 case NL80211_IFTYPE_MESH_POINT:
4068 /* ignore uAPSD data */
4069 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4071 /* associated is disallowed */
4072 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
4074 /* TDLS peers cannot be added */
4075 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4078 case NL80211_IFTYPE_STATION:
4079 case NL80211_IFTYPE_P2P_CLIENT:
4080 /* ignore uAPSD data */
4081 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4083 /* these are disallowed */
4084 if (params.sta_flags_mask &
4085 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
4086 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
4088 /* Only TDLS peers can be added */
4089 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4091 /* Can only add if TDLS ... */
4092 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
4094 /* ... with external setup is supported */
4095 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
4098 * Older wpa_supplicant versions always mark the TDLS peer
4099 * as authorized, but it shouldn't yet be.
4101 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
4107 /* be aware of params.vlan when changing code here */
4109 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
4112 dev_put(params.vlan);
4116 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
4118 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4119 struct net_device *dev = info->user_ptr[1];
4120 u8 *mac_addr = NULL;
4122 if (info->attrs[NL80211_ATTR_MAC])
4123 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4125 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4126 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4127 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4128 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4131 if (!rdev->ops->del_station)
4134 return rdev_del_station(rdev, dev, mac_addr);
4137 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
4138 int flags, struct net_device *dev,
4139 u8 *dst, u8 *next_hop,
4140 struct mpath_info *pinfo)
4143 struct nlattr *pinfoattr;
4145 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
4149 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4150 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
4151 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
4152 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
4153 goto nla_put_failure;
4155 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
4157 goto nla_put_failure;
4158 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
4159 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
4161 goto nla_put_failure;
4162 if (((pinfo->filled & MPATH_INFO_SN) &&
4163 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
4164 ((pinfo->filled & MPATH_INFO_METRIC) &&
4165 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
4167 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
4168 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
4170 ((pinfo->filled & MPATH_INFO_FLAGS) &&
4171 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
4173 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
4174 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
4175 pinfo->discovery_timeout)) ||
4176 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
4177 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
4178 pinfo->discovery_retries)))
4179 goto nla_put_failure;
4181 nla_nest_end(msg, pinfoattr);
4183 return genlmsg_end(msg, hdr);
4186 genlmsg_cancel(msg, hdr);
4190 static int nl80211_dump_mpath(struct sk_buff *skb,
4191 struct netlink_callback *cb)
4193 struct mpath_info pinfo;
4194 struct cfg80211_registered_device *dev;
4195 struct wireless_dev *wdev;
4197 u8 next_hop[ETH_ALEN];
4198 int path_idx = cb->args[2];
4201 err = nl80211_prepare_wdev_dump(skb, cb, &dev, &wdev);
4205 if (!dev->ops->dump_mpath) {
4210 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
4216 err = rdev_dump_mpath(dev, wdev->netdev, path_idx, dst,
4223 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
4224 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4225 wdev->netdev, dst, next_hop,
4234 cb->args[2] = path_idx;
4237 nl80211_finish_wdev_dump(dev);
4241 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
4243 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4245 struct net_device *dev = info->user_ptr[1];
4246 struct mpath_info pinfo;
4247 struct sk_buff *msg;
4249 u8 next_hop[ETH_ALEN];
4251 memset(&pinfo, 0, sizeof(pinfo));
4253 if (!info->attrs[NL80211_ATTR_MAC])
4256 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4258 if (!rdev->ops->get_mpath)
4261 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4264 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
4268 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4272 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4273 dev, dst, next_hop, &pinfo) < 0) {
4278 return genlmsg_reply(msg, info);
4281 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
4283 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4284 struct net_device *dev = info->user_ptr[1];
4286 u8 *next_hop = NULL;
4288 if (!info->attrs[NL80211_ATTR_MAC])
4291 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4294 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4295 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4297 if (!rdev->ops->change_mpath)
4300 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4303 return rdev_change_mpath(rdev, dev, dst, next_hop);
4306 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
4308 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4309 struct net_device *dev = info->user_ptr[1];
4311 u8 *next_hop = NULL;
4313 if (!info->attrs[NL80211_ATTR_MAC])
4316 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4319 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4320 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4322 if (!rdev->ops->add_mpath)
4325 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4328 return rdev_add_mpath(rdev, dev, dst, next_hop);
4331 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
4333 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4334 struct net_device *dev = info->user_ptr[1];
4337 if (info->attrs[NL80211_ATTR_MAC])
4338 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4340 if (!rdev->ops->del_mpath)
4343 return rdev_del_mpath(rdev, dev, dst);
4346 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
4348 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4349 struct net_device *dev = info->user_ptr[1];
4350 struct bss_parameters params;
4352 memset(¶ms, 0, sizeof(params));
4353 /* default to not changing parameters */
4354 params.use_cts_prot = -1;
4355 params.use_short_preamble = -1;
4356 params.use_short_slot_time = -1;
4357 params.ap_isolate = -1;
4358 params.ht_opmode = -1;
4359 params.p2p_ctwindow = -1;
4360 params.p2p_opp_ps = -1;
4362 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
4363 params.use_cts_prot =
4364 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
4365 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
4366 params.use_short_preamble =
4367 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
4368 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
4369 params.use_short_slot_time =
4370 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
4371 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
4372 params.basic_rates =
4373 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4374 params.basic_rates_len =
4375 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4377 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
4378 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
4379 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
4381 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
4383 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4384 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4386 params.p2p_ctwindow =
4387 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4388 if (params.p2p_ctwindow < 0)
4390 if (params.p2p_ctwindow != 0 &&
4391 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4395 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4398 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4400 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4403 params.p2p_opp_ps = tmp;
4404 if (params.p2p_opp_ps &&
4405 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4409 if (!rdev->ops->change_bss)
4412 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4413 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4416 return rdev_change_bss(rdev, dev, ¶ms);
4419 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
4420 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
4421 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
4422 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
4423 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
4424 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
4425 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
4428 static int parse_reg_rule(struct nlattr *tb[],
4429 struct ieee80211_reg_rule *reg_rule)
4431 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
4432 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
4434 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
4436 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
4438 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
4440 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
4442 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
4445 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
4447 freq_range->start_freq_khz =
4448 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
4449 freq_range->end_freq_khz =
4450 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
4451 freq_range->max_bandwidth_khz =
4452 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
4454 power_rule->max_eirp =
4455 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
4457 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
4458 power_rule->max_antenna_gain =
4459 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
4464 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
4468 enum nl80211_user_reg_hint_type user_reg_hint_type;
4471 * You should only get this when cfg80211 hasn't yet initialized
4472 * completely when built-in to the kernel right between the time
4473 * window between nl80211_init() and regulatory_init(), if that is
4476 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
4477 return -EINPROGRESS;
4479 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4482 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4484 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
4485 user_reg_hint_type =
4486 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
4488 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
4490 switch (user_reg_hint_type) {
4491 case NL80211_USER_REG_HINT_USER:
4492 case NL80211_USER_REG_HINT_CELL_BASE:
4498 r = regulatory_hint_user(data, user_reg_hint_type);
4503 static int nl80211_get_mesh_config(struct sk_buff *skb,
4504 struct genl_info *info)
4506 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4507 struct net_device *dev = info->user_ptr[1];
4508 struct wireless_dev *wdev = dev->ieee80211_ptr;
4509 struct mesh_config cur_params;
4512 struct nlattr *pinfoattr;
4513 struct sk_buff *msg;
4515 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4518 if (!rdev->ops->get_mesh_config)
4522 /* If not connected, get default parameters */
4523 if (!wdev->mesh_id_len)
4524 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
4526 err = rdev_get_mesh_config(rdev, dev, &cur_params);
4532 /* Draw up a netlink message to send back */
4533 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4536 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4537 NL80211_CMD_GET_MESH_CONFIG);
4540 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
4542 goto nla_put_failure;
4543 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4544 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
4545 cur_params.dot11MeshRetryTimeout) ||
4546 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4547 cur_params.dot11MeshConfirmTimeout) ||
4548 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
4549 cur_params.dot11MeshHoldingTimeout) ||
4550 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
4551 cur_params.dot11MeshMaxPeerLinks) ||
4552 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
4553 cur_params.dot11MeshMaxRetries) ||
4554 nla_put_u8(msg, NL80211_MESHCONF_TTL,
4555 cur_params.dot11MeshTTL) ||
4556 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
4557 cur_params.element_ttl) ||
4558 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4559 cur_params.auto_open_plinks) ||
4560 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4561 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
4562 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4563 cur_params.dot11MeshHWMPmaxPREQretries) ||
4564 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
4565 cur_params.path_refresh_time) ||
4566 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4567 cur_params.min_discovery_timeout) ||
4568 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4569 cur_params.dot11MeshHWMPactivePathTimeout) ||
4570 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4571 cur_params.dot11MeshHWMPpreqMinInterval) ||
4572 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4573 cur_params.dot11MeshHWMPperrMinInterval) ||
4574 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4575 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
4576 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
4577 cur_params.dot11MeshHWMPRootMode) ||
4578 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4579 cur_params.dot11MeshHWMPRannInterval) ||
4580 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4581 cur_params.dot11MeshGateAnnouncementProtocol) ||
4582 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
4583 cur_params.dot11MeshForwarding) ||
4584 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
4585 cur_params.rssi_threshold) ||
4586 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
4587 cur_params.ht_opmode) ||
4588 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4589 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
4590 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4591 cur_params.dot11MeshHWMProotInterval) ||
4592 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
4593 cur_params.dot11MeshHWMPconfirmationInterval) ||
4594 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
4595 cur_params.power_mode) ||
4596 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
4597 cur_params.dot11MeshAwakeWindowDuration))
4598 goto nla_put_failure;
4599 nla_nest_end(msg, pinfoattr);
4600 genlmsg_end(msg, hdr);
4601 return genlmsg_reply(msg, info);
4604 genlmsg_cancel(msg, hdr);
4610 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
4611 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
4612 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
4613 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
4614 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
4615 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
4616 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
4617 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
4618 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
4619 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
4620 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
4621 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
4622 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
4623 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
4624 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
4625 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
4626 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
4627 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
4628 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
4629 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
4630 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
4631 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
4632 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
4633 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
4634 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
4635 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
4636 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
4637 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
4640 static const struct nla_policy
4641 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
4642 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
4643 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
4644 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
4645 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
4646 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
4647 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
4648 .len = IEEE80211_MAX_DATA_LEN },
4649 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
4652 static int nl80211_parse_mesh_config(struct genl_info *info,
4653 struct mesh_config *cfg,
4656 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
4659 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
4662 if (fn(tb[attr]) < min || fn(tb[attr]) > max) \
4664 cfg->param = fn(tb[attr]); \
4665 mask |= (1 << (attr - 1)); \
4670 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
4672 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
4673 info->attrs[NL80211_ATTR_MESH_CONFIG],
4674 nl80211_meshconf_params_policy))
4677 /* This makes sure that there aren't more than 32 mesh config
4678 * parameters (otherwise our bitfield scheme would not work.) */
4679 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
4681 /* Fill in the params struct */
4682 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
4683 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
4685 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
4686 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4688 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
4689 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
4691 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
4692 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
4694 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
4695 mask, NL80211_MESHCONF_MAX_RETRIES,
4697 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
4698 mask, NL80211_MESHCONF_TTL, nla_get_u8);
4699 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
4700 mask, NL80211_MESHCONF_ELEMENT_TTL,
4702 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
4703 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4705 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
4707 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4709 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
4710 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4712 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
4713 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
4715 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
4716 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4718 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
4720 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4722 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
4724 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4726 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
4728 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4730 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4731 dot11MeshHWMPnetDiameterTraversalTime,
4733 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4735 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
4736 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
4738 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
4739 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4741 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4742 dot11MeshGateAnnouncementProtocol, 0, 1,
4743 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4745 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
4746 mask, NL80211_MESHCONF_FORWARDING,
4748 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, 1, 255,
4749 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
4751 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode, 0, 16,
4752 mask, NL80211_MESHCONF_HT_OPMODE,
4754 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
4756 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4758 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
4759 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4761 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4762 dot11MeshHWMPconfirmationInterval,
4764 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
4766 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
4767 NL80211_MESH_POWER_ACTIVE,
4768 NL80211_MESH_POWER_MAX,
4769 mask, NL80211_MESHCONF_POWER_MODE,
4771 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
4773 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
4779 #undef FILL_IN_MESH_PARAM_IF_SET
4782 static int nl80211_parse_mesh_setup(struct genl_info *info,
4783 struct mesh_setup *setup)
4785 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4786 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
4788 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
4790 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
4791 info->attrs[NL80211_ATTR_MESH_SETUP],
4792 nl80211_mesh_setup_params_policy))
4795 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
4796 setup->sync_method =
4797 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
4798 IEEE80211_SYNC_METHOD_VENDOR :
4799 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
4801 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
4802 setup->path_sel_proto =
4803 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
4804 IEEE80211_PATH_PROTOCOL_VENDOR :
4805 IEEE80211_PATH_PROTOCOL_HWMP;
4807 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
4808 setup->path_metric =
4809 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
4810 IEEE80211_PATH_METRIC_VENDOR :
4811 IEEE80211_PATH_METRIC_AIRTIME;
4814 if (tb[NL80211_MESH_SETUP_IE]) {
4815 struct nlattr *ieattr =
4816 tb[NL80211_MESH_SETUP_IE];
4817 if (!is_valid_ie_attr(ieattr))
4819 setup->ie = nla_data(ieattr);
4820 setup->ie_len = nla_len(ieattr);
4822 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
4823 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
4825 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
4826 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
4827 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
4828 if (setup->is_secure)
4829 setup->user_mpm = true;
4834 static int nl80211_update_mesh_config(struct sk_buff *skb,
4835 struct genl_info *info)
4837 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4838 struct net_device *dev = info->user_ptr[1];
4839 struct wireless_dev *wdev = dev->ieee80211_ptr;
4840 struct mesh_config cfg;
4844 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4847 if (!rdev->ops->update_mesh_config)
4850 err = nl80211_parse_mesh_config(info, &cfg, &mask);
4855 if (!wdev->mesh_id_len)
4859 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
4866 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
4868 const struct ieee80211_regdomain *regdom;
4869 struct sk_buff *msg;
4871 struct nlattr *nl_reg_rules;
4875 mutex_lock(&cfg80211_mutex);
4877 if (!cfg80211_regdomain)
4880 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4886 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4887 NL80211_CMD_GET_REG);
4891 if (reg_last_request_cell_base() &&
4892 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
4893 NL80211_USER_REG_HINT_CELL_BASE))
4894 goto nla_put_failure;
4897 regdom = rcu_dereference(cfg80211_regdomain);
4899 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
4900 (regdom->dfs_region &&
4901 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
4902 goto nla_put_failure_rcu;
4904 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
4906 goto nla_put_failure_rcu;
4908 for (i = 0; i < regdom->n_reg_rules; i++) {
4909 struct nlattr *nl_reg_rule;
4910 const struct ieee80211_reg_rule *reg_rule;
4911 const struct ieee80211_freq_range *freq_range;
4912 const struct ieee80211_power_rule *power_rule;
4914 reg_rule = ®dom->reg_rules[i];
4915 freq_range = ®_rule->freq_range;
4916 power_rule = ®_rule->power_rule;
4918 nl_reg_rule = nla_nest_start(msg, i);
4920 goto nla_put_failure_rcu;
4922 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
4924 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
4925 freq_range->start_freq_khz) ||
4926 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
4927 freq_range->end_freq_khz) ||
4928 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
4929 freq_range->max_bandwidth_khz) ||
4930 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
4931 power_rule->max_antenna_gain) ||
4932 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
4933 power_rule->max_eirp))
4934 goto nla_put_failure_rcu;
4936 nla_nest_end(msg, nl_reg_rule);
4940 nla_nest_end(msg, nl_reg_rules);
4942 genlmsg_end(msg, hdr);
4943 err = genlmsg_reply(msg, info);
4946 nla_put_failure_rcu:
4949 genlmsg_cancel(msg, hdr);
4954 mutex_unlock(&cfg80211_mutex);
4958 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
4960 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
4961 struct nlattr *nl_reg_rule;
4962 char *alpha2 = NULL;
4963 int rem_reg_rules = 0, r = 0;
4964 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4966 struct ieee80211_regdomain *rd = NULL;
4968 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4971 if (!info->attrs[NL80211_ATTR_REG_RULES])
4974 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4976 if (info->attrs[NL80211_ATTR_DFS_REGION])
4977 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
4979 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
4982 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4986 size_of_regd = sizeof(struct ieee80211_regdomain) +
4987 num_rules * sizeof(struct ieee80211_reg_rule);
4989 rd = kzalloc(size_of_regd, GFP_KERNEL);
4993 rd->n_reg_rules = num_rules;
4994 rd->alpha2[0] = alpha2[0];
4995 rd->alpha2[1] = alpha2[1];
4998 * Disable DFS master mode if the DFS region was
4999 * not supported or known on this kernel.
5001 if (reg_supported_dfs_region(dfs_region))
5002 rd->dfs_region = dfs_region;
5004 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
5006 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
5007 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
5009 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
5015 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
5021 mutex_lock(&cfg80211_mutex);
5024 /* set_regdom took ownership */
5026 mutex_unlock(&cfg80211_mutex);
5033 static int validate_scan_freqs(struct nlattr *freqs)
5035 struct nlattr *attr1, *attr2;
5036 int n_channels = 0, tmp1, tmp2;
5038 nla_for_each_nested(attr1, freqs, tmp1) {
5041 * Some hardware has a limited channel list for
5042 * scanning, and it is pretty much nonsensical
5043 * to scan for a channel twice, so disallow that
5044 * and don't require drivers to check that the
5045 * channel list they get isn't longer than what
5046 * they can scan, as long as they can scan all
5047 * the channels they registered at once.
5049 nla_for_each_nested(attr2, freqs, tmp2)
5050 if (attr1 != attr2 &&
5051 nla_get_u32(attr1) == nla_get_u32(attr2))
5058 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
5060 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5061 struct wireless_dev *wdev = info->user_ptr[1];
5062 struct cfg80211_scan_request *request;
5063 struct nlattr *attr;
5064 struct wiphy *wiphy;
5065 int err, tmp, n_ssids = 0, n_channels, i;
5068 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5071 wiphy = &rdev->wiphy;
5073 if (!rdev->ops->scan)
5076 mutex_lock(&rdev->sched_scan_mtx);
5077 if (rdev->scan_req) {
5082 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5083 n_channels = validate_scan_freqs(
5084 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5090 enum ieee80211_band band;
5093 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
5094 if (wiphy->bands[band])
5095 n_channels += wiphy->bands[band]->n_channels;
5098 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5099 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
5102 if (n_ssids > wiphy->max_scan_ssids) {
5107 if (info->attrs[NL80211_ATTR_IE])
5108 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5112 if (ie_len > wiphy->max_scan_ie_len) {
5117 request = kzalloc(sizeof(*request)
5118 + sizeof(*request->ssids) * n_ssids
5119 + sizeof(*request->channels) * n_channels
5120 + ie_len, GFP_KERNEL);
5127 request->ssids = (void *)&request->channels[n_channels];
5128 request->n_ssids = n_ssids;
5131 request->ie = (void *)(request->ssids + n_ssids);
5133 request->ie = (void *)(request->channels + n_channels);
5137 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5138 /* user specified, bail out if channel not found */
5139 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
5140 struct ieee80211_channel *chan;
5142 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5149 /* ignore disabled channels */
5150 if (chan->flags & IEEE80211_CHAN_DISABLED)
5153 request->channels[i] = chan;
5157 enum ieee80211_band band;
5160 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5162 if (!wiphy->bands[band])
5164 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5165 struct ieee80211_channel *chan;
5167 chan = &wiphy->bands[band]->channels[j];
5169 if (chan->flags & IEEE80211_CHAN_DISABLED)
5172 request->channels[i] = chan;
5183 request->n_channels = i;
5186 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5187 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
5188 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5192 request->ssids[i].ssid_len = nla_len(attr);
5193 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
5198 if (info->attrs[NL80211_ATTR_IE]) {
5199 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5200 memcpy((void *)request->ie,
5201 nla_data(info->attrs[NL80211_ATTR_IE]),
5205 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
5206 if (wiphy->bands[i])
5208 (1 << wiphy->bands[i]->n_bitrates) - 1;
5210 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
5211 nla_for_each_nested(attr,
5212 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
5214 enum ieee80211_band band = nla_type(attr);
5216 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
5220 err = ieee80211_get_ratemask(wiphy->bands[band],
5223 &request->rates[band]);
5229 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5230 request->flags = nla_get_u32(
5231 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5232 if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5233 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
5234 ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
5235 !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
5242 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5244 request->wdev = wdev;
5245 request->wiphy = &rdev->wiphy;
5246 request->scan_start = jiffies;
5248 rdev->scan_req = request;
5249 err = rdev_scan(rdev, request);
5252 nl80211_send_scan_start(rdev, wdev);
5254 dev_hold(wdev->netdev);
5257 rdev->scan_req = NULL;
5262 mutex_unlock(&rdev->sched_scan_mtx);
5266 static int nl80211_start_sched_scan(struct sk_buff *skb,
5267 struct genl_info *info)
5269 struct cfg80211_sched_scan_request *request;
5270 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5271 struct net_device *dev = info->user_ptr[1];
5272 struct nlattr *attr;
5273 struct wiphy *wiphy;
5274 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
5276 enum ieee80211_band band;
5278 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
5280 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5281 !rdev->ops->sched_scan_start)
5284 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5287 if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
5290 interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
5294 wiphy = &rdev->wiphy;
5296 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5297 n_channels = validate_scan_freqs(
5298 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5304 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
5305 if (wiphy->bands[band])
5306 n_channels += wiphy->bands[band]->n_channels;
5309 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5310 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5314 if (n_ssids > wiphy->max_sched_scan_ssids)
5317 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH])
5318 nla_for_each_nested(attr,
5319 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5323 if (n_match_sets > wiphy->max_match_sets)
5326 if (info->attrs[NL80211_ATTR_IE])
5327 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5331 if (ie_len > wiphy->max_sched_scan_ie_len)
5334 mutex_lock(&rdev->sched_scan_mtx);
5336 if (rdev->sched_scan_req) {
5341 request = kzalloc(sizeof(*request)
5342 + sizeof(*request->ssids) * n_ssids
5343 + sizeof(*request->match_sets) * n_match_sets
5344 + sizeof(*request->channels) * n_channels
5345 + ie_len, GFP_KERNEL);
5352 request->ssids = (void *)&request->channels[n_channels];
5353 request->n_ssids = n_ssids;
5356 request->ie = (void *)(request->ssids + n_ssids);
5358 request->ie = (void *)(request->channels + n_channels);
5363 request->match_sets = (void *)(request->ie + ie_len);
5364 else if (request->ssids)
5365 request->match_sets =
5366 (void *)(request->ssids + n_ssids);
5368 request->match_sets =
5369 (void *)(request->channels + n_channels);
5371 request->n_match_sets = n_match_sets;
5374 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5375 /* user specified, bail out if channel not found */
5376 nla_for_each_nested(attr,
5377 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
5379 struct ieee80211_channel *chan;
5381 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5388 /* ignore disabled channels */
5389 if (chan->flags & IEEE80211_CHAN_DISABLED)
5392 request->channels[i] = chan;
5397 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5399 if (!wiphy->bands[band])
5401 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5402 struct ieee80211_channel *chan;
5404 chan = &wiphy->bands[band]->channels[j];
5406 if (chan->flags & IEEE80211_CHAN_DISABLED)
5409 request->channels[i] = chan;
5420 request->n_channels = i;
5423 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5424 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5426 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5430 request->ssids[i].ssid_len = nla_len(attr);
5431 memcpy(request->ssids[i].ssid, nla_data(attr),
5438 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
5439 nla_for_each_nested(attr,
5440 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5442 struct nlattr *ssid, *rssi;
5444 nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
5445 nla_data(attr), nla_len(attr),
5446 nl80211_match_policy);
5447 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
5449 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
5453 memcpy(request->match_sets[i].ssid.ssid,
5454 nla_data(ssid), nla_len(ssid));
5455 request->match_sets[i].ssid.ssid_len =
5458 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
5460 request->rssi_thold = nla_get_u32(rssi);
5462 request->rssi_thold =
5463 NL80211_SCAN_RSSI_THOLD_OFF;
5468 if (info->attrs[NL80211_ATTR_IE]) {
5469 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5470 memcpy((void *)request->ie,
5471 nla_data(info->attrs[NL80211_ATTR_IE]),
5475 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5476 request->flags = nla_get_u32(
5477 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5478 if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5479 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
5480 ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
5481 !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
5488 request->wiphy = &rdev->wiphy;
5489 request->interval = interval;
5490 request->scan_start = jiffies;
5492 err = rdev_sched_scan_start(rdev, dev, request);
5494 rdev->sched_scan_req = request;
5495 nl80211_send_sched_scan(rdev, dev,
5496 NL80211_CMD_START_SCHED_SCAN);
5503 mutex_unlock(&rdev->sched_scan_mtx);
5507 static int nl80211_stop_sched_scan(struct sk_buff *skb,
5508 struct genl_info *info)
5510 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5513 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5514 !rdev->ops->sched_scan_stop)
5517 mutex_lock(&rdev->sched_scan_mtx);
5518 err = __cfg80211_stop_sched_scan(rdev, false);
5519 mutex_unlock(&rdev->sched_scan_mtx);
5524 static int nl80211_start_radar_detection(struct sk_buff *skb,
5525 struct genl_info *info)
5527 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5528 struct net_device *dev = info->user_ptr[1];
5529 struct wireless_dev *wdev = dev->ieee80211_ptr;
5530 struct cfg80211_chan_def chandef;
5533 err = nl80211_parse_chandef(rdev, info, &chandef);
5537 if (wdev->cac_started)
5540 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef);
5547 if (chandef.chan->dfs_state != NL80211_DFS_USABLE)
5550 if (!rdev->ops->start_radar_detection)
5553 mutex_lock(&rdev->devlist_mtx);
5554 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
5555 chandef.chan, CHAN_MODE_SHARED,
5556 BIT(chandef.width));
5560 err = rdev->ops->start_radar_detection(&rdev->wiphy, dev, &chandef);
5562 wdev->channel = chandef.chan;
5563 wdev->cac_started = true;
5564 wdev->cac_start_time = jiffies;
5567 mutex_unlock(&rdev->devlist_mtx);
5572 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
5574 struct cfg80211_registered_device *rdev,
5575 struct wireless_dev *wdev,
5576 struct cfg80211_internal_bss *intbss)
5578 struct cfg80211_bss *res = &intbss->pub;
5579 const struct cfg80211_bss_ies *ies;
5584 ASSERT_WDEV_LOCK(wdev);
5586 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
5587 NL80211_CMD_NEW_SCAN_RESULTS);
5591 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
5593 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
5594 goto nla_put_failure;
5596 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
5597 goto nla_put_failure;
5598 if (nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
5599 goto nla_put_failure;
5601 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
5603 goto nla_put_failure;
5604 if ((!is_zero_ether_addr(res->bssid) &&
5605 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
5606 goto nla_put_failure;
5609 ies = rcu_dereference(res->ies);
5611 if (nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
5612 goto fail_unlock_rcu;
5614 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
5615 ies->len, ies->data))
5616 goto fail_unlock_rcu;
5618 ies = rcu_dereference(res->beacon_ies);
5620 if (!tsf && nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
5621 goto fail_unlock_rcu;
5622 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
5623 ies->len, ies->data))
5624 goto fail_unlock_rcu;
5628 if (res->beacon_interval &&
5629 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
5630 goto nla_put_failure;
5631 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
5632 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
5633 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
5634 jiffies_to_msecs(jiffies - intbss->ts)))
5635 goto nla_put_failure;
5637 switch (rdev->wiphy.signal_type) {
5638 case CFG80211_SIGNAL_TYPE_MBM:
5639 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
5640 goto nla_put_failure;
5642 case CFG80211_SIGNAL_TYPE_UNSPEC:
5643 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
5644 goto nla_put_failure;
5650 switch (wdev->iftype) {
5651 case NL80211_IFTYPE_P2P_CLIENT:
5652 case NL80211_IFTYPE_STATION:
5653 if (intbss == wdev->current_bss &&
5654 nla_put_u32(msg, NL80211_BSS_STATUS,
5655 NL80211_BSS_STATUS_ASSOCIATED))
5656 goto nla_put_failure;
5658 case NL80211_IFTYPE_ADHOC:
5659 if (intbss == wdev->current_bss &&
5660 nla_put_u32(msg, NL80211_BSS_STATUS,
5661 NL80211_BSS_STATUS_IBSS_JOINED))
5662 goto nla_put_failure;
5668 nla_nest_end(msg, bss);
5670 return genlmsg_end(msg, hdr);
5675 genlmsg_cancel(msg, hdr);
5679 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
5681 struct cfg80211_registered_device *rdev;
5682 struct cfg80211_internal_bss *scan;
5683 struct wireless_dev *wdev;
5684 int start = cb->args[2], idx = 0;
5687 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
5692 spin_lock_bh(&rdev->bss_lock);
5693 cfg80211_bss_expire(rdev);
5695 cb->seq = rdev->bss_generation;
5697 list_for_each_entry(scan, &rdev->bss_list, list) {
5700 if (nl80211_send_bss(skb, cb,
5701 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5702 rdev, wdev, scan) < 0) {
5708 spin_unlock_bh(&rdev->bss_lock);
5712 nl80211_finish_wdev_dump(rdev);
5717 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
5718 int flags, struct net_device *dev,
5719 struct survey_info *survey)
5722 struct nlattr *infoattr;
5724 hdr = nl80211hdr_put(msg, portid, seq, flags,
5725 NL80211_CMD_NEW_SURVEY_RESULTS);
5729 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
5730 goto nla_put_failure;
5732 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
5734 goto nla_put_failure;
5736 if (nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
5737 survey->channel->center_freq))
5738 goto nla_put_failure;
5740 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
5741 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
5742 goto nla_put_failure;
5743 if ((survey->filled & SURVEY_INFO_IN_USE) &&
5744 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
5745 goto nla_put_failure;
5746 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME) &&
5747 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME,
5748 survey->channel_time))
5749 goto nla_put_failure;
5750 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_BUSY) &&
5751 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY,
5752 survey->channel_time_busy))
5753 goto nla_put_failure;
5754 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) &&
5755 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY,
5756 survey->channel_time_ext_busy))
5757 goto nla_put_failure;
5758 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_RX) &&
5759 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_RX,
5760 survey->channel_time_rx))
5761 goto nla_put_failure;
5762 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_TX) &&
5763 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_TX,
5764 survey->channel_time_tx))
5765 goto nla_put_failure;
5767 nla_nest_end(msg, infoattr);
5769 return genlmsg_end(msg, hdr);
5772 genlmsg_cancel(msg, hdr);
5776 static int nl80211_dump_survey(struct sk_buff *skb,
5777 struct netlink_callback *cb)
5779 struct survey_info survey;
5780 struct cfg80211_registered_device *dev;
5781 struct wireless_dev *wdev;
5782 int survey_idx = cb->args[2];
5785 res = nl80211_prepare_wdev_dump(skb, cb, &dev, &wdev);
5789 if (!wdev->netdev) {
5794 if (!dev->ops->dump_survey) {
5800 struct ieee80211_channel *chan;
5802 res = rdev_dump_survey(dev, wdev->netdev, survey_idx, &survey);
5808 /* Survey without a channel doesn't make sense */
5809 if (!survey.channel) {
5814 chan = ieee80211_get_channel(&dev->wiphy,
5815 survey.channel->center_freq);
5816 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
5821 if (nl80211_send_survey(skb,
5822 NETLINK_CB(cb->skb).portid,
5823 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5824 wdev->netdev, &survey) < 0)
5830 cb->args[2] = survey_idx;
5833 nl80211_finish_wdev_dump(dev);
5837 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
5839 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
5840 NL80211_WPA_VERSION_2));
5843 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
5845 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5846 struct net_device *dev = info->user_ptr[1];
5847 struct ieee80211_channel *chan;
5848 const u8 *bssid, *ssid, *ie = NULL, *sae_data = NULL;
5849 int err, ssid_len, ie_len = 0, sae_data_len = 0;
5850 enum nl80211_auth_type auth_type;
5851 struct key_parse key;
5852 bool local_state_change;
5854 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5857 if (!info->attrs[NL80211_ATTR_MAC])
5860 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
5863 if (!info->attrs[NL80211_ATTR_SSID])
5866 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
5869 err = nl80211_parse_key(info, &key);
5874 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
5876 if (!key.p.key || !key.p.key_len)
5878 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
5879 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
5880 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
5881 key.p.key_len != WLAN_KEY_LEN_WEP104))
5893 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
5894 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
5903 if (!rdev->ops->auth)
5906 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5907 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5910 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5911 chan = ieee80211_get_channel(&rdev->wiphy,
5912 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
5913 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
5916 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5917 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5919 if (info->attrs[NL80211_ATTR_IE]) {
5920 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5921 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5924 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
5925 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
5928 if (auth_type == NL80211_AUTHTYPE_SAE &&
5929 !info->attrs[NL80211_ATTR_SAE_DATA])
5932 if (info->attrs[NL80211_ATTR_SAE_DATA]) {
5933 if (auth_type != NL80211_AUTHTYPE_SAE)
5935 sae_data = nla_data(info->attrs[NL80211_ATTR_SAE_DATA]);
5936 sae_data_len = nla_len(info->attrs[NL80211_ATTR_SAE_DATA]);
5937 /* need to include at least Auth Transaction and Status Code */
5938 if (sae_data_len < 4)
5942 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
5945 * Since we no longer track auth state, ignore
5946 * requests to only change local state.
5948 if (local_state_change)
5951 return cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
5952 ssid, ssid_len, ie, ie_len,
5953 key.p.key, key.p.key_len, key.idx,
5954 sae_data, sae_data_len);
5957 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
5958 struct genl_info *info,
5959 struct cfg80211_crypto_settings *settings,
5962 memset(settings, 0, sizeof(*settings));
5964 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
5966 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
5968 proto = nla_get_u16(
5969 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
5970 settings->control_port_ethertype = cpu_to_be16(proto);
5971 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
5974 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
5975 settings->control_port_no_encrypt = true;
5977 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
5979 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
5983 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
5984 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
5985 settings->n_ciphers_pairwise = len / sizeof(u32);
5987 if (len % sizeof(u32))
5990 if (settings->n_ciphers_pairwise > cipher_limit)
5993 memcpy(settings->ciphers_pairwise, data, len);
5995 for (i = 0; i < settings->n_ciphers_pairwise; i++)
5996 if (!cfg80211_supported_cipher_suite(
5998 settings->ciphers_pairwise[i]))
6002 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
6003 settings->cipher_group =
6004 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
6005 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
6006 settings->cipher_group))
6010 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
6011 settings->wpa_versions =
6012 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
6013 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
6017 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
6021 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
6022 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
6023 settings->n_akm_suites = len / sizeof(u32);
6025 if (len % sizeof(u32))
6028 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
6031 memcpy(settings->akm_suites, data, len);
6037 static int nl80211_associate(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 ieee80211_channel *chan;
6042 struct cfg80211_assoc_request req = {};
6043 const u8 *bssid, *ssid;
6044 int err, ssid_len = 0;
6046 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6049 if (!info->attrs[NL80211_ATTR_MAC] ||
6050 !info->attrs[NL80211_ATTR_SSID] ||
6051 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
6054 if (!rdev->ops->assoc)
6057 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6058 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6061 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6063 chan = ieee80211_get_channel(&rdev->wiphy,
6064 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
6065 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
6068 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6069 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6071 if (info->attrs[NL80211_ATTR_IE]) {
6072 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6073 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6076 if (info->attrs[NL80211_ATTR_USE_MFP]) {
6077 enum nl80211_mfp mfp =
6078 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
6079 if (mfp == NL80211_MFP_REQUIRED)
6081 else if (mfp != NL80211_MFP_NO)
6085 if (info->attrs[NL80211_ATTR_PREV_BSSID])
6086 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
6088 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
6089 req.flags |= ASSOC_REQ_DISABLE_HT;
6091 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6092 memcpy(&req.ht_capa_mask,
6093 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6094 sizeof(req.ht_capa_mask));
6096 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6097 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6099 memcpy(&req.ht_capa,
6100 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6101 sizeof(req.ht_capa));
6104 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
6105 req.flags |= ASSOC_REQ_DISABLE_VHT;
6107 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6108 memcpy(&req.vht_capa_mask,
6109 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
6110 sizeof(req.vht_capa_mask));
6112 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
6113 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6115 memcpy(&req.vht_capa,
6116 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
6117 sizeof(req.vht_capa));
6120 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
6122 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
6123 ssid, ssid_len, &req);
6128 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
6130 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6131 struct net_device *dev = info->user_ptr[1];
6132 const u8 *ie = NULL, *bssid;
6135 bool local_state_change;
6137 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6140 if (!info->attrs[NL80211_ATTR_MAC])
6143 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6146 if (!rdev->ops->deauth)
6149 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6150 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6153 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6155 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6156 if (reason_code == 0) {
6157 /* Reason Code 0 is reserved */
6161 if (info->attrs[NL80211_ATTR_IE]) {
6162 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6163 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6166 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6168 return cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
6169 local_state_change);
6172 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
6174 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6175 struct net_device *dev = info->user_ptr[1];
6176 const u8 *ie = NULL, *bssid;
6179 bool local_state_change;
6181 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6184 if (!info->attrs[NL80211_ATTR_MAC])
6187 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6190 if (!rdev->ops->disassoc)
6193 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6194 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6197 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6199 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6200 if (reason_code == 0) {
6201 /* Reason Code 0 is reserved */
6205 if (info->attrs[NL80211_ATTR_IE]) {
6206 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6207 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6210 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6212 return cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
6213 local_state_change);
6217 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
6218 int mcast_rate[IEEE80211_NUM_BANDS],
6221 struct wiphy *wiphy = &rdev->wiphy;
6225 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
6226 struct ieee80211_supported_band *sband;
6228 sband = wiphy->bands[band];
6232 for (i = 0; i < sband->n_bitrates; i++) {
6233 if (sband->bitrates[i].bitrate == rateval) {
6234 mcast_rate[band] = i + 1;
6244 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
6246 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6247 struct net_device *dev = info->user_ptr[1];
6248 struct cfg80211_ibss_params ibss;
6249 struct wiphy *wiphy;
6250 struct cfg80211_cached_keys *connkeys = NULL;
6253 memset(&ibss, 0, sizeof(ibss));
6255 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6258 if (!info->attrs[NL80211_ATTR_SSID] ||
6259 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6262 ibss.beacon_interval = 100;
6264 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
6265 ibss.beacon_interval =
6266 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
6267 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
6271 if (!rdev->ops->join_ibss)
6274 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6277 wiphy = &rdev->wiphy;
6279 if (info->attrs[NL80211_ATTR_MAC]) {
6280 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6282 if (!is_valid_ether_addr(ibss.bssid))
6285 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6286 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6288 if (info->attrs[NL80211_ATTR_IE]) {
6289 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6290 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6293 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
6297 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef))
6300 if (ibss.chandef.width > NL80211_CHAN_WIDTH_40)
6302 if (ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
6303 !(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
6306 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
6307 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
6309 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6311 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6313 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6314 struct ieee80211_supported_band *sband =
6315 wiphy->bands[ibss.chandef.chan->band];
6317 err = ieee80211_get_ratemask(sband, rates, n_rates,
6323 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
6324 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
6325 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
6328 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
6331 connkeys = nl80211_parse_connkeys(rdev,
6332 info->attrs[NL80211_ATTR_KEYS],
6334 if (IS_ERR(connkeys))
6335 return PTR_ERR(connkeys);
6337 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
6345 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
6347 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
6353 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
6355 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6356 struct net_device *dev = info->user_ptr[1];
6358 if (!rdev->ops->leave_ibss)
6361 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6364 return cfg80211_leave_ibss(rdev, dev, false);
6367 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
6369 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6370 struct net_device *dev = info->user_ptr[1];
6371 int mcast_rate[IEEE80211_NUM_BANDS];
6375 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
6376 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6379 if (!rdev->ops->set_mcast_rate)
6382 memset(mcast_rate, 0, sizeof(mcast_rate));
6384 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
6387 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
6388 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
6391 err = rdev->ops->set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
6397 #ifdef CONFIG_NL80211_TESTMODE
6398 static struct genl_multicast_group nl80211_testmode_mcgrp = {
6402 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
6404 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6407 if (!info->attrs[NL80211_ATTR_TESTDATA])
6411 if (rdev->ops->testmode_cmd) {
6412 rdev->testmode_info = info;
6413 err = rdev_testmode_cmd(rdev,
6414 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
6415 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
6416 rdev->testmode_info = NULL;
6422 static int nl80211_testmode_dump(struct sk_buff *skb,
6423 struct netlink_callback *cb)
6425 struct cfg80211_registered_device *rdev;
6433 * 0 is a valid index, but not valid for args[0],
6434 * so we need to offset by 1.
6436 phy_idx = cb->args[0] - 1;
6438 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
6439 nl80211_fam.attrbuf, nl80211_fam.maxattr,
6444 mutex_lock(&cfg80211_mutex);
6445 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk),
6446 nl80211_fam.attrbuf);
6448 mutex_unlock(&cfg80211_mutex);
6449 return PTR_ERR(rdev);
6451 phy_idx = rdev->wiphy_idx;
6453 mutex_unlock(&cfg80211_mutex);
6455 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
6457 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
6461 data = nla_data((void *)cb->args[1]);
6462 data_len = nla_len((void *)cb->args[1]);
6465 mutex_lock(&cfg80211_mutex);
6466 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
6468 mutex_unlock(&cfg80211_mutex);
6471 cfg80211_lock_rdev(rdev);
6472 mutex_unlock(&cfg80211_mutex);
6474 if (!rdev->ops->testmode_dump) {
6480 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
6481 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6482 NL80211_CMD_TESTMODE);
6483 struct nlattr *tmdata;
6485 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
6486 genlmsg_cancel(skb, hdr);
6490 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
6492 genlmsg_cancel(skb, hdr);
6495 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
6496 nla_nest_end(skb, tmdata);
6498 if (err == -ENOBUFS || err == -ENOENT) {
6499 genlmsg_cancel(skb, hdr);
6502 genlmsg_cancel(skb, hdr);
6506 genlmsg_end(skb, hdr);
6511 cb->args[0] = phy_idx + 1;
6513 cfg80211_unlock_rdev(rdev);
6517 static struct sk_buff *
6518 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
6519 int approxlen, u32 portid, u32 seq, gfp_t gfp)
6521 struct sk_buff *skb;
6523 struct nlattr *data;
6525 skb = nlmsg_new(approxlen + 100, gfp);
6529 hdr = nl80211hdr_put(skb, portid, seq, 0, NL80211_CMD_TESTMODE);
6535 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
6536 goto nla_put_failure;
6537 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
6539 ((void **)skb->cb)[0] = rdev;
6540 ((void **)skb->cb)[1] = hdr;
6541 ((void **)skb->cb)[2] = data;
6550 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
6553 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6555 if (WARN_ON(!rdev->testmode_info))
6558 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
6559 rdev->testmode_info->snd_portid,
6560 rdev->testmode_info->snd_seq,
6563 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
6565 int cfg80211_testmode_reply(struct sk_buff *skb)
6567 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
6568 void *hdr = ((void **)skb->cb)[1];
6569 struct nlattr *data = ((void **)skb->cb)[2];
6571 if (WARN_ON(!rdev->testmode_info)) {
6576 nla_nest_end(skb, data);
6577 genlmsg_end(skb, hdr);
6578 return genlmsg_reply(skb, rdev->testmode_info);
6580 EXPORT_SYMBOL(cfg80211_testmode_reply);
6582 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
6583 int approxlen, gfp_t gfp)
6585 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6587 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
6589 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
6591 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
6593 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
6594 void *hdr = ((void **)skb->cb)[1];
6595 struct nlattr *data = ((void **)skb->cb)[2];
6597 nla_nest_end(skb, data);
6598 genlmsg_end(skb, hdr);
6599 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), skb, 0,
6600 nl80211_testmode_mcgrp.id, gfp);
6602 EXPORT_SYMBOL(cfg80211_testmode_event);
6605 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
6607 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6608 struct net_device *dev = info->user_ptr[1];
6609 struct cfg80211_connect_params connect;
6610 struct wiphy *wiphy;
6611 struct cfg80211_cached_keys *connkeys = NULL;
6614 memset(&connect, 0, sizeof(connect));
6616 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6619 if (!info->attrs[NL80211_ATTR_SSID] ||
6620 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6623 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
6625 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
6626 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
6627 NL80211_CMD_CONNECT))
6630 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
6632 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
6634 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
6635 NL80211_MAX_NR_CIPHER_SUITES);
6639 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6640 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6643 wiphy = &rdev->wiphy;
6645 connect.bg_scan_period = -1;
6646 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
6647 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
6648 connect.bg_scan_period =
6649 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
6652 if (info->attrs[NL80211_ATTR_MAC])
6653 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6654 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6655 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6657 if (info->attrs[NL80211_ATTR_IE]) {
6658 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6659 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6662 if (info->attrs[NL80211_ATTR_USE_MFP]) {
6663 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
6664 if (connect.mfp != NL80211_MFP_REQUIRED &&
6665 connect.mfp != NL80211_MFP_NO)
6668 connect.mfp = NL80211_MFP_NO;
6671 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6673 ieee80211_get_channel(wiphy,
6674 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
6675 if (!connect.channel ||
6676 connect.channel->flags & IEEE80211_CHAN_DISABLED)
6680 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
6681 connkeys = nl80211_parse_connkeys(rdev,
6682 info->attrs[NL80211_ATTR_KEYS], NULL);
6683 if (IS_ERR(connkeys))
6684 return PTR_ERR(connkeys);
6687 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
6688 connect.flags |= ASSOC_REQ_DISABLE_HT;
6690 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6691 memcpy(&connect.ht_capa_mask,
6692 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6693 sizeof(connect.ht_capa_mask));
6695 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6696 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
6700 memcpy(&connect.ht_capa,
6701 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6702 sizeof(connect.ht_capa));
6705 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
6706 connect.flags |= ASSOC_REQ_DISABLE_VHT;
6708 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6709 memcpy(&connect.vht_capa_mask,
6710 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
6711 sizeof(connect.vht_capa_mask));
6713 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
6714 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
6718 memcpy(&connect.vht_capa,
6719 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
6720 sizeof(connect.vht_capa));
6723 err = cfg80211_connect(rdev, dev, &connect, connkeys);
6729 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
6731 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6732 struct net_device *dev = info->user_ptr[1];
6735 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6736 reason = WLAN_REASON_DEAUTH_LEAVING;
6738 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6743 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6744 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6747 return cfg80211_disconnect(rdev, dev, reason, true);
6750 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
6752 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6757 if (!info->attrs[NL80211_ATTR_PID])
6760 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
6762 net = get_net_ns_by_pid(pid);
6764 return PTR_ERR(net);
6768 /* check if anything to do */
6769 if (!net_eq(wiphy_net(&rdev->wiphy), net))
6770 err = cfg80211_switch_netns(rdev, net);
6776 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
6778 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6779 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
6780 struct cfg80211_pmksa *pmksa) = NULL;
6781 struct net_device *dev = info->user_ptr[1];
6782 struct cfg80211_pmksa pmksa;
6784 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
6786 if (!info->attrs[NL80211_ATTR_MAC])
6789 if (!info->attrs[NL80211_ATTR_PMKID])
6792 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
6793 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6795 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6796 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6799 switch (info->genlhdr->cmd) {
6800 case NL80211_CMD_SET_PMKSA:
6801 rdev_ops = rdev->ops->set_pmksa;
6803 case NL80211_CMD_DEL_PMKSA:
6804 rdev_ops = rdev->ops->del_pmksa;
6814 return rdev_ops(&rdev->wiphy, dev, &pmksa);
6817 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
6819 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6820 struct net_device *dev = info->user_ptr[1];
6822 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6823 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6826 if (!rdev->ops->flush_pmksa)
6829 return rdev_flush_pmksa(rdev, dev);
6832 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
6834 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6835 struct net_device *dev = info->user_ptr[1];
6836 u8 action_code, dialog_token;
6840 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
6841 !rdev->ops->tdls_mgmt)
6844 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
6845 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
6846 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
6847 !info->attrs[NL80211_ATTR_IE] ||
6848 !info->attrs[NL80211_ATTR_MAC])
6851 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
6852 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
6853 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
6854 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
6856 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
6857 dialog_token, status_code,
6858 nla_data(info->attrs[NL80211_ATTR_IE]),
6859 nla_len(info->attrs[NL80211_ATTR_IE]));
6862 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
6864 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6865 struct net_device *dev = info->user_ptr[1];
6866 enum nl80211_tdls_operation operation;
6869 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
6870 !rdev->ops->tdls_oper)
6873 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
6874 !info->attrs[NL80211_ATTR_MAC])
6877 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
6878 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
6880 return rdev_tdls_oper(rdev, dev, peer, operation);
6883 static int nl80211_remain_on_channel(struct sk_buff *skb,
6884 struct genl_info *info)
6886 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6887 struct wireless_dev *wdev = info->user_ptr[1];
6888 struct cfg80211_chan_def chandef;
6889 struct sk_buff *msg;
6895 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
6896 !info->attrs[NL80211_ATTR_DURATION])
6899 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
6901 if (!rdev->ops->remain_on_channel ||
6902 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
6906 * We should be on that channel for at least a minimum amount of
6907 * time (10ms) but no longer than the driver supports.
6909 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
6910 duration > rdev->wiphy.max_remain_on_channel_duration)
6913 err = nl80211_parse_chandef(rdev, info, &chandef);
6917 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6921 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6922 NL80211_CMD_REMAIN_ON_CHANNEL);
6929 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
6935 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
6936 goto nla_put_failure;
6938 genlmsg_end(msg, hdr);
6940 return genlmsg_reply(msg, info);
6949 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
6950 struct genl_info *info)
6952 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6953 struct wireless_dev *wdev = info->user_ptr[1];
6956 if (!info->attrs[NL80211_ATTR_COOKIE])
6959 if (!rdev->ops->cancel_remain_on_channel)
6962 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
6964 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
6967 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
6968 u8 *rates, u8 rates_len)
6973 for (i = 0; i < rates_len; i++) {
6974 int rate = (rates[i] & 0x7f) * 5;
6976 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
6977 struct ieee80211_rate *srate =
6978 &sband->bitrates[ridx];
6979 if (rate == srate->bitrate) {
6984 if (ridx == sband->n_bitrates)
6985 return 0; /* rate not found */
6991 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
6992 u8 *rates, u8 rates_len,
6993 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
6997 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
6999 for (i = 0; i < rates_len; i++) {
7002 ridx = rates[i] / 8;
7003 rbit = BIT(rates[i] % 8);
7005 /* check validity */
7006 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
7009 /* check availability */
7010 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
7019 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
7020 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
7021 .len = NL80211_MAX_SUPP_RATES },
7022 [NL80211_TXRATE_MCS] = { .type = NLA_BINARY,
7023 .len = NL80211_MAX_SUPP_HT_RATES },
7026 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
7027 struct genl_info *info)
7029 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
7030 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7031 struct cfg80211_bitrate_mask mask;
7033 struct net_device *dev = info->user_ptr[1];
7034 struct nlattr *tx_rates;
7035 struct ieee80211_supported_band *sband;
7037 if (info->attrs[NL80211_ATTR_TX_RATES] == NULL)
7040 if (!rdev->ops->set_bitrate_mask)
7043 memset(&mask, 0, sizeof(mask));
7044 /* Default to all rates enabled */
7045 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
7046 sband = rdev->wiphy.bands[i];
7047 mask.control[i].legacy =
7048 sband ? (1 << sband->n_bitrates) - 1 : 0;
7050 memcpy(mask.control[i].mcs,
7051 sband->ht_cap.mcs.rx_mask,
7052 sizeof(mask.control[i].mcs));
7054 memset(mask.control[i].mcs, 0,
7055 sizeof(mask.control[i].mcs));
7059 * The nested attribute uses enum nl80211_band as the index. This maps
7060 * directly to the enum ieee80211_band values used in cfg80211.
7062 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
7063 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
7065 enum ieee80211_band band = nla_type(tx_rates);
7066 if (band < 0 || band >= IEEE80211_NUM_BANDS)
7068 sband = rdev->wiphy.bands[band];
7071 nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
7072 nla_len(tx_rates), nl80211_txattr_policy);
7073 if (tb[NL80211_TXRATE_LEGACY]) {
7074 mask.control[band].legacy = rateset_to_mask(
7076 nla_data(tb[NL80211_TXRATE_LEGACY]),
7077 nla_len(tb[NL80211_TXRATE_LEGACY]));
7078 if ((mask.control[band].legacy == 0) &&
7079 nla_len(tb[NL80211_TXRATE_LEGACY]))
7082 if (tb[NL80211_TXRATE_MCS]) {
7083 if (!ht_rateset_to_mask(
7085 nla_data(tb[NL80211_TXRATE_MCS]),
7086 nla_len(tb[NL80211_TXRATE_MCS]),
7087 mask.control[band].mcs))
7091 if (mask.control[band].legacy == 0) {
7092 /* don't allow empty legacy rates if HT
7093 * is not even supported. */
7094 if (!rdev->wiphy.bands[band]->ht_cap.ht_supported)
7097 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
7098 if (mask.control[band].mcs[i])
7101 /* legacy and mcs rates may not be both empty */
7102 if (i == IEEE80211_HT_MCS_MASK_LEN)
7107 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
7110 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
7112 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7113 struct wireless_dev *wdev = info->user_ptr[1];
7114 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
7116 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
7119 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
7120 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
7122 switch (wdev->iftype) {
7123 case NL80211_IFTYPE_STATION:
7124 case NL80211_IFTYPE_ADHOC:
7125 case NL80211_IFTYPE_P2P_CLIENT:
7126 case NL80211_IFTYPE_AP:
7127 case NL80211_IFTYPE_AP_VLAN:
7128 case NL80211_IFTYPE_MESH_POINT:
7129 case NL80211_IFTYPE_P2P_GO:
7130 case NL80211_IFTYPE_P2P_DEVICE:
7136 /* not much point in registering if we can't reply */
7137 if (!rdev->ops->mgmt_tx)
7140 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
7141 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
7142 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
7145 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
7147 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7148 struct wireless_dev *wdev = info->user_ptr[1];
7149 struct cfg80211_chan_def chandef;
7153 struct sk_buff *msg = NULL;
7154 unsigned int wait = 0;
7155 bool offchan, no_cck, dont_wait_for_ack;
7157 dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
7159 if (!info->attrs[NL80211_ATTR_FRAME])
7162 if (!rdev->ops->mgmt_tx)
7165 switch (wdev->iftype) {
7166 case NL80211_IFTYPE_STATION:
7167 case NL80211_IFTYPE_ADHOC:
7168 case NL80211_IFTYPE_P2P_CLIENT:
7169 case NL80211_IFTYPE_AP:
7170 case NL80211_IFTYPE_AP_VLAN:
7171 case NL80211_IFTYPE_MESH_POINT:
7172 case NL80211_IFTYPE_P2P_GO:
7173 case NL80211_IFTYPE_P2P_DEVICE:
7179 if (info->attrs[NL80211_ATTR_DURATION]) {
7180 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7182 wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
7185 * We should wait on the channel for at least a minimum amount
7186 * of time (10ms) but no longer than the driver supports.
7188 if (wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
7189 wait > rdev->wiphy.max_remain_on_channel_duration)
7194 offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
7196 if (offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7199 no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
7201 err = nl80211_parse_chandef(rdev, info, &chandef);
7205 if (!dont_wait_for_ack) {
7206 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7210 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7219 err = cfg80211_mlme_mgmt_tx(rdev, wdev, chandef.chan, offchan, wait,
7220 nla_data(info->attrs[NL80211_ATTR_FRAME]),
7221 nla_len(info->attrs[NL80211_ATTR_FRAME]),
7222 no_cck, dont_wait_for_ack, &cookie);
7227 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7228 goto nla_put_failure;
7230 genlmsg_end(msg, hdr);
7231 return genlmsg_reply(msg, info);
7243 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
7245 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7246 struct wireless_dev *wdev = info->user_ptr[1];
7249 if (!info->attrs[NL80211_ATTR_COOKIE])
7252 if (!rdev->ops->mgmt_tx_cancel_wait)
7255 switch (wdev->iftype) {
7256 case NL80211_IFTYPE_STATION:
7257 case NL80211_IFTYPE_ADHOC:
7258 case NL80211_IFTYPE_P2P_CLIENT:
7259 case NL80211_IFTYPE_AP:
7260 case NL80211_IFTYPE_AP_VLAN:
7261 case NL80211_IFTYPE_P2P_GO:
7262 case NL80211_IFTYPE_P2P_DEVICE:
7268 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7270 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
7273 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
7275 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7276 struct wireless_dev *wdev;
7277 struct net_device *dev = info->user_ptr[1];
7282 if (!info->attrs[NL80211_ATTR_PS_STATE])
7285 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
7287 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
7290 wdev = dev->ieee80211_ptr;
7292 if (!rdev->ops->set_power_mgmt)
7295 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
7297 if (state == wdev->ps)
7300 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
7306 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
7308 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7309 enum nl80211_ps_state ps_state;
7310 struct wireless_dev *wdev;
7311 struct net_device *dev = info->user_ptr[1];
7312 struct sk_buff *msg;
7316 wdev = dev->ieee80211_ptr;
7318 if (!rdev->ops->set_power_mgmt)
7321 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7325 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7326 NL80211_CMD_GET_POWER_SAVE);
7333 ps_state = NL80211_PS_ENABLED;
7335 ps_state = NL80211_PS_DISABLED;
7337 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
7338 goto nla_put_failure;
7340 genlmsg_end(msg, hdr);
7341 return genlmsg_reply(msg, info);
7350 static struct nla_policy
7351 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] __read_mostly = {
7352 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
7353 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
7354 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
7355 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
7356 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
7357 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
7360 static int nl80211_set_cqm_txe(struct genl_info *info,
7361 u32 rate, u32 pkts, u32 intvl)
7363 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7364 struct wireless_dev *wdev;
7365 struct net_device *dev = info->user_ptr[1];
7367 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
7370 wdev = dev->ieee80211_ptr;
7372 if (!rdev->ops->set_cqm_txe_config)
7375 if (wdev->iftype != NL80211_IFTYPE_STATION &&
7376 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
7379 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
7382 static int nl80211_set_cqm_rssi(struct genl_info *info,
7383 s32 threshold, u32 hysteresis)
7385 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7386 struct wireless_dev *wdev;
7387 struct net_device *dev = info->user_ptr[1];
7392 wdev = dev->ieee80211_ptr;
7394 if (!rdev->ops->set_cqm_rssi_config)
7397 if (wdev->iftype != NL80211_IFTYPE_STATION &&
7398 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
7401 return rdev_set_cqm_rssi_config(rdev, dev, threshold, hysteresis);
7404 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
7406 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
7410 cqm = info->attrs[NL80211_ATTR_CQM];
7416 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
7417 nl80211_attr_cqm_policy);
7421 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
7422 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
7425 threshold = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
7426 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
7427 err = nl80211_set_cqm_rssi(info, threshold, hysteresis);
7428 } else if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
7429 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
7430 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
7431 u32 rate, pkts, intvl;
7432 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
7433 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
7434 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
7435 err = nl80211_set_cqm_txe(info, rate, pkts, intvl);
7443 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
7445 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7446 struct net_device *dev = info->user_ptr[1];
7447 struct mesh_config cfg;
7448 struct mesh_setup setup;
7451 /* start with default */
7452 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
7453 memcpy(&setup, &default_mesh_setup, sizeof(setup));
7455 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
7456 /* and parse parameters if given */
7457 err = nl80211_parse_mesh_config(info, &cfg, NULL);
7462 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
7463 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
7466 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
7467 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
7469 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
7470 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
7471 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
7474 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
7475 setup.beacon_interval =
7476 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
7477 if (setup.beacon_interval < 10 ||
7478 setup.beacon_interval > 10000)
7482 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
7484 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
7485 if (setup.dtim_period < 1 || setup.dtim_period > 100)
7489 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
7490 /* parse additional setup parameters if given */
7491 err = nl80211_parse_mesh_setup(info, &setup);
7497 cfg.auto_open_plinks = false;
7499 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
7500 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
7504 /* cfg80211_join_mesh() will sort it out */
7505 setup.chandef.chan = NULL;
7508 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
7511 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
7513 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7514 struct net_device *dev = info->user_ptr[1];
7516 return cfg80211_leave_mesh(rdev, dev);
7520 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
7521 struct cfg80211_registered_device *rdev)
7523 struct nlattr *nl_pats, *nl_pat;
7526 if (!rdev->wowlan->n_patterns)
7529 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
7533 for (i = 0; i < rdev->wowlan->n_patterns; i++) {
7534 nl_pat = nla_nest_start(msg, i + 1);
7537 pat_len = rdev->wowlan->patterns[i].pattern_len;
7538 if (nla_put(msg, NL80211_WOWLAN_PKTPAT_MASK,
7539 DIV_ROUND_UP(pat_len, 8),
7540 rdev->wowlan->patterns[i].mask) ||
7541 nla_put(msg, NL80211_WOWLAN_PKTPAT_PATTERN,
7542 pat_len, rdev->wowlan->patterns[i].pattern) ||
7543 nla_put_u32(msg, NL80211_WOWLAN_PKTPAT_OFFSET,
7544 rdev->wowlan->patterns[i].pkt_offset))
7546 nla_nest_end(msg, nl_pat);
7548 nla_nest_end(msg, nl_pats);
7553 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
7554 struct cfg80211_wowlan_tcp *tcp)
7556 struct nlattr *nl_tcp;
7561 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
7565 if (nla_put_be32(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
7566 nla_put_be32(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
7567 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
7568 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
7569 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
7570 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
7571 tcp->payload_len, tcp->payload) ||
7572 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
7573 tcp->data_interval) ||
7574 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
7575 tcp->wake_len, tcp->wake_data) ||
7576 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
7577 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
7580 if (tcp->payload_seq.len &&
7581 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
7582 sizeof(tcp->payload_seq), &tcp->payload_seq))
7585 if (tcp->payload_tok.len &&
7586 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
7587 sizeof(tcp->payload_tok) + tcp->tokens_size,
7591 nla_nest_end(msg, nl_tcp);
7596 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
7598 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7599 struct sk_buff *msg;
7601 u32 size = NLMSG_DEFAULT_SIZE;
7603 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns &&
7604 !rdev->wiphy.wowlan.tcp)
7607 if (rdev->wowlan && rdev->wowlan->tcp) {
7608 /* adjust size to have room for all the data */
7609 size += rdev->wowlan->tcp->tokens_size +
7610 rdev->wowlan->tcp->payload_len +
7611 rdev->wowlan->tcp->wake_len +
7612 rdev->wowlan->tcp->wake_len / 8;
7615 msg = nlmsg_new(size, GFP_KERNEL);
7619 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7620 NL80211_CMD_GET_WOWLAN);
7622 goto nla_put_failure;
7625 struct nlattr *nl_wowlan;
7627 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7629 goto nla_put_failure;
7631 if ((rdev->wowlan->any &&
7632 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
7633 (rdev->wowlan->disconnect &&
7634 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
7635 (rdev->wowlan->magic_pkt &&
7636 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
7637 (rdev->wowlan->gtk_rekey_failure &&
7638 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
7639 (rdev->wowlan->eap_identity_req &&
7640 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
7641 (rdev->wowlan->four_way_handshake &&
7642 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
7643 (rdev->wowlan->rfkill_release &&
7644 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
7645 goto nla_put_failure;
7647 if (nl80211_send_wowlan_patterns(msg, rdev))
7648 goto nla_put_failure;
7650 if (nl80211_send_wowlan_tcp(msg, rdev->wowlan->tcp))
7651 goto nla_put_failure;
7653 nla_nest_end(msg, nl_wowlan);
7656 genlmsg_end(msg, hdr);
7657 return genlmsg_reply(msg, info);
7664 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
7665 struct nlattr *attr,
7666 struct cfg80211_wowlan *trig)
7668 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
7669 struct cfg80211_wowlan_tcp *cfg;
7670 struct nl80211_wowlan_tcp_data_token *tok = NULL;
7671 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
7673 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
7676 if (!rdev->wiphy.wowlan.tcp)
7679 err = nla_parse(tb, MAX_NL80211_WOWLAN_TCP,
7680 nla_data(attr), nla_len(attr),
7681 nl80211_wowlan_tcp_policy);
7685 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
7686 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
7687 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
7688 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
7689 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
7690 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
7691 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
7692 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
7695 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
7696 if (data_size > rdev->wiphy.wowlan.tcp->data_payload_max)
7699 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
7700 rdev->wiphy.wowlan.tcp->data_interval_max ||
7701 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
7704 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
7705 if (wake_size > rdev->wiphy.wowlan.tcp->wake_payload_max)
7708 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
7709 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
7712 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
7713 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
7715 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
7716 tokens_size = tokln - sizeof(*tok);
7718 if (!tok->len || tokens_size % tok->len)
7720 if (!rdev->wiphy.wowlan.tcp->tok)
7722 if (tok->len > rdev->wiphy.wowlan.tcp->tok->max_len)
7724 if (tok->len < rdev->wiphy.wowlan.tcp->tok->min_len)
7726 if (tokens_size > rdev->wiphy.wowlan.tcp->tok->bufsize)
7728 if (tok->offset + tok->len > data_size)
7732 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
7733 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
7734 if (!rdev->wiphy.wowlan.tcp->seq)
7736 if (seq->len == 0 || seq->len > 4)
7738 if (seq->len + seq->offset > data_size)
7742 size = sizeof(*cfg);
7744 size += wake_size + wake_mask_size;
7745 size += tokens_size;
7747 cfg = kzalloc(size, GFP_KERNEL);
7750 cfg->src = nla_get_be32(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
7751 cfg->dst = nla_get_be32(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
7752 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
7754 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
7755 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
7759 /* allocate a socket and port for it and use it */
7760 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
7761 IPPROTO_TCP, &cfg->sock, 1);
7766 if (inet_csk_get_port(cfg->sock->sk, port)) {
7767 sock_release(cfg->sock);
7771 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
7777 cfg->src_port = port;
7780 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
7781 cfg->payload_len = data_size;
7782 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
7783 memcpy((void *)cfg->payload,
7784 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
7787 cfg->payload_seq = *seq;
7788 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
7789 cfg->wake_len = wake_size;
7790 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
7791 memcpy((void *)cfg->wake_data,
7792 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
7794 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
7795 data_size + wake_size;
7796 memcpy((void *)cfg->wake_mask,
7797 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
7800 cfg->tokens_size = tokens_size;
7801 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
7809 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
7811 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7812 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
7813 struct cfg80211_wowlan new_triggers = {};
7814 struct cfg80211_wowlan *ntrig;
7815 struct wiphy_wowlan_support *wowlan = &rdev->wiphy.wowlan;
7817 bool prev_enabled = rdev->wowlan;
7819 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns &&
7820 !rdev->wiphy.wowlan.tcp)
7823 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
7824 cfg80211_rdev_free_wowlan(rdev);
7825 rdev->wowlan = NULL;
7829 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
7830 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
7831 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
7832 nl80211_wowlan_policy);
7836 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
7837 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
7839 new_triggers.any = true;
7842 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
7843 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
7845 new_triggers.disconnect = true;
7848 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
7849 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
7851 new_triggers.magic_pkt = true;
7854 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
7857 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
7858 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
7860 new_triggers.gtk_rekey_failure = true;
7863 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
7864 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
7866 new_triggers.eap_identity_req = true;
7869 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
7870 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
7872 new_triggers.four_way_handshake = true;
7875 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
7876 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
7878 new_triggers.rfkill_release = true;
7881 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
7884 int rem, pat_len, mask_len, pkt_offset;
7885 struct nlattr *pat_tb[NUM_NL80211_WOWLAN_PKTPAT];
7887 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
7890 if (n_patterns > wowlan->n_patterns)
7893 new_triggers.patterns = kcalloc(n_patterns,
7894 sizeof(new_triggers.patterns[0]),
7896 if (!new_triggers.patterns)
7899 new_triggers.n_patterns = n_patterns;
7902 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
7904 nla_parse(pat_tb, MAX_NL80211_WOWLAN_PKTPAT,
7905 nla_data(pat), nla_len(pat), NULL);
7907 if (!pat_tb[NL80211_WOWLAN_PKTPAT_MASK] ||
7908 !pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN])
7910 pat_len = nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]);
7911 mask_len = DIV_ROUND_UP(pat_len, 8);
7912 if (nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]) !=
7915 if (pat_len > wowlan->pattern_max_len ||
7916 pat_len < wowlan->pattern_min_len)
7919 if (!pat_tb[NL80211_WOWLAN_PKTPAT_OFFSET])
7922 pkt_offset = nla_get_u32(
7923 pat_tb[NL80211_WOWLAN_PKTPAT_OFFSET]);
7924 if (pkt_offset > wowlan->max_pkt_offset)
7926 new_triggers.patterns[i].pkt_offset = pkt_offset;
7928 new_triggers.patterns[i].mask =
7929 kmalloc(mask_len + pat_len, GFP_KERNEL);
7930 if (!new_triggers.patterns[i].mask) {
7934 new_triggers.patterns[i].pattern =
7935 new_triggers.patterns[i].mask + mask_len;
7936 memcpy(new_triggers.patterns[i].mask,
7937 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]),
7939 new_triggers.patterns[i].pattern_len = pat_len;
7940 memcpy(new_triggers.patterns[i].pattern,
7941 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]),
7947 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
7948 err = nl80211_parse_wowlan_tcp(
7949 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
7955 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
7960 cfg80211_rdev_free_wowlan(rdev);
7961 rdev->wowlan = ntrig;
7964 if (rdev->ops->set_wakeup && prev_enabled != !!rdev->wowlan)
7965 rdev_set_wakeup(rdev, rdev->wowlan);
7969 for (i = 0; i < new_triggers.n_patterns; i++)
7970 kfree(new_triggers.patterns[i].mask);
7971 kfree(new_triggers.patterns);
7972 if (new_triggers.tcp && new_triggers.tcp->sock)
7973 sock_release(new_triggers.tcp->sock);
7974 kfree(new_triggers.tcp);
7979 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
7981 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7982 struct net_device *dev = info->user_ptr[1];
7983 struct wireless_dev *wdev = dev->ieee80211_ptr;
7984 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
7985 struct cfg80211_gtk_rekey_data rekey_data;
7988 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
7991 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
7992 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
7993 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
7994 nl80211_rekey_policy);
7998 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
8000 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
8002 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
8005 memcpy(rekey_data.kek, nla_data(tb[NL80211_REKEY_DATA_KEK]),
8007 memcpy(rekey_data.kck, nla_data(tb[NL80211_REKEY_DATA_KCK]),
8009 memcpy(rekey_data.replay_ctr,
8010 nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]),
8011 NL80211_REPLAY_CTR_LEN);
8014 if (!wdev->current_bss) {
8019 if (!rdev->ops->set_rekey_data) {
8024 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
8030 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
8031 struct genl_info *info)
8033 struct net_device *dev = info->user_ptr[1];
8034 struct wireless_dev *wdev = dev->ieee80211_ptr;
8036 if (wdev->iftype != NL80211_IFTYPE_AP &&
8037 wdev->iftype != NL80211_IFTYPE_P2P_GO)
8040 if (wdev->ap_unexpected_nlportid)
8043 wdev->ap_unexpected_nlportid = info->snd_portid;
8047 static int nl80211_probe_client(struct sk_buff *skb,
8048 struct genl_info *info)
8050 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8051 struct net_device *dev = info->user_ptr[1];
8052 struct wireless_dev *wdev = dev->ieee80211_ptr;
8053 struct sk_buff *msg;
8059 if (wdev->iftype != NL80211_IFTYPE_AP &&
8060 wdev->iftype != NL80211_IFTYPE_P2P_GO)
8063 if (!info->attrs[NL80211_ATTR_MAC])
8066 if (!rdev->ops->probe_client)
8069 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8073 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8074 NL80211_CMD_PROBE_CLIENT);
8081 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
8083 err = rdev_probe_client(rdev, dev, addr, &cookie);
8087 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
8088 goto nla_put_failure;
8090 genlmsg_end(msg, hdr);
8092 return genlmsg_reply(msg, info);
8101 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
8103 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8104 struct cfg80211_beacon_registration *reg, *nreg;
8107 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
8110 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
8114 /* First, check if already registered. */
8115 spin_lock_bh(&rdev->beacon_registrations_lock);
8116 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
8117 if (reg->nlportid == info->snd_portid) {
8122 /* Add it to the list */
8123 nreg->nlportid = info->snd_portid;
8124 list_add(&nreg->list, &rdev->beacon_registrations);
8126 spin_unlock_bh(&rdev->beacon_registrations_lock);
8130 spin_unlock_bh(&rdev->beacon_registrations_lock);
8135 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
8137 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8138 struct wireless_dev *wdev = info->user_ptr[1];
8141 if (!rdev->ops->start_p2p_device)
8144 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
8147 if (wdev->p2p_started)
8150 mutex_lock(&rdev->devlist_mtx);
8151 err = cfg80211_can_add_interface(rdev, wdev->iftype);
8152 mutex_unlock(&rdev->devlist_mtx);
8156 err = rdev_start_p2p_device(rdev, wdev);
8160 wdev->p2p_started = true;
8161 mutex_lock(&rdev->devlist_mtx);
8163 mutex_unlock(&rdev->devlist_mtx);
8168 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
8170 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8171 struct wireless_dev *wdev = info->user_ptr[1];
8173 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
8176 if (!rdev->ops->stop_p2p_device)
8179 mutex_lock(&rdev->devlist_mtx);
8180 mutex_lock(&rdev->sched_scan_mtx);
8181 cfg80211_stop_p2p_device(rdev, wdev);
8182 mutex_unlock(&rdev->sched_scan_mtx);
8183 mutex_unlock(&rdev->devlist_mtx);
8188 static int nl80211_get_protocol_features(struct sk_buff *skb,
8189 struct genl_info *info)
8192 struct sk_buff *msg;
8194 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8198 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8199 NL80211_CMD_GET_PROTOCOL_FEATURES);
8201 goto nla_put_failure;
8203 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
8204 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
8205 goto nla_put_failure;
8207 genlmsg_end(msg, hdr);
8208 return genlmsg_reply(msg, info);
8215 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
8217 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8218 struct cfg80211_update_ft_ies_params ft_params;
8219 struct net_device *dev = info->user_ptr[1];
8221 if (!rdev->ops->update_ft_ies)
8224 if (!info->attrs[NL80211_ATTR_MDID] ||
8225 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8228 memset(&ft_params, 0, sizeof(ft_params));
8229 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
8230 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8231 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8233 return rdev_update_ft_ies(rdev, dev, &ft_params);
8236 static int nl80211_crit_protocol_start(struct sk_buff *skb,
8237 struct genl_info *info)
8239 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8240 struct wireless_dev *wdev = info->user_ptr[1];
8241 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
8245 if (!rdev->ops->crit_proto_start)
8248 if (WARN_ON(!rdev->ops->crit_proto_stop))
8251 if (rdev->crit_proto_nlportid)
8254 /* determine protocol if provided */
8255 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
8256 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
8258 if (proto >= NUM_NL80211_CRIT_PROTO)
8261 /* timeout must be provided */
8262 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
8266 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
8268 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
8271 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
8273 rdev->crit_proto_nlportid = info->snd_portid;
8278 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
8279 struct genl_info *info)
8281 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8282 struct wireless_dev *wdev = info->user_ptr[1];
8284 if (!rdev->ops->crit_proto_stop)
8287 if (rdev->crit_proto_nlportid) {
8288 rdev->crit_proto_nlportid = 0;
8289 rdev_crit_proto_stop(rdev, wdev);
8294 #define NL80211_FLAG_NEED_WIPHY 0x01
8295 #define NL80211_FLAG_NEED_NETDEV 0x02
8296 #define NL80211_FLAG_NEED_RTNL 0x04
8297 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
8298 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
8299 NL80211_FLAG_CHECK_NETDEV_UP)
8300 #define NL80211_FLAG_NEED_WDEV 0x10
8301 /* If a netdev is associated, it must be UP, P2P must be started */
8302 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
8303 NL80211_FLAG_CHECK_NETDEV_UP)
8305 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
8306 struct genl_info *info)
8308 struct cfg80211_registered_device *rdev;
8309 struct wireless_dev *wdev;
8310 struct net_device *dev;
8311 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
8316 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
8317 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
8321 return PTR_ERR(rdev);
8323 info->user_ptr[0] = rdev;
8324 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
8325 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
8326 mutex_lock(&cfg80211_mutex);
8327 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
8330 mutex_unlock(&cfg80211_mutex);
8333 return PTR_ERR(wdev);
8337 rdev = wiphy_to_dev(wdev->wiphy);
8339 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
8341 mutex_unlock(&cfg80211_mutex);
8347 info->user_ptr[1] = dev;
8349 info->user_ptr[1] = wdev;
8353 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
8354 !netif_running(dev)) {
8355 mutex_unlock(&cfg80211_mutex);
8362 } else if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP) {
8363 if (!wdev->p2p_started) {
8364 mutex_unlock(&cfg80211_mutex);
8371 cfg80211_lock_rdev(rdev);
8373 mutex_unlock(&cfg80211_mutex);
8375 info->user_ptr[0] = rdev;
8381 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
8382 struct genl_info *info)
8384 if (info->user_ptr[0])
8385 cfg80211_unlock_rdev(info->user_ptr[0]);
8386 if (info->user_ptr[1]) {
8387 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
8388 struct wireless_dev *wdev = info->user_ptr[1];
8391 dev_put(wdev->netdev);
8393 dev_put(info->user_ptr[1]);
8396 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
8400 static struct genl_ops nl80211_ops[] = {
8402 .cmd = NL80211_CMD_GET_WIPHY,
8403 .doit = nl80211_get_wiphy,
8404 .dumpit = nl80211_dump_wiphy,
8405 .policy = nl80211_policy,
8406 /* can be retrieved by unprivileged users */
8407 .internal_flags = NL80211_FLAG_NEED_WIPHY,
8410 .cmd = NL80211_CMD_SET_WIPHY,
8411 .doit = nl80211_set_wiphy,
8412 .policy = nl80211_policy,
8413 .flags = GENL_ADMIN_PERM,
8414 .internal_flags = NL80211_FLAG_NEED_RTNL,
8417 .cmd = NL80211_CMD_GET_INTERFACE,
8418 .doit = nl80211_get_interface,
8419 .dumpit = nl80211_dump_interface,
8420 .policy = nl80211_policy,
8421 /* can be retrieved by unprivileged users */
8422 .internal_flags = NL80211_FLAG_NEED_WDEV,
8425 .cmd = NL80211_CMD_SET_INTERFACE,
8426 .doit = nl80211_set_interface,
8427 .policy = nl80211_policy,
8428 .flags = GENL_ADMIN_PERM,
8429 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8430 NL80211_FLAG_NEED_RTNL,
8433 .cmd = NL80211_CMD_NEW_INTERFACE,
8434 .doit = nl80211_new_interface,
8435 .policy = nl80211_policy,
8436 .flags = GENL_ADMIN_PERM,
8437 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8438 NL80211_FLAG_NEED_RTNL,
8441 .cmd = NL80211_CMD_DEL_INTERFACE,
8442 .doit = nl80211_del_interface,
8443 .policy = nl80211_policy,
8444 .flags = GENL_ADMIN_PERM,
8445 .internal_flags = NL80211_FLAG_NEED_WDEV |
8446 NL80211_FLAG_NEED_RTNL,
8449 .cmd = NL80211_CMD_GET_KEY,
8450 .doit = nl80211_get_key,
8451 .policy = nl80211_policy,
8452 .flags = GENL_ADMIN_PERM,
8453 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8454 NL80211_FLAG_NEED_RTNL,
8457 .cmd = NL80211_CMD_SET_KEY,
8458 .doit = nl80211_set_key,
8459 .policy = nl80211_policy,
8460 .flags = GENL_ADMIN_PERM,
8461 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8462 NL80211_FLAG_NEED_RTNL,
8465 .cmd = NL80211_CMD_NEW_KEY,
8466 .doit = nl80211_new_key,
8467 .policy = nl80211_policy,
8468 .flags = GENL_ADMIN_PERM,
8469 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8470 NL80211_FLAG_NEED_RTNL,
8473 .cmd = NL80211_CMD_DEL_KEY,
8474 .doit = nl80211_del_key,
8475 .policy = nl80211_policy,
8476 .flags = GENL_ADMIN_PERM,
8477 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8478 NL80211_FLAG_NEED_RTNL,
8481 .cmd = NL80211_CMD_SET_BEACON,
8482 .policy = nl80211_policy,
8483 .flags = GENL_ADMIN_PERM,
8484 .doit = nl80211_set_beacon,
8485 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8486 NL80211_FLAG_NEED_RTNL,
8489 .cmd = NL80211_CMD_START_AP,
8490 .policy = nl80211_policy,
8491 .flags = GENL_ADMIN_PERM,
8492 .doit = nl80211_start_ap,
8493 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8494 NL80211_FLAG_NEED_RTNL,
8497 .cmd = NL80211_CMD_STOP_AP,
8498 .policy = nl80211_policy,
8499 .flags = GENL_ADMIN_PERM,
8500 .doit = nl80211_stop_ap,
8501 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8502 NL80211_FLAG_NEED_RTNL,
8505 .cmd = NL80211_CMD_GET_STATION,
8506 .doit = nl80211_get_station,
8507 .dumpit = nl80211_dump_station,
8508 .policy = nl80211_policy,
8509 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8510 NL80211_FLAG_NEED_RTNL,
8513 .cmd = NL80211_CMD_SET_STATION,
8514 .doit = nl80211_set_station,
8515 .policy = nl80211_policy,
8516 .flags = GENL_ADMIN_PERM,
8517 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8518 NL80211_FLAG_NEED_RTNL,
8521 .cmd = NL80211_CMD_NEW_STATION,
8522 .doit = nl80211_new_station,
8523 .policy = nl80211_policy,
8524 .flags = GENL_ADMIN_PERM,
8525 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8526 NL80211_FLAG_NEED_RTNL,
8529 .cmd = NL80211_CMD_DEL_STATION,
8530 .doit = nl80211_del_station,
8531 .policy = nl80211_policy,
8532 .flags = GENL_ADMIN_PERM,
8533 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8534 NL80211_FLAG_NEED_RTNL,
8537 .cmd = NL80211_CMD_GET_MPATH,
8538 .doit = nl80211_get_mpath,
8539 .dumpit = nl80211_dump_mpath,
8540 .policy = nl80211_policy,
8541 .flags = GENL_ADMIN_PERM,
8542 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8543 NL80211_FLAG_NEED_RTNL,
8546 .cmd = NL80211_CMD_SET_MPATH,
8547 .doit = nl80211_set_mpath,
8548 .policy = nl80211_policy,
8549 .flags = GENL_ADMIN_PERM,
8550 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8551 NL80211_FLAG_NEED_RTNL,
8554 .cmd = NL80211_CMD_NEW_MPATH,
8555 .doit = nl80211_new_mpath,
8556 .policy = nl80211_policy,
8557 .flags = GENL_ADMIN_PERM,
8558 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8559 NL80211_FLAG_NEED_RTNL,
8562 .cmd = NL80211_CMD_DEL_MPATH,
8563 .doit = nl80211_del_mpath,
8564 .policy = nl80211_policy,
8565 .flags = GENL_ADMIN_PERM,
8566 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8567 NL80211_FLAG_NEED_RTNL,
8570 .cmd = NL80211_CMD_SET_BSS,
8571 .doit = nl80211_set_bss,
8572 .policy = nl80211_policy,
8573 .flags = GENL_ADMIN_PERM,
8574 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8575 NL80211_FLAG_NEED_RTNL,
8578 .cmd = NL80211_CMD_GET_REG,
8579 .doit = nl80211_get_reg,
8580 .policy = nl80211_policy,
8581 /* can be retrieved by unprivileged users */
8584 .cmd = NL80211_CMD_SET_REG,
8585 .doit = nl80211_set_reg,
8586 .policy = nl80211_policy,
8587 .flags = GENL_ADMIN_PERM,
8590 .cmd = NL80211_CMD_REQ_SET_REG,
8591 .doit = nl80211_req_set_reg,
8592 .policy = nl80211_policy,
8593 .flags = GENL_ADMIN_PERM,
8596 .cmd = NL80211_CMD_GET_MESH_CONFIG,
8597 .doit = nl80211_get_mesh_config,
8598 .policy = nl80211_policy,
8599 /* can be retrieved by unprivileged users */
8600 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8601 NL80211_FLAG_NEED_RTNL,
8604 .cmd = NL80211_CMD_SET_MESH_CONFIG,
8605 .doit = nl80211_update_mesh_config,
8606 .policy = nl80211_policy,
8607 .flags = GENL_ADMIN_PERM,
8608 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8609 NL80211_FLAG_NEED_RTNL,
8612 .cmd = NL80211_CMD_TRIGGER_SCAN,
8613 .doit = nl80211_trigger_scan,
8614 .policy = nl80211_policy,
8615 .flags = GENL_ADMIN_PERM,
8616 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8617 NL80211_FLAG_NEED_RTNL,
8620 .cmd = NL80211_CMD_GET_SCAN,
8621 .policy = nl80211_policy,
8622 .dumpit = nl80211_dump_scan,
8625 .cmd = NL80211_CMD_START_SCHED_SCAN,
8626 .doit = nl80211_start_sched_scan,
8627 .policy = nl80211_policy,
8628 .flags = GENL_ADMIN_PERM,
8629 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8630 NL80211_FLAG_NEED_RTNL,
8633 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
8634 .doit = nl80211_stop_sched_scan,
8635 .policy = nl80211_policy,
8636 .flags = GENL_ADMIN_PERM,
8637 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8638 NL80211_FLAG_NEED_RTNL,
8641 .cmd = NL80211_CMD_AUTHENTICATE,
8642 .doit = nl80211_authenticate,
8643 .policy = nl80211_policy,
8644 .flags = GENL_ADMIN_PERM,
8645 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8646 NL80211_FLAG_NEED_RTNL,
8649 .cmd = NL80211_CMD_ASSOCIATE,
8650 .doit = nl80211_associate,
8651 .policy = nl80211_policy,
8652 .flags = GENL_ADMIN_PERM,
8653 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8654 NL80211_FLAG_NEED_RTNL,
8657 .cmd = NL80211_CMD_DEAUTHENTICATE,
8658 .doit = nl80211_deauthenticate,
8659 .policy = nl80211_policy,
8660 .flags = GENL_ADMIN_PERM,
8661 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8662 NL80211_FLAG_NEED_RTNL,
8665 .cmd = NL80211_CMD_DISASSOCIATE,
8666 .doit = nl80211_disassociate,
8667 .policy = nl80211_policy,
8668 .flags = GENL_ADMIN_PERM,
8669 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8670 NL80211_FLAG_NEED_RTNL,
8673 .cmd = NL80211_CMD_JOIN_IBSS,
8674 .doit = nl80211_join_ibss,
8675 .policy = nl80211_policy,
8676 .flags = GENL_ADMIN_PERM,
8677 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8678 NL80211_FLAG_NEED_RTNL,
8681 .cmd = NL80211_CMD_LEAVE_IBSS,
8682 .doit = nl80211_leave_ibss,
8683 .policy = nl80211_policy,
8684 .flags = GENL_ADMIN_PERM,
8685 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8686 NL80211_FLAG_NEED_RTNL,
8688 #ifdef CONFIG_NL80211_TESTMODE
8690 .cmd = NL80211_CMD_TESTMODE,
8691 .doit = nl80211_testmode_do,
8692 .dumpit = nl80211_testmode_dump,
8693 .policy = nl80211_policy,
8694 .flags = GENL_ADMIN_PERM,
8695 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8696 NL80211_FLAG_NEED_RTNL,
8700 .cmd = NL80211_CMD_CONNECT,
8701 .doit = nl80211_connect,
8702 .policy = nl80211_policy,
8703 .flags = GENL_ADMIN_PERM,
8704 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8705 NL80211_FLAG_NEED_RTNL,
8708 .cmd = NL80211_CMD_DISCONNECT,
8709 .doit = nl80211_disconnect,
8710 .policy = nl80211_policy,
8711 .flags = GENL_ADMIN_PERM,
8712 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8713 NL80211_FLAG_NEED_RTNL,
8716 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
8717 .doit = nl80211_wiphy_netns,
8718 .policy = nl80211_policy,
8719 .flags = GENL_ADMIN_PERM,
8720 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8721 NL80211_FLAG_NEED_RTNL,
8724 .cmd = NL80211_CMD_GET_SURVEY,
8725 .policy = nl80211_policy,
8726 .dumpit = nl80211_dump_survey,
8729 .cmd = NL80211_CMD_SET_PMKSA,
8730 .doit = nl80211_setdel_pmksa,
8731 .policy = nl80211_policy,
8732 .flags = GENL_ADMIN_PERM,
8733 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8734 NL80211_FLAG_NEED_RTNL,
8737 .cmd = NL80211_CMD_DEL_PMKSA,
8738 .doit = nl80211_setdel_pmksa,
8739 .policy = nl80211_policy,
8740 .flags = GENL_ADMIN_PERM,
8741 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8742 NL80211_FLAG_NEED_RTNL,
8745 .cmd = NL80211_CMD_FLUSH_PMKSA,
8746 .doit = nl80211_flush_pmksa,
8747 .policy = nl80211_policy,
8748 .flags = GENL_ADMIN_PERM,
8749 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8750 NL80211_FLAG_NEED_RTNL,
8753 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
8754 .doit = nl80211_remain_on_channel,
8755 .policy = nl80211_policy,
8756 .flags = GENL_ADMIN_PERM,
8757 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8758 NL80211_FLAG_NEED_RTNL,
8761 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
8762 .doit = nl80211_cancel_remain_on_channel,
8763 .policy = nl80211_policy,
8764 .flags = GENL_ADMIN_PERM,
8765 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8766 NL80211_FLAG_NEED_RTNL,
8769 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
8770 .doit = nl80211_set_tx_bitrate_mask,
8771 .policy = nl80211_policy,
8772 .flags = GENL_ADMIN_PERM,
8773 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8774 NL80211_FLAG_NEED_RTNL,
8777 .cmd = NL80211_CMD_REGISTER_FRAME,
8778 .doit = nl80211_register_mgmt,
8779 .policy = nl80211_policy,
8780 .flags = GENL_ADMIN_PERM,
8781 .internal_flags = NL80211_FLAG_NEED_WDEV |
8782 NL80211_FLAG_NEED_RTNL,
8785 .cmd = NL80211_CMD_FRAME,
8786 .doit = nl80211_tx_mgmt,
8787 .policy = nl80211_policy,
8788 .flags = GENL_ADMIN_PERM,
8789 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8790 NL80211_FLAG_NEED_RTNL,
8793 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
8794 .doit = nl80211_tx_mgmt_cancel_wait,
8795 .policy = nl80211_policy,
8796 .flags = GENL_ADMIN_PERM,
8797 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8798 NL80211_FLAG_NEED_RTNL,
8801 .cmd = NL80211_CMD_SET_POWER_SAVE,
8802 .doit = nl80211_set_power_save,
8803 .policy = nl80211_policy,
8804 .flags = GENL_ADMIN_PERM,
8805 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8806 NL80211_FLAG_NEED_RTNL,
8809 .cmd = NL80211_CMD_GET_POWER_SAVE,
8810 .doit = nl80211_get_power_save,
8811 .policy = nl80211_policy,
8812 /* can be retrieved by unprivileged users */
8813 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8814 NL80211_FLAG_NEED_RTNL,
8817 .cmd = NL80211_CMD_SET_CQM,
8818 .doit = nl80211_set_cqm,
8819 .policy = nl80211_policy,
8820 .flags = GENL_ADMIN_PERM,
8821 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8822 NL80211_FLAG_NEED_RTNL,
8825 .cmd = NL80211_CMD_SET_CHANNEL,
8826 .doit = nl80211_set_channel,
8827 .policy = nl80211_policy,
8828 .flags = GENL_ADMIN_PERM,
8829 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8830 NL80211_FLAG_NEED_RTNL,
8833 .cmd = NL80211_CMD_SET_WDS_PEER,
8834 .doit = nl80211_set_wds_peer,
8835 .policy = nl80211_policy,
8836 .flags = GENL_ADMIN_PERM,
8837 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8838 NL80211_FLAG_NEED_RTNL,
8841 .cmd = NL80211_CMD_JOIN_MESH,
8842 .doit = nl80211_join_mesh,
8843 .policy = nl80211_policy,
8844 .flags = GENL_ADMIN_PERM,
8845 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8846 NL80211_FLAG_NEED_RTNL,
8849 .cmd = NL80211_CMD_LEAVE_MESH,
8850 .doit = nl80211_leave_mesh,
8851 .policy = nl80211_policy,
8852 .flags = GENL_ADMIN_PERM,
8853 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8854 NL80211_FLAG_NEED_RTNL,
8858 .cmd = NL80211_CMD_GET_WOWLAN,
8859 .doit = nl80211_get_wowlan,
8860 .policy = nl80211_policy,
8861 /* can be retrieved by unprivileged users */
8862 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8863 NL80211_FLAG_NEED_RTNL,
8866 .cmd = NL80211_CMD_SET_WOWLAN,
8867 .doit = nl80211_set_wowlan,
8868 .policy = nl80211_policy,
8869 .flags = GENL_ADMIN_PERM,
8870 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8871 NL80211_FLAG_NEED_RTNL,
8875 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
8876 .doit = nl80211_set_rekey_data,
8877 .policy = nl80211_policy,
8878 .flags = GENL_ADMIN_PERM,
8879 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8880 NL80211_FLAG_NEED_RTNL,
8883 .cmd = NL80211_CMD_TDLS_MGMT,
8884 .doit = nl80211_tdls_mgmt,
8885 .policy = nl80211_policy,
8886 .flags = GENL_ADMIN_PERM,
8887 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8888 NL80211_FLAG_NEED_RTNL,
8891 .cmd = NL80211_CMD_TDLS_OPER,
8892 .doit = nl80211_tdls_oper,
8893 .policy = nl80211_policy,
8894 .flags = GENL_ADMIN_PERM,
8895 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8896 NL80211_FLAG_NEED_RTNL,
8899 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
8900 .doit = nl80211_register_unexpected_frame,
8901 .policy = nl80211_policy,
8902 .flags = GENL_ADMIN_PERM,
8903 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8904 NL80211_FLAG_NEED_RTNL,
8907 .cmd = NL80211_CMD_PROBE_CLIENT,
8908 .doit = nl80211_probe_client,
8909 .policy = nl80211_policy,
8910 .flags = GENL_ADMIN_PERM,
8911 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8912 NL80211_FLAG_NEED_RTNL,
8915 .cmd = NL80211_CMD_REGISTER_BEACONS,
8916 .doit = nl80211_register_beacons,
8917 .policy = nl80211_policy,
8918 .flags = GENL_ADMIN_PERM,
8919 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8920 NL80211_FLAG_NEED_RTNL,
8923 .cmd = NL80211_CMD_SET_NOACK_MAP,
8924 .doit = nl80211_set_noack_map,
8925 .policy = nl80211_policy,
8926 .flags = GENL_ADMIN_PERM,
8927 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8928 NL80211_FLAG_NEED_RTNL,
8931 .cmd = NL80211_CMD_START_P2P_DEVICE,
8932 .doit = nl80211_start_p2p_device,
8933 .policy = nl80211_policy,
8934 .flags = GENL_ADMIN_PERM,
8935 .internal_flags = NL80211_FLAG_NEED_WDEV |
8936 NL80211_FLAG_NEED_RTNL,
8939 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
8940 .doit = nl80211_stop_p2p_device,
8941 .policy = nl80211_policy,
8942 .flags = GENL_ADMIN_PERM,
8943 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8944 NL80211_FLAG_NEED_RTNL,
8947 .cmd = NL80211_CMD_SET_MCAST_RATE,
8948 .doit = nl80211_set_mcast_rate,
8949 .policy = nl80211_policy,
8950 .flags = GENL_ADMIN_PERM,
8951 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8952 NL80211_FLAG_NEED_RTNL,
8955 .cmd = NL80211_CMD_SET_MAC_ACL,
8956 .doit = nl80211_set_mac_acl,
8957 .policy = nl80211_policy,
8958 .flags = GENL_ADMIN_PERM,
8959 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8960 NL80211_FLAG_NEED_RTNL,
8963 .cmd = NL80211_CMD_RADAR_DETECT,
8964 .doit = nl80211_start_radar_detection,
8965 .policy = nl80211_policy,
8966 .flags = GENL_ADMIN_PERM,
8967 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8968 NL80211_FLAG_NEED_RTNL,
8971 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
8972 .doit = nl80211_get_protocol_features,
8973 .policy = nl80211_policy,
8976 .cmd = NL80211_CMD_UPDATE_FT_IES,
8977 .doit = nl80211_update_ft_ies,
8978 .policy = nl80211_policy,
8979 .flags = GENL_ADMIN_PERM,
8980 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8981 NL80211_FLAG_NEED_RTNL,
8984 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
8985 .doit = nl80211_crit_protocol_start,
8986 .policy = nl80211_policy,
8987 .flags = GENL_ADMIN_PERM,
8988 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8989 NL80211_FLAG_NEED_RTNL,
8992 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
8993 .doit = nl80211_crit_protocol_stop,
8994 .policy = nl80211_policy,
8995 .flags = GENL_ADMIN_PERM,
8996 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8997 NL80211_FLAG_NEED_RTNL,
9001 static struct genl_multicast_group nl80211_mlme_mcgrp = {
9005 /* multicast groups */
9006 static struct genl_multicast_group nl80211_config_mcgrp = {
9009 static struct genl_multicast_group nl80211_scan_mcgrp = {
9012 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
9013 .name = "regulatory",
9016 /* notification functions */
9018 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
9020 struct sk_buff *msg;
9022 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9026 if (nl80211_send_wiphy(rdev, msg, 0, 0, 0,
9027 false, NULL, NULL, NULL) < 0) {
9032 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9033 nl80211_config_mcgrp.id, GFP_KERNEL);
9036 static int nl80211_add_scan_req(struct sk_buff *msg,
9037 struct cfg80211_registered_device *rdev)
9039 struct cfg80211_scan_request *req = rdev->scan_req;
9040 struct nlattr *nest;
9043 lockdep_assert_held(&rdev->sched_scan_mtx);
9048 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
9050 goto nla_put_failure;
9051 for (i = 0; i < req->n_ssids; i++) {
9052 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
9053 goto nla_put_failure;
9055 nla_nest_end(msg, nest);
9057 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
9059 goto nla_put_failure;
9060 for (i = 0; i < req->n_channels; i++) {
9061 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
9062 goto nla_put_failure;
9064 nla_nest_end(msg, nest);
9067 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
9068 goto nla_put_failure;
9071 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags);
9078 static int nl80211_send_scan_msg(struct sk_buff *msg,
9079 struct cfg80211_registered_device *rdev,
9080 struct wireless_dev *wdev,
9081 u32 portid, u32 seq, int flags,
9086 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
9090 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9091 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9092 wdev->netdev->ifindex)) ||
9093 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
9094 goto nla_put_failure;
9096 /* ignore errors and send incomplete event anyway */
9097 nl80211_add_scan_req(msg, rdev);
9099 return genlmsg_end(msg, hdr);
9102 genlmsg_cancel(msg, hdr);
9107 nl80211_send_sched_scan_msg(struct sk_buff *msg,
9108 struct cfg80211_registered_device *rdev,
9109 struct net_device *netdev,
9110 u32 portid, u32 seq, int flags, u32 cmd)
9114 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
9118 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9119 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
9120 goto nla_put_failure;
9122 return genlmsg_end(msg, hdr);
9125 genlmsg_cancel(msg, hdr);
9129 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
9130 struct wireless_dev *wdev)
9132 struct sk_buff *msg;
9134 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9138 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
9139 NL80211_CMD_TRIGGER_SCAN) < 0) {
9144 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9145 nl80211_scan_mcgrp.id, GFP_KERNEL);
9148 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
9149 struct wireless_dev *wdev)
9151 struct sk_buff *msg;
9153 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9157 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
9158 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
9163 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9164 nl80211_scan_mcgrp.id, GFP_KERNEL);
9167 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
9168 struct wireless_dev *wdev)
9170 struct sk_buff *msg;
9172 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9176 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
9177 NL80211_CMD_SCAN_ABORTED) < 0) {
9182 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9183 nl80211_scan_mcgrp.id, GFP_KERNEL);
9186 void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
9187 struct net_device *netdev)
9189 struct sk_buff *msg;
9191 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9195 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
9196 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
9201 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9202 nl80211_scan_mcgrp.id, GFP_KERNEL);
9205 void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
9206 struct net_device *netdev, u32 cmd)
9208 struct sk_buff *msg;
9210 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9214 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
9219 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9220 nl80211_scan_mcgrp.id, GFP_KERNEL);
9224 * This can happen on global regulatory changes or device specific settings
9225 * based on custom world regulatory domains.
9227 void nl80211_send_reg_change_event(struct regulatory_request *request)
9229 struct sk_buff *msg;
9232 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9236 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
9242 /* Userspace can always count this one always being set */
9243 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
9244 goto nla_put_failure;
9246 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
9247 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9248 NL80211_REGDOM_TYPE_WORLD))
9249 goto nla_put_failure;
9250 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
9251 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9252 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
9253 goto nla_put_failure;
9254 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
9255 request->intersect) {
9256 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9257 NL80211_REGDOM_TYPE_INTERSECTION))
9258 goto nla_put_failure;
9260 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9261 NL80211_REGDOM_TYPE_COUNTRY) ||
9262 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
9264 goto nla_put_failure;
9267 if (request->wiphy_idx != WIPHY_IDX_INVALID &&
9268 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
9269 goto nla_put_failure;
9271 genlmsg_end(msg, hdr);
9274 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
9281 genlmsg_cancel(msg, hdr);
9285 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
9286 struct net_device *netdev,
9287 const u8 *buf, size_t len,
9288 enum nl80211_commands cmd, gfp_t gfp)
9290 struct sk_buff *msg;
9293 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9297 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9303 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9304 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9305 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
9306 goto nla_put_failure;
9308 genlmsg_end(msg, hdr);
9310 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9311 nl80211_mlme_mcgrp.id, gfp);
9315 genlmsg_cancel(msg, hdr);
9319 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
9320 struct net_device *netdev, const u8 *buf,
9321 size_t len, gfp_t gfp)
9323 nl80211_send_mlme_event(rdev, netdev, buf, len,
9324 NL80211_CMD_AUTHENTICATE, gfp);
9327 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
9328 struct net_device *netdev, const u8 *buf,
9329 size_t len, gfp_t gfp)
9331 nl80211_send_mlme_event(rdev, netdev, buf, len,
9332 NL80211_CMD_ASSOCIATE, gfp);
9335 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
9336 struct net_device *netdev, const u8 *buf,
9337 size_t len, gfp_t gfp)
9339 nl80211_send_mlme_event(rdev, netdev, buf, len,
9340 NL80211_CMD_DEAUTHENTICATE, gfp);
9343 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
9344 struct net_device *netdev, const u8 *buf,
9345 size_t len, gfp_t gfp)
9347 nl80211_send_mlme_event(rdev, netdev, buf, len,
9348 NL80211_CMD_DISASSOCIATE, gfp);
9351 void cfg80211_send_unprot_deauth(struct net_device *dev, const u8 *buf,
9354 struct wireless_dev *wdev = dev->ieee80211_ptr;
9355 struct wiphy *wiphy = wdev->wiphy;
9356 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9358 trace_cfg80211_send_unprot_deauth(dev);
9359 nl80211_send_mlme_event(rdev, dev, buf, len,
9360 NL80211_CMD_UNPROT_DEAUTHENTICATE, GFP_ATOMIC);
9362 EXPORT_SYMBOL(cfg80211_send_unprot_deauth);
9364 void cfg80211_send_unprot_disassoc(struct net_device *dev, const u8 *buf,
9367 struct wireless_dev *wdev = dev->ieee80211_ptr;
9368 struct wiphy *wiphy = wdev->wiphy;
9369 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9371 trace_cfg80211_send_unprot_disassoc(dev);
9372 nl80211_send_mlme_event(rdev, dev, buf, len,
9373 NL80211_CMD_UNPROT_DISASSOCIATE, GFP_ATOMIC);
9375 EXPORT_SYMBOL(cfg80211_send_unprot_disassoc);
9377 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
9378 struct net_device *netdev, int cmd,
9379 const u8 *addr, gfp_t gfp)
9381 struct sk_buff *msg;
9384 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9388 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9394 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9395 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9396 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
9397 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
9398 goto nla_put_failure;
9400 genlmsg_end(msg, hdr);
9402 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9403 nl80211_mlme_mcgrp.id, gfp);
9407 genlmsg_cancel(msg, hdr);
9411 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
9412 struct net_device *netdev, const u8 *addr,
9415 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
9419 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
9420 struct net_device *netdev, const u8 *addr,
9423 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
9427 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
9428 struct net_device *netdev, const u8 *bssid,
9429 const u8 *req_ie, size_t req_ie_len,
9430 const u8 *resp_ie, size_t resp_ie_len,
9431 u16 status, gfp_t gfp)
9433 struct sk_buff *msg;
9436 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9440 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
9446 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9447 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9448 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
9449 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
9451 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
9453 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
9454 goto nla_put_failure;
9456 genlmsg_end(msg, hdr);
9458 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9459 nl80211_mlme_mcgrp.id, gfp);
9463 genlmsg_cancel(msg, hdr);
9468 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
9469 struct net_device *netdev, const u8 *bssid,
9470 const u8 *req_ie, size_t req_ie_len,
9471 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
9473 struct sk_buff *msg;
9476 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9480 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
9486 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9487 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9488 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
9490 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
9492 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
9493 goto nla_put_failure;
9495 genlmsg_end(msg, hdr);
9497 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9498 nl80211_mlme_mcgrp.id, gfp);
9502 genlmsg_cancel(msg, hdr);
9507 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
9508 struct net_device *netdev, u16 reason,
9509 const u8 *ie, size_t ie_len, bool from_ap)
9511 struct sk_buff *msg;
9514 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9518 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
9524 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9525 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9526 (from_ap && reason &&
9527 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
9529 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
9530 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
9531 goto nla_put_failure;
9533 genlmsg_end(msg, hdr);
9535 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9536 nl80211_mlme_mcgrp.id, GFP_KERNEL);
9540 genlmsg_cancel(msg, hdr);
9545 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
9546 struct net_device *netdev, const u8 *bssid,
9549 struct sk_buff *msg;
9552 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9556 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
9562 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9563 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9564 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
9565 goto nla_put_failure;
9567 genlmsg_end(msg, hdr);
9569 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9570 nl80211_mlme_mcgrp.id, gfp);
9574 genlmsg_cancel(msg, hdr);
9578 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
9579 const u8* ie, u8 ie_len, gfp_t gfp)
9581 struct wireless_dev *wdev = dev->ieee80211_ptr;
9582 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
9583 struct sk_buff *msg;
9586 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
9589 trace_cfg80211_notify_new_peer_candidate(dev, addr);
9591 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9595 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
9601 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9602 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9603 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9605 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
9606 goto nla_put_failure;
9608 genlmsg_end(msg, hdr);
9610 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9611 nl80211_mlme_mcgrp.id, gfp);
9615 genlmsg_cancel(msg, hdr);
9618 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
9620 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
9621 struct net_device *netdev, const u8 *addr,
9622 enum nl80211_key_type key_type, int key_id,
9623 const u8 *tsc, gfp_t gfp)
9625 struct sk_buff *msg;
9628 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9632 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
9638 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9639 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9640 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
9641 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
9643 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
9644 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
9645 goto nla_put_failure;
9647 genlmsg_end(msg, hdr);
9649 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9650 nl80211_mlme_mcgrp.id, gfp);
9654 genlmsg_cancel(msg, hdr);
9658 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
9659 struct ieee80211_channel *channel_before,
9660 struct ieee80211_channel *channel_after)
9662 struct sk_buff *msg;
9664 struct nlattr *nl_freq;
9666 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
9670 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
9677 * Since we are applying the beacon hint to a wiphy we know its
9678 * wiphy_idx is valid
9680 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
9681 goto nla_put_failure;
9684 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
9686 goto nla_put_failure;
9687 if (nl80211_msg_put_channel(msg, channel_before, false))
9688 goto nla_put_failure;
9689 nla_nest_end(msg, nl_freq);
9692 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
9694 goto nla_put_failure;
9695 if (nl80211_msg_put_channel(msg, channel_after, false))
9696 goto nla_put_failure;
9697 nla_nest_end(msg, nl_freq);
9699 genlmsg_end(msg, hdr);
9702 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
9709 genlmsg_cancel(msg, hdr);
9713 static void nl80211_send_remain_on_chan_event(
9714 int cmd, struct cfg80211_registered_device *rdev,
9715 struct wireless_dev *wdev, u64 cookie,
9716 struct ieee80211_channel *chan,
9717 unsigned int duration, gfp_t gfp)
9719 struct sk_buff *msg;
9722 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9726 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9732 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9733 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9734 wdev->netdev->ifindex)) ||
9735 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9736 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
9737 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
9738 NL80211_CHAN_NO_HT) ||
9739 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
9740 goto nla_put_failure;
9742 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
9743 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
9744 goto nla_put_failure;
9746 genlmsg_end(msg, hdr);
9748 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9749 nl80211_mlme_mcgrp.id, gfp);
9753 genlmsg_cancel(msg, hdr);
9757 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
9758 struct ieee80211_channel *chan,
9759 unsigned int duration, gfp_t gfp)
9761 struct wiphy *wiphy = wdev->wiphy;
9762 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9764 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9765 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
9766 rdev, wdev, cookie, chan,
9769 EXPORT_SYMBOL(cfg80211_ready_on_channel);
9771 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
9772 struct ieee80211_channel *chan,
9775 struct wiphy *wiphy = wdev->wiphy;
9776 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9778 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9779 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
9780 rdev, wdev, cookie, chan, 0, gfp);
9782 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9784 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
9785 struct station_info *sinfo, gfp_t gfp)
9787 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
9788 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9789 struct sk_buff *msg;
9791 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
9793 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9797 if (nl80211_send_station(msg, 0, 0, 0,
9798 rdev, dev, mac_addr, sinfo) < 0) {
9803 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9804 nl80211_mlme_mcgrp.id, gfp);
9806 EXPORT_SYMBOL(cfg80211_new_sta);
9808 void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp)
9810 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
9811 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9812 struct sk_buff *msg;
9815 trace_cfg80211_del_sta(dev, mac_addr);
9817 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9821 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
9827 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9828 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
9829 goto nla_put_failure;
9831 genlmsg_end(msg, hdr);
9833 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9834 nl80211_mlme_mcgrp.id, gfp);
9838 genlmsg_cancel(msg, hdr);
9841 EXPORT_SYMBOL(cfg80211_del_sta);
9843 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
9844 enum nl80211_connect_failed_reason reason,
9847 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
9848 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9849 struct sk_buff *msg;
9852 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
9856 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
9862 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9863 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
9864 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
9865 goto nla_put_failure;
9867 genlmsg_end(msg, hdr);
9869 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9870 nl80211_mlme_mcgrp.id, gfp);
9874 genlmsg_cancel(msg, hdr);
9877 EXPORT_SYMBOL(cfg80211_conn_failed);
9879 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
9880 const u8 *addr, gfp_t gfp)
9882 struct wireless_dev *wdev = dev->ieee80211_ptr;
9883 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
9884 struct sk_buff *msg;
9887 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
9892 msg = nlmsg_new(100, gfp);
9896 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9902 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9903 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9904 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
9905 goto nla_put_failure;
9907 err = genlmsg_end(msg, hdr);
9913 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
9917 genlmsg_cancel(msg, hdr);
9922 bool cfg80211_rx_spurious_frame(struct net_device *dev,
9923 const u8 *addr, gfp_t gfp)
9925 struct wireless_dev *wdev = dev->ieee80211_ptr;
9928 trace_cfg80211_rx_spurious_frame(dev, addr);
9930 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
9931 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
9932 trace_cfg80211_return_bool(false);
9935 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
9937 trace_cfg80211_return_bool(ret);
9940 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
9942 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
9943 const u8 *addr, gfp_t gfp)
9945 struct wireless_dev *wdev = dev->ieee80211_ptr;
9948 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
9950 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
9951 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
9952 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
9953 trace_cfg80211_return_bool(false);
9956 ret = __nl80211_unexpected_frame(dev,
9957 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
9959 trace_cfg80211_return_bool(ret);
9962 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
9964 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
9965 struct wireless_dev *wdev, u32 nlportid,
9966 int freq, int sig_dbm,
9967 const u8 *buf, size_t len, gfp_t gfp)
9969 struct net_device *netdev = wdev->netdev;
9970 struct sk_buff *msg;
9973 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9977 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
9983 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9984 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9985 netdev->ifindex)) ||
9986 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9987 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
9989 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
9990 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
9991 goto nla_put_failure;
9993 genlmsg_end(msg, hdr);
9995 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
9998 genlmsg_cancel(msg, hdr);
10003 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
10004 const u8 *buf, size_t len, bool ack, gfp_t gfp)
10006 struct wiphy *wiphy = wdev->wiphy;
10007 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10008 struct net_device *netdev = wdev->netdev;
10009 struct sk_buff *msg;
10012 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
10014 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10018 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
10024 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10025 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10026 netdev->ifindex)) ||
10027 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
10028 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
10029 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
10030 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
10031 goto nla_put_failure;
10033 genlmsg_end(msg, hdr);
10035 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10036 nl80211_mlme_mcgrp.id, gfp);
10040 genlmsg_cancel(msg, hdr);
10043 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
10045 void cfg80211_cqm_rssi_notify(struct net_device *dev,
10046 enum nl80211_cqm_rssi_threshold_event rssi_event,
10049 struct wireless_dev *wdev = dev->ieee80211_ptr;
10050 struct wiphy *wiphy = wdev->wiphy;
10051 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10052 struct sk_buff *msg;
10053 struct nlattr *pinfoattr;
10056 trace_cfg80211_cqm_rssi_notify(dev, rssi_event);
10058 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10062 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
10068 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10069 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
10070 goto nla_put_failure;
10072 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
10074 goto nla_put_failure;
10076 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
10078 goto nla_put_failure;
10080 nla_nest_end(msg, pinfoattr);
10082 genlmsg_end(msg, hdr);
10084 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10085 nl80211_mlme_mcgrp.id, gfp);
10089 genlmsg_cancel(msg, hdr);
10092 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
10094 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
10095 struct net_device *netdev, const u8 *bssid,
10096 const u8 *replay_ctr, gfp_t gfp)
10098 struct sk_buff *msg;
10099 struct nlattr *rekey_attr;
10102 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10106 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
10112 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10113 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10114 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
10115 goto nla_put_failure;
10117 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
10119 goto nla_put_failure;
10121 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
10122 NL80211_REPLAY_CTR_LEN, replay_ctr))
10123 goto nla_put_failure;
10125 nla_nest_end(msg, rekey_attr);
10127 genlmsg_end(msg, hdr);
10129 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10130 nl80211_mlme_mcgrp.id, gfp);
10134 genlmsg_cancel(msg, hdr);
10138 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
10139 const u8 *replay_ctr, gfp_t gfp)
10141 struct wireless_dev *wdev = dev->ieee80211_ptr;
10142 struct wiphy *wiphy = wdev->wiphy;
10143 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10145 trace_cfg80211_gtk_rekey_notify(dev, bssid);
10146 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
10148 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
10151 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
10152 struct net_device *netdev, int index,
10153 const u8 *bssid, bool preauth, gfp_t gfp)
10155 struct sk_buff *msg;
10156 struct nlattr *attr;
10159 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10163 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
10169 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10170 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
10171 goto nla_put_failure;
10173 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
10175 goto nla_put_failure;
10177 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
10178 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
10180 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
10181 goto nla_put_failure;
10183 nla_nest_end(msg, attr);
10185 genlmsg_end(msg, hdr);
10187 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10188 nl80211_mlme_mcgrp.id, gfp);
10192 genlmsg_cancel(msg, hdr);
10196 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
10197 const u8 *bssid, bool preauth, gfp_t gfp)
10199 struct wireless_dev *wdev = dev->ieee80211_ptr;
10200 struct wiphy *wiphy = wdev->wiphy;
10201 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10203 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
10204 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
10206 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
10208 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
10209 struct net_device *netdev,
10210 struct cfg80211_chan_def *chandef,
10213 struct sk_buff *msg;
10216 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10220 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY);
10226 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
10227 goto nla_put_failure;
10229 if (nl80211_send_chandef(msg, chandef))
10230 goto nla_put_failure;
10232 genlmsg_end(msg, hdr);
10234 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10235 nl80211_mlme_mcgrp.id, gfp);
10239 genlmsg_cancel(msg, hdr);
10243 void cfg80211_ch_switch_notify(struct net_device *dev,
10244 struct cfg80211_chan_def *chandef)
10246 struct wireless_dev *wdev = dev->ieee80211_ptr;
10247 struct wiphy *wiphy = wdev->wiphy;
10248 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10250 trace_cfg80211_ch_switch_notify(dev, chandef);
10254 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
10255 wdev->iftype != NL80211_IFTYPE_P2P_GO))
10258 wdev->channel = chandef->chan;
10259 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL);
10264 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
10266 void cfg80211_cqm_txe_notify(struct net_device *dev,
10267 const u8 *peer, u32 num_packets,
10268 u32 rate, u32 intvl, gfp_t gfp)
10270 struct wireless_dev *wdev = dev->ieee80211_ptr;
10271 struct wiphy *wiphy = wdev->wiphy;
10272 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10273 struct sk_buff *msg;
10274 struct nlattr *pinfoattr;
10277 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
10281 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
10287 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10288 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10289 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
10290 goto nla_put_failure;
10292 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
10294 goto nla_put_failure;
10296 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
10297 goto nla_put_failure;
10299 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
10300 goto nla_put_failure;
10302 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
10303 goto nla_put_failure;
10305 nla_nest_end(msg, pinfoattr);
10307 genlmsg_end(msg, hdr);
10309 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10310 nl80211_mlme_mcgrp.id, gfp);
10314 genlmsg_cancel(msg, hdr);
10317 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
10320 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
10321 struct cfg80211_chan_def *chandef,
10322 enum nl80211_radar_event event,
10323 struct net_device *netdev, gfp_t gfp)
10325 struct sk_buff *msg;
10328 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10332 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
10338 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
10339 goto nla_put_failure;
10341 /* NOP and radar events don't need a netdev parameter */
10343 struct wireless_dev *wdev = netdev->ieee80211_ptr;
10345 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10346 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10347 goto nla_put_failure;
10350 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
10351 goto nla_put_failure;
10353 if (nl80211_send_chandef(msg, chandef))
10354 goto nla_put_failure;
10356 if (genlmsg_end(msg, hdr) < 0) {
10361 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10362 nl80211_mlme_mcgrp.id, gfp);
10366 genlmsg_cancel(msg, hdr);
10370 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
10371 const u8 *peer, u32 num_packets, gfp_t gfp)
10373 struct wireless_dev *wdev = dev->ieee80211_ptr;
10374 struct wiphy *wiphy = wdev->wiphy;
10375 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10376 struct sk_buff *msg;
10377 struct nlattr *pinfoattr;
10380 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
10382 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10386 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
10392 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10393 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10394 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
10395 goto nla_put_failure;
10397 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
10399 goto nla_put_failure;
10401 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
10402 goto nla_put_failure;
10404 nla_nest_end(msg, pinfoattr);
10406 genlmsg_end(msg, hdr);
10408 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10409 nl80211_mlme_mcgrp.id, gfp);
10413 genlmsg_cancel(msg, hdr);
10416 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
10418 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
10419 u64 cookie, bool acked, gfp_t gfp)
10421 struct wireless_dev *wdev = dev->ieee80211_ptr;
10422 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10423 struct sk_buff *msg;
10427 trace_cfg80211_probe_status(dev, addr, cookie, acked);
10429 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10434 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
10440 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10441 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10442 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
10443 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
10444 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
10445 goto nla_put_failure;
10447 err = genlmsg_end(msg, hdr);
10453 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10454 nl80211_mlme_mcgrp.id, gfp);
10458 genlmsg_cancel(msg, hdr);
10461 EXPORT_SYMBOL(cfg80211_probe_status);
10463 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
10464 const u8 *frame, size_t len,
10465 int freq, int sig_dbm)
10467 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10468 struct sk_buff *msg;
10470 struct cfg80211_beacon_registration *reg;
10472 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
10474 spin_lock_bh(&rdev->beacon_registrations_lock);
10475 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
10476 msg = nlmsg_new(len + 100, GFP_ATOMIC);
10478 spin_unlock_bh(&rdev->beacon_registrations_lock);
10482 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
10484 goto nla_put_failure;
10486 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10488 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
10490 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
10491 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
10492 goto nla_put_failure;
10494 genlmsg_end(msg, hdr);
10496 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
10498 spin_unlock_bh(&rdev->beacon_registrations_lock);
10502 spin_unlock_bh(&rdev->beacon_registrations_lock);
10504 genlmsg_cancel(msg, hdr);
10507 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
10510 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
10511 struct cfg80211_wowlan_wakeup *wakeup,
10514 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10515 struct sk_buff *msg;
10517 int err, size = 200;
10519 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
10522 size += wakeup->packet_present_len;
10524 msg = nlmsg_new(size, gfp);
10528 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
10532 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10533 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10536 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10537 wdev->netdev->ifindex))
10541 struct nlattr *reasons;
10543 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10545 if (wakeup->disconnect &&
10546 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
10548 if (wakeup->magic_pkt &&
10549 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
10551 if (wakeup->gtk_rekey_failure &&
10552 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
10554 if (wakeup->eap_identity_req &&
10555 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
10557 if (wakeup->four_way_handshake &&
10558 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
10560 if (wakeup->rfkill_release &&
10561 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
10564 if (wakeup->pattern_idx >= 0 &&
10565 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
10566 wakeup->pattern_idx))
10569 if (wakeup->tcp_match)
10570 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH);
10572 if (wakeup->tcp_connlost)
10574 NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST);
10576 if (wakeup->tcp_nomoretokens)
10578 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS);
10580 if (wakeup->packet) {
10581 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
10582 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
10584 if (!wakeup->packet_80211) {
10586 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
10588 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
10591 if (wakeup->packet_len &&
10592 nla_put_u32(msg, len_attr, wakeup->packet_len))
10595 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
10600 nla_nest_end(msg, reasons);
10603 err = genlmsg_end(msg, hdr);
10607 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10608 nl80211_mlme_mcgrp.id, gfp);
10614 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
10617 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
10618 enum nl80211_tdls_operation oper,
10619 u16 reason_code, gfp_t gfp)
10621 struct wireless_dev *wdev = dev->ieee80211_ptr;
10622 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10623 struct sk_buff *msg;
10627 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
10630 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10634 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
10640 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10641 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10642 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
10643 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
10644 (reason_code > 0 &&
10645 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
10646 goto nla_put_failure;
10648 err = genlmsg_end(msg, hdr);
10654 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10655 nl80211_mlme_mcgrp.id, gfp);
10659 genlmsg_cancel(msg, hdr);
10662 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
10664 static int nl80211_netlink_notify(struct notifier_block * nb,
10665 unsigned long state,
10668 struct netlink_notify *notify = _notify;
10669 struct cfg80211_registered_device *rdev;
10670 struct wireless_dev *wdev;
10671 struct cfg80211_beacon_registration *reg, *tmp;
10673 if (state != NETLINK_URELEASE)
10674 return NOTIFY_DONE;
10678 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
10679 list_for_each_entry_rcu(wdev, &rdev->wdev_list, list)
10680 cfg80211_mlme_unregister_socket(wdev, notify->portid);
10682 spin_lock_bh(&rdev->beacon_registrations_lock);
10683 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
10685 if (reg->nlportid == notify->portid) {
10686 list_del(®->list);
10691 spin_unlock_bh(&rdev->beacon_registrations_lock);
10696 return NOTIFY_DONE;
10699 static struct notifier_block nl80211_netlink_notifier = {
10700 .notifier_call = nl80211_netlink_notify,
10703 void cfg80211_ft_event(struct net_device *netdev,
10704 struct cfg80211_ft_event_params *ft_event)
10706 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
10707 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10708 struct sk_buff *msg;
10712 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
10714 if (!ft_event->target_ap)
10717 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10721 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
10727 nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
10728 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
10729 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap);
10731 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies);
10732 if (ft_event->ric_ies)
10733 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
10734 ft_event->ric_ies);
10736 err = genlmsg_end(msg, hdr);
10742 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10743 nl80211_mlme_mcgrp.id, GFP_KERNEL);
10745 EXPORT_SYMBOL(cfg80211_ft_event);
10747 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
10749 struct cfg80211_registered_device *rdev;
10750 struct sk_buff *msg;
10754 rdev = wiphy_to_dev(wdev->wiphy);
10755 if (!rdev->crit_proto_nlportid)
10758 nlportid = rdev->crit_proto_nlportid;
10759 rdev->crit_proto_nlportid = 0;
10761 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10765 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
10767 goto nla_put_failure;
10769 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10770 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10771 goto nla_put_failure;
10773 genlmsg_end(msg, hdr);
10775 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
10780 genlmsg_cancel(msg, hdr);
10784 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
10786 /* initialisation/exit functions */
10788 int nl80211_init(void)
10792 err = genl_register_family_with_ops(&nl80211_fam,
10793 nl80211_ops, ARRAY_SIZE(nl80211_ops));
10797 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
10801 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
10805 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
10809 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
10813 #ifdef CONFIG_NL80211_TESTMODE
10814 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
10819 err = netlink_register_notifier(&nl80211_netlink_notifier);
10825 genl_unregister_family(&nl80211_fam);
10829 void nl80211_exit(void)
10831 netlink_unregister_notifier(&nl80211_netlink_notifier);
10832 genl_unregister_family(&nl80211_fam);