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(const struct genl_ops
*ops
, struct sk_buff
*skb
,
34 struct genl_info
*info
);
35 static void nl80211_post_doit(const 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_GENL_NAME
, /* 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 /* multicast groups */
51 enum nl80211_multicast_groups
{
54 NL80211_MCGRP_REGULATORY
,
57 NL80211_MCGRP_TESTMODE
/* keep last - ifdef! */
60 static const struct genl_multicast_group nl80211_mcgrps
[] = {
61 [NL80211_MCGRP_CONFIG
] = { .name
= "config", },
62 [NL80211_MCGRP_SCAN
] = { .name
= "scan", },
63 [NL80211_MCGRP_REGULATORY
] = { .name
= "regulatory", },
64 [NL80211_MCGRP_MLME
] = { .name
= "mlme", },
65 [NL80211_MCGRP_VENDOR
] = { .name
= "vendor", },
66 #ifdef CONFIG_NL80211_TESTMODE
67 [NL80211_MCGRP_TESTMODE
] = { .name
= "testmode", }
71 /* returns ERR_PTR values */
72 static struct wireless_dev
*
73 __cfg80211_wdev_from_attrs(struct net
*netns
, struct nlattr
**attrs
)
75 struct cfg80211_registered_device
*rdev
;
76 struct wireless_dev
*result
= NULL
;
77 bool have_ifidx
= attrs
[NL80211_ATTR_IFINDEX
];
78 bool have_wdev_id
= attrs
[NL80211_ATTR_WDEV
];
85 if (!have_ifidx
&& !have_wdev_id
)
86 return ERR_PTR(-EINVAL
);
89 ifidx
= nla_get_u32(attrs
[NL80211_ATTR_IFINDEX
]);
91 wdev_id
= nla_get_u64(attrs
[NL80211_ATTR_WDEV
]);
92 wiphy_idx
= wdev_id
>> 32;
95 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
96 struct wireless_dev
*wdev
;
98 if (wiphy_net(&rdev
->wiphy
) != netns
)
101 if (have_wdev_id
&& rdev
->wiphy_idx
!= wiphy_idx
)
104 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
105 if (have_ifidx
&& wdev
->netdev
&&
106 wdev
->netdev
->ifindex
== ifidx
) {
110 if (have_wdev_id
&& wdev
->identifier
== (u32
)wdev_id
) {
122 return ERR_PTR(-ENODEV
);
125 static struct cfg80211_registered_device
*
126 __cfg80211_rdev_from_attrs(struct net
*netns
, struct nlattr
**attrs
)
128 struct cfg80211_registered_device
*rdev
= NULL
, *tmp
;
129 struct net_device
*netdev
;
133 if (!attrs
[NL80211_ATTR_WIPHY
] &&
134 !attrs
[NL80211_ATTR_IFINDEX
] &&
135 !attrs
[NL80211_ATTR_WDEV
])
136 return ERR_PTR(-EINVAL
);
138 if (attrs
[NL80211_ATTR_WIPHY
])
139 rdev
= cfg80211_rdev_by_wiphy_idx(
140 nla_get_u32(attrs
[NL80211_ATTR_WIPHY
]));
142 if (attrs
[NL80211_ATTR_WDEV
]) {
143 u64 wdev_id
= nla_get_u64(attrs
[NL80211_ATTR_WDEV
]);
144 struct wireless_dev
*wdev
;
147 tmp
= cfg80211_rdev_by_wiphy_idx(wdev_id
>> 32);
149 /* make sure wdev exists */
150 list_for_each_entry(wdev
, &tmp
->wdev_list
, list
) {
151 if (wdev
->identifier
!= (u32
)wdev_id
)
160 if (rdev
&& tmp
!= rdev
)
161 return ERR_PTR(-EINVAL
);
166 if (attrs
[NL80211_ATTR_IFINDEX
]) {
167 int ifindex
= nla_get_u32(attrs
[NL80211_ATTR_IFINDEX
]);
168 netdev
= __dev_get_by_index(netns
, ifindex
);
170 if (netdev
->ieee80211_ptr
)
172 netdev
->ieee80211_ptr
->wiphy
);
176 /* not wireless device -- return error */
178 return ERR_PTR(-EINVAL
);
180 /* mismatch -- return error */
181 if (rdev
&& tmp
!= rdev
)
182 return ERR_PTR(-EINVAL
);
189 return ERR_PTR(-ENODEV
);
191 if (netns
!= wiphy_net(&rdev
->wiphy
))
192 return ERR_PTR(-ENODEV
);
198 * This function returns a pointer to the driver
199 * that the genl_info item that is passed refers to.
201 * The result of this can be a PTR_ERR and hence must
202 * be checked with IS_ERR() for errors.
204 static struct cfg80211_registered_device
*
205 cfg80211_get_dev_from_info(struct net
*netns
, struct genl_info
*info
)
207 return __cfg80211_rdev_from_attrs(netns
, info
->attrs
);
210 /* policy for the attributes */
211 static const struct nla_policy nl80211_policy
[NL80211_ATTR_MAX
+1] = {
212 [NL80211_ATTR_WIPHY
] = { .type
= NLA_U32
},
213 [NL80211_ATTR_WIPHY_NAME
] = { .type
= NLA_NUL_STRING
,
215 [NL80211_ATTR_WIPHY_TXQ_PARAMS
] = { .type
= NLA_NESTED
},
217 [NL80211_ATTR_WIPHY_FREQ
] = { .type
= NLA_U32
},
218 [NL80211_ATTR_WIPHY_CHANNEL_TYPE
] = { .type
= NLA_U32
},
219 [NL80211_ATTR_CHANNEL_WIDTH
] = { .type
= NLA_U32
},
220 [NL80211_ATTR_CENTER_FREQ1
] = { .type
= NLA_U32
},
221 [NL80211_ATTR_CENTER_FREQ2
] = { .type
= NLA_U32
},
223 [NL80211_ATTR_WIPHY_RETRY_SHORT
] = { .type
= NLA_U8
},
224 [NL80211_ATTR_WIPHY_RETRY_LONG
] = { .type
= NLA_U8
},
225 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD
] = { .type
= NLA_U32
},
226 [NL80211_ATTR_WIPHY_RTS_THRESHOLD
] = { .type
= NLA_U32
},
227 [NL80211_ATTR_WIPHY_COVERAGE_CLASS
] = { .type
= NLA_U8
},
229 [NL80211_ATTR_IFTYPE
] = { .type
= NLA_U32
},
230 [NL80211_ATTR_IFINDEX
] = { .type
= NLA_U32
},
231 [NL80211_ATTR_IFNAME
] = { .type
= NLA_NUL_STRING
, .len
= IFNAMSIZ
-1 },
233 [NL80211_ATTR_MAC
] = { .len
= ETH_ALEN
},
234 [NL80211_ATTR_PREV_BSSID
] = { .len
= ETH_ALEN
},
236 [NL80211_ATTR_KEY
] = { .type
= NLA_NESTED
, },
237 [NL80211_ATTR_KEY_DATA
] = { .type
= NLA_BINARY
,
238 .len
= WLAN_MAX_KEY_LEN
},
239 [NL80211_ATTR_KEY_IDX
] = { .type
= NLA_U8
},
240 [NL80211_ATTR_KEY_CIPHER
] = { .type
= NLA_U32
},
241 [NL80211_ATTR_KEY_DEFAULT
] = { .type
= NLA_FLAG
},
242 [NL80211_ATTR_KEY_SEQ
] = { .type
= NLA_BINARY
, .len
= 16 },
243 [NL80211_ATTR_KEY_TYPE
] = { .type
= NLA_U32
},
245 [NL80211_ATTR_BEACON_INTERVAL
] = { .type
= NLA_U32
},
246 [NL80211_ATTR_DTIM_PERIOD
] = { .type
= NLA_U32
},
247 [NL80211_ATTR_BEACON_HEAD
] = { .type
= NLA_BINARY
,
248 .len
= IEEE80211_MAX_DATA_LEN
},
249 [NL80211_ATTR_BEACON_TAIL
] = { .type
= NLA_BINARY
,
250 .len
= IEEE80211_MAX_DATA_LEN
},
251 [NL80211_ATTR_STA_AID
] = { .type
= NLA_U16
},
252 [NL80211_ATTR_STA_FLAGS
] = { .type
= NLA_NESTED
},
253 [NL80211_ATTR_STA_LISTEN_INTERVAL
] = { .type
= NLA_U16
},
254 [NL80211_ATTR_STA_SUPPORTED_RATES
] = { .type
= NLA_BINARY
,
255 .len
= NL80211_MAX_SUPP_RATES
},
256 [NL80211_ATTR_STA_PLINK_ACTION
] = { .type
= NLA_U8
},
257 [NL80211_ATTR_STA_VLAN
] = { .type
= NLA_U32
},
258 [NL80211_ATTR_MNTR_FLAGS
] = { /* NLA_NESTED can't be empty */ },
259 [NL80211_ATTR_MESH_ID
] = { .type
= NLA_BINARY
,
260 .len
= IEEE80211_MAX_MESH_ID_LEN
},
261 [NL80211_ATTR_MPATH_NEXT_HOP
] = { .type
= NLA_U32
},
263 [NL80211_ATTR_REG_ALPHA2
] = { .type
= NLA_STRING
, .len
= 2 },
264 [NL80211_ATTR_REG_RULES
] = { .type
= NLA_NESTED
},
266 [NL80211_ATTR_BSS_CTS_PROT
] = { .type
= NLA_U8
},
267 [NL80211_ATTR_BSS_SHORT_PREAMBLE
] = { .type
= NLA_U8
},
268 [NL80211_ATTR_BSS_SHORT_SLOT_TIME
] = { .type
= NLA_U8
},
269 [NL80211_ATTR_BSS_BASIC_RATES
] = { .type
= NLA_BINARY
,
270 .len
= NL80211_MAX_SUPP_RATES
},
271 [NL80211_ATTR_BSS_HT_OPMODE
] = { .type
= NLA_U16
},
273 [NL80211_ATTR_MESH_CONFIG
] = { .type
= NLA_NESTED
},
274 [NL80211_ATTR_SUPPORT_MESH_AUTH
] = { .type
= NLA_FLAG
},
276 [NL80211_ATTR_HT_CAPABILITY
] = { .len
= NL80211_HT_CAPABILITY_LEN
},
278 [NL80211_ATTR_MGMT_SUBTYPE
] = { .type
= NLA_U8
},
279 [NL80211_ATTR_IE
] = { .type
= NLA_BINARY
,
280 .len
= IEEE80211_MAX_DATA_LEN
},
281 [NL80211_ATTR_SCAN_FREQUENCIES
] = { .type
= NLA_NESTED
},
282 [NL80211_ATTR_SCAN_SSIDS
] = { .type
= NLA_NESTED
},
284 [NL80211_ATTR_SSID
] = { .type
= NLA_BINARY
,
285 .len
= IEEE80211_MAX_SSID_LEN
},
286 [NL80211_ATTR_AUTH_TYPE
] = { .type
= NLA_U32
},
287 [NL80211_ATTR_REASON_CODE
] = { .type
= NLA_U16
},
288 [NL80211_ATTR_FREQ_FIXED
] = { .type
= NLA_FLAG
},
289 [NL80211_ATTR_TIMED_OUT
] = { .type
= NLA_FLAG
},
290 [NL80211_ATTR_USE_MFP
] = { .type
= NLA_U32
},
291 [NL80211_ATTR_STA_FLAGS2
] = {
292 .len
= sizeof(struct nl80211_sta_flag_update
),
294 [NL80211_ATTR_CONTROL_PORT
] = { .type
= NLA_FLAG
},
295 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE
] = { .type
= NLA_U16
},
296 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
] = { .type
= NLA_FLAG
},
297 [NL80211_ATTR_PRIVACY
] = { .type
= NLA_FLAG
},
298 [NL80211_ATTR_CIPHER_SUITE_GROUP
] = { .type
= NLA_U32
},
299 [NL80211_ATTR_WPA_VERSIONS
] = { .type
= NLA_U32
},
300 [NL80211_ATTR_PID
] = { .type
= NLA_U32
},
301 [NL80211_ATTR_4ADDR
] = { .type
= NLA_U8
},
302 [NL80211_ATTR_PMKID
] = { .type
= NLA_BINARY
,
303 .len
= WLAN_PMKID_LEN
},
304 [NL80211_ATTR_DURATION
] = { .type
= NLA_U32
},
305 [NL80211_ATTR_COOKIE
] = { .type
= NLA_U64
},
306 [NL80211_ATTR_TX_RATES
] = { .type
= NLA_NESTED
},
307 [NL80211_ATTR_FRAME
] = { .type
= NLA_BINARY
,
308 .len
= IEEE80211_MAX_DATA_LEN
},
309 [NL80211_ATTR_FRAME_MATCH
] = { .type
= NLA_BINARY
, },
310 [NL80211_ATTR_PS_STATE
] = { .type
= NLA_U32
},
311 [NL80211_ATTR_CQM
] = { .type
= NLA_NESTED
, },
312 [NL80211_ATTR_LOCAL_STATE_CHANGE
] = { .type
= NLA_FLAG
},
313 [NL80211_ATTR_AP_ISOLATE
] = { .type
= NLA_U8
},
314 [NL80211_ATTR_WIPHY_TX_POWER_SETTING
] = { .type
= NLA_U32
},
315 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL
] = { .type
= NLA_U32
},
316 [NL80211_ATTR_FRAME_TYPE
] = { .type
= NLA_U16
},
317 [NL80211_ATTR_WIPHY_ANTENNA_TX
] = { .type
= NLA_U32
},
318 [NL80211_ATTR_WIPHY_ANTENNA_RX
] = { .type
= NLA_U32
},
319 [NL80211_ATTR_MCAST_RATE
] = { .type
= NLA_U32
},
320 [NL80211_ATTR_OFFCHANNEL_TX_OK
] = { .type
= NLA_FLAG
},
321 [NL80211_ATTR_KEY_DEFAULT_TYPES
] = { .type
= NLA_NESTED
},
322 [NL80211_ATTR_WOWLAN_TRIGGERS
] = { .type
= NLA_NESTED
},
323 [NL80211_ATTR_STA_PLINK_STATE
] = { .type
= NLA_U8
},
324 [NL80211_ATTR_SCHED_SCAN_INTERVAL
] = { .type
= NLA_U32
},
325 [NL80211_ATTR_REKEY_DATA
] = { .type
= NLA_NESTED
},
326 [NL80211_ATTR_SCAN_SUPP_RATES
] = { .type
= NLA_NESTED
},
327 [NL80211_ATTR_HIDDEN_SSID
] = { .type
= NLA_U32
},
328 [NL80211_ATTR_IE_PROBE_RESP
] = { .type
= NLA_BINARY
,
329 .len
= IEEE80211_MAX_DATA_LEN
},
330 [NL80211_ATTR_IE_ASSOC_RESP
] = { .type
= NLA_BINARY
,
331 .len
= IEEE80211_MAX_DATA_LEN
},
332 [NL80211_ATTR_ROAM_SUPPORT
] = { .type
= NLA_FLAG
},
333 [NL80211_ATTR_SCHED_SCAN_MATCH
] = { .type
= NLA_NESTED
},
334 [NL80211_ATTR_TX_NO_CCK_RATE
] = { .type
= NLA_FLAG
},
335 [NL80211_ATTR_TDLS_ACTION
] = { .type
= NLA_U8
},
336 [NL80211_ATTR_TDLS_DIALOG_TOKEN
] = { .type
= NLA_U8
},
337 [NL80211_ATTR_TDLS_OPERATION
] = { .type
= NLA_U8
},
338 [NL80211_ATTR_TDLS_SUPPORT
] = { .type
= NLA_FLAG
},
339 [NL80211_ATTR_TDLS_EXTERNAL_SETUP
] = { .type
= NLA_FLAG
},
340 [NL80211_ATTR_DONT_WAIT_FOR_ACK
] = { .type
= NLA_FLAG
},
341 [NL80211_ATTR_PROBE_RESP
] = { .type
= NLA_BINARY
,
342 .len
= IEEE80211_MAX_DATA_LEN
},
343 [NL80211_ATTR_DFS_REGION
] = { .type
= NLA_U8
},
344 [NL80211_ATTR_DISABLE_HT
] = { .type
= NLA_FLAG
},
345 [NL80211_ATTR_HT_CAPABILITY_MASK
] = {
346 .len
= NL80211_HT_CAPABILITY_LEN
348 [NL80211_ATTR_NOACK_MAP
] = { .type
= NLA_U16
},
349 [NL80211_ATTR_INACTIVITY_TIMEOUT
] = { .type
= NLA_U16
},
350 [NL80211_ATTR_BG_SCAN_PERIOD
] = { .type
= NLA_U16
},
351 [NL80211_ATTR_WDEV
] = { .type
= NLA_U64
},
352 [NL80211_ATTR_USER_REG_HINT_TYPE
] = { .type
= NLA_U32
},
353 [NL80211_ATTR_SAE_DATA
] = { .type
= NLA_BINARY
, },
354 [NL80211_ATTR_VHT_CAPABILITY
] = { .len
= NL80211_VHT_CAPABILITY_LEN
},
355 [NL80211_ATTR_SCAN_FLAGS
] = { .type
= NLA_U32
},
356 [NL80211_ATTR_P2P_CTWINDOW
] = { .type
= NLA_U8
},
357 [NL80211_ATTR_P2P_OPPPS
] = { .type
= NLA_U8
},
358 [NL80211_ATTR_ACL_POLICY
] = {. type
= NLA_U32
},
359 [NL80211_ATTR_MAC_ADDRS
] = { .type
= NLA_NESTED
},
360 [NL80211_ATTR_STA_CAPABILITY
] = { .type
= NLA_U16
},
361 [NL80211_ATTR_STA_EXT_CAPABILITY
] = { .type
= NLA_BINARY
, },
362 [NL80211_ATTR_SPLIT_WIPHY_DUMP
] = { .type
= NLA_FLAG
, },
363 [NL80211_ATTR_DISABLE_VHT
] = { .type
= NLA_FLAG
},
364 [NL80211_ATTR_VHT_CAPABILITY_MASK
] = {
365 .len
= NL80211_VHT_CAPABILITY_LEN
,
367 [NL80211_ATTR_MDID
] = { .type
= NLA_U16
},
368 [NL80211_ATTR_IE_RIC
] = { .type
= NLA_BINARY
,
369 .len
= IEEE80211_MAX_DATA_LEN
},
370 [NL80211_ATTR_PEER_AID
] = { .type
= NLA_U16
},
371 [NL80211_ATTR_CH_SWITCH_COUNT
] = { .type
= NLA_U32
},
372 [NL80211_ATTR_CH_SWITCH_BLOCK_TX
] = { .type
= NLA_FLAG
},
373 [NL80211_ATTR_CSA_IES
] = { .type
= NLA_NESTED
},
374 [NL80211_ATTR_CSA_C_OFF_BEACON
] = { .type
= NLA_U16
},
375 [NL80211_ATTR_CSA_C_OFF_PRESP
] = { .type
= NLA_U16
},
376 [NL80211_ATTR_STA_SUPPORTED_CHANNELS
] = { .type
= NLA_BINARY
},
377 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
] = { .type
= NLA_BINARY
},
378 [NL80211_ATTR_HANDLE_DFS
] = { .type
= NLA_FLAG
},
379 [NL80211_ATTR_OPMODE_NOTIF
] = { .type
= NLA_U8
},
380 [NL80211_ATTR_VENDOR_ID
] = { .type
= NLA_U32
},
381 [NL80211_ATTR_VENDOR_SUBCMD
] = { .type
= NLA_U32
},
382 [NL80211_ATTR_VENDOR_DATA
] = { .type
= NLA_BINARY
},
383 [NL80211_ATTR_QOS_MAP
] = { .type
= NLA_BINARY
,
384 .len
= IEEE80211_QOS_MAP_LEN_MAX
},
385 [NL80211_ATTR_MAC_HINT
] = { .len
= ETH_ALEN
},
386 [NL80211_ATTR_WIPHY_FREQ_HINT
] = { .type
= NLA_U32
},
389 /* policy for the key attributes */
390 static const struct nla_policy nl80211_key_policy
[NL80211_KEY_MAX
+ 1] = {
391 [NL80211_KEY_DATA
] = { .type
= NLA_BINARY
, .len
= WLAN_MAX_KEY_LEN
},
392 [NL80211_KEY_IDX
] = { .type
= NLA_U8
},
393 [NL80211_KEY_CIPHER
] = { .type
= NLA_U32
},
394 [NL80211_KEY_SEQ
] = { .type
= NLA_BINARY
, .len
= 16 },
395 [NL80211_KEY_DEFAULT
] = { .type
= NLA_FLAG
},
396 [NL80211_KEY_DEFAULT_MGMT
] = { .type
= NLA_FLAG
},
397 [NL80211_KEY_TYPE
] = { .type
= NLA_U32
},
398 [NL80211_KEY_DEFAULT_TYPES
] = { .type
= NLA_NESTED
},
401 /* policy for the key default flags */
402 static const struct nla_policy
403 nl80211_key_default_policy
[NUM_NL80211_KEY_DEFAULT_TYPES
] = {
404 [NL80211_KEY_DEFAULT_TYPE_UNICAST
] = { .type
= NLA_FLAG
},
405 [NL80211_KEY_DEFAULT_TYPE_MULTICAST
] = { .type
= NLA_FLAG
},
408 /* policy for WoWLAN attributes */
409 static const struct nla_policy
410 nl80211_wowlan_policy
[NUM_NL80211_WOWLAN_TRIG
] = {
411 [NL80211_WOWLAN_TRIG_ANY
] = { .type
= NLA_FLAG
},
412 [NL80211_WOWLAN_TRIG_DISCONNECT
] = { .type
= NLA_FLAG
},
413 [NL80211_WOWLAN_TRIG_MAGIC_PKT
] = { .type
= NLA_FLAG
},
414 [NL80211_WOWLAN_TRIG_PKT_PATTERN
] = { .type
= NLA_NESTED
},
415 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
] = { .type
= NLA_FLAG
},
416 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
] = { .type
= NLA_FLAG
},
417 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
] = { .type
= NLA_FLAG
},
418 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE
] = { .type
= NLA_FLAG
},
419 [NL80211_WOWLAN_TRIG_TCP_CONNECTION
] = { .type
= NLA_NESTED
},
422 static const struct nla_policy
423 nl80211_wowlan_tcp_policy
[NUM_NL80211_WOWLAN_TCP
] = {
424 [NL80211_WOWLAN_TCP_SRC_IPV4
] = { .type
= NLA_U32
},
425 [NL80211_WOWLAN_TCP_DST_IPV4
] = { .type
= NLA_U32
},
426 [NL80211_WOWLAN_TCP_DST_MAC
] = { .len
= ETH_ALEN
},
427 [NL80211_WOWLAN_TCP_SRC_PORT
] = { .type
= NLA_U16
},
428 [NL80211_WOWLAN_TCP_DST_PORT
] = { .type
= NLA_U16
},
429 [NL80211_WOWLAN_TCP_DATA_PAYLOAD
] = { .len
= 1 },
430 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
] = {
431 .len
= sizeof(struct nl80211_wowlan_tcp_data_seq
)
433 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
] = {
434 .len
= sizeof(struct nl80211_wowlan_tcp_data_token
)
436 [NL80211_WOWLAN_TCP_DATA_INTERVAL
] = { .type
= NLA_U32
},
437 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD
] = { .len
= 1 },
438 [NL80211_WOWLAN_TCP_WAKE_MASK
] = { .len
= 1 },
441 /* policy for coalesce rule attributes */
442 static const struct nla_policy
443 nl80211_coalesce_policy
[NUM_NL80211_ATTR_COALESCE_RULE
] = {
444 [NL80211_ATTR_COALESCE_RULE_DELAY
] = { .type
= NLA_U32
},
445 [NL80211_ATTR_COALESCE_RULE_CONDITION
] = { .type
= NLA_U32
},
446 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
] = { .type
= NLA_NESTED
},
449 /* policy for GTK rekey offload attributes */
450 static const struct nla_policy
451 nl80211_rekey_policy
[NUM_NL80211_REKEY_DATA
] = {
452 [NL80211_REKEY_DATA_KEK
] = { .len
= NL80211_KEK_LEN
},
453 [NL80211_REKEY_DATA_KCK
] = { .len
= NL80211_KCK_LEN
},
454 [NL80211_REKEY_DATA_REPLAY_CTR
] = { .len
= NL80211_REPLAY_CTR_LEN
},
457 static const struct nla_policy
458 nl80211_match_policy
[NL80211_SCHED_SCAN_MATCH_ATTR_MAX
+ 1] = {
459 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID
] = { .type
= NLA_BINARY
,
460 .len
= IEEE80211_MAX_SSID_LEN
},
461 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
] = { .type
= NLA_U32
},
464 static int nl80211_prepare_wdev_dump(struct sk_buff
*skb
,
465 struct netlink_callback
*cb
,
466 struct cfg80211_registered_device
**rdev
,
467 struct wireless_dev
**wdev
)
474 err
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
475 nl80211_fam
.attrbuf
, nl80211_fam
.maxattr
,
480 *wdev
= __cfg80211_wdev_from_attrs(sock_net(skb
->sk
),
481 nl80211_fam
.attrbuf
);
483 err
= PTR_ERR(*wdev
);
486 *rdev
= wiphy_to_dev((*wdev
)->wiphy
);
487 /* 0 is the first index - add 1 to parse only once */
488 cb
->args
[0] = (*rdev
)->wiphy_idx
+ 1;
489 cb
->args
[1] = (*wdev
)->identifier
;
491 /* subtract the 1 again here */
492 struct wiphy
*wiphy
= wiphy_idx_to_wiphy(cb
->args
[0] - 1);
493 struct wireless_dev
*tmp
;
499 *rdev
= wiphy_to_dev(wiphy
);
502 list_for_each_entry(tmp
, &(*rdev
)->wdev_list
, list
) {
503 if (tmp
->identifier
== cb
->args
[1]) {
521 static void nl80211_finish_wdev_dump(struct cfg80211_registered_device
*rdev
)
527 static bool is_valid_ie_attr(const struct nlattr
*attr
)
535 pos
= nla_data(attr
);
556 /* message building helper */
557 static inline void *nl80211hdr_put(struct sk_buff
*skb
, u32 portid
, u32 seq
,
560 /* since there is no private header just add the generic one */
561 return genlmsg_put(skb
, portid
, seq
, &nl80211_fam
, flags
, cmd
);
564 static int nl80211_msg_put_channel(struct sk_buff
*msg
,
565 struct ieee80211_channel
*chan
,
568 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_FREQ
,
570 goto nla_put_failure
;
572 if ((chan
->flags
& IEEE80211_CHAN_DISABLED
) &&
573 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_DISABLED
))
574 goto nla_put_failure
;
575 if (chan
->flags
& IEEE80211_CHAN_NO_IR
) {
576 if (nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_IR
))
577 goto nla_put_failure
;
578 if (nla_put_flag(msg
, __NL80211_FREQUENCY_ATTR_NO_IBSS
))
579 goto nla_put_failure
;
581 if (chan
->flags
& IEEE80211_CHAN_RADAR
) {
582 if (nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_RADAR
))
583 goto nla_put_failure
;
587 time
= elapsed_jiffies_msecs(chan
->dfs_state_entered
);
589 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_DFS_STATE
,
591 goto nla_put_failure
;
592 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_DFS_TIME
,
594 goto nla_put_failure
;
599 if ((chan
->flags
& IEEE80211_CHAN_NO_HT40MINUS
) &&
600 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS
))
601 goto nla_put_failure
;
602 if ((chan
->flags
& IEEE80211_CHAN_NO_HT40PLUS
) &&
603 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS
))
604 goto nla_put_failure
;
605 if ((chan
->flags
& IEEE80211_CHAN_NO_80MHZ
) &&
606 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_80MHZ
))
607 goto nla_put_failure
;
608 if ((chan
->flags
& IEEE80211_CHAN_NO_160MHZ
) &&
609 nla_put_flag(msg
, NL80211_FREQUENCY_ATTR_NO_160MHZ
))
610 goto nla_put_failure
;
613 if (nla_put_u32(msg
, NL80211_FREQUENCY_ATTR_MAX_TX_POWER
,
614 DBM_TO_MBM(chan
->max_power
)))
615 goto nla_put_failure
;
623 /* netlink command implementations */
630 bool def_uni
, def_multi
;
633 static int nl80211_parse_key_new(struct nlattr
*key
, struct key_parse
*k
)
635 struct nlattr
*tb
[NL80211_KEY_MAX
+ 1];
636 int err
= nla_parse_nested(tb
, NL80211_KEY_MAX
, key
,
641 k
->def
= !!tb
[NL80211_KEY_DEFAULT
];
642 k
->defmgmt
= !!tb
[NL80211_KEY_DEFAULT_MGMT
];
651 if (tb
[NL80211_KEY_IDX
])
652 k
->idx
= nla_get_u8(tb
[NL80211_KEY_IDX
]);
654 if (tb
[NL80211_KEY_DATA
]) {
655 k
->p
.key
= nla_data(tb
[NL80211_KEY_DATA
]);
656 k
->p
.key_len
= nla_len(tb
[NL80211_KEY_DATA
]);
659 if (tb
[NL80211_KEY_SEQ
]) {
660 k
->p
.seq
= nla_data(tb
[NL80211_KEY_SEQ
]);
661 k
->p
.seq_len
= nla_len(tb
[NL80211_KEY_SEQ
]);
664 if (tb
[NL80211_KEY_CIPHER
])
665 k
->p
.cipher
= nla_get_u32(tb
[NL80211_KEY_CIPHER
]);
667 if (tb
[NL80211_KEY_TYPE
]) {
668 k
->type
= nla_get_u32(tb
[NL80211_KEY_TYPE
]);
669 if (k
->type
< 0 || k
->type
>= NUM_NL80211_KEYTYPES
)
673 if (tb
[NL80211_KEY_DEFAULT_TYPES
]) {
674 struct nlattr
*kdt
[NUM_NL80211_KEY_DEFAULT_TYPES
];
675 err
= nla_parse_nested(kdt
, NUM_NL80211_KEY_DEFAULT_TYPES
- 1,
676 tb
[NL80211_KEY_DEFAULT_TYPES
],
677 nl80211_key_default_policy
);
681 k
->def_uni
= kdt
[NL80211_KEY_DEFAULT_TYPE_UNICAST
];
682 k
->def_multi
= kdt
[NL80211_KEY_DEFAULT_TYPE_MULTICAST
];
688 static int nl80211_parse_key_old(struct genl_info
*info
, struct key_parse
*k
)
690 if (info
->attrs
[NL80211_ATTR_KEY_DATA
]) {
691 k
->p
.key
= nla_data(info
->attrs
[NL80211_ATTR_KEY_DATA
]);
692 k
->p
.key_len
= nla_len(info
->attrs
[NL80211_ATTR_KEY_DATA
]);
695 if (info
->attrs
[NL80211_ATTR_KEY_SEQ
]) {
696 k
->p
.seq
= nla_data(info
->attrs
[NL80211_ATTR_KEY_SEQ
]);
697 k
->p
.seq_len
= nla_len(info
->attrs
[NL80211_ATTR_KEY_SEQ
]);
700 if (info
->attrs
[NL80211_ATTR_KEY_IDX
])
701 k
->idx
= nla_get_u8(info
->attrs
[NL80211_ATTR_KEY_IDX
]);
703 if (info
->attrs
[NL80211_ATTR_KEY_CIPHER
])
704 k
->p
.cipher
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_CIPHER
]);
706 k
->def
= !!info
->attrs
[NL80211_ATTR_KEY_DEFAULT
];
707 k
->defmgmt
= !!info
->attrs
[NL80211_ATTR_KEY_DEFAULT_MGMT
];
716 if (info
->attrs
[NL80211_ATTR_KEY_TYPE
]) {
717 k
->type
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_TYPE
]);
718 if (k
->type
< 0 || k
->type
>= NUM_NL80211_KEYTYPES
)
722 if (info
->attrs
[NL80211_ATTR_KEY_DEFAULT_TYPES
]) {
723 struct nlattr
*kdt
[NUM_NL80211_KEY_DEFAULT_TYPES
];
724 int err
= nla_parse_nested(
725 kdt
, NUM_NL80211_KEY_DEFAULT_TYPES
- 1,
726 info
->attrs
[NL80211_ATTR_KEY_DEFAULT_TYPES
],
727 nl80211_key_default_policy
);
731 k
->def_uni
= kdt
[NL80211_KEY_DEFAULT_TYPE_UNICAST
];
732 k
->def_multi
= kdt
[NL80211_KEY_DEFAULT_TYPE_MULTICAST
];
738 static int nl80211_parse_key(struct genl_info
*info
, struct key_parse
*k
)
742 memset(k
, 0, sizeof(*k
));
746 if (info
->attrs
[NL80211_ATTR_KEY
])
747 err
= nl80211_parse_key_new(info
->attrs
[NL80211_ATTR_KEY
], k
);
749 err
= nl80211_parse_key_old(info
, k
);
754 if (k
->def
&& k
->defmgmt
)
758 if (k
->def_uni
|| !k
->def_multi
)
764 if (k
->idx
< 4 || k
->idx
> 5)
767 if (k
->idx
< 0 || k
->idx
> 3)
770 if (k
->idx
< 0 || k
->idx
> 5)
778 static struct cfg80211_cached_keys
*
779 nl80211_parse_connkeys(struct cfg80211_registered_device
*rdev
,
780 struct nlattr
*keys
, bool *no_ht
)
782 struct key_parse parse
;
784 struct cfg80211_cached_keys
*result
;
785 int rem
, err
, def
= 0;
787 result
= kzalloc(sizeof(*result
), GFP_KERNEL
);
789 return ERR_PTR(-ENOMEM
);
792 result
->defmgmt
= -1;
794 nla_for_each_nested(key
, keys
, rem
) {
795 memset(&parse
, 0, sizeof(parse
));
798 err
= nl80211_parse_key_new(key
, &parse
);
804 if (parse
.idx
< 0 || parse
.idx
> 4)
810 result
->def
= parse
.idx
;
811 if (!parse
.def_uni
|| !parse
.def_multi
)
813 } else if (parse
.defmgmt
)
815 err
= cfg80211_validate_key_settings(rdev
, &parse
.p
,
816 parse
.idx
, false, NULL
);
819 result
->params
[parse
.idx
].cipher
= parse
.p
.cipher
;
820 result
->params
[parse
.idx
].key_len
= parse
.p
.key_len
;
821 result
->params
[parse
.idx
].key
= result
->data
[parse
.idx
];
822 memcpy(result
->data
[parse
.idx
], parse
.p
.key
, parse
.p
.key_len
);
824 if (parse
.p
.cipher
== WLAN_CIPHER_SUITE_WEP40
||
825 parse
.p
.cipher
== WLAN_CIPHER_SUITE_WEP104
) {
837 static int nl80211_key_allowed(struct wireless_dev
*wdev
)
839 ASSERT_WDEV_LOCK(wdev
);
841 switch (wdev
->iftype
) {
842 case NL80211_IFTYPE_AP
:
843 case NL80211_IFTYPE_AP_VLAN
:
844 case NL80211_IFTYPE_P2P_GO
:
845 case NL80211_IFTYPE_MESH_POINT
:
847 case NL80211_IFTYPE_ADHOC
:
848 case NL80211_IFTYPE_STATION
:
849 case NL80211_IFTYPE_P2P_CLIENT
:
850 if (!wdev
->current_bss
)
860 static int nl80211_put_iftypes(struct sk_buff
*msg
, u32 attr
, u16 ifmodes
)
862 struct nlattr
*nl_modes
= nla_nest_start(msg
, attr
);
866 goto nla_put_failure
;
870 if ((ifmodes
& 1) && nla_put_flag(msg
, i
))
871 goto nla_put_failure
;
876 nla_nest_end(msg
, nl_modes
);
883 static int nl80211_put_iface_combinations(struct wiphy
*wiphy
,
887 struct nlattr
*nl_combis
;
890 nl_combis
= nla_nest_start(msg
,
891 NL80211_ATTR_INTERFACE_COMBINATIONS
);
893 goto nla_put_failure
;
895 for (i
= 0; i
< wiphy
->n_iface_combinations
; i
++) {
896 const struct ieee80211_iface_combination
*c
;
897 struct nlattr
*nl_combi
, *nl_limits
;
899 c
= &wiphy
->iface_combinations
[i
];
901 nl_combi
= nla_nest_start(msg
, i
+ 1);
903 goto nla_put_failure
;
905 nl_limits
= nla_nest_start(msg
, NL80211_IFACE_COMB_LIMITS
);
907 goto nla_put_failure
;
909 for (j
= 0; j
< c
->n_limits
; j
++) {
910 struct nlattr
*nl_limit
;
912 nl_limit
= nla_nest_start(msg
, j
+ 1);
914 goto nla_put_failure
;
915 if (nla_put_u32(msg
, NL80211_IFACE_LIMIT_MAX
,
917 goto nla_put_failure
;
918 if (nl80211_put_iftypes(msg
, NL80211_IFACE_LIMIT_TYPES
,
920 goto nla_put_failure
;
921 nla_nest_end(msg
, nl_limit
);
924 nla_nest_end(msg
, nl_limits
);
926 if (c
->beacon_int_infra_match
&&
927 nla_put_flag(msg
, NL80211_IFACE_COMB_STA_AP_BI_MATCH
))
928 goto nla_put_failure
;
929 if (nla_put_u32(msg
, NL80211_IFACE_COMB_NUM_CHANNELS
,
930 c
->num_different_channels
) ||
931 nla_put_u32(msg
, NL80211_IFACE_COMB_MAXNUM
,
933 goto nla_put_failure
;
935 nla_put_u32(msg
, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS
,
936 c
->radar_detect_widths
))
937 goto nla_put_failure
;
939 nla_nest_end(msg
, nl_combi
);
942 nla_nest_end(msg
, nl_combis
);
950 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device
*rdev
,
953 const struct wiphy_wowlan_tcp_support
*tcp
= rdev
->wiphy
.wowlan
->tcp
;
954 struct nlattr
*nl_tcp
;
959 nl_tcp
= nla_nest_start(msg
, NL80211_WOWLAN_TRIG_TCP_CONNECTION
);
963 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD
,
964 tcp
->data_payload_max
))
967 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD
,
968 tcp
->data_payload_max
))
971 if (tcp
->seq
&& nla_put_flag(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
))
974 if (tcp
->tok
&& nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
,
975 sizeof(*tcp
->tok
), tcp
->tok
))
978 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_INTERVAL
,
979 tcp
->data_interval_max
))
982 if (nla_put_u32(msg
, NL80211_WOWLAN_TCP_WAKE_PAYLOAD
,
983 tcp
->wake_payload_max
))
986 nla_nest_end(msg
, nl_tcp
);
990 static int nl80211_send_wowlan(struct sk_buff
*msg
,
991 struct cfg80211_registered_device
*dev
,
994 struct nlattr
*nl_wowlan
;
996 if (!dev
->wiphy
.wowlan
)
999 nl_wowlan
= nla_nest_start(msg
, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED
);
1003 if (((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_ANY
) &&
1004 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_ANY
)) ||
1005 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_DISCONNECT
) &&
1006 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
)) ||
1007 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_MAGIC_PKT
) &&
1008 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
)) ||
1009 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_SUPPORTS_GTK_REKEY
) &&
1010 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED
)) ||
1011 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
) &&
1012 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
)) ||
1013 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_EAP_IDENTITY_REQ
) &&
1014 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
)) ||
1015 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_4WAY_HANDSHAKE
) &&
1016 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
)) ||
1017 ((dev
->wiphy
.wowlan
->flags
& WIPHY_WOWLAN_RFKILL_RELEASE
) &&
1018 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
)))
1021 if (dev
->wiphy
.wowlan
->n_patterns
) {
1022 struct nl80211_pattern_support pat
= {
1023 .max_patterns
= dev
->wiphy
.wowlan
->n_patterns
,
1024 .min_pattern_len
= dev
->wiphy
.wowlan
->pattern_min_len
,
1025 .max_pattern_len
= dev
->wiphy
.wowlan
->pattern_max_len
,
1026 .max_pkt_offset
= dev
->wiphy
.wowlan
->max_pkt_offset
,
1029 if (nla_put(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
,
1034 if (large
&& nl80211_send_wowlan_tcp_caps(dev
, msg
))
1037 nla_nest_end(msg
, nl_wowlan
);
1043 static int nl80211_send_coalesce(struct sk_buff
*msg
,
1044 struct cfg80211_registered_device
*dev
)
1046 struct nl80211_coalesce_rule_support rule
;
1048 if (!dev
->wiphy
.coalesce
)
1051 rule
.max_rules
= dev
->wiphy
.coalesce
->n_rules
;
1052 rule
.max_delay
= dev
->wiphy
.coalesce
->max_delay
;
1053 rule
.pat
.max_patterns
= dev
->wiphy
.coalesce
->n_patterns
;
1054 rule
.pat
.min_pattern_len
= dev
->wiphy
.coalesce
->pattern_min_len
;
1055 rule
.pat
.max_pattern_len
= dev
->wiphy
.coalesce
->pattern_max_len
;
1056 rule
.pat
.max_pkt_offset
= dev
->wiphy
.coalesce
->max_pkt_offset
;
1058 if (nla_put(msg
, NL80211_ATTR_COALESCE_RULE
, sizeof(rule
), &rule
))
1064 static int nl80211_send_band_rateinfo(struct sk_buff
*msg
,
1065 struct ieee80211_supported_band
*sband
)
1067 struct nlattr
*nl_rates
, *nl_rate
;
1068 struct ieee80211_rate
*rate
;
1072 if (sband
->ht_cap
.ht_supported
&&
1073 (nla_put(msg
, NL80211_BAND_ATTR_HT_MCS_SET
,
1074 sizeof(sband
->ht_cap
.mcs
),
1075 &sband
->ht_cap
.mcs
) ||
1076 nla_put_u16(msg
, NL80211_BAND_ATTR_HT_CAPA
,
1077 sband
->ht_cap
.cap
) ||
1078 nla_put_u8(msg
, NL80211_BAND_ATTR_HT_AMPDU_FACTOR
,
1079 sband
->ht_cap
.ampdu_factor
) ||
1080 nla_put_u8(msg
, NL80211_BAND_ATTR_HT_AMPDU_DENSITY
,
1081 sband
->ht_cap
.ampdu_density
)))
1085 if (sband
->vht_cap
.vht_supported
&&
1086 (nla_put(msg
, NL80211_BAND_ATTR_VHT_MCS_SET
,
1087 sizeof(sband
->vht_cap
.vht_mcs
),
1088 &sband
->vht_cap
.vht_mcs
) ||
1089 nla_put_u32(msg
, NL80211_BAND_ATTR_VHT_CAPA
,
1090 sband
->vht_cap
.cap
)))
1094 nl_rates
= nla_nest_start(msg
, NL80211_BAND_ATTR_RATES
);
1098 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
1099 nl_rate
= nla_nest_start(msg
, i
);
1103 rate
= &sband
->bitrates
[i
];
1104 if (nla_put_u32(msg
, NL80211_BITRATE_ATTR_RATE
,
1107 if ((rate
->flags
& IEEE80211_RATE_SHORT_PREAMBLE
) &&
1109 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE
))
1112 nla_nest_end(msg
, nl_rate
);
1115 nla_nest_end(msg
, nl_rates
);
1121 nl80211_send_mgmt_stypes(struct sk_buff
*msg
,
1122 const struct ieee80211_txrx_stypes
*mgmt_stypes
)
1125 struct nlattr
*nl_ftypes
, *nl_ifs
;
1126 enum nl80211_iftype ift
;
1132 nl_ifs
= nla_nest_start(msg
, NL80211_ATTR_TX_FRAME_TYPES
);
1136 for (ift
= 0; ift
< NUM_NL80211_IFTYPES
; ift
++) {
1137 nl_ftypes
= nla_nest_start(msg
, ift
);
1141 stypes
= mgmt_stypes
[ift
].tx
;
1144 nla_put_u16(msg
, NL80211_ATTR_FRAME_TYPE
,
1145 (i
<< 4) | IEEE80211_FTYPE_MGMT
))
1150 nla_nest_end(msg
, nl_ftypes
);
1153 nla_nest_end(msg
, nl_ifs
);
1155 nl_ifs
= nla_nest_start(msg
, NL80211_ATTR_RX_FRAME_TYPES
);
1159 for (ift
= 0; ift
< NUM_NL80211_IFTYPES
; ift
++) {
1160 nl_ftypes
= nla_nest_start(msg
, ift
);
1164 stypes
= mgmt_stypes
[ift
].rx
;
1167 nla_put_u16(msg
, NL80211_ATTR_FRAME_TYPE
,
1168 (i
<< 4) | IEEE80211_FTYPE_MGMT
))
1173 nla_nest_end(msg
, nl_ftypes
);
1175 nla_nest_end(msg
, nl_ifs
);
1180 struct nl80211_dump_wiphy_state
{
1183 long split_start
, band_start
, chan_start
;
1187 static int nl80211_send_wiphy(struct cfg80211_registered_device
*dev
,
1188 struct sk_buff
*msg
, u32 portid
, u32 seq
,
1189 int flags
, struct nl80211_dump_wiphy_state
*state
)
1192 struct nlattr
*nl_bands
, *nl_band
;
1193 struct nlattr
*nl_freqs
, *nl_freq
;
1194 struct nlattr
*nl_cmds
;
1195 enum ieee80211_band band
;
1196 struct ieee80211_channel
*chan
;
1198 const struct ieee80211_txrx_stypes
*mgmt_stypes
=
1199 dev
->wiphy
.mgmt_stypes
;
1202 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, NL80211_CMD_NEW_WIPHY
);
1206 if (WARN_ON(!state
))
1209 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, dev
->wiphy_idx
) ||
1210 nla_put_string(msg
, NL80211_ATTR_WIPHY_NAME
,
1211 wiphy_name(&dev
->wiphy
)) ||
1212 nla_put_u32(msg
, NL80211_ATTR_GENERATION
,
1213 cfg80211_rdev_list_generation
))
1214 goto nla_put_failure
;
1216 switch (state
->split_start
) {
1218 if (nla_put_u8(msg
, NL80211_ATTR_WIPHY_RETRY_SHORT
,
1219 dev
->wiphy
.retry_short
) ||
1220 nla_put_u8(msg
, NL80211_ATTR_WIPHY_RETRY_LONG
,
1221 dev
->wiphy
.retry_long
) ||
1222 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FRAG_THRESHOLD
,
1223 dev
->wiphy
.frag_threshold
) ||
1224 nla_put_u32(msg
, NL80211_ATTR_WIPHY_RTS_THRESHOLD
,
1225 dev
->wiphy
.rts_threshold
) ||
1226 nla_put_u8(msg
, NL80211_ATTR_WIPHY_COVERAGE_CLASS
,
1227 dev
->wiphy
.coverage_class
) ||
1228 nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_SCAN_SSIDS
,
1229 dev
->wiphy
.max_scan_ssids
) ||
1230 nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS
,
1231 dev
->wiphy
.max_sched_scan_ssids
) ||
1232 nla_put_u16(msg
, NL80211_ATTR_MAX_SCAN_IE_LEN
,
1233 dev
->wiphy
.max_scan_ie_len
) ||
1234 nla_put_u16(msg
, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN
,
1235 dev
->wiphy
.max_sched_scan_ie_len
) ||
1236 nla_put_u8(msg
, NL80211_ATTR_MAX_MATCH_SETS
,
1237 dev
->wiphy
.max_match_sets
))
1238 goto nla_put_failure
;
1240 if ((dev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
) &&
1241 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_IBSS_RSN
))
1242 goto nla_put_failure
;
1243 if ((dev
->wiphy
.flags
& WIPHY_FLAG_MESH_AUTH
) &&
1244 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_MESH_AUTH
))
1245 goto nla_put_failure
;
1246 if ((dev
->wiphy
.flags
& WIPHY_FLAG_AP_UAPSD
) &&
1247 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_AP_UAPSD
))
1248 goto nla_put_failure
;
1249 if ((dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
) &&
1250 nla_put_flag(msg
, NL80211_ATTR_ROAM_SUPPORT
))
1251 goto nla_put_failure
;
1252 if ((dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) &&
1253 nla_put_flag(msg
, NL80211_ATTR_TDLS_SUPPORT
))
1254 goto nla_put_failure
;
1255 if ((dev
->wiphy
.flags
& WIPHY_FLAG_TDLS_EXTERNAL_SETUP
) &&
1256 nla_put_flag(msg
, NL80211_ATTR_TDLS_EXTERNAL_SETUP
))
1257 goto nla_put_failure
;
1258 state
->split_start
++;
1262 if (nla_put(msg
, NL80211_ATTR_CIPHER_SUITES
,
1263 sizeof(u32
) * dev
->wiphy
.n_cipher_suites
,
1264 dev
->wiphy
.cipher_suites
))
1265 goto nla_put_failure
;
1267 if (nla_put_u8(msg
, NL80211_ATTR_MAX_NUM_PMKIDS
,
1268 dev
->wiphy
.max_num_pmkids
))
1269 goto nla_put_failure
;
1271 if ((dev
->wiphy
.flags
& WIPHY_FLAG_CONTROL_PORT_PROTOCOL
) &&
1272 nla_put_flag(msg
, NL80211_ATTR_CONTROL_PORT_ETHERTYPE
))
1273 goto nla_put_failure
;
1275 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX
,
1276 dev
->wiphy
.available_antennas_tx
) ||
1277 nla_put_u32(msg
, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX
,
1278 dev
->wiphy
.available_antennas_rx
))
1279 goto nla_put_failure
;
1281 if ((dev
->wiphy
.flags
& WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
) &&
1282 nla_put_u32(msg
, NL80211_ATTR_PROBE_RESP_OFFLOAD
,
1283 dev
->wiphy
.probe_resp_offload
))
1284 goto nla_put_failure
;
1286 if ((dev
->wiphy
.available_antennas_tx
||
1287 dev
->wiphy
.available_antennas_rx
) &&
1288 dev
->ops
->get_antenna
) {
1289 u32 tx_ant
= 0, rx_ant
= 0;
1291 res
= rdev_get_antenna(dev
, &tx_ant
, &rx_ant
);
1293 if (nla_put_u32(msg
,
1294 NL80211_ATTR_WIPHY_ANTENNA_TX
,
1297 NL80211_ATTR_WIPHY_ANTENNA_RX
,
1299 goto nla_put_failure
;
1303 state
->split_start
++;
1307 if (nl80211_put_iftypes(msg
, NL80211_ATTR_SUPPORTED_IFTYPES
,
1308 dev
->wiphy
.interface_modes
))
1309 goto nla_put_failure
;
1310 state
->split_start
++;
1314 nl_bands
= nla_nest_start(msg
, NL80211_ATTR_WIPHY_BANDS
);
1316 goto nla_put_failure
;
1318 for (band
= state
->band_start
;
1319 band
< IEEE80211_NUM_BANDS
; band
++) {
1320 struct ieee80211_supported_band
*sband
;
1322 sband
= dev
->wiphy
.bands
[band
];
1327 nl_band
= nla_nest_start(msg
, band
);
1329 goto nla_put_failure
;
1331 switch (state
->chan_start
) {
1333 if (nl80211_send_band_rateinfo(msg
, sband
))
1334 goto nla_put_failure
;
1335 state
->chan_start
++;
1339 /* add frequencies */
1340 nl_freqs
= nla_nest_start(
1341 msg
, NL80211_BAND_ATTR_FREQS
);
1343 goto nla_put_failure
;
1345 for (i
= state
->chan_start
- 1;
1346 i
< sband
->n_channels
;
1348 nl_freq
= nla_nest_start(msg
, i
);
1350 goto nla_put_failure
;
1352 chan
= &sband
->channels
[i
];
1354 if (nl80211_msg_put_channel(
1357 goto nla_put_failure
;
1359 nla_nest_end(msg
, nl_freq
);
1363 if (i
< sband
->n_channels
)
1364 state
->chan_start
= i
+ 2;
1366 state
->chan_start
= 0;
1367 nla_nest_end(msg
, nl_freqs
);
1370 nla_nest_end(msg
, nl_band
);
1373 /* start again here */
1374 if (state
->chan_start
)
1379 nla_nest_end(msg
, nl_bands
);
1381 if (band
< IEEE80211_NUM_BANDS
)
1382 state
->band_start
= band
+ 1;
1384 state
->band_start
= 0;
1386 /* if bands & channels are done, continue outside */
1387 if (state
->band_start
== 0 && state
->chan_start
== 0)
1388 state
->split_start
++;
1392 nl_cmds
= nla_nest_start(msg
, NL80211_ATTR_SUPPORTED_COMMANDS
);
1394 goto nla_put_failure
;
1397 #define CMD(op, n) \
1399 if (dev->ops->op) { \
1401 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1402 goto nla_put_failure; \
1406 CMD(add_virtual_intf
, NEW_INTERFACE
);
1407 CMD(change_virtual_intf
, SET_INTERFACE
);
1408 CMD(add_key
, NEW_KEY
);
1409 CMD(start_ap
, START_AP
);
1410 CMD(add_station
, NEW_STATION
);
1411 CMD(add_mpath
, NEW_MPATH
);
1412 CMD(update_mesh_config
, SET_MESH_CONFIG
);
1413 CMD(change_bss
, SET_BSS
);
1414 CMD(auth
, AUTHENTICATE
);
1415 CMD(assoc
, ASSOCIATE
);
1416 CMD(deauth
, DEAUTHENTICATE
);
1417 CMD(disassoc
, DISASSOCIATE
);
1418 CMD(join_ibss
, JOIN_IBSS
);
1419 CMD(join_mesh
, JOIN_MESH
);
1420 CMD(set_pmksa
, SET_PMKSA
);
1421 CMD(del_pmksa
, DEL_PMKSA
);
1422 CMD(flush_pmksa
, FLUSH_PMKSA
);
1423 if (dev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
)
1424 CMD(remain_on_channel
, REMAIN_ON_CHANNEL
);
1425 CMD(set_bitrate_mask
, SET_TX_BITRATE_MASK
);
1426 CMD(mgmt_tx
, FRAME
);
1427 CMD(mgmt_tx_cancel_wait
, FRAME_WAIT_CANCEL
);
1428 if (dev
->wiphy
.flags
& WIPHY_FLAG_NETNS_OK
) {
1430 if (nla_put_u32(msg
, i
, NL80211_CMD_SET_WIPHY_NETNS
))
1431 goto nla_put_failure
;
1433 if (dev
->ops
->set_monitor_channel
|| dev
->ops
->start_ap
||
1434 dev
->ops
->join_mesh
) {
1436 if (nla_put_u32(msg
, i
, NL80211_CMD_SET_CHANNEL
))
1437 goto nla_put_failure
;
1439 CMD(set_wds_peer
, SET_WDS_PEER
);
1440 if (dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) {
1441 CMD(tdls_mgmt
, TDLS_MGMT
);
1442 CMD(tdls_oper
, TDLS_OPER
);
1444 if (dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_SCHED_SCAN
)
1445 CMD(sched_scan_start
, START_SCHED_SCAN
);
1446 CMD(probe_client
, PROBE_CLIENT
);
1447 CMD(set_noack_map
, SET_NOACK_MAP
);
1448 if (dev
->wiphy
.flags
& WIPHY_FLAG_REPORTS_OBSS
) {
1450 if (nla_put_u32(msg
, i
, NL80211_CMD_REGISTER_BEACONS
))
1451 goto nla_put_failure
;
1453 CMD(start_p2p_device
, START_P2P_DEVICE
);
1454 CMD(set_mcast_rate
, SET_MCAST_RATE
);
1456 CMD(crit_proto_start
, CRIT_PROTOCOL_START
);
1457 CMD(crit_proto_stop
, CRIT_PROTOCOL_STOP
);
1458 if (dev
->wiphy
.flags
& WIPHY_FLAG_HAS_CHANNEL_SWITCH
)
1459 CMD(channel_switch
, CHANNEL_SWITCH
);
1461 CMD(set_qos_map
, SET_QOS_MAP
);
1463 #ifdef CONFIG_NL80211_TESTMODE
1464 CMD(testmode_cmd
, TESTMODE
);
1469 if (dev
->ops
->connect
|| dev
->ops
->auth
) {
1471 if (nla_put_u32(msg
, i
, NL80211_CMD_CONNECT
))
1472 goto nla_put_failure
;
1475 if (dev
->ops
->disconnect
|| dev
->ops
->deauth
) {
1477 if (nla_put_u32(msg
, i
, NL80211_CMD_DISCONNECT
))
1478 goto nla_put_failure
;
1481 nla_nest_end(msg
, nl_cmds
);
1482 state
->split_start
++;
1486 if (dev
->ops
->remain_on_channel
&&
1487 (dev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
) &&
1489 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION
,
1490 dev
->wiphy
.max_remain_on_channel_duration
))
1491 goto nla_put_failure
;
1493 if ((dev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
) &&
1494 nla_put_flag(msg
, NL80211_ATTR_OFFCHANNEL_TX_OK
))
1495 goto nla_put_failure
;
1497 if (nl80211_send_mgmt_stypes(msg
, mgmt_stypes
))
1498 goto nla_put_failure
;
1499 state
->split_start
++;
1504 if (nl80211_send_wowlan(msg
, dev
, state
->split
))
1505 goto nla_put_failure
;
1506 state
->split_start
++;
1510 state
->split_start
++;
1513 if (nl80211_put_iftypes(msg
, NL80211_ATTR_SOFTWARE_IFTYPES
,
1514 dev
->wiphy
.software_iftypes
))
1515 goto nla_put_failure
;
1517 if (nl80211_put_iface_combinations(&dev
->wiphy
, msg
,
1519 goto nla_put_failure
;
1521 state
->split_start
++;
1525 if ((dev
->wiphy
.flags
& WIPHY_FLAG_HAVE_AP_SME
) &&
1526 nla_put_u32(msg
, NL80211_ATTR_DEVICE_AP_SME
,
1527 dev
->wiphy
.ap_sme_capa
))
1528 goto nla_put_failure
;
1530 features
= dev
->wiphy
.features
;
1532 * We can only add the per-channel limit information if the
1533 * dump is split, otherwise it makes it too big. Therefore
1534 * only advertise it in that case.
1537 features
|= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS
;
1538 if (nla_put_u32(msg
, NL80211_ATTR_FEATURE_FLAGS
, features
))
1539 goto nla_put_failure
;
1541 if (dev
->wiphy
.ht_capa_mod_mask
&&
1542 nla_put(msg
, NL80211_ATTR_HT_CAPABILITY_MASK
,
1543 sizeof(*dev
->wiphy
.ht_capa_mod_mask
),
1544 dev
->wiphy
.ht_capa_mod_mask
))
1545 goto nla_put_failure
;
1547 if (dev
->wiphy
.flags
& WIPHY_FLAG_HAVE_AP_SME
&&
1548 dev
->wiphy
.max_acl_mac_addrs
&&
1549 nla_put_u32(msg
, NL80211_ATTR_MAC_ACL_MAX
,
1550 dev
->wiphy
.max_acl_mac_addrs
))
1551 goto nla_put_failure
;
1554 * Any information below this point is only available to
1555 * applications that can deal with it being split. This
1556 * helps ensure that newly added capabilities don't break
1557 * older tools by overrunning their buffers.
1559 * We still increment split_start so that in the split
1560 * case we'll continue with more data in the next round,
1561 * but break unconditionally so unsplit data stops here.
1563 state
->split_start
++;
1566 if (dev
->wiphy
.extended_capabilities
&&
1567 (nla_put(msg
, NL80211_ATTR_EXT_CAPA
,
1568 dev
->wiphy
.extended_capabilities_len
,
1569 dev
->wiphy
.extended_capabilities
) ||
1570 nla_put(msg
, NL80211_ATTR_EXT_CAPA_MASK
,
1571 dev
->wiphy
.extended_capabilities_len
,
1572 dev
->wiphy
.extended_capabilities_mask
)))
1573 goto nla_put_failure
;
1575 if (dev
->wiphy
.vht_capa_mod_mask
&&
1576 nla_put(msg
, NL80211_ATTR_VHT_CAPABILITY_MASK
,
1577 sizeof(*dev
->wiphy
.vht_capa_mod_mask
),
1578 dev
->wiphy
.vht_capa_mod_mask
))
1579 goto nla_put_failure
;
1581 state
->split_start
++;
1584 if (nl80211_send_coalesce(msg
, dev
))
1585 goto nla_put_failure
;
1587 if ((dev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_5_10_MHZ
) &&
1588 (nla_put_flag(msg
, NL80211_ATTR_SUPPORT_5_MHZ
) ||
1589 nla_put_flag(msg
, NL80211_ATTR_SUPPORT_10_MHZ
)))
1590 goto nla_put_failure
;
1592 if (dev
->wiphy
.max_ap_assoc_sta
&&
1593 nla_put_u32(msg
, NL80211_ATTR_MAX_AP_ASSOC_STA
,
1594 dev
->wiphy
.max_ap_assoc_sta
))
1595 goto nla_put_failure
;
1597 state
->split_start
++;
1600 if (dev
->wiphy
.n_vendor_commands
) {
1601 const struct nl80211_vendor_cmd_info
*info
;
1602 struct nlattr
*nested
;
1604 nested
= nla_nest_start(msg
, NL80211_ATTR_VENDOR_DATA
);
1606 goto nla_put_failure
;
1608 for (i
= 0; i
< dev
->wiphy
.n_vendor_commands
; i
++) {
1609 info
= &dev
->wiphy
.vendor_commands
[i
].info
;
1610 if (nla_put(msg
, i
+ 1, sizeof(*info
), info
))
1611 goto nla_put_failure
;
1613 nla_nest_end(msg
, nested
);
1616 if (dev
->wiphy
.n_vendor_events
) {
1617 const struct nl80211_vendor_cmd_info
*info
;
1618 struct nlattr
*nested
;
1620 nested
= nla_nest_start(msg
,
1621 NL80211_ATTR_VENDOR_EVENTS
);
1623 goto nla_put_failure
;
1625 for (i
= 0; i
< dev
->wiphy
.n_vendor_events
; i
++) {
1626 info
= &dev
->wiphy
.vendor_events
[i
];
1627 if (nla_put(msg
, i
+ 1, sizeof(*info
), info
))
1628 goto nla_put_failure
;
1630 nla_nest_end(msg
, nested
);
1634 state
->split_start
= 0;
1637 return genlmsg_end(msg
, hdr
);
1640 genlmsg_cancel(msg
, hdr
);
1644 static int nl80211_dump_wiphy_parse(struct sk_buff
*skb
,
1645 struct netlink_callback
*cb
,
1646 struct nl80211_dump_wiphy_state
*state
)
1648 struct nlattr
**tb
= nl80211_fam
.attrbuf
;
1649 int ret
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
1650 tb
, nl80211_fam
.maxattr
, nl80211_policy
);
1651 /* ignore parse errors for backward compatibility */
1655 state
->split
= tb
[NL80211_ATTR_SPLIT_WIPHY_DUMP
];
1656 if (tb
[NL80211_ATTR_WIPHY
])
1657 state
->filter_wiphy
= nla_get_u32(tb
[NL80211_ATTR_WIPHY
]);
1658 if (tb
[NL80211_ATTR_WDEV
])
1659 state
->filter_wiphy
= nla_get_u64(tb
[NL80211_ATTR_WDEV
]) >> 32;
1660 if (tb
[NL80211_ATTR_IFINDEX
]) {
1661 struct net_device
*netdev
;
1662 struct cfg80211_registered_device
*rdev
;
1663 int ifidx
= nla_get_u32(tb
[NL80211_ATTR_IFINDEX
]);
1665 netdev
= __dev_get_by_index(sock_net(skb
->sk
), ifidx
);
1668 if (netdev
->ieee80211_ptr
) {
1669 rdev
= wiphy_to_dev(
1670 netdev
->ieee80211_ptr
->wiphy
);
1671 state
->filter_wiphy
= rdev
->wiphy_idx
;
1678 static int nl80211_dump_wiphy(struct sk_buff
*skb
, struct netlink_callback
*cb
)
1681 struct nl80211_dump_wiphy_state
*state
= (void *)cb
->args
[0];
1682 struct cfg80211_registered_device
*dev
;
1686 state
= kzalloc(sizeof(*state
), GFP_KERNEL
);
1691 state
->filter_wiphy
= -1;
1692 ret
= nl80211_dump_wiphy_parse(skb
, cb
, state
);
1698 cb
->args
[0] = (long)state
;
1701 list_for_each_entry(dev
, &cfg80211_rdev_list
, list
) {
1702 if (!net_eq(wiphy_net(&dev
->wiphy
), sock_net(skb
->sk
)))
1704 if (++idx
<= state
->start
)
1706 if (state
->filter_wiphy
!= -1 &&
1707 state
->filter_wiphy
!= dev
->wiphy_idx
)
1709 /* attempt to fit multiple wiphy data chunks into the skb */
1711 ret
= nl80211_send_wiphy(dev
, skb
,
1712 NETLINK_CB(cb
->skb
).portid
,
1714 NLM_F_MULTI
, state
);
1717 * If sending the wiphy data didn't fit (ENOBUFS
1718 * or EMSGSIZE returned), this SKB is still
1719 * empty (so it's not too big because another
1720 * wiphy dataset is already in the skb) and
1721 * we've not tried to adjust the dump allocation
1722 * yet ... then adjust the alloc size to be
1723 * bigger, and return 1 but with the empty skb.
1724 * This results in an empty message being RX'ed
1725 * in userspace, but that is ignored.
1727 * We can then retry with the larger buffer.
1729 if ((ret
== -ENOBUFS
|| ret
== -EMSGSIZE
) &&
1731 cb
->min_dump_alloc
< 4096) {
1732 cb
->min_dump_alloc
= 4096;
1739 } while (state
->split_start
> 0);
1749 static int nl80211_dump_wiphy_done(struct netlink_callback
*cb
)
1751 kfree((void *)cb
->args
[0]);
1755 static int nl80211_get_wiphy(struct sk_buff
*skb
, struct genl_info
*info
)
1757 struct sk_buff
*msg
;
1758 struct cfg80211_registered_device
*dev
= info
->user_ptr
[0];
1759 struct nl80211_dump_wiphy_state state
= {};
1761 msg
= nlmsg_new(4096, GFP_KERNEL
);
1765 if (nl80211_send_wiphy(dev
, msg
, info
->snd_portid
, info
->snd_seq
, 0,
1771 return genlmsg_reply(msg
, info
);
1774 static const struct nla_policy txq_params_policy
[NL80211_TXQ_ATTR_MAX
+ 1] = {
1775 [NL80211_TXQ_ATTR_QUEUE
] = { .type
= NLA_U8
},
1776 [NL80211_TXQ_ATTR_TXOP
] = { .type
= NLA_U16
},
1777 [NL80211_TXQ_ATTR_CWMIN
] = { .type
= NLA_U16
},
1778 [NL80211_TXQ_ATTR_CWMAX
] = { .type
= NLA_U16
},
1779 [NL80211_TXQ_ATTR_AIFS
] = { .type
= NLA_U8
},
1782 static int parse_txq_params(struct nlattr
*tb
[],
1783 struct ieee80211_txq_params
*txq_params
)
1785 if (!tb
[NL80211_TXQ_ATTR_AC
] || !tb
[NL80211_TXQ_ATTR_TXOP
] ||
1786 !tb
[NL80211_TXQ_ATTR_CWMIN
] || !tb
[NL80211_TXQ_ATTR_CWMAX
] ||
1787 !tb
[NL80211_TXQ_ATTR_AIFS
])
1790 txq_params
->ac
= nla_get_u8(tb
[NL80211_TXQ_ATTR_AC
]);
1791 txq_params
->txop
= nla_get_u16(tb
[NL80211_TXQ_ATTR_TXOP
]);
1792 txq_params
->cwmin
= nla_get_u16(tb
[NL80211_TXQ_ATTR_CWMIN
]);
1793 txq_params
->cwmax
= nla_get_u16(tb
[NL80211_TXQ_ATTR_CWMAX
]);
1794 txq_params
->aifs
= nla_get_u8(tb
[NL80211_TXQ_ATTR_AIFS
]);
1796 if (txq_params
->ac
>= NL80211_NUM_ACS
)
1802 static bool nl80211_can_set_dev_channel(struct wireless_dev
*wdev
)
1805 * You can only set the channel explicitly for WDS interfaces,
1806 * all others have their channel managed via their respective
1807 * "establish a connection" command (connect, join, ...)
1809 * For AP/GO and mesh mode, the channel can be set with the
1810 * channel userspace API, but is only stored and passed to the
1811 * low-level driver when the AP starts or the mesh is joined.
1812 * This is for backward compatibility, userspace can also give
1813 * the channel in the start-ap or join-mesh commands instead.
1815 * Monitors are special as they are normally slaved to
1816 * whatever else is going on, so they have their own special
1817 * operation to set the monitor channel if possible.
1820 wdev
->iftype
== NL80211_IFTYPE_AP
||
1821 wdev
->iftype
== NL80211_IFTYPE_MESH_POINT
||
1822 wdev
->iftype
== NL80211_IFTYPE_MONITOR
||
1823 wdev
->iftype
== NL80211_IFTYPE_P2P_GO
;
1826 static int nl80211_parse_chandef(struct cfg80211_registered_device
*rdev
,
1827 struct genl_info
*info
,
1828 struct cfg80211_chan_def
*chandef
)
1832 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
1835 control_freq
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]);
1837 chandef
->chan
= ieee80211_get_channel(&rdev
->wiphy
, control_freq
);
1838 chandef
->width
= NL80211_CHAN_WIDTH_20_NOHT
;
1839 chandef
->center_freq1
= control_freq
;
1840 chandef
->center_freq2
= 0;
1842 /* Primary channel not allowed */
1843 if (!chandef
->chan
|| chandef
->chan
->flags
& IEEE80211_CHAN_DISABLED
)
1846 if (info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]) {
1847 enum nl80211_channel_type chantype
;
1849 chantype
= nla_get_u32(
1850 info
->attrs
[NL80211_ATTR_WIPHY_CHANNEL_TYPE
]);
1853 case NL80211_CHAN_NO_HT
:
1854 case NL80211_CHAN_HT20
:
1855 case NL80211_CHAN_HT40PLUS
:
1856 case NL80211_CHAN_HT40MINUS
:
1857 cfg80211_chandef_create(chandef
, chandef
->chan
,
1863 } else if (info
->attrs
[NL80211_ATTR_CHANNEL_WIDTH
]) {
1865 nla_get_u32(info
->attrs
[NL80211_ATTR_CHANNEL_WIDTH
]);
1866 if (info
->attrs
[NL80211_ATTR_CENTER_FREQ1
])
1867 chandef
->center_freq1
=
1869 info
->attrs
[NL80211_ATTR_CENTER_FREQ1
]);
1870 if (info
->attrs
[NL80211_ATTR_CENTER_FREQ2
])
1871 chandef
->center_freq2
=
1873 info
->attrs
[NL80211_ATTR_CENTER_FREQ2
]);
1876 if (!cfg80211_chandef_valid(chandef
))
1879 if (!cfg80211_chandef_usable(&rdev
->wiphy
, chandef
,
1880 IEEE80211_CHAN_DISABLED
))
1883 if ((chandef
->width
== NL80211_CHAN_WIDTH_5
||
1884 chandef
->width
== NL80211_CHAN_WIDTH_10
) &&
1885 !(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_5_10_MHZ
))
1891 static int __nl80211_set_channel(struct cfg80211_registered_device
*rdev
,
1892 struct wireless_dev
*wdev
,
1893 struct genl_info
*info
)
1895 struct cfg80211_chan_def chandef
;
1897 enum nl80211_iftype iftype
= NL80211_IFTYPE_MONITOR
;
1900 iftype
= wdev
->iftype
;
1902 if (!nl80211_can_set_dev_channel(wdev
))
1905 result
= nl80211_parse_chandef(rdev
, info
, &chandef
);
1910 case NL80211_IFTYPE_AP
:
1911 case NL80211_IFTYPE_P2P_GO
:
1912 if (wdev
->beacon_interval
) {
1916 if (!cfg80211_reg_can_beacon(&rdev
->wiphy
, &chandef
)) {
1920 wdev
->preset_chandef
= chandef
;
1923 case NL80211_IFTYPE_MESH_POINT
:
1924 result
= cfg80211_set_mesh_channel(rdev
, wdev
, &chandef
);
1926 case NL80211_IFTYPE_MONITOR
:
1927 result
= cfg80211_set_monitor_channel(rdev
, &chandef
);
1936 static int nl80211_set_channel(struct sk_buff
*skb
, struct genl_info
*info
)
1938 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1939 struct net_device
*netdev
= info
->user_ptr
[1];
1941 return __nl80211_set_channel(rdev
, netdev
->ieee80211_ptr
, info
);
1944 static int nl80211_set_wds_peer(struct sk_buff
*skb
, struct genl_info
*info
)
1946 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
1947 struct net_device
*dev
= info
->user_ptr
[1];
1948 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
1951 if (!info
->attrs
[NL80211_ATTR_MAC
])
1954 if (netif_running(dev
))
1957 if (!rdev
->ops
->set_wds_peer
)
1960 if (wdev
->iftype
!= NL80211_IFTYPE_WDS
)
1963 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
1964 return rdev_set_wds_peer(rdev
, dev
, bssid
);
1968 static int nl80211_set_wiphy(struct sk_buff
*skb
, struct genl_info
*info
)
1970 struct cfg80211_registered_device
*rdev
;
1971 struct net_device
*netdev
= NULL
;
1972 struct wireless_dev
*wdev
;
1973 int result
= 0, rem_txq_params
= 0;
1974 struct nlattr
*nl_txq_params
;
1976 u8 retry_short
= 0, retry_long
= 0;
1977 u32 frag_threshold
= 0, rts_threshold
= 0;
1978 u8 coverage_class
= 0;
1983 * Try to find the wiphy and netdev. Normally this
1984 * function shouldn't need the netdev, but this is
1985 * done for backward compatibility -- previously
1986 * setting the channel was done per wiphy, but now
1987 * it is per netdev. Previous userland like hostapd
1988 * also passed a netdev to set_wiphy, so that it is
1989 * possible to let that go to the right netdev!
1992 if (info
->attrs
[NL80211_ATTR_IFINDEX
]) {
1993 int ifindex
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFINDEX
]);
1995 netdev
= __dev_get_by_index(genl_info_net(info
), ifindex
);
1996 if (netdev
&& netdev
->ieee80211_ptr
)
1997 rdev
= wiphy_to_dev(netdev
->ieee80211_ptr
->wiphy
);
2003 rdev
= __cfg80211_rdev_from_attrs(genl_info_net(info
),
2006 return PTR_ERR(rdev
);
2011 wdev
= netdev
->ieee80211_ptr
;
2014 * end workaround code, by now the rdev is available
2015 * and locked, and wdev may or may not be NULL.
2018 if (info
->attrs
[NL80211_ATTR_WIPHY_NAME
])
2019 result
= cfg80211_dev_rename(
2020 rdev
, nla_data(info
->attrs
[NL80211_ATTR_WIPHY_NAME
]));
2025 if (info
->attrs
[NL80211_ATTR_WIPHY_TXQ_PARAMS
]) {
2026 struct ieee80211_txq_params txq_params
;
2027 struct nlattr
*tb
[NL80211_TXQ_ATTR_MAX
+ 1];
2029 if (!rdev
->ops
->set_txq_params
)
2035 if (netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
2036 netdev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
2039 if (!netif_running(netdev
))
2042 nla_for_each_nested(nl_txq_params
,
2043 info
->attrs
[NL80211_ATTR_WIPHY_TXQ_PARAMS
],
2045 nla_parse(tb
, NL80211_TXQ_ATTR_MAX
,
2046 nla_data(nl_txq_params
),
2047 nla_len(nl_txq_params
),
2049 result
= parse_txq_params(tb
, &txq_params
);
2053 result
= rdev_set_txq_params(rdev
, netdev
,
2060 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
2061 result
= __nl80211_set_channel(rdev
,
2062 nl80211_can_set_dev_channel(wdev
) ? wdev
: NULL
,
2068 if (info
->attrs
[NL80211_ATTR_WIPHY_TX_POWER_SETTING
]) {
2069 struct wireless_dev
*txp_wdev
= wdev
;
2070 enum nl80211_tx_power_setting type
;
2073 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_VIF_TXPOWER
))
2076 if (!rdev
->ops
->set_tx_power
)
2079 idx
= NL80211_ATTR_WIPHY_TX_POWER_SETTING
;
2080 type
= nla_get_u32(info
->attrs
[idx
]);
2082 if (!info
->attrs
[NL80211_ATTR_WIPHY_TX_POWER_LEVEL
] &&
2083 (type
!= NL80211_TX_POWER_AUTOMATIC
))
2086 if (type
!= NL80211_TX_POWER_AUTOMATIC
) {
2087 idx
= NL80211_ATTR_WIPHY_TX_POWER_LEVEL
;
2088 mbm
= nla_get_u32(info
->attrs
[idx
]);
2091 result
= rdev_set_tx_power(rdev
, txp_wdev
, type
, mbm
);
2096 if (info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_TX
] &&
2097 info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_RX
]) {
2099 if ((!rdev
->wiphy
.available_antennas_tx
&&
2100 !rdev
->wiphy
.available_antennas_rx
) ||
2101 !rdev
->ops
->set_antenna
)
2104 tx_ant
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_TX
]);
2105 rx_ant
= nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_ANTENNA_RX
]);
2107 /* reject antenna configurations which don't match the
2108 * available antenna masks, except for the "all" mask */
2109 if ((~tx_ant
&& (tx_ant
& ~rdev
->wiphy
.available_antennas_tx
)) ||
2110 (~rx_ant
&& (rx_ant
& ~rdev
->wiphy
.available_antennas_rx
)))
2113 tx_ant
= tx_ant
& rdev
->wiphy
.available_antennas_tx
;
2114 rx_ant
= rx_ant
& rdev
->wiphy
.available_antennas_rx
;
2116 result
= rdev_set_antenna(rdev
, tx_ant
, rx_ant
);
2123 if (info
->attrs
[NL80211_ATTR_WIPHY_RETRY_SHORT
]) {
2124 retry_short
= nla_get_u8(
2125 info
->attrs
[NL80211_ATTR_WIPHY_RETRY_SHORT
]);
2126 if (retry_short
== 0)
2129 changed
|= WIPHY_PARAM_RETRY_SHORT
;
2132 if (info
->attrs
[NL80211_ATTR_WIPHY_RETRY_LONG
]) {
2133 retry_long
= nla_get_u8(
2134 info
->attrs
[NL80211_ATTR_WIPHY_RETRY_LONG
]);
2135 if (retry_long
== 0)
2138 changed
|= WIPHY_PARAM_RETRY_LONG
;
2141 if (info
->attrs
[NL80211_ATTR_WIPHY_FRAG_THRESHOLD
]) {
2142 frag_threshold
= nla_get_u32(
2143 info
->attrs
[NL80211_ATTR_WIPHY_FRAG_THRESHOLD
]);
2144 if (frag_threshold
< 256)
2147 if (frag_threshold
!= (u32
) -1) {
2149 * Fragments (apart from the last one) are required to
2150 * have even length. Make the fragmentation code
2151 * simpler by stripping LSB should someone try to use
2152 * odd threshold value.
2154 frag_threshold
&= ~0x1;
2156 changed
|= WIPHY_PARAM_FRAG_THRESHOLD
;
2159 if (info
->attrs
[NL80211_ATTR_WIPHY_RTS_THRESHOLD
]) {
2160 rts_threshold
= nla_get_u32(
2161 info
->attrs
[NL80211_ATTR_WIPHY_RTS_THRESHOLD
]);
2162 changed
|= WIPHY_PARAM_RTS_THRESHOLD
;
2165 if (info
->attrs
[NL80211_ATTR_WIPHY_COVERAGE_CLASS
]) {
2166 coverage_class
= nla_get_u8(
2167 info
->attrs
[NL80211_ATTR_WIPHY_COVERAGE_CLASS
]);
2168 changed
|= WIPHY_PARAM_COVERAGE_CLASS
;
2172 u8 old_retry_short
, old_retry_long
;
2173 u32 old_frag_threshold
, old_rts_threshold
;
2174 u8 old_coverage_class
;
2176 if (!rdev
->ops
->set_wiphy_params
)
2179 old_retry_short
= rdev
->wiphy
.retry_short
;
2180 old_retry_long
= rdev
->wiphy
.retry_long
;
2181 old_frag_threshold
= rdev
->wiphy
.frag_threshold
;
2182 old_rts_threshold
= rdev
->wiphy
.rts_threshold
;
2183 old_coverage_class
= rdev
->wiphy
.coverage_class
;
2185 if (changed
& WIPHY_PARAM_RETRY_SHORT
)
2186 rdev
->wiphy
.retry_short
= retry_short
;
2187 if (changed
& WIPHY_PARAM_RETRY_LONG
)
2188 rdev
->wiphy
.retry_long
= retry_long
;
2189 if (changed
& WIPHY_PARAM_FRAG_THRESHOLD
)
2190 rdev
->wiphy
.frag_threshold
= frag_threshold
;
2191 if (changed
& WIPHY_PARAM_RTS_THRESHOLD
)
2192 rdev
->wiphy
.rts_threshold
= rts_threshold
;
2193 if (changed
& WIPHY_PARAM_COVERAGE_CLASS
)
2194 rdev
->wiphy
.coverage_class
= coverage_class
;
2196 result
= rdev_set_wiphy_params(rdev
, changed
);
2198 rdev
->wiphy
.retry_short
= old_retry_short
;
2199 rdev
->wiphy
.retry_long
= old_retry_long
;
2200 rdev
->wiphy
.frag_threshold
= old_frag_threshold
;
2201 rdev
->wiphy
.rts_threshold
= old_rts_threshold
;
2202 rdev
->wiphy
.coverage_class
= old_coverage_class
;
2208 static inline u64
wdev_id(struct wireless_dev
*wdev
)
2210 return (u64
)wdev
->identifier
|
2211 ((u64
)wiphy_to_dev(wdev
->wiphy
)->wiphy_idx
<< 32);
2214 static int nl80211_send_chandef(struct sk_buff
*msg
,
2215 const struct cfg80211_chan_def
*chandef
)
2217 WARN_ON(!cfg80211_chandef_valid(chandef
));
2219 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
,
2220 chandef
->chan
->center_freq
))
2222 switch (chandef
->width
) {
2223 case NL80211_CHAN_WIDTH_20_NOHT
:
2224 case NL80211_CHAN_WIDTH_20
:
2225 case NL80211_CHAN_WIDTH_40
:
2226 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
2227 cfg80211_get_chandef_type(chandef
)))
2233 if (nla_put_u32(msg
, NL80211_ATTR_CHANNEL_WIDTH
, chandef
->width
))
2235 if (nla_put_u32(msg
, NL80211_ATTR_CENTER_FREQ1
, chandef
->center_freq1
))
2237 if (chandef
->center_freq2
&&
2238 nla_put_u32(msg
, NL80211_ATTR_CENTER_FREQ2
, chandef
->center_freq2
))
2243 static int nl80211_send_iface(struct sk_buff
*msg
, u32 portid
, u32 seq
, int flags
,
2244 struct cfg80211_registered_device
*rdev
,
2245 struct wireless_dev
*wdev
)
2247 struct net_device
*dev
= wdev
->netdev
;
2250 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, NL80211_CMD_NEW_INTERFACE
);
2255 (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
2256 nla_put_string(msg
, NL80211_ATTR_IFNAME
, dev
->name
)))
2257 goto nla_put_failure
;
2259 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
2260 nla_put_u32(msg
, NL80211_ATTR_IFTYPE
, wdev
->iftype
) ||
2261 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)) ||
2262 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, wdev_address(wdev
)) ||
2263 nla_put_u32(msg
, NL80211_ATTR_GENERATION
,
2264 rdev
->devlist_generation
^
2265 (cfg80211_rdev_list_generation
<< 2)))
2266 goto nla_put_failure
;
2268 if (rdev
->ops
->get_channel
) {
2270 struct cfg80211_chan_def chandef
;
2272 ret
= rdev_get_channel(rdev
, wdev
, &chandef
);
2274 if (nl80211_send_chandef(msg
, &chandef
))
2275 goto nla_put_failure
;
2279 if (wdev
->ssid_len
) {
2280 if (nla_put(msg
, NL80211_ATTR_SSID
, wdev
->ssid_len
, wdev
->ssid
))
2281 goto nla_put_failure
;
2284 return genlmsg_end(msg
, hdr
);
2287 genlmsg_cancel(msg
, hdr
);
2291 static int nl80211_dump_interface(struct sk_buff
*skb
, struct netlink_callback
*cb
)
2295 int wp_start
= cb
->args
[0];
2296 int if_start
= cb
->args
[1];
2297 struct cfg80211_registered_device
*rdev
;
2298 struct wireless_dev
*wdev
;
2301 list_for_each_entry(rdev
, &cfg80211_rdev_list
, list
) {
2302 if (!net_eq(wiphy_net(&rdev
->wiphy
), sock_net(skb
->sk
)))
2304 if (wp_idx
< wp_start
) {
2310 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
2311 if (if_idx
< if_start
) {
2315 if (nl80211_send_iface(skb
, NETLINK_CB(cb
->skb
).portid
,
2316 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
2328 cb
->args
[0] = wp_idx
;
2329 cb
->args
[1] = if_idx
;
2334 static int nl80211_get_interface(struct sk_buff
*skb
, struct genl_info
*info
)
2336 struct sk_buff
*msg
;
2337 struct cfg80211_registered_device
*dev
= info
->user_ptr
[0];
2338 struct wireless_dev
*wdev
= info
->user_ptr
[1];
2340 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2344 if (nl80211_send_iface(msg
, info
->snd_portid
, info
->snd_seq
, 0,
2350 return genlmsg_reply(msg
, info
);
2353 static const struct nla_policy mntr_flags_policy
[NL80211_MNTR_FLAG_MAX
+ 1] = {
2354 [NL80211_MNTR_FLAG_FCSFAIL
] = { .type
= NLA_FLAG
},
2355 [NL80211_MNTR_FLAG_PLCPFAIL
] = { .type
= NLA_FLAG
},
2356 [NL80211_MNTR_FLAG_CONTROL
] = { .type
= NLA_FLAG
},
2357 [NL80211_MNTR_FLAG_OTHER_BSS
] = { .type
= NLA_FLAG
},
2358 [NL80211_MNTR_FLAG_COOK_FRAMES
] = { .type
= NLA_FLAG
},
2359 [NL80211_MNTR_FLAG_ACTIVE
] = { .type
= NLA_FLAG
},
2362 static int parse_monitor_flags(struct nlattr
*nla
, u32
*mntrflags
)
2364 struct nlattr
*flags
[NL80211_MNTR_FLAG_MAX
+ 1];
2372 if (nla_parse_nested(flags
, NL80211_MNTR_FLAG_MAX
,
2373 nla
, mntr_flags_policy
))
2376 for (flag
= 1; flag
<= NL80211_MNTR_FLAG_MAX
; flag
++)
2378 *mntrflags
|= (1<<flag
);
2383 static int nl80211_valid_4addr(struct cfg80211_registered_device
*rdev
,
2384 struct net_device
*netdev
, u8 use_4addr
,
2385 enum nl80211_iftype iftype
)
2388 if (netdev
&& (netdev
->priv_flags
& IFF_BRIDGE_PORT
))
2394 case NL80211_IFTYPE_AP_VLAN
:
2395 if (rdev
->wiphy
.flags
& WIPHY_FLAG_4ADDR_AP
)
2398 case NL80211_IFTYPE_STATION
:
2399 if (rdev
->wiphy
.flags
& WIPHY_FLAG_4ADDR_STATION
)
2409 static int nl80211_set_interface(struct sk_buff
*skb
, struct genl_info
*info
)
2411 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2412 struct vif_params params
;
2414 enum nl80211_iftype otype
, ntype
;
2415 struct net_device
*dev
= info
->user_ptr
[1];
2416 u32 _flags
, *flags
= NULL
;
2417 bool change
= false;
2419 memset(¶ms
, 0, sizeof(params
));
2421 otype
= ntype
= dev
->ieee80211_ptr
->iftype
;
2423 if (info
->attrs
[NL80211_ATTR_IFTYPE
]) {
2424 ntype
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFTYPE
]);
2427 if (ntype
> NL80211_IFTYPE_MAX
)
2431 if (info
->attrs
[NL80211_ATTR_MESH_ID
]) {
2432 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
2434 if (ntype
!= NL80211_IFTYPE_MESH_POINT
)
2436 if (netif_running(dev
))
2440 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN
!=
2441 IEEE80211_MAX_MESH_ID_LEN
);
2442 wdev
->mesh_id_up_len
=
2443 nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
2444 memcpy(wdev
->ssid
, nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]),
2445 wdev
->mesh_id_up_len
);
2449 if (info
->attrs
[NL80211_ATTR_4ADDR
]) {
2450 params
.use_4addr
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_4ADDR
]);
2452 err
= nl80211_valid_4addr(rdev
, dev
, params
.use_4addr
, ntype
);
2456 params
.use_4addr
= -1;
2459 if (info
->attrs
[NL80211_ATTR_MNTR_FLAGS
]) {
2460 if (ntype
!= NL80211_IFTYPE_MONITOR
)
2462 err
= parse_monitor_flags(info
->attrs
[NL80211_ATTR_MNTR_FLAGS
],
2471 if (flags
&& (*flags
& MONITOR_FLAG_ACTIVE
) &&
2472 !(rdev
->wiphy
.features
& NL80211_FEATURE_ACTIVE_MONITOR
))
2476 err
= cfg80211_change_iface(rdev
, dev
, ntype
, flags
, ¶ms
);
2480 if (!err
&& params
.use_4addr
!= -1)
2481 dev
->ieee80211_ptr
->use_4addr
= params
.use_4addr
;
2486 static int nl80211_new_interface(struct sk_buff
*skb
, struct genl_info
*info
)
2488 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2489 struct vif_params params
;
2490 struct wireless_dev
*wdev
;
2491 struct sk_buff
*msg
;
2493 enum nl80211_iftype type
= NL80211_IFTYPE_UNSPECIFIED
;
2496 memset(¶ms
, 0, sizeof(params
));
2498 if (!info
->attrs
[NL80211_ATTR_IFNAME
])
2501 if (info
->attrs
[NL80211_ATTR_IFTYPE
]) {
2502 type
= nla_get_u32(info
->attrs
[NL80211_ATTR_IFTYPE
]);
2503 if (type
> NL80211_IFTYPE_MAX
)
2507 if (!rdev
->ops
->add_virtual_intf
||
2508 !(rdev
->wiphy
.interface_modes
& (1 << type
)))
2511 if (type
== NL80211_IFTYPE_P2P_DEVICE
&& info
->attrs
[NL80211_ATTR_MAC
]) {
2512 nla_memcpy(params
.macaddr
, info
->attrs
[NL80211_ATTR_MAC
],
2514 if (!is_valid_ether_addr(params
.macaddr
))
2515 return -EADDRNOTAVAIL
;
2518 if (info
->attrs
[NL80211_ATTR_4ADDR
]) {
2519 params
.use_4addr
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_4ADDR
]);
2520 err
= nl80211_valid_4addr(rdev
, NULL
, params
.use_4addr
, type
);
2525 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2529 err
= parse_monitor_flags(type
== NL80211_IFTYPE_MONITOR
?
2530 info
->attrs
[NL80211_ATTR_MNTR_FLAGS
] : NULL
,
2533 if (!err
&& (flags
& MONITOR_FLAG_ACTIVE
) &&
2534 !(rdev
->wiphy
.features
& NL80211_FEATURE_ACTIVE_MONITOR
))
2537 wdev
= rdev_add_virtual_intf(rdev
,
2538 nla_data(info
->attrs
[NL80211_ATTR_IFNAME
]),
2539 type
, err
? NULL
: &flags
, ¶ms
);
2542 return PTR_ERR(wdev
);
2546 case NL80211_IFTYPE_MESH_POINT
:
2547 if (!info
->attrs
[NL80211_ATTR_MESH_ID
])
2550 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN
!=
2551 IEEE80211_MAX_MESH_ID_LEN
);
2552 wdev
->mesh_id_up_len
=
2553 nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
2554 memcpy(wdev
->ssid
, nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]),
2555 wdev
->mesh_id_up_len
);
2558 case NL80211_IFTYPE_P2P_DEVICE
:
2560 * P2P Device doesn't have a netdev, so doesn't go
2561 * through the netdev notifier and must be added here
2563 mutex_init(&wdev
->mtx
);
2564 INIT_LIST_HEAD(&wdev
->event_list
);
2565 spin_lock_init(&wdev
->event_lock
);
2566 INIT_LIST_HEAD(&wdev
->mgmt_registrations
);
2567 spin_lock_init(&wdev
->mgmt_registrations_lock
);
2569 wdev
->identifier
= ++rdev
->wdev_id
;
2570 list_add_rcu(&wdev
->list
, &rdev
->wdev_list
);
2571 rdev
->devlist_generation
++;
2577 if (nl80211_send_iface(msg
, info
->snd_portid
, info
->snd_seq
, 0,
2583 return genlmsg_reply(msg
, info
);
2586 static int nl80211_del_interface(struct sk_buff
*skb
, struct genl_info
*info
)
2588 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2589 struct wireless_dev
*wdev
= info
->user_ptr
[1];
2591 if (!rdev
->ops
->del_virtual_intf
)
2595 * If we remove a wireless device without a netdev then clear
2596 * user_ptr[1] so that nl80211_post_doit won't dereference it
2597 * to check if it needs to do dev_put(). Otherwise it crashes
2598 * since the wdev has been freed, unlike with a netdev where
2599 * we need the dev_put() for the netdev to really be freed.
2602 info
->user_ptr
[1] = NULL
;
2604 return rdev_del_virtual_intf(rdev
, wdev
);
2607 static int nl80211_set_noack_map(struct sk_buff
*skb
, struct genl_info
*info
)
2609 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2610 struct net_device
*dev
= info
->user_ptr
[1];
2613 if (!info
->attrs
[NL80211_ATTR_NOACK_MAP
])
2616 if (!rdev
->ops
->set_noack_map
)
2619 noack_map
= nla_get_u16(info
->attrs
[NL80211_ATTR_NOACK_MAP
]);
2621 return rdev_set_noack_map(rdev
, dev
, noack_map
);
2624 struct get_key_cookie
{
2625 struct sk_buff
*msg
;
2630 static void get_key_callback(void *c
, struct key_params
*params
)
2633 struct get_key_cookie
*cookie
= c
;
2636 nla_put(cookie
->msg
, NL80211_ATTR_KEY_DATA
,
2637 params
->key_len
, params
->key
)) ||
2639 nla_put(cookie
->msg
, NL80211_ATTR_KEY_SEQ
,
2640 params
->seq_len
, params
->seq
)) ||
2642 nla_put_u32(cookie
->msg
, NL80211_ATTR_KEY_CIPHER
,
2644 goto nla_put_failure
;
2646 key
= nla_nest_start(cookie
->msg
, NL80211_ATTR_KEY
);
2648 goto nla_put_failure
;
2651 nla_put(cookie
->msg
, NL80211_KEY_DATA
,
2652 params
->key_len
, params
->key
)) ||
2654 nla_put(cookie
->msg
, NL80211_KEY_SEQ
,
2655 params
->seq_len
, params
->seq
)) ||
2657 nla_put_u32(cookie
->msg
, NL80211_KEY_CIPHER
,
2659 goto nla_put_failure
;
2661 if (nla_put_u8(cookie
->msg
, NL80211_ATTR_KEY_IDX
, cookie
->idx
))
2662 goto nla_put_failure
;
2664 nla_nest_end(cookie
->msg
, key
);
2671 static int nl80211_get_key(struct sk_buff
*skb
, struct genl_info
*info
)
2673 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2675 struct net_device
*dev
= info
->user_ptr
[1];
2677 const u8
*mac_addr
= NULL
;
2679 struct get_key_cookie cookie
= {
2683 struct sk_buff
*msg
;
2685 if (info
->attrs
[NL80211_ATTR_KEY_IDX
])
2686 key_idx
= nla_get_u8(info
->attrs
[NL80211_ATTR_KEY_IDX
]);
2691 if (info
->attrs
[NL80211_ATTR_MAC
])
2692 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2694 pairwise
= !!mac_addr
;
2695 if (info
->attrs
[NL80211_ATTR_KEY_TYPE
]) {
2696 u32 kt
= nla_get_u32(info
->attrs
[NL80211_ATTR_KEY_TYPE
]);
2697 if (kt
>= NUM_NL80211_KEYTYPES
)
2699 if (kt
!= NL80211_KEYTYPE_GROUP
&&
2700 kt
!= NL80211_KEYTYPE_PAIRWISE
)
2702 pairwise
= kt
== NL80211_KEYTYPE_PAIRWISE
;
2705 if (!rdev
->ops
->get_key
)
2708 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
2712 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
2713 NL80211_CMD_NEW_KEY
);
2715 goto nla_put_failure
;
2718 cookie
.idx
= key_idx
;
2720 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
2721 nla_put_u8(msg
, NL80211_ATTR_KEY_IDX
, key_idx
))
2722 goto nla_put_failure
;
2724 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
))
2725 goto nla_put_failure
;
2727 if (pairwise
&& mac_addr
&&
2728 !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
2731 err
= rdev_get_key(rdev
, dev
, key_idx
, pairwise
, mac_addr
, &cookie
,
2738 goto nla_put_failure
;
2740 genlmsg_end(msg
, hdr
);
2741 return genlmsg_reply(msg
, info
);
2750 static int nl80211_set_key(struct sk_buff
*skb
, struct genl_info
*info
)
2752 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2753 struct key_parse key
;
2755 struct net_device
*dev
= info
->user_ptr
[1];
2757 err
= nl80211_parse_key(info
, &key
);
2764 /* only support setting default key */
2765 if (!key
.def
&& !key
.defmgmt
)
2768 wdev_lock(dev
->ieee80211_ptr
);
2771 if (!rdev
->ops
->set_default_key
) {
2776 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2780 err
= rdev_set_default_key(rdev
, dev
, key
.idx
,
2781 key
.def_uni
, key
.def_multi
);
2786 #ifdef CONFIG_CFG80211_WEXT
2787 dev
->ieee80211_ptr
->wext
.default_key
= key
.idx
;
2790 if (key
.def_uni
|| !key
.def_multi
) {
2795 if (!rdev
->ops
->set_default_mgmt_key
) {
2800 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2804 err
= rdev_set_default_mgmt_key(rdev
, dev
, key
.idx
);
2808 #ifdef CONFIG_CFG80211_WEXT
2809 dev
->ieee80211_ptr
->wext
.default_mgmt_key
= key
.idx
;
2814 wdev_unlock(dev
->ieee80211_ptr
);
2819 static int nl80211_new_key(struct sk_buff
*skb
, struct genl_info
*info
)
2821 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2823 struct net_device
*dev
= info
->user_ptr
[1];
2824 struct key_parse key
;
2825 const u8
*mac_addr
= NULL
;
2827 err
= nl80211_parse_key(info
, &key
);
2834 if (info
->attrs
[NL80211_ATTR_MAC
])
2835 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2837 if (key
.type
== -1) {
2839 key
.type
= NL80211_KEYTYPE_PAIRWISE
;
2841 key
.type
= NL80211_KEYTYPE_GROUP
;
2845 if (key
.type
!= NL80211_KEYTYPE_PAIRWISE
&&
2846 key
.type
!= NL80211_KEYTYPE_GROUP
)
2849 if (!rdev
->ops
->add_key
)
2852 if (cfg80211_validate_key_settings(rdev
, &key
.p
, key
.idx
,
2853 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
2857 wdev_lock(dev
->ieee80211_ptr
);
2858 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2860 err
= rdev_add_key(rdev
, dev
, key
.idx
,
2861 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
2863 wdev_unlock(dev
->ieee80211_ptr
);
2868 static int nl80211_del_key(struct sk_buff
*skb
, struct genl_info
*info
)
2870 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2872 struct net_device
*dev
= info
->user_ptr
[1];
2873 u8
*mac_addr
= NULL
;
2874 struct key_parse key
;
2876 err
= nl80211_parse_key(info
, &key
);
2880 if (info
->attrs
[NL80211_ATTR_MAC
])
2881 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
2883 if (key
.type
== -1) {
2885 key
.type
= NL80211_KEYTYPE_PAIRWISE
;
2887 key
.type
= NL80211_KEYTYPE_GROUP
;
2891 if (key
.type
!= NL80211_KEYTYPE_PAIRWISE
&&
2892 key
.type
!= NL80211_KEYTYPE_GROUP
)
2895 if (!rdev
->ops
->del_key
)
2898 wdev_lock(dev
->ieee80211_ptr
);
2899 err
= nl80211_key_allowed(dev
->ieee80211_ptr
);
2901 if (key
.type
== NL80211_KEYTYPE_PAIRWISE
&& mac_addr
&&
2902 !(rdev
->wiphy
.flags
& WIPHY_FLAG_IBSS_RSN
))
2906 err
= rdev_del_key(rdev
, dev
, key
.idx
,
2907 key
.type
== NL80211_KEYTYPE_PAIRWISE
,
2910 #ifdef CONFIG_CFG80211_WEXT
2912 if (key
.idx
== dev
->ieee80211_ptr
->wext
.default_key
)
2913 dev
->ieee80211_ptr
->wext
.default_key
= -1;
2914 else if (key
.idx
== dev
->ieee80211_ptr
->wext
.default_mgmt_key
)
2915 dev
->ieee80211_ptr
->wext
.default_mgmt_key
= -1;
2918 wdev_unlock(dev
->ieee80211_ptr
);
2923 /* This function returns an error or the number of nested attributes */
2924 static int validate_acl_mac_addrs(struct nlattr
*nl_attr
)
2926 struct nlattr
*attr
;
2927 int n_entries
= 0, tmp
;
2929 nla_for_each_nested(attr
, nl_attr
, tmp
) {
2930 if (nla_len(attr
) != ETH_ALEN
)
2940 * This function parses ACL information and allocates memory for ACL data.
2941 * On successful return, the calling function is responsible to free the
2942 * ACL buffer returned by this function.
2944 static struct cfg80211_acl_data
*parse_acl_data(struct wiphy
*wiphy
,
2945 struct genl_info
*info
)
2947 enum nl80211_acl_policy acl_policy
;
2948 struct nlattr
*attr
;
2949 struct cfg80211_acl_data
*acl
;
2950 int i
= 0, n_entries
, tmp
;
2952 if (!wiphy
->max_acl_mac_addrs
)
2953 return ERR_PTR(-EOPNOTSUPP
);
2955 if (!info
->attrs
[NL80211_ATTR_ACL_POLICY
])
2956 return ERR_PTR(-EINVAL
);
2958 acl_policy
= nla_get_u32(info
->attrs
[NL80211_ATTR_ACL_POLICY
]);
2959 if (acl_policy
!= NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED
&&
2960 acl_policy
!= NL80211_ACL_POLICY_DENY_UNLESS_LISTED
)
2961 return ERR_PTR(-EINVAL
);
2963 if (!info
->attrs
[NL80211_ATTR_MAC_ADDRS
])
2964 return ERR_PTR(-EINVAL
);
2966 n_entries
= validate_acl_mac_addrs(info
->attrs
[NL80211_ATTR_MAC_ADDRS
]);
2968 return ERR_PTR(n_entries
);
2970 if (n_entries
> wiphy
->max_acl_mac_addrs
)
2971 return ERR_PTR(-ENOTSUPP
);
2973 acl
= kzalloc(sizeof(*acl
) + (sizeof(struct mac_address
) * n_entries
),
2976 return ERR_PTR(-ENOMEM
);
2978 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_MAC_ADDRS
], tmp
) {
2979 memcpy(acl
->mac_addrs
[i
].addr
, nla_data(attr
), ETH_ALEN
);
2983 acl
->n_acl_entries
= n_entries
;
2984 acl
->acl_policy
= acl_policy
;
2989 static int nl80211_set_mac_acl(struct sk_buff
*skb
, struct genl_info
*info
)
2991 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
2992 struct net_device
*dev
= info
->user_ptr
[1];
2993 struct cfg80211_acl_data
*acl
;
2996 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
2997 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3000 if (!dev
->ieee80211_ptr
->beacon_interval
)
3003 acl
= parse_acl_data(&rdev
->wiphy
, info
);
3005 return PTR_ERR(acl
);
3007 err
= rdev_set_mac_acl(rdev
, dev
, acl
);
3014 static int nl80211_parse_beacon(struct nlattr
*attrs
[],
3015 struct cfg80211_beacon_data
*bcn
)
3017 bool haveinfo
= false;
3019 if (!is_valid_ie_attr(attrs
[NL80211_ATTR_BEACON_TAIL
]) ||
3020 !is_valid_ie_attr(attrs
[NL80211_ATTR_IE
]) ||
3021 !is_valid_ie_attr(attrs
[NL80211_ATTR_IE_PROBE_RESP
]) ||
3022 !is_valid_ie_attr(attrs
[NL80211_ATTR_IE_ASSOC_RESP
]))
3025 memset(bcn
, 0, sizeof(*bcn
));
3027 if (attrs
[NL80211_ATTR_BEACON_HEAD
]) {
3028 bcn
->head
= nla_data(attrs
[NL80211_ATTR_BEACON_HEAD
]);
3029 bcn
->head_len
= nla_len(attrs
[NL80211_ATTR_BEACON_HEAD
]);
3035 if (attrs
[NL80211_ATTR_BEACON_TAIL
]) {
3036 bcn
->tail
= nla_data(attrs
[NL80211_ATTR_BEACON_TAIL
]);
3037 bcn
->tail_len
= nla_len(attrs
[NL80211_ATTR_BEACON_TAIL
]);
3044 if (attrs
[NL80211_ATTR_IE
]) {
3045 bcn
->beacon_ies
= nla_data(attrs
[NL80211_ATTR_IE
]);
3046 bcn
->beacon_ies_len
= nla_len(attrs
[NL80211_ATTR_IE
]);
3049 if (attrs
[NL80211_ATTR_IE_PROBE_RESP
]) {
3050 bcn
->proberesp_ies
=
3051 nla_data(attrs
[NL80211_ATTR_IE_PROBE_RESP
]);
3052 bcn
->proberesp_ies_len
=
3053 nla_len(attrs
[NL80211_ATTR_IE_PROBE_RESP
]);
3056 if (attrs
[NL80211_ATTR_IE_ASSOC_RESP
]) {
3057 bcn
->assocresp_ies
=
3058 nla_data(attrs
[NL80211_ATTR_IE_ASSOC_RESP
]);
3059 bcn
->assocresp_ies_len
=
3060 nla_len(attrs
[NL80211_ATTR_IE_ASSOC_RESP
]);
3063 if (attrs
[NL80211_ATTR_PROBE_RESP
]) {
3064 bcn
->probe_resp
= nla_data(attrs
[NL80211_ATTR_PROBE_RESP
]);
3065 bcn
->probe_resp_len
= nla_len(attrs
[NL80211_ATTR_PROBE_RESP
]);
3071 static bool nl80211_get_ap_channel(struct cfg80211_registered_device
*rdev
,
3072 struct cfg80211_ap_settings
*params
)
3074 struct wireless_dev
*wdev
;
3077 list_for_each_entry(wdev
, &rdev
->wdev_list
, list
) {
3078 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
3079 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3082 if (!wdev
->preset_chandef
.chan
)
3085 params
->chandef
= wdev
->preset_chandef
;
3093 static bool nl80211_valid_auth_type(struct cfg80211_registered_device
*rdev
,
3094 enum nl80211_auth_type auth_type
,
3095 enum nl80211_commands cmd
)
3097 if (auth_type
> NL80211_AUTHTYPE_MAX
)
3101 case NL80211_CMD_AUTHENTICATE
:
3102 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_SAE
) &&
3103 auth_type
== NL80211_AUTHTYPE_SAE
)
3106 case NL80211_CMD_CONNECT
:
3107 case NL80211_CMD_START_AP
:
3108 /* SAE not supported yet */
3109 if (auth_type
== NL80211_AUTHTYPE_SAE
)
3117 static int nl80211_start_ap(struct sk_buff
*skb
, struct genl_info
*info
)
3119 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3120 struct net_device
*dev
= info
->user_ptr
[1];
3121 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
3122 struct cfg80211_ap_settings params
;
3124 u8 radar_detect_width
= 0;
3126 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
3127 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3130 if (!rdev
->ops
->start_ap
)
3133 if (wdev
->beacon_interval
)
3136 memset(¶ms
, 0, sizeof(params
));
3138 /* these are required for START_AP */
3139 if (!info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
] ||
3140 !info
->attrs
[NL80211_ATTR_DTIM_PERIOD
] ||
3141 !info
->attrs
[NL80211_ATTR_BEACON_HEAD
])
3144 err
= nl80211_parse_beacon(info
->attrs
, ¶ms
.beacon
);
3148 params
.beacon_interval
=
3149 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
3150 params
.dtim_period
=
3151 nla_get_u32(info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]);
3153 err
= cfg80211_validate_beacon_int(rdev
, params
.beacon_interval
);
3158 * In theory, some of these attributes should be required here
3159 * but since they were not used when the command was originally
3160 * added, keep them optional for old user space programs to let
3161 * them continue to work with drivers that do not need the
3162 * additional information -- drivers must check!
3164 if (info
->attrs
[NL80211_ATTR_SSID
]) {
3165 params
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
3167 nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
3168 if (params
.ssid_len
== 0 ||
3169 params
.ssid_len
> IEEE80211_MAX_SSID_LEN
)
3173 if (info
->attrs
[NL80211_ATTR_HIDDEN_SSID
]) {
3174 params
.hidden_ssid
= nla_get_u32(
3175 info
->attrs
[NL80211_ATTR_HIDDEN_SSID
]);
3176 if (params
.hidden_ssid
!= NL80211_HIDDEN_SSID_NOT_IN_USE
&&
3177 params
.hidden_ssid
!= NL80211_HIDDEN_SSID_ZERO_LEN
&&
3178 params
.hidden_ssid
!= NL80211_HIDDEN_SSID_ZERO_CONTENTS
)
3182 params
.privacy
= !!info
->attrs
[NL80211_ATTR_PRIVACY
];
3184 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
3185 params
.auth_type
= nla_get_u32(
3186 info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
3187 if (!nl80211_valid_auth_type(rdev
, params
.auth_type
,
3188 NL80211_CMD_START_AP
))
3191 params
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
3193 err
= nl80211_crypto_settings(rdev
, info
, ¶ms
.crypto
,
3194 NL80211_MAX_NR_CIPHER_SUITES
);
3198 if (info
->attrs
[NL80211_ATTR_INACTIVITY_TIMEOUT
]) {
3199 if (!(rdev
->wiphy
.features
& NL80211_FEATURE_INACTIVITY_TIMER
))
3201 params
.inactivity_timeout
= nla_get_u16(
3202 info
->attrs
[NL80211_ATTR_INACTIVITY_TIMEOUT
]);
3205 if (info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]) {
3206 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3208 params
.p2p_ctwindow
=
3209 nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]);
3210 if (params
.p2p_ctwindow
> 127)
3212 if (params
.p2p_ctwindow
!= 0 &&
3213 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_CTWIN
))
3217 if (info
->attrs
[NL80211_ATTR_P2P_OPPPS
]) {
3220 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3222 tmp
= nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_OPPPS
]);
3225 params
.p2p_opp_ps
= tmp
;
3226 if (params
.p2p_opp_ps
!= 0 &&
3227 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_OPPPS
))
3231 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
3232 err
= nl80211_parse_chandef(rdev
, info
, ¶ms
.chandef
);
3235 } else if (wdev
->preset_chandef
.chan
) {
3236 params
.chandef
= wdev
->preset_chandef
;
3237 } else if (!nl80211_get_ap_channel(rdev
, ¶ms
))
3240 if (!cfg80211_reg_can_beacon(&rdev
->wiphy
, ¶ms
.chandef
))
3243 err
= cfg80211_chandef_dfs_required(wdev
->wiphy
, ¶ms
.chandef
);
3247 radar_detect_width
= BIT(params
.chandef
.width
);
3248 params
.radar_required
= true;
3251 err
= cfg80211_can_use_iftype_chan(rdev
, wdev
, wdev
->iftype
,
3252 params
.chandef
.chan
,
3254 radar_detect_width
);
3258 if (info
->attrs
[NL80211_ATTR_ACL_POLICY
]) {
3259 params
.acl
= parse_acl_data(&rdev
->wiphy
, info
);
3260 if (IS_ERR(params
.acl
))
3261 return PTR_ERR(params
.acl
);
3265 err
= rdev_start_ap(rdev
, dev
, ¶ms
);
3267 wdev
->preset_chandef
= params
.chandef
;
3268 wdev
->beacon_interval
= params
.beacon_interval
;
3269 wdev
->channel
= params
.chandef
.chan
;
3270 wdev
->ssid_len
= params
.ssid_len
;
3271 memcpy(wdev
->ssid
, params
.ssid
, wdev
->ssid_len
);
3280 static int nl80211_set_beacon(struct sk_buff
*skb
, struct genl_info
*info
)
3282 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3283 struct net_device
*dev
= info
->user_ptr
[1];
3284 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
3285 struct cfg80211_beacon_data params
;
3288 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
3289 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
3292 if (!rdev
->ops
->change_beacon
)
3295 if (!wdev
->beacon_interval
)
3298 err
= nl80211_parse_beacon(info
->attrs
, ¶ms
);
3303 err
= rdev_change_beacon(rdev
, dev
, ¶ms
);
3309 static int nl80211_stop_ap(struct sk_buff
*skb
, struct genl_info
*info
)
3311 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3312 struct net_device
*dev
= info
->user_ptr
[1];
3314 return cfg80211_stop_ap(rdev
, dev
);
3317 static const struct nla_policy sta_flags_policy
[NL80211_STA_FLAG_MAX
+ 1] = {
3318 [NL80211_STA_FLAG_AUTHORIZED
] = { .type
= NLA_FLAG
},
3319 [NL80211_STA_FLAG_SHORT_PREAMBLE
] = { .type
= NLA_FLAG
},
3320 [NL80211_STA_FLAG_WME
] = { .type
= NLA_FLAG
},
3321 [NL80211_STA_FLAG_MFP
] = { .type
= NLA_FLAG
},
3322 [NL80211_STA_FLAG_AUTHENTICATED
] = { .type
= NLA_FLAG
},
3323 [NL80211_STA_FLAG_TDLS_PEER
] = { .type
= NLA_FLAG
},
3326 static int parse_station_flags(struct genl_info
*info
,
3327 enum nl80211_iftype iftype
,
3328 struct station_parameters
*params
)
3330 struct nlattr
*flags
[NL80211_STA_FLAG_MAX
+ 1];
3335 * Try parsing the new attribute first so userspace
3336 * can specify both for older kernels.
3338 nla
= info
->attrs
[NL80211_ATTR_STA_FLAGS2
];
3340 struct nl80211_sta_flag_update
*sta_flags
;
3342 sta_flags
= nla_data(nla
);
3343 params
->sta_flags_mask
= sta_flags
->mask
;
3344 params
->sta_flags_set
= sta_flags
->set
;
3345 params
->sta_flags_set
&= params
->sta_flags_mask
;
3346 if ((params
->sta_flags_mask
|
3347 params
->sta_flags_set
) & BIT(__NL80211_STA_FLAG_INVALID
))
3352 /* if present, parse the old attribute */
3354 nla
= info
->attrs
[NL80211_ATTR_STA_FLAGS
];
3358 if (nla_parse_nested(flags
, NL80211_STA_FLAG_MAX
,
3359 nla
, sta_flags_policy
))
3363 * Only allow certain flags for interface types so that
3364 * other attributes are silently ignored. Remember that
3365 * this is backward compatibility code with old userspace
3366 * and shouldn't be hit in other cases anyway.
3369 case NL80211_IFTYPE_AP
:
3370 case NL80211_IFTYPE_AP_VLAN
:
3371 case NL80211_IFTYPE_P2P_GO
:
3372 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
) |
3373 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
) |
3374 BIT(NL80211_STA_FLAG_WME
) |
3375 BIT(NL80211_STA_FLAG_MFP
);
3377 case NL80211_IFTYPE_P2P_CLIENT
:
3378 case NL80211_IFTYPE_STATION
:
3379 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHORIZED
) |
3380 BIT(NL80211_STA_FLAG_TDLS_PEER
);
3382 case NL80211_IFTYPE_MESH_POINT
:
3383 params
->sta_flags_mask
= BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
3384 BIT(NL80211_STA_FLAG_MFP
) |
3385 BIT(NL80211_STA_FLAG_AUTHORIZED
);
3390 for (flag
= 1; flag
<= NL80211_STA_FLAG_MAX
; flag
++) {
3392 params
->sta_flags_set
|= (1<<flag
);
3394 /* no longer support new API additions in old API */
3395 if (flag
> NL80211_STA_FLAG_MAX_OLD_API
)
3403 static bool nl80211_put_sta_rate(struct sk_buff
*msg
, struct rate_info
*info
,
3406 struct nlattr
*rate
;
3410 rate
= nla_nest_start(msg
, attr
);
3414 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
3415 bitrate
= cfg80211_calculate_bitrate(info
);
3416 /* report 16-bit bitrate only if we can */
3417 bitrate_compat
= bitrate
< (1UL << 16) ? bitrate
: 0;
3419 nla_put_u32(msg
, NL80211_RATE_INFO_BITRATE32
, bitrate
))
3421 if (bitrate_compat
> 0 &&
3422 nla_put_u16(msg
, NL80211_RATE_INFO_BITRATE
, bitrate_compat
))
3425 if (info
->flags
& RATE_INFO_FLAGS_MCS
) {
3426 if (nla_put_u8(msg
, NL80211_RATE_INFO_MCS
, info
->mcs
))
3428 if (info
->flags
& RATE_INFO_FLAGS_40_MHZ_WIDTH
&&
3429 nla_put_flag(msg
, NL80211_RATE_INFO_40_MHZ_WIDTH
))
3431 if (info
->flags
& RATE_INFO_FLAGS_SHORT_GI
&&
3432 nla_put_flag(msg
, NL80211_RATE_INFO_SHORT_GI
))
3434 } else if (info
->flags
& RATE_INFO_FLAGS_VHT_MCS
) {
3435 if (nla_put_u8(msg
, NL80211_RATE_INFO_VHT_MCS
, info
->mcs
))
3437 if (nla_put_u8(msg
, NL80211_RATE_INFO_VHT_NSS
, info
->nss
))
3439 if (info
->flags
& RATE_INFO_FLAGS_40_MHZ_WIDTH
&&
3440 nla_put_flag(msg
, NL80211_RATE_INFO_40_MHZ_WIDTH
))
3442 if (info
->flags
& RATE_INFO_FLAGS_80_MHZ_WIDTH
&&
3443 nla_put_flag(msg
, NL80211_RATE_INFO_80_MHZ_WIDTH
))
3445 if (info
->flags
& RATE_INFO_FLAGS_80P80_MHZ_WIDTH
&&
3446 nla_put_flag(msg
, NL80211_RATE_INFO_80P80_MHZ_WIDTH
))
3448 if (info
->flags
& RATE_INFO_FLAGS_160_MHZ_WIDTH
&&
3449 nla_put_flag(msg
, NL80211_RATE_INFO_160_MHZ_WIDTH
))
3451 if (info
->flags
& RATE_INFO_FLAGS_SHORT_GI
&&
3452 nla_put_flag(msg
, NL80211_RATE_INFO_SHORT_GI
))
3456 nla_nest_end(msg
, rate
);
3460 static bool nl80211_put_signal(struct sk_buff
*msg
, u8 mask
, s8
*signal
,
3469 attr
= nla_nest_start(msg
, id
);
3473 for (i
= 0; i
< IEEE80211_MAX_CHAINS
; i
++) {
3474 if (!(mask
& BIT(i
)))
3477 if (nla_put_u8(msg
, i
, signal
[i
]))
3481 nla_nest_end(msg
, attr
);
3486 static int nl80211_send_station(struct sk_buff
*msg
, u32 portid
, u32 seq
,
3488 struct cfg80211_registered_device
*rdev
,
3489 struct net_device
*dev
,
3490 const u8
*mac_addr
, struct station_info
*sinfo
)
3493 struct nlattr
*sinfoattr
, *bss_param
;
3495 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, NL80211_CMD_NEW_STATION
);
3499 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
3500 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
) ||
3501 nla_put_u32(msg
, NL80211_ATTR_GENERATION
, sinfo
->generation
))
3502 goto nla_put_failure
;
3504 sinfoattr
= nla_nest_start(msg
, NL80211_ATTR_STA_INFO
);
3506 goto nla_put_failure
;
3507 if ((sinfo
->filled
& STATION_INFO_CONNECTED_TIME
) &&
3508 nla_put_u32(msg
, NL80211_STA_INFO_CONNECTED_TIME
,
3509 sinfo
->connected_time
))
3510 goto nla_put_failure
;
3511 if ((sinfo
->filled
& STATION_INFO_INACTIVE_TIME
) &&
3512 nla_put_u32(msg
, NL80211_STA_INFO_INACTIVE_TIME
,
3513 sinfo
->inactive_time
))
3514 goto nla_put_failure
;
3515 if ((sinfo
->filled
& (STATION_INFO_RX_BYTES
|
3516 STATION_INFO_RX_BYTES64
)) &&
3517 nla_put_u32(msg
, NL80211_STA_INFO_RX_BYTES
,
3518 (u32
)sinfo
->rx_bytes
))
3519 goto nla_put_failure
;
3520 if ((sinfo
->filled
& (STATION_INFO_TX_BYTES
|
3521 STATION_INFO_TX_BYTES64
)) &&
3522 nla_put_u32(msg
, NL80211_STA_INFO_TX_BYTES
,
3523 (u32
)sinfo
->tx_bytes
))
3524 goto nla_put_failure
;
3525 if ((sinfo
->filled
& STATION_INFO_RX_BYTES64
) &&
3526 nla_put_u64(msg
, NL80211_STA_INFO_RX_BYTES64
,
3528 goto nla_put_failure
;
3529 if ((sinfo
->filled
& STATION_INFO_TX_BYTES64
) &&
3530 nla_put_u64(msg
, NL80211_STA_INFO_TX_BYTES64
,
3532 goto nla_put_failure
;
3533 if ((sinfo
->filled
& STATION_INFO_LLID
) &&
3534 nla_put_u16(msg
, NL80211_STA_INFO_LLID
, sinfo
->llid
))
3535 goto nla_put_failure
;
3536 if ((sinfo
->filled
& STATION_INFO_PLID
) &&
3537 nla_put_u16(msg
, NL80211_STA_INFO_PLID
, sinfo
->plid
))
3538 goto nla_put_failure
;
3539 if ((sinfo
->filled
& STATION_INFO_PLINK_STATE
) &&
3540 nla_put_u8(msg
, NL80211_STA_INFO_PLINK_STATE
,
3541 sinfo
->plink_state
))
3542 goto nla_put_failure
;
3543 switch (rdev
->wiphy
.signal_type
) {
3544 case CFG80211_SIGNAL_TYPE_MBM
:
3545 if ((sinfo
->filled
& STATION_INFO_SIGNAL
) &&
3546 nla_put_u8(msg
, NL80211_STA_INFO_SIGNAL
,
3548 goto nla_put_failure
;
3549 if ((sinfo
->filled
& STATION_INFO_SIGNAL_AVG
) &&
3550 nla_put_u8(msg
, NL80211_STA_INFO_SIGNAL_AVG
,
3552 goto nla_put_failure
;
3557 if (sinfo
->filled
& STATION_INFO_CHAIN_SIGNAL
) {
3558 if (!nl80211_put_signal(msg
, sinfo
->chains
,
3559 sinfo
->chain_signal
,
3560 NL80211_STA_INFO_CHAIN_SIGNAL
))
3561 goto nla_put_failure
;
3563 if (sinfo
->filled
& STATION_INFO_CHAIN_SIGNAL_AVG
) {
3564 if (!nl80211_put_signal(msg
, sinfo
->chains
,
3565 sinfo
->chain_signal_avg
,
3566 NL80211_STA_INFO_CHAIN_SIGNAL_AVG
))
3567 goto nla_put_failure
;
3569 if (sinfo
->filled
& STATION_INFO_TX_BITRATE
) {
3570 if (!nl80211_put_sta_rate(msg
, &sinfo
->txrate
,
3571 NL80211_STA_INFO_TX_BITRATE
))
3572 goto nla_put_failure
;
3574 if (sinfo
->filled
& STATION_INFO_RX_BITRATE
) {
3575 if (!nl80211_put_sta_rate(msg
, &sinfo
->rxrate
,
3576 NL80211_STA_INFO_RX_BITRATE
))
3577 goto nla_put_failure
;
3579 if ((sinfo
->filled
& STATION_INFO_RX_PACKETS
) &&
3580 nla_put_u32(msg
, NL80211_STA_INFO_RX_PACKETS
,
3582 goto nla_put_failure
;
3583 if ((sinfo
->filled
& STATION_INFO_TX_PACKETS
) &&
3584 nla_put_u32(msg
, NL80211_STA_INFO_TX_PACKETS
,
3586 goto nla_put_failure
;
3587 if ((sinfo
->filled
& STATION_INFO_TX_RETRIES
) &&
3588 nla_put_u32(msg
, NL80211_STA_INFO_TX_RETRIES
,
3590 goto nla_put_failure
;
3591 if ((sinfo
->filled
& STATION_INFO_TX_FAILED
) &&
3592 nla_put_u32(msg
, NL80211_STA_INFO_TX_FAILED
,
3594 goto nla_put_failure
;
3595 if ((sinfo
->filled
& STATION_INFO_BEACON_LOSS_COUNT
) &&
3596 nla_put_u32(msg
, NL80211_STA_INFO_BEACON_LOSS
,
3597 sinfo
->beacon_loss_count
))
3598 goto nla_put_failure
;
3599 if ((sinfo
->filled
& STATION_INFO_LOCAL_PM
) &&
3600 nla_put_u32(msg
, NL80211_STA_INFO_LOCAL_PM
,
3602 goto nla_put_failure
;
3603 if ((sinfo
->filled
& STATION_INFO_PEER_PM
) &&
3604 nla_put_u32(msg
, NL80211_STA_INFO_PEER_PM
,
3606 goto nla_put_failure
;
3607 if ((sinfo
->filled
& STATION_INFO_NONPEER_PM
) &&
3608 nla_put_u32(msg
, NL80211_STA_INFO_NONPEER_PM
,
3610 goto nla_put_failure
;
3611 if (sinfo
->filled
& STATION_INFO_BSS_PARAM
) {
3612 bss_param
= nla_nest_start(msg
, NL80211_STA_INFO_BSS_PARAM
);
3614 goto nla_put_failure
;
3616 if (((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_CTS_PROT
) &&
3617 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_CTS_PROT
)) ||
3618 ((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_SHORT_PREAMBLE
) &&
3619 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE
)) ||
3620 ((sinfo
->bss_param
.flags
& BSS_PARAM_FLAGS_SHORT_SLOT_TIME
) &&
3621 nla_put_flag(msg
, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME
)) ||
3622 nla_put_u8(msg
, NL80211_STA_BSS_PARAM_DTIM_PERIOD
,
3623 sinfo
->bss_param
.dtim_period
) ||
3624 nla_put_u16(msg
, NL80211_STA_BSS_PARAM_BEACON_INTERVAL
,
3625 sinfo
->bss_param
.beacon_interval
))
3626 goto nla_put_failure
;
3628 nla_nest_end(msg
, bss_param
);
3630 if ((sinfo
->filled
& STATION_INFO_STA_FLAGS
) &&
3631 nla_put(msg
, NL80211_STA_INFO_STA_FLAGS
,
3632 sizeof(struct nl80211_sta_flag_update
),
3634 goto nla_put_failure
;
3635 if ((sinfo
->filled
& STATION_INFO_T_OFFSET
) &&
3636 nla_put_u64(msg
, NL80211_STA_INFO_T_OFFSET
,
3638 goto nla_put_failure
;
3639 nla_nest_end(msg
, sinfoattr
);
3641 if ((sinfo
->filled
& STATION_INFO_ASSOC_REQ_IES
) &&
3642 nla_put(msg
, NL80211_ATTR_IE
, sinfo
->assoc_req_ies_len
,
3643 sinfo
->assoc_req_ies
))
3644 goto nla_put_failure
;
3646 return genlmsg_end(msg
, hdr
);
3649 genlmsg_cancel(msg
, hdr
);
3653 static int nl80211_dump_station(struct sk_buff
*skb
,
3654 struct netlink_callback
*cb
)
3656 struct station_info sinfo
;
3657 struct cfg80211_registered_device
*dev
;
3658 struct wireless_dev
*wdev
;
3659 u8 mac_addr
[ETH_ALEN
];
3660 int sta_idx
= cb
->args
[2];
3663 err
= nl80211_prepare_wdev_dump(skb
, cb
, &dev
, &wdev
);
3667 if (!wdev
->netdev
) {
3672 if (!dev
->ops
->dump_station
) {
3678 memset(&sinfo
, 0, sizeof(sinfo
));
3679 err
= rdev_dump_station(dev
, wdev
->netdev
, sta_idx
,
3686 if (nl80211_send_station(skb
,
3687 NETLINK_CB(cb
->skb
).portid
,
3688 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
3689 dev
, wdev
->netdev
, mac_addr
,
3698 cb
->args
[2] = sta_idx
;
3701 nl80211_finish_wdev_dump(dev
);
3706 static int nl80211_get_station(struct sk_buff
*skb
, struct genl_info
*info
)
3708 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
3709 struct net_device
*dev
= info
->user_ptr
[1];
3710 struct station_info sinfo
;
3711 struct sk_buff
*msg
;
3712 u8
*mac_addr
= NULL
;
3715 memset(&sinfo
, 0, sizeof(sinfo
));
3717 if (!info
->attrs
[NL80211_ATTR_MAC
])
3720 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
3722 if (!rdev
->ops
->get_station
)
3725 err
= rdev_get_station(rdev
, dev
, mac_addr
, &sinfo
);
3729 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
3733 if (nl80211_send_station(msg
, info
->snd_portid
, info
->snd_seq
, 0,
3734 rdev
, dev
, mac_addr
, &sinfo
) < 0) {
3739 return genlmsg_reply(msg
, info
);
3742 int cfg80211_check_station_change(struct wiphy
*wiphy
,
3743 struct station_parameters
*params
,
3744 enum cfg80211_station_type statype
)
3746 if (params
->listen_interval
!= -1)
3751 /* When you run into this, adjust the code below for the new flag */
3752 BUILD_BUG_ON(NL80211_STA_FLAG_MAX
!= 7);
3755 case CFG80211_STA_MESH_PEER_KERNEL
:
3756 case CFG80211_STA_MESH_PEER_USER
:
3758 * No ignoring the TDLS flag here -- the userspace mesh
3759 * code doesn't have the bug of including TDLS in the
3762 if (params
->sta_flags_mask
&
3763 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
3764 BIT(NL80211_STA_FLAG_MFP
) |
3765 BIT(NL80211_STA_FLAG_AUTHORIZED
)))
3768 case CFG80211_STA_TDLS_PEER_SETUP
:
3769 case CFG80211_STA_TDLS_PEER_ACTIVE
:
3770 if (!(params
->sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)))
3772 /* ignore since it can't change */
3773 params
->sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
3776 /* disallow mesh-specific things */
3777 if (params
->plink_action
!= NL80211_PLINK_ACTION_NO_ACTION
)
3779 if (params
->local_pm
)
3781 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_PLINK_STATE
)
3785 if (statype
!= CFG80211_STA_TDLS_PEER_SETUP
&&
3786 statype
!= CFG80211_STA_TDLS_PEER_ACTIVE
) {
3787 /* TDLS can't be set, ... */
3788 if (params
->sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
))
3791 * ... but don't bother the driver with it. This works around
3792 * a hostapd/wpa_supplicant issue -- it always includes the
3793 * TLDS_PEER flag in the mask even for AP mode.
3795 params
->sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
3798 if (statype
!= CFG80211_STA_TDLS_PEER_SETUP
) {
3799 /* reject other things that can't change */
3800 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_UAPSD
)
3802 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_CAPABILITY
)
3804 if (params
->supported_rates
)
3806 if (params
->ext_capab
|| params
->ht_capa
|| params
->vht_capa
)
3810 if (statype
!= CFG80211_STA_AP_CLIENT
) {
3816 case CFG80211_STA_AP_MLME_CLIENT
:
3817 /* Use this only for authorizing/unauthorizing a station */
3818 if (!(params
->sta_flags_mask
& BIT(NL80211_STA_FLAG_AUTHORIZED
)))
3821 case CFG80211_STA_AP_CLIENT
:
3822 /* accept only the listed bits */
3823 if (params
->sta_flags_mask
&
3824 ~(BIT(NL80211_STA_FLAG_AUTHORIZED
) |
3825 BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
3826 BIT(NL80211_STA_FLAG_ASSOCIATED
) |
3827 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE
) |
3828 BIT(NL80211_STA_FLAG_WME
) |
3829 BIT(NL80211_STA_FLAG_MFP
)))
3832 /* but authenticated/associated only if driver handles it */
3833 if (!(wiphy
->features
& NL80211_FEATURE_FULL_AP_CLIENT_STATE
) &&
3834 params
->sta_flags_mask
&
3835 (BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
3836 BIT(NL80211_STA_FLAG_ASSOCIATED
)))
3839 case CFG80211_STA_IBSS
:
3840 case CFG80211_STA_AP_STA
:
3841 /* reject any changes other than AUTHORIZED */
3842 if (params
->sta_flags_mask
& ~BIT(NL80211_STA_FLAG_AUTHORIZED
))
3845 case CFG80211_STA_TDLS_PEER_SETUP
:
3846 /* reject any changes other than AUTHORIZED or WME */
3847 if (params
->sta_flags_mask
& ~(BIT(NL80211_STA_FLAG_AUTHORIZED
) |
3848 BIT(NL80211_STA_FLAG_WME
)))
3850 /* force (at least) rates when authorizing */
3851 if (params
->sta_flags_set
& BIT(NL80211_STA_FLAG_AUTHORIZED
) &&
3852 !params
->supported_rates
)
3855 case CFG80211_STA_TDLS_PEER_ACTIVE
:
3856 /* reject any changes */
3858 case CFG80211_STA_MESH_PEER_KERNEL
:
3859 if (params
->sta_modify_mask
& STATION_PARAM_APPLY_PLINK_STATE
)
3862 case CFG80211_STA_MESH_PEER_USER
:
3863 if (params
->plink_action
!= NL80211_PLINK_ACTION_NO_ACTION
)
3870 EXPORT_SYMBOL(cfg80211_check_station_change
);
3873 * Get vlan interface making sure it is running and on the right wiphy.
3875 static struct net_device
*get_vlan(struct genl_info
*info
,
3876 struct cfg80211_registered_device
*rdev
)
3878 struct nlattr
*vlanattr
= info
->attrs
[NL80211_ATTR_STA_VLAN
];
3879 struct net_device
*v
;
3885 v
= dev_get_by_index(genl_info_net(info
), nla_get_u32(vlanattr
));
3887 return ERR_PTR(-ENODEV
);
3889 if (!v
->ieee80211_ptr
|| v
->ieee80211_ptr
->wiphy
!= &rdev
->wiphy
) {
3894 if (v
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
3895 v
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
3896 v
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
) {
3901 if (!netif_running(v
)) {
3909 return ERR_PTR(ret
);
3912 static struct nla_policy
3913 nl80211_sta_wme_policy
[NL80211_STA_WME_MAX
+ 1] __read_mostly
= {
3914 [NL80211_STA_WME_UAPSD_QUEUES
] = { .type
= NLA_U8
},
3915 [NL80211_STA_WME_MAX_SP
] = { .type
= NLA_U8
},
3918 static int nl80211_parse_sta_wme(struct genl_info
*info
,
3919 struct station_parameters
*params
)
3921 struct nlattr
*tb
[NL80211_STA_WME_MAX
+ 1];
3925 /* parse WME attributes if present */
3926 if (!info
->attrs
[NL80211_ATTR_STA_WME
])
3929 nla
= info
->attrs
[NL80211_ATTR_STA_WME
];
3930 err
= nla_parse_nested(tb
, NL80211_STA_WME_MAX
, nla
,
3931 nl80211_sta_wme_policy
);
3935 if (tb
[NL80211_STA_WME_UAPSD_QUEUES
])
3936 params
->uapsd_queues
= nla_get_u8(
3937 tb
[NL80211_STA_WME_UAPSD_QUEUES
]);
3938 if (params
->uapsd_queues
& ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK
)
3941 if (tb
[NL80211_STA_WME_MAX_SP
])
3942 params
->max_sp
= nla_get_u8(tb
[NL80211_STA_WME_MAX_SP
]);
3944 if (params
->max_sp
& ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK
)
3947 params
->sta_modify_mask
|= STATION_PARAM_APPLY_UAPSD
;
3952 static int nl80211_parse_sta_channel_info(struct genl_info
*info
,
3953 struct station_parameters
*params
)
3955 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_CHANNELS
]) {
3956 params
->supported_channels
=
3957 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_CHANNELS
]);
3958 params
->supported_channels_len
=
3959 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_CHANNELS
]);
3961 * Need to include at least one (first channel, number of
3962 * channels) tuple for each subband, and must have proper
3963 * tuples for the rest of the data as well.
3965 if (params
->supported_channels_len
< 2)
3967 if (params
->supported_channels_len
% 2)
3971 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
]) {
3972 params
->supported_oper_classes
=
3973 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
]);
3974 params
->supported_oper_classes_len
=
3975 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES
]);
3977 * The value of the Length field of the Supported Operating
3978 * Classes element is between 2 and 253.
3980 if (params
->supported_oper_classes_len
< 2 ||
3981 params
->supported_oper_classes_len
> 253)
3987 static int nl80211_set_station_tdls(struct genl_info
*info
,
3988 struct station_parameters
*params
)
3991 /* Dummy STA entry gets updated once the peer capabilities are known */
3992 if (info
->attrs
[NL80211_ATTR_PEER_AID
])
3993 params
->aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_PEER_AID
]);
3994 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
])
3996 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
3997 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
])
3999 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]);
4001 err
= nl80211_parse_sta_channel_info(info
, params
);
4005 return nl80211_parse_sta_wme(info
, params
);
4008 static int nl80211_set_station(struct sk_buff
*skb
, struct genl_info
*info
)
4010 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4011 struct net_device
*dev
= info
->user_ptr
[1];
4012 struct station_parameters params
;
4016 memset(¶ms
, 0, sizeof(params
));
4018 params
.listen_interval
= -1;
4020 if (!rdev
->ops
->change_station
)
4023 if (info
->attrs
[NL80211_ATTR_STA_AID
])
4026 if (!info
->attrs
[NL80211_ATTR_MAC
])
4029 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4031 if (info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]) {
4032 params
.supported_rates
=
4033 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
4034 params
.supported_rates_len
=
4035 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
4038 if (info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]) {
4040 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]);
4041 params
.sta_modify_mask
|= STATION_PARAM_APPLY_CAPABILITY
;
4044 if (info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]) {
4046 nla_data(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
4047 params
.ext_capab_len
=
4048 nla_len(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
4051 if (info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
])
4054 if (parse_station_flags(info
, dev
->ieee80211_ptr
->iftype
, ¶ms
))
4057 if (info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]) {
4058 params
.plink_action
=
4059 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]);
4060 if (params
.plink_action
>= NUM_NL80211_PLINK_ACTIONS
)
4064 if (info
->attrs
[NL80211_ATTR_STA_PLINK_STATE
]) {
4065 params
.plink_state
=
4066 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_STATE
]);
4067 if (params
.plink_state
>= NUM_NL80211_PLINK_STATES
)
4069 params
.sta_modify_mask
|= STATION_PARAM_APPLY_PLINK_STATE
;
4072 if (info
->attrs
[NL80211_ATTR_LOCAL_MESH_POWER_MODE
]) {
4073 enum nl80211_mesh_power_mode pm
= nla_get_u32(
4074 info
->attrs
[NL80211_ATTR_LOCAL_MESH_POWER_MODE
]);
4076 if (pm
<= NL80211_MESH_POWER_UNKNOWN
||
4077 pm
> NL80211_MESH_POWER_MAX
)
4080 params
.local_pm
= pm
;
4083 /* Include parameters for TDLS peer (will check later) */
4084 err
= nl80211_set_station_tdls(info
, ¶ms
);
4088 params
.vlan
= get_vlan(info
, rdev
);
4089 if (IS_ERR(params
.vlan
))
4090 return PTR_ERR(params
.vlan
);
4092 switch (dev
->ieee80211_ptr
->iftype
) {
4093 case NL80211_IFTYPE_AP
:
4094 case NL80211_IFTYPE_AP_VLAN
:
4095 case NL80211_IFTYPE_P2P_GO
:
4096 case NL80211_IFTYPE_P2P_CLIENT
:
4097 case NL80211_IFTYPE_STATION
:
4098 case NL80211_IFTYPE_ADHOC
:
4099 case NL80211_IFTYPE_MESH_POINT
:
4106 /* driver will call cfg80211_check_station_change() */
4107 err
= rdev_change_station(rdev
, dev
, mac_addr
, ¶ms
);
4111 dev_put(params
.vlan
);
4116 static int nl80211_new_station(struct sk_buff
*skb
, struct genl_info
*info
)
4118 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4120 struct net_device
*dev
= info
->user_ptr
[1];
4121 struct station_parameters params
;
4122 u8
*mac_addr
= NULL
;
4124 memset(¶ms
, 0, sizeof(params
));
4126 if (!rdev
->ops
->add_station
)
4129 if (!info
->attrs
[NL80211_ATTR_MAC
])
4132 if (!info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
])
4135 if (!info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
])
4138 if (!info
->attrs
[NL80211_ATTR_STA_AID
] &&
4139 !info
->attrs
[NL80211_ATTR_PEER_AID
])
4142 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4143 params
.supported_rates
=
4144 nla_data(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
4145 params
.supported_rates_len
=
4146 nla_len(info
->attrs
[NL80211_ATTR_STA_SUPPORTED_RATES
]);
4147 params
.listen_interval
=
4148 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_LISTEN_INTERVAL
]);
4150 if (info
->attrs
[NL80211_ATTR_PEER_AID
])
4151 params
.aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_PEER_AID
]);
4153 params
.aid
= nla_get_u16(info
->attrs
[NL80211_ATTR_STA_AID
]);
4154 if (!params
.aid
|| params
.aid
> IEEE80211_MAX_AID
)
4157 if (info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]) {
4159 nla_get_u16(info
->attrs
[NL80211_ATTR_STA_CAPABILITY
]);
4160 params
.sta_modify_mask
|= STATION_PARAM_APPLY_CAPABILITY
;
4163 if (info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]) {
4165 nla_data(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
4166 params
.ext_capab_len
=
4167 nla_len(info
->attrs
[NL80211_ATTR_STA_EXT_CAPABILITY
]);
4170 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
])
4172 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]);
4174 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
])
4176 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]);
4178 if (info
->attrs
[NL80211_ATTR_OPMODE_NOTIF
]) {
4179 params
.opmode_notif_used
= true;
4180 params
.opmode_notif
=
4181 nla_get_u8(info
->attrs
[NL80211_ATTR_OPMODE_NOTIF
]);
4184 if (info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]) {
4185 params
.plink_action
=
4186 nla_get_u8(info
->attrs
[NL80211_ATTR_STA_PLINK_ACTION
]);
4187 if (params
.plink_action
>= NUM_NL80211_PLINK_ACTIONS
)
4191 err
= nl80211_parse_sta_channel_info(info
, ¶ms
);
4195 err
= nl80211_parse_sta_wme(info
, ¶ms
);
4199 if (parse_station_flags(info
, dev
->ieee80211_ptr
->iftype
, ¶ms
))
4202 /* When you run into this, adjust the code below for the new flag */
4203 BUILD_BUG_ON(NL80211_STA_FLAG_MAX
!= 7);
4205 switch (dev
->ieee80211_ptr
->iftype
) {
4206 case NL80211_IFTYPE_AP
:
4207 case NL80211_IFTYPE_AP_VLAN
:
4208 case NL80211_IFTYPE_P2P_GO
:
4209 /* ignore WME attributes if iface/sta is not capable */
4210 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_AP_UAPSD
) ||
4211 !(params
.sta_flags_set
& BIT(NL80211_STA_FLAG_WME
)))
4212 params
.sta_modify_mask
&= ~STATION_PARAM_APPLY_UAPSD
;
4214 /* TDLS peers cannot be added */
4215 if ((params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)) ||
4216 info
->attrs
[NL80211_ATTR_PEER_AID
])
4218 /* but don't bother the driver with it */
4219 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_TDLS_PEER
);
4221 /* allow authenticated/associated only if driver handles it */
4222 if (!(rdev
->wiphy
.features
&
4223 NL80211_FEATURE_FULL_AP_CLIENT_STATE
) &&
4224 params
.sta_flags_mask
&
4225 (BIT(NL80211_STA_FLAG_AUTHENTICATED
) |
4226 BIT(NL80211_STA_FLAG_ASSOCIATED
)))
4229 /* must be last in here for error handling */
4230 params
.vlan
= get_vlan(info
, rdev
);
4231 if (IS_ERR(params
.vlan
))
4232 return PTR_ERR(params
.vlan
);
4234 case NL80211_IFTYPE_MESH_POINT
:
4235 /* ignore uAPSD data */
4236 params
.sta_modify_mask
&= ~STATION_PARAM_APPLY_UAPSD
;
4238 /* associated is disallowed */
4239 if (params
.sta_flags_mask
& BIT(NL80211_STA_FLAG_ASSOCIATED
))
4241 /* TDLS peers cannot be added */
4242 if ((params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)) ||
4243 info
->attrs
[NL80211_ATTR_PEER_AID
])
4246 case NL80211_IFTYPE_STATION
:
4247 case NL80211_IFTYPE_P2P_CLIENT
:
4248 /* ignore uAPSD data */
4249 params
.sta_modify_mask
&= ~STATION_PARAM_APPLY_UAPSD
;
4251 /* these are disallowed */
4252 if (params
.sta_flags_mask
&
4253 (BIT(NL80211_STA_FLAG_ASSOCIATED
) |
4254 BIT(NL80211_STA_FLAG_AUTHENTICATED
)))
4256 /* Only TDLS peers can be added */
4257 if (!(params
.sta_flags_set
& BIT(NL80211_STA_FLAG_TDLS_PEER
)))
4259 /* Can only add if TDLS ... */
4260 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
))
4262 /* ... with external setup is supported */
4263 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_TDLS_EXTERNAL_SETUP
))
4266 * Older wpa_supplicant versions always mark the TDLS peer
4267 * as authorized, but it shouldn't yet be.
4269 params
.sta_flags_mask
&= ~BIT(NL80211_STA_FLAG_AUTHORIZED
);
4275 /* be aware of params.vlan when changing code here */
4277 err
= rdev_add_station(rdev
, dev
, mac_addr
, ¶ms
);
4280 dev_put(params
.vlan
);
4284 static int nl80211_del_station(struct sk_buff
*skb
, struct genl_info
*info
)
4286 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4287 struct net_device
*dev
= info
->user_ptr
[1];
4288 u8
*mac_addr
= NULL
;
4290 if (info
->attrs
[NL80211_ATTR_MAC
])
4291 mac_addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4293 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
4294 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP_VLAN
&&
4295 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
&&
4296 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
4299 if (!rdev
->ops
->del_station
)
4302 return rdev_del_station(rdev
, dev
, mac_addr
);
4305 static int nl80211_send_mpath(struct sk_buff
*msg
, u32 portid
, u32 seq
,
4306 int flags
, struct net_device
*dev
,
4307 u8
*dst
, u8
*next_hop
,
4308 struct mpath_info
*pinfo
)
4311 struct nlattr
*pinfoattr
;
4313 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, NL80211_CMD_NEW_STATION
);
4317 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
4318 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, dst
) ||
4319 nla_put(msg
, NL80211_ATTR_MPATH_NEXT_HOP
, ETH_ALEN
, next_hop
) ||
4320 nla_put_u32(msg
, NL80211_ATTR_GENERATION
, pinfo
->generation
))
4321 goto nla_put_failure
;
4323 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_MPATH_INFO
);
4325 goto nla_put_failure
;
4326 if ((pinfo
->filled
& MPATH_INFO_FRAME_QLEN
) &&
4327 nla_put_u32(msg
, NL80211_MPATH_INFO_FRAME_QLEN
,
4329 goto nla_put_failure
;
4330 if (((pinfo
->filled
& MPATH_INFO_SN
) &&
4331 nla_put_u32(msg
, NL80211_MPATH_INFO_SN
, pinfo
->sn
)) ||
4332 ((pinfo
->filled
& MPATH_INFO_METRIC
) &&
4333 nla_put_u32(msg
, NL80211_MPATH_INFO_METRIC
,
4335 ((pinfo
->filled
& MPATH_INFO_EXPTIME
) &&
4336 nla_put_u32(msg
, NL80211_MPATH_INFO_EXPTIME
,
4338 ((pinfo
->filled
& MPATH_INFO_FLAGS
) &&
4339 nla_put_u8(msg
, NL80211_MPATH_INFO_FLAGS
,
4341 ((pinfo
->filled
& MPATH_INFO_DISCOVERY_TIMEOUT
) &&
4342 nla_put_u32(msg
, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT
,
4343 pinfo
->discovery_timeout
)) ||
4344 ((pinfo
->filled
& MPATH_INFO_DISCOVERY_RETRIES
) &&
4345 nla_put_u8(msg
, NL80211_MPATH_INFO_DISCOVERY_RETRIES
,
4346 pinfo
->discovery_retries
)))
4347 goto nla_put_failure
;
4349 nla_nest_end(msg
, pinfoattr
);
4351 return genlmsg_end(msg
, hdr
);
4354 genlmsg_cancel(msg
, hdr
);
4358 static int nl80211_dump_mpath(struct sk_buff
*skb
,
4359 struct netlink_callback
*cb
)
4361 struct mpath_info pinfo
;
4362 struct cfg80211_registered_device
*dev
;
4363 struct wireless_dev
*wdev
;
4365 u8 next_hop
[ETH_ALEN
];
4366 int path_idx
= cb
->args
[2];
4369 err
= nl80211_prepare_wdev_dump(skb
, cb
, &dev
, &wdev
);
4373 if (!dev
->ops
->dump_mpath
) {
4378 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
) {
4384 err
= rdev_dump_mpath(dev
, wdev
->netdev
, path_idx
, dst
,
4391 if (nl80211_send_mpath(skb
, NETLINK_CB(cb
->skb
).portid
,
4392 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
4393 wdev
->netdev
, dst
, next_hop
,
4402 cb
->args
[2] = path_idx
;
4405 nl80211_finish_wdev_dump(dev
);
4409 static int nl80211_get_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
4411 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4413 struct net_device
*dev
= info
->user_ptr
[1];
4414 struct mpath_info pinfo
;
4415 struct sk_buff
*msg
;
4417 u8 next_hop
[ETH_ALEN
];
4419 memset(&pinfo
, 0, sizeof(pinfo
));
4421 if (!info
->attrs
[NL80211_ATTR_MAC
])
4424 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4426 if (!rdev
->ops
->get_mpath
)
4429 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
4432 err
= rdev_get_mpath(rdev
, dev
, dst
, next_hop
, &pinfo
);
4436 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
4440 if (nl80211_send_mpath(msg
, info
->snd_portid
, info
->snd_seq
, 0,
4441 dev
, dst
, next_hop
, &pinfo
) < 0) {
4446 return genlmsg_reply(msg
, info
);
4449 static int nl80211_set_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
4451 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4452 struct net_device
*dev
= info
->user_ptr
[1];
4454 u8
*next_hop
= NULL
;
4456 if (!info
->attrs
[NL80211_ATTR_MAC
])
4459 if (!info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
])
4462 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4463 next_hop
= nla_data(info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
]);
4465 if (!rdev
->ops
->change_mpath
)
4468 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
4471 return rdev_change_mpath(rdev
, dev
, dst
, next_hop
);
4474 static int nl80211_new_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
4476 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4477 struct net_device
*dev
= info
->user_ptr
[1];
4479 u8
*next_hop
= NULL
;
4481 if (!info
->attrs
[NL80211_ATTR_MAC
])
4484 if (!info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
])
4487 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4488 next_hop
= nla_data(info
->attrs
[NL80211_ATTR_MPATH_NEXT_HOP
]);
4490 if (!rdev
->ops
->add_mpath
)
4493 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
4496 return rdev_add_mpath(rdev
, dev
, dst
, next_hop
);
4499 static int nl80211_del_mpath(struct sk_buff
*skb
, struct genl_info
*info
)
4501 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4502 struct net_device
*dev
= info
->user_ptr
[1];
4505 if (info
->attrs
[NL80211_ATTR_MAC
])
4506 dst
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
4508 if (!rdev
->ops
->del_mpath
)
4511 return rdev_del_mpath(rdev
, dev
, dst
);
4514 static int nl80211_set_bss(struct sk_buff
*skb
, struct genl_info
*info
)
4516 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4517 struct net_device
*dev
= info
->user_ptr
[1];
4518 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
4519 struct bss_parameters params
;
4522 memset(¶ms
, 0, sizeof(params
));
4523 /* default to not changing parameters */
4524 params
.use_cts_prot
= -1;
4525 params
.use_short_preamble
= -1;
4526 params
.use_short_slot_time
= -1;
4527 params
.ap_isolate
= -1;
4528 params
.ht_opmode
= -1;
4529 params
.p2p_ctwindow
= -1;
4530 params
.p2p_opp_ps
= -1;
4532 if (info
->attrs
[NL80211_ATTR_BSS_CTS_PROT
])
4533 params
.use_cts_prot
=
4534 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_CTS_PROT
]);
4535 if (info
->attrs
[NL80211_ATTR_BSS_SHORT_PREAMBLE
])
4536 params
.use_short_preamble
=
4537 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_SHORT_PREAMBLE
]);
4538 if (info
->attrs
[NL80211_ATTR_BSS_SHORT_SLOT_TIME
])
4539 params
.use_short_slot_time
=
4540 nla_get_u8(info
->attrs
[NL80211_ATTR_BSS_SHORT_SLOT_TIME
]);
4541 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
4542 params
.basic_rates
=
4543 nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
4544 params
.basic_rates_len
=
4545 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
4547 if (info
->attrs
[NL80211_ATTR_AP_ISOLATE
])
4548 params
.ap_isolate
= !!nla_get_u8(info
->attrs
[NL80211_ATTR_AP_ISOLATE
]);
4549 if (info
->attrs
[NL80211_ATTR_BSS_HT_OPMODE
])
4551 nla_get_u16(info
->attrs
[NL80211_ATTR_BSS_HT_OPMODE
]);
4553 if (info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]) {
4554 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
4556 params
.p2p_ctwindow
=
4557 nla_get_s8(info
->attrs
[NL80211_ATTR_P2P_CTWINDOW
]);
4558 if (params
.p2p_ctwindow
< 0)
4560 if (params
.p2p_ctwindow
!= 0 &&
4561 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_CTWIN
))
4565 if (info
->attrs
[NL80211_ATTR_P2P_OPPPS
]) {
4568 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
4570 tmp
= nla_get_u8(info
->attrs
[NL80211_ATTR_P2P_OPPPS
]);
4573 params
.p2p_opp_ps
= tmp
;
4574 if (params
.p2p_opp_ps
&&
4575 !(rdev
->wiphy
.features
& NL80211_FEATURE_P2P_GO_OPPPS
))
4579 if (!rdev
->ops
->change_bss
)
4582 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_AP
&&
4583 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_GO
)
4587 err
= rdev_change_bss(rdev
, dev
, ¶ms
);
4593 static const struct nla_policy reg_rule_policy
[NL80211_REG_RULE_ATTR_MAX
+ 1] = {
4594 [NL80211_ATTR_REG_RULE_FLAGS
] = { .type
= NLA_U32
},
4595 [NL80211_ATTR_FREQ_RANGE_START
] = { .type
= NLA_U32
},
4596 [NL80211_ATTR_FREQ_RANGE_END
] = { .type
= NLA_U32
},
4597 [NL80211_ATTR_FREQ_RANGE_MAX_BW
] = { .type
= NLA_U32
},
4598 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
] = { .type
= NLA_U32
},
4599 [NL80211_ATTR_POWER_RULE_MAX_EIRP
] = { .type
= NLA_U32
},
4602 static int parse_reg_rule(struct nlattr
*tb
[],
4603 struct ieee80211_reg_rule
*reg_rule
)
4605 struct ieee80211_freq_range
*freq_range
= ®_rule
->freq_range
;
4606 struct ieee80211_power_rule
*power_rule
= ®_rule
->power_rule
;
4608 if (!tb
[NL80211_ATTR_REG_RULE_FLAGS
])
4610 if (!tb
[NL80211_ATTR_FREQ_RANGE_START
])
4612 if (!tb
[NL80211_ATTR_FREQ_RANGE_END
])
4614 if (!tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
])
4616 if (!tb
[NL80211_ATTR_POWER_RULE_MAX_EIRP
])
4619 reg_rule
->flags
= nla_get_u32(tb
[NL80211_ATTR_REG_RULE_FLAGS
]);
4621 freq_range
->start_freq_khz
=
4622 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_START
]);
4623 freq_range
->end_freq_khz
=
4624 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_END
]);
4625 freq_range
->max_bandwidth_khz
=
4626 nla_get_u32(tb
[NL80211_ATTR_FREQ_RANGE_MAX_BW
]);
4628 power_rule
->max_eirp
=
4629 nla_get_u32(tb
[NL80211_ATTR_POWER_RULE_MAX_EIRP
]);
4631 if (tb
[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
])
4632 power_rule
->max_antenna_gain
=
4633 nla_get_u32(tb
[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
]);
4638 static int nl80211_req_set_reg(struct sk_buff
*skb
, struct genl_info
*info
)
4642 enum nl80211_user_reg_hint_type user_reg_hint_type
;
4645 * You should only get this when cfg80211 hasn't yet initialized
4646 * completely when built-in to the kernel right between the time
4647 * window between nl80211_init() and regulatory_init(), if that is
4650 if (unlikely(!rcu_access_pointer(cfg80211_regdomain
)))
4651 return -EINPROGRESS
;
4653 if (!info
->attrs
[NL80211_ATTR_REG_ALPHA2
])
4656 data
= nla_data(info
->attrs
[NL80211_ATTR_REG_ALPHA2
]);
4658 if (info
->attrs
[NL80211_ATTR_USER_REG_HINT_TYPE
])
4659 user_reg_hint_type
=
4660 nla_get_u32(info
->attrs
[NL80211_ATTR_USER_REG_HINT_TYPE
]);
4662 user_reg_hint_type
= NL80211_USER_REG_HINT_USER
;
4664 switch (user_reg_hint_type
) {
4665 case NL80211_USER_REG_HINT_USER
:
4666 case NL80211_USER_REG_HINT_CELL_BASE
:
4672 r
= regulatory_hint_user(data
, user_reg_hint_type
);
4677 static int nl80211_get_mesh_config(struct sk_buff
*skb
,
4678 struct genl_info
*info
)
4680 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4681 struct net_device
*dev
= info
->user_ptr
[1];
4682 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
4683 struct mesh_config cur_params
;
4686 struct nlattr
*pinfoattr
;
4687 struct sk_buff
*msg
;
4689 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
4692 if (!rdev
->ops
->get_mesh_config
)
4696 /* If not connected, get default parameters */
4697 if (!wdev
->mesh_id_len
)
4698 memcpy(&cur_params
, &default_mesh_config
, sizeof(cur_params
));
4700 err
= rdev_get_mesh_config(rdev
, dev
, &cur_params
);
4706 /* Draw up a netlink message to send back */
4707 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
4710 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
4711 NL80211_CMD_GET_MESH_CONFIG
);
4714 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_MESH_CONFIG
);
4716 goto nla_put_failure
;
4717 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
4718 nla_put_u16(msg
, NL80211_MESHCONF_RETRY_TIMEOUT
,
4719 cur_params
.dot11MeshRetryTimeout
) ||
4720 nla_put_u16(msg
, NL80211_MESHCONF_CONFIRM_TIMEOUT
,
4721 cur_params
.dot11MeshConfirmTimeout
) ||
4722 nla_put_u16(msg
, NL80211_MESHCONF_HOLDING_TIMEOUT
,
4723 cur_params
.dot11MeshHoldingTimeout
) ||
4724 nla_put_u16(msg
, NL80211_MESHCONF_MAX_PEER_LINKS
,
4725 cur_params
.dot11MeshMaxPeerLinks
) ||
4726 nla_put_u8(msg
, NL80211_MESHCONF_MAX_RETRIES
,
4727 cur_params
.dot11MeshMaxRetries
) ||
4728 nla_put_u8(msg
, NL80211_MESHCONF_TTL
,
4729 cur_params
.dot11MeshTTL
) ||
4730 nla_put_u8(msg
, NL80211_MESHCONF_ELEMENT_TTL
,
4731 cur_params
.element_ttl
) ||
4732 nla_put_u8(msg
, NL80211_MESHCONF_AUTO_OPEN_PLINKS
,
4733 cur_params
.auto_open_plinks
) ||
4734 nla_put_u32(msg
, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
,
4735 cur_params
.dot11MeshNbrOffsetMaxNeighbor
) ||
4736 nla_put_u8(msg
, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
,
4737 cur_params
.dot11MeshHWMPmaxPREQretries
) ||
4738 nla_put_u32(msg
, NL80211_MESHCONF_PATH_REFRESH_TIME
,
4739 cur_params
.path_refresh_time
) ||
4740 nla_put_u16(msg
, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
,
4741 cur_params
.min_discovery_timeout
) ||
4742 nla_put_u32(msg
, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
,
4743 cur_params
.dot11MeshHWMPactivePathTimeout
) ||
4744 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
,
4745 cur_params
.dot11MeshHWMPpreqMinInterval
) ||
4746 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
,
4747 cur_params
.dot11MeshHWMPperrMinInterval
) ||
4748 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
,
4749 cur_params
.dot11MeshHWMPnetDiameterTraversalTime
) ||
4750 nla_put_u8(msg
, NL80211_MESHCONF_HWMP_ROOTMODE
,
4751 cur_params
.dot11MeshHWMPRootMode
) ||
4752 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_RANN_INTERVAL
,
4753 cur_params
.dot11MeshHWMPRannInterval
) ||
4754 nla_put_u8(msg
, NL80211_MESHCONF_GATE_ANNOUNCEMENTS
,
4755 cur_params
.dot11MeshGateAnnouncementProtocol
) ||
4756 nla_put_u8(msg
, NL80211_MESHCONF_FORWARDING
,
4757 cur_params
.dot11MeshForwarding
) ||
4758 nla_put_u32(msg
, NL80211_MESHCONF_RSSI_THRESHOLD
,
4759 cur_params
.rssi_threshold
) ||
4760 nla_put_u32(msg
, NL80211_MESHCONF_HT_OPMODE
,
4761 cur_params
.ht_opmode
) ||
4762 nla_put_u32(msg
, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
,
4763 cur_params
.dot11MeshHWMPactivePathToRootTimeout
) ||
4764 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_ROOT_INTERVAL
,
4765 cur_params
.dot11MeshHWMProotInterval
) ||
4766 nla_put_u16(msg
, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL
,
4767 cur_params
.dot11MeshHWMPconfirmationInterval
) ||
4768 nla_put_u32(msg
, NL80211_MESHCONF_POWER_MODE
,
4769 cur_params
.power_mode
) ||
4770 nla_put_u16(msg
, NL80211_MESHCONF_AWAKE_WINDOW
,
4771 cur_params
.dot11MeshAwakeWindowDuration
) ||
4772 nla_put_u32(msg
, NL80211_MESHCONF_PLINK_TIMEOUT
,
4773 cur_params
.plink_timeout
))
4774 goto nla_put_failure
;
4775 nla_nest_end(msg
, pinfoattr
);
4776 genlmsg_end(msg
, hdr
);
4777 return genlmsg_reply(msg
, info
);
4780 genlmsg_cancel(msg
, hdr
);
4786 static const struct nla_policy nl80211_meshconf_params_policy
[NL80211_MESHCONF_ATTR_MAX
+1] = {
4787 [NL80211_MESHCONF_RETRY_TIMEOUT
] = { .type
= NLA_U16
},
4788 [NL80211_MESHCONF_CONFIRM_TIMEOUT
] = { .type
= NLA_U16
},
4789 [NL80211_MESHCONF_HOLDING_TIMEOUT
] = { .type
= NLA_U16
},
4790 [NL80211_MESHCONF_MAX_PEER_LINKS
] = { .type
= NLA_U16
},
4791 [NL80211_MESHCONF_MAX_RETRIES
] = { .type
= NLA_U8
},
4792 [NL80211_MESHCONF_TTL
] = { .type
= NLA_U8
},
4793 [NL80211_MESHCONF_ELEMENT_TTL
] = { .type
= NLA_U8
},
4794 [NL80211_MESHCONF_AUTO_OPEN_PLINKS
] = { .type
= NLA_U8
},
4795 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
] = { .type
= NLA_U32
},
4796 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
] = { .type
= NLA_U8
},
4797 [NL80211_MESHCONF_PATH_REFRESH_TIME
] = { .type
= NLA_U32
},
4798 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
] = { .type
= NLA_U16
},
4799 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
] = { .type
= NLA_U32
},
4800 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
] = { .type
= NLA_U16
},
4801 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
] = { .type
= NLA_U16
},
4802 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
] = { .type
= NLA_U16
},
4803 [NL80211_MESHCONF_HWMP_ROOTMODE
] = { .type
= NLA_U8
},
4804 [NL80211_MESHCONF_HWMP_RANN_INTERVAL
] = { .type
= NLA_U16
},
4805 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS
] = { .type
= NLA_U8
},
4806 [NL80211_MESHCONF_FORWARDING
] = { .type
= NLA_U8
},
4807 [NL80211_MESHCONF_RSSI_THRESHOLD
] = { .type
= NLA_U32
},
4808 [NL80211_MESHCONF_HT_OPMODE
] = { .type
= NLA_U16
},
4809 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
] = { .type
= NLA_U32
},
4810 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL
] = { .type
= NLA_U16
},
4811 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL
] = { .type
= NLA_U16
},
4812 [NL80211_MESHCONF_POWER_MODE
] = { .type
= NLA_U32
},
4813 [NL80211_MESHCONF_AWAKE_WINDOW
] = { .type
= NLA_U16
},
4814 [NL80211_MESHCONF_PLINK_TIMEOUT
] = { .type
= NLA_U32
},
4817 static const struct nla_policy
4818 nl80211_mesh_setup_params_policy
[NL80211_MESH_SETUP_ATTR_MAX
+1] = {
4819 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
] = { .type
= NLA_U8
},
4820 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
] = { .type
= NLA_U8
},
4821 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
] = { .type
= NLA_U8
},
4822 [NL80211_MESH_SETUP_USERSPACE_AUTH
] = { .type
= NLA_FLAG
},
4823 [NL80211_MESH_SETUP_AUTH_PROTOCOL
] = { .type
= NLA_U8
},
4824 [NL80211_MESH_SETUP_USERSPACE_MPM
] = { .type
= NLA_FLAG
},
4825 [NL80211_MESH_SETUP_IE
] = { .type
= NLA_BINARY
,
4826 .len
= IEEE80211_MAX_DATA_LEN
},
4827 [NL80211_MESH_SETUP_USERSPACE_AMPE
] = { .type
= NLA_FLAG
},
4830 static int nl80211_parse_mesh_config(struct genl_info
*info
,
4831 struct mesh_config
*cfg
,
4834 struct nlattr
*tb
[NL80211_MESHCONF_ATTR_MAX
+ 1];
4837 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
4840 if (fn(tb[attr]) < min || fn(tb[attr]) > max) \
4842 cfg->param = fn(tb[attr]); \
4843 mask |= (1 << (attr - 1)); \
4848 if (!info
->attrs
[NL80211_ATTR_MESH_CONFIG
])
4850 if (nla_parse_nested(tb
, NL80211_MESHCONF_ATTR_MAX
,
4851 info
->attrs
[NL80211_ATTR_MESH_CONFIG
],
4852 nl80211_meshconf_params_policy
))
4855 /* This makes sure that there aren't more than 32 mesh config
4856 * parameters (otherwise our bitfield scheme would not work.) */
4857 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX
> 32);
4859 /* Fill in the params struct */
4860 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshRetryTimeout
, 1, 255,
4861 mask
, NL80211_MESHCONF_RETRY_TIMEOUT
,
4863 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshConfirmTimeout
, 1, 255,
4864 mask
, NL80211_MESHCONF_CONFIRM_TIMEOUT
,
4866 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHoldingTimeout
, 1, 255,
4867 mask
, NL80211_MESHCONF_HOLDING_TIMEOUT
,
4869 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshMaxPeerLinks
, 0, 255,
4870 mask
, NL80211_MESHCONF_MAX_PEER_LINKS
,
4872 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshMaxRetries
, 0, 16,
4873 mask
, NL80211_MESHCONF_MAX_RETRIES
,
4875 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshTTL
, 1, 255,
4876 mask
, NL80211_MESHCONF_TTL
, nla_get_u8
);
4877 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, element_ttl
, 1, 255,
4878 mask
, NL80211_MESHCONF_ELEMENT_TTL
,
4880 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, auto_open_plinks
, 0, 1,
4881 mask
, NL80211_MESHCONF_AUTO_OPEN_PLINKS
,
4883 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshNbrOffsetMaxNeighbor
,
4885 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR
,
4887 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPmaxPREQretries
, 0, 255,
4888 mask
, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES
,
4890 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, path_refresh_time
, 1, 65535,
4891 mask
, NL80211_MESHCONF_PATH_REFRESH_TIME
,
4893 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, min_discovery_timeout
, 1, 65535,
4894 mask
, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT
,
4896 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPactivePathTimeout
,
4898 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT
,
4900 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPpreqMinInterval
,
4902 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL
,
4904 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPperrMinInterval
,
4906 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL
,
4908 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
4909 dot11MeshHWMPnetDiameterTraversalTime
,
4911 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME
,
4913 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPRootMode
, 0, 4,
4914 mask
, NL80211_MESHCONF_HWMP_ROOTMODE
,
4916 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPRannInterval
, 1, 65535,
4917 mask
, NL80211_MESHCONF_HWMP_RANN_INTERVAL
,
4919 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
4920 dot11MeshGateAnnouncementProtocol
, 0, 1,
4921 mask
, NL80211_MESHCONF_GATE_ANNOUNCEMENTS
,
4923 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshForwarding
, 0, 1,
4924 mask
, NL80211_MESHCONF_FORWARDING
,
4926 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, rssi_threshold
, -255, 0,
4927 mask
, NL80211_MESHCONF_RSSI_THRESHOLD
,
4929 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, ht_opmode
, 0, 16,
4930 mask
, NL80211_MESHCONF_HT_OPMODE
,
4932 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMPactivePathToRootTimeout
,
4934 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT
,
4936 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshHWMProotInterval
, 1, 65535,
4937 mask
, NL80211_MESHCONF_HWMP_ROOT_INTERVAL
,
4939 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
,
4940 dot11MeshHWMPconfirmationInterval
,
4942 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL
,
4944 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, power_mode
,
4945 NL80211_MESH_POWER_ACTIVE
,
4946 NL80211_MESH_POWER_MAX
,
4947 mask
, NL80211_MESHCONF_POWER_MODE
,
4949 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, dot11MeshAwakeWindowDuration
,
4951 NL80211_MESHCONF_AWAKE_WINDOW
, nla_get_u16
);
4952 FILL_IN_MESH_PARAM_IF_SET(tb
, cfg
, plink_timeout
, 1, 0xffffffff,
4953 mask
, NL80211_MESHCONF_PLINK_TIMEOUT
,
4960 #undef FILL_IN_MESH_PARAM_IF_SET
4963 static int nl80211_parse_mesh_setup(struct genl_info
*info
,
4964 struct mesh_setup
*setup
)
4966 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
4967 struct nlattr
*tb
[NL80211_MESH_SETUP_ATTR_MAX
+ 1];
4969 if (!info
->attrs
[NL80211_ATTR_MESH_SETUP
])
4971 if (nla_parse_nested(tb
, NL80211_MESH_SETUP_ATTR_MAX
,
4972 info
->attrs
[NL80211_ATTR_MESH_SETUP
],
4973 nl80211_mesh_setup_params_policy
))
4976 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
])
4977 setup
->sync_method
=
4978 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC
])) ?
4979 IEEE80211_SYNC_METHOD_VENDOR
:
4980 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET
;
4982 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
])
4983 setup
->path_sel_proto
=
4984 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL
])) ?
4985 IEEE80211_PATH_PROTOCOL_VENDOR
:
4986 IEEE80211_PATH_PROTOCOL_HWMP
;
4988 if (tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
])
4989 setup
->path_metric
=
4990 (nla_get_u8(tb
[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC
])) ?
4991 IEEE80211_PATH_METRIC_VENDOR
:
4992 IEEE80211_PATH_METRIC_AIRTIME
;
4995 if (tb
[NL80211_MESH_SETUP_IE
]) {
4996 struct nlattr
*ieattr
=
4997 tb
[NL80211_MESH_SETUP_IE
];
4998 if (!is_valid_ie_attr(ieattr
))
5000 setup
->ie
= nla_data(ieattr
);
5001 setup
->ie_len
= nla_len(ieattr
);
5003 if (tb
[NL80211_MESH_SETUP_USERSPACE_MPM
] &&
5004 !(rdev
->wiphy
.features
& NL80211_FEATURE_USERSPACE_MPM
))
5006 setup
->user_mpm
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_MPM
]);
5007 setup
->is_authenticated
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_AUTH
]);
5008 setup
->is_secure
= nla_get_flag(tb
[NL80211_MESH_SETUP_USERSPACE_AMPE
]);
5009 if (setup
->is_secure
)
5010 setup
->user_mpm
= true;
5012 if (tb
[NL80211_MESH_SETUP_AUTH_PROTOCOL
]) {
5013 if (!setup
->user_mpm
)
5016 nla_get_u8(tb
[NL80211_MESH_SETUP_AUTH_PROTOCOL
]);
5022 static int nl80211_update_mesh_config(struct sk_buff
*skb
,
5023 struct genl_info
*info
)
5025 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5026 struct net_device
*dev
= info
->user_ptr
[1];
5027 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
5028 struct mesh_config cfg
;
5032 if (wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
5035 if (!rdev
->ops
->update_mesh_config
)
5038 err
= nl80211_parse_mesh_config(info
, &cfg
, &mask
);
5043 if (!wdev
->mesh_id_len
)
5047 err
= rdev_update_mesh_config(rdev
, dev
, mask
, &cfg
);
5054 static int nl80211_get_reg(struct sk_buff
*skb
, struct genl_info
*info
)
5056 const struct ieee80211_regdomain
*regdom
;
5057 struct sk_buff
*msg
;
5059 struct nlattr
*nl_reg_rules
;
5062 if (!cfg80211_regdomain
)
5065 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
5069 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
5070 NL80211_CMD_GET_REG
);
5074 if (reg_last_request_cell_base() &&
5075 nla_put_u32(msg
, NL80211_ATTR_USER_REG_HINT_TYPE
,
5076 NL80211_USER_REG_HINT_CELL_BASE
))
5077 goto nla_put_failure
;
5080 regdom
= rcu_dereference(cfg80211_regdomain
);
5082 if (nla_put_string(msg
, NL80211_ATTR_REG_ALPHA2
, regdom
->alpha2
) ||
5083 (regdom
->dfs_region
&&
5084 nla_put_u8(msg
, NL80211_ATTR_DFS_REGION
, regdom
->dfs_region
)))
5085 goto nla_put_failure_rcu
;
5087 nl_reg_rules
= nla_nest_start(msg
, NL80211_ATTR_REG_RULES
);
5089 goto nla_put_failure_rcu
;
5091 for (i
= 0; i
< regdom
->n_reg_rules
; i
++) {
5092 struct nlattr
*nl_reg_rule
;
5093 const struct ieee80211_reg_rule
*reg_rule
;
5094 const struct ieee80211_freq_range
*freq_range
;
5095 const struct ieee80211_power_rule
*power_rule
;
5097 reg_rule
= ®dom
->reg_rules
[i
];
5098 freq_range
= ®_rule
->freq_range
;
5099 power_rule
= ®_rule
->power_rule
;
5101 nl_reg_rule
= nla_nest_start(msg
, i
);
5103 goto nla_put_failure_rcu
;
5105 if (nla_put_u32(msg
, NL80211_ATTR_REG_RULE_FLAGS
,
5107 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_START
,
5108 freq_range
->start_freq_khz
) ||
5109 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_END
,
5110 freq_range
->end_freq_khz
) ||
5111 nla_put_u32(msg
, NL80211_ATTR_FREQ_RANGE_MAX_BW
,
5112 freq_range
->max_bandwidth_khz
) ||
5113 nla_put_u32(msg
, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN
,
5114 power_rule
->max_antenna_gain
) ||
5115 nla_put_u32(msg
, NL80211_ATTR_POWER_RULE_MAX_EIRP
,
5116 power_rule
->max_eirp
))
5117 goto nla_put_failure_rcu
;
5119 nla_nest_end(msg
, nl_reg_rule
);
5123 nla_nest_end(msg
, nl_reg_rules
);
5125 genlmsg_end(msg
, hdr
);
5126 return genlmsg_reply(msg
, info
);
5128 nla_put_failure_rcu
:
5131 genlmsg_cancel(msg
, hdr
);
5137 static int nl80211_set_reg(struct sk_buff
*skb
, struct genl_info
*info
)
5139 struct nlattr
*tb
[NL80211_REG_RULE_ATTR_MAX
+ 1];
5140 struct nlattr
*nl_reg_rule
;
5141 char *alpha2
= NULL
;
5142 int rem_reg_rules
= 0, r
= 0;
5143 u32 num_rules
= 0, rule_idx
= 0, size_of_regd
;
5144 enum nl80211_dfs_regions dfs_region
= NL80211_DFS_UNSET
;
5145 struct ieee80211_regdomain
*rd
= NULL
;
5147 if (!info
->attrs
[NL80211_ATTR_REG_ALPHA2
])
5150 if (!info
->attrs
[NL80211_ATTR_REG_RULES
])
5153 alpha2
= nla_data(info
->attrs
[NL80211_ATTR_REG_ALPHA2
]);
5155 if (info
->attrs
[NL80211_ATTR_DFS_REGION
])
5156 dfs_region
= nla_get_u8(info
->attrs
[NL80211_ATTR_DFS_REGION
]);
5158 nla_for_each_nested(nl_reg_rule
, info
->attrs
[NL80211_ATTR_REG_RULES
],
5161 if (num_rules
> NL80211_MAX_SUPP_REG_RULES
)
5165 if (!reg_is_valid_request(alpha2
))
5168 size_of_regd
= sizeof(struct ieee80211_regdomain
) +
5169 num_rules
* sizeof(struct ieee80211_reg_rule
);
5171 rd
= kzalloc(size_of_regd
, GFP_KERNEL
);
5175 rd
->n_reg_rules
= num_rules
;
5176 rd
->alpha2
[0] = alpha2
[0];
5177 rd
->alpha2
[1] = alpha2
[1];
5180 * Disable DFS master mode if the DFS region was
5181 * not supported or known on this kernel.
5183 if (reg_supported_dfs_region(dfs_region
))
5184 rd
->dfs_region
= dfs_region
;
5186 nla_for_each_nested(nl_reg_rule
, info
->attrs
[NL80211_ATTR_REG_RULES
],
5188 nla_parse(tb
, NL80211_REG_RULE_ATTR_MAX
,
5189 nla_data(nl_reg_rule
), nla_len(nl_reg_rule
),
5191 r
= parse_reg_rule(tb
, &rd
->reg_rules
[rule_idx
]);
5197 if (rule_idx
> NL80211_MAX_SUPP_REG_RULES
) {
5204 /* set_regdom took ownership */
5212 static int validate_scan_freqs(struct nlattr
*freqs
)
5214 struct nlattr
*attr1
, *attr2
;
5215 int n_channels
= 0, tmp1
, tmp2
;
5217 nla_for_each_nested(attr1
, freqs
, tmp1
) {
5220 * Some hardware has a limited channel list for
5221 * scanning, and it is pretty much nonsensical
5222 * to scan for a channel twice, so disallow that
5223 * and don't require drivers to check that the
5224 * channel list they get isn't longer than what
5225 * they can scan, as long as they can scan all
5226 * the channels they registered at once.
5228 nla_for_each_nested(attr2
, freqs
, tmp2
)
5229 if (attr1
!= attr2
&&
5230 nla_get_u32(attr1
) == nla_get_u32(attr2
))
5237 static int nl80211_trigger_scan(struct sk_buff
*skb
, struct genl_info
*info
)
5239 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5240 struct wireless_dev
*wdev
= info
->user_ptr
[1];
5241 struct cfg80211_scan_request
*request
;
5242 struct nlattr
*attr
;
5243 struct wiphy
*wiphy
;
5244 int err
, tmp
, n_ssids
= 0, n_channels
, i
;
5247 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
5250 wiphy
= &rdev
->wiphy
;
5252 if (!rdev
->ops
->scan
)
5255 if (rdev
->scan_req
) {
5260 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
5261 n_channels
= validate_scan_freqs(
5262 info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]);
5268 n_channels
= ieee80211_get_num_supported_channels(wiphy
);
5271 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
])
5272 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
], tmp
)
5275 if (n_ssids
> wiphy
->max_scan_ssids
) {
5280 if (info
->attrs
[NL80211_ATTR_IE
])
5281 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
5285 if (ie_len
> wiphy
->max_scan_ie_len
) {
5290 request
= kzalloc(sizeof(*request
)
5291 + sizeof(*request
->ssids
) * n_ssids
5292 + sizeof(*request
->channels
) * n_channels
5293 + ie_len
, GFP_KERNEL
);
5300 request
->ssids
= (void *)&request
->channels
[n_channels
];
5301 request
->n_ssids
= n_ssids
;
5304 request
->ie
= (void *)(request
->ssids
+ n_ssids
);
5306 request
->ie
= (void *)(request
->channels
+ n_channels
);
5310 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
5311 /* user specified, bail out if channel not found */
5312 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
], tmp
) {
5313 struct ieee80211_channel
*chan
;
5315 chan
= ieee80211_get_channel(wiphy
, nla_get_u32(attr
));
5322 /* ignore disabled channels */
5323 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
5326 request
->channels
[i
] = chan
;
5330 enum ieee80211_band band
;
5333 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
5335 if (!wiphy
->bands
[band
])
5337 for (j
= 0; j
< wiphy
->bands
[band
]->n_channels
; j
++) {
5338 struct ieee80211_channel
*chan
;
5340 chan
= &wiphy
->bands
[band
]->channels
[j
];
5342 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
5345 request
->channels
[i
] = chan
;
5356 request
->n_channels
= i
;
5359 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
]) {
5360 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
], tmp
) {
5361 if (nla_len(attr
) > IEEE80211_MAX_SSID_LEN
) {
5365 request
->ssids
[i
].ssid_len
= nla_len(attr
);
5366 memcpy(request
->ssids
[i
].ssid
, nla_data(attr
), nla_len(attr
));
5371 if (info
->attrs
[NL80211_ATTR_IE
]) {
5372 request
->ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
5373 memcpy((void *)request
->ie
,
5374 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
5378 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++)
5379 if (wiphy
->bands
[i
])
5381 (1 << wiphy
->bands
[i
]->n_bitrates
) - 1;
5383 if (info
->attrs
[NL80211_ATTR_SCAN_SUPP_RATES
]) {
5384 nla_for_each_nested(attr
,
5385 info
->attrs
[NL80211_ATTR_SCAN_SUPP_RATES
],
5387 enum ieee80211_band band
= nla_type(attr
);
5389 if (band
< 0 || band
>= IEEE80211_NUM_BANDS
) {
5394 if (!wiphy
->bands
[band
])
5397 err
= ieee80211_get_ratemask(wiphy
->bands
[band
],
5400 &request
->rates
[band
]);
5406 if (info
->attrs
[NL80211_ATTR_SCAN_FLAGS
]) {
5407 request
->flags
= nla_get_u32(
5408 info
->attrs
[NL80211_ATTR_SCAN_FLAGS
]);
5409 if ((request
->flags
& NL80211_SCAN_FLAG_LOW_PRIORITY
) &&
5410 !(wiphy
->features
& NL80211_FEATURE_LOW_PRIORITY_SCAN
)) {
5417 nla_get_flag(info
->attrs
[NL80211_ATTR_TX_NO_CCK_RATE
]);
5419 request
->wdev
= wdev
;
5420 request
->wiphy
= &rdev
->wiphy
;
5421 request
->scan_start
= jiffies
;
5423 rdev
->scan_req
= request
;
5424 err
= rdev_scan(rdev
, request
);
5427 nl80211_send_scan_start(rdev
, wdev
);
5429 dev_hold(wdev
->netdev
);
5432 rdev
->scan_req
= NULL
;
5440 static int nl80211_start_sched_scan(struct sk_buff
*skb
,
5441 struct genl_info
*info
)
5443 struct cfg80211_sched_scan_request
*request
;
5444 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5445 struct net_device
*dev
= info
->user_ptr
[1];
5446 struct nlattr
*attr
;
5447 struct wiphy
*wiphy
;
5448 int err
, tmp
, n_ssids
= 0, n_match_sets
= 0, n_channels
, i
;
5450 enum ieee80211_band band
;
5452 struct nlattr
*tb
[NL80211_SCHED_SCAN_MATCH_ATTR_MAX
+ 1];
5454 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_SCHED_SCAN
) ||
5455 !rdev
->ops
->sched_scan_start
)
5458 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
5461 if (!info
->attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
])
5464 interval
= nla_get_u32(info
->attrs
[NL80211_ATTR_SCHED_SCAN_INTERVAL
]);
5468 wiphy
= &rdev
->wiphy
;
5470 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
5471 n_channels
= validate_scan_freqs(
5472 info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]);
5476 n_channels
= ieee80211_get_num_supported_channels(wiphy
);
5479 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
])
5480 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
],
5484 if (n_ssids
> wiphy
->max_sched_scan_ssids
)
5487 if (info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
])
5488 nla_for_each_nested(attr
,
5489 info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
],
5493 if (n_match_sets
> wiphy
->max_match_sets
)
5496 if (info
->attrs
[NL80211_ATTR_IE
])
5497 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
5501 if (ie_len
> wiphy
->max_sched_scan_ie_len
)
5504 if (rdev
->sched_scan_req
) {
5509 request
= kzalloc(sizeof(*request
)
5510 + sizeof(*request
->ssids
) * n_ssids
5511 + sizeof(*request
->match_sets
) * n_match_sets
5512 + sizeof(*request
->channels
) * n_channels
5513 + ie_len
, GFP_KERNEL
);
5520 request
->ssids
= (void *)&request
->channels
[n_channels
];
5521 request
->n_ssids
= n_ssids
;
5524 request
->ie
= (void *)(request
->ssids
+ n_ssids
);
5526 request
->ie
= (void *)(request
->channels
+ n_channels
);
5531 request
->match_sets
= (void *)(request
->ie
+ ie_len
);
5532 else if (request
->ssids
)
5533 request
->match_sets
=
5534 (void *)(request
->ssids
+ n_ssids
);
5536 request
->match_sets
=
5537 (void *)(request
->channels
+ n_channels
);
5539 request
->n_match_sets
= n_match_sets
;
5542 if (info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
]) {
5543 /* user specified, bail out if channel not found */
5544 nla_for_each_nested(attr
,
5545 info
->attrs
[NL80211_ATTR_SCAN_FREQUENCIES
],
5547 struct ieee80211_channel
*chan
;
5549 chan
= ieee80211_get_channel(wiphy
, nla_get_u32(attr
));
5556 /* ignore disabled channels */
5557 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
5560 request
->channels
[i
] = chan
;
5565 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
5567 if (!wiphy
->bands
[band
])
5569 for (j
= 0; j
< wiphy
->bands
[band
]->n_channels
; j
++) {
5570 struct ieee80211_channel
*chan
;
5572 chan
= &wiphy
->bands
[band
]->channels
[j
];
5574 if (chan
->flags
& IEEE80211_CHAN_DISABLED
)
5577 request
->channels
[i
] = chan
;
5588 request
->n_channels
= i
;
5591 if (info
->attrs
[NL80211_ATTR_SCAN_SSIDS
]) {
5592 nla_for_each_nested(attr
, info
->attrs
[NL80211_ATTR_SCAN_SSIDS
],
5594 if (nla_len(attr
) > IEEE80211_MAX_SSID_LEN
) {
5598 request
->ssids
[i
].ssid_len
= nla_len(attr
);
5599 memcpy(request
->ssids
[i
].ssid
, nla_data(attr
),
5606 if (info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
]) {
5607 nla_for_each_nested(attr
,
5608 info
->attrs
[NL80211_ATTR_SCHED_SCAN_MATCH
],
5610 struct nlattr
*ssid
, *rssi
;
5612 nla_parse(tb
, NL80211_SCHED_SCAN_MATCH_ATTR_MAX
,
5613 nla_data(attr
), nla_len(attr
),
5614 nl80211_match_policy
);
5615 ssid
= tb
[NL80211_SCHED_SCAN_MATCH_ATTR_SSID
];
5617 if (nla_len(ssid
) > IEEE80211_MAX_SSID_LEN
) {
5621 memcpy(request
->match_sets
[i
].ssid
.ssid
,
5622 nla_data(ssid
), nla_len(ssid
));
5623 request
->match_sets
[i
].ssid
.ssid_len
=
5626 rssi
= tb
[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI
];
5628 request
->rssi_thold
= nla_get_u32(rssi
);
5630 request
->rssi_thold
=
5631 NL80211_SCAN_RSSI_THOLD_OFF
;
5636 if (info
->attrs
[NL80211_ATTR_IE
]) {
5637 request
->ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
5638 memcpy((void *)request
->ie
,
5639 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
5643 if (info
->attrs
[NL80211_ATTR_SCAN_FLAGS
]) {
5644 request
->flags
= nla_get_u32(
5645 info
->attrs
[NL80211_ATTR_SCAN_FLAGS
]);
5646 if ((request
->flags
& NL80211_SCAN_FLAG_LOW_PRIORITY
) &&
5647 !(wiphy
->features
& NL80211_FEATURE_LOW_PRIORITY_SCAN
)) {
5654 request
->wiphy
= &rdev
->wiphy
;
5655 request
->interval
= interval
;
5656 request
->scan_start
= jiffies
;
5658 err
= rdev_sched_scan_start(rdev
, dev
, request
);
5660 rdev
->sched_scan_req
= request
;
5661 nl80211_send_sched_scan(rdev
, dev
,
5662 NL80211_CMD_START_SCHED_SCAN
);
5672 static int nl80211_stop_sched_scan(struct sk_buff
*skb
,
5673 struct genl_info
*info
)
5675 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5677 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_SCHED_SCAN
) ||
5678 !rdev
->ops
->sched_scan_stop
)
5681 return __cfg80211_stop_sched_scan(rdev
, false);
5684 static int nl80211_start_radar_detection(struct sk_buff
*skb
,
5685 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 wireless_dev
*wdev
= dev
->ieee80211_ptr
;
5690 struct cfg80211_chan_def chandef
;
5691 enum nl80211_dfs_regions dfs_region
;
5694 dfs_region
= reg_get_dfs_region(wdev
->wiphy
);
5695 if (dfs_region
== NL80211_DFS_UNSET
)
5698 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
5702 if (netif_carrier_ok(dev
))
5705 if (wdev
->cac_started
)
5708 err
= cfg80211_chandef_dfs_required(wdev
->wiphy
, &chandef
);
5715 if (!cfg80211_chandef_dfs_usable(wdev
->wiphy
, &chandef
))
5718 if (!rdev
->ops
->start_radar_detection
)
5721 err
= cfg80211_can_use_iftype_chan(rdev
, wdev
, wdev
->iftype
,
5722 chandef
.chan
, CHAN_MODE_SHARED
,
5723 BIT(chandef
.width
));
5727 err
= rdev
->ops
->start_radar_detection(&rdev
->wiphy
, dev
, &chandef
);
5729 wdev
->channel
= chandef
.chan
;
5730 wdev
->cac_started
= true;
5731 wdev
->cac_start_time
= jiffies
;
5736 static int nl80211_channel_switch(struct sk_buff
*skb
, struct genl_info
*info
)
5738 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
5739 struct net_device
*dev
= info
->user_ptr
[1];
5740 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
5741 struct cfg80211_csa_settings params
;
5742 /* csa_attrs is defined static to avoid waste of stack size - this
5743 * function is called under RTNL lock, so this should not be a problem.
5745 static struct nlattr
*csa_attrs
[NL80211_ATTR_MAX
+1];
5746 u8 radar_detect_width
= 0;
5748 bool need_new_beacon
= false;
5750 if (!rdev
->ops
->channel_switch
||
5751 !(rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_CHANNEL_SWITCH
))
5754 switch (dev
->ieee80211_ptr
->iftype
) {
5755 case NL80211_IFTYPE_AP
:
5756 case NL80211_IFTYPE_P2P_GO
:
5757 need_new_beacon
= true;
5759 /* useless if AP is not running */
5760 if (!wdev
->beacon_interval
)
5763 case NL80211_IFTYPE_ADHOC
:
5764 case NL80211_IFTYPE_MESH_POINT
:
5770 memset(¶ms
, 0, sizeof(params
));
5772 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
] ||
5773 !info
->attrs
[NL80211_ATTR_CH_SWITCH_COUNT
])
5776 /* only important for AP, IBSS and mesh create IEs internally */
5777 if (need_new_beacon
&& !info
->attrs
[NL80211_ATTR_CSA_IES
])
5780 params
.count
= nla_get_u32(info
->attrs
[NL80211_ATTR_CH_SWITCH_COUNT
]);
5782 if (!need_new_beacon
)
5785 err
= nl80211_parse_beacon(info
->attrs
, ¶ms
.beacon_after
);
5789 err
= nla_parse_nested(csa_attrs
, NL80211_ATTR_MAX
,
5790 info
->attrs
[NL80211_ATTR_CSA_IES
],
5795 err
= nl80211_parse_beacon(csa_attrs
, ¶ms
.beacon_csa
);
5799 if (!csa_attrs
[NL80211_ATTR_CSA_C_OFF_BEACON
])
5802 params
.counter_offset_beacon
=
5803 nla_get_u16(csa_attrs
[NL80211_ATTR_CSA_C_OFF_BEACON
]);
5804 if (params
.counter_offset_beacon
>= params
.beacon_csa
.tail_len
)
5807 /* sanity check - counters should be the same */
5808 if (params
.beacon_csa
.tail
[params
.counter_offset_beacon
] !=
5812 if (csa_attrs
[NL80211_ATTR_CSA_C_OFF_PRESP
]) {
5813 params
.counter_offset_presp
=
5814 nla_get_u16(csa_attrs
[NL80211_ATTR_CSA_C_OFF_PRESP
]);
5815 if (params
.counter_offset_presp
>=
5816 params
.beacon_csa
.probe_resp_len
)
5819 if (params
.beacon_csa
.probe_resp
[params
.counter_offset_presp
] !=
5825 err
= nl80211_parse_chandef(rdev
, info
, ¶ms
.chandef
);
5829 if (!cfg80211_reg_can_beacon(&rdev
->wiphy
, ¶ms
.chandef
))
5832 if (dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_AP
||
5833 dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_P2P_GO
||
5834 dev
->ieee80211_ptr
->iftype
== NL80211_IFTYPE_ADHOC
) {
5835 err
= cfg80211_chandef_dfs_required(wdev
->wiphy
,
5840 radar_detect_width
= BIT(params
.chandef
.width
);
5841 params
.radar_required
= true;
5845 err
= cfg80211_can_use_iftype_chan(rdev
, wdev
, wdev
->iftype
,
5846 params
.chandef
.chan
,
5848 radar_detect_width
);
5852 if (info
->attrs
[NL80211_ATTR_CH_SWITCH_BLOCK_TX
])
5853 params
.block_tx
= true;
5856 err
= rdev_channel_switch(rdev
, dev
, ¶ms
);
5862 static int nl80211_send_bss(struct sk_buff
*msg
, struct netlink_callback
*cb
,
5864 struct cfg80211_registered_device
*rdev
,
5865 struct wireless_dev
*wdev
,
5866 struct cfg80211_internal_bss
*intbss
)
5868 struct cfg80211_bss
*res
= &intbss
->pub
;
5869 const struct cfg80211_bss_ies
*ies
;
5874 ASSERT_WDEV_LOCK(wdev
);
5876 hdr
= nl80211hdr_put(msg
, NETLINK_CB(cb
->skb
).portid
, seq
, flags
,
5877 NL80211_CMD_NEW_SCAN_RESULTS
);
5881 genl_dump_check_consistent(cb
, hdr
, &nl80211_fam
);
5883 if (nla_put_u32(msg
, NL80211_ATTR_GENERATION
, rdev
->bss_generation
))
5884 goto nla_put_failure
;
5886 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, wdev
->netdev
->ifindex
))
5887 goto nla_put_failure
;
5888 if (nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)))
5889 goto nla_put_failure
;
5891 bss
= nla_nest_start(msg
, NL80211_ATTR_BSS
);
5893 goto nla_put_failure
;
5894 if ((!is_zero_ether_addr(res
->bssid
) &&
5895 nla_put(msg
, NL80211_BSS_BSSID
, ETH_ALEN
, res
->bssid
)))
5896 goto nla_put_failure
;
5899 ies
= rcu_dereference(res
->ies
);
5901 if (nla_put_u64(msg
, NL80211_BSS_TSF
, ies
->tsf
))
5902 goto fail_unlock_rcu
;
5904 if (ies
->len
&& nla_put(msg
, NL80211_BSS_INFORMATION_ELEMENTS
,
5905 ies
->len
, ies
->data
))
5906 goto fail_unlock_rcu
;
5908 ies
= rcu_dereference(res
->beacon_ies
);
5910 if (!tsf
&& nla_put_u64(msg
, NL80211_BSS_TSF
, ies
->tsf
))
5911 goto fail_unlock_rcu
;
5912 if (ies
->len
&& nla_put(msg
, NL80211_BSS_BEACON_IES
,
5913 ies
->len
, ies
->data
))
5914 goto fail_unlock_rcu
;
5918 if (res
->beacon_interval
&&
5919 nla_put_u16(msg
, NL80211_BSS_BEACON_INTERVAL
, res
->beacon_interval
))
5920 goto nla_put_failure
;
5921 if (nla_put_u16(msg
, NL80211_BSS_CAPABILITY
, res
->capability
) ||
5922 nla_put_u32(msg
, NL80211_BSS_FREQUENCY
, res
->channel
->center_freq
) ||
5923 nla_put_u32(msg
, NL80211_BSS_CHAN_WIDTH
, res
->scan_width
) ||
5924 nla_put_u32(msg
, NL80211_BSS_SEEN_MS_AGO
,
5925 jiffies_to_msecs(jiffies
- intbss
->ts
)))
5926 goto nla_put_failure
;
5928 switch (rdev
->wiphy
.signal_type
) {
5929 case CFG80211_SIGNAL_TYPE_MBM
:
5930 if (nla_put_u32(msg
, NL80211_BSS_SIGNAL_MBM
, res
->signal
))
5931 goto nla_put_failure
;
5933 case CFG80211_SIGNAL_TYPE_UNSPEC
:
5934 if (nla_put_u8(msg
, NL80211_BSS_SIGNAL_UNSPEC
, res
->signal
))
5935 goto nla_put_failure
;
5941 switch (wdev
->iftype
) {
5942 case NL80211_IFTYPE_P2P_CLIENT
:
5943 case NL80211_IFTYPE_STATION
:
5944 if (intbss
== wdev
->current_bss
&&
5945 nla_put_u32(msg
, NL80211_BSS_STATUS
,
5946 NL80211_BSS_STATUS_ASSOCIATED
))
5947 goto nla_put_failure
;
5949 case NL80211_IFTYPE_ADHOC
:
5950 if (intbss
== wdev
->current_bss
&&
5951 nla_put_u32(msg
, NL80211_BSS_STATUS
,
5952 NL80211_BSS_STATUS_IBSS_JOINED
))
5953 goto nla_put_failure
;
5959 nla_nest_end(msg
, bss
);
5961 return genlmsg_end(msg
, hdr
);
5966 genlmsg_cancel(msg
, hdr
);
5970 static int nl80211_dump_scan(struct sk_buff
*skb
, struct netlink_callback
*cb
)
5972 struct cfg80211_registered_device
*rdev
;
5973 struct cfg80211_internal_bss
*scan
;
5974 struct wireless_dev
*wdev
;
5975 int start
= cb
->args
[2], idx
= 0;
5978 err
= nl80211_prepare_wdev_dump(skb
, cb
, &rdev
, &wdev
);
5983 spin_lock_bh(&rdev
->bss_lock
);
5984 cfg80211_bss_expire(rdev
);
5986 cb
->seq
= rdev
->bss_generation
;
5988 list_for_each_entry(scan
, &rdev
->bss_list
, list
) {
5991 if (nl80211_send_bss(skb
, cb
,
5992 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
5993 rdev
, wdev
, scan
) < 0) {
5999 spin_unlock_bh(&rdev
->bss_lock
);
6003 nl80211_finish_wdev_dump(rdev
);
6008 static int nl80211_send_survey(struct sk_buff
*msg
, u32 portid
, u32 seq
,
6009 int flags
, struct net_device
*dev
,
6010 struct survey_info
*survey
)
6013 struct nlattr
*infoattr
;
6015 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
,
6016 NL80211_CMD_NEW_SURVEY_RESULTS
);
6020 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
6021 goto nla_put_failure
;
6023 infoattr
= nla_nest_start(msg
, NL80211_ATTR_SURVEY_INFO
);
6025 goto nla_put_failure
;
6027 if (nla_put_u32(msg
, NL80211_SURVEY_INFO_FREQUENCY
,
6028 survey
->channel
->center_freq
))
6029 goto nla_put_failure
;
6031 if ((survey
->filled
& SURVEY_INFO_NOISE_DBM
) &&
6032 nla_put_u8(msg
, NL80211_SURVEY_INFO_NOISE
, survey
->noise
))
6033 goto nla_put_failure
;
6034 if ((survey
->filled
& SURVEY_INFO_IN_USE
) &&
6035 nla_put_flag(msg
, NL80211_SURVEY_INFO_IN_USE
))
6036 goto nla_put_failure
;
6037 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME
) &&
6038 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME
,
6039 survey
->channel_time
))
6040 goto nla_put_failure
;
6041 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_BUSY
) &&
6042 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY
,
6043 survey
->channel_time_busy
))
6044 goto nla_put_failure
;
6045 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_EXT_BUSY
) &&
6046 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY
,
6047 survey
->channel_time_ext_busy
))
6048 goto nla_put_failure
;
6049 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_RX
) &&
6050 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_RX
,
6051 survey
->channel_time_rx
))
6052 goto nla_put_failure
;
6053 if ((survey
->filled
& SURVEY_INFO_CHANNEL_TIME_TX
) &&
6054 nla_put_u64(msg
, NL80211_SURVEY_INFO_CHANNEL_TIME_TX
,
6055 survey
->channel_time_tx
))
6056 goto nla_put_failure
;
6058 nla_nest_end(msg
, infoattr
);
6060 return genlmsg_end(msg
, hdr
);
6063 genlmsg_cancel(msg
, hdr
);
6067 static int nl80211_dump_survey(struct sk_buff
*skb
,
6068 struct netlink_callback
*cb
)
6070 struct survey_info survey
;
6071 struct cfg80211_registered_device
*dev
;
6072 struct wireless_dev
*wdev
;
6073 int survey_idx
= cb
->args
[2];
6076 res
= nl80211_prepare_wdev_dump(skb
, cb
, &dev
, &wdev
);
6080 if (!wdev
->netdev
) {
6085 if (!dev
->ops
->dump_survey
) {
6091 struct ieee80211_channel
*chan
;
6093 res
= rdev_dump_survey(dev
, wdev
->netdev
, survey_idx
, &survey
);
6099 /* Survey without a channel doesn't make sense */
6100 if (!survey
.channel
) {
6105 chan
= ieee80211_get_channel(&dev
->wiphy
,
6106 survey
.channel
->center_freq
);
6107 if (!chan
|| chan
->flags
& IEEE80211_CHAN_DISABLED
) {
6112 if (nl80211_send_survey(skb
,
6113 NETLINK_CB(cb
->skb
).portid
,
6114 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
6115 wdev
->netdev
, &survey
) < 0)
6121 cb
->args
[2] = survey_idx
;
6124 nl80211_finish_wdev_dump(dev
);
6128 static bool nl80211_valid_wpa_versions(u32 wpa_versions
)
6130 return !(wpa_versions
& ~(NL80211_WPA_VERSION_1
|
6131 NL80211_WPA_VERSION_2
));
6134 static int nl80211_authenticate(struct sk_buff
*skb
, struct genl_info
*info
)
6136 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6137 struct net_device
*dev
= info
->user_ptr
[1];
6138 struct ieee80211_channel
*chan
;
6139 const u8
*bssid
, *ssid
, *ie
= NULL
, *sae_data
= NULL
;
6140 int err
, ssid_len
, ie_len
= 0, sae_data_len
= 0;
6141 enum nl80211_auth_type auth_type
;
6142 struct key_parse key
;
6143 bool local_state_change
;
6145 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
6148 if (!info
->attrs
[NL80211_ATTR_MAC
])
6151 if (!info
->attrs
[NL80211_ATTR_AUTH_TYPE
])
6154 if (!info
->attrs
[NL80211_ATTR_SSID
])
6157 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
6160 err
= nl80211_parse_key(info
, &key
);
6165 if (key
.type
!= -1 && key
.type
!= NL80211_KEYTYPE_GROUP
)
6167 if (!key
.p
.key
|| !key
.p
.key_len
)
6169 if ((key
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP40
||
6170 key
.p
.key_len
!= WLAN_KEY_LEN_WEP40
) &&
6171 (key
.p
.cipher
!= WLAN_CIPHER_SUITE_WEP104
||
6172 key
.p
.key_len
!= WLAN_KEY_LEN_WEP104
))
6184 for (i
= 0; i
< rdev
->wiphy
.n_cipher_suites
; i
++) {
6185 if (key
.p
.cipher
== rdev
->wiphy
.cipher_suites
[i
]) {
6194 if (!rdev
->ops
->auth
)
6197 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
6198 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
6201 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6202 chan
= ieee80211_get_channel(&rdev
->wiphy
,
6203 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
6204 if (!chan
|| (chan
->flags
& IEEE80211_CHAN_DISABLED
))
6207 ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
6208 ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
6210 if (info
->attrs
[NL80211_ATTR_IE
]) {
6211 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
6212 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
6215 auth_type
= nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
6216 if (!nl80211_valid_auth_type(rdev
, auth_type
, NL80211_CMD_AUTHENTICATE
))
6219 if (auth_type
== NL80211_AUTHTYPE_SAE
&&
6220 !info
->attrs
[NL80211_ATTR_SAE_DATA
])
6223 if (info
->attrs
[NL80211_ATTR_SAE_DATA
]) {
6224 if (auth_type
!= NL80211_AUTHTYPE_SAE
)
6226 sae_data
= nla_data(info
->attrs
[NL80211_ATTR_SAE_DATA
]);
6227 sae_data_len
= nla_len(info
->attrs
[NL80211_ATTR_SAE_DATA
]);
6228 /* need to include at least Auth Transaction and Status Code */
6229 if (sae_data_len
< 4)
6233 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
6236 * Since we no longer track auth state, ignore
6237 * requests to only change local state.
6239 if (local_state_change
)
6242 wdev_lock(dev
->ieee80211_ptr
);
6243 err
= cfg80211_mlme_auth(rdev
, dev
, chan
, auth_type
, bssid
,
6244 ssid
, ssid_len
, ie
, ie_len
,
6245 key
.p
.key
, key
.p
.key_len
, key
.idx
,
6246 sae_data
, sae_data_len
);
6247 wdev_unlock(dev
->ieee80211_ptr
);
6251 static int nl80211_crypto_settings(struct cfg80211_registered_device
*rdev
,
6252 struct genl_info
*info
,
6253 struct cfg80211_crypto_settings
*settings
,
6256 memset(settings
, 0, sizeof(*settings
));
6258 settings
->control_port
= info
->attrs
[NL80211_ATTR_CONTROL_PORT
];
6260 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]) {
6262 proto
= nla_get_u16(
6263 info
->attrs
[NL80211_ATTR_CONTROL_PORT_ETHERTYPE
]);
6264 settings
->control_port_ethertype
= cpu_to_be16(proto
);
6265 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_CONTROL_PORT_PROTOCOL
) &&
6268 if (info
->attrs
[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT
])
6269 settings
->control_port_no_encrypt
= true;
6271 settings
->control_port_ethertype
= cpu_to_be16(ETH_P_PAE
);
6273 if (info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]) {
6277 data
= nla_data(info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]);
6278 len
= nla_len(info
->attrs
[NL80211_ATTR_CIPHER_SUITES_PAIRWISE
]);
6279 settings
->n_ciphers_pairwise
= len
/ sizeof(u32
);
6281 if (len
% sizeof(u32
))
6284 if (settings
->n_ciphers_pairwise
> cipher_limit
)
6287 memcpy(settings
->ciphers_pairwise
, data
, len
);
6289 for (i
= 0; i
< settings
->n_ciphers_pairwise
; i
++)
6290 if (!cfg80211_supported_cipher_suite(
6292 settings
->ciphers_pairwise
[i
]))
6296 if (info
->attrs
[NL80211_ATTR_CIPHER_SUITE_GROUP
]) {
6297 settings
->cipher_group
=
6298 nla_get_u32(info
->attrs
[NL80211_ATTR_CIPHER_SUITE_GROUP
]);
6299 if (!cfg80211_supported_cipher_suite(&rdev
->wiphy
,
6300 settings
->cipher_group
))
6304 if (info
->attrs
[NL80211_ATTR_WPA_VERSIONS
]) {
6305 settings
->wpa_versions
=
6306 nla_get_u32(info
->attrs
[NL80211_ATTR_WPA_VERSIONS
]);
6307 if (!nl80211_valid_wpa_versions(settings
->wpa_versions
))
6311 if (info
->attrs
[NL80211_ATTR_AKM_SUITES
]) {
6315 data
= nla_data(info
->attrs
[NL80211_ATTR_AKM_SUITES
]);
6316 len
= nla_len(info
->attrs
[NL80211_ATTR_AKM_SUITES
]);
6317 settings
->n_akm_suites
= len
/ sizeof(u32
);
6319 if (len
% sizeof(u32
))
6322 if (settings
->n_akm_suites
> NL80211_MAX_NR_AKM_SUITES
)
6325 memcpy(settings
->akm_suites
, data
, len
);
6331 static int nl80211_associate(struct sk_buff
*skb
, struct genl_info
*info
)
6333 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6334 struct net_device
*dev
= info
->user_ptr
[1];
6335 struct ieee80211_channel
*chan
;
6336 struct cfg80211_assoc_request req
= {};
6337 const u8
*bssid
, *ssid
;
6338 int err
, ssid_len
= 0;
6340 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
6343 if (!info
->attrs
[NL80211_ATTR_MAC
] ||
6344 !info
->attrs
[NL80211_ATTR_SSID
] ||
6345 !info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
6348 if (!rdev
->ops
->assoc
)
6351 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
6352 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
6355 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6357 chan
= ieee80211_get_channel(&rdev
->wiphy
,
6358 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
6359 if (!chan
|| (chan
->flags
& IEEE80211_CHAN_DISABLED
))
6362 ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
6363 ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
6365 if (info
->attrs
[NL80211_ATTR_IE
]) {
6366 req
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
6367 req
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
6370 if (info
->attrs
[NL80211_ATTR_USE_MFP
]) {
6371 enum nl80211_mfp mfp
=
6372 nla_get_u32(info
->attrs
[NL80211_ATTR_USE_MFP
]);
6373 if (mfp
== NL80211_MFP_REQUIRED
)
6375 else if (mfp
!= NL80211_MFP_NO
)
6379 if (info
->attrs
[NL80211_ATTR_PREV_BSSID
])
6380 req
.prev_bssid
= nla_data(info
->attrs
[NL80211_ATTR_PREV_BSSID
]);
6382 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HT
]))
6383 req
.flags
|= ASSOC_REQ_DISABLE_HT
;
6385 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
6386 memcpy(&req
.ht_capa_mask
,
6387 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
6388 sizeof(req
.ht_capa_mask
));
6390 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
6391 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
6393 memcpy(&req
.ht_capa
,
6394 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
6395 sizeof(req
.ht_capa
));
6398 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_VHT
]))
6399 req
.flags
|= ASSOC_REQ_DISABLE_VHT
;
6401 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
])
6402 memcpy(&req
.vht_capa_mask
,
6403 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
]),
6404 sizeof(req
.vht_capa_mask
));
6406 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]) {
6407 if (!info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
])
6409 memcpy(&req
.vht_capa
,
6410 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]),
6411 sizeof(req
.vht_capa
));
6414 err
= nl80211_crypto_settings(rdev
, info
, &req
.crypto
, 1);
6416 wdev_lock(dev
->ieee80211_ptr
);
6417 err
= cfg80211_mlme_assoc(rdev
, dev
, chan
, bssid
,
6418 ssid
, ssid_len
, &req
);
6419 wdev_unlock(dev
->ieee80211_ptr
);
6425 static int nl80211_deauthenticate(struct sk_buff
*skb
, struct genl_info
*info
)
6427 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6428 struct net_device
*dev
= info
->user_ptr
[1];
6429 const u8
*ie
= NULL
, *bssid
;
6430 int ie_len
= 0, err
;
6432 bool local_state_change
;
6434 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
6437 if (!info
->attrs
[NL80211_ATTR_MAC
])
6440 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
6443 if (!rdev
->ops
->deauth
)
6446 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
6447 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
6450 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6452 reason_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
6453 if (reason_code
== 0) {
6454 /* Reason Code 0 is reserved */
6458 if (info
->attrs
[NL80211_ATTR_IE
]) {
6459 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
6460 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
6463 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
6465 wdev_lock(dev
->ieee80211_ptr
);
6466 err
= cfg80211_mlme_deauth(rdev
, dev
, bssid
, ie
, ie_len
, reason_code
,
6467 local_state_change
);
6468 wdev_unlock(dev
->ieee80211_ptr
);
6472 static int nl80211_disassociate(struct sk_buff
*skb
, struct genl_info
*info
)
6474 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6475 struct net_device
*dev
= info
->user_ptr
[1];
6476 const u8
*ie
= NULL
, *bssid
;
6477 int ie_len
= 0, err
;
6479 bool local_state_change
;
6481 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
6484 if (!info
->attrs
[NL80211_ATTR_MAC
])
6487 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
6490 if (!rdev
->ops
->disassoc
)
6493 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
6494 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
6497 bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6499 reason_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
6500 if (reason_code
== 0) {
6501 /* Reason Code 0 is reserved */
6505 if (info
->attrs
[NL80211_ATTR_IE
]) {
6506 ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
6507 ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
6510 local_state_change
= !!info
->attrs
[NL80211_ATTR_LOCAL_STATE_CHANGE
];
6512 wdev_lock(dev
->ieee80211_ptr
);
6513 err
= cfg80211_mlme_disassoc(rdev
, dev
, bssid
, ie
, ie_len
, reason_code
,
6514 local_state_change
);
6515 wdev_unlock(dev
->ieee80211_ptr
);
6520 nl80211_parse_mcast_rate(struct cfg80211_registered_device
*rdev
,
6521 int mcast_rate
[IEEE80211_NUM_BANDS
],
6524 struct wiphy
*wiphy
= &rdev
->wiphy
;
6528 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
6529 struct ieee80211_supported_band
*sband
;
6531 sband
= wiphy
->bands
[band
];
6535 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
6536 if (sband
->bitrates
[i
].bitrate
== rateval
) {
6537 mcast_rate
[band
] = i
+ 1;
6547 static int nl80211_join_ibss(struct sk_buff
*skb
, struct genl_info
*info
)
6549 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6550 struct net_device
*dev
= info
->user_ptr
[1];
6551 struct cfg80211_ibss_params ibss
;
6552 struct wiphy
*wiphy
;
6553 struct cfg80211_cached_keys
*connkeys
= NULL
;
6556 memset(&ibss
, 0, sizeof(ibss
));
6558 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
6561 if (!info
->attrs
[NL80211_ATTR_SSID
] ||
6562 !nla_len(info
->attrs
[NL80211_ATTR_SSID
]))
6565 ibss
.beacon_interval
= 100;
6567 if (info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]) {
6568 ibss
.beacon_interval
=
6569 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
6570 if (ibss
.beacon_interval
< 1 || ibss
.beacon_interval
> 10000)
6574 if (!rdev
->ops
->join_ibss
)
6577 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
)
6580 wiphy
= &rdev
->wiphy
;
6582 if (info
->attrs
[NL80211_ATTR_MAC
]) {
6583 ibss
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6585 if (!is_valid_ether_addr(ibss
.bssid
))
6588 ibss
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
6589 ibss
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
6591 if (info
->attrs
[NL80211_ATTR_IE
]) {
6592 ibss
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
6593 ibss
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
6596 err
= nl80211_parse_chandef(rdev
, info
, &ibss
.chandef
);
6600 if (!cfg80211_reg_can_beacon(&rdev
->wiphy
, &ibss
.chandef
))
6603 switch (ibss
.chandef
.width
) {
6604 case NL80211_CHAN_WIDTH_5
:
6605 case NL80211_CHAN_WIDTH_10
:
6606 case NL80211_CHAN_WIDTH_20_NOHT
:
6608 case NL80211_CHAN_WIDTH_20
:
6609 case NL80211_CHAN_WIDTH_40
:
6610 if (rdev
->wiphy
.features
& NL80211_FEATURE_HT_IBSS
)
6616 ibss
.channel_fixed
= !!info
->attrs
[NL80211_ATTR_FREQ_FIXED
];
6617 ibss
.privacy
= !!info
->attrs
[NL80211_ATTR_PRIVACY
];
6619 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
6621 nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
6623 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
6624 struct ieee80211_supported_band
*sband
=
6625 wiphy
->bands
[ibss
.chandef
.chan
->band
];
6627 err
= ieee80211_get_ratemask(sband
, rates
, n_rates
,
6633 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
6634 memcpy(&ibss
.ht_capa_mask
,
6635 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
6636 sizeof(ibss
.ht_capa_mask
));
6638 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
6639 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
6641 memcpy(&ibss
.ht_capa
,
6642 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
6643 sizeof(ibss
.ht_capa
));
6646 if (info
->attrs
[NL80211_ATTR_MCAST_RATE
] &&
6647 !nl80211_parse_mcast_rate(rdev
, ibss
.mcast_rate
,
6648 nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
])))
6651 if (ibss
.privacy
&& info
->attrs
[NL80211_ATTR_KEYS
]) {
6654 connkeys
= nl80211_parse_connkeys(rdev
,
6655 info
->attrs
[NL80211_ATTR_KEYS
],
6657 if (IS_ERR(connkeys
))
6658 return PTR_ERR(connkeys
);
6660 if ((ibss
.chandef
.width
!= NL80211_CHAN_WIDTH_20_NOHT
) &&
6668 nla_get_flag(info
->attrs
[NL80211_ATTR_CONTROL_PORT
]);
6670 ibss
.userspace_handles_dfs
=
6671 nla_get_flag(info
->attrs
[NL80211_ATTR_HANDLE_DFS
]);
6673 err
= cfg80211_join_ibss(rdev
, dev
, &ibss
, connkeys
);
6679 static int nl80211_leave_ibss(struct sk_buff
*skb
, struct genl_info
*info
)
6681 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6682 struct net_device
*dev
= info
->user_ptr
[1];
6684 if (!rdev
->ops
->leave_ibss
)
6687 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
)
6690 return cfg80211_leave_ibss(rdev
, dev
, false);
6693 static int nl80211_set_mcast_rate(struct sk_buff
*skb
, struct genl_info
*info
)
6695 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6696 struct net_device
*dev
= info
->user_ptr
[1];
6697 int mcast_rate
[IEEE80211_NUM_BANDS
];
6701 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_ADHOC
&&
6702 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_MESH_POINT
)
6705 if (!rdev
->ops
->set_mcast_rate
)
6708 memset(mcast_rate
, 0, sizeof(mcast_rate
));
6710 if (!info
->attrs
[NL80211_ATTR_MCAST_RATE
])
6713 nla_rate
= nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
]);
6714 if (!nl80211_parse_mcast_rate(rdev
, mcast_rate
, nla_rate
))
6717 err
= rdev
->ops
->set_mcast_rate(&rdev
->wiphy
, dev
, mcast_rate
);
6722 static struct sk_buff
*
6723 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device
*rdev
,
6724 int approxlen
, u32 portid
, u32 seq
,
6725 enum nl80211_commands cmd
,
6726 enum nl80211_attrs attr
,
6727 const struct nl80211_vendor_cmd_info
*info
,
6730 struct sk_buff
*skb
;
6732 struct nlattr
*data
;
6734 skb
= nlmsg_new(approxlen
+ 100, gfp
);
6738 hdr
= nl80211hdr_put(skb
, portid
, seq
, 0, cmd
);
6744 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
))
6745 goto nla_put_failure
;
6748 if (nla_put_u32(skb
, NL80211_ATTR_VENDOR_ID
,
6750 goto nla_put_failure
;
6751 if (nla_put_u32(skb
, NL80211_ATTR_VENDOR_SUBCMD
,
6753 goto nla_put_failure
;
6756 data
= nla_nest_start(skb
, attr
);
6758 ((void **)skb
->cb
)[0] = rdev
;
6759 ((void **)skb
->cb
)[1] = hdr
;
6760 ((void **)skb
->cb
)[2] = data
;
6769 struct sk_buff
*__cfg80211_alloc_event_skb(struct wiphy
*wiphy
,
6770 enum nl80211_commands cmd
,
6771 enum nl80211_attrs attr
,
6772 int vendor_event_idx
,
6773 int approxlen
, gfp_t gfp
)
6775 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
6776 const struct nl80211_vendor_cmd_info
*info
;
6779 case NL80211_CMD_TESTMODE
:
6780 if (WARN_ON(vendor_event_idx
!= -1))
6784 case NL80211_CMD_VENDOR
:
6785 if (WARN_ON(vendor_event_idx
< 0 ||
6786 vendor_event_idx
>= wiphy
->n_vendor_events
))
6788 info
= &wiphy
->vendor_events
[vendor_event_idx
];
6795 return __cfg80211_alloc_vendor_skb(rdev
, approxlen
, 0, 0,
6796 cmd
, attr
, info
, gfp
);
6798 EXPORT_SYMBOL(__cfg80211_alloc_event_skb
);
6800 void __cfg80211_send_event_skb(struct sk_buff
*skb
, gfp_t gfp
)
6802 struct cfg80211_registered_device
*rdev
= ((void **)skb
->cb
)[0];
6803 void *hdr
= ((void **)skb
->cb
)[1];
6804 struct nlattr
*data
= ((void **)skb
->cb
)[2];
6805 enum nl80211_multicast_groups mcgrp
= NL80211_MCGRP_TESTMODE
;
6807 nla_nest_end(skb
, data
);
6808 genlmsg_end(skb
, hdr
);
6810 if (data
->nla_type
== NL80211_ATTR_VENDOR_DATA
)
6811 mcgrp
= NL80211_MCGRP_VENDOR
;
6813 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), skb
, 0,
6816 EXPORT_SYMBOL(__cfg80211_send_event_skb
);
6818 #ifdef CONFIG_NL80211_TESTMODE
6819 static int nl80211_testmode_do(struct sk_buff
*skb
, struct genl_info
*info
)
6821 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6822 struct wireless_dev
*wdev
=
6823 __cfg80211_wdev_from_attrs(genl_info_net(info
), info
->attrs
);
6826 if (!rdev
->ops
->testmode_cmd
)
6830 err
= PTR_ERR(wdev
);
6834 } else if (wdev
->wiphy
!= &rdev
->wiphy
) {
6838 if (!info
->attrs
[NL80211_ATTR_TESTDATA
])
6841 rdev
->cur_cmd_info
= info
;
6842 err
= rdev_testmode_cmd(rdev
, wdev
,
6843 nla_data(info
->attrs
[NL80211_ATTR_TESTDATA
]),
6844 nla_len(info
->attrs
[NL80211_ATTR_TESTDATA
]));
6845 rdev
->cur_cmd_info
= NULL
;
6850 static int nl80211_testmode_dump(struct sk_buff
*skb
,
6851 struct netlink_callback
*cb
)
6853 struct cfg80211_registered_device
*rdev
;
6863 * 0 is a valid index, but not valid for args[0],
6864 * so we need to offset by 1.
6866 phy_idx
= cb
->args
[0] - 1;
6868 err
= nlmsg_parse(cb
->nlh
, GENL_HDRLEN
+ nl80211_fam
.hdrsize
,
6869 nl80211_fam
.attrbuf
, nl80211_fam
.maxattr
,
6874 rdev
= __cfg80211_rdev_from_attrs(sock_net(skb
->sk
),
6875 nl80211_fam
.attrbuf
);
6877 err
= PTR_ERR(rdev
);
6880 phy_idx
= rdev
->wiphy_idx
;
6883 if (nl80211_fam
.attrbuf
[NL80211_ATTR_TESTDATA
])
6885 (long)nl80211_fam
.attrbuf
[NL80211_ATTR_TESTDATA
];
6889 data
= nla_data((void *)cb
->args
[1]);
6890 data_len
= nla_len((void *)cb
->args
[1]);
6893 rdev
= cfg80211_rdev_by_wiphy_idx(phy_idx
);
6899 if (!rdev
->ops
->testmode_dump
) {
6905 void *hdr
= nl80211hdr_put(skb
, NETLINK_CB(cb
->skb
).portid
,
6906 cb
->nlh
->nlmsg_seq
, NLM_F_MULTI
,
6907 NL80211_CMD_TESTMODE
);
6908 struct nlattr
*tmdata
;
6913 if (nla_put_u32(skb
, NL80211_ATTR_WIPHY
, phy_idx
)) {
6914 genlmsg_cancel(skb
, hdr
);
6918 tmdata
= nla_nest_start(skb
, NL80211_ATTR_TESTDATA
);
6920 genlmsg_cancel(skb
, hdr
);
6923 err
= rdev_testmode_dump(rdev
, skb
, cb
, data
, data_len
);
6924 nla_nest_end(skb
, tmdata
);
6926 if (err
== -ENOBUFS
|| err
== -ENOENT
) {
6927 genlmsg_cancel(skb
, hdr
);
6930 genlmsg_cancel(skb
, hdr
);
6934 genlmsg_end(skb
, hdr
);
6939 cb
->args
[0] = phy_idx
+ 1;
6946 static int nl80211_connect(struct sk_buff
*skb
, struct genl_info
*info
)
6948 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
6949 struct net_device
*dev
= info
->user_ptr
[1];
6950 struct cfg80211_connect_params connect
;
6951 struct wiphy
*wiphy
;
6952 struct cfg80211_cached_keys
*connkeys
= NULL
;
6955 memset(&connect
, 0, sizeof(connect
));
6957 if (!is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
6960 if (!info
->attrs
[NL80211_ATTR_SSID
] ||
6961 !nla_len(info
->attrs
[NL80211_ATTR_SSID
]))
6964 if (info
->attrs
[NL80211_ATTR_AUTH_TYPE
]) {
6966 nla_get_u32(info
->attrs
[NL80211_ATTR_AUTH_TYPE
]);
6967 if (!nl80211_valid_auth_type(rdev
, connect
.auth_type
,
6968 NL80211_CMD_CONNECT
))
6971 connect
.auth_type
= NL80211_AUTHTYPE_AUTOMATIC
;
6973 connect
.privacy
= info
->attrs
[NL80211_ATTR_PRIVACY
];
6975 err
= nl80211_crypto_settings(rdev
, info
, &connect
.crypto
,
6976 NL80211_MAX_NR_CIPHER_SUITES
);
6980 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
6981 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
6984 wiphy
= &rdev
->wiphy
;
6986 connect
.bg_scan_period
= -1;
6987 if (info
->attrs
[NL80211_ATTR_BG_SCAN_PERIOD
] &&
6988 (wiphy
->flags
& WIPHY_FLAG_SUPPORTS_FW_ROAM
)) {
6989 connect
.bg_scan_period
=
6990 nla_get_u16(info
->attrs
[NL80211_ATTR_BG_SCAN_PERIOD
]);
6993 if (info
->attrs
[NL80211_ATTR_MAC
])
6994 connect
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
6995 else if (info
->attrs
[NL80211_ATTR_MAC_HINT
])
6996 connect
.bssid_hint
=
6997 nla_data(info
->attrs
[NL80211_ATTR_MAC_HINT
]);
6998 connect
.ssid
= nla_data(info
->attrs
[NL80211_ATTR_SSID
]);
6999 connect
.ssid_len
= nla_len(info
->attrs
[NL80211_ATTR_SSID
]);
7001 if (info
->attrs
[NL80211_ATTR_IE
]) {
7002 connect
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
7003 connect
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
7006 if (info
->attrs
[NL80211_ATTR_USE_MFP
]) {
7007 connect
.mfp
= nla_get_u32(info
->attrs
[NL80211_ATTR_USE_MFP
]);
7008 if (connect
.mfp
!= NL80211_MFP_REQUIRED
&&
7009 connect
.mfp
!= NL80211_MFP_NO
)
7012 connect
.mfp
= NL80211_MFP_NO
;
7015 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
7017 ieee80211_get_channel(wiphy
,
7018 nla_get_u32(info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]));
7019 if (!connect
.channel
||
7020 connect
.channel
->flags
& IEEE80211_CHAN_DISABLED
)
7022 } else if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ_HINT
]) {
7023 connect
.channel_hint
=
7024 ieee80211_get_channel(wiphy
,
7026 info
->attrs
[NL80211_ATTR_WIPHY_FREQ_HINT
]));
7027 if (!connect
.channel_hint
||
7028 connect
.channel_hint
->flags
& IEEE80211_CHAN_DISABLED
)
7032 if (connect
.privacy
&& info
->attrs
[NL80211_ATTR_KEYS
]) {
7033 connkeys
= nl80211_parse_connkeys(rdev
,
7034 info
->attrs
[NL80211_ATTR_KEYS
], NULL
);
7035 if (IS_ERR(connkeys
))
7036 return PTR_ERR(connkeys
);
7039 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_HT
]))
7040 connect
.flags
|= ASSOC_REQ_DISABLE_HT
;
7042 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
])
7043 memcpy(&connect
.ht_capa_mask
,
7044 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]),
7045 sizeof(connect
.ht_capa_mask
));
7047 if (info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]) {
7048 if (!info
->attrs
[NL80211_ATTR_HT_CAPABILITY_MASK
]) {
7052 memcpy(&connect
.ht_capa
,
7053 nla_data(info
->attrs
[NL80211_ATTR_HT_CAPABILITY
]),
7054 sizeof(connect
.ht_capa
));
7057 if (nla_get_flag(info
->attrs
[NL80211_ATTR_DISABLE_VHT
]))
7058 connect
.flags
|= ASSOC_REQ_DISABLE_VHT
;
7060 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
])
7061 memcpy(&connect
.vht_capa_mask
,
7062 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
]),
7063 sizeof(connect
.vht_capa_mask
));
7065 if (info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]) {
7066 if (!info
->attrs
[NL80211_ATTR_VHT_CAPABILITY_MASK
]) {
7070 memcpy(&connect
.vht_capa
,
7071 nla_data(info
->attrs
[NL80211_ATTR_VHT_CAPABILITY
]),
7072 sizeof(connect
.vht_capa
));
7075 wdev_lock(dev
->ieee80211_ptr
);
7076 err
= cfg80211_connect(rdev
, dev
, &connect
, connkeys
, NULL
);
7077 wdev_unlock(dev
->ieee80211_ptr
);
7083 static int nl80211_disconnect(struct sk_buff
*skb
, struct genl_info
*info
)
7085 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7086 struct net_device
*dev
= info
->user_ptr
[1];
7090 if (!info
->attrs
[NL80211_ATTR_REASON_CODE
])
7091 reason
= WLAN_REASON_DEAUTH_LEAVING
;
7093 reason
= nla_get_u16(info
->attrs
[NL80211_ATTR_REASON_CODE
]);
7098 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
7099 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
7102 wdev_lock(dev
->ieee80211_ptr
);
7103 ret
= cfg80211_disconnect(rdev
, dev
, reason
, true);
7104 wdev_unlock(dev
->ieee80211_ptr
);
7108 static int nl80211_wiphy_netns(struct sk_buff
*skb
, struct genl_info
*info
)
7110 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7115 if (!info
->attrs
[NL80211_ATTR_PID
])
7118 pid
= nla_get_u32(info
->attrs
[NL80211_ATTR_PID
]);
7120 net
= get_net_ns_by_pid(pid
);
7122 return PTR_ERR(net
);
7126 /* check if anything to do */
7127 if (!net_eq(wiphy_net(&rdev
->wiphy
), net
))
7128 err
= cfg80211_switch_netns(rdev
, net
);
7134 static int nl80211_setdel_pmksa(struct sk_buff
*skb
, struct genl_info
*info
)
7136 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7137 int (*rdev_ops
)(struct wiphy
*wiphy
, struct net_device
*dev
,
7138 struct cfg80211_pmksa
*pmksa
) = NULL
;
7139 struct net_device
*dev
= info
->user_ptr
[1];
7140 struct cfg80211_pmksa pmksa
;
7142 memset(&pmksa
, 0, sizeof(struct cfg80211_pmksa
));
7144 if (!info
->attrs
[NL80211_ATTR_MAC
])
7147 if (!info
->attrs
[NL80211_ATTR_PMKID
])
7150 pmksa
.pmkid
= nla_data(info
->attrs
[NL80211_ATTR_PMKID
]);
7151 pmksa
.bssid
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
7153 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
7154 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
7157 switch (info
->genlhdr
->cmd
) {
7158 case NL80211_CMD_SET_PMKSA
:
7159 rdev_ops
= rdev
->ops
->set_pmksa
;
7161 case NL80211_CMD_DEL_PMKSA
:
7162 rdev_ops
= rdev
->ops
->del_pmksa
;
7172 return rdev_ops(&rdev
->wiphy
, dev
, &pmksa
);
7175 static int nl80211_flush_pmksa(struct sk_buff
*skb
, struct genl_info
*info
)
7177 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7178 struct net_device
*dev
= info
->user_ptr
[1];
7180 if (dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_STATION
&&
7181 dev
->ieee80211_ptr
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
7184 if (!rdev
->ops
->flush_pmksa
)
7187 return rdev_flush_pmksa(rdev
, dev
);
7190 static int nl80211_tdls_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
7192 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7193 struct net_device
*dev
= info
->user_ptr
[1];
7194 u8 action_code
, dialog_token
;
7198 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) ||
7199 !rdev
->ops
->tdls_mgmt
)
7202 if (!info
->attrs
[NL80211_ATTR_TDLS_ACTION
] ||
7203 !info
->attrs
[NL80211_ATTR_STATUS_CODE
] ||
7204 !info
->attrs
[NL80211_ATTR_TDLS_DIALOG_TOKEN
] ||
7205 !info
->attrs
[NL80211_ATTR_IE
] ||
7206 !info
->attrs
[NL80211_ATTR_MAC
])
7209 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
7210 action_code
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_ACTION
]);
7211 status_code
= nla_get_u16(info
->attrs
[NL80211_ATTR_STATUS_CODE
]);
7212 dialog_token
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_DIALOG_TOKEN
]);
7214 return rdev_tdls_mgmt(rdev
, dev
, peer
, action_code
,
7215 dialog_token
, status_code
,
7216 nla_data(info
->attrs
[NL80211_ATTR_IE
]),
7217 nla_len(info
->attrs
[NL80211_ATTR_IE
]));
7220 static int nl80211_tdls_oper(struct sk_buff
*skb
, struct genl_info
*info
)
7222 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7223 struct net_device
*dev
= info
->user_ptr
[1];
7224 enum nl80211_tdls_operation operation
;
7227 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_SUPPORTS_TDLS
) ||
7228 !rdev
->ops
->tdls_oper
)
7231 if (!info
->attrs
[NL80211_ATTR_TDLS_OPERATION
] ||
7232 !info
->attrs
[NL80211_ATTR_MAC
])
7235 operation
= nla_get_u8(info
->attrs
[NL80211_ATTR_TDLS_OPERATION
]);
7236 peer
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
7238 return rdev_tdls_oper(rdev
, dev
, peer
, operation
);
7241 static int nl80211_remain_on_channel(struct sk_buff
*skb
,
7242 struct genl_info
*info
)
7244 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7245 struct wireless_dev
*wdev
= info
->user_ptr
[1];
7246 struct cfg80211_chan_def chandef
;
7247 struct sk_buff
*msg
;
7253 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
] ||
7254 !info
->attrs
[NL80211_ATTR_DURATION
])
7257 duration
= nla_get_u32(info
->attrs
[NL80211_ATTR_DURATION
]);
7259 if (!rdev
->ops
->remain_on_channel
||
7260 !(rdev
->wiphy
.flags
& WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
))
7264 * We should be on that channel for at least a minimum amount of
7265 * time (10ms) but no longer than the driver supports.
7267 if (duration
< NL80211_MIN_REMAIN_ON_CHANNEL_TIME
||
7268 duration
> rdev
->wiphy
.max_remain_on_channel_duration
)
7271 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
7275 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7279 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
7280 NL80211_CMD_REMAIN_ON_CHANNEL
);
7286 err
= rdev_remain_on_channel(rdev
, wdev
, chandef
.chan
,
7292 if (nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
7293 goto nla_put_failure
;
7295 genlmsg_end(msg
, hdr
);
7297 return genlmsg_reply(msg
, info
);
7306 static int nl80211_cancel_remain_on_channel(struct sk_buff
*skb
,
7307 struct genl_info
*info
)
7309 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7310 struct wireless_dev
*wdev
= info
->user_ptr
[1];
7313 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
7316 if (!rdev
->ops
->cancel_remain_on_channel
)
7319 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
7321 return rdev_cancel_remain_on_channel(rdev
, wdev
, cookie
);
7324 static u32
rateset_to_mask(struct ieee80211_supported_band
*sband
,
7325 u8
*rates
, u8 rates_len
)
7330 for (i
= 0; i
< rates_len
; i
++) {
7331 int rate
= (rates
[i
] & 0x7f) * 5;
7333 for (ridx
= 0; ridx
< sband
->n_bitrates
; ridx
++) {
7334 struct ieee80211_rate
*srate
=
7335 &sband
->bitrates
[ridx
];
7336 if (rate
== srate
->bitrate
) {
7341 if (ridx
== sband
->n_bitrates
)
7342 return 0; /* rate not found */
7348 static bool ht_rateset_to_mask(struct ieee80211_supported_band
*sband
,
7349 u8
*rates
, u8 rates_len
,
7350 u8 mcs
[IEEE80211_HT_MCS_MASK_LEN
])
7354 memset(mcs
, 0, IEEE80211_HT_MCS_MASK_LEN
);
7356 for (i
= 0; i
< rates_len
; i
++) {
7359 ridx
= rates
[i
] / 8;
7360 rbit
= BIT(rates
[i
] % 8);
7362 /* check validity */
7363 if ((ridx
< 0) || (ridx
>= IEEE80211_HT_MCS_MASK_LEN
))
7366 /* check availability */
7367 if (sband
->ht_cap
.mcs
.rx_mask
[ridx
] & rbit
)
7376 static u16
vht_mcs_map_to_mcs_mask(u8 vht_mcs_map
)
7380 switch (vht_mcs_map
) {
7381 case IEEE80211_VHT_MCS_NOT_SUPPORTED
:
7383 case IEEE80211_VHT_MCS_SUPPORT_0_7
:
7386 case IEEE80211_VHT_MCS_SUPPORT_0_8
:
7389 case IEEE80211_VHT_MCS_SUPPORT_0_9
:
7399 static void vht_build_mcs_mask(u16 vht_mcs_map
,
7400 u16 vht_mcs_mask
[NL80211_VHT_NSS_MAX
])
7404 for (nss
= 0; nss
< NL80211_VHT_NSS_MAX
; nss
++) {
7405 vht_mcs_mask
[nss
] = vht_mcs_map_to_mcs_mask(vht_mcs_map
& 0x03);
7410 static bool vht_set_mcs_mask(struct ieee80211_supported_band
*sband
,
7411 struct nl80211_txrate_vht
*txrate
,
7412 u16 mcs
[NL80211_VHT_NSS_MAX
])
7414 u16 tx_mcs_map
= le16_to_cpu(sband
->vht_cap
.vht_mcs
.tx_mcs_map
);
7415 u16 tx_mcs_mask
[NL80211_VHT_NSS_MAX
] = {};
7418 if (!sband
->vht_cap
.vht_supported
)
7421 memset(mcs
, 0, sizeof(u16
) * NL80211_VHT_NSS_MAX
);
7423 /* Build vht_mcs_mask from VHT capabilities */
7424 vht_build_mcs_mask(tx_mcs_map
, tx_mcs_mask
);
7426 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++) {
7427 if ((tx_mcs_mask
[i
] & txrate
->mcs
[i
]) == txrate
->mcs
[i
])
7428 mcs
[i
] = txrate
->mcs
[i
];
7436 static const struct nla_policy nl80211_txattr_policy
[NL80211_TXRATE_MAX
+ 1] = {
7437 [NL80211_TXRATE_LEGACY
] = { .type
= NLA_BINARY
,
7438 .len
= NL80211_MAX_SUPP_RATES
},
7439 [NL80211_TXRATE_HT
] = { .type
= NLA_BINARY
,
7440 .len
= NL80211_MAX_SUPP_HT_RATES
},
7441 [NL80211_TXRATE_VHT
] = { .len
= sizeof(struct nl80211_txrate_vht
)},
7444 static int nl80211_set_tx_bitrate_mask(struct sk_buff
*skb
,
7445 struct genl_info
*info
)
7447 struct nlattr
*tb
[NL80211_TXRATE_MAX
+ 1];
7448 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7449 struct cfg80211_bitrate_mask mask
;
7451 struct net_device
*dev
= info
->user_ptr
[1];
7452 struct nlattr
*tx_rates
;
7453 struct ieee80211_supported_band
*sband
;
7456 if (!rdev
->ops
->set_bitrate_mask
)
7459 memset(&mask
, 0, sizeof(mask
));
7460 /* Default to all rates enabled */
7461 for (i
= 0; i
< IEEE80211_NUM_BANDS
; i
++) {
7462 sband
= rdev
->wiphy
.bands
[i
];
7467 mask
.control
[i
].legacy
= (1 << sband
->n_bitrates
) - 1;
7468 memcpy(mask
.control
[i
].ht_mcs
,
7469 sband
->ht_cap
.mcs
.rx_mask
,
7470 sizeof(mask
.control
[i
].ht_mcs
));
7472 if (!sband
->vht_cap
.vht_supported
)
7475 vht_tx_mcs_map
= le16_to_cpu(sband
->vht_cap
.vht_mcs
.tx_mcs_map
);
7476 vht_build_mcs_mask(vht_tx_mcs_map
, mask
.control
[i
].vht_mcs
);
7479 /* if no rates are given set it back to the defaults */
7480 if (!info
->attrs
[NL80211_ATTR_TX_RATES
])
7484 * The nested attribute uses enum nl80211_band as the index. This maps
7485 * directly to the enum ieee80211_band values used in cfg80211.
7487 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES
> IEEE80211_HT_MCS_MASK_LEN
* 8);
7488 nla_for_each_nested(tx_rates
, info
->attrs
[NL80211_ATTR_TX_RATES
], rem
)
7490 enum ieee80211_band band
= nla_type(tx_rates
);
7491 if (band
< 0 || band
>= IEEE80211_NUM_BANDS
)
7493 sband
= rdev
->wiphy
.bands
[band
];
7496 nla_parse(tb
, NL80211_TXRATE_MAX
, nla_data(tx_rates
),
7497 nla_len(tx_rates
), nl80211_txattr_policy
);
7498 if (tb
[NL80211_TXRATE_LEGACY
]) {
7499 mask
.control
[band
].legacy
= rateset_to_mask(
7501 nla_data(tb
[NL80211_TXRATE_LEGACY
]),
7502 nla_len(tb
[NL80211_TXRATE_LEGACY
]));
7503 if ((mask
.control
[band
].legacy
== 0) &&
7504 nla_len(tb
[NL80211_TXRATE_LEGACY
]))
7507 if (tb
[NL80211_TXRATE_HT
]) {
7508 if (!ht_rateset_to_mask(
7510 nla_data(tb
[NL80211_TXRATE_HT
]),
7511 nla_len(tb
[NL80211_TXRATE_HT
]),
7512 mask
.control
[band
].ht_mcs
))
7515 if (tb
[NL80211_TXRATE_VHT
]) {
7516 if (!vht_set_mcs_mask(
7518 nla_data(tb
[NL80211_TXRATE_VHT
]),
7519 mask
.control
[band
].vht_mcs
))
7523 if (mask
.control
[band
].legacy
== 0) {
7524 /* don't allow empty legacy rates if HT or VHT
7525 * are not even supported.
7527 if (!(rdev
->wiphy
.bands
[band
]->ht_cap
.ht_supported
||
7528 rdev
->wiphy
.bands
[band
]->vht_cap
.vht_supported
))
7531 for (i
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
; i
++)
7532 if (mask
.control
[band
].ht_mcs
[i
])
7535 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++)
7536 if (mask
.control
[band
].vht_mcs
[i
])
7539 /* legacy and mcs rates may not be both empty */
7545 return rdev_set_bitrate_mask(rdev
, dev
, NULL
, &mask
);
7548 static int nl80211_register_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
7550 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7551 struct wireless_dev
*wdev
= info
->user_ptr
[1];
7552 u16 frame_type
= IEEE80211_FTYPE_MGMT
| IEEE80211_STYPE_ACTION
;
7554 if (!info
->attrs
[NL80211_ATTR_FRAME_MATCH
])
7557 if (info
->attrs
[NL80211_ATTR_FRAME_TYPE
])
7558 frame_type
= nla_get_u16(info
->attrs
[NL80211_ATTR_FRAME_TYPE
]);
7560 switch (wdev
->iftype
) {
7561 case NL80211_IFTYPE_STATION
:
7562 case NL80211_IFTYPE_ADHOC
:
7563 case NL80211_IFTYPE_P2P_CLIENT
:
7564 case NL80211_IFTYPE_AP
:
7565 case NL80211_IFTYPE_AP_VLAN
:
7566 case NL80211_IFTYPE_MESH_POINT
:
7567 case NL80211_IFTYPE_P2P_GO
:
7568 case NL80211_IFTYPE_P2P_DEVICE
:
7574 /* not much point in registering if we can't reply */
7575 if (!rdev
->ops
->mgmt_tx
)
7578 return cfg80211_mlme_register_mgmt(wdev
, info
->snd_portid
, frame_type
,
7579 nla_data(info
->attrs
[NL80211_ATTR_FRAME_MATCH
]),
7580 nla_len(info
->attrs
[NL80211_ATTR_FRAME_MATCH
]));
7583 static int nl80211_tx_mgmt(struct sk_buff
*skb
, struct genl_info
*info
)
7585 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7586 struct wireless_dev
*wdev
= info
->user_ptr
[1];
7587 struct cfg80211_chan_def chandef
;
7591 struct sk_buff
*msg
= NULL
;
7592 struct cfg80211_mgmt_tx_params params
= {
7593 .dont_wait_for_ack
=
7594 info
->attrs
[NL80211_ATTR_DONT_WAIT_FOR_ACK
],
7597 if (!info
->attrs
[NL80211_ATTR_FRAME
])
7600 if (!rdev
->ops
->mgmt_tx
)
7603 switch (wdev
->iftype
) {
7604 case NL80211_IFTYPE_P2P_DEVICE
:
7605 if (!info
->attrs
[NL80211_ATTR_WIPHY_FREQ
])
7607 case NL80211_IFTYPE_STATION
:
7608 case NL80211_IFTYPE_ADHOC
:
7609 case NL80211_IFTYPE_P2P_CLIENT
:
7610 case NL80211_IFTYPE_AP
:
7611 case NL80211_IFTYPE_AP_VLAN
:
7612 case NL80211_IFTYPE_MESH_POINT
:
7613 case NL80211_IFTYPE_P2P_GO
:
7619 if (info
->attrs
[NL80211_ATTR_DURATION
]) {
7620 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
))
7622 params
.wait
= nla_get_u32(info
->attrs
[NL80211_ATTR_DURATION
]);
7625 * We should wait on the channel for at least a minimum amount
7626 * of time (10ms) but no longer than the driver supports.
7628 if (params
.wait
< NL80211_MIN_REMAIN_ON_CHANNEL_TIME
||
7629 params
.wait
> rdev
->wiphy
.max_remain_on_channel_duration
)
7634 params
.offchan
= info
->attrs
[NL80211_ATTR_OFFCHANNEL_TX_OK
];
7636 if (params
.offchan
&& !(rdev
->wiphy
.flags
& WIPHY_FLAG_OFFCHAN_TX
))
7639 params
.no_cck
= nla_get_flag(info
->attrs
[NL80211_ATTR_TX_NO_CCK_RATE
]);
7641 /* get the channel if any has been specified, otherwise pass NULL to
7642 * the driver. The latter will use the current one
7644 chandef
.chan
= NULL
;
7645 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
7646 err
= nl80211_parse_chandef(rdev
, info
, &chandef
);
7651 if (!chandef
.chan
&& params
.offchan
)
7654 if (!params
.dont_wait_for_ack
) {
7655 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7659 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
7667 params
.buf
= nla_data(info
->attrs
[NL80211_ATTR_FRAME
]);
7668 params
.len
= nla_len(info
->attrs
[NL80211_ATTR_FRAME
]);
7669 params
.chan
= chandef
.chan
;
7670 err
= cfg80211_mlme_mgmt_tx(rdev
, wdev
, ¶ms
, &cookie
);
7675 if (nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
7676 goto nla_put_failure
;
7678 genlmsg_end(msg
, hdr
);
7679 return genlmsg_reply(msg
, info
);
7691 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff
*skb
, struct genl_info
*info
)
7693 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7694 struct wireless_dev
*wdev
= info
->user_ptr
[1];
7697 if (!info
->attrs
[NL80211_ATTR_COOKIE
])
7700 if (!rdev
->ops
->mgmt_tx_cancel_wait
)
7703 switch (wdev
->iftype
) {
7704 case NL80211_IFTYPE_STATION
:
7705 case NL80211_IFTYPE_ADHOC
:
7706 case NL80211_IFTYPE_P2P_CLIENT
:
7707 case NL80211_IFTYPE_AP
:
7708 case NL80211_IFTYPE_AP_VLAN
:
7709 case NL80211_IFTYPE_P2P_GO
:
7710 case NL80211_IFTYPE_P2P_DEVICE
:
7716 cookie
= nla_get_u64(info
->attrs
[NL80211_ATTR_COOKIE
]);
7718 return rdev_mgmt_tx_cancel_wait(rdev
, wdev
, cookie
);
7721 static int nl80211_set_power_save(struct sk_buff
*skb
, struct genl_info
*info
)
7723 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7724 struct wireless_dev
*wdev
;
7725 struct net_device
*dev
= info
->user_ptr
[1];
7730 if (!info
->attrs
[NL80211_ATTR_PS_STATE
])
7733 ps_state
= nla_get_u32(info
->attrs
[NL80211_ATTR_PS_STATE
]);
7735 if (ps_state
!= NL80211_PS_DISABLED
&& ps_state
!= NL80211_PS_ENABLED
)
7738 wdev
= dev
->ieee80211_ptr
;
7740 if (!rdev
->ops
->set_power_mgmt
)
7743 state
= (ps_state
== NL80211_PS_ENABLED
) ? true : false;
7745 if (state
== wdev
->ps
)
7748 err
= rdev_set_power_mgmt(rdev
, dev
, state
, wdev
->ps_timeout
);
7754 static int nl80211_get_power_save(struct sk_buff
*skb
, struct genl_info
*info
)
7756 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7757 enum nl80211_ps_state ps_state
;
7758 struct wireless_dev
*wdev
;
7759 struct net_device
*dev
= info
->user_ptr
[1];
7760 struct sk_buff
*msg
;
7764 wdev
= dev
->ieee80211_ptr
;
7766 if (!rdev
->ops
->set_power_mgmt
)
7769 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
7773 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
7774 NL80211_CMD_GET_POWER_SAVE
);
7781 ps_state
= NL80211_PS_ENABLED
;
7783 ps_state
= NL80211_PS_DISABLED
;
7785 if (nla_put_u32(msg
, NL80211_ATTR_PS_STATE
, ps_state
))
7786 goto nla_put_failure
;
7788 genlmsg_end(msg
, hdr
);
7789 return genlmsg_reply(msg
, info
);
7798 static struct nla_policy
7799 nl80211_attr_cqm_policy
[NL80211_ATTR_CQM_MAX
+ 1] __read_mostly
= {
7800 [NL80211_ATTR_CQM_RSSI_THOLD
] = { .type
= NLA_U32
},
7801 [NL80211_ATTR_CQM_RSSI_HYST
] = { .type
= NLA_U32
},
7802 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
] = { .type
= NLA_U32
},
7803 [NL80211_ATTR_CQM_TXE_RATE
] = { .type
= NLA_U32
},
7804 [NL80211_ATTR_CQM_TXE_PKTS
] = { .type
= NLA_U32
},
7805 [NL80211_ATTR_CQM_TXE_INTVL
] = { .type
= NLA_U32
},
7808 static int nl80211_set_cqm_txe(struct genl_info
*info
,
7809 u32 rate
, u32 pkts
, u32 intvl
)
7811 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7812 struct net_device
*dev
= info
->user_ptr
[1];
7813 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
7815 if (rate
> 100 || intvl
> NL80211_CQM_TXE_MAX_INTVL
)
7818 if (!rdev
->ops
->set_cqm_txe_config
)
7821 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
7822 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
7825 return rdev_set_cqm_txe_config(rdev
, dev
, rate
, pkts
, intvl
);
7828 static int nl80211_set_cqm_rssi(struct genl_info
*info
,
7829 s32 threshold
, u32 hysteresis
)
7831 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7832 struct net_device
*dev
= info
->user_ptr
[1];
7833 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
7838 /* disabling - hysteresis should also be zero then */
7842 if (!rdev
->ops
->set_cqm_rssi_config
)
7845 if (wdev
->iftype
!= NL80211_IFTYPE_STATION
&&
7846 wdev
->iftype
!= NL80211_IFTYPE_P2P_CLIENT
)
7849 return rdev_set_cqm_rssi_config(rdev
, dev
, threshold
, hysteresis
);
7852 static int nl80211_set_cqm(struct sk_buff
*skb
, struct genl_info
*info
)
7854 struct nlattr
*attrs
[NL80211_ATTR_CQM_MAX
+ 1];
7858 cqm
= info
->attrs
[NL80211_ATTR_CQM
];
7862 err
= nla_parse_nested(attrs
, NL80211_ATTR_CQM_MAX
, cqm
,
7863 nl80211_attr_cqm_policy
);
7867 if (attrs
[NL80211_ATTR_CQM_RSSI_THOLD
] &&
7868 attrs
[NL80211_ATTR_CQM_RSSI_HYST
]) {
7869 s32 threshold
= nla_get_s32(attrs
[NL80211_ATTR_CQM_RSSI_THOLD
]);
7870 u32 hysteresis
= nla_get_u32(attrs
[NL80211_ATTR_CQM_RSSI_HYST
]);
7872 return nl80211_set_cqm_rssi(info
, threshold
, hysteresis
);
7875 if (attrs
[NL80211_ATTR_CQM_TXE_RATE
] &&
7876 attrs
[NL80211_ATTR_CQM_TXE_PKTS
] &&
7877 attrs
[NL80211_ATTR_CQM_TXE_INTVL
]) {
7878 u32 rate
= nla_get_u32(attrs
[NL80211_ATTR_CQM_TXE_RATE
]);
7879 u32 pkts
= nla_get_u32(attrs
[NL80211_ATTR_CQM_TXE_PKTS
]);
7880 u32 intvl
= nla_get_u32(attrs
[NL80211_ATTR_CQM_TXE_INTVL
]);
7882 return nl80211_set_cqm_txe(info
, rate
, pkts
, intvl
);
7888 static int nl80211_join_mesh(struct sk_buff
*skb
, struct genl_info
*info
)
7890 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7891 struct net_device
*dev
= info
->user_ptr
[1];
7892 struct mesh_config cfg
;
7893 struct mesh_setup setup
;
7896 /* start with default */
7897 memcpy(&cfg
, &default_mesh_config
, sizeof(cfg
));
7898 memcpy(&setup
, &default_mesh_setup
, sizeof(setup
));
7900 if (info
->attrs
[NL80211_ATTR_MESH_CONFIG
]) {
7901 /* and parse parameters if given */
7902 err
= nl80211_parse_mesh_config(info
, &cfg
, NULL
);
7907 if (!info
->attrs
[NL80211_ATTR_MESH_ID
] ||
7908 !nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]))
7911 setup
.mesh_id
= nla_data(info
->attrs
[NL80211_ATTR_MESH_ID
]);
7912 setup
.mesh_id_len
= nla_len(info
->attrs
[NL80211_ATTR_MESH_ID
]);
7914 if (info
->attrs
[NL80211_ATTR_MCAST_RATE
] &&
7915 !nl80211_parse_mcast_rate(rdev
, setup
.mcast_rate
,
7916 nla_get_u32(info
->attrs
[NL80211_ATTR_MCAST_RATE
])))
7919 if (info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]) {
7920 setup
.beacon_interval
=
7921 nla_get_u32(info
->attrs
[NL80211_ATTR_BEACON_INTERVAL
]);
7922 if (setup
.beacon_interval
< 10 ||
7923 setup
.beacon_interval
> 10000)
7927 if (info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]) {
7929 nla_get_u32(info
->attrs
[NL80211_ATTR_DTIM_PERIOD
]);
7930 if (setup
.dtim_period
< 1 || setup
.dtim_period
> 100)
7934 if (info
->attrs
[NL80211_ATTR_MESH_SETUP
]) {
7935 /* parse additional setup parameters if given */
7936 err
= nl80211_parse_mesh_setup(info
, &setup
);
7942 cfg
.auto_open_plinks
= false;
7944 if (info
->attrs
[NL80211_ATTR_WIPHY_FREQ
]) {
7945 err
= nl80211_parse_chandef(rdev
, info
, &setup
.chandef
);
7949 /* cfg80211_join_mesh() will sort it out */
7950 setup
.chandef
.chan
= NULL
;
7953 if (info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]) {
7954 u8
*rates
= nla_data(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
7956 nla_len(info
->attrs
[NL80211_ATTR_BSS_BASIC_RATES
]);
7957 struct ieee80211_supported_band
*sband
;
7959 if (!setup
.chandef
.chan
)
7962 sband
= rdev
->wiphy
.bands
[setup
.chandef
.chan
->band
];
7964 err
= ieee80211_get_ratemask(sband
, rates
, n_rates
,
7965 &setup
.basic_rates
);
7970 return cfg80211_join_mesh(rdev
, dev
, &setup
, &cfg
);
7973 static int nl80211_leave_mesh(struct sk_buff
*skb
, struct genl_info
*info
)
7975 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
7976 struct net_device
*dev
= info
->user_ptr
[1];
7978 return cfg80211_leave_mesh(rdev
, dev
);
7982 static int nl80211_send_wowlan_patterns(struct sk_buff
*msg
,
7983 struct cfg80211_registered_device
*rdev
)
7985 struct cfg80211_wowlan
*wowlan
= rdev
->wiphy
.wowlan_config
;
7986 struct nlattr
*nl_pats
, *nl_pat
;
7989 if (!wowlan
->n_patterns
)
7992 nl_pats
= nla_nest_start(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
);
7996 for (i
= 0; i
< wowlan
->n_patterns
; i
++) {
7997 nl_pat
= nla_nest_start(msg
, i
+ 1);
8000 pat_len
= wowlan
->patterns
[i
].pattern_len
;
8001 if (nla_put(msg
, NL80211_PKTPAT_MASK
, DIV_ROUND_UP(pat_len
, 8),
8002 wowlan
->patterns
[i
].mask
) ||
8003 nla_put(msg
, NL80211_PKTPAT_PATTERN
, pat_len
,
8004 wowlan
->patterns
[i
].pattern
) ||
8005 nla_put_u32(msg
, NL80211_PKTPAT_OFFSET
,
8006 wowlan
->patterns
[i
].pkt_offset
))
8008 nla_nest_end(msg
, nl_pat
);
8010 nla_nest_end(msg
, nl_pats
);
8015 static int nl80211_send_wowlan_tcp(struct sk_buff
*msg
,
8016 struct cfg80211_wowlan_tcp
*tcp
)
8018 struct nlattr
*nl_tcp
;
8023 nl_tcp
= nla_nest_start(msg
, NL80211_WOWLAN_TRIG_TCP_CONNECTION
);
8027 if (nla_put_be32(msg
, NL80211_WOWLAN_TCP_SRC_IPV4
, tcp
->src
) ||
8028 nla_put_be32(msg
, NL80211_WOWLAN_TCP_DST_IPV4
, tcp
->dst
) ||
8029 nla_put(msg
, NL80211_WOWLAN_TCP_DST_MAC
, ETH_ALEN
, tcp
->dst_mac
) ||
8030 nla_put_u16(msg
, NL80211_WOWLAN_TCP_SRC_PORT
, tcp
->src_port
) ||
8031 nla_put_u16(msg
, NL80211_WOWLAN_TCP_DST_PORT
, tcp
->dst_port
) ||
8032 nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD
,
8033 tcp
->payload_len
, tcp
->payload
) ||
8034 nla_put_u32(msg
, NL80211_WOWLAN_TCP_DATA_INTERVAL
,
8035 tcp
->data_interval
) ||
8036 nla_put(msg
, NL80211_WOWLAN_TCP_WAKE_PAYLOAD
,
8037 tcp
->wake_len
, tcp
->wake_data
) ||
8038 nla_put(msg
, NL80211_WOWLAN_TCP_WAKE_MASK
,
8039 DIV_ROUND_UP(tcp
->wake_len
, 8), tcp
->wake_mask
))
8042 if (tcp
->payload_seq
.len
&&
8043 nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
,
8044 sizeof(tcp
->payload_seq
), &tcp
->payload_seq
))
8047 if (tcp
->payload_tok
.len
&&
8048 nla_put(msg
, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
,
8049 sizeof(tcp
->payload_tok
) + tcp
->tokens_size
,
8053 nla_nest_end(msg
, nl_tcp
);
8058 static int nl80211_get_wowlan(struct sk_buff
*skb
, struct genl_info
*info
)
8060 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8061 struct sk_buff
*msg
;
8063 u32 size
= NLMSG_DEFAULT_SIZE
;
8065 if (!rdev
->wiphy
.wowlan
)
8068 if (rdev
->wiphy
.wowlan_config
&& rdev
->wiphy
.wowlan_config
->tcp
) {
8069 /* adjust size to have room for all the data */
8070 size
+= rdev
->wiphy
.wowlan_config
->tcp
->tokens_size
+
8071 rdev
->wiphy
.wowlan_config
->tcp
->payload_len
+
8072 rdev
->wiphy
.wowlan_config
->tcp
->wake_len
+
8073 rdev
->wiphy
.wowlan_config
->tcp
->wake_len
/ 8;
8076 msg
= nlmsg_new(size
, GFP_KERNEL
);
8080 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
8081 NL80211_CMD_GET_WOWLAN
);
8083 goto nla_put_failure
;
8085 if (rdev
->wiphy
.wowlan_config
) {
8086 struct nlattr
*nl_wowlan
;
8088 nl_wowlan
= nla_nest_start(msg
, NL80211_ATTR_WOWLAN_TRIGGERS
);
8090 goto nla_put_failure
;
8092 if ((rdev
->wiphy
.wowlan_config
->any
&&
8093 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_ANY
)) ||
8094 (rdev
->wiphy
.wowlan_config
->disconnect
&&
8095 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
)) ||
8096 (rdev
->wiphy
.wowlan_config
->magic_pkt
&&
8097 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
)) ||
8098 (rdev
->wiphy
.wowlan_config
->gtk_rekey_failure
&&
8099 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
)) ||
8100 (rdev
->wiphy
.wowlan_config
->eap_identity_req
&&
8101 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
)) ||
8102 (rdev
->wiphy
.wowlan_config
->four_way_handshake
&&
8103 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
)) ||
8104 (rdev
->wiphy
.wowlan_config
->rfkill_release
&&
8105 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
)))
8106 goto nla_put_failure
;
8108 if (nl80211_send_wowlan_patterns(msg
, rdev
))
8109 goto nla_put_failure
;
8111 if (nl80211_send_wowlan_tcp(msg
,
8112 rdev
->wiphy
.wowlan_config
->tcp
))
8113 goto nla_put_failure
;
8115 nla_nest_end(msg
, nl_wowlan
);
8118 genlmsg_end(msg
, hdr
);
8119 return genlmsg_reply(msg
, info
);
8126 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device
*rdev
,
8127 struct nlattr
*attr
,
8128 struct cfg80211_wowlan
*trig
)
8130 struct nlattr
*tb
[NUM_NL80211_WOWLAN_TCP
];
8131 struct cfg80211_wowlan_tcp
*cfg
;
8132 struct nl80211_wowlan_tcp_data_token
*tok
= NULL
;
8133 struct nl80211_wowlan_tcp_data_seq
*seq
= NULL
;
8135 u32 data_size
, wake_size
, tokens_size
= 0, wake_mask_size
;
8138 if (!rdev
->wiphy
.wowlan
->tcp
)
8141 err
= nla_parse(tb
, MAX_NL80211_WOWLAN_TCP
,
8142 nla_data(attr
), nla_len(attr
),
8143 nl80211_wowlan_tcp_policy
);
8147 if (!tb
[NL80211_WOWLAN_TCP_SRC_IPV4
] ||
8148 !tb
[NL80211_WOWLAN_TCP_DST_IPV4
] ||
8149 !tb
[NL80211_WOWLAN_TCP_DST_MAC
] ||
8150 !tb
[NL80211_WOWLAN_TCP_DST_PORT
] ||
8151 !tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD
] ||
8152 !tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
] ||
8153 !tb
[NL80211_WOWLAN_TCP_WAKE_PAYLOAD
] ||
8154 !tb
[NL80211_WOWLAN_TCP_WAKE_MASK
])
8157 data_size
= nla_len(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD
]);
8158 if (data_size
> rdev
->wiphy
.wowlan
->tcp
->data_payload_max
)
8161 if (nla_get_u32(tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
]) >
8162 rdev
->wiphy
.wowlan
->tcp
->data_interval_max
||
8163 nla_get_u32(tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
]) == 0)
8166 wake_size
= nla_len(tb
[NL80211_WOWLAN_TCP_WAKE_PAYLOAD
]);
8167 if (wake_size
> rdev
->wiphy
.wowlan
->tcp
->wake_payload_max
)
8170 wake_mask_size
= nla_len(tb
[NL80211_WOWLAN_TCP_WAKE_MASK
]);
8171 if (wake_mask_size
!= DIV_ROUND_UP(wake_size
, 8))
8174 if (tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
]) {
8175 u32 tokln
= nla_len(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
]);
8177 tok
= nla_data(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN
]);
8178 tokens_size
= tokln
- sizeof(*tok
);
8180 if (!tok
->len
|| tokens_size
% tok
->len
)
8182 if (!rdev
->wiphy
.wowlan
->tcp
->tok
)
8184 if (tok
->len
> rdev
->wiphy
.wowlan
->tcp
->tok
->max_len
)
8186 if (tok
->len
< rdev
->wiphy
.wowlan
->tcp
->tok
->min_len
)
8188 if (tokens_size
> rdev
->wiphy
.wowlan
->tcp
->tok
->bufsize
)
8190 if (tok
->offset
+ tok
->len
> data_size
)
8194 if (tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
]) {
8195 seq
= nla_data(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ
]);
8196 if (!rdev
->wiphy
.wowlan
->tcp
->seq
)
8198 if (seq
->len
== 0 || seq
->len
> 4)
8200 if (seq
->len
+ seq
->offset
> data_size
)
8204 size
= sizeof(*cfg
);
8206 size
+= wake_size
+ wake_mask_size
;
8207 size
+= tokens_size
;
8209 cfg
= kzalloc(size
, GFP_KERNEL
);
8212 cfg
->src
= nla_get_be32(tb
[NL80211_WOWLAN_TCP_SRC_IPV4
]);
8213 cfg
->dst
= nla_get_be32(tb
[NL80211_WOWLAN_TCP_DST_IPV4
]);
8214 memcpy(cfg
->dst_mac
, nla_data(tb
[NL80211_WOWLAN_TCP_DST_MAC
]),
8216 if (tb
[NL80211_WOWLAN_TCP_SRC_PORT
])
8217 port
= nla_get_u16(tb
[NL80211_WOWLAN_TCP_SRC_PORT
]);
8221 /* allocate a socket and port for it and use it */
8222 err
= __sock_create(wiphy_net(&rdev
->wiphy
), PF_INET
, SOCK_STREAM
,
8223 IPPROTO_TCP
, &cfg
->sock
, 1);
8228 if (inet_csk_get_port(cfg
->sock
->sk
, port
)) {
8229 sock_release(cfg
->sock
);
8233 cfg
->src_port
= inet_sk(cfg
->sock
->sk
)->inet_num
;
8239 cfg
->src_port
= port
;
8242 cfg
->dst_port
= nla_get_u16(tb
[NL80211_WOWLAN_TCP_DST_PORT
]);
8243 cfg
->payload_len
= data_size
;
8244 cfg
->payload
= (u8
*)cfg
+ sizeof(*cfg
) + tokens_size
;
8245 memcpy((void *)cfg
->payload
,
8246 nla_data(tb
[NL80211_WOWLAN_TCP_DATA_PAYLOAD
]),
8249 cfg
->payload_seq
= *seq
;
8250 cfg
->data_interval
= nla_get_u32(tb
[NL80211_WOWLAN_TCP_DATA_INTERVAL
]);
8251 cfg
->wake_len
= wake_size
;
8252 cfg
->wake_data
= (u8
*)cfg
+ sizeof(*cfg
) + tokens_size
+ data_size
;
8253 memcpy((void *)cfg
->wake_data
,
8254 nla_data(tb
[NL80211_WOWLAN_TCP_WAKE_PAYLOAD
]),
8256 cfg
->wake_mask
= (u8
*)cfg
+ sizeof(*cfg
) + tokens_size
+
8257 data_size
+ wake_size
;
8258 memcpy((void *)cfg
->wake_mask
,
8259 nla_data(tb
[NL80211_WOWLAN_TCP_WAKE_MASK
]),
8262 cfg
->tokens_size
= tokens_size
;
8263 memcpy(&cfg
->payload_tok
, tok
, sizeof(*tok
) + tokens_size
);
8271 static int nl80211_set_wowlan(struct sk_buff
*skb
, struct genl_info
*info
)
8273 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8274 struct nlattr
*tb
[NUM_NL80211_WOWLAN_TRIG
];
8275 struct cfg80211_wowlan new_triggers
= {};
8276 struct cfg80211_wowlan
*ntrig
;
8277 const struct wiphy_wowlan_support
*wowlan
= rdev
->wiphy
.wowlan
;
8279 bool prev_enabled
= rdev
->wiphy
.wowlan_config
;
8284 if (!info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
]) {
8285 cfg80211_rdev_free_wowlan(rdev
);
8286 rdev
->wiphy
.wowlan_config
= NULL
;
8290 err
= nla_parse(tb
, MAX_NL80211_WOWLAN_TRIG
,
8291 nla_data(info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
]),
8292 nla_len(info
->attrs
[NL80211_ATTR_WOWLAN_TRIGGERS
]),
8293 nl80211_wowlan_policy
);
8297 if (tb
[NL80211_WOWLAN_TRIG_ANY
]) {
8298 if (!(wowlan
->flags
& WIPHY_WOWLAN_ANY
))
8300 new_triggers
.any
= true;
8303 if (tb
[NL80211_WOWLAN_TRIG_DISCONNECT
]) {
8304 if (!(wowlan
->flags
& WIPHY_WOWLAN_DISCONNECT
))
8306 new_triggers
.disconnect
= true;
8309 if (tb
[NL80211_WOWLAN_TRIG_MAGIC_PKT
]) {
8310 if (!(wowlan
->flags
& WIPHY_WOWLAN_MAGIC_PKT
))
8312 new_triggers
.magic_pkt
= true;
8315 if (tb
[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED
])
8318 if (tb
[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
]) {
8319 if (!(wowlan
->flags
& WIPHY_WOWLAN_GTK_REKEY_FAILURE
))
8321 new_triggers
.gtk_rekey_failure
= true;
8324 if (tb
[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
]) {
8325 if (!(wowlan
->flags
& WIPHY_WOWLAN_EAP_IDENTITY_REQ
))
8327 new_triggers
.eap_identity_req
= true;
8330 if (tb
[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
]) {
8331 if (!(wowlan
->flags
& WIPHY_WOWLAN_4WAY_HANDSHAKE
))
8333 new_triggers
.four_way_handshake
= true;
8336 if (tb
[NL80211_WOWLAN_TRIG_RFKILL_RELEASE
]) {
8337 if (!(wowlan
->flags
& WIPHY_WOWLAN_RFKILL_RELEASE
))
8339 new_triggers
.rfkill_release
= true;
8342 if (tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
]) {
8345 int rem
, pat_len
, mask_len
, pkt_offset
;
8346 struct nlattr
*pat_tb
[NUM_NL80211_PKTPAT
];
8348 nla_for_each_nested(pat
, tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
],
8351 if (n_patterns
> wowlan
->n_patterns
)
8354 new_triggers
.patterns
= kcalloc(n_patterns
,
8355 sizeof(new_triggers
.patterns
[0]),
8357 if (!new_triggers
.patterns
)
8360 new_triggers
.n_patterns
= n_patterns
;
8363 nla_for_each_nested(pat
, tb
[NL80211_WOWLAN_TRIG_PKT_PATTERN
],
8365 nla_parse(pat_tb
, MAX_NL80211_PKTPAT
, nla_data(pat
),
8366 nla_len(pat
), NULL
);
8368 if (!pat_tb
[NL80211_PKTPAT_MASK
] ||
8369 !pat_tb
[NL80211_PKTPAT_PATTERN
])
8371 pat_len
= nla_len(pat_tb
[NL80211_PKTPAT_PATTERN
]);
8372 mask_len
= DIV_ROUND_UP(pat_len
, 8);
8373 if (nla_len(pat_tb
[NL80211_PKTPAT_MASK
]) != mask_len
)
8375 if (pat_len
> wowlan
->pattern_max_len
||
8376 pat_len
< wowlan
->pattern_min_len
)
8379 if (!pat_tb
[NL80211_PKTPAT_OFFSET
])
8382 pkt_offset
= nla_get_u32(
8383 pat_tb
[NL80211_PKTPAT_OFFSET
]);
8384 if (pkt_offset
> wowlan
->max_pkt_offset
)
8386 new_triggers
.patterns
[i
].pkt_offset
= pkt_offset
;
8388 new_triggers
.patterns
[i
].mask
=
8389 kmalloc(mask_len
+ pat_len
, GFP_KERNEL
);
8390 if (!new_triggers
.patterns
[i
].mask
) {
8394 new_triggers
.patterns
[i
].pattern
=
8395 new_triggers
.patterns
[i
].mask
+ mask_len
;
8396 memcpy(new_triggers
.patterns
[i
].mask
,
8397 nla_data(pat_tb
[NL80211_PKTPAT_MASK
]),
8399 new_triggers
.patterns
[i
].pattern_len
= pat_len
;
8400 memcpy(new_triggers
.patterns
[i
].pattern
,
8401 nla_data(pat_tb
[NL80211_PKTPAT_PATTERN
]),
8407 if (tb
[NL80211_WOWLAN_TRIG_TCP_CONNECTION
]) {
8408 err
= nl80211_parse_wowlan_tcp(
8409 rdev
, tb
[NL80211_WOWLAN_TRIG_TCP_CONNECTION
],
8415 ntrig
= kmemdup(&new_triggers
, sizeof(new_triggers
), GFP_KERNEL
);
8420 cfg80211_rdev_free_wowlan(rdev
);
8421 rdev
->wiphy
.wowlan_config
= ntrig
;
8424 if (rdev
->ops
->set_wakeup
&&
8425 prev_enabled
!= !!rdev
->wiphy
.wowlan_config
)
8426 rdev_set_wakeup(rdev
, rdev
->wiphy
.wowlan_config
);
8430 for (i
= 0; i
< new_triggers
.n_patterns
; i
++)
8431 kfree(new_triggers
.patterns
[i
].mask
);
8432 kfree(new_triggers
.patterns
);
8433 if (new_triggers
.tcp
&& new_triggers
.tcp
->sock
)
8434 sock_release(new_triggers
.tcp
->sock
);
8435 kfree(new_triggers
.tcp
);
8440 static int nl80211_send_coalesce_rules(struct sk_buff
*msg
,
8441 struct cfg80211_registered_device
*rdev
)
8443 struct nlattr
*nl_pats
, *nl_pat
, *nl_rule
, *nl_rules
;
8445 struct cfg80211_coalesce_rules
*rule
;
8447 if (!rdev
->coalesce
->n_rules
)
8450 nl_rules
= nla_nest_start(msg
, NL80211_ATTR_COALESCE_RULE
);
8454 for (i
= 0; i
< rdev
->coalesce
->n_rules
; i
++) {
8455 nl_rule
= nla_nest_start(msg
, i
+ 1);
8459 rule
= &rdev
->coalesce
->rules
[i
];
8460 if (nla_put_u32(msg
, NL80211_ATTR_COALESCE_RULE_DELAY
,
8464 if (nla_put_u32(msg
, NL80211_ATTR_COALESCE_RULE_CONDITION
,
8468 nl_pats
= nla_nest_start(msg
,
8469 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
);
8473 for (j
= 0; j
< rule
->n_patterns
; j
++) {
8474 nl_pat
= nla_nest_start(msg
, j
+ 1);
8477 pat_len
= rule
->patterns
[j
].pattern_len
;
8478 if (nla_put(msg
, NL80211_PKTPAT_MASK
,
8479 DIV_ROUND_UP(pat_len
, 8),
8480 rule
->patterns
[j
].mask
) ||
8481 nla_put(msg
, NL80211_PKTPAT_PATTERN
, pat_len
,
8482 rule
->patterns
[j
].pattern
) ||
8483 nla_put_u32(msg
, NL80211_PKTPAT_OFFSET
,
8484 rule
->patterns
[j
].pkt_offset
))
8486 nla_nest_end(msg
, nl_pat
);
8488 nla_nest_end(msg
, nl_pats
);
8489 nla_nest_end(msg
, nl_rule
);
8491 nla_nest_end(msg
, nl_rules
);
8496 static int nl80211_get_coalesce(struct sk_buff
*skb
, struct genl_info
*info
)
8498 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8499 struct sk_buff
*msg
;
8502 if (!rdev
->wiphy
.coalesce
)
8505 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
8509 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
8510 NL80211_CMD_GET_COALESCE
);
8512 goto nla_put_failure
;
8514 if (rdev
->coalesce
&& nl80211_send_coalesce_rules(msg
, rdev
))
8515 goto nla_put_failure
;
8517 genlmsg_end(msg
, hdr
);
8518 return genlmsg_reply(msg
, info
);
8525 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device
*rdev
)
8527 struct cfg80211_coalesce
*coalesce
= rdev
->coalesce
;
8529 struct cfg80211_coalesce_rules
*rule
;
8534 for (i
= 0; i
< coalesce
->n_rules
; i
++) {
8535 rule
= &coalesce
->rules
[i
];
8536 for (j
= 0; j
< rule
->n_patterns
; j
++)
8537 kfree(rule
->patterns
[j
].mask
);
8538 kfree(rule
->patterns
);
8540 kfree(coalesce
->rules
);
8542 rdev
->coalesce
= NULL
;
8545 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device
*rdev
,
8546 struct nlattr
*rule
,
8547 struct cfg80211_coalesce_rules
*new_rule
)
8550 const struct wiphy_coalesce_support
*coalesce
= rdev
->wiphy
.coalesce
;
8551 struct nlattr
*tb
[NUM_NL80211_ATTR_COALESCE_RULE
], *pat
;
8552 int rem
, pat_len
, mask_len
, pkt_offset
, n_patterns
= 0;
8553 struct nlattr
*pat_tb
[NUM_NL80211_PKTPAT
];
8555 err
= nla_parse(tb
, NL80211_ATTR_COALESCE_RULE_MAX
, nla_data(rule
),
8556 nla_len(rule
), nl80211_coalesce_policy
);
8560 if (tb
[NL80211_ATTR_COALESCE_RULE_DELAY
])
8562 nla_get_u32(tb
[NL80211_ATTR_COALESCE_RULE_DELAY
]);
8563 if (new_rule
->delay
> coalesce
->max_delay
)
8566 if (tb
[NL80211_ATTR_COALESCE_RULE_CONDITION
])
8567 new_rule
->condition
=
8568 nla_get_u32(tb
[NL80211_ATTR_COALESCE_RULE_CONDITION
]);
8569 if (new_rule
->condition
!= NL80211_COALESCE_CONDITION_MATCH
&&
8570 new_rule
->condition
!= NL80211_COALESCE_CONDITION_NO_MATCH
)
8573 if (!tb
[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
])
8576 nla_for_each_nested(pat
, tb
[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
],
8579 if (n_patterns
> coalesce
->n_patterns
)
8582 new_rule
->patterns
= kcalloc(n_patterns
, sizeof(new_rule
->patterns
[0]),
8584 if (!new_rule
->patterns
)
8587 new_rule
->n_patterns
= n_patterns
;
8590 nla_for_each_nested(pat
, tb
[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN
],
8592 nla_parse(pat_tb
, MAX_NL80211_PKTPAT
, nla_data(pat
),
8593 nla_len(pat
), NULL
);
8594 if (!pat_tb
[NL80211_PKTPAT_MASK
] ||
8595 !pat_tb
[NL80211_PKTPAT_PATTERN
])
8597 pat_len
= nla_len(pat_tb
[NL80211_PKTPAT_PATTERN
]);
8598 mask_len
= DIV_ROUND_UP(pat_len
, 8);
8599 if (nla_len(pat_tb
[NL80211_PKTPAT_MASK
]) != mask_len
)
8601 if (pat_len
> coalesce
->pattern_max_len
||
8602 pat_len
< coalesce
->pattern_min_len
)
8605 if (!pat_tb
[NL80211_PKTPAT_OFFSET
])
8608 pkt_offset
= nla_get_u32(pat_tb
[NL80211_PKTPAT_OFFSET
]);
8609 if (pkt_offset
> coalesce
->max_pkt_offset
)
8611 new_rule
->patterns
[i
].pkt_offset
= pkt_offset
;
8613 new_rule
->patterns
[i
].mask
=
8614 kmalloc(mask_len
+ pat_len
, GFP_KERNEL
);
8615 if (!new_rule
->patterns
[i
].mask
)
8617 new_rule
->patterns
[i
].pattern
=
8618 new_rule
->patterns
[i
].mask
+ mask_len
;
8619 memcpy(new_rule
->patterns
[i
].mask
,
8620 nla_data(pat_tb
[NL80211_PKTPAT_MASK
]), mask_len
);
8621 new_rule
->patterns
[i
].pattern_len
= pat_len
;
8622 memcpy(new_rule
->patterns
[i
].pattern
,
8623 nla_data(pat_tb
[NL80211_PKTPAT_PATTERN
]), pat_len
);
8630 static int nl80211_set_coalesce(struct sk_buff
*skb
, struct genl_info
*info
)
8632 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8633 const struct wiphy_coalesce_support
*coalesce
= rdev
->wiphy
.coalesce
;
8634 struct cfg80211_coalesce new_coalesce
= {};
8635 struct cfg80211_coalesce
*n_coalesce
;
8636 int err
, rem_rule
, n_rules
= 0, i
, j
;
8637 struct nlattr
*rule
;
8638 struct cfg80211_coalesce_rules
*tmp_rule
;
8640 if (!rdev
->wiphy
.coalesce
|| !rdev
->ops
->set_coalesce
)
8643 if (!info
->attrs
[NL80211_ATTR_COALESCE_RULE
]) {
8644 cfg80211_rdev_free_coalesce(rdev
);
8645 rdev
->ops
->set_coalesce(&rdev
->wiphy
, NULL
);
8649 nla_for_each_nested(rule
, info
->attrs
[NL80211_ATTR_COALESCE_RULE
],
8652 if (n_rules
> coalesce
->n_rules
)
8655 new_coalesce
.rules
= kcalloc(n_rules
, sizeof(new_coalesce
.rules
[0]),
8657 if (!new_coalesce
.rules
)
8660 new_coalesce
.n_rules
= n_rules
;
8663 nla_for_each_nested(rule
, info
->attrs
[NL80211_ATTR_COALESCE_RULE
],
8665 err
= nl80211_parse_coalesce_rule(rdev
, rule
,
8666 &new_coalesce
.rules
[i
]);
8673 err
= rdev
->ops
->set_coalesce(&rdev
->wiphy
, &new_coalesce
);
8677 n_coalesce
= kmemdup(&new_coalesce
, sizeof(new_coalesce
), GFP_KERNEL
);
8682 cfg80211_rdev_free_coalesce(rdev
);
8683 rdev
->coalesce
= n_coalesce
;
8687 for (i
= 0; i
< new_coalesce
.n_rules
; i
++) {
8688 tmp_rule
= &new_coalesce
.rules
[i
];
8689 for (j
= 0; j
< tmp_rule
->n_patterns
; j
++)
8690 kfree(tmp_rule
->patterns
[j
].mask
);
8691 kfree(tmp_rule
->patterns
);
8693 kfree(new_coalesce
.rules
);
8698 static int nl80211_set_rekey_data(struct sk_buff
*skb
, struct genl_info
*info
)
8700 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8701 struct net_device
*dev
= info
->user_ptr
[1];
8702 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
8703 struct nlattr
*tb
[NUM_NL80211_REKEY_DATA
];
8704 struct cfg80211_gtk_rekey_data rekey_data
;
8707 if (!info
->attrs
[NL80211_ATTR_REKEY_DATA
])
8710 err
= nla_parse(tb
, MAX_NL80211_REKEY_DATA
,
8711 nla_data(info
->attrs
[NL80211_ATTR_REKEY_DATA
]),
8712 nla_len(info
->attrs
[NL80211_ATTR_REKEY_DATA
]),
8713 nl80211_rekey_policy
);
8717 if (nla_len(tb
[NL80211_REKEY_DATA_REPLAY_CTR
]) != NL80211_REPLAY_CTR_LEN
)
8719 if (nla_len(tb
[NL80211_REKEY_DATA_KEK
]) != NL80211_KEK_LEN
)
8721 if (nla_len(tb
[NL80211_REKEY_DATA_KCK
]) != NL80211_KCK_LEN
)
8724 memcpy(rekey_data
.kek
, nla_data(tb
[NL80211_REKEY_DATA_KEK
]),
8726 memcpy(rekey_data
.kck
, nla_data(tb
[NL80211_REKEY_DATA_KCK
]),
8728 memcpy(rekey_data
.replay_ctr
,
8729 nla_data(tb
[NL80211_REKEY_DATA_REPLAY_CTR
]),
8730 NL80211_REPLAY_CTR_LEN
);
8733 if (!wdev
->current_bss
) {
8738 if (!rdev
->ops
->set_rekey_data
) {
8743 err
= rdev_set_rekey_data(rdev
, dev
, &rekey_data
);
8749 static int nl80211_register_unexpected_frame(struct sk_buff
*skb
,
8750 struct genl_info
*info
)
8752 struct net_device
*dev
= info
->user_ptr
[1];
8753 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
8755 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
8756 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
8759 if (wdev
->ap_unexpected_nlportid
)
8762 wdev
->ap_unexpected_nlportid
= info
->snd_portid
;
8766 static int nl80211_probe_client(struct sk_buff
*skb
,
8767 struct genl_info
*info
)
8769 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8770 struct net_device
*dev
= info
->user_ptr
[1];
8771 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
8772 struct sk_buff
*msg
;
8778 if (wdev
->iftype
!= NL80211_IFTYPE_AP
&&
8779 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)
8782 if (!info
->attrs
[NL80211_ATTR_MAC
])
8785 if (!rdev
->ops
->probe_client
)
8788 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
8792 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
8793 NL80211_CMD_PROBE_CLIENT
);
8799 addr
= nla_data(info
->attrs
[NL80211_ATTR_MAC
]);
8801 err
= rdev_probe_client(rdev
, dev
, addr
, &cookie
);
8805 if (nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
8806 goto nla_put_failure
;
8808 genlmsg_end(msg
, hdr
);
8810 return genlmsg_reply(msg
, info
);
8819 static int nl80211_register_beacons(struct sk_buff
*skb
, struct genl_info
*info
)
8821 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8822 struct cfg80211_beacon_registration
*reg
, *nreg
;
8825 if (!(rdev
->wiphy
.flags
& WIPHY_FLAG_REPORTS_OBSS
))
8828 nreg
= kzalloc(sizeof(*nreg
), GFP_KERNEL
);
8832 /* First, check if already registered. */
8833 spin_lock_bh(&rdev
->beacon_registrations_lock
);
8834 list_for_each_entry(reg
, &rdev
->beacon_registrations
, list
) {
8835 if (reg
->nlportid
== info
->snd_portid
) {
8840 /* Add it to the list */
8841 nreg
->nlportid
= info
->snd_portid
;
8842 list_add(&nreg
->list
, &rdev
->beacon_registrations
);
8844 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
8848 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
8853 static int nl80211_start_p2p_device(struct sk_buff
*skb
, struct genl_info
*info
)
8855 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8856 struct wireless_dev
*wdev
= info
->user_ptr
[1];
8859 if (!rdev
->ops
->start_p2p_device
)
8862 if (wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
)
8865 if (wdev
->p2p_started
)
8868 err
= cfg80211_can_add_interface(rdev
, wdev
->iftype
);
8872 err
= rdev_start_p2p_device(rdev
, wdev
);
8876 wdev
->p2p_started
= true;
8882 static int nl80211_stop_p2p_device(struct sk_buff
*skb
, struct genl_info
*info
)
8884 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8885 struct wireless_dev
*wdev
= info
->user_ptr
[1];
8887 if (wdev
->iftype
!= NL80211_IFTYPE_P2P_DEVICE
)
8890 if (!rdev
->ops
->stop_p2p_device
)
8893 cfg80211_stop_p2p_device(rdev
, wdev
);
8898 static int nl80211_get_protocol_features(struct sk_buff
*skb
,
8899 struct genl_info
*info
)
8902 struct sk_buff
*msg
;
8904 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
8908 hdr
= nl80211hdr_put(msg
, info
->snd_portid
, info
->snd_seq
, 0,
8909 NL80211_CMD_GET_PROTOCOL_FEATURES
);
8911 goto nla_put_failure
;
8913 if (nla_put_u32(msg
, NL80211_ATTR_PROTOCOL_FEATURES
,
8914 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP
))
8915 goto nla_put_failure
;
8917 genlmsg_end(msg
, hdr
);
8918 return genlmsg_reply(msg
, info
);
8925 static int nl80211_update_ft_ies(struct sk_buff
*skb
, struct genl_info
*info
)
8927 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8928 struct cfg80211_update_ft_ies_params ft_params
;
8929 struct net_device
*dev
= info
->user_ptr
[1];
8931 if (!rdev
->ops
->update_ft_ies
)
8934 if (!info
->attrs
[NL80211_ATTR_MDID
] ||
8935 !is_valid_ie_attr(info
->attrs
[NL80211_ATTR_IE
]))
8938 memset(&ft_params
, 0, sizeof(ft_params
));
8939 ft_params
.md
= nla_get_u16(info
->attrs
[NL80211_ATTR_MDID
]);
8940 ft_params
.ie
= nla_data(info
->attrs
[NL80211_ATTR_IE
]);
8941 ft_params
.ie_len
= nla_len(info
->attrs
[NL80211_ATTR_IE
]);
8943 return rdev_update_ft_ies(rdev
, dev
, &ft_params
);
8946 static int nl80211_crit_protocol_start(struct sk_buff
*skb
,
8947 struct genl_info
*info
)
8949 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8950 struct wireless_dev
*wdev
= info
->user_ptr
[1];
8951 enum nl80211_crit_proto_id proto
= NL80211_CRIT_PROTO_UNSPEC
;
8955 if (!rdev
->ops
->crit_proto_start
)
8958 if (WARN_ON(!rdev
->ops
->crit_proto_stop
))
8961 if (rdev
->crit_proto_nlportid
)
8964 /* determine protocol if provided */
8965 if (info
->attrs
[NL80211_ATTR_CRIT_PROT_ID
])
8966 proto
= nla_get_u16(info
->attrs
[NL80211_ATTR_CRIT_PROT_ID
]);
8968 if (proto
>= NUM_NL80211_CRIT_PROTO
)
8971 /* timeout must be provided */
8972 if (!info
->attrs
[NL80211_ATTR_MAX_CRIT_PROT_DURATION
])
8976 nla_get_u16(info
->attrs
[NL80211_ATTR_MAX_CRIT_PROT_DURATION
]);
8978 if (duration
> NL80211_CRIT_PROTO_MAX_DURATION
)
8981 ret
= rdev_crit_proto_start(rdev
, wdev
, proto
, duration
);
8983 rdev
->crit_proto_nlportid
= info
->snd_portid
;
8988 static int nl80211_crit_protocol_stop(struct sk_buff
*skb
,
8989 struct genl_info
*info
)
8991 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
8992 struct wireless_dev
*wdev
= info
->user_ptr
[1];
8994 if (!rdev
->ops
->crit_proto_stop
)
8997 if (rdev
->crit_proto_nlportid
) {
8998 rdev
->crit_proto_nlportid
= 0;
8999 rdev_crit_proto_stop(rdev
, wdev
);
9004 static int nl80211_vendor_cmd(struct sk_buff
*skb
, struct genl_info
*info
)
9006 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9007 struct wireless_dev
*wdev
=
9008 __cfg80211_wdev_from_attrs(genl_info_net(info
), info
->attrs
);
9012 if (!rdev
->wiphy
.vendor_commands
)
9016 err
= PTR_ERR(wdev
);
9020 } else if (wdev
->wiphy
!= &rdev
->wiphy
) {
9024 if (!info
->attrs
[NL80211_ATTR_VENDOR_ID
] ||
9025 !info
->attrs
[NL80211_ATTR_VENDOR_SUBCMD
])
9028 vid
= nla_get_u32(info
->attrs
[NL80211_ATTR_VENDOR_ID
]);
9029 subcmd
= nla_get_u32(info
->attrs
[NL80211_ATTR_VENDOR_SUBCMD
]);
9030 for (i
= 0; i
< rdev
->wiphy
.n_vendor_commands
; i
++) {
9031 const struct wiphy_vendor_command
*vcmd
;
9035 vcmd
= &rdev
->wiphy
.vendor_commands
[i
];
9037 if (vcmd
->info
.vendor_id
!= vid
|| vcmd
->info
.subcmd
!= subcmd
)
9040 if (vcmd
->flags
& (WIPHY_VENDOR_CMD_NEED_WDEV
|
9041 WIPHY_VENDOR_CMD_NEED_NETDEV
)) {
9044 if (vcmd
->flags
& WIPHY_VENDOR_CMD_NEED_NETDEV
&&
9048 if (vcmd
->flags
& WIPHY_VENDOR_CMD_NEED_RUNNING
) {
9050 !netif_running(wdev
->netdev
))
9052 if (!wdev
->netdev
&& !wdev
->p2p_started
)
9059 if (info
->attrs
[NL80211_ATTR_VENDOR_DATA
]) {
9060 data
= nla_data(info
->attrs
[NL80211_ATTR_VENDOR_DATA
]);
9061 len
= nla_len(info
->attrs
[NL80211_ATTR_VENDOR_DATA
]);
9064 rdev
->cur_cmd_info
= info
;
9065 err
= rdev
->wiphy
.vendor_commands
[i
].doit(&rdev
->wiphy
, wdev
,
9067 rdev
->cur_cmd_info
= NULL
;
9074 struct sk_buff
*__cfg80211_alloc_reply_skb(struct wiphy
*wiphy
,
9075 enum nl80211_commands cmd
,
9076 enum nl80211_attrs attr
,
9079 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
9081 if (WARN_ON(!rdev
->cur_cmd_info
))
9084 return __cfg80211_alloc_vendor_skb(rdev
, approxlen
,
9085 rdev
->cur_cmd_info
->snd_portid
,
9086 rdev
->cur_cmd_info
->snd_seq
,
9087 cmd
, attr
, NULL
, GFP_KERNEL
);
9089 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb
);
9091 int cfg80211_vendor_cmd_reply(struct sk_buff
*skb
)
9093 struct cfg80211_registered_device
*rdev
= ((void **)skb
->cb
)[0];
9094 void *hdr
= ((void **)skb
->cb
)[1];
9095 struct nlattr
*data
= ((void **)skb
->cb
)[2];
9097 if (WARN_ON(!rdev
->cur_cmd_info
)) {
9102 nla_nest_end(skb
, data
);
9103 genlmsg_end(skb
, hdr
);
9104 return genlmsg_reply(skb
, rdev
->cur_cmd_info
);
9106 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply
);
9109 static int nl80211_set_qos_map(struct sk_buff
*skb
,
9110 struct genl_info
*info
)
9112 struct cfg80211_registered_device
*rdev
= info
->user_ptr
[0];
9113 struct cfg80211_qos_map
*qos_map
= NULL
;
9114 struct net_device
*dev
= info
->user_ptr
[1];
9115 u8
*pos
, len
, num_des
, des_len
, des
;
9118 if (!rdev
->ops
->set_qos_map
)
9121 if (info
->attrs
[NL80211_ATTR_QOS_MAP
]) {
9122 pos
= nla_data(info
->attrs
[NL80211_ATTR_QOS_MAP
]);
9123 len
= nla_len(info
->attrs
[NL80211_ATTR_QOS_MAP
]);
9125 if (len
% 2 || len
< IEEE80211_QOS_MAP_LEN_MIN
||
9126 len
> IEEE80211_QOS_MAP_LEN_MAX
)
9129 qos_map
= kzalloc(sizeof(struct cfg80211_qos_map
), GFP_KERNEL
);
9133 num_des
= (len
- IEEE80211_QOS_MAP_LEN_MIN
) >> 1;
9136 sizeof(struct cfg80211_dscp_exception
);
9137 memcpy(qos_map
->dscp_exception
, pos
, des_len
);
9138 qos_map
->num_des
= num_des
;
9139 for (des
= 0; des
< num_des
; des
++) {
9140 if (qos_map
->dscp_exception
[des
].up
> 7) {
9147 memcpy(qos_map
->up
, pos
, IEEE80211_QOS_MAP_LEN_MIN
);
9150 wdev_lock(dev
->ieee80211_ptr
);
9151 ret
= nl80211_key_allowed(dev
->ieee80211_ptr
);
9153 ret
= rdev_set_qos_map(rdev
, dev
, qos_map
);
9154 wdev_unlock(dev
->ieee80211_ptr
);
9160 #define NL80211_FLAG_NEED_WIPHY 0x01
9161 #define NL80211_FLAG_NEED_NETDEV 0x02
9162 #define NL80211_FLAG_NEED_RTNL 0x04
9163 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
9164 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
9165 NL80211_FLAG_CHECK_NETDEV_UP)
9166 #define NL80211_FLAG_NEED_WDEV 0x10
9167 /* If a netdev is associated, it must be UP, P2P must be started */
9168 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
9169 NL80211_FLAG_CHECK_NETDEV_UP)
9171 static int nl80211_pre_doit(const struct genl_ops
*ops
, struct sk_buff
*skb
,
9172 struct genl_info
*info
)
9174 struct cfg80211_registered_device
*rdev
;
9175 struct wireless_dev
*wdev
;
9176 struct net_device
*dev
;
9177 bool rtnl
= ops
->internal_flags
& NL80211_FLAG_NEED_RTNL
;
9182 if (ops
->internal_flags
& NL80211_FLAG_NEED_WIPHY
) {
9183 rdev
= cfg80211_get_dev_from_info(genl_info_net(info
), info
);
9187 return PTR_ERR(rdev
);
9189 info
->user_ptr
[0] = rdev
;
9190 } else if (ops
->internal_flags
& NL80211_FLAG_NEED_NETDEV
||
9191 ops
->internal_flags
& NL80211_FLAG_NEED_WDEV
) {
9194 wdev
= __cfg80211_wdev_from_attrs(genl_info_net(info
),
9199 return PTR_ERR(wdev
);
9203 rdev
= wiphy_to_dev(wdev
->wiphy
);
9205 if (ops
->internal_flags
& NL80211_FLAG_NEED_NETDEV
) {
9212 info
->user_ptr
[1] = dev
;
9214 info
->user_ptr
[1] = wdev
;
9218 if (ops
->internal_flags
& NL80211_FLAG_CHECK_NETDEV_UP
&&
9219 !netif_running(dev
)) {
9226 } else if (ops
->internal_flags
& NL80211_FLAG_CHECK_NETDEV_UP
) {
9227 if (!wdev
->p2p_started
) {
9234 info
->user_ptr
[0] = rdev
;
9240 static void nl80211_post_doit(const struct genl_ops
*ops
, struct sk_buff
*skb
,
9241 struct genl_info
*info
)
9243 if (info
->user_ptr
[1]) {
9244 if (ops
->internal_flags
& NL80211_FLAG_NEED_WDEV
) {
9245 struct wireless_dev
*wdev
= info
->user_ptr
[1];
9248 dev_put(wdev
->netdev
);
9250 dev_put(info
->user_ptr
[1]);
9253 if (ops
->internal_flags
& NL80211_FLAG_NEED_RTNL
)
9257 static const struct genl_ops nl80211_ops
[] = {
9259 .cmd
= NL80211_CMD_GET_WIPHY
,
9260 .doit
= nl80211_get_wiphy
,
9261 .dumpit
= nl80211_dump_wiphy
,
9262 .done
= nl80211_dump_wiphy_done
,
9263 .policy
= nl80211_policy
,
9264 /* can be retrieved by unprivileged users */
9265 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9266 NL80211_FLAG_NEED_RTNL
,
9269 .cmd
= NL80211_CMD_SET_WIPHY
,
9270 .doit
= nl80211_set_wiphy
,
9271 .policy
= nl80211_policy
,
9272 .flags
= GENL_ADMIN_PERM
,
9273 .internal_flags
= NL80211_FLAG_NEED_RTNL
,
9276 .cmd
= NL80211_CMD_GET_INTERFACE
,
9277 .doit
= nl80211_get_interface
,
9278 .dumpit
= nl80211_dump_interface
,
9279 .policy
= nl80211_policy
,
9280 /* can be retrieved by unprivileged users */
9281 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
9282 NL80211_FLAG_NEED_RTNL
,
9285 .cmd
= NL80211_CMD_SET_INTERFACE
,
9286 .doit
= nl80211_set_interface
,
9287 .policy
= nl80211_policy
,
9288 .flags
= GENL_ADMIN_PERM
,
9289 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9290 NL80211_FLAG_NEED_RTNL
,
9293 .cmd
= NL80211_CMD_NEW_INTERFACE
,
9294 .doit
= nl80211_new_interface
,
9295 .policy
= nl80211_policy
,
9296 .flags
= GENL_ADMIN_PERM
,
9297 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9298 NL80211_FLAG_NEED_RTNL
,
9301 .cmd
= NL80211_CMD_DEL_INTERFACE
,
9302 .doit
= nl80211_del_interface
,
9303 .policy
= nl80211_policy
,
9304 .flags
= GENL_ADMIN_PERM
,
9305 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
9306 NL80211_FLAG_NEED_RTNL
,
9309 .cmd
= NL80211_CMD_GET_KEY
,
9310 .doit
= nl80211_get_key
,
9311 .policy
= nl80211_policy
,
9312 .flags
= GENL_ADMIN_PERM
,
9313 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9314 NL80211_FLAG_NEED_RTNL
,
9317 .cmd
= NL80211_CMD_SET_KEY
,
9318 .doit
= nl80211_set_key
,
9319 .policy
= nl80211_policy
,
9320 .flags
= GENL_ADMIN_PERM
,
9321 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9322 NL80211_FLAG_NEED_RTNL
,
9325 .cmd
= NL80211_CMD_NEW_KEY
,
9326 .doit
= nl80211_new_key
,
9327 .policy
= nl80211_policy
,
9328 .flags
= GENL_ADMIN_PERM
,
9329 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9330 NL80211_FLAG_NEED_RTNL
,
9333 .cmd
= NL80211_CMD_DEL_KEY
,
9334 .doit
= nl80211_del_key
,
9335 .policy
= nl80211_policy
,
9336 .flags
= GENL_ADMIN_PERM
,
9337 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9338 NL80211_FLAG_NEED_RTNL
,
9341 .cmd
= NL80211_CMD_SET_BEACON
,
9342 .policy
= nl80211_policy
,
9343 .flags
= GENL_ADMIN_PERM
,
9344 .doit
= nl80211_set_beacon
,
9345 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9346 NL80211_FLAG_NEED_RTNL
,
9349 .cmd
= NL80211_CMD_START_AP
,
9350 .policy
= nl80211_policy
,
9351 .flags
= GENL_ADMIN_PERM
,
9352 .doit
= nl80211_start_ap
,
9353 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9354 NL80211_FLAG_NEED_RTNL
,
9357 .cmd
= NL80211_CMD_STOP_AP
,
9358 .policy
= nl80211_policy
,
9359 .flags
= GENL_ADMIN_PERM
,
9360 .doit
= nl80211_stop_ap
,
9361 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9362 NL80211_FLAG_NEED_RTNL
,
9365 .cmd
= NL80211_CMD_GET_STATION
,
9366 .doit
= nl80211_get_station
,
9367 .dumpit
= nl80211_dump_station
,
9368 .policy
= nl80211_policy
,
9369 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9370 NL80211_FLAG_NEED_RTNL
,
9373 .cmd
= NL80211_CMD_SET_STATION
,
9374 .doit
= nl80211_set_station
,
9375 .policy
= nl80211_policy
,
9376 .flags
= GENL_ADMIN_PERM
,
9377 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9378 NL80211_FLAG_NEED_RTNL
,
9381 .cmd
= NL80211_CMD_NEW_STATION
,
9382 .doit
= nl80211_new_station
,
9383 .policy
= nl80211_policy
,
9384 .flags
= GENL_ADMIN_PERM
,
9385 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9386 NL80211_FLAG_NEED_RTNL
,
9389 .cmd
= NL80211_CMD_DEL_STATION
,
9390 .doit
= nl80211_del_station
,
9391 .policy
= nl80211_policy
,
9392 .flags
= GENL_ADMIN_PERM
,
9393 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9394 NL80211_FLAG_NEED_RTNL
,
9397 .cmd
= NL80211_CMD_GET_MPATH
,
9398 .doit
= nl80211_get_mpath
,
9399 .dumpit
= nl80211_dump_mpath
,
9400 .policy
= nl80211_policy
,
9401 .flags
= GENL_ADMIN_PERM
,
9402 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9403 NL80211_FLAG_NEED_RTNL
,
9406 .cmd
= NL80211_CMD_SET_MPATH
,
9407 .doit
= nl80211_set_mpath
,
9408 .policy
= nl80211_policy
,
9409 .flags
= GENL_ADMIN_PERM
,
9410 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9411 NL80211_FLAG_NEED_RTNL
,
9414 .cmd
= NL80211_CMD_NEW_MPATH
,
9415 .doit
= nl80211_new_mpath
,
9416 .policy
= nl80211_policy
,
9417 .flags
= GENL_ADMIN_PERM
,
9418 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9419 NL80211_FLAG_NEED_RTNL
,
9422 .cmd
= NL80211_CMD_DEL_MPATH
,
9423 .doit
= nl80211_del_mpath
,
9424 .policy
= nl80211_policy
,
9425 .flags
= GENL_ADMIN_PERM
,
9426 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9427 NL80211_FLAG_NEED_RTNL
,
9430 .cmd
= NL80211_CMD_SET_BSS
,
9431 .doit
= nl80211_set_bss
,
9432 .policy
= nl80211_policy
,
9433 .flags
= GENL_ADMIN_PERM
,
9434 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9435 NL80211_FLAG_NEED_RTNL
,
9438 .cmd
= NL80211_CMD_GET_REG
,
9439 .doit
= nl80211_get_reg
,
9440 .policy
= nl80211_policy
,
9441 .internal_flags
= NL80211_FLAG_NEED_RTNL
,
9442 /* can be retrieved by unprivileged users */
9445 .cmd
= NL80211_CMD_SET_REG
,
9446 .doit
= nl80211_set_reg
,
9447 .policy
= nl80211_policy
,
9448 .flags
= GENL_ADMIN_PERM
,
9449 .internal_flags
= NL80211_FLAG_NEED_RTNL
,
9452 .cmd
= NL80211_CMD_REQ_SET_REG
,
9453 .doit
= nl80211_req_set_reg
,
9454 .policy
= nl80211_policy
,
9455 .flags
= GENL_ADMIN_PERM
,
9458 .cmd
= NL80211_CMD_GET_MESH_CONFIG
,
9459 .doit
= nl80211_get_mesh_config
,
9460 .policy
= nl80211_policy
,
9461 /* can be retrieved by unprivileged users */
9462 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9463 NL80211_FLAG_NEED_RTNL
,
9466 .cmd
= NL80211_CMD_SET_MESH_CONFIG
,
9467 .doit
= nl80211_update_mesh_config
,
9468 .policy
= nl80211_policy
,
9469 .flags
= GENL_ADMIN_PERM
,
9470 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9471 NL80211_FLAG_NEED_RTNL
,
9474 .cmd
= NL80211_CMD_TRIGGER_SCAN
,
9475 .doit
= nl80211_trigger_scan
,
9476 .policy
= nl80211_policy
,
9477 .flags
= GENL_ADMIN_PERM
,
9478 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9479 NL80211_FLAG_NEED_RTNL
,
9482 .cmd
= NL80211_CMD_GET_SCAN
,
9483 .policy
= nl80211_policy
,
9484 .dumpit
= nl80211_dump_scan
,
9487 .cmd
= NL80211_CMD_START_SCHED_SCAN
,
9488 .doit
= nl80211_start_sched_scan
,
9489 .policy
= nl80211_policy
,
9490 .flags
= GENL_ADMIN_PERM
,
9491 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9492 NL80211_FLAG_NEED_RTNL
,
9495 .cmd
= NL80211_CMD_STOP_SCHED_SCAN
,
9496 .doit
= nl80211_stop_sched_scan
,
9497 .policy
= nl80211_policy
,
9498 .flags
= GENL_ADMIN_PERM
,
9499 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9500 NL80211_FLAG_NEED_RTNL
,
9503 .cmd
= NL80211_CMD_AUTHENTICATE
,
9504 .doit
= nl80211_authenticate
,
9505 .policy
= nl80211_policy
,
9506 .flags
= GENL_ADMIN_PERM
,
9507 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9508 NL80211_FLAG_NEED_RTNL
,
9511 .cmd
= NL80211_CMD_ASSOCIATE
,
9512 .doit
= nl80211_associate
,
9513 .policy
= nl80211_policy
,
9514 .flags
= GENL_ADMIN_PERM
,
9515 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9516 NL80211_FLAG_NEED_RTNL
,
9519 .cmd
= NL80211_CMD_DEAUTHENTICATE
,
9520 .doit
= nl80211_deauthenticate
,
9521 .policy
= nl80211_policy
,
9522 .flags
= GENL_ADMIN_PERM
,
9523 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9524 NL80211_FLAG_NEED_RTNL
,
9527 .cmd
= NL80211_CMD_DISASSOCIATE
,
9528 .doit
= nl80211_disassociate
,
9529 .policy
= nl80211_policy
,
9530 .flags
= GENL_ADMIN_PERM
,
9531 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9532 NL80211_FLAG_NEED_RTNL
,
9535 .cmd
= NL80211_CMD_JOIN_IBSS
,
9536 .doit
= nl80211_join_ibss
,
9537 .policy
= nl80211_policy
,
9538 .flags
= GENL_ADMIN_PERM
,
9539 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9540 NL80211_FLAG_NEED_RTNL
,
9543 .cmd
= NL80211_CMD_LEAVE_IBSS
,
9544 .doit
= nl80211_leave_ibss
,
9545 .policy
= nl80211_policy
,
9546 .flags
= GENL_ADMIN_PERM
,
9547 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9548 NL80211_FLAG_NEED_RTNL
,
9550 #ifdef CONFIG_NL80211_TESTMODE
9552 .cmd
= NL80211_CMD_TESTMODE
,
9553 .doit
= nl80211_testmode_do
,
9554 .dumpit
= nl80211_testmode_dump
,
9555 .policy
= nl80211_policy
,
9556 .flags
= GENL_ADMIN_PERM
,
9557 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9558 NL80211_FLAG_NEED_RTNL
,
9562 .cmd
= NL80211_CMD_CONNECT
,
9563 .doit
= nl80211_connect
,
9564 .policy
= nl80211_policy
,
9565 .flags
= GENL_ADMIN_PERM
,
9566 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9567 NL80211_FLAG_NEED_RTNL
,
9570 .cmd
= NL80211_CMD_DISCONNECT
,
9571 .doit
= nl80211_disconnect
,
9572 .policy
= nl80211_policy
,
9573 .flags
= GENL_ADMIN_PERM
,
9574 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9575 NL80211_FLAG_NEED_RTNL
,
9578 .cmd
= NL80211_CMD_SET_WIPHY_NETNS
,
9579 .doit
= nl80211_wiphy_netns
,
9580 .policy
= nl80211_policy
,
9581 .flags
= GENL_ADMIN_PERM
,
9582 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9583 NL80211_FLAG_NEED_RTNL
,
9586 .cmd
= NL80211_CMD_GET_SURVEY
,
9587 .policy
= nl80211_policy
,
9588 .dumpit
= nl80211_dump_survey
,
9591 .cmd
= NL80211_CMD_SET_PMKSA
,
9592 .doit
= nl80211_setdel_pmksa
,
9593 .policy
= nl80211_policy
,
9594 .flags
= GENL_ADMIN_PERM
,
9595 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9596 NL80211_FLAG_NEED_RTNL
,
9599 .cmd
= NL80211_CMD_DEL_PMKSA
,
9600 .doit
= nl80211_setdel_pmksa
,
9601 .policy
= nl80211_policy
,
9602 .flags
= GENL_ADMIN_PERM
,
9603 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9604 NL80211_FLAG_NEED_RTNL
,
9607 .cmd
= NL80211_CMD_FLUSH_PMKSA
,
9608 .doit
= nl80211_flush_pmksa
,
9609 .policy
= nl80211_policy
,
9610 .flags
= GENL_ADMIN_PERM
,
9611 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9612 NL80211_FLAG_NEED_RTNL
,
9615 .cmd
= NL80211_CMD_REMAIN_ON_CHANNEL
,
9616 .doit
= nl80211_remain_on_channel
,
9617 .policy
= nl80211_policy
,
9618 .flags
= GENL_ADMIN_PERM
,
9619 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9620 NL80211_FLAG_NEED_RTNL
,
9623 .cmd
= NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
,
9624 .doit
= nl80211_cancel_remain_on_channel
,
9625 .policy
= nl80211_policy
,
9626 .flags
= GENL_ADMIN_PERM
,
9627 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9628 NL80211_FLAG_NEED_RTNL
,
9631 .cmd
= NL80211_CMD_SET_TX_BITRATE_MASK
,
9632 .doit
= nl80211_set_tx_bitrate_mask
,
9633 .policy
= nl80211_policy
,
9634 .flags
= GENL_ADMIN_PERM
,
9635 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9636 NL80211_FLAG_NEED_RTNL
,
9639 .cmd
= NL80211_CMD_REGISTER_FRAME
,
9640 .doit
= nl80211_register_mgmt
,
9641 .policy
= nl80211_policy
,
9642 .flags
= GENL_ADMIN_PERM
,
9643 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
9644 NL80211_FLAG_NEED_RTNL
,
9647 .cmd
= NL80211_CMD_FRAME
,
9648 .doit
= nl80211_tx_mgmt
,
9649 .policy
= nl80211_policy
,
9650 .flags
= GENL_ADMIN_PERM
,
9651 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9652 NL80211_FLAG_NEED_RTNL
,
9655 .cmd
= NL80211_CMD_FRAME_WAIT_CANCEL
,
9656 .doit
= nl80211_tx_mgmt_cancel_wait
,
9657 .policy
= nl80211_policy
,
9658 .flags
= GENL_ADMIN_PERM
,
9659 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9660 NL80211_FLAG_NEED_RTNL
,
9663 .cmd
= NL80211_CMD_SET_POWER_SAVE
,
9664 .doit
= nl80211_set_power_save
,
9665 .policy
= nl80211_policy
,
9666 .flags
= GENL_ADMIN_PERM
,
9667 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9668 NL80211_FLAG_NEED_RTNL
,
9671 .cmd
= NL80211_CMD_GET_POWER_SAVE
,
9672 .doit
= nl80211_get_power_save
,
9673 .policy
= nl80211_policy
,
9674 /* can be retrieved by unprivileged users */
9675 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9676 NL80211_FLAG_NEED_RTNL
,
9679 .cmd
= NL80211_CMD_SET_CQM
,
9680 .doit
= nl80211_set_cqm
,
9681 .policy
= nl80211_policy
,
9682 .flags
= GENL_ADMIN_PERM
,
9683 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9684 NL80211_FLAG_NEED_RTNL
,
9687 .cmd
= NL80211_CMD_SET_CHANNEL
,
9688 .doit
= nl80211_set_channel
,
9689 .policy
= nl80211_policy
,
9690 .flags
= GENL_ADMIN_PERM
,
9691 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9692 NL80211_FLAG_NEED_RTNL
,
9695 .cmd
= NL80211_CMD_SET_WDS_PEER
,
9696 .doit
= nl80211_set_wds_peer
,
9697 .policy
= nl80211_policy
,
9698 .flags
= GENL_ADMIN_PERM
,
9699 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9700 NL80211_FLAG_NEED_RTNL
,
9703 .cmd
= NL80211_CMD_JOIN_MESH
,
9704 .doit
= nl80211_join_mesh
,
9705 .policy
= nl80211_policy
,
9706 .flags
= GENL_ADMIN_PERM
,
9707 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9708 NL80211_FLAG_NEED_RTNL
,
9711 .cmd
= NL80211_CMD_LEAVE_MESH
,
9712 .doit
= nl80211_leave_mesh
,
9713 .policy
= nl80211_policy
,
9714 .flags
= GENL_ADMIN_PERM
,
9715 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9716 NL80211_FLAG_NEED_RTNL
,
9720 .cmd
= NL80211_CMD_GET_WOWLAN
,
9721 .doit
= nl80211_get_wowlan
,
9722 .policy
= nl80211_policy
,
9723 /* can be retrieved by unprivileged users */
9724 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9725 NL80211_FLAG_NEED_RTNL
,
9728 .cmd
= NL80211_CMD_SET_WOWLAN
,
9729 .doit
= nl80211_set_wowlan
,
9730 .policy
= nl80211_policy
,
9731 .flags
= GENL_ADMIN_PERM
,
9732 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9733 NL80211_FLAG_NEED_RTNL
,
9737 .cmd
= NL80211_CMD_SET_REKEY_OFFLOAD
,
9738 .doit
= nl80211_set_rekey_data
,
9739 .policy
= nl80211_policy
,
9740 .flags
= GENL_ADMIN_PERM
,
9741 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9742 NL80211_FLAG_NEED_RTNL
,
9745 .cmd
= NL80211_CMD_TDLS_MGMT
,
9746 .doit
= nl80211_tdls_mgmt
,
9747 .policy
= nl80211_policy
,
9748 .flags
= GENL_ADMIN_PERM
,
9749 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9750 NL80211_FLAG_NEED_RTNL
,
9753 .cmd
= NL80211_CMD_TDLS_OPER
,
9754 .doit
= nl80211_tdls_oper
,
9755 .policy
= nl80211_policy
,
9756 .flags
= GENL_ADMIN_PERM
,
9757 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9758 NL80211_FLAG_NEED_RTNL
,
9761 .cmd
= NL80211_CMD_UNEXPECTED_FRAME
,
9762 .doit
= nl80211_register_unexpected_frame
,
9763 .policy
= nl80211_policy
,
9764 .flags
= GENL_ADMIN_PERM
,
9765 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9766 NL80211_FLAG_NEED_RTNL
,
9769 .cmd
= NL80211_CMD_PROBE_CLIENT
,
9770 .doit
= nl80211_probe_client
,
9771 .policy
= nl80211_policy
,
9772 .flags
= GENL_ADMIN_PERM
,
9773 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9774 NL80211_FLAG_NEED_RTNL
,
9777 .cmd
= NL80211_CMD_REGISTER_BEACONS
,
9778 .doit
= nl80211_register_beacons
,
9779 .policy
= nl80211_policy
,
9780 .flags
= GENL_ADMIN_PERM
,
9781 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9782 NL80211_FLAG_NEED_RTNL
,
9785 .cmd
= NL80211_CMD_SET_NOACK_MAP
,
9786 .doit
= nl80211_set_noack_map
,
9787 .policy
= nl80211_policy
,
9788 .flags
= GENL_ADMIN_PERM
,
9789 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9790 NL80211_FLAG_NEED_RTNL
,
9793 .cmd
= NL80211_CMD_START_P2P_DEVICE
,
9794 .doit
= nl80211_start_p2p_device
,
9795 .policy
= nl80211_policy
,
9796 .flags
= GENL_ADMIN_PERM
,
9797 .internal_flags
= NL80211_FLAG_NEED_WDEV
|
9798 NL80211_FLAG_NEED_RTNL
,
9801 .cmd
= NL80211_CMD_STOP_P2P_DEVICE
,
9802 .doit
= nl80211_stop_p2p_device
,
9803 .policy
= nl80211_policy
,
9804 .flags
= GENL_ADMIN_PERM
,
9805 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9806 NL80211_FLAG_NEED_RTNL
,
9809 .cmd
= NL80211_CMD_SET_MCAST_RATE
,
9810 .doit
= nl80211_set_mcast_rate
,
9811 .policy
= nl80211_policy
,
9812 .flags
= GENL_ADMIN_PERM
,
9813 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9814 NL80211_FLAG_NEED_RTNL
,
9817 .cmd
= NL80211_CMD_SET_MAC_ACL
,
9818 .doit
= nl80211_set_mac_acl
,
9819 .policy
= nl80211_policy
,
9820 .flags
= GENL_ADMIN_PERM
,
9821 .internal_flags
= NL80211_FLAG_NEED_NETDEV
|
9822 NL80211_FLAG_NEED_RTNL
,
9825 .cmd
= NL80211_CMD_RADAR_DETECT
,
9826 .doit
= nl80211_start_radar_detection
,
9827 .policy
= nl80211_policy
,
9828 .flags
= GENL_ADMIN_PERM
,
9829 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9830 NL80211_FLAG_NEED_RTNL
,
9833 .cmd
= NL80211_CMD_GET_PROTOCOL_FEATURES
,
9834 .doit
= nl80211_get_protocol_features
,
9835 .policy
= nl80211_policy
,
9838 .cmd
= NL80211_CMD_UPDATE_FT_IES
,
9839 .doit
= nl80211_update_ft_ies
,
9840 .policy
= nl80211_policy
,
9841 .flags
= GENL_ADMIN_PERM
,
9842 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9843 NL80211_FLAG_NEED_RTNL
,
9846 .cmd
= NL80211_CMD_CRIT_PROTOCOL_START
,
9847 .doit
= nl80211_crit_protocol_start
,
9848 .policy
= nl80211_policy
,
9849 .flags
= GENL_ADMIN_PERM
,
9850 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9851 NL80211_FLAG_NEED_RTNL
,
9854 .cmd
= NL80211_CMD_CRIT_PROTOCOL_STOP
,
9855 .doit
= nl80211_crit_protocol_stop
,
9856 .policy
= nl80211_policy
,
9857 .flags
= GENL_ADMIN_PERM
,
9858 .internal_flags
= NL80211_FLAG_NEED_WDEV_UP
|
9859 NL80211_FLAG_NEED_RTNL
,
9862 .cmd
= NL80211_CMD_GET_COALESCE
,
9863 .doit
= nl80211_get_coalesce
,
9864 .policy
= nl80211_policy
,
9865 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9866 NL80211_FLAG_NEED_RTNL
,
9869 .cmd
= NL80211_CMD_SET_COALESCE
,
9870 .doit
= nl80211_set_coalesce
,
9871 .policy
= nl80211_policy
,
9872 .flags
= GENL_ADMIN_PERM
,
9873 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9874 NL80211_FLAG_NEED_RTNL
,
9877 .cmd
= NL80211_CMD_CHANNEL_SWITCH
,
9878 .doit
= nl80211_channel_switch
,
9879 .policy
= nl80211_policy
,
9880 .flags
= GENL_ADMIN_PERM
,
9881 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9882 NL80211_FLAG_NEED_RTNL
,
9885 .cmd
= NL80211_CMD_VENDOR
,
9886 .doit
= nl80211_vendor_cmd
,
9887 .policy
= nl80211_policy
,
9888 .flags
= GENL_ADMIN_PERM
,
9889 .internal_flags
= NL80211_FLAG_NEED_WIPHY
|
9890 NL80211_FLAG_NEED_RTNL
,
9893 .cmd
= NL80211_CMD_SET_QOS_MAP
,
9894 .doit
= nl80211_set_qos_map
,
9895 .policy
= nl80211_policy
,
9896 .flags
= GENL_ADMIN_PERM
,
9897 .internal_flags
= NL80211_FLAG_NEED_NETDEV_UP
|
9898 NL80211_FLAG_NEED_RTNL
,
9902 /* notification functions */
9904 void nl80211_notify_dev_rename(struct cfg80211_registered_device
*rdev
)
9906 struct sk_buff
*msg
;
9907 struct nl80211_dump_wiphy_state state
= {};
9909 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
9913 if (nl80211_send_wiphy(rdev
, msg
, 0, 0, 0, &state
) < 0) {
9918 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
9919 NL80211_MCGRP_CONFIG
, GFP_KERNEL
);
9922 static int nl80211_add_scan_req(struct sk_buff
*msg
,
9923 struct cfg80211_registered_device
*rdev
)
9925 struct cfg80211_scan_request
*req
= rdev
->scan_req
;
9926 struct nlattr
*nest
;
9932 nest
= nla_nest_start(msg
, NL80211_ATTR_SCAN_SSIDS
);
9934 goto nla_put_failure
;
9935 for (i
= 0; i
< req
->n_ssids
; i
++) {
9936 if (nla_put(msg
, i
, req
->ssids
[i
].ssid_len
, req
->ssids
[i
].ssid
))
9937 goto nla_put_failure
;
9939 nla_nest_end(msg
, nest
);
9941 nest
= nla_nest_start(msg
, NL80211_ATTR_SCAN_FREQUENCIES
);
9943 goto nla_put_failure
;
9944 for (i
= 0; i
< req
->n_channels
; i
++) {
9945 if (nla_put_u32(msg
, i
, req
->channels
[i
]->center_freq
))
9946 goto nla_put_failure
;
9948 nla_nest_end(msg
, nest
);
9951 nla_put(msg
, NL80211_ATTR_IE
, req
->ie_len
, req
->ie
))
9952 goto nla_put_failure
;
9955 nla_put_u32(msg
, NL80211_ATTR_SCAN_FLAGS
, req
->flags
))
9956 goto nla_put_failure
;
9963 static int nl80211_send_scan_msg(struct sk_buff
*msg
,
9964 struct cfg80211_registered_device
*rdev
,
9965 struct wireless_dev
*wdev
,
9966 u32 portid
, u32 seq
, int flags
,
9971 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, cmd
);
9975 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
9976 (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
9977 wdev
->netdev
->ifindex
)) ||
9978 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)))
9979 goto nla_put_failure
;
9981 /* ignore errors and send incomplete event anyway */
9982 nl80211_add_scan_req(msg
, rdev
);
9984 return genlmsg_end(msg
, hdr
);
9987 genlmsg_cancel(msg
, hdr
);
9992 nl80211_send_sched_scan_msg(struct sk_buff
*msg
,
9993 struct cfg80211_registered_device
*rdev
,
9994 struct net_device
*netdev
,
9995 u32 portid
, u32 seq
, int flags
, u32 cmd
)
9999 hdr
= nl80211hdr_put(msg
, portid
, seq
, flags
, cmd
);
10003 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10004 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
10005 goto nla_put_failure
;
10007 return genlmsg_end(msg
, hdr
);
10010 genlmsg_cancel(msg
, hdr
);
10014 void nl80211_send_scan_start(struct cfg80211_registered_device
*rdev
,
10015 struct wireless_dev
*wdev
)
10017 struct sk_buff
*msg
;
10019 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10023 if (nl80211_send_scan_msg(msg
, rdev
, wdev
, 0, 0, 0,
10024 NL80211_CMD_TRIGGER_SCAN
) < 0) {
10029 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10030 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
10033 void nl80211_send_scan_done(struct cfg80211_registered_device
*rdev
,
10034 struct wireless_dev
*wdev
)
10036 struct sk_buff
*msg
;
10038 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10042 if (nl80211_send_scan_msg(msg
, rdev
, wdev
, 0, 0, 0,
10043 NL80211_CMD_NEW_SCAN_RESULTS
) < 0) {
10048 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10049 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
10052 void nl80211_send_scan_aborted(struct cfg80211_registered_device
*rdev
,
10053 struct wireless_dev
*wdev
)
10055 struct sk_buff
*msg
;
10057 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10061 if (nl80211_send_scan_msg(msg
, rdev
, wdev
, 0, 0, 0,
10062 NL80211_CMD_SCAN_ABORTED
) < 0) {
10067 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10068 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
10071 void nl80211_send_sched_scan_results(struct cfg80211_registered_device
*rdev
,
10072 struct net_device
*netdev
)
10074 struct sk_buff
*msg
;
10076 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10080 if (nl80211_send_sched_scan_msg(msg
, rdev
, netdev
, 0, 0, 0,
10081 NL80211_CMD_SCHED_SCAN_RESULTS
) < 0) {
10086 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10087 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
10090 void nl80211_send_sched_scan(struct cfg80211_registered_device
*rdev
,
10091 struct net_device
*netdev
, u32 cmd
)
10093 struct sk_buff
*msg
;
10095 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10099 if (nl80211_send_sched_scan_msg(msg
, rdev
, netdev
, 0, 0, 0, cmd
) < 0) {
10104 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10105 NL80211_MCGRP_SCAN
, GFP_KERNEL
);
10109 * This can happen on global regulatory changes or device specific settings
10110 * based on custom world regulatory domains.
10112 void nl80211_send_reg_change_event(struct regulatory_request
*request
)
10114 struct sk_buff
*msg
;
10117 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10121 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_REG_CHANGE
);
10127 /* Userspace can always count this one always being set */
10128 if (nla_put_u8(msg
, NL80211_ATTR_REG_INITIATOR
, request
->initiator
))
10129 goto nla_put_failure
;
10131 if (request
->alpha2
[0] == '0' && request
->alpha2
[1] == '0') {
10132 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
10133 NL80211_REGDOM_TYPE_WORLD
))
10134 goto nla_put_failure
;
10135 } else if (request
->alpha2
[0] == '9' && request
->alpha2
[1] == '9') {
10136 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
10137 NL80211_REGDOM_TYPE_CUSTOM_WORLD
))
10138 goto nla_put_failure
;
10139 } else if ((request
->alpha2
[0] == '9' && request
->alpha2
[1] == '8') ||
10140 request
->intersect
) {
10141 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
10142 NL80211_REGDOM_TYPE_INTERSECTION
))
10143 goto nla_put_failure
;
10145 if (nla_put_u8(msg
, NL80211_ATTR_REG_TYPE
,
10146 NL80211_REGDOM_TYPE_COUNTRY
) ||
10147 nla_put_string(msg
, NL80211_ATTR_REG_ALPHA2
,
10149 goto nla_put_failure
;
10152 if (request
->wiphy_idx
!= WIPHY_IDX_INVALID
&&
10153 nla_put_u32(msg
, NL80211_ATTR_WIPHY
, request
->wiphy_idx
))
10154 goto nla_put_failure
;
10156 genlmsg_end(msg
, hdr
);
10159 genlmsg_multicast_allns(&nl80211_fam
, msg
, 0,
10160 NL80211_MCGRP_REGULATORY
, GFP_ATOMIC
);
10166 genlmsg_cancel(msg
, hdr
);
10170 static void nl80211_send_mlme_event(struct cfg80211_registered_device
*rdev
,
10171 struct net_device
*netdev
,
10172 const u8
*buf
, size_t len
,
10173 enum nl80211_commands cmd
, gfp_t gfp
)
10175 struct sk_buff
*msg
;
10178 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10182 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
10188 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10189 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10190 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
))
10191 goto nla_put_failure
;
10193 genlmsg_end(msg
, hdr
);
10195 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10196 NL80211_MCGRP_MLME
, gfp
);
10200 genlmsg_cancel(msg
, hdr
);
10204 void nl80211_send_rx_auth(struct cfg80211_registered_device
*rdev
,
10205 struct net_device
*netdev
, const u8
*buf
,
10206 size_t len
, gfp_t gfp
)
10208 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
10209 NL80211_CMD_AUTHENTICATE
, gfp
);
10212 void nl80211_send_rx_assoc(struct cfg80211_registered_device
*rdev
,
10213 struct net_device
*netdev
, const u8
*buf
,
10214 size_t len
, gfp_t gfp
)
10216 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
10217 NL80211_CMD_ASSOCIATE
, gfp
);
10220 void nl80211_send_deauth(struct cfg80211_registered_device
*rdev
,
10221 struct net_device
*netdev
, const u8
*buf
,
10222 size_t len
, gfp_t gfp
)
10224 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
10225 NL80211_CMD_DEAUTHENTICATE
, gfp
);
10228 void nl80211_send_disassoc(struct cfg80211_registered_device
*rdev
,
10229 struct net_device
*netdev
, const u8
*buf
,
10230 size_t len
, gfp_t gfp
)
10232 nl80211_send_mlme_event(rdev
, netdev
, buf
, len
,
10233 NL80211_CMD_DISASSOCIATE
, gfp
);
10236 void cfg80211_rx_unprot_mlme_mgmt(struct net_device
*dev
, const u8
*buf
,
10239 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10240 struct wiphy
*wiphy
= wdev
->wiphy
;
10241 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10242 const struct ieee80211_mgmt
*mgmt
= (void *)buf
;
10245 if (WARN_ON(len
< 2))
10248 if (ieee80211_is_deauth(mgmt
->frame_control
))
10249 cmd
= NL80211_CMD_UNPROT_DEAUTHENTICATE
;
10251 cmd
= NL80211_CMD_UNPROT_DISASSOCIATE
;
10253 trace_cfg80211_rx_unprot_mlme_mgmt(dev
, buf
, len
);
10254 nl80211_send_mlme_event(rdev
, dev
, buf
, len
, cmd
, GFP_ATOMIC
);
10256 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt
);
10258 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device
*rdev
,
10259 struct net_device
*netdev
, int cmd
,
10260 const u8
*addr
, gfp_t gfp
)
10262 struct sk_buff
*msg
;
10265 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10269 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
10275 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10276 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10277 nla_put_flag(msg
, NL80211_ATTR_TIMED_OUT
) ||
10278 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
))
10279 goto nla_put_failure
;
10281 genlmsg_end(msg
, hdr
);
10283 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10284 NL80211_MCGRP_MLME
, gfp
);
10288 genlmsg_cancel(msg
, hdr
);
10292 void nl80211_send_auth_timeout(struct cfg80211_registered_device
*rdev
,
10293 struct net_device
*netdev
, const u8
*addr
,
10296 nl80211_send_mlme_timeout(rdev
, netdev
, NL80211_CMD_AUTHENTICATE
,
10300 void nl80211_send_assoc_timeout(struct cfg80211_registered_device
*rdev
,
10301 struct net_device
*netdev
, const u8
*addr
,
10304 nl80211_send_mlme_timeout(rdev
, netdev
, NL80211_CMD_ASSOCIATE
,
10308 void nl80211_send_connect_result(struct cfg80211_registered_device
*rdev
,
10309 struct net_device
*netdev
, const u8
*bssid
,
10310 const u8
*req_ie
, size_t req_ie_len
,
10311 const u8
*resp_ie
, size_t resp_ie_len
,
10312 u16 status
, gfp_t gfp
)
10314 struct sk_buff
*msg
;
10317 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10321 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CONNECT
);
10327 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10328 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10329 (bssid
&& nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
)) ||
10330 nla_put_u16(msg
, NL80211_ATTR_STATUS_CODE
, status
) ||
10332 nla_put(msg
, NL80211_ATTR_REQ_IE
, req_ie_len
, req_ie
)) ||
10334 nla_put(msg
, NL80211_ATTR_RESP_IE
, resp_ie_len
, resp_ie
)))
10335 goto nla_put_failure
;
10337 genlmsg_end(msg
, hdr
);
10339 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10340 NL80211_MCGRP_MLME
, gfp
);
10344 genlmsg_cancel(msg
, hdr
);
10349 void nl80211_send_roamed(struct cfg80211_registered_device
*rdev
,
10350 struct net_device
*netdev
, const u8
*bssid
,
10351 const u8
*req_ie
, size_t req_ie_len
,
10352 const u8
*resp_ie
, size_t resp_ie_len
, gfp_t gfp
)
10354 struct sk_buff
*msg
;
10357 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10361 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_ROAM
);
10367 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10368 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10369 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
) ||
10371 nla_put(msg
, NL80211_ATTR_REQ_IE
, req_ie_len
, req_ie
)) ||
10373 nla_put(msg
, NL80211_ATTR_RESP_IE
, resp_ie_len
, resp_ie
)))
10374 goto nla_put_failure
;
10376 genlmsg_end(msg
, hdr
);
10378 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10379 NL80211_MCGRP_MLME
, gfp
);
10383 genlmsg_cancel(msg
, hdr
);
10388 void nl80211_send_disconnected(struct cfg80211_registered_device
*rdev
,
10389 struct net_device
*netdev
, u16 reason
,
10390 const u8
*ie
, size_t ie_len
, bool from_ap
)
10392 struct sk_buff
*msg
;
10395 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
10399 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_DISCONNECT
);
10405 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10406 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10407 (from_ap
&& reason
&&
10408 nla_put_u16(msg
, NL80211_ATTR_REASON_CODE
, reason
)) ||
10410 nla_put_flag(msg
, NL80211_ATTR_DISCONNECTED_BY_AP
)) ||
10411 (ie
&& nla_put(msg
, NL80211_ATTR_IE
, ie_len
, ie
)))
10412 goto nla_put_failure
;
10414 genlmsg_end(msg
, hdr
);
10416 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10417 NL80211_MCGRP_MLME
, GFP_KERNEL
);
10421 genlmsg_cancel(msg
, hdr
);
10426 void nl80211_send_ibss_bssid(struct cfg80211_registered_device
*rdev
,
10427 struct net_device
*netdev
, const u8
*bssid
,
10430 struct sk_buff
*msg
;
10433 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10437 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_JOIN_IBSS
);
10443 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10444 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10445 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
10446 goto nla_put_failure
;
10448 genlmsg_end(msg
, hdr
);
10450 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10451 NL80211_MCGRP_MLME
, gfp
);
10455 genlmsg_cancel(msg
, hdr
);
10459 void cfg80211_notify_new_peer_candidate(struct net_device
*dev
, const u8
*addr
,
10460 const u8
* ie
, u8 ie_len
, gfp_t gfp
)
10462 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10463 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
10464 struct sk_buff
*msg
;
10467 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
))
10470 trace_cfg80211_notify_new_peer_candidate(dev
, addr
);
10472 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10476 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE
);
10482 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10483 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
10484 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
) ||
10486 nla_put(msg
, NL80211_ATTR_IE
, ie_len
, ie
)))
10487 goto nla_put_failure
;
10489 genlmsg_end(msg
, hdr
);
10491 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10492 NL80211_MCGRP_MLME
, gfp
);
10496 genlmsg_cancel(msg
, hdr
);
10499 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate
);
10501 void nl80211_michael_mic_failure(struct cfg80211_registered_device
*rdev
,
10502 struct net_device
*netdev
, const u8
*addr
,
10503 enum nl80211_key_type key_type
, int key_id
,
10504 const u8
*tsc
, gfp_t gfp
)
10506 struct sk_buff
*msg
;
10509 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10513 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE
);
10519 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10520 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10521 (addr
&& nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
)) ||
10522 nla_put_u32(msg
, NL80211_ATTR_KEY_TYPE
, key_type
) ||
10524 nla_put_u8(msg
, NL80211_ATTR_KEY_IDX
, key_id
)) ||
10525 (tsc
&& nla_put(msg
, NL80211_ATTR_KEY_SEQ
, 6, tsc
)))
10526 goto nla_put_failure
;
10528 genlmsg_end(msg
, hdr
);
10530 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10531 NL80211_MCGRP_MLME
, gfp
);
10535 genlmsg_cancel(msg
, hdr
);
10539 void nl80211_send_beacon_hint_event(struct wiphy
*wiphy
,
10540 struct ieee80211_channel
*channel_before
,
10541 struct ieee80211_channel
*channel_after
)
10543 struct sk_buff
*msg
;
10545 struct nlattr
*nl_freq
;
10547 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_ATOMIC
);
10551 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT
);
10558 * Since we are applying the beacon hint to a wiphy we know its
10559 * wiphy_idx is valid
10561 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, get_wiphy_idx(wiphy
)))
10562 goto nla_put_failure
;
10565 nl_freq
= nla_nest_start(msg
, NL80211_ATTR_FREQ_BEFORE
);
10567 goto nla_put_failure
;
10568 if (nl80211_msg_put_channel(msg
, channel_before
, false))
10569 goto nla_put_failure
;
10570 nla_nest_end(msg
, nl_freq
);
10573 nl_freq
= nla_nest_start(msg
, NL80211_ATTR_FREQ_AFTER
);
10575 goto nla_put_failure
;
10576 if (nl80211_msg_put_channel(msg
, channel_after
, false))
10577 goto nla_put_failure
;
10578 nla_nest_end(msg
, nl_freq
);
10580 genlmsg_end(msg
, hdr
);
10583 genlmsg_multicast_allns(&nl80211_fam
, msg
, 0,
10584 NL80211_MCGRP_REGULATORY
, GFP_ATOMIC
);
10590 genlmsg_cancel(msg
, hdr
);
10594 static void nl80211_send_remain_on_chan_event(
10595 int cmd
, struct cfg80211_registered_device
*rdev
,
10596 struct wireless_dev
*wdev
, u64 cookie
,
10597 struct ieee80211_channel
*chan
,
10598 unsigned int duration
, gfp_t gfp
)
10600 struct sk_buff
*msg
;
10603 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10607 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
10613 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10614 (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
10615 wdev
->netdev
->ifindex
)) ||
10616 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)) ||
10617 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, chan
->center_freq
) ||
10618 nla_put_u32(msg
, NL80211_ATTR_WIPHY_CHANNEL_TYPE
,
10619 NL80211_CHAN_NO_HT
) ||
10620 nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
))
10621 goto nla_put_failure
;
10623 if (cmd
== NL80211_CMD_REMAIN_ON_CHANNEL
&&
10624 nla_put_u32(msg
, NL80211_ATTR_DURATION
, duration
))
10625 goto nla_put_failure
;
10627 genlmsg_end(msg
, hdr
);
10629 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10630 NL80211_MCGRP_MLME
, gfp
);
10634 genlmsg_cancel(msg
, hdr
);
10638 void cfg80211_ready_on_channel(struct wireless_dev
*wdev
, u64 cookie
,
10639 struct ieee80211_channel
*chan
,
10640 unsigned int duration
, gfp_t gfp
)
10642 struct wiphy
*wiphy
= wdev
->wiphy
;
10643 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10645 trace_cfg80211_ready_on_channel(wdev
, cookie
, chan
, duration
);
10646 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL
,
10647 rdev
, wdev
, cookie
, chan
,
10650 EXPORT_SYMBOL(cfg80211_ready_on_channel
);
10652 void cfg80211_remain_on_channel_expired(struct wireless_dev
*wdev
, u64 cookie
,
10653 struct ieee80211_channel
*chan
,
10656 struct wiphy
*wiphy
= wdev
->wiphy
;
10657 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10659 trace_cfg80211_ready_on_channel_expired(wdev
, cookie
, chan
);
10660 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL
,
10661 rdev
, wdev
, cookie
, chan
, 0, gfp
);
10663 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired
);
10665 void cfg80211_new_sta(struct net_device
*dev
, const u8
*mac_addr
,
10666 struct station_info
*sinfo
, gfp_t gfp
)
10668 struct wiphy
*wiphy
= dev
->ieee80211_ptr
->wiphy
;
10669 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10670 struct sk_buff
*msg
;
10672 trace_cfg80211_new_sta(dev
, mac_addr
, sinfo
);
10674 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10678 if (nl80211_send_station(msg
, 0, 0, 0,
10679 rdev
, dev
, mac_addr
, sinfo
) < 0) {
10684 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10685 NL80211_MCGRP_MLME
, gfp
);
10687 EXPORT_SYMBOL(cfg80211_new_sta
);
10689 void cfg80211_del_sta(struct net_device
*dev
, const u8
*mac_addr
, gfp_t gfp
)
10691 struct wiphy
*wiphy
= dev
->ieee80211_ptr
->wiphy
;
10692 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10693 struct sk_buff
*msg
;
10696 trace_cfg80211_del_sta(dev
, mac_addr
);
10698 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10702 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_DEL_STATION
);
10708 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
10709 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
))
10710 goto nla_put_failure
;
10712 genlmsg_end(msg
, hdr
);
10714 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10715 NL80211_MCGRP_MLME
, gfp
);
10719 genlmsg_cancel(msg
, hdr
);
10722 EXPORT_SYMBOL(cfg80211_del_sta
);
10724 void cfg80211_conn_failed(struct net_device
*dev
, const u8
*mac_addr
,
10725 enum nl80211_connect_failed_reason reason
,
10728 struct wiphy
*wiphy
= dev
->ieee80211_ptr
->wiphy
;
10729 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10730 struct sk_buff
*msg
;
10733 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
10737 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CONN_FAILED
);
10743 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
10744 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, mac_addr
) ||
10745 nla_put_u32(msg
, NL80211_ATTR_CONN_FAILED_REASON
, reason
))
10746 goto nla_put_failure
;
10748 genlmsg_end(msg
, hdr
);
10750 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10751 NL80211_MCGRP_MLME
, gfp
);
10755 genlmsg_cancel(msg
, hdr
);
10758 EXPORT_SYMBOL(cfg80211_conn_failed
);
10760 static bool __nl80211_unexpected_frame(struct net_device
*dev
, u8 cmd
,
10761 const u8
*addr
, gfp_t gfp
)
10763 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10764 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
10765 struct sk_buff
*msg
;
10767 u32 nlportid
= ACCESS_ONCE(wdev
->ap_unexpected_nlportid
);
10772 msg
= nlmsg_new(100, gfp
);
10776 hdr
= nl80211hdr_put(msg
, 0, 0, 0, cmd
);
10782 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10783 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
10784 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
))
10785 goto nla_put_failure
;
10787 genlmsg_end(msg
, hdr
);
10788 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
10792 genlmsg_cancel(msg
, hdr
);
10797 bool cfg80211_rx_spurious_frame(struct net_device
*dev
,
10798 const u8
*addr
, gfp_t gfp
)
10800 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10803 trace_cfg80211_rx_spurious_frame(dev
, addr
);
10805 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_AP
&&
10806 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
)) {
10807 trace_cfg80211_return_bool(false);
10810 ret
= __nl80211_unexpected_frame(dev
, NL80211_CMD_UNEXPECTED_FRAME
,
10812 trace_cfg80211_return_bool(ret
);
10815 EXPORT_SYMBOL(cfg80211_rx_spurious_frame
);
10817 bool cfg80211_rx_unexpected_4addr_frame(struct net_device
*dev
,
10818 const u8
*addr
, gfp_t gfp
)
10820 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10823 trace_cfg80211_rx_unexpected_4addr_frame(dev
, addr
);
10825 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_AP
&&
10826 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
&&
10827 wdev
->iftype
!= NL80211_IFTYPE_AP_VLAN
)) {
10828 trace_cfg80211_return_bool(false);
10831 ret
= __nl80211_unexpected_frame(dev
,
10832 NL80211_CMD_UNEXPECTED_4ADDR_FRAME
,
10834 trace_cfg80211_return_bool(ret
);
10837 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame
);
10839 int nl80211_send_mgmt(struct cfg80211_registered_device
*rdev
,
10840 struct wireless_dev
*wdev
, u32 nlportid
,
10841 int freq
, int sig_dbm
,
10842 const u8
*buf
, size_t len
, u32 flags
, gfp_t gfp
)
10844 struct net_device
*netdev
= wdev
->netdev
;
10845 struct sk_buff
*msg
;
10848 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10852 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME
);
10858 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10859 (netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
10860 netdev
->ifindex
)) ||
10861 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)) ||
10862 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
) ||
10864 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)) ||
10865 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
) ||
10867 nla_put_u32(msg
, NL80211_ATTR_RXMGMT_FLAGS
, flags
)))
10868 goto nla_put_failure
;
10870 genlmsg_end(msg
, hdr
);
10872 return genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
10875 genlmsg_cancel(msg
, hdr
);
10880 void cfg80211_mgmt_tx_status(struct wireless_dev
*wdev
, u64 cookie
,
10881 const u8
*buf
, size_t len
, bool ack
, gfp_t gfp
)
10883 struct wiphy
*wiphy
= wdev
->wiphy
;
10884 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10885 struct net_device
*netdev
= wdev
->netdev
;
10886 struct sk_buff
*msg
;
10889 trace_cfg80211_mgmt_tx_status(wdev
, cookie
, ack
);
10891 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10895 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS
);
10901 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10902 (netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
10903 netdev
->ifindex
)) ||
10904 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)) ||
10905 nla_put(msg
, NL80211_ATTR_FRAME
, len
, buf
) ||
10906 nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
) ||
10907 (ack
&& nla_put_flag(msg
, NL80211_ATTR_ACK
)))
10908 goto nla_put_failure
;
10910 genlmsg_end(msg
, hdr
);
10912 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10913 NL80211_MCGRP_MLME
, gfp
);
10917 genlmsg_cancel(msg
, hdr
);
10920 EXPORT_SYMBOL(cfg80211_mgmt_tx_status
);
10922 void cfg80211_cqm_rssi_notify(struct net_device
*dev
,
10923 enum nl80211_cqm_rssi_threshold_event rssi_event
,
10926 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
10927 struct wiphy
*wiphy
= wdev
->wiphy
;
10928 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
10929 struct sk_buff
*msg
;
10930 struct nlattr
*pinfoattr
;
10933 trace_cfg80211_cqm_rssi_notify(dev
, rssi_event
);
10935 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10939 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NOTIFY_CQM
);
10945 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10946 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
))
10947 goto nla_put_failure
;
10949 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_CQM
);
10951 goto nla_put_failure
;
10953 if (nla_put_u32(msg
, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT
,
10955 goto nla_put_failure
;
10957 nla_nest_end(msg
, pinfoattr
);
10959 genlmsg_end(msg
, hdr
);
10961 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
10962 NL80211_MCGRP_MLME
, gfp
);
10966 genlmsg_cancel(msg
, hdr
);
10969 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify
);
10971 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device
*rdev
,
10972 struct net_device
*netdev
, const u8
*bssid
,
10973 const u8
*replay_ctr
, gfp_t gfp
)
10975 struct sk_buff
*msg
;
10976 struct nlattr
*rekey_attr
;
10979 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
10983 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD
);
10989 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
10990 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
10991 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, bssid
))
10992 goto nla_put_failure
;
10994 rekey_attr
= nla_nest_start(msg
, NL80211_ATTR_REKEY_DATA
);
10996 goto nla_put_failure
;
10998 if (nla_put(msg
, NL80211_REKEY_DATA_REPLAY_CTR
,
10999 NL80211_REPLAY_CTR_LEN
, replay_ctr
))
11000 goto nla_put_failure
;
11002 nla_nest_end(msg
, rekey_attr
);
11004 genlmsg_end(msg
, hdr
);
11006 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11007 NL80211_MCGRP_MLME
, gfp
);
11011 genlmsg_cancel(msg
, hdr
);
11015 void cfg80211_gtk_rekey_notify(struct net_device
*dev
, const u8
*bssid
,
11016 const u8
*replay_ctr
, gfp_t gfp
)
11018 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11019 struct wiphy
*wiphy
= wdev
->wiphy
;
11020 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11022 trace_cfg80211_gtk_rekey_notify(dev
, bssid
);
11023 nl80211_gtk_rekey_notify(rdev
, dev
, bssid
, replay_ctr
, gfp
);
11025 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify
);
11028 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device
*rdev
,
11029 struct net_device
*netdev
, int index
,
11030 const u8
*bssid
, bool preauth
, gfp_t gfp
)
11032 struct sk_buff
*msg
;
11033 struct nlattr
*attr
;
11036 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11040 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE
);
11046 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11047 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
11048 goto nla_put_failure
;
11050 attr
= nla_nest_start(msg
, NL80211_ATTR_PMKSA_CANDIDATE
);
11052 goto nla_put_failure
;
11054 if (nla_put_u32(msg
, NL80211_PMKSA_CANDIDATE_INDEX
, index
) ||
11055 nla_put(msg
, NL80211_PMKSA_CANDIDATE_BSSID
, ETH_ALEN
, bssid
) ||
11057 nla_put_flag(msg
, NL80211_PMKSA_CANDIDATE_PREAUTH
)))
11058 goto nla_put_failure
;
11060 nla_nest_end(msg
, attr
);
11062 genlmsg_end(msg
, hdr
);
11064 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11065 NL80211_MCGRP_MLME
, gfp
);
11069 genlmsg_cancel(msg
, hdr
);
11073 void cfg80211_pmksa_candidate_notify(struct net_device
*dev
, int index
,
11074 const u8
*bssid
, bool preauth
, gfp_t gfp
)
11076 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11077 struct wiphy
*wiphy
= wdev
->wiphy
;
11078 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11080 trace_cfg80211_pmksa_candidate_notify(dev
, index
, bssid
, preauth
);
11081 nl80211_pmksa_candidate_notify(rdev
, dev
, index
, bssid
, preauth
, gfp
);
11083 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify
);
11085 static void nl80211_ch_switch_notify(struct cfg80211_registered_device
*rdev
,
11086 struct net_device
*netdev
,
11087 struct cfg80211_chan_def
*chandef
,
11090 struct sk_buff
*msg
;
11093 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11097 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY
);
11103 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
))
11104 goto nla_put_failure
;
11106 if (nl80211_send_chandef(msg
, chandef
))
11107 goto nla_put_failure
;
11109 genlmsg_end(msg
, hdr
);
11111 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11112 NL80211_MCGRP_MLME
, gfp
);
11116 genlmsg_cancel(msg
, hdr
);
11120 void cfg80211_ch_switch_notify(struct net_device
*dev
,
11121 struct cfg80211_chan_def
*chandef
)
11123 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11124 struct wiphy
*wiphy
= wdev
->wiphy
;
11125 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11127 ASSERT_WDEV_LOCK(wdev
);
11129 trace_cfg80211_ch_switch_notify(dev
, chandef
);
11131 if (WARN_ON(wdev
->iftype
!= NL80211_IFTYPE_AP
&&
11132 wdev
->iftype
!= NL80211_IFTYPE_P2P_GO
&&
11133 wdev
->iftype
!= NL80211_IFTYPE_ADHOC
&&
11134 wdev
->iftype
!= NL80211_IFTYPE_MESH_POINT
))
11137 wdev
->channel
= chandef
->chan
;
11138 nl80211_ch_switch_notify(rdev
, dev
, chandef
, GFP_KERNEL
);
11140 EXPORT_SYMBOL(cfg80211_ch_switch_notify
);
11142 void cfg80211_cqm_txe_notify(struct net_device
*dev
,
11143 const u8
*peer
, u32 num_packets
,
11144 u32 rate
, u32 intvl
, gfp_t gfp
)
11146 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11147 struct wiphy
*wiphy
= wdev
->wiphy
;
11148 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11149 struct sk_buff
*msg
;
11150 struct nlattr
*pinfoattr
;
11153 msg
= nlmsg_new(NLMSG_GOODSIZE
, gfp
);
11157 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NOTIFY_CQM
);
11163 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11164 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
11165 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, peer
))
11166 goto nla_put_failure
;
11168 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_CQM
);
11170 goto nla_put_failure
;
11172 if (nla_put_u32(msg
, NL80211_ATTR_CQM_TXE_PKTS
, num_packets
))
11173 goto nla_put_failure
;
11175 if (nla_put_u32(msg
, NL80211_ATTR_CQM_TXE_RATE
, rate
))
11176 goto nla_put_failure
;
11178 if (nla_put_u32(msg
, NL80211_ATTR_CQM_TXE_INTVL
, intvl
))
11179 goto nla_put_failure
;
11181 nla_nest_end(msg
, pinfoattr
);
11183 genlmsg_end(msg
, hdr
);
11185 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11186 NL80211_MCGRP_MLME
, gfp
);
11190 genlmsg_cancel(msg
, hdr
);
11193 EXPORT_SYMBOL(cfg80211_cqm_txe_notify
);
11196 nl80211_radar_notify(struct cfg80211_registered_device
*rdev
,
11197 const struct cfg80211_chan_def
*chandef
,
11198 enum nl80211_radar_event event
,
11199 struct net_device
*netdev
, gfp_t gfp
)
11201 struct sk_buff
*msg
;
11204 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11208 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_RADAR_DETECT
);
11214 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
))
11215 goto nla_put_failure
;
11217 /* NOP and radar events don't need a netdev parameter */
11219 struct wireless_dev
*wdev
= netdev
->ieee80211_ptr
;
11221 if (nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
11222 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)))
11223 goto nla_put_failure
;
11226 if (nla_put_u32(msg
, NL80211_ATTR_RADAR_EVENT
, event
))
11227 goto nla_put_failure
;
11229 if (nl80211_send_chandef(msg
, chandef
))
11230 goto nla_put_failure
;
11232 genlmsg_end(msg
, hdr
);
11234 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11235 NL80211_MCGRP_MLME
, gfp
);
11239 genlmsg_cancel(msg
, hdr
);
11243 void cfg80211_cqm_pktloss_notify(struct net_device
*dev
,
11244 const u8
*peer
, u32 num_packets
, gfp_t gfp
)
11246 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11247 struct wiphy
*wiphy
= wdev
->wiphy
;
11248 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11249 struct sk_buff
*msg
;
11250 struct nlattr
*pinfoattr
;
11253 trace_cfg80211_cqm_pktloss_notify(dev
, peer
, num_packets
);
11255 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11259 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_NOTIFY_CQM
);
11265 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11266 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
11267 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, peer
))
11268 goto nla_put_failure
;
11270 pinfoattr
= nla_nest_start(msg
, NL80211_ATTR_CQM
);
11272 goto nla_put_failure
;
11274 if (nla_put_u32(msg
, NL80211_ATTR_CQM_PKT_LOSS_EVENT
, num_packets
))
11275 goto nla_put_failure
;
11277 nla_nest_end(msg
, pinfoattr
);
11279 genlmsg_end(msg
, hdr
);
11281 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11282 NL80211_MCGRP_MLME
, gfp
);
11286 genlmsg_cancel(msg
, hdr
);
11289 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify
);
11291 void cfg80211_probe_status(struct net_device
*dev
, const u8
*addr
,
11292 u64 cookie
, bool acked
, gfp_t gfp
)
11294 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11295 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
11296 struct sk_buff
*msg
;
11299 trace_cfg80211_probe_status(dev
, addr
, cookie
, acked
);
11301 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11306 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_PROBE_CLIENT
);
11312 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11313 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
11314 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, addr
) ||
11315 nla_put_u64(msg
, NL80211_ATTR_COOKIE
, cookie
) ||
11316 (acked
&& nla_put_flag(msg
, NL80211_ATTR_ACK
)))
11317 goto nla_put_failure
;
11319 genlmsg_end(msg
, hdr
);
11321 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11322 NL80211_MCGRP_MLME
, gfp
);
11326 genlmsg_cancel(msg
, hdr
);
11329 EXPORT_SYMBOL(cfg80211_probe_status
);
11331 void cfg80211_report_obss_beacon(struct wiphy
*wiphy
,
11332 const u8
*frame
, size_t len
,
11333 int freq
, int sig_dbm
)
11335 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11336 struct sk_buff
*msg
;
11338 struct cfg80211_beacon_registration
*reg
;
11340 trace_cfg80211_report_obss_beacon(wiphy
, frame
, len
, freq
, sig_dbm
);
11342 spin_lock_bh(&rdev
->beacon_registrations_lock
);
11343 list_for_each_entry(reg
, &rdev
->beacon_registrations
, list
) {
11344 msg
= nlmsg_new(len
+ 100, GFP_ATOMIC
);
11346 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
11350 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FRAME
);
11352 goto nla_put_failure
;
11354 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11356 nla_put_u32(msg
, NL80211_ATTR_WIPHY_FREQ
, freq
)) ||
11358 nla_put_u32(msg
, NL80211_ATTR_RX_SIGNAL_DBM
, sig_dbm
)) ||
11359 nla_put(msg
, NL80211_ATTR_FRAME
, len
, frame
))
11360 goto nla_put_failure
;
11362 genlmsg_end(msg
, hdr
);
11364 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, reg
->nlportid
);
11366 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
11370 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
11372 genlmsg_cancel(msg
, hdr
);
11375 EXPORT_SYMBOL(cfg80211_report_obss_beacon
);
11378 void cfg80211_report_wowlan_wakeup(struct wireless_dev
*wdev
,
11379 struct cfg80211_wowlan_wakeup
*wakeup
,
11382 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
11383 struct sk_buff
*msg
;
11387 trace_cfg80211_report_wowlan_wakeup(wdev
->wiphy
, wdev
, wakeup
);
11390 size
+= wakeup
->packet_present_len
;
11392 msg
= nlmsg_new(size
, gfp
);
11396 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_SET_WOWLAN
);
11400 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11401 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)))
11404 if (wdev
->netdev
&& nla_put_u32(msg
, NL80211_ATTR_IFINDEX
,
11405 wdev
->netdev
->ifindex
))
11409 struct nlattr
*reasons
;
11411 reasons
= nla_nest_start(msg
, NL80211_ATTR_WOWLAN_TRIGGERS
);
11415 if (wakeup
->disconnect
&&
11416 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_DISCONNECT
))
11418 if (wakeup
->magic_pkt
&&
11419 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_MAGIC_PKT
))
11421 if (wakeup
->gtk_rekey_failure
&&
11422 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE
))
11424 if (wakeup
->eap_identity_req
&&
11425 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST
))
11427 if (wakeup
->four_way_handshake
&&
11428 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE
))
11430 if (wakeup
->rfkill_release
&&
11431 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_RFKILL_RELEASE
))
11434 if (wakeup
->pattern_idx
>= 0 &&
11435 nla_put_u32(msg
, NL80211_WOWLAN_TRIG_PKT_PATTERN
,
11436 wakeup
->pattern_idx
))
11439 if (wakeup
->tcp_match
&&
11440 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH
))
11443 if (wakeup
->tcp_connlost
&&
11444 nla_put_flag(msg
, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST
))
11447 if (wakeup
->tcp_nomoretokens
&&
11449 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS
))
11452 if (wakeup
->packet
) {
11453 u32 pkt_attr
= NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211
;
11454 u32 len_attr
= NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN
;
11456 if (!wakeup
->packet_80211
) {
11458 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023
;
11460 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN
;
11463 if (wakeup
->packet_len
&&
11464 nla_put_u32(msg
, len_attr
, wakeup
->packet_len
))
11467 if (nla_put(msg
, pkt_attr
, wakeup
->packet_present_len
,
11472 nla_nest_end(msg
, reasons
);
11475 genlmsg_end(msg
, hdr
);
11477 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11478 NL80211_MCGRP_MLME
, gfp
);
11484 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup
);
11487 void cfg80211_tdls_oper_request(struct net_device
*dev
, const u8
*peer
,
11488 enum nl80211_tdls_operation oper
,
11489 u16 reason_code
, gfp_t gfp
)
11491 struct wireless_dev
*wdev
= dev
->ieee80211_ptr
;
11492 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wdev
->wiphy
);
11493 struct sk_buff
*msg
;
11496 trace_cfg80211_tdls_oper_request(wdev
->wiphy
, dev
, peer
, oper
,
11499 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11503 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_TDLS_OPER
);
11509 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11510 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, dev
->ifindex
) ||
11511 nla_put_u8(msg
, NL80211_ATTR_TDLS_OPERATION
, oper
) ||
11512 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, peer
) ||
11513 (reason_code
> 0 &&
11514 nla_put_u16(msg
, NL80211_ATTR_REASON_CODE
, reason_code
)))
11515 goto nla_put_failure
;
11517 genlmsg_end(msg
, hdr
);
11519 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11520 NL80211_MCGRP_MLME
, gfp
);
11524 genlmsg_cancel(msg
, hdr
);
11527 EXPORT_SYMBOL(cfg80211_tdls_oper_request
);
11529 static int nl80211_netlink_notify(struct notifier_block
* nb
,
11530 unsigned long state
,
11533 struct netlink_notify
*notify
= _notify
;
11534 struct cfg80211_registered_device
*rdev
;
11535 struct wireless_dev
*wdev
;
11536 struct cfg80211_beacon_registration
*reg
, *tmp
;
11538 if (state
!= NETLINK_URELEASE
)
11539 return NOTIFY_DONE
;
11543 list_for_each_entry_rcu(rdev
, &cfg80211_rdev_list
, list
) {
11544 list_for_each_entry_rcu(wdev
, &rdev
->wdev_list
, list
)
11545 cfg80211_mlme_unregister_socket(wdev
, notify
->portid
);
11547 spin_lock_bh(&rdev
->beacon_registrations_lock
);
11548 list_for_each_entry_safe(reg
, tmp
, &rdev
->beacon_registrations
,
11550 if (reg
->nlportid
== notify
->portid
) {
11551 list_del(®
->list
);
11556 spin_unlock_bh(&rdev
->beacon_registrations_lock
);
11561 return NOTIFY_DONE
;
11564 static struct notifier_block nl80211_netlink_notifier
= {
11565 .notifier_call
= nl80211_netlink_notify
,
11568 void cfg80211_ft_event(struct net_device
*netdev
,
11569 struct cfg80211_ft_event_params
*ft_event
)
11571 struct wiphy
*wiphy
= netdev
->ieee80211_ptr
->wiphy
;
11572 struct cfg80211_registered_device
*rdev
= wiphy_to_dev(wiphy
);
11573 struct sk_buff
*msg
;
11576 trace_cfg80211_ft_event(wiphy
, netdev
, ft_event
);
11578 if (!ft_event
->target_ap
)
11581 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, GFP_KERNEL
);
11585 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_FT_EVENT
);
11589 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11590 nla_put_u32(msg
, NL80211_ATTR_IFINDEX
, netdev
->ifindex
) ||
11591 nla_put(msg
, NL80211_ATTR_MAC
, ETH_ALEN
, ft_event
->target_ap
))
11594 if (ft_event
->ies
&&
11595 nla_put(msg
, NL80211_ATTR_IE
, ft_event
->ies_len
, ft_event
->ies
))
11597 if (ft_event
->ric_ies
&&
11598 nla_put(msg
, NL80211_ATTR_IE_RIC
, ft_event
->ric_ies_len
,
11599 ft_event
->ric_ies
))
11602 genlmsg_end(msg
, hdr
);
11604 genlmsg_multicast_netns(&nl80211_fam
, wiphy_net(&rdev
->wiphy
), msg
, 0,
11605 NL80211_MCGRP_MLME
, GFP_KERNEL
);
11610 EXPORT_SYMBOL(cfg80211_ft_event
);
11612 void cfg80211_crit_proto_stopped(struct wireless_dev
*wdev
, gfp_t gfp
)
11614 struct cfg80211_registered_device
*rdev
;
11615 struct sk_buff
*msg
;
11619 rdev
= wiphy_to_dev(wdev
->wiphy
);
11620 if (!rdev
->crit_proto_nlportid
)
11623 nlportid
= rdev
->crit_proto_nlportid
;
11624 rdev
->crit_proto_nlportid
= 0;
11626 msg
= nlmsg_new(NLMSG_DEFAULT_SIZE
, gfp
);
11630 hdr
= nl80211hdr_put(msg
, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP
);
11632 goto nla_put_failure
;
11634 if (nla_put_u32(msg
, NL80211_ATTR_WIPHY
, rdev
->wiphy_idx
) ||
11635 nla_put_u64(msg
, NL80211_ATTR_WDEV
, wdev_id(wdev
)))
11636 goto nla_put_failure
;
11638 genlmsg_end(msg
, hdr
);
11640 genlmsg_unicast(wiphy_net(&rdev
->wiphy
), msg
, nlportid
);
11645 genlmsg_cancel(msg
, hdr
);
11649 EXPORT_SYMBOL(cfg80211_crit_proto_stopped
);
11651 /* initialisation/exit functions */
11653 int nl80211_init(void)
11657 err
= genl_register_family_with_ops_groups(&nl80211_fam
, nl80211_ops
,
11662 err
= netlink_register_notifier(&nl80211_netlink_notifier
);
11668 genl_unregister_family(&nl80211_fam
);
11672 void nl80211_exit(void)
11674 netlink_unregister_notifier(&nl80211_netlink_notifier
);
11675 genl_unregister_family(&nl80211_fam
);