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, },
376 /* policy for the key attributes */
377 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
378 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
379 [NL80211_KEY_IDX] = { .type = NLA_U8 },
380 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
381 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
382 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
383 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
384 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
385 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
388 /* policy for the key default flags */
389 static const struct nla_policy
390 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
391 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
392 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
395 /* policy for WoWLAN attributes */
396 static const struct nla_policy
397 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
398 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
399 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
400 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
401 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
402 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
403 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
404 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
405 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
406 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
409 static const struct nla_policy
410 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
411 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
412 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
413 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
414 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
415 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
416 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
417 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
418 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
420 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
421 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
423 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
424 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
425 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
428 /* policy for GTK rekey offload attributes */
429 static const struct nla_policy
430 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
431 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
432 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
433 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
436 static const struct nla_policy
437 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
438 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
439 .len = IEEE80211_MAX_SSID_LEN },
440 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
443 /* ifidx get helper */
444 static int nl80211_get_ifidx(struct netlink_callback *cb)
448 res = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
449 nl80211_fam.attrbuf, nl80211_fam.maxattr,
454 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
457 res = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
463 static int nl80211_prepare_netdev_dump(struct sk_buff *skb,
464 struct netlink_callback *cb,
465 struct cfg80211_registered_device **rdev,
466 struct net_device **dev)
468 int ifidx = cb->args[0];
472 ifidx = nl80211_get_ifidx(cb);
480 *dev = __dev_get_by_index(sock_net(skb->sk), ifidx);
486 *rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
488 err = PTR_ERR(*rdev);
498 static void nl80211_finish_netdev_dump(struct cfg80211_registered_device *rdev)
500 cfg80211_unlock_rdev(rdev);
505 static bool is_valid_ie_attr(const struct nlattr *attr)
513 pos = nla_data(attr);
534 /* message building helper */
535 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
538 /* since there is no private header just add the generic one */
539 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
542 static int nl80211_msg_put_channel(struct sk_buff *msg,
543 struct ieee80211_channel *chan)
545 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
547 goto nla_put_failure;
549 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
550 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
551 goto nla_put_failure;
552 if ((chan->flags & IEEE80211_CHAN_PASSIVE_SCAN) &&
553 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN))
554 goto nla_put_failure;
555 if ((chan->flags & IEEE80211_CHAN_NO_IBSS) &&
556 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IBSS))
557 goto nla_put_failure;
558 if ((chan->flags & IEEE80211_CHAN_RADAR) &&
559 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
560 goto nla_put_failure;
562 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
563 DBM_TO_MBM(chan->max_power)))
564 goto nla_put_failure;
572 /* netlink command implementations */
579 bool def_uni, def_multi;
582 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
584 struct nlattr *tb[NL80211_KEY_MAX + 1];
585 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
590 k->def = !!tb[NL80211_KEY_DEFAULT];
591 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
600 if (tb[NL80211_KEY_IDX])
601 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
603 if (tb[NL80211_KEY_DATA]) {
604 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
605 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
608 if (tb[NL80211_KEY_SEQ]) {
609 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
610 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
613 if (tb[NL80211_KEY_CIPHER])
614 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
616 if (tb[NL80211_KEY_TYPE]) {
617 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
618 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
622 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
623 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
624 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
625 tb[NL80211_KEY_DEFAULT_TYPES],
626 nl80211_key_default_policy);
630 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
631 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
637 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
639 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
640 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
641 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
644 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
645 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
646 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
649 if (info->attrs[NL80211_ATTR_KEY_IDX])
650 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
652 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
653 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
655 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
656 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
665 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
666 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
667 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
671 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
672 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
673 int err = nla_parse_nested(
674 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
675 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
676 nl80211_key_default_policy);
680 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
681 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
687 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
691 memset(k, 0, sizeof(*k));
695 if (info->attrs[NL80211_ATTR_KEY])
696 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
698 err = nl80211_parse_key_old(info, k);
703 if (k->def && k->defmgmt)
707 if (k->def_uni || !k->def_multi)
713 if (k->idx < 4 || k->idx > 5)
716 if (k->idx < 0 || k->idx > 3)
719 if (k->idx < 0 || k->idx > 5)
727 static struct cfg80211_cached_keys *
728 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
729 struct nlattr *keys, bool *no_ht)
731 struct key_parse parse;
733 struct cfg80211_cached_keys *result;
734 int rem, err, def = 0;
736 result = kzalloc(sizeof(*result), GFP_KERNEL);
738 return ERR_PTR(-ENOMEM);
741 result->defmgmt = -1;
743 nla_for_each_nested(key, keys, rem) {
744 memset(&parse, 0, sizeof(parse));
747 err = nl80211_parse_key_new(key, &parse);
753 if (parse.idx < 0 || parse.idx > 4)
759 result->def = parse.idx;
760 if (!parse.def_uni || !parse.def_multi)
762 } else if (parse.defmgmt)
764 err = cfg80211_validate_key_settings(rdev, &parse.p,
765 parse.idx, false, NULL);
768 result->params[parse.idx].cipher = parse.p.cipher;
769 result->params[parse.idx].key_len = parse.p.key_len;
770 result->params[parse.idx].key = result->data[parse.idx];
771 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
773 if (parse.p.cipher == WLAN_CIPHER_SUITE_WEP40 ||
774 parse.p.cipher == WLAN_CIPHER_SUITE_WEP104) {
786 static int nl80211_key_allowed(struct wireless_dev *wdev)
788 ASSERT_WDEV_LOCK(wdev);
790 switch (wdev->iftype) {
791 case NL80211_IFTYPE_AP:
792 case NL80211_IFTYPE_AP_VLAN:
793 case NL80211_IFTYPE_P2P_GO:
794 case NL80211_IFTYPE_MESH_POINT:
796 case NL80211_IFTYPE_ADHOC:
797 if (!wdev->current_bss)
800 case NL80211_IFTYPE_STATION:
801 case NL80211_IFTYPE_P2P_CLIENT:
802 if (wdev->sme_state != CFG80211_SME_CONNECTED)
812 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
814 struct nlattr *nl_modes = nla_nest_start(msg, attr);
818 goto nla_put_failure;
822 if ((ifmodes & 1) && nla_put_flag(msg, i))
823 goto nla_put_failure;
828 nla_nest_end(msg, nl_modes);
835 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
838 struct nlattr *nl_combis;
841 nl_combis = nla_nest_start(msg,
842 NL80211_ATTR_INTERFACE_COMBINATIONS);
844 goto nla_put_failure;
846 for (i = 0; i < wiphy->n_iface_combinations; i++) {
847 const struct ieee80211_iface_combination *c;
848 struct nlattr *nl_combi, *nl_limits;
850 c = &wiphy->iface_combinations[i];
852 nl_combi = nla_nest_start(msg, i + 1);
854 goto nla_put_failure;
856 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
858 goto nla_put_failure;
860 for (j = 0; j < c->n_limits; j++) {
861 struct nlattr *nl_limit;
863 nl_limit = nla_nest_start(msg, j + 1);
865 goto nla_put_failure;
866 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
868 goto nla_put_failure;
869 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
871 goto nla_put_failure;
872 nla_nest_end(msg, nl_limit);
875 nla_nest_end(msg, nl_limits);
877 if (c->beacon_int_infra_match &&
878 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
879 goto nla_put_failure;
880 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
881 c->num_different_channels) ||
882 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
884 goto nla_put_failure;
886 nla_nest_end(msg, nl_combi);
889 nla_nest_end(msg, nl_combis);
897 static int nl80211_send_wowlan(struct sk_buff *msg,
898 struct cfg80211_registered_device *dev)
900 struct nlattr *nl_wowlan;
902 if (!dev->wiphy.wowlan.flags && !dev->wiphy.wowlan.n_patterns)
905 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
909 if (((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_ANY) &&
910 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
911 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_DISCONNECT) &&
912 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
913 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_MAGIC_PKT) &&
914 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
915 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
916 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
917 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
918 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
919 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
920 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
921 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
922 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
923 ((dev->wiphy.wowlan.flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
924 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
927 if (dev->wiphy.wowlan.n_patterns) {
928 struct nl80211_wowlan_pattern_support pat = {
929 .max_patterns = dev->wiphy.wowlan.n_patterns,
930 .min_pattern_len = dev->wiphy.wowlan.pattern_min_len,
931 .max_pattern_len = dev->wiphy.wowlan.pattern_max_len,
932 .max_pkt_offset = dev->wiphy.wowlan.max_pkt_offset,
935 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
940 nla_nest_end(msg, nl_wowlan);
946 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
947 struct ieee80211_supported_band *sband)
949 struct nlattr *nl_rates, *nl_rate;
950 struct ieee80211_rate *rate;
954 if (sband->ht_cap.ht_supported &&
955 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
956 sizeof(sband->ht_cap.mcs),
957 &sband->ht_cap.mcs) ||
958 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
959 sband->ht_cap.cap) ||
960 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
961 sband->ht_cap.ampdu_factor) ||
962 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
963 sband->ht_cap.ampdu_density)))
967 if (sband->vht_cap.vht_supported &&
968 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
969 sizeof(sband->vht_cap.vht_mcs),
970 &sband->vht_cap.vht_mcs) ||
971 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
972 sband->vht_cap.cap)))
976 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
980 for (i = 0; i < sband->n_bitrates; i++) {
981 nl_rate = nla_nest_start(msg, i);
985 rate = &sband->bitrates[i];
986 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
989 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
991 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
994 nla_nest_end(msg, nl_rate);
997 nla_nest_end(msg, nl_rates);
1003 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1004 const struct ieee80211_txrx_stypes *mgmt_stypes)
1007 struct nlattr *nl_ftypes, *nl_ifs;
1008 enum nl80211_iftype ift;
1014 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1018 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1019 nl_ftypes = nla_nest_start(msg, ift);
1023 stypes = mgmt_stypes[ift].tx;
1026 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1027 (i << 4) | IEEE80211_FTYPE_MGMT))
1032 nla_nest_end(msg, nl_ftypes);
1035 nla_nest_end(msg, nl_ifs);
1037 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1041 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1042 nl_ftypes = nla_nest_start(msg, ift);
1046 stypes = mgmt_stypes[ift].rx;
1049 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1050 (i << 4) | IEEE80211_FTYPE_MGMT))
1055 nla_nest_end(msg, nl_ftypes);
1057 nla_nest_end(msg, nl_ifs);
1062 static int nl80211_send_wiphy(struct cfg80211_registered_device *dev,
1063 struct sk_buff *msg, u32 portid, u32 seq,
1064 int flags, bool split, long *split_start,
1065 long *band_start, long *chan_start)
1068 struct nlattr *nl_bands, *nl_band;
1069 struct nlattr *nl_freqs, *nl_freq;
1070 struct nlattr *nl_cmds;
1071 enum ieee80211_band band;
1072 struct ieee80211_channel *chan;
1074 const struct ieee80211_txrx_stypes *mgmt_stypes =
1075 dev->wiphy.mgmt_stypes;
1076 long start = 0, start_chan = 0, start_band = 0;
1078 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_WIPHY);
1082 /* allow always using the variables */
1084 split_start = &start;
1085 band_start = &start_band;
1086 chan_start = &start_chan;
1089 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx) ||
1090 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1091 wiphy_name(&dev->wiphy)) ||
1092 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1093 cfg80211_rdev_list_generation))
1094 goto nla_put_failure;
1096 switch (*split_start) {
1098 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1099 dev->wiphy.retry_short) ||
1100 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1101 dev->wiphy.retry_long) ||
1102 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1103 dev->wiphy.frag_threshold) ||
1104 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1105 dev->wiphy.rts_threshold) ||
1106 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1107 dev->wiphy.coverage_class) ||
1108 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1109 dev->wiphy.max_scan_ssids) ||
1110 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1111 dev->wiphy.max_sched_scan_ssids) ||
1112 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1113 dev->wiphy.max_scan_ie_len) ||
1114 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1115 dev->wiphy.max_sched_scan_ie_len) ||
1116 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
1117 dev->wiphy.max_match_sets))
1118 goto nla_put_failure;
1120 if ((dev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
1121 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
1122 goto nla_put_failure;
1123 if ((dev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
1124 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1125 goto nla_put_failure;
1126 if ((dev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
1127 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1128 goto nla_put_failure;
1129 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
1130 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1131 goto nla_put_failure;
1132 if ((dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
1133 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1134 goto nla_put_failure;
1135 if ((dev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
1136 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
1137 goto nla_put_failure;
1143 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1144 sizeof(u32) * dev->wiphy.n_cipher_suites,
1145 dev->wiphy.cipher_suites))
1146 goto nla_put_failure;
1148 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1149 dev->wiphy.max_num_pmkids))
1150 goto nla_put_failure;
1152 if ((dev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
1153 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
1154 goto nla_put_failure;
1156 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1157 dev->wiphy.available_antennas_tx) ||
1158 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1159 dev->wiphy.available_antennas_rx))
1160 goto nla_put_failure;
1162 if ((dev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
1163 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1164 dev->wiphy.probe_resp_offload))
1165 goto nla_put_failure;
1167 if ((dev->wiphy.available_antennas_tx ||
1168 dev->wiphy.available_antennas_rx) &&
1169 dev->ops->get_antenna) {
1170 u32 tx_ant = 0, rx_ant = 0;
1172 res = rdev_get_antenna(dev, &tx_ant, &rx_ant);
1174 if (nla_put_u32(msg,
1175 NL80211_ATTR_WIPHY_ANTENNA_TX,
1178 NL80211_ATTR_WIPHY_ANTENNA_RX,
1180 goto nla_put_failure;
1188 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1189 dev->wiphy.interface_modes))
1190 goto nla_put_failure;
1195 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1197 goto nla_put_failure;
1199 for (band = *band_start; band < IEEE80211_NUM_BANDS; band++) {
1200 struct ieee80211_supported_band *sband;
1202 sband = dev->wiphy.bands[band];
1207 nl_band = nla_nest_start(msg, band);
1209 goto nla_put_failure;
1211 switch (*chan_start) {
1213 if (nl80211_send_band_rateinfo(msg, sband))
1214 goto nla_put_failure;
1219 /* add frequencies */
1220 nl_freqs = nla_nest_start(
1221 msg, NL80211_BAND_ATTR_FREQS);
1223 goto nla_put_failure;
1225 for (i = *chan_start - 1;
1226 i < sband->n_channels;
1228 nl_freq = nla_nest_start(msg, i);
1230 goto nla_put_failure;
1232 chan = &sband->channels[i];
1234 if (nl80211_msg_put_channel(msg, chan))
1235 goto nla_put_failure;
1237 nla_nest_end(msg, nl_freq);
1241 if (i < sband->n_channels)
1242 *chan_start = i + 2;
1245 nla_nest_end(msg, nl_freqs);
1248 nla_nest_end(msg, nl_band);
1251 /* start again here */
1257 nla_nest_end(msg, nl_bands);
1259 if (band < IEEE80211_NUM_BANDS)
1260 *band_start = band + 1;
1264 /* if bands & channels are done, continue outside */
1265 if (*band_start == 0 && *chan_start == 0)
1270 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1272 goto nla_put_failure;
1275 #define CMD(op, n) \
1277 if (dev->ops->op) { \
1279 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1280 goto nla_put_failure; \
1284 CMD(add_virtual_intf, NEW_INTERFACE);
1285 CMD(change_virtual_intf, SET_INTERFACE);
1286 CMD(add_key, NEW_KEY);
1287 CMD(start_ap, START_AP);
1288 CMD(add_station, NEW_STATION);
1289 CMD(add_mpath, NEW_MPATH);
1290 CMD(update_mesh_config, SET_MESH_CONFIG);
1291 CMD(change_bss, SET_BSS);
1292 CMD(auth, AUTHENTICATE);
1293 CMD(assoc, ASSOCIATE);
1294 CMD(deauth, DEAUTHENTICATE);
1295 CMD(disassoc, DISASSOCIATE);
1296 CMD(join_ibss, JOIN_IBSS);
1297 CMD(join_mesh, JOIN_MESH);
1298 CMD(set_pmksa, SET_PMKSA);
1299 CMD(del_pmksa, DEL_PMKSA);
1300 CMD(flush_pmksa, FLUSH_PMKSA);
1301 if (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1302 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1303 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1304 CMD(mgmt_tx, FRAME);
1305 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1306 if (dev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1308 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1309 goto nla_put_failure;
1311 if (dev->ops->set_monitor_channel || dev->ops->start_ap ||
1312 dev->ops->join_mesh) {
1314 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1315 goto nla_put_failure;
1317 CMD(set_wds_peer, SET_WDS_PEER);
1318 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1319 CMD(tdls_mgmt, TDLS_MGMT);
1320 CMD(tdls_oper, TDLS_OPER);
1322 if (dev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
1323 CMD(sched_scan_start, START_SCHED_SCAN);
1324 CMD(probe_client, PROBE_CLIENT);
1325 CMD(set_noack_map, SET_NOACK_MAP);
1326 if (dev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1328 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1329 goto nla_put_failure;
1331 CMD(start_p2p_device, START_P2P_DEVICE);
1332 CMD(set_mcast_rate, SET_MCAST_RATE);
1334 #ifdef CONFIG_NL80211_TESTMODE
1335 CMD(testmode_cmd, TESTMODE);
1340 if (dev->ops->connect || dev->ops->auth) {
1342 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1343 goto nla_put_failure;
1346 if (dev->ops->disconnect || dev->ops->deauth) {
1348 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1349 goto nla_put_failure;
1352 nla_nest_end(msg, nl_cmds);
1357 if (dev->ops->remain_on_channel &&
1358 (dev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
1360 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1361 dev->wiphy.max_remain_on_channel_duration))
1362 goto nla_put_failure;
1364 if ((dev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
1365 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1366 goto nla_put_failure;
1368 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1369 goto nla_put_failure;
1375 if (nl80211_send_wowlan(msg, dev))
1376 goto nla_put_failure;
1384 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1385 dev->wiphy.software_iftypes))
1386 goto nla_put_failure;
1388 if (nl80211_put_iface_combinations(&dev->wiphy, msg))
1389 goto nla_put_failure;
1395 if ((dev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
1396 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1397 dev->wiphy.ap_sme_capa))
1398 goto nla_put_failure;
1400 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS,
1401 dev->wiphy.features))
1402 goto nla_put_failure;
1404 if (dev->wiphy.ht_capa_mod_mask &&
1405 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1406 sizeof(*dev->wiphy.ht_capa_mod_mask),
1407 dev->wiphy.ht_capa_mod_mask))
1408 goto nla_put_failure;
1410 if (dev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1411 dev->wiphy.max_acl_mac_addrs &&
1412 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1413 dev->wiphy.max_acl_mac_addrs))
1414 goto nla_put_failure;
1417 * Any information below this point is only available to
1418 * applications that can deal with it being split. This
1419 * helps ensure that newly added capabilities don't break
1420 * older tools by overrunning their buffers.
1422 * We still increment split_start so that in the split
1423 * case we'll continue with more data in the next round,
1424 * but break unconditionally so unsplit data stops here.
1435 return genlmsg_end(msg, hdr);
1438 genlmsg_cancel(msg, hdr);
1442 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1445 int start = cb->args[0];
1446 struct cfg80211_registered_device *dev;
1447 s64 filter_wiphy = -1;
1449 struct nlattr **tb = nl80211_fam.attrbuf;
1452 mutex_lock(&cfg80211_mutex);
1453 res = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1454 tb, nl80211_fam.maxattr, nl80211_policy);
1456 split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1457 if (tb[NL80211_ATTR_WIPHY])
1458 filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1459 if (tb[NL80211_ATTR_WDEV])
1460 filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1461 if (tb[NL80211_ATTR_IFINDEX]) {
1462 struct net_device *netdev;
1463 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1465 netdev = dev_get_by_index(sock_net(skb->sk), ifidx);
1467 mutex_unlock(&cfg80211_mutex);
1470 if (netdev->ieee80211_ptr) {
1472 netdev->ieee80211_ptr->wiphy);
1473 filter_wiphy = dev->wiphy_idx;
1479 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
1480 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
1484 if (filter_wiphy != -1 && dev->wiphy_idx != filter_wiphy)
1486 /* attempt to fit multiple wiphy data chunks into the skb */
1488 ret = nl80211_send_wiphy(dev, skb,
1489 NETLINK_CB(cb->skb).portid,
1492 split, &cb->args[1],
1497 * If sending the wiphy data didn't fit (ENOBUFS
1498 * or EMSGSIZE returned), this SKB is still
1499 * empty (so it's not too big because another
1500 * wiphy dataset is already in the skb) and
1501 * we've not tried to adjust the dump allocation
1502 * yet ... then adjust the alloc size to be
1503 * bigger, and return 1 but with the empty skb.
1504 * This results in an empty message being RX'ed
1505 * in userspace, but that is ignored.
1507 * We can then retry with the larger buffer.
1509 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
1511 cb->min_dump_alloc < 4096) {
1512 cb->min_dump_alloc = 4096;
1513 mutex_unlock(&cfg80211_mutex);
1519 } while (cb->args[1] > 0);
1522 mutex_unlock(&cfg80211_mutex);
1529 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
1531 struct sk_buff *msg;
1532 struct cfg80211_registered_device *dev = info->user_ptr[0];
1534 msg = nlmsg_new(4096, GFP_KERNEL);
1538 if (nl80211_send_wiphy(dev, msg, info->snd_portid, info->snd_seq, 0,
1539 false, NULL, NULL, NULL) < 0) {
1544 return genlmsg_reply(msg, info);
1547 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
1548 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
1549 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
1550 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
1551 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
1552 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
1555 static int parse_txq_params(struct nlattr *tb[],
1556 struct ieee80211_txq_params *txq_params)
1558 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
1559 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
1560 !tb[NL80211_TXQ_ATTR_AIFS])
1563 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
1564 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
1565 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
1566 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
1567 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
1569 if (txq_params->ac >= NL80211_NUM_ACS)
1575 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
1578 * You can only set the channel explicitly for WDS interfaces,
1579 * all others have their channel managed via their respective
1580 * "establish a connection" command (connect, join, ...)
1582 * For AP/GO and mesh mode, the channel can be set with the
1583 * channel userspace API, but is only stored and passed to the
1584 * low-level driver when the AP starts or the mesh is joined.
1585 * This is for backward compatibility, userspace can also give
1586 * the channel in the start-ap or join-mesh commands instead.
1588 * Monitors are special as they are normally slaved to
1589 * whatever else is going on, so they have their own special
1590 * operation to set the monitor channel if possible.
1593 wdev->iftype == NL80211_IFTYPE_AP ||
1594 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
1595 wdev->iftype == NL80211_IFTYPE_MONITOR ||
1596 wdev->iftype == NL80211_IFTYPE_P2P_GO;
1599 static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
1600 struct genl_info *info,
1601 struct cfg80211_chan_def *chandef)
1605 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
1608 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
1610 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
1611 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
1612 chandef->center_freq1 = control_freq;
1613 chandef->center_freq2 = 0;
1615 /* Primary channel not allowed */
1616 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
1619 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
1620 enum nl80211_channel_type chantype;
1622 chantype = nla_get_u32(
1623 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1626 case NL80211_CHAN_NO_HT:
1627 case NL80211_CHAN_HT20:
1628 case NL80211_CHAN_HT40PLUS:
1629 case NL80211_CHAN_HT40MINUS:
1630 cfg80211_chandef_create(chandef, chandef->chan,
1636 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
1638 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
1639 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
1640 chandef->center_freq1 =
1642 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
1643 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
1644 chandef->center_freq2 =
1646 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
1649 if (!cfg80211_chandef_valid(chandef))
1652 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
1653 IEEE80211_CHAN_DISABLED))
1659 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
1660 struct wireless_dev *wdev,
1661 struct genl_info *info)
1663 struct cfg80211_chan_def chandef;
1665 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
1668 iftype = wdev->iftype;
1670 if (!nl80211_can_set_dev_channel(wdev))
1673 result = nl80211_parse_chandef(rdev, info, &chandef);
1677 mutex_lock(&rdev->devlist_mtx);
1679 case NL80211_IFTYPE_AP:
1680 case NL80211_IFTYPE_P2P_GO:
1681 if (wdev->beacon_interval) {
1685 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef)) {
1689 wdev->preset_chandef = chandef;
1692 case NL80211_IFTYPE_MESH_POINT:
1693 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
1695 case NL80211_IFTYPE_MONITOR:
1696 result = cfg80211_set_monitor_channel(rdev, &chandef);
1701 mutex_unlock(&rdev->devlist_mtx);
1706 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
1708 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1709 struct net_device *netdev = info->user_ptr[1];
1711 return __nl80211_set_channel(rdev, netdev->ieee80211_ptr, info);
1714 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
1716 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1717 struct net_device *dev = info->user_ptr[1];
1718 struct wireless_dev *wdev = dev->ieee80211_ptr;
1721 if (!info->attrs[NL80211_ATTR_MAC])
1724 if (netif_running(dev))
1727 if (!rdev->ops->set_wds_peer)
1730 if (wdev->iftype != NL80211_IFTYPE_WDS)
1733 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
1734 return rdev_set_wds_peer(rdev, dev, bssid);
1738 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
1740 struct cfg80211_registered_device *rdev;
1741 struct net_device *netdev = NULL;
1742 struct wireless_dev *wdev;
1743 int result = 0, rem_txq_params = 0;
1744 struct nlattr *nl_txq_params;
1746 u8 retry_short = 0, retry_long = 0;
1747 u32 frag_threshold = 0, rts_threshold = 0;
1748 u8 coverage_class = 0;
1751 * Try to find the wiphy and netdev. Normally this
1752 * function shouldn't need the netdev, but this is
1753 * done for backward compatibility -- previously
1754 * setting the channel was done per wiphy, but now
1755 * it is per netdev. Previous userland like hostapd
1756 * also passed a netdev to set_wiphy, so that it is
1757 * possible to let that go to the right netdev!
1759 mutex_lock(&cfg80211_mutex);
1761 if (info->attrs[NL80211_ATTR_IFINDEX]) {
1762 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
1764 netdev = dev_get_by_index(genl_info_net(info), ifindex);
1765 if (netdev && netdev->ieee80211_ptr) {
1766 rdev = wiphy_to_dev(netdev->ieee80211_ptr->wiphy);
1767 mutex_lock(&rdev->mtx);
1773 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
1776 mutex_unlock(&cfg80211_mutex);
1777 return PTR_ERR(rdev);
1783 mutex_lock(&rdev->mtx);
1785 wdev = netdev->ieee80211_ptr;
1788 * end workaround code, by now the rdev is available
1789 * and locked, and wdev may or may not be NULL.
1792 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
1793 result = cfg80211_dev_rename(
1794 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
1796 mutex_unlock(&cfg80211_mutex);
1801 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
1802 struct ieee80211_txq_params txq_params;
1803 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
1805 if (!rdev->ops->set_txq_params) {
1806 result = -EOPNOTSUPP;
1815 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
1816 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
1821 if (!netif_running(netdev)) {
1826 nla_for_each_nested(nl_txq_params,
1827 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
1829 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
1830 nla_data(nl_txq_params),
1831 nla_len(nl_txq_params),
1833 result = parse_txq_params(tb, &txq_params);
1837 result = rdev_set_txq_params(rdev, netdev,
1844 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
1845 result = __nl80211_set_channel(rdev,
1846 nl80211_can_set_dev_channel(wdev) ? wdev : NULL,
1852 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
1853 struct wireless_dev *txp_wdev = wdev;
1854 enum nl80211_tx_power_setting type;
1857 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
1860 if (!rdev->ops->set_tx_power) {
1861 result = -EOPNOTSUPP;
1865 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
1866 type = nla_get_u32(info->attrs[idx]);
1868 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
1869 (type != NL80211_TX_POWER_AUTOMATIC)) {
1874 if (type != NL80211_TX_POWER_AUTOMATIC) {
1875 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
1876 mbm = nla_get_u32(info->attrs[idx]);
1879 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
1884 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
1885 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
1887 if ((!rdev->wiphy.available_antennas_tx &&
1888 !rdev->wiphy.available_antennas_rx) ||
1889 !rdev->ops->set_antenna) {
1890 result = -EOPNOTSUPP;
1894 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
1895 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
1897 /* reject antenna configurations which don't match the
1898 * available antenna masks, except for the "all" mask */
1899 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
1900 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx))) {
1905 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
1906 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
1908 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
1915 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
1916 retry_short = nla_get_u8(
1917 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
1918 if (retry_short == 0) {
1922 changed |= WIPHY_PARAM_RETRY_SHORT;
1925 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
1926 retry_long = nla_get_u8(
1927 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
1928 if (retry_long == 0) {
1932 changed |= WIPHY_PARAM_RETRY_LONG;
1935 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
1936 frag_threshold = nla_get_u32(
1937 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
1938 if (frag_threshold < 256) {
1942 if (frag_threshold != (u32) -1) {
1944 * Fragments (apart from the last one) are required to
1945 * have even length. Make the fragmentation code
1946 * simpler by stripping LSB should someone try to use
1947 * odd threshold value.
1949 frag_threshold &= ~0x1;
1951 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
1954 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
1955 rts_threshold = nla_get_u32(
1956 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
1957 changed |= WIPHY_PARAM_RTS_THRESHOLD;
1960 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
1961 coverage_class = nla_get_u8(
1962 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
1963 changed |= WIPHY_PARAM_COVERAGE_CLASS;
1967 u8 old_retry_short, old_retry_long;
1968 u32 old_frag_threshold, old_rts_threshold;
1969 u8 old_coverage_class;
1971 if (!rdev->ops->set_wiphy_params) {
1972 result = -EOPNOTSUPP;
1976 old_retry_short = rdev->wiphy.retry_short;
1977 old_retry_long = rdev->wiphy.retry_long;
1978 old_frag_threshold = rdev->wiphy.frag_threshold;
1979 old_rts_threshold = rdev->wiphy.rts_threshold;
1980 old_coverage_class = rdev->wiphy.coverage_class;
1982 if (changed & WIPHY_PARAM_RETRY_SHORT)
1983 rdev->wiphy.retry_short = retry_short;
1984 if (changed & WIPHY_PARAM_RETRY_LONG)
1985 rdev->wiphy.retry_long = retry_long;
1986 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
1987 rdev->wiphy.frag_threshold = frag_threshold;
1988 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
1989 rdev->wiphy.rts_threshold = rts_threshold;
1990 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
1991 rdev->wiphy.coverage_class = coverage_class;
1993 result = rdev_set_wiphy_params(rdev, changed);
1995 rdev->wiphy.retry_short = old_retry_short;
1996 rdev->wiphy.retry_long = old_retry_long;
1997 rdev->wiphy.frag_threshold = old_frag_threshold;
1998 rdev->wiphy.rts_threshold = old_rts_threshold;
1999 rdev->wiphy.coverage_class = old_coverage_class;
2004 mutex_unlock(&rdev->mtx);
2010 static inline u64 wdev_id(struct wireless_dev *wdev)
2012 return (u64)wdev->identifier |
2013 ((u64)wiphy_to_dev(wdev->wiphy)->wiphy_idx << 32);
2016 static int nl80211_send_chandef(struct sk_buff *msg,
2017 struct cfg80211_chan_def *chandef)
2019 WARN_ON(!cfg80211_chandef_valid(chandef));
2021 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2022 chandef->chan->center_freq))
2024 switch (chandef->width) {
2025 case NL80211_CHAN_WIDTH_20_NOHT:
2026 case NL80211_CHAN_WIDTH_20:
2027 case NL80211_CHAN_WIDTH_40:
2028 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2029 cfg80211_get_chandef_type(chandef)))
2035 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2037 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2039 if (chandef->center_freq2 &&
2040 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
2045 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
2046 struct cfg80211_registered_device *rdev,
2047 struct wireless_dev *wdev)
2049 struct net_device *dev = wdev->netdev;
2052 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_INTERFACE);
2057 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2058 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
2059 goto nla_put_failure;
2061 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2062 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2063 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
2064 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
2065 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2066 rdev->devlist_generation ^
2067 (cfg80211_rdev_list_generation << 2)))
2068 goto nla_put_failure;
2070 if (rdev->ops->get_channel) {
2072 struct cfg80211_chan_def chandef;
2074 ret = rdev_get_channel(rdev, wdev, &chandef);
2076 if (nl80211_send_chandef(msg, &chandef))
2077 goto nla_put_failure;
2081 if (wdev->ssid_len) {
2082 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2083 goto nla_put_failure;
2086 return genlmsg_end(msg, hdr);
2089 genlmsg_cancel(msg, hdr);
2093 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2097 int wp_start = cb->args[0];
2098 int if_start = cb->args[1];
2099 struct cfg80211_registered_device *rdev;
2100 struct wireless_dev *wdev;
2102 mutex_lock(&cfg80211_mutex);
2103 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2104 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2106 if (wp_idx < wp_start) {
2112 mutex_lock(&rdev->devlist_mtx);
2113 list_for_each_entry(wdev, &rdev->wdev_list, list) {
2114 if (if_idx < if_start) {
2118 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
2119 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2121 mutex_unlock(&rdev->devlist_mtx);
2126 mutex_unlock(&rdev->devlist_mtx);
2131 mutex_unlock(&cfg80211_mutex);
2133 cb->args[0] = wp_idx;
2134 cb->args[1] = if_idx;
2139 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2141 struct sk_buff *msg;
2142 struct cfg80211_registered_device *dev = info->user_ptr[0];
2143 struct wireless_dev *wdev = info->user_ptr[1];
2145 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2149 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
2155 return genlmsg_reply(msg, info);
2158 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2159 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2160 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2161 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2162 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2163 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
2166 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2168 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2176 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
2177 nla, mntr_flags_policy))
2180 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2182 *mntrflags |= (1<<flag);
2187 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
2188 struct net_device *netdev, u8 use_4addr,
2189 enum nl80211_iftype iftype)
2192 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
2198 case NL80211_IFTYPE_AP_VLAN:
2199 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2202 case NL80211_IFTYPE_STATION:
2203 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2213 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2215 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2216 struct vif_params params;
2218 enum nl80211_iftype otype, ntype;
2219 struct net_device *dev = info->user_ptr[1];
2220 u32 _flags, *flags = NULL;
2221 bool change = false;
2223 memset(¶ms, 0, sizeof(params));
2225 otype = ntype = dev->ieee80211_ptr->iftype;
2227 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2228 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2231 if (ntype > NL80211_IFTYPE_MAX)
2235 if (info->attrs[NL80211_ATTR_MESH_ID]) {
2236 struct wireless_dev *wdev = dev->ieee80211_ptr;
2238 if (ntype != NL80211_IFTYPE_MESH_POINT)
2240 if (netif_running(dev))
2244 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2245 IEEE80211_MAX_MESH_ID_LEN);
2246 wdev->mesh_id_up_len =
2247 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2248 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2249 wdev->mesh_id_up_len);
2253 if (info->attrs[NL80211_ATTR_4ADDR]) {
2254 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2256 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
2260 params.use_4addr = -1;
2263 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2264 if (ntype != NL80211_IFTYPE_MONITOR)
2266 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2276 err = cfg80211_change_iface(rdev, dev, ntype, flags, ¶ms);
2280 if (!err && params.use_4addr != -1)
2281 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2286 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2288 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2289 struct vif_params params;
2290 struct wireless_dev *wdev;
2291 struct sk_buff *msg;
2293 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2296 memset(¶ms, 0, sizeof(params));
2298 if (!info->attrs[NL80211_ATTR_IFNAME])
2301 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2302 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2303 if (type > NL80211_IFTYPE_MAX)
2307 if (!rdev->ops->add_virtual_intf ||
2308 !(rdev->wiphy.interface_modes & (1 << type)))
2311 if (type == NL80211_IFTYPE_P2P_DEVICE && info->attrs[NL80211_ATTR_MAC]) {
2312 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2314 if (!is_valid_ether_addr(params.macaddr))
2315 return -EADDRNOTAVAIL;
2318 if (info->attrs[NL80211_ATTR_4ADDR]) {
2319 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2320 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
2325 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2329 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
2330 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
2332 wdev = rdev_add_virtual_intf(rdev,
2333 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
2334 type, err ? NULL : &flags, ¶ms);
2337 return PTR_ERR(wdev);
2341 case NL80211_IFTYPE_MESH_POINT:
2342 if (!info->attrs[NL80211_ATTR_MESH_ID])
2345 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2346 IEEE80211_MAX_MESH_ID_LEN);
2347 wdev->mesh_id_up_len =
2348 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2349 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2350 wdev->mesh_id_up_len);
2353 case NL80211_IFTYPE_P2P_DEVICE:
2355 * P2P Device doesn't have a netdev, so doesn't go
2356 * through the netdev notifier and must be added here
2358 mutex_init(&wdev->mtx);
2359 INIT_LIST_HEAD(&wdev->event_list);
2360 spin_lock_init(&wdev->event_lock);
2361 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2362 spin_lock_init(&wdev->mgmt_registrations_lock);
2364 mutex_lock(&rdev->devlist_mtx);
2365 wdev->identifier = ++rdev->wdev_id;
2366 list_add_rcu(&wdev->list, &rdev->wdev_list);
2367 rdev->devlist_generation++;
2368 mutex_unlock(&rdev->devlist_mtx);
2374 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
2380 return genlmsg_reply(msg, info);
2383 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
2385 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2386 struct wireless_dev *wdev = info->user_ptr[1];
2388 if (!rdev->ops->del_virtual_intf)
2392 * If we remove a wireless device without a netdev then clear
2393 * user_ptr[1] so that nl80211_post_doit won't dereference it
2394 * to check if it needs to do dev_put(). Otherwise it crashes
2395 * since the wdev has been freed, unlike with a netdev where
2396 * we need the dev_put() for the netdev to really be freed.
2399 info->user_ptr[1] = NULL;
2401 return rdev_del_virtual_intf(rdev, wdev);
2404 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
2406 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2407 struct net_device *dev = info->user_ptr[1];
2410 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
2413 if (!rdev->ops->set_noack_map)
2416 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
2418 return rdev_set_noack_map(rdev, dev, noack_map);
2421 struct get_key_cookie {
2422 struct sk_buff *msg;
2427 static void get_key_callback(void *c, struct key_params *params)
2430 struct get_key_cookie *cookie = c;
2433 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
2434 params->key_len, params->key)) ||
2436 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
2437 params->seq_len, params->seq)) ||
2439 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
2441 goto nla_put_failure;
2443 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
2445 goto nla_put_failure;
2448 nla_put(cookie->msg, NL80211_KEY_DATA,
2449 params->key_len, params->key)) ||
2451 nla_put(cookie->msg, NL80211_KEY_SEQ,
2452 params->seq_len, params->seq)) ||
2454 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
2456 goto nla_put_failure;
2458 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
2459 goto nla_put_failure;
2461 nla_nest_end(cookie->msg, key);
2468 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
2470 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2472 struct net_device *dev = info->user_ptr[1];
2474 const u8 *mac_addr = NULL;
2476 struct get_key_cookie cookie = {
2480 struct sk_buff *msg;
2482 if (info->attrs[NL80211_ATTR_KEY_IDX])
2483 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
2488 if (info->attrs[NL80211_ATTR_MAC])
2489 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2491 pairwise = !!mac_addr;
2492 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
2493 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
2494 if (kt >= NUM_NL80211_KEYTYPES)
2496 if (kt != NL80211_KEYTYPE_GROUP &&
2497 kt != NL80211_KEYTYPE_PAIRWISE)
2499 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
2502 if (!rdev->ops->get_key)
2505 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2509 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
2510 NL80211_CMD_NEW_KEY);
2512 return PTR_ERR(hdr);
2515 cookie.idx = key_idx;
2517 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2518 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
2519 goto nla_put_failure;
2521 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
2522 goto nla_put_failure;
2524 if (pairwise && mac_addr &&
2525 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2528 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
2535 goto nla_put_failure;
2537 genlmsg_end(msg, hdr);
2538 return genlmsg_reply(msg, info);
2547 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
2549 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2550 struct key_parse key;
2552 struct net_device *dev = info->user_ptr[1];
2554 err = nl80211_parse_key(info, &key);
2561 /* only support setting default key */
2562 if (!key.def && !key.defmgmt)
2565 wdev_lock(dev->ieee80211_ptr);
2568 if (!rdev->ops->set_default_key) {
2573 err = nl80211_key_allowed(dev->ieee80211_ptr);
2577 err = rdev_set_default_key(rdev, dev, key.idx,
2578 key.def_uni, key.def_multi);
2583 #ifdef CONFIG_CFG80211_WEXT
2584 dev->ieee80211_ptr->wext.default_key = key.idx;
2587 if (key.def_uni || !key.def_multi) {
2592 if (!rdev->ops->set_default_mgmt_key) {
2597 err = nl80211_key_allowed(dev->ieee80211_ptr);
2601 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
2605 #ifdef CONFIG_CFG80211_WEXT
2606 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
2611 wdev_unlock(dev->ieee80211_ptr);
2616 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
2618 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2620 struct net_device *dev = info->user_ptr[1];
2621 struct key_parse key;
2622 const u8 *mac_addr = NULL;
2624 err = nl80211_parse_key(info, &key);
2631 if (info->attrs[NL80211_ATTR_MAC])
2632 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2634 if (key.type == -1) {
2636 key.type = NL80211_KEYTYPE_PAIRWISE;
2638 key.type = NL80211_KEYTYPE_GROUP;
2642 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2643 key.type != NL80211_KEYTYPE_GROUP)
2646 if (!rdev->ops->add_key)
2649 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
2650 key.type == NL80211_KEYTYPE_PAIRWISE,
2654 wdev_lock(dev->ieee80211_ptr);
2655 err = nl80211_key_allowed(dev->ieee80211_ptr);
2657 err = rdev_add_key(rdev, dev, key.idx,
2658 key.type == NL80211_KEYTYPE_PAIRWISE,
2660 wdev_unlock(dev->ieee80211_ptr);
2665 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
2667 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2669 struct net_device *dev = info->user_ptr[1];
2670 u8 *mac_addr = NULL;
2671 struct key_parse key;
2673 err = nl80211_parse_key(info, &key);
2677 if (info->attrs[NL80211_ATTR_MAC])
2678 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2680 if (key.type == -1) {
2682 key.type = NL80211_KEYTYPE_PAIRWISE;
2684 key.type = NL80211_KEYTYPE_GROUP;
2688 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2689 key.type != NL80211_KEYTYPE_GROUP)
2692 if (!rdev->ops->del_key)
2695 wdev_lock(dev->ieee80211_ptr);
2696 err = nl80211_key_allowed(dev->ieee80211_ptr);
2698 if (key.type == NL80211_KEYTYPE_PAIRWISE && mac_addr &&
2699 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2703 err = rdev_del_key(rdev, dev, key.idx,
2704 key.type == NL80211_KEYTYPE_PAIRWISE,
2707 #ifdef CONFIG_CFG80211_WEXT
2709 if (key.idx == dev->ieee80211_ptr->wext.default_key)
2710 dev->ieee80211_ptr->wext.default_key = -1;
2711 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
2712 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
2715 wdev_unlock(dev->ieee80211_ptr);
2720 /* This function returns an error or the number of nested attributes */
2721 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
2723 struct nlattr *attr;
2724 int n_entries = 0, tmp;
2726 nla_for_each_nested(attr, nl_attr, tmp) {
2727 if (nla_len(attr) != ETH_ALEN)
2737 * This function parses ACL information and allocates memory for ACL data.
2738 * On successful return, the calling function is responsible to free the
2739 * ACL buffer returned by this function.
2741 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
2742 struct genl_info *info)
2744 enum nl80211_acl_policy acl_policy;
2745 struct nlattr *attr;
2746 struct cfg80211_acl_data *acl;
2747 int i = 0, n_entries, tmp;
2749 if (!wiphy->max_acl_mac_addrs)
2750 return ERR_PTR(-EOPNOTSUPP);
2752 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
2753 return ERR_PTR(-EINVAL);
2755 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
2756 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
2757 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
2758 return ERR_PTR(-EINVAL);
2760 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
2761 return ERR_PTR(-EINVAL);
2763 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
2765 return ERR_PTR(n_entries);
2767 if (n_entries > wiphy->max_acl_mac_addrs)
2768 return ERR_PTR(-ENOTSUPP);
2770 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
2773 return ERR_PTR(-ENOMEM);
2775 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
2776 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
2780 acl->n_acl_entries = n_entries;
2781 acl->acl_policy = acl_policy;
2786 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
2788 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2789 struct net_device *dev = info->user_ptr[1];
2790 struct cfg80211_acl_data *acl;
2793 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2794 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2797 if (!dev->ieee80211_ptr->beacon_interval)
2800 acl = parse_acl_data(&rdev->wiphy, info);
2802 return PTR_ERR(acl);
2804 err = rdev_set_mac_acl(rdev, dev, acl);
2811 static int nl80211_parse_beacon(struct genl_info *info,
2812 struct cfg80211_beacon_data *bcn)
2814 bool haveinfo = false;
2816 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]) ||
2817 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]) ||
2818 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
2819 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]))
2822 memset(bcn, 0, sizeof(*bcn));
2824 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
2825 bcn->head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2826 bcn->head_len = nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
2832 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
2833 bcn->tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2835 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
2842 if (info->attrs[NL80211_ATTR_IE]) {
2843 bcn->beacon_ies = nla_data(info->attrs[NL80211_ATTR_IE]);
2844 bcn->beacon_ies_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2847 if (info->attrs[NL80211_ATTR_IE_PROBE_RESP]) {
2848 bcn->proberesp_ies =
2849 nla_data(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2850 bcn->proberesp_ies_len =
2851 nla_len(info->attrs[NL80211_ATTR_IE_PROBE_RESP]);
2854 if (info->attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
2855 bcn->assocresp_ies =
2856 nla_data(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2857 bcn->assocresp_ies_len =
2858 nla_len(info->attrs[NL80211_ATTR_IE_ASSOC_RESP]);
2861 if (info->attrs[NL80211_ATTR_PROBE_RESP]) {
2863 nla_data(info->attrs[NL80211_ATTR_PROBE_RESP]);
2864 bcn->probe_resp_len =
2865 nla_len(info->attrs[NL80211_ATTR_PROBE_RESP]);
2871 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
2872 struct cfg80211_ap_settings *params)
2874 struct wireless_dev *wdev;
2877 mutex_lock(&rdev->devlist_mtx);
2879 list_for_each_entry(wdev, &rdev->wdev_list, list) {
2880 if (wdev->iftype != NL80211_IFTYPE_AP &&
2881 wdev->iftype != NL80211_IFTYPE_P2P_GO)
2884 if (!wdev->preset_chandef.chan)
2887 params->chandef = wdev->preset_chandef;
2892 mutex_unlock(&rdev->devlist_mtx);
2897 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
2898 enum nl80211_auth_type auth_type,
2899 enum nl80211_commands cmd)
2901 if (auth_type > NL80211_AUTHTYPE_MAX)
2905 case NL80211_CMD_AUTHENTICATE:
2906 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
2907 auth_type == NL80211_AUTHTYPE_SAE)
2910 case NL80211_CMD_CONNECT:
2911 case NL80211_CMD_START_AP:
2912 /* SAE not supported yet */
2913 if (auth_type == NL80211_AUTHTYPE_SAE)
2921 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
2923 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2924 struct net_device *dev = info->user_ptr[1];
2925 struct wireless_dev *wdev = dev->ieee80211_ptr;
2926 struct cfg80211_ap_settings params;
2928 u8 radar_detect_width = 0;
2930 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2931 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2934 if (!rdev->ops->start_ap)
2937 if (wdev->beacon_interval)
2940 memset(¶ms, 0, sizeof(params));
2942 /* these are required for START_AP */
2943 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
2944 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
2945 !info->attrs[NL80211_ATTR_BEACON_HEAD])
2948 err = nl80211_parse_beacon(info, ¶ms.beacon);
2952 params.beacon_interval =
2953 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
2954 params.dtim_period =
2955 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
2957 err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
2962 * In theory, some of these attributes should be required here
2963 * but since they were not used when the command was originally
2964 * added, keep them optional for old user space programs to let
2965 * them continue to work with drivers that do not need the
2966 * additional information -- drivers must check!
2968 if (info->attrs[NL80211_ATTR_SSID]) {
2969 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
2971 nla_len(info->attrs[NL80211_ATTR_SSID]);
2972 if (params.ssid_len == 0 ||
2973 params.ssid_len > IEEE80211_MAX_SSID_LEN)
2977 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
2978 params.hidden_ssid = nla_get_u32(
2979 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
2980 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
2981 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
2982 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
2986 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
2988 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
2989 params.auth_type = nla_get_u32(
2990 info->attrs[NL80211_ATTR_AUTH_TYPE]);
2991 if (!nl80211_valid_auth_type(rdev, params.auth_type,
2992 NL80211_CMD_START_AP))
2995 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
2997 err = nl80211_crypto_settings(rdev, info, ¶ms.crypto,
2998 NL80211_MAX_NR_CIPHER_SUITES);
3002 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3003 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3005 params.inactivity_timeout = nla_get_u16(
3006 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3009 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3010 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3012 params.p2p_ctwindow =
3013 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3014 if (params.p2p_ctwindow > 127)
3016 if (params.p2p_ctwindow != 0 &&
3017 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3021 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3024 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3026 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3029 params.p2p_opp_ps = tmp;
3030 if (params.p2p_opp_ps != 0 &&
3031 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
3035 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3036 err = nl80211_parse_chandef(rdev, info, ¶ms.chandef);
3039 } else if (wdev->preset_chandef.chan) {
3040 params.chandef = wdev->preset_chandef;
3041 } else if (!nl80211_get_ap_channel(rdev, ¶ms))
3044 if (!cfg80211_reg_can_beacon(&rdev->wiphy, ¶ms.chandef))
3047 err = cfg80211_chandef_dfs_required(wdev->wiphy, ¶ms.chandef);
3051 radar_detect_width = BIT(params.chandef.width);
3052 params.radar_required = true;
3055 mutex_lock(&rdev->devlist_mtx);
3056 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
3057 params.chandef.chan,
3059 radar_detect_width);
3060 mutex_unlock(&rdev->devlist_mtx);
3065 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
3066 params.acl = parse_acl_data(&rdev->wiphy, info);
3067 if (IS_ERR(params.acl))
3068 return PTR_ERR(params.acl);
3071 err = rdev_start_ap(rdev, dev, ¶ms);
3073 wdev->preset_chandef = params.chandef;
3074 wdev->beacon_interval = params.beacon_interval;
3075 wdev->channel = params.chandef.chan;
3076 wdev->ssid_len = params.ssid_len;
3077 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
3085 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
3087 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3088 struct net_device *dev = info->user_ptr[1];
3089 struct wireless_dev *wdev = dev->ieee80211_ptr;
3090 struct cfg80211_beacon_data params;
3093 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3094 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3097 if (!rdev->ops->change_beacon)
3100 if (!wdev->beacon_interval)
3103 err = nl80211_parse_beacon(info, ¶ms);
3107 return rdev_change_beacon(rdev, dev, ¶ms);
3110 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
3112 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3113 struct net_device *dev = info->user_ptr[1];
3115 return cfg80211_stop_ap(rdev, dev);
3118 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
3119 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
3120 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
3121 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
3122 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
3123 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
3124 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
3127 static int parse_station_flags(struct genl_info *info,
3128 enum nl80211_iftype iftype,
3129 struct station_parameters *params)
3131 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
3136 * Try parsing the new attribute first so userspace
3137 * can specify both for older kernels.
3139 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
3141 struct nl80211_sta_flag_update *sta_flags;
3143 sta_flags = nla_data(nla);
3144 params->sta_flags_mask = sta_flags->mask;
3145 params->sta_flags_set = sta_flags->set;
3146 params->sta_flags_set &= params->sta_flags_mask;
3147 if ((params->sta_flags_mask |
3148 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
3153 /* if present, parse the old attribute */
3155 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
3159 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
3160 nla, sta_flags_policy))
3164 * Only allow certain flags for interface types so that
3165 * other attributes are silently ignored. Remember that
3166 * this is backward compatibility code with old userspace
3167 * and shouldn't be hit in other cases anyway.
3170 case NL80211_IFTYPE_AP:
3171 case NL80211_IFTYPE_AP_VLAN:
3172 case NL80211_IFTYPE_P2P_GO:
3173 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3174 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3175 BIT(NL80211_STA_FLAG_WME) |
3176 BIT(NL80211_STA_FLAG_MFP);
3178 case NL80211_IFTYPE_P2P_CLIENT:
3179 case NL80211_IFTYPE_STATION:
3180 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3181 BIT(NL80211_STA_FLAG_TDLS_PEER);
3183 case NL80211_IFTYPE_MESH_POINT:
3184 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3185 BIT(NL80211_STA_FLAG_MFP) |
3186 BIT(NL80211_STA_FLAG_AUTHORIZED);
3191 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
3193 params->sta_flags_set |= (1<<flag);
3195 /* no longer support new API additions in old API */
3196 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
3204 static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
3207 struct nlattr *rate;
3211 rate = nla_nest_start(msg, attr);
3215 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
3216 bitrate = cfg80211_calculate_bitrate(info);
3217 /* report 16-bit bitrate only if we can */
3218 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
3220 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
3222 if (bitrate_compat > 0 &&
3223 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
3226 if (info->flags & RATE_INFO_FLAGS_MCS) {
3227 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
3229 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3230 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3232 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3233 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3235 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
3236 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
3238 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
3240 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3241 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3243 if (info->flags & RATE_INFO_FLAGS_80_MHZ_WIDTH &&
3244 nla_put_flag(msg, NL80211_RATE_INFO_80_MHZ_WIDTH))
3246 if (info->flags & RATE_INFO_FLAGS_80P80_MHZ_WIDTH &&
3247 nla_put_flag(msg, NL80211_RATE_INFO_80P80_MHZ_WIDTH))
3249 if (info->flags & RATE_INFO_FLAGS_160_MHZ_WIDTH &&
3250 nla_put_flag(msg, NL80211_RATE_INFO_160_MHZ_WIDTH))
3252 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3253 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3257 nla_nest_end(msg, rate);
3261 static int nl80211_send_station(struct sk_buff *msg, u32 portid, u32 seq,
3263 struct cfg80211_registered_device *rdev,
3264 struct net_device *dev,
3265 const u8 *mac_addr, struct station_info *sinfo)
3268 struct nlattr *sinfoattr, *bss_param;
3270 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
3274 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3275 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
3276 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
3277 goto nla_put_failure;
3279 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
3281 goto nla_put_failure;
3282 if ((sinfo->filled & STATION_INFO_CONNECTED_TIME) &&
3283 nla_put_u32(msg, NL80211_STA_INFO_CONNECTED_TIME,
3284 sinfo->connected_time))
3285 goto nla_put_failure;
3286 if ((sinfo->filled & STATION_INFO_INACTIVE_TIME) &&
3287 nla_put_u32(msg, NL80211_STA_INFO_INACTIVE_TIME,
3288 sinfo->inactive_time))
3289 goto nla_put_failure;
3290 if ((sinfo->filled & (STATION_INFO_RX_BYTES |
3291 STATION_INFO_RX_BYTES64)) &&
3292 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
3293 (u32)sinfo->rx_bytes))
3294 goto nla_put_failure;
3295 if ((sinfo->filled & (STATION_INFO_TX_BYTES |
3296 NL80211_STA_INFO_TX_BYTES64)) &&
3297 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
3298 (u32)sinfo->tx_bytes))
3299 goto nla_put_failure;
3300 if ((sinfo->filled & STATION_INFO_RX_BYTES64) &&
3301 nla_put_u64(msg, NL80211_STA_INFO_RX_BYTES64,
3303 goto nla_put_failure;
3304 if ((sinfo->filled & STATION_INFO_TX_BYTES64) &&
3305 nla_put_u64(msg, NL80211_STA_INFO_TX_BYTES64,
3307 goto nla_put_failure;
3308 if ((sinfo->filled & STATION_INFO_LLID) &&
3309 nla_put_u16(msg, NL80211_STA_INFO_LLID, sinfo->llid))
3310 goto nla_put_failure;
3311 if ((sinfo->filled & STATION_INFO_PLID) &&
3312 nla_put_u16(msg, NL80211_STA_INFO_PLID, sinfo->plid))
3313 goto nla_put_failure;
3314 if ((sinfo->filled & STATION_INFO_PLINK_STATE) &&
3315 nla_put_u8(msg, NL80211_STA_INFO_PLINK_STATE,
3316 sinfo->plink_state))
3317 goto nla_put_failure;
3318 switch (rdev->wiphy.signal_type) {
3319 case CFG80211_SIGNAL_TYPE_MBM:
3320 if ((sinfo->filled & STATION_INFO_SIGNAL) &&
3321 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL,
3323 goto nla_put_failure;
3324 if ((sinfo->filled & STATION_INFO_SIGNAL_AVG) &&
3325 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL_AVG,
3327 goto nla_put_failure;
3332 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
3333 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
3334 NL80211_STA_INFO_TX_BITRATE))
3335 goto nla_put_failure;
3337 if (sinfo->filled & STATION_INFO_RX_BITRATE) {
3338 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
3339 NL80211_STA_INFO_RX_BITRATE))
3340 goto nla_put_failure;
3342 if ((sinfo->filled & STATION_INFO_RX_PACKETS) &&
3343 nla_put_u32(msg, NL80211_STA_INFO_RX_PACKETS,
3345 goto nla_put_failure;
3346 if ((sinfo->filled & STATION_INFO_TX_PACKETS) &&
3347 nla_put_u32(msg, NL80211_STA_INFO_TX_PACKETS,
3349 goto nla_put_failure;
3350 if ((sinfo->filled & STATION_INFO_TX_RETRIES) &&
3351 nla_put_u32(msg, NL80211_STA_INFO_TX_RETRIES,
3353 goto nla_put_failure;
3354 if ((sinfo->filled & STATION_INFO_TX_FAILED) &&
3355 nla_put_u32(msg, NL80211_STA_INFO_TX_FAILED,
3357 goto nla_put_failure;
3358 if ((sinfo->filled & STATION_INFO_BEACON_LOSS_COUNT) &&
3359 nla_put_u32(msg, NL80211_STA_INFO_BEACON_LOSS,
3360 sinfo->beacon_loss_count))
3361 goto nla_put_failure;
3362 if ((sinfo->filled & STATION_INFO_LOCAL_PM) &&
3363 nla_put_u32(msg, NL80211_STA_INFO_LOCAL_PM,
3365 goto nla_put_failure;
3366 if ((sinfo->filled & STATION_INFO_PEER_PM) &&
3367 nla_put_u32(msg, NL80211_STA_INFO_PEER_PM,
3369 goto nla_put_failure;
3370 if ((sinfo->filled & STATION_INFO_NONPEER_PM) &&
3371 nla_put_u32(msg, NL80211_STA_INFO_NONPEER_PM,
3373 goto nla_put_failure;
3374 if (sinfo->filled & STATION_INFO_BSS_PARAM) {
3375 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
3377 goto nla_put_failure;
3379 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
3380 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
3381 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
3382 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
3383 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
3384 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
3385 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
3386 sinfo->bss_param.dtim_period) ||
3387 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
3388 sinfo->bss_param.beacon_interval))
3389 goto nla_put_failure;
3391 nla_nest_end(msg, bss_param);
3393 if ((sinfo->filled & STATION_INFO_STA_FLAGS) &&
3394 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
3395 sizeof(struct nl80211_sta_flag_update),
3397 goto nla_put_failure;
3398 if ((sinfo->filled & STATION_INFO_T_OFFSET) &&
3399 nla_put_u64(msg, NL80211_STA_INFO_T_OFFSET,
3401 goto nla_put_failure;
3402 nla_nest_end(msg, sinfoattr);
3404 if ((sinfo->filled & STATION_INFO_ASSOC_REQ_IES) &&
3405 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
3406 sinfo->assoc_req_ies))
3407 goto nla_put_failure;
3409 return genlmsg_end(msg, hdr);
3412 genlmsg_cancel(msg, hdr);
3416 static int nl80211_dump_station(struct sk_buff *skb,
3417 struct netlink_callback *cb)
3419 struct station_info sinfo;
3420 struct cfg80211_registered_device *dev;
3421 struct net_device *netdev;
3422 u8 mac_addr[ETH_ALEN];
3423 int sta_idx = cb->args[1];
3426 err = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
3430 if (!dev->ops->dump_station) {
3436 memset(&sinfo, 0, sizeof(sinfo));
3437 err = rdev_dump_station(dev, netdev, sta_idx,
3444 if (nl80211_send_station(skb,
3445 NETLINK_CB(cb->skb).portid,
3446 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3447 dev, netdev, mac_addr,
3456 cb->args[1] = sta_idx;
3459 nl80211_finish_netdev_dump(dev);
3464 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
3466 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3467 struct net_device *dev = info->user_ptr[1];
3468 struct station_info sinfo;
3469 struct sk_buff *msg;
3470 u8 *mac_addr = NULL;
3473 memset(&sinfo, 0, sizeof(sinfo));
3475 if (!info->attrs[NL80211_ATTR_MAC])
3478 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3480 if (!rdev->ops->get_station)
3483 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
3487 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3491 if (nl80211_send_station(msg, info->snd_portid, info->snd_seq, 0,
3492 rdev, dev, mac_addr, &sinfo) < 0) {
3497 return genlmsg_reply(msg, info);
3500 int cfg80211_check_station_change(struct wiphy *wiphy,
3501 struct station_parameters *params,
3502 enum cfg80211_station_type statype)
3504 if (params->listen_interval != -1)
3509 /* When you run into this, adjust the code below for the new flag */
3510 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
3513 case CFG80211_STA_MESH_PEER_NONSEC:
3514 case CFG80211_STA_MESH_PEER_SECURE:
3516 * No ignoring the TDLS flag here -- the userspace mesh
3517 * code doesn't have the bug of including TDLS in the
3520 if (params->sta_flags_mask &
3521 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3522 BIT(NL80211_STA_FLAG_MFP) |
3523 BIT(NL80211_STA_FLAG_AUTHORIZED)))
3526 case CFG80211_STA_TDLS_PEER_SETUP:
3527 case CFG80211_STA_TDLS_PEER_ACTIVE:
3528 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3530 /* ignore since it can't change */
3531 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3534 /* disallow mesh-specific things */
3535 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3537 if (params->local_pm)
3539 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3543 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
3544 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
3545 /* TDLS can't be set, ... */
3546 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3549 * ... but don't bother the driver with it. This works around
3550 * a hostapd/wpa_supplicant issue -- it always includes the
3551 * TLDS_PEER flag in the mask even for AP mode.
3553 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3556 if (statype != CFG80211_STA_TDLS_PEER_SETUP) {
3557 /* reject other things that can't change */
3558 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
3560 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
3562 if (params->supported_rates)
3564 if (params->ext_capab || params->ht_capa || params->vht_capa)
3568 if (statype != CFG80211_STA_AP_CLIENT) {
3574 case CFG80211_STA_AP_MLME_CLIENT:
3575 /* Use this only for authorizing/unauthorizing a station */
3576 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
3579 case CFG80211_STA_AP_CLIENT:
3580 /* accept only the listed bits */
3581 if (params->sta_flags_mask &
3582 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3583 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3584 BIT(NL80211_STA_FLAG_ASSOCIATED) |
3585 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3586 BIT(NL80211_STA_FLAG_WME) |
3587 BIT(NL80211_STA_FLAG_MFP)))
3590 /* but authenticated/associated only if driver handles it */
3591 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
3592 params->sta_flags_mask &
3593 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3594 BIT(NL80211_STA_FLAG_ASSOCIATED)))
3597 case CFG80211_STA_IBSS:
3598 case CFG80211_STA_AP_STA:
3599 /* reject any changes other than AUTHORIZED */
3600 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
3603 case CFG80211_STA_TDLS_PEER_SETUP:
3604 /* reject any changes other than AUTHORIZED or WME */
3605 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3606 BIT(NL80211_STA_FLAG_WME)))
3608 /* force (at least) rates when authorizing */
3609 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
3610 !params->supported_rates)
3613 case CFG80211_STA_TDLS_PEER_ACTIVE:
3614 /* reject any changes */
3616 case CFG80211_STA_MESH_PEER_NONSEC:
3617 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3620 case CFG80211_STA_MESH_PEER_SECURE:
3621 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3628 EXPORT_SYMBOL(cfg80211_check_station_change);
3631 * Get vlan interface making sure it is running and on the right wiphy.
3633 static struct net_device *get_vlan(struct genl_info *info,
3634 struct cfg80211_registered_device *rdev)
3636 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
3637 struct net_device *v;
3643 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
3645 return ERR_PTR(-ENODEV);
3647 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
3652 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
3653 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3654 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
3659 if (!netif_running(v)) {
3667 return ERR_PTR(ret);
3670 static struct nla_policy
3671 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] __read_mostly = {
3672 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
3673 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
3676 static int nl80211_parse_sta_wme(struct genl_info *info,
3677 struct station_parameters *params)
3679 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
3683 /* parse WME attributes if present */
3684 if (!info->attrs[NL80211_ATTR_STA_WME])
3687 nla = info->attrs[NL80211_ATTR_STA_WME];
3688 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
3689 nl80211_sta_wme_policy);
3693 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
3694 params->uapsd_queues = nla_get_u8(
3695 tb[NL80211_STA_WME_UAPSD_QUEUES]);
3696 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
3699 if (tb[NL80211_STA_WME_MAX_SP])
3700 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
3702 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
3705 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
3710 static int nl80211_set_station_tdls(struct genl_info *info,
3711 struct station_parameters *params)
3713 /* Dummy STA entry gets updated once the peer capabilities are known */
3714 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
3716 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
3717 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
3719 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
3721 return nl80211_parse_sta_wme(info, params);
3724 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
3726 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3727 struct net_device *dev = info->user_ptr[1];
3728 struct station_parameters params;
3732 memset(¶ms, 0, sizeof(params));
3734 params.listen_interval = -1;
3736 if (!rdev->ops->change_station)
3739 if (info->attrs[NL80211_ATTR_STA_AID])
3742 if (!info->attrs[NL80211_ATTR_MAC])
3745 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3747 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
3748 params.supported_rates =
3749 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3750 params.supported_rates_len =
3751 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3754 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
3756 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
3757 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
3760 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
3762 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
3763 params.ext_capab_len =
3764 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
3767 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
3770 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
3773 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
3774 params.plink_action =
3775 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
3776 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
3780 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
3781 params.plink_state =
3782 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
3783 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
3785 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
3788 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
3789 enum nl80211_mesh_power_mode pm = nla_get_u32(
3790 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
3792 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
3793 pm > NL80211_MESH_POWER_MAX)
3796 params.local_pm = pm;
3799 /* Include parameters for TDLS peer (will check later) */
3800 err = nl80211_set_station_tdls(info, ¶ms);
3804 params.vlan = get_vlan(info, rdev);
3805 if (IS_ERR(params.vlan))
3806 return PTR_ERR(params.vlan);
3808 switch (dev->ieee80211_ptr->iftype) {
3809 case NL80211_IFTYPE_AP:
3810 case NL80211_IFTYPE_AP_VLAN:
3811 case NL80211_IFTYPE_P2P_GO:
3812 case NL80211_IFTYPE_P2P_CLIENT:
3813 case NL80211_IFTYPE_STATION:
3814 case NL80211_IFTYPE_ADHOC:
3815 case NL80211_IFTYPE_MESH_POINT:
3822 /* driver will call cfg80211_check_station_change() */
3823 err = rdev_change_station(rdev, dev, mac_addr, ¶ms);
3827 dev_put(params.vlan);
3832 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
3834 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3836 struct net_device *dev = info->user_ptr[1];
3837 struct station_parameters params;
3838 u8 *mac_addr = NULL;
3840 memset(¶ms, 0, sizeof(params));
3842 if (!rdev->ops->add_station)
3845 if (!info->attrs[NL80211_ATTR_MAC])
3848 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
3851 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
3854 if (!info->attrs[NL80211_ATTR_STA_AID])
3857 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3858 params.supported_rates =
3859 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3860 params.supported_rates_len =
3861 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
3862 params.listen_interval =
3863 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
3865 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
3866 if (!params.aid || params.aid > IEEE80211_MAX_AID)
3869 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
3871 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
3872 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
3875 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
3877 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
3878 params.ext_capab_len =
3879 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
3882 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
3884 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
3886 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
3888 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
3890 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
3891 params.plink_action =
3892 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
3893 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
3897 err = nl80211_parse_sta_wme(info, ¶ms);
3901 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, ¶ms))
3904 /* When you run into this, adjust the code below for the new flag */
3905 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
3907 switch (dev->ieee80211_ptr->iftype) {
3908 case NL80211_IFTYPE_AP:
3909 case NL80211_IFTYPE_AP_VLAN:
3910 case NL80211_IFTYPE_P2P_GO:
3911 /* ignore WME attributes if iface/sta is not capable */
3912 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
3913 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
3914 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
3916 /* TDLS peers cannot be added */
3917 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3919 /* but don't bother the driver with it */
3920 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3922 /* allow authenticated/associated only if driver handles it */
3923 if (!(rdev->wiphy.features &
3924 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
3925 params.sta_flags_mask &
3926 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3927 BIT(NL80211_STA_FLAG_ASSOCIATED)))
3930 /* must be last in here for error handling */
3931 params.vlan = get_vlan(info, rdev);
3932 if (IS_ERR(params.vlan))
3933 return PTR_ERR(params.vlan);
3935 case NL80211_IFTYPE_MESH_POINT:
3936 /* ignore uAPSD data */
3937 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
3939 /* associated is disallowed */
3940 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
3942 /* TDLS peers cannot be added */
3943 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3946 case NL80211_IFTYPE_STATION:
3947 /* ignore uAPSD data */
3948 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
3950 /* these are disallowed */
3951 if (params.sta_flags_mask &
3952 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
3953 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
3955 /* Only TDLS peers can be added */
3956 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3958 /* Can only add if TDLS ... */
3959 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
3961 /* ... with external setup is supported */
3962 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
3965 * Older wpa_supplicant versions always mark the TDLS peer
3966 * as authorized, but it shouldn't yet be.
3968 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
3974 /* be aware of params.vlan when changing code here */
3976 err = rdev_add_station(rdev, dev, mac_addr, ¶ms);
3979 dev_put(params.vlan);
3983 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
3985 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3986 struct net_device *dev = info->user_ptr[1];
3987 u8 *mac_addr = NULL;
3989 if (info->attrs[NL80211_ATTR_MAC])
3990 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3992 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3993 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
3994 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
3995 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3998 if (!rdev->ops->del_station)
4001 return rdev_del_station(rdev, dev, mac_addr);
4004 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
4005 int flags, struct net_device *dev,
4006 u8 *dst, u8 *next_hop,
4007 struct mpath_info *pinfo)
4010 struct nlattr *pinfoattr;
4012 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
4016 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4017 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
4018 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
4019 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
4020 goto nla_put_failure;
4022 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
4024 goto nla_put_failure;
4025 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
4026 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
4028 goto nla_put_failure;
4029 if (((pinfo->filled & MPATH_INFO_SN) &&
4030 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
4031 ((pinfo->filled & MPATH_INFO_METRIC) &&
4032 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
4034 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
4035 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
4037 ((pinfo->filled & MPATH_INFO_FLAGS) &&
4038 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
4040 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
4041 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
4042 pinfo->discovery_timeout)) ||
4043 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
4044 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
4045 pinfo->discovery_retries)))
4046 goto nla_put_failure;
4048 nla_nest_end(msg, pinfoattr);
4050 return genlmsg_end(msg, hdr);
4053 genlmsg_cancel(msg, hdr);
4057 static int nl80211_dump_mpath(struct sk_buff *skb,
4058 struct netlink_callback *cb)
4060 struct mpath_info pinfo;
4061 struct cfg80211_registered_device *dev;
4062 struct net_device *netdev;
4064 u8 next_hop[ETH_ALEN];
4065 int path_idx = cb->args[1];
4068 err = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
4072 if (!dev->ops->dump_mpath) {
4077 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
4083 err = rdev_dump_mpath(dev, netdev, path_idx, dst, next_hop,
4090 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
4091 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4092 netdev, dst, next_hop,
4101 cb->args[1] = path_idx;
4104 nl80211_finish_netdev_dump(dev);
4108 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
4110 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4112 struct net_device *dev = info->user_ptr[1];
4113 struct mpath_info pinfo;
4114 struct sk_buff *msg;
4116 u8 next_hop[ETH_ALEN];
4118 memset(&pinfo, 0, sizeof(pinfo));
4120 if (!info->attrs[NL80211_ATTR_MAC])
4123 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4125 if (!rdev->ops->get_mpath)
4128 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4131 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
4135 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4139 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4140 dev, dst, next_hop, &pinfo) < 0) {
4145 return genlmsg_reply(msg, info);
4148 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
4150 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4151 struct net_device *dev = info->user_ptr[1];
4153 u8 *next_hop = NULL;
4155 if (!info->attrs[NL80211_ATTR_MAC])
4158 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4161 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4162 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4164 if (!rdev->ops->change_mpath)
4167 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4170 return rdev_change_mpath(rdev, dev, dst, next_hop);
4173 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
4175 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4176 struct net_device *dev = info->user_ptr[1];
4178 u8 *next_hop = NULL;
4180 if (!info->attrs[NL80211_ATTR_MAC])
4183 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4186 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4187 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4189 if (!rdev->ops->add_mpath)
4192 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4195 return rdev_add_mpath(rdev, dev, dst, next_hop);
4198 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
4200 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4201 struct net_device *dev = info->user_ptr[1];
4204 if (info->attrs[NL80211_ATTR_MAC])
4205 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4207 if (!rdev->ops->del_mpath)
4210 return rdev_del_mpath(rdev, dev, dst);
4213 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
4215 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4216 struct net_device *dev = info->user_ptr[1];
4217 struct bss_parameters params;
4219 memset(¶ms, 0, sizeof(params));
4220 /* default to not changing parameters */
4221 params.use_cts_prot = -1;
4222 params.use_short_preamble = -1;
4223 params.use_short_slot_time = -1;
4224 params.ap_isolate = -1;
4225 params.ht_opmode = -1;
4226 params.p2p_ctwindow = -1;
4227 params.p2p_opp_ps = -1;
4229 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
4230 params.use_cts_prot =
4231 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
4232 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
4233 params.use_short_preamble =
4234 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
4235 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
4236 params.use_short_slot_time =
4237 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
4238 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
4239 params.basic_rates =
4240 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4241 params.basic_rates_len =
4242 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4244 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
4245 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
4246 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
4248 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
4250 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4251 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4253 params.p2p_ctwindow =
4254 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4255 if (params.p2p_ctwindow < 0)
4257 if (params.p2p_ctwindow != 0 &&
4258 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4262 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4265 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4267 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4270 params.p2p_opp_ps = tmp;
4271 if (params.p2p_opp_ps &&
4272 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4276 if (!rdev->ops->change_bss)
4279 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4280 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4283 return rdev_change_bss(rdev, dev, ¶ms);
4286 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
4287 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
4288 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
4289 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
4290 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
4291 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
4292 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
4295 static int parse_reg_rule(struct nlattr *tb[],
4296 struct ieee80211_reg_rule *reg_rule)
4298 struct ieee80211_freq_range *freq_range = ®_rule->freq_range;
4299 struct ieee80211_power_rule *power_rule = ®_rule->power_rule;
4301 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
4303 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
4305 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
4307 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
4309 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
4312 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
4314 freq_range->start_freq_khz =
4315 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
4316 freq_range->end_freq_khz =
4317 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
4318 freq_range->max_bandwidth_khz =
4319 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
4321 power_rule->max_eirp =
4322 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
4324 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
4325 power_rule->max_antenna_gain =
4326 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
4331 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
4335 enum nl80211_user_reg_hint_type user_reg_hint_type;
4338 * You should only get this when cfg80211 hasn't yet initialized
4339 * completely when built-in to the kernel right between the time
4340 * window between nl80211_init() and regulatory_init(), if that is
4343 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
4344 return -EINPROGRESS;
4346 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4349 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4351 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
4352 user_reg_hint_type =
4353 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
4355 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
4357 switch (user_reg_hint_type) {
4358 case NL80211_USER_REG_HINT_USER:
4359 case NL80211_USER_REG_HINT_CELL_BASE:
4365 r = regulatory_hint_user(data, user_reg_hint_type);
4370 static int nl80211_get_mesh_config(struct sk_buff *skb,
4371 struct genl_info *info)
4373 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4374 struct net_device *dev = info->user_ptr[1];
4375 struct wireless_dev *wdev = dev->ieee80211_ptr;
4376 struct mesh_config cur_params;
4379 struct nlattr *pinfoattr;
4380 struct sk_buff *msg;
4382 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4385 if (!rdev->ops->get_mesh_config)
4389 /* If not connected, get default parameters */
4390 if (!wdev->mesh_id_len)
4391 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
4393 err = rdev_get_mesh_config(rdev, dev, &cur_params);
4399 /* Draw up a netlink message to send back */
4400 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4403 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4404 NL80211_CMD_GET_MESH_CONFIG);
4407 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
4409 goto nla_put_failure;
4410 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4411 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
4412 cur_params.dot11MeshRetryTimeout) ||
4413 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4414 cur_params.dot11MeshConfirmTimeout) ||
4415 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
4416 cur_params.dot11MeshHoldingTimeout) ||
4417 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
4418 cur_params.dot11MeshMaxPeerLinks) ||
4419 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
4420 cur_params.dot11MeshMaxRetries) ||
4421 nla_put_u8(msg, NL80211_MESHCONF_TTL,
4422 cur_params.dot11MeshTTL) ||
4423 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
4424 cur_params.element_ttl) ||
4425 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4426 cur_params.auto_open_plinks) ||
4427 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4428 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
4429 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4430 cur_params.dot11MeshHWMPmaxPREQretries) ||
4431 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
4432 cur_params.path_refresh_time) ||
4433 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4434 cur_params.min_discovery_timeout) ||
4435 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4436 cur_params.dot11MeshHWMPactivePathTimeout) ||
4437 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4438 cur_params.dot11MeshHWMPpreqMinInterval) ||
4439 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4440 cur_params.dot11MeshHWMPperrMinInterval) ||
4441 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4442 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
4443 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
4444 cur_params.dot11MeshHWMPRootMode) ||
4445 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4446 cur_params.dot11MeshHWMPRannInterval) ||
4447 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4448 cur_params.dot11MeshGateAnnouncementProtocol) ||
4449 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
4450 cur_params.dot11MeshForwarding) ||
4451 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
4452 cur_params.rssi_threshold) ||
4453 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
4454 cur_params.ht_opmode) ||
4455 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4456 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
4457 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4458 cur_params.dot11MeshHWMProotInterval) ||
4459 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
4460 cur_params.dot11MeshHWMPconfirmationInterval) ||
4461 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
4462 cur_params.power_mode) ||
4463 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
4464 cur_params.dot11MeshAwakeWindowDuration))
4465 goto nla_put_failure;
4466 nla_nest_end(msg, pinfoattr);
4467 genlmsg_end(msg, hdr);
4468 return genlmsg_reply(msg, info);
4471 genlmsg_cancel(msg, hdr);
4477 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
4478 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
4479 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
4480 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
4481 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
4482 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
4483 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
4484 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
4485 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
4486 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
4487 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
4488 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
4489 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
4490 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
4491 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
4492 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
4493 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
4494 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
4495 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
4496 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
4497 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
4498 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
4499 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
4500 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
4501 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
4502 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
4503 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
4504 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
4507 static const struct nla_policy
4508 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
4509 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
4510 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
4511 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
4512 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
4513 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
4514 .len = IEEE80211_MAX_DATA_LEN },
4515 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
4518 static int nl80211_parse_mesh_config(struct genl_info *info,
4519 struct mesh_config *cfg,
4522 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
4525 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
4528 if (fn(tb[attr]) < min || fn(tb[attr]) > max) \
4530 cfg->param = fn(tb[attr]); \
4531 mask |= (1 << (attr - 1)); \
4536 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
4538 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
4539 info->attrs[NL80211_ATTR_MESH_CONFIG],
4540 nl80211_meshconf_params_policy))
4543 /* This makes sure that there aren't more than 32 mesh config
4544 * parameters (otherwise our bitfield scheme would not work.) */
4545 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
4547 /* Fill in the params struct */
4548 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
4549 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
4551 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
4552 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4554 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
4555 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
4557 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
4558 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
4560 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
4561 mask, NL80211_MESHCONF_MAX_RETRIES,
4563 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
4564 mask, NL80211_MESHCONF_TTL, nla_get_u8);
4565 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
4566 mask, NL80211_MESHCONF_ELEMENT_TTL,
4568 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
4569 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4571 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
4573 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4575 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
4576 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4578 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
4579 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
4581 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
4582 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4584 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
4586 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4588 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
4590 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4592 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
4594 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4596 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4597 dot11MeshHWMPnetDiameterTraversalTime,
4599 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4601 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
4602 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
4604 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
4605 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4607 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4608 dot11MeshGateAnnouncementProtocol, 0, 1,
4609 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4611 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
4612 mask, NL80211_MESHCONF_FORWARDING,
4614 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, 1, 255,
4615 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
4617 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode, 0, 16,
4618 mask, NL80211_MESHCONF_HT_OPMODE,
4620 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
4622 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4624 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
4625 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4627 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4628 dot11MeshHWMPconfirmationInterval,
4630 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
4632 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
4633 NL80211_MESH_POWER_ACTIVE,
4634 NL80211_MESH_POWER_MAX,
4635 mask, NL80211_MESHCONF_POWER_MODE,
4637 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
4639 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
4645 #undef FILL_IN_MESH_PARAM_IF_SET
4648 static int nl80211_parse_mesh_setup(struct genl_info *info,
4649 struct mesh_setup *setup)
4651 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
4653 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
4655 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
4656 info->attrs[NL80211_ATTR_MESH_SETUP],
4657 nl80211_mesh_setup_params_policy))
4660 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
4661 setup->sync_method =
4662 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
4663 IEEE80211_SYNC_METHOD_VENDOR :
4664 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
4666 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
4667 setup->path_sel_proto =
4668 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
4669 IEEE80211_PATH_PROTOCOL_VENDOR :
4670 IEEE80211_PATH_PROTOCOL_HWMP;
4672 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
4673 setup->path_metric =
4674 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
4675 IEEE80211_PATH_METRIC_VENDOR :
4676 IEEE80211_PATH_METRIC_AIRTIME;
4679 if (tb[NL80211_MESH_SETUP_IE]) {
4680 struct nlattr *ieattr =
4681 tb[NL80211_MESH_SETUP_IE];
4682 if (!is_valid_ie_attr(ieattr))
4684 setup->ie = nla_data(ieattr);
4685 setup->ie_len = nla_len(ieattr);
4687 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
4688 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
4693 static int nl80211_update_mesh_config(struct sk_buff *skb,
4694 struct genl_info *info)
4696 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4697 struct net_device *dev = info->user_ptr[1];
4698 struct wireless_dev *wdev = dev->ieee80211_ptr;
4699 struct mesh_config cfg;
4703 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4706 if (!rdev->ops->update_mesh_config)
4709 err = nl80211_parse_mesh_config(info, &cfg, &mask);
4714 if (!wdev->mesh_id_len)
4718 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
4725 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
4727 const struct ieee80211_regdomain *regdom;
4728 struct sk_buff *msg;
4730 struct nlattr *nl_reg_rules;
4734 mutex_lock(&cfg80211_mutex);
4736 if (!cfg80211_regdomain)
4739 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4745 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4746 NL80211_CMD_GET_REG);
4750 if (reg_last_request_cell_base() &&
4751 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
4752 NL80211_USER_REG_HINT_CELL_BASE))
4753 goto nla_put_failure;
4756 regdom = rcu_dereference(cfg80211_regdomain);
4758 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
4759 (regdom->dfs_region &&
4760 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
4761 goto nla_put_failure_rcu;
4763 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
4765 goto nla_put_failure_rcu;
4767 for (i = 0; i < regdom->n_reg_rules; i++) {
4768 struct nlattr *nl_reg_rule;
4769 const struct ieee80211_reg_rule *reg_rule;
4770 const struct ieee80211_freq_range *freq_range;
4771 const struct ieee80211_power_rule *power_rule;
4773 reg_rule = ®dom->reg_rules[i];
4774 freq_range = ®_rule->freq_range;
4775 power_rule = ®_rule->power_rule;
4777 nl_reg_rule = nla_nest_start(msg, i);
4779 goto nla_put_failure_rcu;
4781 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
4783 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
4784 freq_range->start_freq_khz) ||
4785 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
4786 freq_range->end_freq_khz) ||
4787 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
4788 freq_range->max_bandwidth_khz) ||
4789 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
4790 power_rule->max_antenna_gain) ||
4791 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
4792 power_rule->max_eirp))
4793 goto nla_put_failure_rcu;
4795 nla_nest_end(msg, nl_reg_rule);
4799 nla_nest_end(msg, nl_reg_rules);
4801 genlmsg_end(msg, hdr);
4802 err = genlmsg_reply(msg, info);
4805 nla_put_failure_rcu:
4808 genlmsg_cancel(msg, hdr);
4813 mutex_unlock(&cfg80211_mutex);
4817 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
4819 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
4820 struct nlattr *nl_reg_rule;
4821 char *alpha2 = NULL;
4822 int rem_reg_rules = 0, r = 0;
4823 u32 num_rules = 0, rule_idx = 0, size_of_regd;
4825 struct ieee80211_regdomain *rd = NULL;
4827 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4830 if (!info->attrs[NL80211_ATTR_REG_RULES])
4833 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4835 if (info->attrs[NL80211_ATTR_DFS_REGION])
4836 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
4838 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
4841 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4845 size_of_regd = sizeof(struct ieee80211_regdomain) +
4846 num_rules * sizeof(struct ieee80211_reg_rule);
4848 rd = kzalloc(size_of_regd, GFP_KERNEL);
4852 rd->n_reg_rules = num_rules;
4853 rd->alpha2[0] = alpha2[0];
4854 rd->alpha2[1] = alpha2[1];
4857 * Disable DFS master mode if the DFS region was
4858 * not supported or known on this kernel.
4860 if (reg_supported_dfs_region(dfs_region))
4861 rd->dfs_region = dfs_region;
4863 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
4865 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
4866 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
4868 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
4874 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
4880 mutex_lock(&cfg80211_mutex);
4883 /* set_regdom took ownership */
4885 mutex_unlock(&cfg80211_mutex);
4892 static int validate_scan_freqs(struct nlattr *freqs)
4894 struct nlattr *attr1, *attr2;
4895 int n_channels = 0, tmp1, tmp2;
4897 nla_for_each_nested(attr1, freqs, tmp1) {
4900 * Some hardware has a limited channel list for
4901 * scanning, and it is pretty much nonsensical
4902 * to scan for a channel twice, so disallow that
4903 * and don't require drivers to check that the
4904 * channel list they get isn't longer than what
4905 * they can scan, as long as they can scan all
4906 * the channels they registered at once.
4908 nla_for_each_nested(attr2, freqs, tmp2)
4909 if (attr1 != attr2 &&
4910 nla_get_u32(attr1) == nla_get_u32(attr2))
4917 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
4919 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4920 struct wireless_dev *wdev = info->user_ptr[1];
4921 struct cfg80211_scan_request *request;
4922 struct nlattr *attr;
4923 struct wiphy *wiphy;
4924 int err, tmp, n_ssids = 0, n_channels, i;
4927 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
4930 wiphy = &rdev->wiphy;
4932 if (!rdev->ops->scan)
4938 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4939 n_channels = validate_scan_freqs(
4940 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
4944 enum ieee80211_band band;
4947 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
4948 if (wiphy->bands[band])
4949 n_channels += wiphy->bands[band]->n_channels;
4952 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
4953 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
4956 if (n_ssids > wiphy->max_scan_ssids)
4959 if (info->attrs[NL80211_ATTR_IE])
4960 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
4964 if (ie_len > wiphy->max_scan_ie_len)
4967 request = kzalloc(sizeof(*request)
4968 + sizeof(*request->ssids) * n_ssids
4969 + sizeof(*request->channels) * n_channels
4970 + ie_len, GFP_KERNEL);
4975 request->ssids = (void *)&request->channels[n_channels];
4976 request->n_ssids = n_ssids;
4979 request->ie = (void *)(request->ssids + n_ssids);
4981 request->ie = (void *)(request->channels + n_channels);
4985 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
4986 /* user specified, bail out if channel not found */
4987 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
4988 struct ieee80211_channel *chan;
4990 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
4997 /* ignore disabled channels */
4998 if (chan->flags & IEEE80211_CHAN_DISABLED)
5001 request->channels[i] = chan;
5005 enum ieee80211_band band;
5008 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5010 if (!wiphy->bands[band])
5012 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5013 struct ieee80211_channel *chan;
5015 chan = &wiphy->bands[band]->channels[j];
5017 if (chan->flags & IEEE80211_CHAN_DISABLED)
5020 request->channels[i] = chan;
5031 request->n_channels = i;
5034 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5035 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
5036 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5040 request->ssids[i].ssid_len = nla_len(attr);
5041 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
5046 if (info->attrs[NL80211_ATTR_IE]) {
5047 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5048 memcpy((void *)request->ie,
5049 nla_data(info->attrs[NL80211_ATTR_IE]),
5053 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
5054 if (wiphy->bands[i])
5056 (1 << wiphy->bands[i]->n_bitrates) - 1;
5058 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
5059 nla_for_each_nested(attr,
5060 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
5062 enum ieee80211_band band = nla_type(attr);
5064 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
5068 err = ieee80211_get_ratemask(wiphy->bands[band],
5071 &request->rates[band]);
5077 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5078 request->flags = nla_get_u32(
5079 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5080 if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5081 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
5082 ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
5083 !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
5090 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5092 request->wdev = wdev;
5093 request->wiphy = &rdev->wiphy;
5094 request->scan_start = jiffies;
5096 rdev->scan_req = request;
5097 err = rdev_scan(rdev, request);
5100 nl80211_send_scan_start(rdev, wdev);
5102 dev_hold(wdev->netdev);
5105 rdev->scan_req = NULL;
5112 static int nl80211_start_sched_scan(struct sk_buff *skb,
5113 struct genl_info *info)
5115 struct cfg80211_sched_scan_request *request;
5116 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5117 struct net_device *dev = info->user_ptr[1];
5118 struct nlattr *attr;
5119 struct wiphy *wiphy;
5120 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
5122 enum ieee80211_band band;
5124 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
5126 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5127 !rdev->ops->sched_scan_start)
5130 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5133 if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
5136 interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
5140 wiphy = &rdev->wiphy;
5142 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5143 n_channels = validate_scan_freqs(
5144 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5150 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
5151 if (wiphy->bands[band])
5152 n_channels += wiphy->bands[band]->n_channels;
5155 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5156 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5160 if (n_ssids > wiphy->max_sched_scan_ssids)
5163 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH])
5164 nla_for_each_nested(attr,
5165 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5169 if (n_match_sets > wiphy->max_match_sets)
5172 if (info->attrs[NL80211_ATTR_IE])
5173 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5177 if (ie_len > wiphy->max_sched_scan_ie_len)
5180 mutex_lock(&rdev->sched_scan_mtx);
5182 if (rdev->sched_scan_req) {
5187 request = kzalloc(sizeof(*request)
5188 + sizeof(*request->ssids) * n_ssids
5189 + sizeof(*request->match_sets) * n_match_sets
5190 + sizeof(*request->channels) * n_channels
5191 + ie_len, GFP_KERNEL);
5198 request->ssids = (void *)&request->channels[n_channels];
5199 request->n_ssids = n_ssids;
5202 request->ie = (void *)(request->ssids + n_ssids);
5204 request->ie = (void *)(request->channels + n_channels);
5209 request->match_sets = (void *)(request->ie + ie_len);
5210 else if (request->ssids)
5211 request->match_sets =
5212 (void *)(request->ssids + n_ssids);
5214 request->match_sets =
5215 (void *)(request->channels + n_channels);
5217 request->n_match_sets = n_match_sets;
5220 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5221 /* user specified, bail out if channel not found */
5222 nla_for_each_nested(attr,
5223 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
5225 struct ieee80211_channel *chan;
5227 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5234 /* ignore disabled channels */
5235 if (chan->flags & IEEE80211_CHAN_DISABLED)
5238 request->channels[i] = chan;
5243 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5245 if (!wiphy->bands[band])
5247 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5248 struct ieee80211_channel *chan;
5250 chan = &wiphy->bands[band]->channels[j];
5252 if (chan->flags & IEEE80211_CHAN_DISABLED)
5255 request->channels[i] = chan;
5266 request->n_channels = i;
5269 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5270 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5272 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5276 request->ssids[i].ssid_len = nla_len(attr);
5277 memcpy(request->ssids[i].ssid, nla_data(attr),
5284 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
5285 nla_for_each_nested(attr,
5286 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5288 struct nlattr *ssid, *rssi;
5290 nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
5291 nla_data(attr), nla_len(attr),
5292 nl80211_match_policy);
5293 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
5295 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
5299 memcpy(request->match_sets[i].ssid.ssid,
5300 nla_data(ssid), nla_len(ssid));
5301 request->match_sets[i].ssid.ssid_len =
5304 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
5306 request->rssi_thold = nla_get_u32(rssi);
5308 request->rssi_thold =
5309 NL80211_SCAN_RSSI_THOLD_OFF;
5314 if (info->attrs[NL80211_ATTR_IE]) {
5315 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5316 memcpy((void *)request->ie,
5317 nla_data(info->attrs[NL80211_ATTR_IE]),
5321 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5322 request->flags = nla_get_u32(
5323 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5324 if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5325 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
5326 ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
5327 !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
5334 request->wiphy = &rdev->wiphy;
5335 request->interval = interval;
5336 request->scan_start = jiffies;
5338 err = rdev_sched_scan_start(rdev, dev, request);
5340 rdev->sched_scan_req = request;
5341 nl80211_send_sched_scan(rdev, dev,
5342 NL80211_CMD_START_SCHED_SCAN);
5349 mutex_unlock(&rdev->sched_scan_mtx);
5353 static int nl80211_stop_sched_scan(struct sk_buff *skb,
5354 struct genl_info *info)
5356 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5359 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5360 !rdev->ops->sched_scan_stop)
5363 mutex_lock(&rdev->sched_scan_mtx);
5364 err = __cfg80211_stop_sched_scan(rdev, false);
5365 mutex_unlock(&rdev->sched_scan_mtx);
5370 static int nl80211_start_radar_detection(struct sk_buff *skb,
5371 struct genl_info *info)
5373 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5374 struct net_device *dev = info->user_ptr[1];
5375 struct wireless_dev *wdev = dev->ieee80211_ptr;
5376 struct cfg80211_chan_def chandef;
5379 err = nl80211_parse_chandef(rdev, info, &chandef);
5383 if (wdev->cac_started)
5386 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef);
5393 if (chandef.chan->dfs_state != NL80211_DFS_USABLE)
5396 if (!rdev->ops->start_radar_detection)
5399 mutex_lock(&rdev->devlist_mtx);
5400 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
5401 chandef.chan, CHAN_MODE_SHARED,
5402 BIT(chandef.width));
5406 err = rdev->ops->start_radar_detection(&rdev->wiphy, dev, &chandef);
5408 wdev->channel = chandef.chan;
5409 wdev->cac_started = true;
5410 wdev->cac_start_time = jiffies;
5413 mutex_unlock(&rdev->devlist_mtx);
5418 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
5420 struct cfg80211_registered_device *rdev,
5421 struct wireless_dev *wdev,
5422 struct cfg80211_internal_bss *intbss)
5424 struct cfg80211_bss *res = &intbss->pub;
5425 const struct cfg80211_bss_ies *ies;
5430 ASSERT_WDEV_LOCK(wdev);
5432 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
5433 NL80211_CMD_NEW_SCAN_RESULTS);
5437 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
5439 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation) ||
5440 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
5441 goto nla_put_failure;
5443 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
5445 goto nla_put_failure;
5446 if ((!is_zero_ether_addr(res->bssid) &&
5447 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
5448 goto nla_put_failure;
5451 ies = rcu_dereference(res->ies);
5453 if (nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
5454 goto fail_unlock_rcu;
5456 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
5457 ies->len, ies->data))
5458 goto fail_unlock_rcu;
5460 ies = rcu_dereference(res->beacon_ies);
5462 if (!tsf && nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
5463 goto fail_unlock_rcu;
5464 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
5465 ies->len, ies->data))
5466 goto fail_unlock_rcu;
5470 if (res->beacon_interval &&
5471 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
5472 goto nla_put_failure;
5473 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
5474 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
5475 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
5476 jiffies_to_msecs(jiffies - intbss->ts)))
5477 goto nla_put_failure;
5479 switch (rdev->wiphy.signal_type) {
5480 case CFG80211_SIGNAL_TYPE_MBM:
5481 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
5482 goto nla_put_failure;
5484 case CFG80211_SIGNAL_TYPE_UNSPEC:
5485 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
5486 goto nla_put_failure;
5492 switch (wdev->iftype) {
5493 case NL80211_IFTYPE_P2P_CLIENT:
5494 case NL80211_IFTYPE_STATION:
5495 if (intbss == wdev->current_bss &&
5496 nla_put_u32(msg, NL80211_BSS_STATUS,
5497 NL80211_BSS_STATUS_ASSOCIATED))
5498 goto nla_put_failure;
5500 case NL80211_IFTYPE_ADHOC:
5501 if (intbss == wdev->current_bss &&
5502 nla_put_u32(msg, NL80211_BSS_STATUS,
5503 NL80211_BSS_STATUS_IBSS_JOINED))
5504 goto nla_put_failure;
5510 nla_nest_end(msg, bss);
5512 return genlmsg_end(msg, hdr);
5517 genlmsg_cancel(msg, hdr);
5521 static int nl80211_dump_scan(struct sk_buff *skb,
5522 struct netlink_callback *cb)
5524 struct cfg80211_registered_device *rdev;
5525 struct net_device *dev;
5526 struct cfg80211_internal_bss *scan;
5527 struct wireless_dev *wdev;
5528 int start = cb->args[1], idx = 0;
5531 err = nl80211_prepare_netdev_dump(skb, cb, &rdev, &dev);
5535 wdev = dev->ieee80211_ptr;
5538 spin_lock_bh(&rdev->bss_lock);
5539 cfg80211_bss_expire(rdev);
5541 cb->seq = rdev->bss_generation;
5543 list_for_each_entry(scan, &rdev->bss_list, list) {
5546 if (nl80211_send_bss(skb, cb,
5547 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5548 rdev, wdev, scan) < 0) {
5554 spin_unlock_bh(&rdev->bss_lock);
5558 nl80211_finish_netdev_dump(rdev);
5563 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
5564 int flags, struct net_device *dev,
5565 struct survey_info *survey)
5568 struct nlattr *infoattr;
5570 hdr = nl80211hdr_put(msg, portid, seq, flags,
5571 NL80211_CMD_NEW_SURVEY_RESULTS);
5575 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
5576 goto nla_put_failure;
5578 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
5580 goto nla_put_failure;
5582 if (nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
5583 survey->channel->center_freq))
5584 goto nla_put_failure;
5586 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
5587 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
5588 goto nla_put_failure;
5589 if ((survey->filled & SURVEY_INFO_IN_USE) &&
5590 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
5591 goto nla_put_failure;
5592 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME) &&
5593 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME,
5594 survey->channel_time))
5595 goto nla_put_failure;
5596 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_BUSY) &&
5597 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY,
5598 survey->channel_time_busy))
5599 goto nla_put_failure;
5600 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) &&
5601 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY,
5602 survey->channel_time_ext_busy))
5603 goto nla_put_failure;
5604 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_RX) &&
5605 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_RX,
5606 survey->channel_time_rx))
5607 goto nla_put_failure;
5608 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_TX) &&
5609 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_TX,
5610 survey->channel_time_tx))
5611 goto nla_put_failure;
5613 nla_nest_end(msg, infoattr);
5615 return genlmsg_end(msg, hdr);
5618 genlmsg_cancel(msg, hdr);
5622 static int nl80211_dump_survey(struct sk_buff *skb,
5623 struct netlink_callback *cb)
5625 struct survey_info survey;
5626 struct cfg80211_registered_device *dev;
5627 struct net_device *netdev;
5628 int survey_idx = cb->args[1];
5631 res = nl80211_prepare_netdev_dump(skb, cb, &dev, &netdev);
5635 if (!dev->ops->dump_survey) {
5641 struct ieee80211_channel *chan;
5643 res = rdev_dump_survey(dev, netdev, survey_idx, &survey);
5649 /* Survey without a channel doesn't make sense */
5650 if (!survey.channel) {
5655 chan = ieee80211_get_channel(&dev->wiphy,
5656 survey.channel->center_freq);
5657 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
5662 if (nl80211_send_survey(skb,
5663 NETLINK_CB(cb->skb).portid,
5664 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5672 cb->args[1] = survey_idx;
5675 nl80211_finish_netdev_dump(dev);
5679 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
5681 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
5682 NL80211_WPA_VERSION_2));
5685 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
5687 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5688 struct net_device *dev = info->user_ptr[1];
5689 struct ieee80211_channel *chan;
5690 const u8 *bssid, *ssid, *ie = NULL, *sae_data = NULL;
5691 int err, ssid_len, ie_len = 0, sae_data_len = 0;
5692 enum nl80211_auth_type auth_type;
5693 struct key_parse key;
5694 bool local_state_change;
5696 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5699 if (!info->attrs[NL80211_ATTR_MAC])
5702 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
5705 if (!info->attrs[NL80211_ATTR_SSID])
5708 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
5711 err = nl80211_parse_key(info, &key);
5716 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
5718 if (!key.p.key || !key.p.key_len)
5720 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
5721 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
5722 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
5723 key.p.key_len != WLAN_KEY_LEN_WEP104))
5735 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
5736 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
5745 if (!rdev->ops->auth)
5748 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5749 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5752 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5753 chan = ieee80211_get_channel(&rdev->wiphy,
5754 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
5755 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
5758 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5759 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5761 if (info->attrs[NL80211_ATTR_IE]) {
5762 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5763 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5766 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
5767 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
5770 if (auth_type == NL80211_AUTHTYPE_SAE &&
5771 !info->attrs[NL80211_ATTR_SAE_DATA])
5774 if (info->attrs[NL80211_ATTR_SAE_DATA]) {
5775 if (auth_type != NL80211_AUTHTYPE_SAE)
5777 sae_data = nla_data(info->attrs[NL80211_ATTR_SAE_DATA]);
5778 sae_data_len = nla_len(info->attrs[NL80211_ATTR_SAE_DATA]);
5779 /* need to include at least Auth Transaction and Status Code */
5780 if (sae_data_len < 4)
5784 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
5787 * Since we no longer track auth state, ignore
5788 * requests to only change local state.
5790 if (local_state_change)
5793 return cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
5794 ssid, ssid_len, ie, ie_len,
5795 key.p.key, key.p.key_len, key.idx,
5796 sae_data, sae_data_len);
5799 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
5800 struct genl_info *info,
5801 struct cfg80211_crypto_settings *settings,
5804 memset(settings, 0, sizeof(*settings));
5806 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
5808 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
5810 proto = nla_get_u16(
5811 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
5812 settings->control_port_ethertype = cpu_to_be16(proto);
5813 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
5816 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
5817 settings->control_port_no_encrypt = true;
5819 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
5821 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
5825 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
5826 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
5827 settings->n_ciphers_pairwise = len / sizeof(u32);
5829 if (len % sizeof(u32))
5832 if (settings->n_ciphers_pairwise > cipher_limit)
5835 memcpy(settings->ciphers_pairwise, data, len);
5837 for (i = 0; i < settings->n_ciphers_pairwise; i++)
5838 if (!cfg80211_supported_cipher_suite(
5840 settings->ciphers_pairwise[i]))
5844 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
5845 settings->cipher_group =
5846 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
5847 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
5848 settings->cipher_group))
5852 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
5853 settings->wpa_versions =
5854 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
5855 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
5859 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
5863 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
5864 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
5865 settings->n_akm_suites = len / sizeof(u32);
5867 if (len % sizeof(u32))
5870 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
5873 memcpy(settings->akm_suites, data, len);
5879 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
5881 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5882 struct net_device *dev = info->user_ptr[1];
5883 struct cfg80211_crypto_settings crypto;
5884 struct ieee80211_channel *chan;
5885 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
5886 int err, ssid_len, ie_len = 0;
5887 bool use_mfp = false;
5889 struct ieee80211_ht_cap *ht_capa = NULL;
5890 struct ieee80211_ht_cap *ht_capa_mask = NULL;
5892 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5895 if (!info->attrs[NL80211_ATTR_MAC] ||
5896 !info->attrs[NL80211_ATTR_SSID] ||
5897 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
5900 if (!rdev->ops->assoc)
5903 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5904 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5907 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5909 chan = ieee80211_get_channel(&rdev->wiphy,
5910 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
5911 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
5914 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5915 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5917 if (info->attrs[NL80211_ATTR_IE]) {
5918 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5919 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5922 if (info->attrs[NL80211_ATTR_USE_MFP]) {
5923 enum nl80211_mfp mfp =
5924 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
5925 if (mfp == NL80211_MFP_REQUIRED)
5927 else if (mfp != NL80211_MFP_NO)
5931 if (info->attrs[NL80211_ATTR_PREV_BSSID])
5932 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
5934 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
5935 flags |= ASSOC_REQ_DISABLE_HT;
5937 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
5939 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]);
5941 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
5944 ht_capa = nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5947 err = nl80211_crypto_settings(rdev, info, &crypto, 1);
5949 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
5950 ssid, ssid_len, ie, ie_len, use_mfp,
5951 &crypto, flags, ht_capa,
5957 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
5959 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5960 struct net_device *dev = info->user_ptr[1];
5961 const u8 *ie = NULL, *bssid;
5964 bool local_state_change;
5966 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5969 if (!info->attrs[NL80211_ATTR_MAC])
5972 if (!info->attrs[NL80211_ATTR_REASON_CODE])
5975 if (!rdev->ops->deauth)
5978 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5979 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5982 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5984 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
5985 if (reason_code == 0) {
5986 /* Reason Code 0 is reserved */
5990 if (info->attrs[NL80211_ATTR_IE]) {
5991 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5992 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5995 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
5997 return cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
5998 local_state_change);
6001 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
6003 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6004 struct net_device *dev = info->user_ptr[1];
6005 const u8 *ie = NULL, *bssid;
6008 bool local_state_change;
6010 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6013 if (!info->attrs[NL80211_ATTR_MAC])
6016 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6019 if (!rdev->ops->disassoc)
6022 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6023 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6026 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6028 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6029 if (reason_code == 0) {
6030 /* Reason Code 0 is reserved */
6034 if (info->attrs[NL80211_ATTR_IE]) {
6035 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6036 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6039 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6041 return cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
6042 local_state_change);
6046 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
6047 int mcast_rate[IEEE80211_NUM_BANDS],
6050 struct wiphy *wiphy = &rdev->wiphy;
6054 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
6055 struct ieee80211_supported_band *sband;
6057 sband = wiphy->bands[band];
6061 for (i = 0; i < sband->n_bitrates; i++) {
6062 if (sband->bitrates[i].bitrate == rateval) {
6063 mcast_rate[band] = i + 1;
6073 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
6075 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6076 struct net_device *dev = info->user_ptr[1];
6077 struct cfg80211_ibss_params ibss;
6078 struct wiphy *wiphy;
6079 struct cfg80211_cached_keys *connkeys = NULL;
6082 memset(&ibss, 0, sizeof(ibss));
6084 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6087 if (!info->attrs[NL80211_ATTR_SSID] ||
6088 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6091 ibss.beacon_interval = 100;
6093 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
6094 ibss.beacon_interval =
6095 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
6096 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
6100 if (!rdev->ops->join_ibss)
6103 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6106 wiphy = &rdev->wiphy;
6108 if (info->attrs[NL80211_ATTR_MAC]) {
6109 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6111 if (!is_valid_ether_addr(ibss.bssid))
6114 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6115 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6117 if (info->attrs[NL80211_ATTR_IE]) {
6118 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6119 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6122 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
6126 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef))
6129 if (ibss.chandef.width > NL80211_CHAN_WIDTH_40)
6131 if (ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
6132 !(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
6135 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
6136 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
6138 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6140 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6142 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6143 struct ieee80211_supported_band *sband =
6144 wiphy->bands[ibss.chandef.chan->band];
6146 err = ieee80211_get_ratemask(sband, rates, n_rates,
6152 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
6153 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
6154 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
6157 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
6160 connkeys = nl80211_parse_connkeys(rdev,
6161 info->attrs[NL80211_ATTR_KEYS],
6163 if (IS_ERR(connkeys))
6164 return PTR_ERR(connkeys);
6166 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
6174 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
6176 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
6182 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
6184 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6185 struct net_device *dev = info->user_ptr[1];
6187 if (!rdev->ops->leave_ibss)
6190 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6193 return cfg80211_leave_ibss(rdev, dev, false);
6196 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
6198 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6199 struct net_device *dev = info->user_ptr[1];
6200 int mcast_rate[IEEE80211_NUM_BANDS];
6204 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
6205 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6208 if (!rdev->ops->set_mcast_rate)
6211 memset(mcast_rate, 0, sizeof(mcast_rate));
6213 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
6216 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
6217 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
6220 err = rdev->ops->set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
6226 #ifdef CONFIG_NL80211_TESTMODE
6227 static struct genl_multicast_group nl80211_testmode_mcgrp = {
6231 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
6233 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6236 if (!info->attrs[NL80211_ATTR_TESTDATA])
6240 if (rdev->ops->testmode_cmd) {
6241 rdev->testmode_info = info;
6242 err = rdev_testmode_cmd(rdev,
6243 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
6244 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
6245 rdev->testmode_info = NULL;
6251 static int nl80211_testmode_dump(struct sk_buff *skb,
6252 struct netlink_callback *cb)
6254 struct cfg80211_registered_device *rdev;
6262 * 0 is a valid index, but not valid for args[0],
6263 * so we need to offset by 1.
6265 phy_idx = cb->args[0] - 1;
6267 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
6268 nl80211_fam.attrbuf, nl80211_fam.maxattr,
6273 mutex_lock(&cfg80211_mutex);
6274 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk),
6275 nl80211_fam.attrbuf);
6277 mutex_unlock(&cfg80211_mutex);
6278 return PTR_ERR(rdev);
6280 phy_idx = rdev->wiphy_idx;
6282 mutex_unlock(&cfg80211_mutex);
6284 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
6286 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
6290 data = nla_data((void *)cb->args[1]);
6291 data_len = nla_len((void *)cb->args[1]);
6294 mutex_lock(&cfg80211_mutex);
6295 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
6297 mutex_unlock(&cfg80211_mutex);
6300 cfg80211_lock_rdev(rdev);
6301 mutex_unlock(&cfg80211_mutex);
6303 if (!rdev->ops->testmode_dump) {
6309 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
6310 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6311 NL80211_CMD_TESTMODE);
6312 struct nlattr *tmdata;
6314 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
6315 genlmsg_cancel(skb, hdr);
6319 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
6321 genlmsg_cancel(skb, hdr);
6324 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
6325 nla_nest_end(skb, tmdata);
6327 if (err == -ENOBUFS || err == -ENOENT) {
6328 genlmsg_cancel(skb, hdr);
6331 genlmsg_cancel(skb, hdr);
6335 genlmsg_end(skb, hdr);
6340 cb->args[0] = phy_idx + 1;
6342 cfg80211_unlock_rdev(rdev);
6346 static struct sk_buff *
6347 __cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
6348 int approxlen, u32 portid, u32 seq, gfp_t gfp)
6350 struct sk_buff *skb;
6352 struct nlattr *data;
6354 skb = nlmsg_new(approxlen + 100, gfp);
6358 hdr = nl80211hdr_put(skb, portid, seq, 0, NL80211_CMD_TESTMODE);
6364 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
6365 goto nla_put_failure;
6366 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
6368 ((void **)skb->cb)[0] = rdev;
6369 ((void **)skb->cb)[1] = hdr;
6370 ((void **)skb->cb)[2] = data;
6379 struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
6382 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6384 if (WARN_ON(!rdev->testmode_info))
6387 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
6388 rdev->testmode_info->snd_portid,
6389 rdev->testmode_info->snd_seq,
6392 EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
6394 int cfg80211_testmode_reply(struct sk_buff *skb)
6396 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
6397 void *hdr = ((void **)skb->cb)[1];
6398 struct nlattr *data = ((void **)skb->cb)[2];
6400 if (WARN_ON(!rdev->testmode_info)) {
6405 nla_nest_end(skb, data);
6406 genlmsg_end(skb, hdr);
6407 return genlmsg_reply(skb, rdev->testmode_info);
6409 EXPORT_SYMBOL(cfg80211_testmode_reply);
6411 struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
6412 int approxlen, gfp_t gfp)
6414 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6416 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
6418 EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
6420 void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
6422 void *hdr = ((void **)skb->cb)[1];
6423 struct nlattr *data = ((void **)skb->cb)[2];
6425 nla_nest_end(skb, data);
6426 genlmsg_end(skb, hdr);
6427 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
6429 EXPORT_SYMBOL(cfg80211_testmode_event);
6432 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
6434 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6435 struct net_device *dev = info->user_ptr[1];
6436 struct cfg80211_connect_params connect;
6437 struct wiphy *wiphy;
6438 struct cfg80211_cached_keys *connkeys = NULL;
6441 memset(&connect, 0, sizeof(connect));
6443 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6446 if (!info->attrs[NL80211_ATTR_SSID] ||
6447 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6450 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
6452 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
6453 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
6454 NL80211_CMD_CONNECT))
6457 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
6459 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
6461 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
6462 NL80211_MAX_NR_CIPHER_SUITES);
6466 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6467 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6470 wiphy = &rdev->wiphy;
6472 connect.bg_scan_period = -1;
6473 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
6474 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
6475 connect.bg_scan_period =
6476 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
6479 if (info->attrs[NL80211_ATTR_MAC])
6480 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6481 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6482 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6484 if (info->attrs[NL80211_ATTR_IE]) {
6485 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6486 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6489 if (info->attrs[NL80211_ATTR_USE_MFP]) {
6490 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
6491 if (connect.mfp != NL80211_MFP_REQUIRED &&
6492 connect.mfp != NL80211_MFP_NO)
6495 connect.mfp = NL80211_MFP_NO;
6498 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6500 ieee80211_get_channel(wiphy,
6501 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
6502 if (!connect.channel ||
6503 connect.channel->flags & IEEE80211_CHAN_DISABLED)
6507 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
6508 connkeys = nl80211_parse_connkeys(rdev,
6509 info->attrs[NL80211_ATTR_KEYS], NULL);
6510 if (IS_ERR(connkeys))
6511 return PTR_ERR(connkeys);
6514 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
6515 connect.flags |= ASSOC_REQ_DISABLE_HT;
6517 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6518 memcpy(&connect.ht_capa_mask,
6519 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6520 sizeof(connect.ht_capa_mask));
6522 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6523 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
6527 memcpy(&connect.ht_capa,
6528 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6529 sizeof(connect.ht_capa));
6532 err = cfg80211_connect(rdev, dev, &connect, connkeys);
6538 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
6540 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6541 struct net_device *dev = info->user_ptr[1];
6544 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6545 reason = WLAN_REASON_DEAUTH_LEAVING;
6547 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6552 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6553 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6556 return cfg80211_disconnect(rdev, dev, reason, true);
6559 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
6561 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6566 if (!info->attrs[NL80211_ATTR_PID])
6569 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
6571 net = get_net_ns_by_pid(pid);
6573 return PTR_ERR(net);
6577 /* check if anything to do */
6578 if (!net_eq(wiphy_net(&rdev->wiphy), net))
6579 err = cfg80211_switch_netns(rdev, net);
6585 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
6587 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6588 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
6589 struct cfg80211_pmksa *pmksa) = NULL;
6590 struct net_device *dev = info->user_ptr[1];
6591 struct cfg80211_pmksa pmksa;
6593 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
6595 if (!info->attrs[NL80211_ATTR_MAC])
6598 if (!info->attrs[NL80211_ATTR_PMKID])
6601 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
6602 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6604 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6605 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6608 switch (info->genlhdr->cmd) {
6609 case NL80211_CMD_SET_PMKSA:
6610 rdev_ops = rdev->ops->set_pmksa;
6612 case NL80211_CMD_DEL_PMKSA:
6613 rdev_ops = rdev->ops->del_pmksa;
6623 return rdev_ops(&rdev->wiphy, dev, &pmksa);
6626 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
6628 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6629 struct net_device *dev = info->user_ptr[1];
6631 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6632 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6635 if (!rdev->ops->flush_pmksa)
6638 return rdev_flush_pmksa(rdev, dev);
6641 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
6643 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6644 struct net_device *dev = info->user_ptr[1];
6645 u8 action_code, dialog_token;
6649 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
6650 !rdev->ops->tdls_mgmt)
6653 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
6654 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
6655 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
6656 !info->attrs[NL80211_ATTR_IE] ||
6657 !info->attrs[NL80211_ATTR_MAC])
6660 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
6661 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
6662 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
6663 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
6665 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
6666 dialog_token, status_code,
6667 nla_data(info->attrs[NL80211_ATTR_IE]),
6668 nla_len(info->attrs[NL80211_ATTR_IE]));
6671 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
6673 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6674 struct net_device *dev = info->user_ptr[1];
6675 enum nl80211_tdls_operation operation;
6678 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
6679 !rdev->ops->tdls_oper)
6682 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
6683 !info->attrs[NL80211_ATTR_MAC])
6686 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
6687 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
6689 return rdev_tdls_oper(rdev, dev, peer, operation);
6692 static int nl80211_remain_on_channel(struct sk_buff *skb,
6693 struct genl_info *info)
6695 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6696 struct wireless_dev *wdev = info->user_ptr[1];
6697 struct cfg80211_chan_def chandef;
6698 struct sk_buff *msg;
6704 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
6705 !info->attrs[NL80211_ATTR_DURATION])
6708 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
6710 if (!rdev->ops->remain_on_channel ||
6711 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
6715 * We should be on that channel for at least a minimum amount of
6716 * time (10ms) but no longer than the driver supports.
6718 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
6719 duration > rdev->wiphy.max_remain_on_channel_duration)
6722 err = nl80211_parse_chandef(rdev, info, &chandef);
6726 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6730 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6731 NL80211_CMD_REMAIN_ON_CHANNEL);
6738 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
6744 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
6745 goto nla_put_failure;
6747 genlmsg_end(msg, hdr);
6749 return genlmsg_reply(msg, info);
6758 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
6759 struct genl_info *info)
6761 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6762 struct wireless_dev *wdev = info->user_ptr[1];
6765 if (!info->attrs[NL80211_ATTR_COOKIE])
6768 if (!rdev->ops->cancel_remain_on_channel)
6771 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
6773 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
6776 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
6777 u8 *rates, u8 rates_len)
6782 for (i = 0; i < rates_len; i++) {
6783 int rate = (rates[i] & 0x7f) * 5;
6785 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
6786 struct ieee80211_rate *srate =
6787 &sband->bitrates[ridx];
6788 if (rate == srate->bitrate) {
6793 if (ridx == sband->n_bitrates)
6794 return 0; /* rate not found */
6800 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
6801 u8 *rates, u8 rates_len,
6802 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
6806 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
6808 for (i = 0; i < rates_len; i++) {
6811 ridx = rates[i] / 8;
6812 rbit = BIT(rates[i] % 8);
6814 /* check validity */
6815 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
6818 /* check availability */
6819 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
6828 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
6829 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
6830 .len = NL80211_MAX_SUPP_RATES },
6831 [NL80211_TXRATE_MCS] = { .type = NLA_BINARY,
6832 .len = NL80211_MAX_SUPP_HT_RATES },
6835 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
6836 struct genl_info *info)
6838 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
6839 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6840 struct cfg80211_bitrate_mask mask;
6842 struct net_device *dev = info->user_ptr[1];
6843 struct nlattr *tx_rates;
6844 struct ieee80211_supported_band *sband;
6846 if (info->attrs[NL80211_ATTR_TX_RATES] == NULL)
6849 if (!rdev->ops->set_bitrate_mask)
6852 memset(&mask, 0, sizeof(mask));
6853 /* Default to all rates enabled */
6854 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
6855 sband = rdev->wiphy.bands[i];
6856 mask.control[i].legacy =
6857 sband ? (1 << sband->n_bitrates) - 1 : 0;
6859 memcpy(mask.control[i].mcs,
6860 sband->ht_cap.mcs.rx_mask,
6861 sizeof(mask.control[i].mcs));
6863 memset(mask.control[i].mcs, 0,
6864 sizeof(mask.control[i].mcs));
6868 * The nested attribute uses enum nl80211_band as the index. This maps
6869 * directly to the enum ieee80211_band values used in cfg80211.
6871 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
6872 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
6874 enum ieee80211_band band = nla_type(tx_rates);
6875 if (band < 0 || band >= IEEE80211_NUM_BANDS)
6877 sband = rdev->wiphy.bands[band];
6880 nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
6881 nla_len(tx_rates), nl80211_txattr_policy);
6882 if (tb[NL80211_TXRATE_LEGACY]) {
6883 mask.control[band].legacy = rateset_to_mask(
6885 nla_data(tb[NL80211_TXRATE_LEGACY]),
6886 nla_len(tb[NL80211_TXRATE_LEGACY]));
6887 if ((mask.control[band].legacy == 0) &&
6888 nla_len(tb[NL80211_TXRATE_LEGACY]))
6891 if (tb[NL80211_TXRATE_MCS]) {
6892 if (!ht_rateset_to_mask(
6894 nla_data(tb[NL80211_TXRATE_MCS]),
6895 nla_len(tb[NL80211_TXRATE_MCS]),
6896 mask.control[band].mcs))
6900 if (mask.control[band].legacy == 0) {
6901 /* don't allow empty legacy rates if HT
6902 * is not even supported. */
6903 if (!rdev->wiphy.bands[band]->ht_cap.ht_supported)
6906 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
6907 if (mask.control[band].mcs[i])
6910 /* legacy and mcs rates may not be both empty */
6911 if (i == IEEE80211_HT_MCS_MASK_LEN)
6916 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
6919 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
6921 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6922 struct wireless_dev *wdev = info->user_ptr[1];
6923 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
6925 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
6928 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
6929 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
6931 switch (wdev->iftype) {
6932 case NL80211_IFTYPE_STATION:
6933 case NL80211_IFTYPE_ADHOC:
6934 case NL80211_IFTYPE_P2P_CLIENT:
6935 case NL80211_IFTYPE_AP:
6936 case NL80211_IFTYPE_AP_VLAN:
6937 case NL80211_IFTYPE_MESH_POINT:
6938 case NL80211_IFTYPE_P2P_GO:
6939 case NL80211_IFTYPE_P2P_DEVICE:
6945 /* not much point in registering if we can't reply */
6946 if (!rdev->ops->mgmt_tx)
6949 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
6950 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
6951 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
6954 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
6956 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6957 struct wireless_dev *wdev = info->user_ptr[1];
6958 struct cfg80211_chan_def chandef;
6962 struct sk_buff *msg = NULL;
6963 unsigned int wait = 0;
6964 bool offchan, no_cck, dont_wait_for_ack;
6966 dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
6968 if (!info->attrs[NL80211_ATTR_FRAME])
6971 if (!rdev->ops->mgmt_tx)
6974 switch (wdev->iftype) {
6975 case NL80211_IFTYPE_STATION:
6976 case NL80211_IFTYPE_ADHOC:
6977 case NL80211_IFTYPE_P2P_CLIENT:
6978 case NL80211_IFTYPE_AP:
6979 case NL80211_IFTYPE_AP_VLAN:
6980 case NL80211_IFTYPE_MESH_POINT:
6981 case NL80211_IFTYPE_P2P_GO:
6982 case NL80211_IFTYPE_P2P_DEVICE:
6988 if (info->attrs[NL80211_ATTR_DURATION]) {
6989 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
6991 wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
6994 * We should wait on the channel for at least a minimum amount
6995 * of time (10ms) but no longer than the driver supports.
6997 if (wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
6998 wait > rdev->wiphy.max_remain_on_channel_duration)
7003 offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
7005 if (offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7008 no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
7010 err = nl80211_parse_chandef(rdev, info, &chandef);
7014 if (!dont_wait_for_ack) {
7015 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7019 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7028 err = cfg80211_mlme_mgmt_tx(rdev, wdev, chandef.chan, offchan, wait,
7029 nla_data(info->attrs[NL80211_ATTR_FRAME]),
7030 nla_len(info->attrs[NL80211_ATTR_FRAME]),
7031 no_cck, dont_wait_for_ack, &cookie);
7036 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7037 goto nla_put_failure;
7039 genlmsg_end(msg, hdr);
7040 return genlmsg_reply(msg, info);
7052 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
7054 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7055 struct wireless_dev *wdev = info->user_ptr[1];
7058 if (!info->attrs[NL80211_ATTR_COOKIE])
7061 if (!rdev->ops->mgmt_tx_cancel_wait)
7064 switch (wdev->iftype) {
7065 case NL80211_IFTYPE_STATION:
7066 case NL80211_IFTYPE_ADHOC:
7067 case NL80211_IFTYPE_P2P_CLIENT:
7068 case NL80211_IFTYPE_AP:
7069 case NL80211_IFTYPE_AP_VLAN:
7070 case NL80211_IFTYPE_P2P_GO:
7071 case NL80211_IFTYPE_P2P_DEVICE:
7077 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7079 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
7082 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
7084 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7085 struct wireless_dev *wdev;
7086 struct net_device *dev = info->user_ptr[1];
7091 if (!info->attrs[NL80211_ATTR_PS_STATE])
7094 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
7096 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
7099 wdev = dev->ieee80211_ptr;
7101 if (!rdev->ops->set_power_mgmt)
7104 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
7106 if (state == wdev->ps)
7109 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
7115 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
7117 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7118 enum nl80211_ps_state ps_state;
7119 struct wireless_dev *wdev;
7120 struct net_device *dev = info->user_ptr[1];
7121 struct sk_buff *msg;
7125 wdev = dev->ieee80211_ptr;
7127 if (!rdev->ops->set_power_mgmt)
7130 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7134 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7135 NL80211_CMD_GET_POWER_SAVE);
7142 ps_state = NL80211_PS_ENABLED;
7144 ps_state = NL80211_PS_DISABLED;
7146 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
7147 goto nla_put_failure;
7149 genlmsg_end(msg, hdr);
7150 return genlmsg_reply(msg, info);
7159 static struct nla_policy
7160 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] __read_mostly = {
7161 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
7162 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
7163 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
7164 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
7165 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
7166 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
7169 static int nl80211_set_cqm_txe(struct genl_info *info,
7170 u32 rate, u32 pkts, u32 intvl)
7172 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7173 struct wireless_dev *wdev;
7174 struct net_device *dev = info->user_ptr[1];
7176 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
7179 wdev = dev->ieee80211_ptr;
7181 if (!rdev->ops->set_cqm_txe_config)
7184 if (wdev->iftype != NL80211_IFTYPE_STATION &&
7185 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
7188 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
7191 static int nl80211_set_cqm_rssi(struct genl_info *info,
7192 s32 threshold, u32 hysteresis)
7194 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7195 struct wireless_dev *wdev;
7196 struct net_device *dev = info->user_ptr[1];
7201 wdev = dev->ieee80211_ptr;
7203 if (!rdev->ops->set_cqm_rssi_config)
7206 if (wdev->iftype != NL80211_IFTYPE_STATION &&
7207 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
7210 return rdev_set_cqm_rssi_config(rdev, dev, threshold, hysteresis);
7213 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
7215 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
7219 cqm = info->attrs[NL80211_ATTR_CQM];
7225 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
7226 nl80211_attr_cqm_policy);
7230 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
7231 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
7234 threshold = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
7235 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
7236 err = nl80211_set_cqm_rssi(info, threshold, hysteresis);
7237 } else if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
7238 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
7239 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
7240 u32 rate, pkts, intvl;
7241 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
7242 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
7243 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
7244 err = nl80211_set_cqm_txe(info, rate, pkts, intvl);
7252 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
7254 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7255 struct net_device *dev = info->user_ptr[1];
7256 struct mesh_config cfg;
7257 struct mesh_setup setup;
7260 /* start with default */
7261 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
7262 memcpy(&setup, &default_mesh_setup, sizeof(setup));
7264 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
7265 /* and parse parameters if given */
7266 err = nl80211_parse_mesh_config(info, &cfg, NULL);
7271 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
7272 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
7275 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
7276 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
7278 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
7279 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
7280 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
7283 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
7284 setup.beacon_interval =
7285 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
7286 if (setup.beacon_interval < 10 ||
7287 setup.beacon_interval > 10000)
7291 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
7293 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
7294 if (setup.dtim_period < 1 || setup.dtim_period > 100)
7298 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
7299 /* parse additional setup parameters if given */
7300 err = nl80211_parse_mesh_setup(info, &setup);
7305 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
7306 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
7310 /* cfg80211_join_mesh() will sort it out */
7311 setup.chandef.chan = NULL;
7314 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
7317 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
7319 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7320 struct net_device *dev = info->user_ptr[1];
7322 return cfg80211_leave_mesh(rdev, dev);
7326 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
7327 struct cfg80211_registered_device *rdev)
7329 struct nlattr *nl_pats, *nl_pat;
7332 if (!rdev->wowlan->n_patterns)
7335 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
7339 for (i = 0; i < rdev->wowlan->n_patterns; i++) {
7340 nl_pat = nla_nest_start(msg, i + 1);
7343 pat_len = rdev->wowlan->patterns[i].pattern_len;
7344 if (nla_put(msg, NL80211_WOWLAN_PKTPAT_MASK,
7345 DIV_ROUND_UP(pat_len, 8),
7346 rdev->wowlan->patterns[i].mask) ||
7347 nla_put(msg, NL80211_WOWLAN_PKTPAT_PATTERN,
7348 pat_len, rdev->wowlan->patterns[i].pattern) ||
7349 nla_put_u32(msg, NL80211_WOWLAN_PKTPAT_OFFSET,
7350 rdev->wowlan->patterns[i].pkt_offset))
7352 nla_nest_end(msg, nl_pat);
7354 nla_nest_end(msg, nl_pats);
7359 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
7360 struct cfg80211_wowlan_tcp *tcp)
7362 struct nlattr *nl_tcp;
7367 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
7371 if (nla_put_be32(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
7372 nla_put_be32(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
7373 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
7374 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
7375 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
7376 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
7377 tcp->payload_len, tcp->payload) ||
7378 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
7379 tcp->data_interval) ||
7380 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
7381 tcp->wake_len, tcp->wake_data) ||
7382 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
7383 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
7386 if (tcp->payload_seq.len &&
7387 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
7388 sizeof(tcp->payload_seq), &tcp->payload_seq))
7391 if (tcp->payload_tok.len &&
7392 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
7393 sizeof(tcp->payload_tok) + tcp->tokens_size,
7400 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
7402 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7403 struct sk_buff *msg;
7405 u32 size = NLMSG_DEFAULT_SIZE;
7407 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns &&
7408 !rdev->wiphy.wowlan.tcp)
7411 if (rdev->wowlan && rdev->wowlan->tcp) {
7412 /* adjust size to have room for all the data */
7413 size += rdev->wowlan->tcp->tokens_size +
7414 rdev->wowlan->tcp->payload_len +
7415 rdev->wowlan->tcp->wake_len +
7416 rdev->wowlan->tcp->wake_len / 8;
7419 msg = nlmsg_new(size, GFP_KERNEL);
7423 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7424 NL80211_CMD_GET_WOWLAN);
7426 goto nla_put_failure;
7429 struct nlattr *nl_wowlan;
7431 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7433 goto nla_put_failure;
7435 if ((rdev->wowlan->any &&
7436 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
7437 (rdev->wowlan->disconnect &&
7438 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
7439 (rdev->wowlan->magic_pkt &&
7440 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
7441 (rdev->wowlan->gtk_rekey_failure &&
7442 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
7443 (rdev->wowlan->eap_identity_req &&
7444 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
7445 (rdev->wowlan->four_way_handshake &&
7446 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
7447 (rdev->wowlan->rfkill_release &&
7448 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
7449 goto nla_put_failure;
7451 if (nl80211_send_wowlan_patterns(msg, rdev))
7452 goto nla_put_failure;
7454 if (nl80211_send_wowlan_tcp(msg, rdev->wowlan->tcp))
7455 goto nla_put_failure;
7457 nla_nest_end(msg, nl_wowlan);
7460 genlmsg_end(msg, hdr);
7461 return genlmsg_reply(msg, info);
7468 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
7469 struct nlattr *attr,
7470 struct cfg80211_wowlan *trig)
7472 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
7473 struct cfg80211_wowlan_tcp *cfg;
7474 struct nl80211_wowlan_tcp_data_token *tok = NULL;
7475 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
7477 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
7480 if (!rdev->wiphy.wowlan.tcp)
7483 err = nla_parse(tb, MAX_NL80211_WOWLAN_TCP,
7484 nla_data(attr), nla_len(attr),
7485 nl80211_wowlan_tcp_policy);
7489 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
7490 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
7491 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
7492 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
7493 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
7494 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
7495 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
7496 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
7499 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
7500 if (data_size > rdev->wiphy.wowlan.tcp->data_payload_max)
7503 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
7504 rdev->wiphy.wowlan.tcp->data_interval_max)
7507 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
7508 if (wake_size > rdev->wiphy.wowlan.tcp->wake_payload_max)
7511 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
7512 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
7515 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
7516 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
7518 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
7519 tokens_size = tokln - sizeof(*tok);
7521 if (!tok->len || tokens_size % tok->len)
7523 if (!rdev->wiphy.wowlan.tcp->tok)
7525 if (tok->len > rdev->wiphy.wowlan.tcp->tok->max_len)
7527 if (tok->len < rdev->wiphy.wowlan.tcp->tok->min_len)
7529 if (tokens_size > rdev->wiphy.wowlan.tcp->tok->bufsize)
7531 if (tok->offset + tok->len > data_size)
7535 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
7536 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
7537 if (!rdev->wiphy.wowlan.tcp->seq)
7539 if (seq->len == 0 || seq->len > 4)
7541 if (seq->len + seq->offset > data_size)
7545 size = sizeof(*cfg);
7547 size += wake_size + wake_mask_size;
7548 size += tokens_size;
7550 cfg = kzalloc(size, GFP_KERNEL);
7553 cfg->src = nla_get_be32(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
7554 cfg->dst = nla_get_be32(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
7555 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
7557 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
7558 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
7562 /* allocate a socket and port for it and use it */
7563 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
7564 IPPROTO_TCP, &cfg->sock, 1);
7569 if (inet_csk_get_port(cfg->sock->sk, port)) {
7570 sock_release(cfg->sock);
7574 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
7580 cfg->src_port = port;
7583 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
7584 cfg->payload_len = data_size;
7585 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
7586 memcpy((void *)cfg->payload,
7587 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
7590 cfg->payload_seq = *seq;
7591 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
7592 cfg->wake_len = wake_size;
7593 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
7594 memcpy((void *)cfg->wake_data,
7595 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
7597 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
7598 data_size + wake_size;
7599 memcpy((void *)cfg->wake_mask,
7600 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
7603 cfg->tokens_size = tokens_size;
7604 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
7612 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
7614 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7615 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
7616 struct cfg80211_wowlan new_triggers = {};
7617 struct cfg80211_wowlan *ntrig;
7618 struct wiphy_wowlan_support *wowlan = &rdev->wiphy.wowlan;
7620 bool prev_enabled = rdev->wowlan;
7622 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns &&
7623 !rdev->wiphy.wowlan.tcp)
7626 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
7627 cfg80211_rdev_free_wowlan(rdev);
7628 rdev->wowlan = NULL;
7632 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
7633 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
7634 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
7635 nl80211_wowlan_policy);
7639 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
7640 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
7642 new_triggers.any = true;
7645 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
7646 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
7648 new_triggers.disconnect = true;
7651 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
7652 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
7654 new_triggers.magic_pkt = true;
7657 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
7660 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
7661 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
7663 new_triggers.gtk_rekey_failure = true;
7666 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
7667 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
7669 new_triggers.eap_identity_req = true;
7672 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
7673 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
7675 new_triggers.four_way_handshake = true;
7678 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
7679 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
7681 new_triggers.rfkill_release = true;
7684 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
7687 int rem, pat_len, mask_len, pkt_offset;
7688 struct nlattr *pat_tb[NUM_NL80211_WOWLAN_PKTPAT];
7690 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
7693 if (n_patterns > wowlan->n_patterns)
7696 new_triggers.patterns = kcalloc(n_patterns,
7697 sizeof(new_triggers.patterns[0]),
7699 if (!new_triggers.patterns)
7702 new_triggers.n_patterns = n_patterns;
7705 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
7707 nla_parse(pat_tb, MAX_NL80211_WOWLAN_PKTPAT,
7708 nla_data(pat), nla_len(pat), NULL);
7710 if (!pat_tb[NL80211_WOWLAN_PKTPAT_MASK] ||
7711 !pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN])
7713 pat_len = nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]);
7714 mask_len = DIV_ROUND_UP(pat_len, 8);
7715 if (nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]) !=
7718 if (pat_len > wowlan->pattern_max_len ||
7719 pat_len < wowlan->pattern_min_len)
7722 if (!pat_tb[NL80211_WOWLAN_PKTPAT_OFFSET])
7725 pkt_offset = nla_get_u32(
7726 pat_tb[NL80211_WOWLAN_PKTPAT_OFFSET]);
7727 if (pkt_offset > wowlan->max_pkt_offset)
7729 new_triggers.patterns[i].pkt_offset = pkt_offset;
7731 new_triggers.patterns[i].mask =
7732 kmalloc(mask_len + pat_len, GFP_KERNEL);
7733 if (!new_triggers.patterns[i].mask) {
7737 new_triggers.patterns[i].pattern =
7738 new_triggers.patterns[i].mask + mask_len;
7739 memcpy(new_triggers.patterns[i].mask,
7740 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]),
7742 new_triggers.patterns[i].pattern_len = pat_len;
7743 memcpy(new_triggers.patterns[i].pattern,
7744 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]),
7750 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
7751 err = nl80211_parse_wowlan_tcp(
7752 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
7758 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
7763 cfg80211_rdev_free_wowlan(rdev);
7764 rdev->wowlan = ntrig;
7767 if (rdev->ops->set_wakeup && prev_enabled != !!rdev->wowlan)
7768 rdev_set_wakeup(rdev, rdev->wowlan);
7772 for (i = 0; i < new_triggers.n_patterns; i++)
7773 kfree(new_triggers.patterns[i].mask);
7774 kfree(new_triggers.patterns);
7775 if (new_triggers.tcp && new_triggers.tcp->sock)
7776 sock_release(new_triggers.tcp->sock);
7777 kfree(new_triggers.tcp);
7782 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
7784 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7785 struct net_device *dev = info->user_ptr[1];
7786 struct wireless_dev *wdev = dev->ieee80211_ptr;
7787 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
7788 struct cfg80211_gtk_rekey_data rekey_data;
7791 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
7794 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
7795 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
7796 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
7797 nl80211_rekey_policy);
7801 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
7803 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
7805 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
7808 memcpy(rekey_data.kek, nla_data(tb[NL80211_REKEY_DATA_KEK]),
7810 memcpy(rekey_data.kck, nla_data(tb[NL80211_REKEY_DATA_KCK]),
7812 memcpy(rekey_data.replay_ctr,
7813 nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]),
7814 NL80211_REPLAY_CTR_LEN);
7817 if (!wdev->current_bss) {
7822 if (!rdev->ops->set_rekey_data) {
7827 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
7833 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
7834 struct genl_info *info)
7836 struct net_device *dev = info->user_ptr[1];
7837 struct wireless_dev *wdev = dev->ieee80211_ptr;
7839 if (wdev->iftype != NL80211_IFTYPE_AP &&
7840 wdev->iftype != NL80211_IFTYPE_P2P_GO)
7843 if (wdev->ap_unexpected_nlportid)
7846 wdev->ap_unexpected_nlportid = info->snd_portid;
7850 static int nl80211_probe_client(struct sk_buff *skb,
7851 struct genl_info *info)
7853 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7854 struct net_device *dev = info->user_ptr[1];
7855 struct wireless_dev *wdev = dev->ieee80211_ptr;
7856 struct sk_buff *msg;
7862 if (wdev->iftype != NL80211_IFTYPE_AP &&
7863 wdev->iftype != NL80211_IFTYPE_P2P_GO)
7866 if (!info->attrs[NL80211_ATTR_MAC])
7869 if (!rdev->ops->probe_client)
7872 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7876 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7877 NL80211_CMD_PROBE_CLIENT);
7884 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
7886 err = rdev_probe_client(rdev, dev, addr, &cookie);
7890 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7891 goto nla_put_failure;
7893 genlmsg_end(msg, hdr);
7895 return genlmsg_reply(msg, info);
7904 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
7906 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7907 struct cfg80211_beacon_registration *reg, *nreg;
7910 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
7913 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
7917 /* First, check if already registered. */
7918 spin_lock_bh(&rdev->beacon_registrations_lock);
7919 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
7920 if (reg->nlportid == info->snd_portid) {
7925 /* Add it to the list */
7926 nreg->nlportid = info->snd_portid;
7927 list_add(&nreg->list, &rdev->beacon_registrations);
7929 spin_unlock_bh(&rdev->beacon_registrations_lock);
7933 spin_unlock_bh(&rdev->beacon_registrations_lock);
7938 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
7940 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7941 struct wireless_dev *wdev = info->user_ptr[1];
7944 if (!rdev->ops->start_p2p_device)
7947 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
7950 if (wdev->p2p_started)
7953 mutex_lock(&rdev->devlist_mtx);
7954 err = cfg80211_can_add_interface(rdev, wdev->iftype);
7955 mutex_unlock(&rdev->devlist_mtx);
7959 err = rdev_start_p2p_device(rdev, wdev);
7963 wdev->p2p_started = true;
7964 mutex_lock(&rdev->devlist_mtx);
7966 mutex_unlock(&rdev->devlist_mtx);
7971 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
7973 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7974 struct wireless_dev *wdev = info->user_ptr[1];
7976 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
7979 if (!rdev->ops->stop_p2p_device)
7982 if (!wdev->p2p_started)
7985 rdev_stop_p2p_device(rdev, wdev);
7986 wdev->p2p_started = false;
7988 mutex_lock(&rdev->devlist_mtx);
7990 mutex_unlock(&rdev->devlist_mtx);
7992 if (WARN_ON(rdev->scan_req && rdev->scan_req->wdev == wdev)) {
7993 rdev->scan_req->aborted = true;
7994 ___cfg80211_scan_done(rdev, true);
8000 static int nl80211_get_protocol_features(struct sk_buff *skb,
8001 struct genl_info *info)
8004 struct sk_buff *msg;
8006 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8010 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8011 NL80211_CMD_GET_PROTOCOL_FEATURES);
8013 goto nla_put_failure;
8015 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
8016 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
8017 goto nla_put_failure;
8019 genlmsg_end(msg, hdr);
8020 return genlmsg_reply(msg, info);
8027 #define NL80211_FLAG_NEED_WIPHY 0x01
8028 #define NL80211_FLAG_NEED_NETDEV 0x02
8029 #define NL80211_FLAG_NEED_RTNL 0x04
8030 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
8031 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
8032 NL80211_FLAG_CHECK_NETDEV_UP)
8033 #define NL80211_FLAG_NEED_WDEV 0x10
8034 /* If a netdev is associated, it must be UP, P2P must be started */
8035 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
8036 NL80211_FLAG_CHECK_NETDEV_UP)
8038 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
8039 struct genl_info *info)
8041 struct cfg80211_registered_device *rdev;
8042 struct wireless_dev *wdev;
8043 struct net_device *dev;
8044 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
8049 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
8050 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
8054 return PTR_ERR(rdev);
8056 info->user_ptr[0] = rdev;
8057 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
8058 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
8059 mutex_lock(&cfg80211_mutex);
8060 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
8063 mutex_unlock(&cfg80211_mutex);
8066 return PTR_ERR(wdev);
8070 rdev = wiphy_to_dev(wdev->wiphy);
8072 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
8074 mutex_unlock(&cfg80211_mutex);
8080 info->user_ptr[1] = dev;
8082 info->user_ptr[1] = wdev;
8086 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
8087 !netif_running(dev)) {
8088 mutex_unlock(&cfg80211_mutex);
8095 } else if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP) {
8096 if (!wdev->p2p_started) {
8097 mutex_unlock(&cfg80211_mutex);
8104 cfg80211_lock_rdev(rdev);
8106 mutex_unlock(&cfg80211_mutex);
8108 info->user_ptr[0] = rdev;
8114 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
8115 struct genl_info *info)
8117 if (info->user_ptr[0])
8118 cfg80211_unlock_rdev(info->user_ptr[0]);
8119 if (info->user_ptr[1]) {
8120 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
8121 struct wireless_dev *wdev = info->user_ptr[1];
8124 dev_put(wdev->netdev);
8126 dev_put(info->user_ptr[1]);
8129 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
8133 static struct genl_ops nl80211_ops[] = {
8135 .cmd = NL80211_CMD_GET_WIPHY,
8136 .doit = nl80211_get_wiphy,
8137 .dumpit = nl80211_dump_wiphy,
8138 .policy = nl80211_policy,
8139 /* can be retrieved by unprivileged users */
8140 .internal_flags = NL80211_FLAG_NEED_WIPHY,
8143 .cmd = NL80211_CMD_SET_WIPHY,
8144 .doit = nl80211_set_wiphy,
8145 .policy = nl80211_policy,
8146 .flags = GENL_ADMIN_PERM,
8147 .internal_flags = NL80211_FLAG_NEED_RTNL,
8150 .cmd = NL80211_CMD_GET_INTERFACE,
8151 .doit = nl80211_get_interface,
8152 .dumpit = nl80211_dump_interface,
8153 .policy = nl80211_policy,
8154 /* can be retrieved by unprivileged users */
8155 .internal_flags = NL80211_FLAG_NEED_WDEV,
8158 .cmd = NL80211_CMD_SET_INTERFACE,
8159 .doit = nl80211_set_interface,
8160 .policy = nl80211_policy,
8161 .flags = GENL_ADMIN_PERM,
8162 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8163 NL80211_FLAG_NEED_RTNL,
8166 .cmd = NL80211_CMD_NEW_INTERFACE,
8167 .doit = nl80211_new_interface,
8168 .policy = nl80211_policy,
8169 .flags = GENL_ADMIN_PERM,
8170 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8171 NL80211_FLAG_NEED_RTNL,
8174 .cmd = NL80211_CMD_DEL_INTERFACE,
8175 .doit = nl80211_del_interface,
8176 .policy = nl80211_policy,
8177 .flags = GENL_ADMIN_PERM,
8178 .internal_flags = NL80211_FLAG_NEED_WDEV |
8179 NL80211_FLAG_NEED_RTNL,
8182 .cmd = NL80211_CMD_GET_KEY,
8183 .doit = nl80211_get_key,
8184 .policy = nl80211_policy,
8185 .flags = GENL_ADMIN_PERM,
8186 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8187 NL80211_FLAG_NEED_RTNL,
8190 .cmd = NL80211_CMD_SET_KEY,
8191 .doit = nl80211_set_key,
8192 .policy = nl80211_policy,
8193 .flags = GENL_ADMIN_PERM,
8194 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8195 NL80211_FLAG_NEED_RTNL,
8198 .cmd = NL80211_CMD_NEW_KEY,
8199 .doit = nl80211_new_key,
8200 .policy = nl80211_policy,
8201 .flags = GENL_ADMIN_PERM,
8202 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8203 NL80211_FLAG_NEED_RTNL,
8206 .cmd = NL80211_CMD_DEL_KEY,
8207 .doit = nl80211_del_key,
8208 .policy = nl80211_policy,
8209 .flags = GENL_ADMIN_PERM,
8210 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8211 NL80211_FLAG_NEED_RTNL,
8214 .cmd = NL80211_CMD_SET_BEACON,
8215 .policy = nl80211_policy,
8216 .flags = GENL_ADMIN_PERM,
8217 .doit = nl80211_set_beacon,
8218 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8219 NL80211_FLAG_NEED_RTNL,
8222 .cmd = NL80211_CMD_START_AP,
8223 .policy = nl80211_policy,
8224 .flags = GENL_ADMIN_PERM,
8225 .doit = nl80211_start_ap,
8226 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8227 NL80211_FLAG_NEED_RTNL,
8230 .cmd = NL80211_CMD_STOP_AP,
8231 .policy = nl80211_policy,
8232 .flags = GENL_ADMIN_PERM,
8233 .doit = nl80211_stop_ap,
8234 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8235 NL80211_FLAG_NEED_RTNL,
8238 .cmd = NL80211_CMD_GET_STATION,
8239 .doit = nl80211_get_station,
8240 .dumpit = nl80211_dump_station,
8241 .policy = nl80211_policy,
8242 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8243 NL80211_FLAG_NEED_RTNL,
8246 .cmd = NL80211_CMD_SET_STATION,
8247 .doit = nl80211_set_station,
8248 .policy = nl80211_policy,
8249 .flags = GENL_ADMIN_PERM,
8250 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8251 NL80211_FLAG_NEED_RTNL,
8254 .cmd = NL80211_CMD_NEW_STATION,
8255 .doit = nl80211_new_station,
8256 .policy = nl80211_policy,
8257 .flags = GENL_ADMIN_PERM,
8258 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8259 NL80211_FLAG_NEED_RTNL,
8262 .cmd = NL80211_CMD_DEL_STATION,
8263 .doit = nl80211_del_station,
8264 .policy = nl80211_policy,
8265 .flags = GENL_ADMIN_PERM,
8266 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8267 NL80211_FLAG_NEED_RTNL,
8270 .cmd = NL80211_CMD_GET_MPATH,
8271 .doit = nl80211_get_mpath,
8272 .dumpit = nl80211_dump_mpath,
8273 .policy = nl80211_policy,
8274 .flags = GENL_ADMIN_PERM,
8275 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8276 NL80211_FLAG_NEED_RTNL,
8279 .cmd = NL80211_CMD_SET_MPATH,
8280 .doit = nl80211_set_mpath,
8281 .policy = nl80211_policy,
8282 .flags = GENL_ADMIN_PERM,
8283 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8284 NL80211_FLAG_NEED_RTNL,
8287 .cmd = NL80211_CMD_NEW_MPATH,
8288 .doit = nl80211_new_mpath,
8289 .policy = nl80211_policy,
8290 .flags = GENL_ADMIN_PERM,
8291 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8292 NL80211_FLAG_NEED_RTNL,
8295 .cmd = NL80211_CMD_DEL_MPATH,
8296 .doit = nl80211_del_mpath,
8297 .policy = nl80211_policy,
8298 .flags = GENL_ADMIN_PERM,
8299 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8300 NL80211_FLAG_NEED_RTNL,
8303 .cmd = NL80211_CMD_SET_BSS,
8304 .doit = nl80211_set_bss,
8305 .policy = nl80211_policy,
8306 .flags = GENL_ADMIN_PERM,
8307 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8308 NL80211_FLAG_NEED_RTNL,
8311 .cmd = NL80211_CMD_GET_REG,
8312 .doit = nl80211_get_reg,
8313 .policy = nl80211_policy,
8314 /* can be retrieved by unprivileged users */
8317 .cmd = NL80211_CMD_SET_REG,
8318 .doit = nl80211_set_reg,
8319 .policy = nl80211_policy,
8320 .flags = GENL_ADMIN_PERM,
8323 .cmd = NL80211_CMD_REQ_SET_REG,
8324 .doit = nl80211_req_set_reg,
8325 .policy = nl80211_policy,
8326 .flags = GENL_ADMIN_PERM,
8329 .cmd = NL80211_CMD_GET_MESH_CONFIG,
8330 .doit = nl80211_get_mesh_config,
8331 .policy = nl80211_policy,
8332 /* can be retrieved by unprivileged users */
8333 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8334 NL80211_FLAG_NEED_RTNL,
8337 .cmd = NL80211_CMD_SET_MESH_CONFIG,
8338 .doit = nl80211_update_mesh_config,
8339 .policy = nl80211_policy,
8340 .flags = GENL_ADMIN_PERM,
8341 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8342 NL80211_FLAG_NEED_RTNL,
8345 .cmd = NL80211_CMD_TRIGGER_SCAN,
8346 .doit = nl80211_trigger_scan,
8347 .policy = nl80211_policy,
8348 .flags = GENL_ADMIN_PERM,
8349 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8350 NL80211_FLAG_NEED_RTNL,
8353 .cmd = NL80211_CMD_GET_SCAN,
8354 .policy = nl80211_policy,
8355 .dumpit = nl80211_dump_scan,
8358 .cmd = NL80211_CMD_START_SCHED_SCAN,
8359 .doit = nl80211_start_sched_scan,
8360 .policy = nl80211_policy,
8361 .flags = GENL_ADMIN_PERM,
8362 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8363 NL80211_FLAG_NEED_RTNL,
8366 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
8367 .doit = nl80211_stop_sched_scan,
8368 .policy = nl80211_policy,
8369 .flags = GENL_ADMIN_PERM,
8370 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8371 NL80211_FLAG_NEED_RTNL,
8374 .cmd = NL80211_CMD_AUTHENTICATE,
8375 .doit = nl80211_authenticate,
8376 .policy = nl80211_policy,
8377 .flags = GENL_ADMIN_PERM,
8378 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8379 NL80211_FLAG_NEED_RTNL,
8382 .cmd = NL80211_CMD_ASSOCIATE,
8383 .doit = nl80211_associate,
8384 .policy = nl80211_policy,
8385 .flags = GENL_ADMIN_PERM,
8386 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8387 NL80211_FLAG_NEED_RTNL,
8390 .cmd = NL80211_CMD_DEAUTHENTICATE,
8391 .doit = nl80211_deauthenticate,
8392 .policy = nl80211_policy,
8393 .flags = GENL_ADMIN_PERM,
8394 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8395 NL80211_FLAG_NEED_RTNL,
8398 .cmd = NL80211_CMD_DISASSOCIATE,
8399 .doit = nl80211_disassociate,
8400 .policy = nl80211_policy,
8401 .flags = GENL_ADMIN_PERM,
8402 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8403 NL80211_FLAG_NEED_RTNL,
8406 .cmd = NL80211_CMD_JOIN_IBSS,
8407 .doit = nl80211_join_ibss,
8408 .policy = nl80211_policy,
8409 .flags = GENL_ADMIN_PERM,
8410 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8411 NL80211_FLAG_NEED_RTNL,
8414 .cmd = NL80211_CMD_LEAVE_IBSS,
8415 .doit = nl80211_leave_ibss,
8416 .policy = nl80211_policy,
8417 .flags = GENL_ADMIN_PERM,
8418 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8419 NL80211_FLAG_NEED_RTNL,
8421 #ifdef CONFIG_NL80211_TESTMODE
8423 .cmd = NL80211_CMD_TESTMODE,
8424 .doit = nl80211_testmode_do,
8425 .dumpit = nl80211_testmode_dump,
8426 .policy = nl80211_policy,
8427 .flags = GENL_ADMIN_PERM,
8428 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8429 NL80211_FLAG_NEED_RTNL,
8433 .cmd = NL80211_CMD_CONNECT,
8434 .doit = nl80211_connect,
8435 .policy = nl80211_policy,
8436 .flags = GENL_ADMIN_PERM,
8437 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8438 NL80211_FLAG_NEED_RTNL,
8441 .cmd = NL80211_CMD_DISCONNECT,
8442 .doit = nl80211_disconnect,
8443 .policy = nl80211_policy,
8444 .flags = GENL_ADMIN_PERM,
8445 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8446 NL80211_FLAG_NEED_RTNL,
8449 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
8450 .doit = nl80211_wiphy_netns,
8451 .policy = nl80211_policy,
8452 .flags = GENL_ADMIN_PERM,
8453 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8454 NL80211_FLAG_NEED_RTNL,
8457 .cmd = NL80211_CMD_GET_SURVEY,
8458 .policy = nl80211_policy,
8459 .dumpit = nl80211_dump_survey,
8462 .cmd = NL80211_CMD_SET_PMKSA,
8463 .doit = nl80211_setdel_pmksa,
8464 .policy = nl80211_policy,
8465 .flags = GENL_ADMIN_PERM,
8466 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8467 NL80211_FLAG_NEED_RTNL,
8470 .cmd = NL80211_CMD_DEL_PMKSA,
8471 .doit = nl80211_setdel_pmksa,
8472 .policy = nl80211_policy,
8473 .flags = GENL_ADMIN_PERM,
8474 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8475 NL80211_FLAG_NEED_RTNL,
8478 .cmd = NL80211_CMD_FLUSH_PMKSA,
8479 .doit = nl80211_flush_pmksa,
8480 .policy = nl80211_policy,
8481 .flags = GENL_ADMIN_PERM,
8482 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8483 NL80211_FLAG_NEED_RTNL,
8486 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
8487 .doit = nl80211_remain_on_channel,
8488 .policy = nl80211_policy,
8489 .flags = GENL_ADMIN_PERM,
8490 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8491 NL80211_FLAG_NEED_RTNL,
8494 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
8495 .doit = nl80211_cancel_remain_on_channel,
8496 .policy = nl80211_policy,
8497 .flags = GENL_ADMIN_PERM,
8498 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8499 NL80211_FLAG_NEED_RTNL,
8502 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
8503 .doit = nl80211_set_tx_bitrate_mask,
8504 .policy = nl80211_policy,
8505 .flags = GENL_ADMIN_PERM,
8506 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8507 NL80211_FLAG_NEED_RTNL,
8510 .cmd = NL80211_CMD_REGISTER_FRAME,
8511 .doit = nl80211_register_mgmt,
8512 .policy = nl80211_policy,
8513 .flags = GENL_ADMIN_PERM,
8514 .internal_flags = NL80211_FLAG_NEED_WDEV |
8515 NL80211_FLAG_NEED_RTNL,
8518 .cmd = NL80211_CMD_FRAME,
8519 .doit = nl80211_tx_mgmt,
8520 .policy = nl80211_policy,
8521 .flags = GENL_ADMIN_PERM,
8522 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8523 NL80211_FLAG_NEED_RTNL,
8526 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
8527 .doit = nl80211_tx_mgmt_cancel_wait,
8528 .policy = nl80211_policy,
8529 .flags = GENL_ADMIN_PERM,
8530 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8531 NL80211_FLAG_NEED_RTNL,
8534 .cmd = NL80211_CMD_SET_POWER_SAVE,
8535 .doit = nl80211_set_power_save,
8536 .policy = nl80211_policy,
8537 .flags = GENL_ADMIN_PERM,
8538 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8539 NL80211_FLAG_NEED_RTNL,
8542 .cmd = NL80211_CMD_GET_POWER_SAVE,
8543 .doit = nl80211_get_power_save,
8544 .policy = nl80211_policy,
8545 /* can be retrieved by unprivileged users */
8546 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8547 NL80211_FLAG_NEED_RTNL,
8550 .cmd = NL80211_CMD_SET_CQM,
8551 .doit = nl80211_set_cqm,
8552 .policy = nl80211_policy,
8553 .flags = GENL_ADMIN_PERM,
8554 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8555 NL80211_FLAG_NEED_RTNL,
8558 .cmd = NL80211_CMD_SET_CHANNEL,
8559 .doit = nl80211_set_channel,
8560 .policy = nl80211_policy,
8561 .flags = GENL_ADMIN_PERM,
8562 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8563 NL80211_FLAG_NEED_RTNL,
8566 .cmd = NL80211_CMD_SET_WDS_PEER,
8567 .doit = nl80211_set_wds_peer,
8568 .policy = nl80211_policy,
8569 .flags = GENL_ADMIN_PERM,
8570 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8571 NL80211_FLAG_NEED_RTNL,
8574 .cmd = NL80211_CMD_JOIN_MESH,
8575 .doit = nl80211_join_mesh,
8576 .policy = nl80211_policy,
8577 .flags = GENL_ADMIN_PERM,
8578 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8579 NL80211_FLAG_NEED_RTNL,
8582 .cmd = NL80211_CMD_LEAVE_MESH,
8583 .doit = nl80211_leave_mesh,
8584 .policy = nl80211_policy,
8585 .flags = GENL_ADMIN_PERM,
8586 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8587 NL80211_FLAG_NEED_RTNL,
8591 .cmd = NL80211_CMD_GET_WOWLAN,
8592 .doit = nl80211_get_wowlan,
8593 .policy = nl80211_policy,
8594 /* can be retrieved by unprivileged users */
8595 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8596 NL80211_FLAG_NEED_RTNL,
8599 .cmd = NL80211_CMD_SET_WOWLAN,
8600 .doit = nl80211_set_wowlan,
8601 .policy = nl80211_policy,
8602 .flags = GENL_ADMIN_PERM,
8603 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8604 NL80211_FLAG_NEED_RTNL,
8608 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
8609 .doit = nl80211_set_rekey_data,
8610 .policy = nl80211_policy,
8611 .flags = GENL_ADMIN_PERM,
8612 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8613 NL80211_FLAG_NEED_RTNL,
8616 .cmd = NL80211_CMD_TDLS_MGMT,
8617 .doit = nl80211_tdls_mgmt,
8618 .policy = nl80211_policy,
8619 .flags = GENL_ADMIN_PERM,
8620 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8621 NL80211_FLAG_NEED_RTNL,
8624 .cmd = NL80211_CMD_TDLS_OPER,
8625 .doit = nl80211_tdls_oper,
8626 .policy = nl80211_policy,
8627 .flags = GENL_ADMIN_PERM,
8628 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8629 NL80211_FLAG_NEED_RTNL,
8632 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
8633 .doit = nl80211_register_unexpected_frame,
8634 .policy = nl80211_policy,
8635 .flags = GENL_ADMIN_PERM,
8636 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8637 NL80211_FLAG_NEED_RTNL,
8640 .cmd = NL80211_CMD_PROBE_CLIENT,
8641 .doit = nl80211_probe_client,
8642 .policy = nl80211_policy,
8643 .flags = GENL_ADMIN_PERM,
8644 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8645 NL80211_FLAG_NEED_RTNL,
8648 .cmd = NL80211_CMD_REGISTER_BEACONS,
8649 .doit = nl80211_register_beacons,
8650 .policy = nl80211_policy,
8651 .flags = GENL_ADMIN_PERM,
8652 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8653 NL80211_FLAG_NEED_RTNL,
8656 .cmd = NL80211_CMD_SET_NOACK_MAP,
8657 .doit = nl80211_set_noack_map,
8658 .policy = nl80211_policy,
8659 .flags = GENL_ADMIN_PERM,
8660 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8661 NL80211_FLAG_NEED_RTNL,
8664 .cmd = NL80211_CMD_START_P2P_DEVICE,
8665 .doit = nl80211_start_p2p_device,
8666 .policy = nl80211_policy,
8667 .flags = GENL_ADMIN_PERM,
8668 .internal_flags = NL80211_FLAG_NEED_WDEV |
8669 NL80211_FLAG_NEED_RTNL,
8672 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
8673 .doit = nl80211_stop_p2p_device,
8674 .policy = nl80211_policy,
8675 .flags = GENL_ADMIN_PERM,
8676 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8677 NL80211_FLAG_NEED_RTNL,
8680 .cmd = NL80211_CMD_SET_MCAST_RATE,
8681 .doit = nl80211_set_mcast_rate,
8682 .policy = nl80211_policy,
8683 .flags = GENL_ADMIN_PERM,
8684 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8685 NL80211_FLAG_NEED_RTNL,
8688 .cmd = NL80211_CMD_SET_MAC_ACL,
8689 .doit = nl80211_set_mac_acl,
8690 .policy = nl80211_policy,
8691 .flags = GENL_ADMIN_PERM,
8692 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8693 NL80211_FLAG_NEED_RTNL,
8696 .cmd = NL80211_CMD_RADAR_DETECT,
8697 .doit = nl80211_start_radar_detection,
8698 .policy = nl80211_policy,
8699 .flags = GENL_ADMIN_PERM,
8700 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8701 NL80211_FLAG_NEED_RTNL,
8704 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
8705 .doit = nl80211_get_protocol_features,
8706 .policy = nl80211_policy,
8710 static struct genl_multicast_group nl80211_mlme_mcgrp = {
8714 /* multicast groups */
8715 static struct genl_multicast_group nl80211_config_mcgrp = {
8718 static struct genl_multicast_group nl80211_scan_mcgrp = {
8721 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
8722 .name = "regulatory",
8725 /* notification functions */
8727 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
8729 struct sk_buff *msg;
8731 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8735 if (nl80211_send_wiphy(rdev, msg, 0, 0, 0,
8736 false, NULL, NULL, NULL) < 0) {
8741 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8742 nl80211_config_mcgrp.id, GFP_KERNEL);
8745 static int nl80211_add_scan_req(struct sk_buff *msg,
8746 struct cfg80211_registered_device *rdev)
8748 struct cfg80211_scan_request *req = rdev->scan_req;
8749 struct nlattr *nest;
8752 ASSERT_RDEV_LOCK(rdev);
8757 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
8759 goto nla_put_failure;
8760 for (i = 0; i < req->n_ssids; i++) {
8761 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
8762 goto nla_put_failure;
8764 nla_nest_end(msg, nest);
8766 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
8768 goto nla_put_failure;
8769 for (i = 0; i < req->n_channels; i++) {
8770 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
8771 goto nla_put_failure;
8773 nla_nest_end(msg, nest);
8776 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
8777 goto nla_put_failure;
8780 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags);
8787 static int nl80211_send_scan_msg(struct sk_buff *msg,
8788 struct cfg80211_registered_device *rdev,
8789 struct wireless_dev *wdev,
8790 u32 portid, u32 seq, int flags,
8795 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
8799 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8800 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
8801 wdev->netdev->ifindex)) ||
8802 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
8803 goto nla_put_failure;
8805 /* ignore errors and send incomplete event anyway */
8806 nl80211_add_scan_req(msg, rdev);
8808 return genlmsg_end(msg, hdr);
8811 genlmsg_cancel(msg, hdr);
8816 nl80211_send_sched_scan_msg(struct sk_buff *msg,
8817 struct cfg80211_registered_device *rdev,
8818 struct net_device *netdev,
8819 u32 portid, u32 seq, int flags, u32 cmd)
8823 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
8827 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
8828 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
8829 goto nla_put_failure;
8831 return genlmsg_end(msg, hdr);
8834 genlmsg_cancel(msg, hdr);
8838 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
8839 struct wireless_dev *wdev)
8841 struct sk_buff *msg;
8843 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8847 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
8848 NL80211_CMD_TRIGGER_SCAN) < 0) {
8853 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8854 nl80211_scan_mcgrp.id, GFP_KERNEL);
8857 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
8858 struct wireless_dev *wdev)
8860 struct sk_buff *msg;
8862 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8866 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
8867 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
8872 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8873 nl80211_scan_mcgrp.id, GFP_KERNEL);
8876 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
8877 struct wireless_dev *wdev)
8879 struct sk_buff *msg;
8881 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8885 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
8886 NL80211_CMD_SCAN_ABORTED) < 0) {
8891 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8892 nl80211_scan_mcgrp.id, GFP_KERNEL);
8895 void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
8896 struct net_device *netdev)
8898 struct sk_buff *msg;
8900 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8904 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
8905 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
8910 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8911 nl80211_scan_mcgrp.id, GFP_KERNEL);
8914 void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
8915 struct net_device *netdev, u32 cmd)
8917 struct sk_buff *msg;
8919 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8923 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
8928 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
8929 nl80211_scan_mcgrp.id, GFP_KERNEL);
8933 * This can happen on global regulatory changes or device specific settings
8934 * based on custom world regulatory domains.
8936 void nl80211_send_reg_change_event(struct regulatory_request *request)
8938 struct sk_buff *msg;
8941 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8945 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
8951 /* Userspace can always count this one always being set */
8952 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
8953 goto nla_put_failure;
8955 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
8956 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
8957 NL80211_REGDOM_TYPE_WORLD))
8958 goto nla_put_failure;
8959 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
8960 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
8961 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
8962 goto nla_put_failure;
8963 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
8964 request->intersect) {
8965 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
8966 NL80211_REGDOM_TYPE_INTERSECTION))
8967 goto nla_put_failure;
8969 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
8970 NL80211_REGDOM_TYPE_COUNTRY) ||
8971 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
8973 goto nla_put_failure;
8976 if (request->wiphy_idx != WIPHY_IDX_INVALID &&
8977 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
8978 goto nla_put_failure;
8980 genlmsg_end(msg, hdr);
8983 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
8990 genlmsg_cancel(msg, hdr);
8994 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
8995 struct net_device *netdev,
8996 const u8 *buf, size_t len,
8997 enum nl80211_commands cmd, gfp_t gfp)
8999 struct sk_buff *msg;
9002 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9006 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9012 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9013 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9014 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
9015 goto nla_put_failure;
9017 genlmsg_end(msg, hdr);
9019 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9020 nl80211_mlme_mcgrp.id, gfp);
9024 genlmsg_cancel(msg, hdr);
9028 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
9029 struct net_device *netdev, const u8 *buf,
9030 size_t len, gfp_t gfp)
9032 nl80211_send_mlme_event(rdev, netdev, buf, len,
9033 NL80211_CMD_AUTHENTICATE, gfp);
9036 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
9037 struct net_device *netdev, const u8 *buf,
9038 size_t len, gfp_t gfp)
9040 nl80211_send_mlme_event(rdev, netdev, buf, len,
9041 NL80211_CMD_ASSOCIATE, gfp);
9044 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
9045 struct net_device *netdev, const u8 *buf,
9046 size_t len, gfp_t gfp)
9048 nl80211_send_mlme_event(rdev, netdev, buf, len,
9049 NL80211_CMD_DEAUTHENTICATE, gfp);
9052 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
9053 struct net_device *netdev, const u8 *buf,
9054 size_t len, gfp_t gfp)
9056 nl80211_send_mlme_event(rdev, netdev, buf, len,
9057 NL80211_CMD_DISASSOCIATE, gfp);
9060 void nl80211_send_unprot_deauth(struct cfg80211_registered_device *rdev,
9061 struct net_device *netdev, const u8 *buf,
9062 size_t len, gfp_t gfp)
9064 nl80211_send_mlme_event(rdev, netdev, buf, len,
9065 NL80211_CMD_UNPROT_DEAUTHENTICATE, gfp);
9068 void nl80211_send_unprot_disassoc(struct cfg80211_registered_device *rdev,
9069 struct net_device *netdev, const u8 *buf,
9070 size_t len, gfp_t gfp)
9072 nl80211_send_mlme_event(rdev, netdev, buf, len,
9073 NL80211_CMD_UNPROT_DISASSOCIATE, gfp);
9076 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
9077 struct net_device *netdev, int cmd,
9078 const u8 *addr, gfp_t gfp)
9080 struct sk_buff *msg;
9083 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9087 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9093 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9094 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9095 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
9096 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
9097 goto nla_put_failure;
9099 genlmsg_end(msg, hdr);
9101 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9102 nl80211_mlme_mcgrp.id, gfp);
9106 genlmsg_cancel(msg, hdr);
9110 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
9111 struct net_device *netdev, const u8 *addr,
9114 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
9118 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
9119 struct net_device *netdev, const u8 *addr,
9122 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
9126 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
9127 struct net_device *netdev, const u8 *bssid,
9128 const u8 *req_ie, size_t req_ie_len,
9129 const u8 *resp_ie, size_t resp_ie_len,
9130 u16 status, gfp_t gfp)
9132 struct sk_buff *msg;
9135 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9139 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
9145 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9146 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9147 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
9148 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
9150 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
9152 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
9153 goto nla_put_failure;
9155 genlmsg_end(msg, hdr);
9157 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9158 nl80211_mlme_mcgrp.id, gfp);
9162 genlmsg_cancel(msg, hdr);
9167 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
9168 struct net_device *netdev, const u8 *bssid,
9169 const u8 *req_ie, size_t req_ie_len,
9170 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
9172 struct sk_buff *msg;
9175 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9179 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
9185 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9186 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9187 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
9189 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
9191 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
9192 goto nla_put_failure;
9194 genlmsg_end(msg, hdr);
9196 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9197 nl80211_mlme_mcgrp.id, gfp);
9201 genlmsg_cancel(msg, hdr);
9206 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
9207 struct net_device *netdev, u16 reason,
9208 const u8 *ie, size_t ie_len, bool from_ap)
9210 struct sk_buff *msg;
9213 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9217 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
9223 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9224 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9225 (from_ap && reason &&
9226 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
9228 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
9229 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
9230 goto nla_put_failure;
9232 genlmsg_end(msg, hdr);
9234 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9235 nl80211_mlme_mcgrp.id, GFP_KERNEL);
9239 genlmsg_cancel(msg, hdr);
9244 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
9245 struct net_device *netdev, const u8 *bssid,
9248 struct sk_buff *msg;
9251 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9255 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
9261 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9262 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9263 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
9264 goto nla_put_failure;
9266 genlmsg_end(msg, hdr);
9268 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9269 nl80211_mlme_mcgrp.id, gfp);
9273 genlmsg_cancel(msg, hdr);
9277 void nl80211_send_new_peer_candidate(struct cfg80211_registered_device *rdev,
9278 struct net_device *netdev,
9279 const u8 *macaddr, const u8* ie, u8 ie_len,
9282 struct sk_buff *msg;
9285 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9289 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
9295 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9296 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9297 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, macaddr) ||
9299 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
9300 goto nla_put_failure;
9302 genlmsg_end(msg, hdr);
9304 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9305 nl80211_mlme_mcgrp.id, gfp);
9309 genlmsg_cancel(msg, hdr);
9313 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
9314 struct net_device *netdev, const u8 *addr,
9315 enum nl80211_key_type key_type, int key_id,
9316 const u8 *tsc, gfp_t gfp)
9318 struct sk_buff *msg;
9321 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9325 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
9331 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9332 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9333 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
9334 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
9336 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
9337 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
9338 goto nla_put_failure;
9340 genlmsg_end(msg, hdr);
9342 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9343 nl80211_mlme_mcgrp.id, gfp);
9347 genlmsg_cancel(msg, hdr);
9351 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
9352 struct ieee80211_channel *channel_before,
9353 struct ieee80211_channel *channel_after)
9355 struct sk_buff *msg;
9357 struct nlattr *nl_freq;
9359 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
9363 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
9370 * Since we are applying the beacon hint to a wiphy we know its
9371 * wiphy_idx is valid
9373 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
9374 goto nla_put_failure;
9377 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
9379 goto nla_put_failure;
9380 if (nl80211_msg_put_channel(msg, channel_before))
9381 goto nla_put_failure;
9382 nla_nest_end(msg, nl_freq);
9385 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
9387 goto nla_put_failure;
9388 if (nl80211_msg_put_channel(msg, channel_after))
9389 goto nla_put_failure;
9390 nla_nest_end(msg, nl_freq);
9392 genlmsg_end(msg, hdr);
9395 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
9402 genlmsg_cancel(msg, hdr);
9406 static void nl80211_send_remain_on_chan_event(
9407 int cmd, struct cfg80211_registered_device *rdev,
9408 struct wireless_dev *wdev, u64 cookie,
9409 struct ieee80211_channel *chan,
9410 unsigned int duration, gfp_t gfp)
9412 struct sk_buff *msg;
9415 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9419 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9425 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9426 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9427 wdev->netdev->ifindex)) ||
9428 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9429 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
9430 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
9431 NL80211_CHAN_NO_HT) ||
9432 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
9433 goto nla_put_failure;
9435 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
9436 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
9437 goto nla_put_failure;
9439 genlmsg_end(msg, hdr);
9441 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9442 nl80211_mlme_mcgrp.id, gfp);
9446 genlmsg_cancel(msg, hdr);
9450 void nl80211_send_remain_on_channel(struct cfg80211_registered_device *rdev,
9451 struct wireless_dev *wdev, u64 cookie,
9452 struct ieee80211_channel *chan,
9453 unsigned int duration, gfp_t gfp)
9455 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
9456 rdev, wdev, cookie, chan,
9460 void nl80211_send_remain_on_channel_cancel(
9461 struct cfg80211_registered_device *rdev,
9462 struct wireless_dev *wdev,
9463 u64 cookie, struct ieee80211_channel *chan, gfp_t gfp)
9465 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
9466 rdev, wdev, cookie, chan, 0, gfp);
9469 void nl80211_send_sta_event(struct cfg80211_registered_device *rdev,
9470 struct net_device *dev, const u8 *mac_addr,
9471 struct station_info *sinfo, gfp_t gfp)
9473 struct sk_buff *msg;
9475 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9479 if (nl80211_send_station(msg, 0, 0, 0,
9480 rdev, dev, mac_addr, sinfo) < 0) {
9485 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9486 nl80211_mlme_mcgrp.id, gfp);
9489 void nl80211_send_sta_del_event(struct cfg80211_registered_device *rdev,
9490 struct net_device *dev, const u8 *mac_addr,
9493 struct sk_buff *msg;
9496 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9500 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
9506 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9507 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
9508 goto nla_put_failure;
9510 genlmsg_end(msg, hdr);
9512 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9513 nl80211_mlme_mcgrp.id, gfp);
9517 genlmsg_cancel(msg, hdr);
9521 void nl80211_send_conn_failed_event(struct cfg80211_registered_device *rdev,
9522 struct net_device *dev, const u8 *mac_addr,
9523 enum nl80211_connect_failed_reason reason,
9526 struct sk_buff *msg;
9529 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
9533 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
9539 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9540 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
9541 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
9542 goto nla_put_failure;
9544 genlmsg_end(msg, hdr);
9546 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9547 nl80211_mlme_mcgrp.id, gfp);
9551 genlmsg_cancel(msg, hdr);
9555 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
9556 const u8 *addr, gfp_t gfp)
9558 struct wireless_dev *wdev = dev->ieee80211_ptr;
9559 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
9560 struct sk_buff *msg;
9563 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
9568 msg = nlmsg_new(100, gfp);
9572 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9578 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9579 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9580 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
9581 goto nla_put_failure;
9583 err = genlmsg_end(msg, hdr);
9589 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
9593 genlmsg_cancel(msg, hdr);
9598 bool nl80211_unexpected_frame(struct net_device *dev, const u8 *addr, gfp_t gfp)
9600 return __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
9604 bool nl80211_unexpected_4addr_frame(struct net_device *dev,
9605 const u8 *addr, gfp_t gfp)
9607 return __nl80211_unexpected_frame(dev,
9608 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
9612 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
9613 struct wireless_dev *wdev, u32 nlportid,
9614 int freq, int sig_dbm,
9615 const u8 *buf, size_t len, gfp_t gfp)
9617 struct net_device *netdev = wdev->netdev;
9618 struct sk_buff *msg;
9621 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9625 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
9631 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9632 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9633 netdev->ifindex)) ||
9634 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
9636 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
9637 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
9638 goto nla_put_failure;
9640 genlmsg_end(msg, hdr);
9642 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
9645 genlmsg_cancel(msg, hdr);
9650 void nl80211_send_mgmt_tx_status(struct cfg80211_registered_device *rdev,
9651 struct wireless_dev *wdev, u64 cookie,
9652 const u8 *buf, size_t len, bool ack,
9655 struct net_device *netdev = wdev->netdev;
9656 struct sk_buff *msg;
9659 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9663 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
9669 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9670 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9671 netdev->ifindex)) ||
9672 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
9673 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
9674 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
9675 goto nla_put_failure;
9677 genlmsg_end(msg, hdr);
9679 genlmsg_multicast(msg, 0, nl80211_mlme_mcgrp.id, gfp);
9683 genlmsg_cancel(msg, hdr);
9688 nl80211_send_cqm_rssi_notify(struct cfg80211_registered_device *rdev,
9689 struct net_device *netdev,
9690 enum nl80211_cqm_rssi_threshold_event rssi_event,
9693 struct sk_buff *msg;
9694 struct nlattr *pinfoattr;
9697 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9701 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
9707 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9708 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
9709 goto nla_put_failure;
9711 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
9713 goto nla_put_failure;
9715 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
9717 goto nla_put_failure;
9719 nla_nest_end(msg, pinfoattr);
9721 genlmsg_end(msg, hdr);
9723 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9724 nl80211_mlme_mcgrp.id, gfp);
9728 genlmsg_cancel(msg, hdr);
9732 void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
9733 struct net_device *netdev, const u8 *bssid,
9734 const u8 *replay_ctr, gfp_t gfp)
9736 struct sk_buff *msg;
9737 struct nlattr *rekey_attr;
9740 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9744 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
9750 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9751 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9752 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
9753 goto nla_put_failure;
9755 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
9757 goto nla_put_failure;
9759 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
9760 NL80211_REPLAY_CTR_LEN, replay_ctr))
9761 goto nla_put_failure;
9763 nla_nest_end(msg, rekey_attr);
9765 genlmsg_end(msg, hdr);
9767 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9768 nl80211_mlme_mcgrp.id, gfp);
9772 genlmsg_cancel(msg, hdr);
9776 void nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
9777 struct net_device *netdev, int index,
9778 const u8 *bssid, bool preauth, gfp_t gfp)
9780 struct sk_buff *msg;
9781 struct nlattr *attr;
9784 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9788 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
9794 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9795 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
9796 goto nla_put_failure;
9798 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
9800 goto nla_put_failure;
9802 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
9803 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
9805 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
9806 goto nla_put_failure;
9808 nla_nest_end(msg, attr);
9810 genlmsg_end(msg, hdr);
9812 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9813 nl80211_mlme_mcgrp.id, gfp);
9817 genlmsg_cancel(msg, hdr);
9821 void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
9822 struct net_device *netdev,
9823 struct cfg80211_chan_def *chandef, gfp_t gfp)
9825 struct sk_buff *msg;
9828 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9832 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY);
9838 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
9839 goto nla_put_failure;
9841 if (nl80211_send_chandef(msg, chandef))
9842 goto nla_put_failure;
9844 genlmsg_end(msg, hdr);
9846 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9847 nl80211_mlme_mcgrp.id, gfp);
9851 genlmsg_cancel(msg, hdr);
9856 nl80211_send_cqm_txe_notify(struct cfg80211_registered_device *rdev,
9857 struct net_device *netdev, const u8 *peer,
9858 u32 num_packets, u32 rate, u32 intvl, gfp_t gfp)
9860 struct sk_buff *msg;
9861 struct nlattr *pinfoattr;
9864 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
9868 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
9874 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9875 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9876 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
9877 goto nla_put_failure;
9879 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
9881 goto nla_put_failure;
9883 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
9884 goto nla_put_failure;
9886 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
9887 goto nla_put_failure;
9889 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
9890 goto nla_put_failure;
9892 nla_nest_end(msg, pinfoattr);
9894 genlmsg_end(msg, hdr);
9896 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9897 nl80211_mlme_mcgrp.id, gfp);
9901 genlmsg_cancel(msg, hdr);
9906 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
9907 struct cfg80211_chan_def *chandef,
9908 enum nl80211_radar_event event,
9909 struct net_device *netdev, gfp_t gfp)
9911 struct sk_buff *msg;
9914 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9918 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
9924 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
9925 goto nla_put_failure;
9927 /* NOP and radar events don't need a netdev parameter */
9929 struct wireless_dev *wdev = netdev->ieee80211_ptr;
9931 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9932 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
9933 goto nla_put_failure;
9936 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
9937 goto nla_put_failure;
9939 if (nl80211_send_chandef(msg, chandef))
9940 goto nla_put_failure;
9942 if (genlmsg_end(msg, hdr) < 0) {
9947 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9948 nl80211_mlme_mcgrp.id, gfp);
9952 genlmsg_cancel(msg, hdr);
9957 nl80211_send_cqm_pktloss_notify(struct cfg80211_registered_device *rdev,
9958 struct net_device *netdev, const u8 *peer,
9959 u32 num_packets, gfp_t gfp)
9961 struct sk_buff *msg;
9962 struct nlattr *pinfoattr;
9965 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9969 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
9975 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9976 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9977 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
9978 goto nla_put_failure;
9980 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
9982 goto nla_put_failure;
9984 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
9985 goto nla_put_failure;
9987 nla_nest_end(msg, pinfoattr);
9989 genlmsg_end(msg, hdr);
9991 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9992 nl80211_mlme_mcgrp.id, gfp);
9996 genlmsg_cancel(msg, hdr);
10000 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
10001 u64 cookie, bool acked, gfp_t gfp)
10003 struct wireless_dev *wdev = dev->ieee80211_ptr;
10004 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10005 struct sk_buff *msg;
10009 trace_cfg80211_probe_status(dev, addr, cookie, acked);
10011 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10016 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
10022 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10023 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10024 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
10025 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
10026 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
10027 goto nla_put_failure;
10029 err = 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_probe_status);
10045 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
10046 const u8 *frame, size_t len,
10047 int freq, int sig_dbm)
10049 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10050 struct sk_buff *msg;
10052 struct cfg80211_beacon_registration *reg;
10054 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
10056 spin_lock_bh(&rdev->beacon_registrations_lock);
10057 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
10058 msg = nlmsg_new(len + 100, GFP_ATOMIC);
10060 spin_unlock_bh(&rdev->beacon_registrations_lock);
10064 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
10066 goto nla_put_failure;
10068 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10070 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
10072 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
10073 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
10074 goto nla_put_failure;
10076 genlmsg_end(msg, hdr);
10078 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
10080 spin_unlock_bh(&rdev->beacon_registrations_lock);
10084 spin_unlock_bh(&rdev->beacon_registrations_lock);
10086 genlmsg_cancel(msg, hdr);
10089 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
10092 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
10093 struct cfg80211_wowlan_wakeup *wakeup,
10096 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10097 struct sk_buff *msg;
10099 int err, size = 200;
10101 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
10104 size += wakeup->packet_present_len;
10106 msg = nlmsg_new(size, gfp);
10110 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
10114 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10115 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10118 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10119 wdev->netdev->ifindex))
10123 struct nlattr *reasons;
10125 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10127 if (wakeup->disconnect &&
10128 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
10130 if (wakeup->magic_pkt &&
10131 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
10133 if (wakeup->gtk_rekey_failure &&
10134 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
10136 if (wakeup->eap_identity_req &&
10137 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
10139 if (wakeup->four_way_handshake &&
10140 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
10142 if (wakeup->rfkill_release &&
10143 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
10146 if (wakeup->pattern_idx >= 0 &&
10147 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
10148 wakeup->pattern_idx))
10151 if (wakeup->tcp_match)
10152 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH);
10154 if (wakeup->tcp_connlost)
10156 NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST);
10158 if (wakeup->tcp_nomoretokens)
10160 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS);
10162 if (wakeup->packet) {
10163 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
10164 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
10166 if (!wakeup->packet_80211) {
10168 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
10170 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
10173 if (wakeup->packet_len &&
10174 nla_put_u32(msg, len_attr, wakeup->packet_len))
10177 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
10182 nla_nest_end(msg, reasons);
10185 err = genlmsg_end(msg, hdr);
10189 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10190 nl80211_mlme_mcgrp.id, gfp);
10196 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
10199 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
10200 enum nl80211_tdls_operation oper,
10201 u16 reason_code, gfp_t gfp)
10203 struct wireless_dev *wdev = dev->ieee80211_ptr;
10204 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10205 struct sk_buff *msg;
10209 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
10212 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10216 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
10222 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10223 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10224 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
10225 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
10226 (reason_code > 0 &&
10227 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
10228 goto nla_put_failure;
10230 err = genlmsg_end(msg, hdr);
10236 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10237 nl80211_mlme_mcgrp.id, gfp);
10241 genlmsg_cancel(msg, hdr);
10244 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
10246 static int nl80211_netlink_notify(struct notifier_block * nb,
10247 unsigned long state,
10250 struct netlink_notify *notify = _notify;
10251 struct cfg80211_registered_device *rdev;
10252 struct wireless_dev *wdev;
10253 struct cfg80211_beacon_registration *reg, *tmp;
10255 if (state != NETLINK_URELEASE)
10256 return NOTIFY_DONE;
10260 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
10261 list_for_each_entry_rcu(wdev, &rdev->wdev_list, list)
10262 cfg80211_mlme_unregister_socket(wdev, notify->portid);
10264 spin_lock_bh(&rdev->beacon_registrations_lock);
10265 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
10267 if (reg->nlportid == notify->portid) {
10268 list_del(®->list);
10273 spin_unlock_bh(&rdev->beacon_registrations_lock);
10278 return NOTIFY_DONE;
10281 static struct notifier_block nl80211_netlink_notifier = {
10282 .notifier_call = nl80211_netlink_notify,
10285 /* initialisation/exit functions */
10287 int nl80211_init(void)
10291 err = genl_register_family_with_ops(&nl80211_fam,
10292 nl80211_ops, ARRAY_SIZE(nl80211_ops));
10296 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
10300 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
10304 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
10308 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
10312 #ifdef CONFIG_NL80211_TESTMODE
10313 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
10318 err = netlink_register_notifier(&nl80211_netlink_notifier);
10324 genl_unregister_family(&nl80211_fam);
10328 void nl80211_exit(void)
10330 netlink_unregister_notifier(&nl80211_netlink_notifier);
10331 genl_unregister_family(&nl80211_fam);