projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
cfg80211: avoid using default in interface type switch
[deliverable/linux.git] / net / wireless / nl80211.c
1 /*
2 * This is the new netlink-based wireless configuration interface.
3 *
4 * Copyright 2006-2010 Johannes Berg <johannes@sipsolutions.net>
5 * Copyright 2013-2014 Intel Mobile Communications GmbH
6 */
7
8 #include <linux/if.h>
9 #include <linux/module.h>
10 #include <linux/err.h>
11 #include <linux/slab.h>
12 #include <linux/list.h>
13 #include <linux/if_ether.h>
14 #include <linux/ieee80211.h>
15 #include <linux/nl80211.h>
16 #include <linux/rtnetlink.h>
17 #include <linux/netlink.h>
18 #include <linux/etherdevice.h>
19 #include <net/net_namespace.h>
20 #include <net/genetlink.h>
21 #include <net/cfg80211.h>
22 #include <net/sock.h>
23 #include <net/inet_connection_sock.h>
24 #include "core.h"
25 #include "nl80211.h"
26 #include "reg.h"
27 #include "rdev-ops.h"
28
29 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
30 struct genl_info *info,
31 struct cfg80211_crypto_settings *settings,
32 int cipher_limit);
33
34 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
35 struct genl_info *info);
36 static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
37 struct genl_info *info);
38
39 /* the netlink family */
40 static struct genl_family nl80211_fam = {
41 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
42 .name = NL80211_GENL_NAME, /* have users key off the name instead */
43 .hdrsize = 0, /* no private header */
44 .version = 1, /* no particular meaning now */
45 .maxattr = NL80211_ATTR_MAX,
46 .netnsok = true,
47 .pre_doit = nl80211_pre_doit,
48 .post_doit = nl80211_post_doit,
49 };
50
51 /* multicast groups */
52 enum nl80211_multicast_groups {
53 NL80211_MCGRP_CONFIG,
54 NL80211_MCGRP_SCAN,
55 NL80211_MCGRP_REGULATORY,
56 NL80211_MCGRP_MLME,
57 NL80211_MCGRP_VENDOR,
58 NL80211_MCGRP_TESTMODE /* keep last - ifdef! */
59 };
60
61 static const struct genl_multicast_group nl80211_mcgrps[] = {
62 [NL80211_MCGRP_CONFIG] = { .name = "config", },
63 [NL80211_MCGRP_SCAN] = { .name = "scan", },
64 [NL80211_MCGRP_REGULATORY] = { .name = "regulatory", },
65 [NL80211_MCGRP_MLME] = { .name = "mlme", },
66 [NL80211_MCGRP_VENDOR] = { .name = "vendor", },
67 #ifdef CONFIG_NL80211_TESTMODE
68 [NL80211_MCGRP_TESTMODE] = { .name = "testmode", }
69 #endif
70 };
71
72 /* returns ERR_PTR values */
73 static struct wireless_dev *
74 __cfg80211_wdev_from_attrs(struct net *netns, struct nlattr **attrs)
75 {
76 struct cfg80211_registered_device *rdev;
77 struct wireless_dev *result = NULL;
78 bool have_ifidx = attrs[NL80211_ATTR_IFINDEX];
79 bool have_wdev_id = attrs[NL80211_ATTR_WDEV];
80 u64 wdev_id;
81 int wiphy_idx = -1;
82 int ifidx = -1;
83
84 ASSERT_RTNL();
85
86 if (!have_ifidx && !have_wdev_id)
87 return ERR_PTR(-EINVAL);
88
89 if (have_ifidx)
90 ifidx = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
91 if (have_wdev_id) {
92 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
93 wiphy_idx = wdev_id >> 32;
94 }
95
96 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
97 struct wireless_dev *wdev;
98
99 if (wiphy_net(&rdev->wiphy) != netns)
100 continue;
101
102 if (have_wdev_id && rdev->wiphy_idx != wiphy_idx)
103 continue;
104
105 list_for_each_entry(wdev, &rdev->wdev_list, list) {
106 if (have_ifidx && wdev->netdev &&
107 wdev->netdev->ifindex == ifidx) {
108 result = wdev;
109 break;
110 }
111 if (have_wdev_id && wdev->identifier == (u32)wdev_id) {
112 result = wdev;
113 break;
114 }
115 }
116
117 if (result)
118 break;
119 }
120
121 if (result)
122 return result;
123 return ERR_PTR(-ENODEV);
124 }
125
126 static struct cfg80211_registered_device *
127 __cfg80211_rdev_from_attrs(struct net *netns, struct nlattr **attrs)
128 {
129 struct cfg80211_registered_device *rdev = NULL, *tmp;
130 struct net_device *netdev;
131
132 ASSERT_RTNL();
133
134 if (!attrs[NL80211_ATTR_WIPHY] &&
135 !attrs[NL80211_ATTR_IFINDEX] &&
136 !attrs[NL80211_ATTR_WDEV])
137 return ERR_PTR(-EINVAL);
138
139 if (attrs[NL80211_ATTR_WIPHY])
140 rdev = cfg80211_rdev_by_wiphy_idx(
141 nla_get_u32(attrs[NL80211_ATTR_WIPHY]));
142
143 if (attrs[NL80211_ATTR_WDEV]) {
144 u64 wdev_id = nla_get_u64(attrs[NL80211_ATTR_WDEV]);
145 struct wireless_dev *wdev;
146 bool found = false;
147
148 tmp = cfg80211_rdev_by_wiphy_idx(wdev_id >> 32);
149 if (tmp) {
150 /* make sure wdev exists */
151 list_for_each_entry(wdev, &tmp->wdev_list, list) {
152 if (wdev->identifier != (u32)wdev_id)
153 continue;
154 found = true;
155 break;
156 }
157
158 if (!found)
159 tmp = NULL;
160
161 if (rdev && tmp != rdev)
162 return ERR_PTR(-EINVAL);
163 rdev = tmp;
164 }
165 }
166
167 if (attrs[NL80211_ATTR_IFINDEX]) {
168 int ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
169 netdev = __dev_get_by_index(netns, ifindex);
170 if (netdev) {
171 if (netdev->ieee80211_ptr)
172 tmp = wiphy_to_rdev(
173 netdev->ieee80211_ptr->wiphy);
174 else
175 tmp = NULL;
176
177 /* not wireless device -- return error */
178 if (!tmp)
179 return ERR_PTR(-EINVAL);
180
181 /* mismatch -- return error */
182 if (rdev && tmp != rdev)
183 return ERR_PTR(-EINVAL);
184
185 rdev = tmp;
186 }
187 }
188
189 if (!rdev)
190 return ERR_PTR(-ENODEV);
191
192 if (netns != wiphy_net(&rdev->wiphy))
193 return ERR_PTR(-ENODEV);
194
195 return rdev;
196 }
197
198 /*
199 * This function returns a pointer to the driver
200 * that the genl_info item that is passed refers to.
201 *
202 * The result of this can be a PTR_ERR and hence must
203 * be checked with IS_ERR() for errors.
204 */
205 static struct cfg80211_registered_device *
206 cfg80211_get_dev_from_info(struct net *netns, struct genl_info *info)
207 {
208 return __cfg80211_rdev_from_attrs(netns, info->attrs);
209 }
210
211 /* policy for the attributes */
212 static const struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] = {
213 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
214 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
215 .len = 20-1 },
216 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
217
218 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
219 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
220 [NL80211_ATTR_CHANNEL_WIDTH] = { .type = NLA_U32 },
221 [NL80211_ATTR_CENTER_FREQ1] = { .type = NLA_U32 },
222 [NL80211_ATTR_CENTER_FREQ2] = { .type = NLA_U32 },
223
224 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
225 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
226 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
227 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
228 [NL80211_ATTR_WIPHY_COVERAGE_CLASS] = { .type = NLA_U8 },
229 [NL80211_ATTR_WIPHY_DYN_ACK] = { .type = NLA_FLAG },
230
231 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
232 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
233 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
234
235 [NL80211_ATTR_MAC] = { .len = ETH_ALEN },
236 [NL80211_ATTR_PREV_BSSID] = { .len = ETH_ALEN },
237
238 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
239 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
240 .len = WLAN_MAX_KEY_LEN },
241 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
242 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
243 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
244 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
245 [NL80211_ATTR_KEY_TYPE] = { .type = NLA_U32 },
246
247 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
248 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
249 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
250 .len = IEEE80211_MAX_DATA_LEN },
251 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
252 .len = IEEE80211_MAX_DATA_LEN },
253 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
254 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
255 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
256 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
257 .len = NL80211_MAX_SUPP_RATES },
258 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
259 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
260 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
261 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
262 .len = IEEE80211_MAX_MESH_ID_LEN },
263 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
264
265 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
266 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
267
268 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
269 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
270 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
271 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
272 .len = NL80211_MAX_SUPP_RATES },
273 [NL80211_ATTR_BSS_HT_OPMODE] = { .type = NLA_U16 },
274
275 [NL80211_ATTR_MESH_CONFIG] = { .type = NLA_NESTED },
276 [NL80211_ATTR_SUPPORT_MESH_AUTH] = { .type = NLA_FLAG },
277
278 [NL80211_ATTR_HT_CAPABILITY] = { .len = NL80211_HT_CAPABILITY_LEN },
279
280 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
281 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
282 .len = IEEE80211_MAX_DATA_LEN },
283 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
284 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
285
286 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
287 .len = IEEE80211_MAX_SSID_LEN },
288 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
289 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
290 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
291 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
292 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
293 [NL80211_ATTR_STA_FLAGS2] = {
294 .len = sizeof(struct nl80211_sta_flag_update),
295 },
296 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
297 [NL80211_ATTR_CONTROL_PORT_ETHERTYPE] = { .type = NLA_U16 },
298 [NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT] = { .type = NLA_FLAG },
299 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
300 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
301 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
302 [NL80211_ATTR_PID] = { .type = NLA_U32 },
303 [NL80211_ATTR_4ADDR] = { .type = NLA_U8 },
304 [NL80211_ATTR_PMKID] = { .type = NLA_BINARY,
305 .len = WLAN_PMKID_LEN },
306 [NL80211_ATTR_DURATION] = { .type = NLA_U32 },
307 [NL80211_ATTR_COOKIE] = { .type = NLA_U64 },
308 [NL80211_ATTR_TX_RATES] = { .type = NLA_NESTED },
309 [NL80211_ATTR_FRAME] = { .type = NLA_BINARY,
310 .len = IEEE80211_MAX_DATA_LEN },
311 [NL80211_ATTR_FRAME_MATCH] = { .type = NLA_BINARY, },
312 [NL80211_ATTR_PS_STATE] = { .type = NLA_U32 },
313 [NL80211_ATTR_CQM] = { .type = NLA_NESTED, },
314 [NL80211_ATTR_LOCAL_STATE_CHANGE] = { .type = NLA_FLAG },
315 [NL80211_ATTR_AP_ISOLATE] = { .type = NLA_U8 },
316 [NL80211_ATTR_WIPHY_TX_POWER_SETTING] = { .type = NLA_U32 },
317 [NL80211_ATTR_WIPHY_TX_POWER_LEVEL] = { .type = NLA_U32 },
318 [NL80211_ATTR_FRAME_TYPE] = { .type = NLA_U16 },
319 [NL80211_ATTR_WIPHY_ANTENNA_TX] = { .type = NLA_U32 },
320 [NL80211_ATTR_WIPHY_ANTENNA_RX] = { .type = NLA_U32 },
321 [NL80211_ATTR_MCAST_RATE] = { .type = NLA_U32 },
322 [NL80211_ATTR_OFFCHANNEL_TX_OK] = { .type = NLA_FLAG },
323 [NL80211_ATTR_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
324 [NL80211_ATTR_WOWLAN_TRIGGERS] = { .type = NLA_NESTED },
325 [NL80211_ATTR_STA_PLINK_STATE] = { .type = NLA_U8 },
326 [NL80211_ATTR_SCHED_SCAN_INTERVAL] = { .type = NLA_U32 },
327 [NL80211_ATTR_REKEY_DATA] = { .type = NLA_NESTED },
328 [NL80211_ATTR_SCAN_SUPP_RATES] = { .type = NLA_NESTED },
329 [NL80211_ATTR_HIDDEN_SSID] = { .type = NLA_U32 },
330 [NL80211_ATTR_IE_PROBE_RESP] = { .type = NLA_BINARY,
331 .len = IEEE80211_MAX_DATA_LEN },
332 [NL80211_ATTR_IE_ASSOC_RESP] = { .type = NLA_BINARY,
333 .len = IEEE80211_MAX_DATA_LEN },
334 [NL80211_ATTR_ROAM_SUPPORT] = { .type = NLA_FLAG },
335 [NL80211_ATTR_SCHED_SCAN_MATCH] = { .type = NLA_NESTED },
336 [NL80211_ATTR_TX_NO_CCK_RATE] = { .type = NLA_FLAG },
337 [NL80211_ATTR_TDLS_ACTION] = { .type = NLA_U8 },
338 [NL80211_ATTR_TDLS_DIALOG_TOKEN] = { .type = NLA_U8 },
339 [NL80211_ATTR_TDLS_OPERATION] = { .type = NLA_U8 },
340 [NL80211_ATTR_TDLS_SUPPORT] = { .type = NLA_FLAG },
341 [NL80211_ATTR_TDLS_EXTERNAL_SETUP] = { .type = NLA_FLAG },
342 [NL80211_ATTR_TDLS_INITIATOR] = { .type = NLA_FLAG },
343 [NL80211_ATTR_DONT_WAIT_FOR_ACK] = { .type = NLA_FLAG },
344 [NL80211_ATTR_PROBE_RESP] = { .type = NLA_BINARY,
345 .len = IEEE80211_MAX_DATA_LEN },
346 [NL80211_ATTR_DFS_REGION] = { .type = NLA_U8 },
347 [NL80211_ATTR_DISABLE_HT] = { .type = NLA_FLAG },
348 [NL80211_ATTR_HT_CAPABILITY_MASK] = {
349 .len = NL80211_HT_CAPABILITY_LEN
350 },
351 [NL80211_ATTR_NOACK_MAP] = { .type = NLA_U16 },
352 [NL80211_ATTR_INACTIVITY_TIMEOUT] = { .type = NLA_U16 },
353 [NL80211_ATTR_BG_SCAN_PERIOD] = { .type = NLA_U16 },
354 [NL80211_ATTR_WDEV] = { .type = NLA_U64 },
355 [NL80211_ATTR_USER_REG_HINT_TYPE] = { .type = NLA_U32 },
356 [NL80211_ATTR_SAE_DATA] = { .type = NLA_BINARY, },
357 [NL80211_ATTR_VHT_CAPABILITY] = { .len = NL80211_VHT_CAPABILITY_LEN },
358 [NL80211_ATTR_SCAN_FLAGS] = { .type = NLA_U32 },
359 [NL80211_ATTR_P2P_CTWINDOW] = { .type = NLA_U8 },
360 [NL80211_ATTR_P2P_OPPPS] = { .type = NLA_U8 },
361 [NL80211_ATTR_ACL_POLICY] = {. type = NLA_U32 },
362 [NL80211_ATTR_MAC_ADDRS] = { .type = NLA_NESTED },
363 [NL80211_ATTR_STA_CAPABILITY] = { .type = NLA_U16 },
364 [NL80211_ATTR_STA_EXT_CAPABILITY] = { .type = NLA_BINARY, },
365 [NL80211_ATTR_SPLIT_WIPHY_DUMP] = { .type = NLA_FLAG, },
366 [NL80211_ATTR_DISABLE_VHT] = { .type = NLA_FLAG },
367 [NL80211_ATTR_VHT_CAPABILITY_MASK] = {
368 .len = NL80211_VHT_CAPABILITY_LEN,
369 },
370 [NL80211_ATTR_MDID] = { .type = NLA_U16 },
371 [NL80211_ATTR_IE_RIC] = { .type = NLA_BINARY,
372 .len = IEEE80211_MAX_DATA_LEN },
373 [NL80211_ATTR_PEER_AID] = { .type = NLA_U16 },
374 [NL80211_ATTR_CH_SWITCH_COUNT] = { .type = NLA_U32 },
375 [NL80211_ATTR_CH_SWITCH_BLOCK_TX] = { .type = NLA_FLAG },
376 [NL80211_ATTR_CSA_IES] = { .type = NLA_NESTED },
377 [NL80211_ATTR_CSA_C_OFF_BEACON] = { .type = NLA_BINARY },
378 [NL80211_ATTR_CSA_C_OFF_PRESP] = { .type = NLA_BINARY },
379 [NL80211_ATTR_STA_SUPPORTED_CHANNELS] = { .type = NLA_BINARY },
380 [NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES] = { .type = NLA_BINARY },
381 [NL80211_ATTR_HANDLE_DFS] = { .type = NLA_FLAG },
382 [NL80211_ATTR_OPMODE_NOTIF] = { .type = NLA_U8 },
383 [NL80211_ATTR_VENDOR_ID] = { .type = NLA_U32 },
384 [NL80211_ATTR_VENDOR_SUBCMD] = { .type = NLA_U32 },
385 [NL80211_ATTR_VENDOR_DATA] = { .type = NLA_BINARY },
386 [NL80211_ATTR_QOS_MAP] = { .type = NLA_BINARY,
387 .len = IEEE80211_QOS_MAP_LEN_MAX },
388 [NL80211_ATTR_MAC_HINT] = { .len = ETH_ALEN },
389 [NL80211_ATTR_WIPHY_FREQ_HINT] = { .type = NLA_U32 },
390 [NL80211_ATTR_TDLS_PEER_CAPABILITY] = { .type = NLA_U32 },
391 [NL80211_ATTR_IFACE_SOCKET_OWNER] = { .type = NLA_FLAG },
392 [NL80211_ATTR_CSA_C_OFFSETS_TX] = { .type = NLA_BINARY },
393 [NL80211_ATTR_USE_RRM] = { .type = NLA_FLAG },
394 [NL80211_ATTR_TSID] = { .type = NLA_U8 },
395 [NL80211_ATTR_USER_PRIO] = { .type = NLA_U8 },
396 [NL80211_ATTR_ADMITTED_TIME] = { .type = NLA_U16 },
397 [NL80211_ATTR_SMPS_MODE] = { .type = NLA_U8 },
398 };
399
400 /* policy for the key attributes */
401 static const struct nla_policy nl80211_key_policy[NL80211_KEY_MAX + 1] = {
402 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
403 [NL80211_KEY_IDX] = { .type = NLA_U8 },
404 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
405 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 16 },
406 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
407 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
408 [NL80211_KEY_TYPE] = { .type = NLA_U32 },
409 [NL80211_KEY_DEFAULT_TYPES] = { .type = NLA_NESTED },
410 };
411
412 /* policy for the key default flags */
413 static const struct nla_policy
414 nl80211_key_default_policy[NUM_NL80211_KEY_DEFAULT_TYPES] = {
415 [NL80211_KEY_DEFAULT_TYPE_UNICAST] = { .type = NLA_FLAG },
416 [NL80211_KEY_DEFAULT_TYPE_MULTICAST] = { .type = NLA_FLAG },
417 };
418
419 /* policy for WoWLAN attributes */
420 static const struct nla_policy
421 nl80211_wowlan_policy[NUM_NL80211_WOWLAN_TRIG] = {
422 [NL80211_WOWLAN_TRIG_ANY] = { .type = NLA_FLAG },
423 [NL80211_WOWLAN_TRIG_DISCONNECT] = { .type = NLA_FLAG },
424 [NL80211_WOWLAN_TRIG_MAGIC_PKT] = { .type = NLA_FLAG },
425 [NL80211_WOWLAN_TRIG_PKT_PATTERN] = { .type = NLA_NESTED },
426 [NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE] = { .type = NLA_FLAG },
427 [NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST] = { .type = NLA_FLAG },
428 [NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE] = { .type = NLA_FLAG },
429 [NL80211_WOWLAN_TRIG_RFKILL_RELEASE] = { .type = NLA_FLAG },
430 [NL80211_WOWLAN_TRIG_TCP_CONNECTION] = { .type = NLA_NESTED },
431 };
432
433 static const struct nla_policy
434 nl80211_wowlan_tcp_policy[NUM_NL80211_WOWLAN_TCP] = {
435 [NL80211_WOWLAN_TCP_SRC_IPV4] = { .type = NLA_U32 },
436 [NL80211_WOWLAN_TCP_DST_IPV4] = { .type = NLA_U32 },
437 [NL80211_WOWLAN_TCP_DST_MAC] = { .len = ETH_ALEN },
438 [NL80211_WOWLAN_TCP_SRC_PORT] = { .type = NLA_U16 },
439 [NL80211_WOWLAN_TCP_DST_PORT] = { .type = NLA_U16 },
440 [NL80211_WOWLAN_TCP_DATA_PAYLOAD] = { .len = 1 },
441 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ] = {
442 .len = sizeof(struct nl80211_wowlan_tcp_data_seq)
443 },
444 [NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN] = {
445 .len = sizeof(struct nl80211_wowlan_tcp_data_token)
446 },
447 [NL80211_WOWLAN_TCP_DATA_INTERVAL] = { .type = NLA_U32 },
448 [NL80211_WOWLAN_TCP_WAKE_PAYLOAD] = { .len = 1 },
449 [NL80211_WOWLAN_TCP_WAKE_MASK] = { .len = 1 },
450 };
451
452 /* policy for coalesce rule attributes */
453 static const struct nla_policy
454 nl80211_coalesce_policy[NUM_NL80211_ATTR_COALESCE_RULE] = {
455 [NL80211_ATTR_COALESCE_RULE_DELAY] = { .type = NLA_U32 },
456 [NL80211_ATTR_COALESCE_RULE_CONDITION] = { .type = NLA_U32 },
457 [NL80211_ATTR_COALESCE_RULE_PKT_PATTERN] = { .type = NLA_NESTED },
458 };
459
460 /* policy for GTK rekey offload attributes */
461 static const struct nla_policy
462 nl80211_rekey_policy[NUM_NL80211_REKEY_DATA] = {
463 [NL80211_REKEY_DATA_KEK] = { .len = NL80211_KEK_LEN },
464 [NL80211_REKEY_DATA_KCK] = { .len = NL80211_KCK_LEN },
465 [NL80211_REKEY_DATA_REPLAY_CTR] = { .len = NL80211_REPLAY_CTR_LEN },
466 };
467
468 static const struct nla_policy
469 nl80211_match_policy[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1] = {
470 [NL80211_SCHED_SCAN_MATCH_ATTR_SSID] = { .type = NLA_BINARY,
471 .len = IEEE80211_MAX_SSID_LEN },
472 [NL80211_SCHED_SCAN_MATCH_ATTR_RSSI] = { .type = NLA_U32 },
473 };
474
475 static int nl80211_prepare_wdev_dump(struct sk_buff *skb,
476 struct netlink_callback *cb,
477 struct cfg80211_registered_device **rdev,
478 struct wireless_dev **wdev)
479 {
480 int err;
481
482 rtnl_lock();
483
484 if (!cb->args[0]) {
485 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
486 nl80211_fam.attrbuf, nl80211_fam.maxattr,
487 nl80211_policy);
488 if (err)
489 goto out_unlock;
490
491 *wdev = __cfg80211_wdev_from_attrs(sock_net(skb->sk),
492 nl80211_fam.attrbuf);
493 if (IS_ERR(*wdev)) {
494 err = PTR_ERR(*wdev);
495 goto out_unlock;
496 }
497 *rdev = wiphy_to_rdev((*wdev)->wiphy);
498 /* 0 is the first index - add 1 to parse only once */
499 cb->args[0] = (*rdev)->wiphy_idx + 1;
500 cb->args[1] = (*wdev)->identifier;
501 } else {
502 /* subtract the 1 again here */
503 struct wiphy *wiphy = wiphy_idx_to_wiphy(cb->args[0] - 1);
504 struct wireless_dev *tmp;
505
506 if (!wiphy) {
507 err = -ENODEV;
508 goto out_unlock;
509 }
510 *rdev = wiphy_to_rdev(wiphy);
511 *wdev = NULL;
512
513 list_for_each_entry(tmp, &(*rdev)->wdev_list, list) {
514 if (tmp->identifier == cb->args[1]) {
515 *wdev = tmp;
516 break;
517 }
518 }
519
520 if (!*wdev) {
521 err = -ENODEV;
522 goto out_unlock;
523 }
524 }
525
526 return 0;
527 out_unlock:
528 rtnl_unlock();
529 return err;
530 }
531
532 static void nl80211_finish_wdev_dump(struct cfg80211_registered_device *rdev)
533 {
534 rtnl_unlock();
535 }
536
537 /* IE validation */
538 static bool is_valid_ie_attr(const struct nlattr *attr)
539 {
540 const u8 *pos;
541 int len;
542
543 if (!attr)
544 return true;
545
546 pos = nla_data(attr);
547 len = nla_len(attr);
548
549 while (len) {
550 u8 elemlen;
551
552 if (len < 2)
553 return false;
554 len -= 2;
555
556 elemlen = pos[1];
557 if (elemlen > len)
558 return false;
559
560 len -= elemlen;
561 pos += 2 + elemlen;
562 }
563
564 return true;
565 }
566
567 /* message building helper */
568 static inline void *nl80211hdr_put(struct sk_buff *skb, u32 portid, u32 seq,
569 int flags, u8 cmd)
570 {
571 /* since there is no private header just add the generic one */
572 return genlmsg_put(skb, portid, seq, &nl80211_fam, flags, cmd);
573 }
574
575 static int nl80211_msg_put_channel(struct sk_buff *msg,
576 struct ieee80211_channel *chan,
577 bool large)
578 {
579 /* Some channels must be completely excluded from the
580 * list to protect old user-space tools from breaking
581 */
582 if (!large && chan->flags &
583 (IEEE80211_CHAN_NO_10MHZ | IEEE80211_CHAN_NO_20MHZ))
584 return 0;
585
586 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_FREQ,
587 chan->center_freq))
588 goto nla_put_failure;
589
590 if ((chan->flags & IEEE80211_CHAN_DISABLED) &&
591 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_DISABLED))
592 goto nla_put_failure;
593 if (chan->flags & IEEE80211_CHAN_NO_IR) {
594 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_IR))
595 goto nla_put_failure;
596 if (nla_put_flag(msg, __NL80211_FREQUENCY_ATTR_NO_IBSS))
597 goto nla_put_failure;
598 }
599 if (chan->flags & IEEE80211_CHAN_RADAR) {
600 if (nla_put_flag(msg, NL80211_FREQUENCY_ATTR_RADAR))
601 goto nla_put_failure;
602 if (large) {
603 u32 time;
604
605 time = elapsed_jiffies_msecs(chan->dfs_state_entered);
606
607 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_STATE,
608 chan->dfs_state))
609 goto nla_put_failure;
610 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_DFS_TIME,
611 time))
612 goto nla_put_failure;
613 if (nla_put_u32(msg,
614 NL80211_FREQUENCY_ATTR_DFS_CAC_TIME,
615 chan->dfs_cac_ms))
616 goto nla_put_failure;
617 }
618 }
619
620 if (large) {
621 if ((chan->flags & IEEE80211_CHAN_NO_HT40MINUS) &&
622 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_MINUS))
623 goto nla_put_failure;
624 if ((chan->flags & IEEE80211_CHAN_NO_HT40PLUS) &&
625 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_HT40_PLUS))
626 goto nla_put_failure;
627 if ((chan->flags & IEEE80211_CHAN_NO_80MHZ) &&
628 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_80MHZ))
629 goto nla_put_failure;
630 if ((chan->flags & IEEE80211_CHAN_NO_160MHZ) &&
631 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_160MHZ))
632 goto nla_put_failure;
633 if ((chan->flags & IEEE80211_CHAN_INDOOR_ONLY) &&
634 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_INDOOR_ONLY))
635 goto nla_put_failure;
636 if ((chan->flags & IEEE80211_CHAN_GO_CONCURRENT) &&
637 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_GO_CONCURRENT))
638 goto nla_put_failure;
639 if ((chan->flags & IEEE80211_CHAN_NO_20MHZ) &&
640 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_20MHZ))
641 goto nla_put_failure;
642 if ((chan->flags & IEEE80211_CHAN_NO_10MHZ) &&
643 nla_put_flag(msg, NL80211_FREQUENCY_ATTR_NO_10MHZ))
644 goto nla_put_failure;
645 }
646
647 if (nla_put_u32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
648 DBM_TO_MBM(chan->max_power)))
649 goto nla_put_failure;
650
651 return 0;
652
653 nla_put_failure:
654 return -ENOBUFS;
655 }
656
657 /* netlink command implementations */
658
659 struct key_parse {
660 struct key_params p;
661 int idx;
662 int type;
663 bool def, defmgmt;
664 bool def_uni, def_multi;
665 };
666
667 static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
668 {
669 struct nlattr *tb[NL80211_KEY_MAX + 1];
670 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
671 nl80211_key_policy);
672 if (err)
673 return err;
674
675 k->def = !!tb[NL80211_KEY_DEFAULT];
676 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
677
678 if (k->def) {
679 k->def_uni = true;
680 k->def_multi = true;
681 }
682 if (k->defmgmt)
683 k->def_multi = true;
684
685 if (tb[NL80211_KEY_IDX])
686 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
687
688 if (tb[NL80211_KEY_DATA]) {
689 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
690 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
691 }
692
693 if (tb[NL80211_KEY_SEQ]) {
694 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
695 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
696 }
697
698 if (tb[NL80211_KEY_CIPHER])
699 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
700
701 if (tb[NL80211_KEY_TYPE]) {
702 k->type = nla_get_u32(tb[NL80211_KEY_TYPE]);
703 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
704 return -EINVAL;
705 }
706
707 if (tb[NL80211_KEY_DEFAULT_TYPES]) {
708 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
709 err = nla_parse_nested(kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
710 tb[NL80211_KEY_DEFAULT_TYPES],
711 nl80211_key_default_policy);
712 if (err)
713 return err;
714
715 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
716 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
717 }
718
719 return 0;
720 }
721
722 static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
723 {
724 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
725 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
726 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
727 }
728
729 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
730 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
731 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
732 }
733
734 if (info->attrs[NL80211_ATTR_KEY_IDX])
735 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
736
737 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
738 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
739
740 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
741 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
742
743 if (k->def) {
744 k->def_uni = true;
745 k->def_multi = true;
746 }
747 if (k->defmgmt)
748 k->def_multi = true;
749
750 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
751 k->type = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
752 if (k->type < 0 || k->type >= NUM_NL80211_KEYTYPES)
753 return -EINVAL;
754 }
755
756 if (info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES]) {
757 struct nlattr *kdt[NUM_NL80211_KEY_DEFAULT_TYPES];
758 int err = nla_parse_nested(
759 kdt, NUM_NL80211_KEY_DEFAULT_TYPES - 1,
760 info->attrs[NL80211_ATTR_KEY_DEFAULT_TYPES],
761 nl80211_key_default_policy);
762 if (err)
763 return err;
764
765 k->def_uni = kdt[NL80211_KEY_DEFAULT_TYPE_UNICAST];
766 k->def_multi = kdt[NL80211_KEY_DEFAULT_TYPE_MULTICAST];
767 }
768
769 return 0;
770 }
771
772 static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
773 {
774 int err;
775
776 memset(k, 0, sizeof(*k));
777 k->idx = -1;
778 k->type = -1;
779
780 if (info->attrs[NL80211_ATTR_KEY])
781 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
782 else
783 err = nl80211_parse_key_old(info, k);
784
785 if (err)
786 return err;
787
788 if (k->def && k->defmgmt)
789 return -EINVAL;
790
791 if (k->defmgmt) {
792 if (k->def_uni || !k->def_multi)
793 return -EINVAL;
794 }
795
796 if (k->idx != -1) {
797 if (k->defmgmt) {
798 if (k->idx < 4 || k->idx > 5)
799 return -EINVAL;
800 } else if (k->def) {
801 if (k->idx < 0 || k->idx > 3)
802 return -EINVAL;
803 } else {
804 if (k->idx < 0 || k->idx > 5)
805 return -EINVAL;
806 }
807 }
808
809 return 0;
810 }
811
812 static struct cfg80211_cached_keys *
813 nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
814 struct nlattr *keys, bool *no_ht)
815 {
816 struct key_parse parse;
817 struct nlattr *key;
818 struct cfg80211_cached_keys *result;
819 int rem, err, def = 0;
820
821 result = kzalloc(sizeof(*result), GFP_KERNEL);
822 if (!result)
823 return ERR_PTR(-ENOMEM);
824
825 result->def = -1;
826 result->defmgmt = -1;
827
828 nla_for_each_nested(key, keys, rem) {
829 memset(&parse, 0, sizeof(parse));
830 parse.idx = -1;
831
832 err = nl80211_parse_key_new(key, &parse);
833 if (err)
834 goto error;
835 err = -EINVAL;
836 if (!parse.p.key)
837 goto error;
838 if (parse.idx < 0 || parse.idx > 4)
839 goto error;
840 if (parse.def) {
841 if (def)
842 goto error;
843 def = 1;
844 result->def = parse.idx;
845 if (!parse.def_uni || !parse.def_multi)
846 goto error;
847 } else if (parse.defmgmt)
848 goto error;
849 err = cfg80211_validate_key_settings(rdev, &parse.p,
850 parse.idx, false, NULL);
851 if (err)
852 goto error;
853 result->params[parse.idx].cipher = parse.p.cipher;
854 result->params[parse.idx].key_len = parse.p.key_len;
855 result->params[parse.idx].key = result->data[parse.idx];
856 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
857
858 if (parse.p.cipher == WLAN_CIPHER_SUITE_WEP40 ||
859 parse.p.cipher == WLAN_CIPHER_SUITE_WEP104) {
860 if (no_ht)
861 *no_ht = true;
862 }
863 }
864
865 return result;
866 error:
867 kfree(result);
868 return ERR_PTR(err);
869 }
870
871 static int nl80211_key_allowed(struct wireless_dev *wdev)
872 {
873 ASSERT_WDEV_LOCK(wdev);
874
875 switch (wdev->iftype) {
876 case NL80211_IFTYPE_AP:
877 case NL80211_IFTYPE_AP_VLAN:
878 case NL80211_IFTYPE_P2P_GO:
879 case NL80211_IFTYPE_MESH_POINT:
880 break;
881 case NL80211_IFTYPE_ADHOC:
882 case NL80211_IFTYPE_STATION:
883 case NL80211_IFTYPE_P2P_CLIENT:
884 if (!wdev->current_bss)
885 return -ENOLINK;
886 break;
887 case NL80211_IFTYPE_UNSPECIFIED:
888 case NL80211_IFTYPE_MONITOR:
889 case NL80211_IFTYPE_P2P_DEVICE:
890 case NL80211_IFTYPE_WDS:
891 case NUM_NL80211_IFTYPES:
892 return -EINVAL;
893 }
894
895 return 0;
896 }
897
898 static struct ieee80211_channel *nl80211_get_valid_chan(struct wiphy *wiphy,
899 struct nlattr *tb)
900 {
901 struct ieee80211_channel *chan;
902
903 if (tb == NULL)
904 return NULL;
905 chan = ieee80211_get_channel(wiphy, nla_get_u32(tb));
906 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
907 return NULL;
908 return chan;
909 }
910
911 static int nl80211_put_iftypes(struct sk_buff *msg, u32 attr, u16 ifmodes)
912 {
913 struct nlattr *nl_modes = nla_nest_start(msg, attr);
914 int i;
915
916 if (!nl_modes)
917 goto nla_put_failure;
918
919 i = 0;
920 while (ifmodes) {
921 if ((ifmodes & 1) && nla_put_flag(msg, i))
922 goto nla_put_failure;
923 ifmodes >>= 1;
924 i++;
925 }
926
927 nla_nest_end(msg, nl_modes);
928 return 0;
929
930 nla_put_failure:
931 return -ENOBUFS;
932 }
933
934 static int nl80211_put_iface_combinations(struct wiphy *wiphy,
935 struct sk_buff *msg,
936 bool large)
937 {
938 struct nlattr *nl_combis;
939 int i, j;
940
941 nl_combis = nla_nest_start(msg,
942 NL80211_ATTR_INTERFACE_COMBINATIONS);
943 if (!nl_combis)
944 goto nla_put_failure;
945
946 for (i = 0; i < wiphy->n_iface_combinations; i++) {
947 const struct ieee80211_iface_combination *c;
948 struct nlattr *nl_combi, *nl_limits;
949
950 c = &wiphy->iface_combinations[i];
951
952 nl_combi = nla_nest_start(msg, i + 1);
953 if (!nl_combi)
954 goto nla_put_failure;
955
956 nl_limits = nla_nest_start(msg, NL80211_IFACE_COMB_LIMITS);
957 if (!nl_limits)
958 goto nla_put_failure;
959
960 for (j = 0; j < c->n_limits; j++) {
961 struct nlattr *nl_limit;
962
963 nl_limit = nla_nest_start(msg, j + 1);
964 if (!nl_limit)
965 goto nla_put_failure;
966 if (nla_put_u32(msg, NL80211_IFACE_LIMIT_MAX,
967 c->limits[j].max))
968 goto nla_put_failure;
969 if (nl80211_put_iftypes(msg, NL80211_IFACE_LIMIT_TYPES,
970 c->limits[j].types))
971 goto nla_put_failure;
972 nla_nest_end(msg, nl_limit);
973 }
974
975 nla_nest_end(msg, nl_limits);
976
977 if (c->beacon_int_infra_match &&
978 nla_put_flag(msg, NL80211_IFACE_COMB_STA_AP_BI_MATCH))
979 goto nla_put_failure;
980 if (nla_put_u32(msg, NL80211_IFACE_COMB_NUM_CHANNELS,
981 c->num_different_channels) ||
982 nla_put_u32(msg, NL80211_IFACE_COMB_MAXNUM,
983 c->max_interfaces))
984 goto nla_put_failure;
985 if (large &&
986 (nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_WIDTHS,
987 c->radar_detect_widths) ||
988 nla_put_u32(msg, NL80211_IFACE_COMB_RADAR_DETECT_REGIONS,
989 c->radar_detect_regions)))
990 goto nla_put_failure;
991
992 nla_nest_end(msg, nl_combi);
993 }
994
995 nla_nest_end(msg, nl_combis);
996
997 return 0;
998 nla_put_failure:
999 return -ENOBUFS;
1000 }
1001
1002 #ifdef CONFIG_PM
1003 static int nl80211_send_wowlan_tcp_caps(struct cfg80211_registered_device *rdev,
1004 struct sk_buff *msg)
1005 {
1006 const struct wiphy_wowlan_tcp_support *tcp = rdev->wiphy.wowlan->tcp;
1007 struct nlattr *nl_tcp;
1008
1009 if (!tcp)
1010 return 0;
1011
1012 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
1013 if (!nl_tcp)
1014 return -ENOBUFS;
1015
1016 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1017 tcp->data_payload_max))
1018 return -ENOBUFS;
1019
1020 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
1021 tcp->data_payload_max))
1022 return -ENOBUFS;
1023
1024 if (tcp->seq && nla_put_flag(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ))
1025 return -ENOBUFS;
1026
1027 if (tcp->tok && nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
1028 sizeof(*tcp->tok), tcp->tok))
1029 return -ENOBUFS;
1030
1031 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
1032 tcp->data_interval_max))
1033 return -ENOBUFS;
1034
1035 if (nla_put_u32(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
1036 tcp->wake_payload_max))
1037 return -ENOBUFS;
1038
1039 nla_nest_end(msg, nl_tcp);
1040 return 0;
1041 }
1042
1043 static int nl80211_send_wowlan(struct sk_buff *msg,
1044 struct cfg80211_registered_device *rdev,
1045 bool large)
1046 {
1047 struct nlattr *nl_wowlan;
1048
1049 if (!rdev->wiphy.wowlan)
1050 return 0;
1051
1052 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS_SUPPORTED);
1053 if (!nl_wowlan)
1054 return -ENOBUFS;
1055
1056 if (((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_ANY) &&
1057 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
1058 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_DISCONNECT) &&
1059 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
1060 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT) &&
1061 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
1062 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_SUPPORTS_GTK_REKEY) &&
1063 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED)) ||
1064 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE) &&
1065 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
1066 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ) &&
1067 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
1068 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE) &&
1069 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
1070 ((rdev->wiphy.wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE) &&
1071 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
1072 return -ENOBUFS;
1073
1074 if (rdev->wiphy.wowlan->n_patterns) {
1075 struct nl80211_pattern_support pat = {
1076 .max_patterns = rdev->wiphy.wowlan->n_patterns,
1077 .min_pattern_len = rdev->wiphy.wowlan->pattern_min_len,
1078 .max_pattern_len = rdev->wiphy.wowlan->pattern_max_len,
1079 .max_pkt_offset = rdev->wiphy.wowlan->max_pkt_offset,
1080 };
1081
1082 if (nla_put(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
1083 sizeof(pat), &pat))
1084 return -ENOBUFS;
1085 }
1086
1087 if (large && nl80211_send_wowlan_tcp_caps(rdev, msg))
1088 return -ENOBUFS;
1089
1090 nla_nest_end(msg, nl_wowlan);
1091
1092 return 0;
1093 }
1094 #endif
1095
1096 static int nl80211_send_coalesce(struct sk_buff *msg,
1097 struct cfg80211_registered_device *rdev)
1098 {
1099 struct nl80211_coalesce_rule_support rule;
1100
1101 if (!rdev->wiphy.coalesce)
1102 return 0;
1103
1104 rule.max_rules = rdev->wiphy.coalesce->n_rules;
1105 rule.max_delay = rdev->wiphy.coalesce->max_delay;
1106 rule.pat.max_patterns = rdev->wiphy.coalesce->n_patterns;
1107 rule.pat.min_pattern_len = rdev->wiphy.coalesce->pattern_min_len;
1108 rule.pat.max_pattern_len = rdev->wiphy.coalesce->pattern_max_len;
1109 rule.pat.max_pkt_offset = rdev->wiphy.coalesce->max_pkt_offset;
1110
1111 if (nla_put(msg, NL80211_ATTR_COALESCE_RULE, sizeof(rule), &rule))
1112 return -ENOBUFS;
1113
1114 return 0;
1115 }
1116
1117 static int nl80211_send_band_rateinfo(struct sk_buff *msg,
1118 struct ieee80211_supported_band *sband)
1119 {
1120 struct nlattr *nl_rates, *nl_rate;
1121 struct ieee80211_rate *rate;
1122 int i;
1123
1124 /* add HT info */
1125 if (sband->ht_cap.ht_supported &&
1126 (nla_put(msg, NL80211_BAND_ATTR_HT_MCS_SET,
1127 sizeof(sband->ht_cap.mcs),
1128 &sband->ht_cap.mcs) ||
1129 nla_put_u16(msg, NL80211_BAND_ATTR_HT_CAPA,
1130 sband->ht_cap.cap) ||
1131 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
1132 sband->ht_cap.ampdu_factor) ||
1133 nla_put_u8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
1134 sband->ht_cap.ampdu_density)))
1135 return -ENOBUFS;
1136
1137 /* add VHT info */
1138 if (sband->vht_cap.vht_supported &&
1139 (nla_put(msg, NL80211_BAND_ATTR_VHT_MCS_SET,
1140 sizeof(sband->vht_cap.vht_mcs),
1141 &sband->vht_cap.vht_mcs) ||
1142 nla_put_u32(msg, NL80211_BAND_ATTR_VHT_CAPA,
1143 sband->vht_cap.cap)))
1144 return -ENOBUFS;
1145
1146 /* add bitrates */
1147 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
1148 if (!nl_rates)
1149 return -ENOBUFS;
1150
1151 for (i = 0; i < sband->n_bitrates; i++) {
1152 nl_rate = nla_nest_start(msg, i);
1153 if (!nl_rate)
1154 return -ENOBUFS;
1155
1156 rate = &sband->bitrates[i];
1157 if (nla_put_u32(msg, NL80211_BITRATE_ATTR_RATE,
1158 rate->bitrate))
1159 return -ENOBUFS;
1160 if ((rate->flags & IEEE80211_RATE_SHORT_PREAMBLE) &&
1161 nla_put_flag(msg,
1162 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE))
1163 return -ENOBUFS;
1164
1165 nla_nest_end(msg, nl_rate);
1166 }
1167
1168 nla_nest_end(msg, nl_rates);
1169
1170 return 0;
1171 }
1172
1173 static int
1174 nl80211_send_mgmt_stypes(struct sk_buff *msg,
1175 const struct ieee80211_txrx_stypes *mgmt_stypes)
1176 {
1177 u16 stypes;
1178 struct nlattr *nl_ftypes, *nl_ifs;
1179 enum nl80211_iftype ift;
1180 int i;
1181
1182 if (!mgmt_stypes)
1183 return 0;
1184
1185 nl_ifs = nla_nest_start(msg, NL80211_ATTR_TX_FRAME_TYPES);
1186 if (!nl_ifs)
1187 return -ENOBUFS;
1188
1189 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1190 nl_ftypes = nla_nest_start(msg, ift);
1191 if (!nl_ftypes)
1192 return -ENOBUFS;
1193 i = 0;
1194 stypes = mgmt_stypes[ift].tx;
1195 while (stypes) {
1196 if ((stypes & 1) &&
1197 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1198 (i << 4) | IEEE80211_FTYPE_MGMT))
1199 return -ENOBUFS;
1200 stypes >>= 1;
1201 i++;
1202 }
1203 nla_nest_end(msg, nl_ftypes);
1204 }
1205
1206 nla_nest_end(msg, nl_ifs);
1207
1208 nl_ifs = nla_nest_start(msg, NL80211_ATTR_RX_FRAME_TYPES);
1209 if (!nl_ifs)
1210 return -ENOBUFS;
1211
1212 for (ift = 0; ift < NUM_NL80211_IFTYPES; ift++) {
1213 nl_ftypes = nla_nest_start(msg, ift);
1214 if (!nl_ftypes)
1215 return -ENOBUFS;
1216 i = 0;
1217 stypes = mgmt_stypes[ift].rx;
1218 while (stypes) {
1219 if ((stypes & 1) &&
1220 nla_put_u16(msg, NL80211_ATTR_FRAME_TYPE,
1221 (i << 4) | IEEE80211_FTYPE_MGMT))
1222 return -ENOBUFS;
1223 stypes >>= 1;
1224 i++;
1225 }
1226 nla_nest_end(msg, nl_ftypes);
1227 }
1228 nla_nest_end(msg, nl_ifs);
1229
1230 return 0;
1231 }
1232
1233 struct nl80211_dump_wiphy_state {
1234 s64 filter_wiphy;
1235 long start;
1236 long split_start, band_start, chan_start;
1237 bool split;
1238 };
1239
1240 static int nl80211_send_wiphy(struct cfg80211_registered_device *rdev,
1241 enum nl80211_commands cmd,
1242 struct sk_buff *msg, u32 portid, u32 seq,
1243 int flags, struct nl80211_dump_wiphy_state *state)
1244 {
1245 void *hdr;
1246 struct nlattr *nl_bands, *nl_band;
1247 struct nlattr *nl_freqs, *nl_freq;
1248 struct nlattr *nl_cmds;
1249 enum ieee80211_band band;
1250 struct ieee80211_channel *chan;
1251 int i;
1252 const struct ieee80211_txrx_stypes *mgmt_stypes =
1253 rdev->wiphy.mgmt_stypes;
1254 u32 features;
1255
1256 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
1257 if (!hdr)
1258 return -ENOBUFS;
1259
1260 if (WARN_ON(!state))
1261 return -EINVAL;
1262
1263 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
1264 nla_put_string(msg, NL80211_ATTR_WIPHY_NAME,
1265 wiphy_name(&rdev->wiphy)) ||
1266 nla_put_u32(msg, NL80211_ATTR_GENERATION,
1267 cfg80211_rdev_list_generation))
1268 goto nla_put_failure;
1269
1270 if (cmd != NL80211_CMD_NEW_WIPHY)
1271 goto finish;
1272
1273 switch (state->split_start) {
1274 case 0:
1275 if (nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
1276 rdev->wiphy.retry_short) ||
1277 nla_put_u8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
1278 rdev->wiphy.retry_long) ||
1279 nla_put_u32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
1280 rdev->wiphy.frag_threshold) ||
1281 nla_put_u32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
1282 rdev->wiphy.rts_threshold) ||
1283 nla_put_u8(msg, NL80211_ATTR_WIPHY_COVERAGE_CLASS,
1284 rdev->wiphy.coverage_class) ||
1285 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
1286 rdev->wiphy.max_scan_ssids) ||
1287 nla_put_u8(msg, NL80211_ATTR_MAX_NUM_SCHED_SCAN_SSIDS,
1288 rdev->wiphy.max_sched_scan_ssids) ||
1289 nla_put_u16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
1290 rdev->wiphy.max_scan_ie_len) ||
1291 nla_put_u16(msg, NL80211_ATTR_MAX_SCHED_SCAN_IE_LEN,
1292 rdev->wiphy.max_sched_scan_ie_len) ||
1293 nla_put_u8(msg, NL80211_ATTR_MAX_MATCH_SETS,
1294 rdev->wiphy.max_match_sets))
1295 goto nla_put_failure;
1296
1297 if ((rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN) &&
1298 nla_put_flag(msg, NL80211_ATTR_SUPPORT_IBSS_RSN))
1299 goto nla_put_failure;
1300 if ((rdev->wiphy.flags & WIPHY_FLAG_MESH_AUTH) &&
1301 nla_put_flag(msg, NL80211_ATTR_SUPPORT_MESH_AUTH))
1302 goto nla_put_failure;
1303 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) &&
1304 nla_put_flag(msg, NL80211_ATTR_SUPPORT_AP_UAPSD))
1305 goto nla_put_failure;
1306 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_FW_ROAM) &&
1307 nla_put_flag(msg, NL80211_ATTR_ROAM_SUPPORT))
1308 goto nla_put_failure;
1309 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) &&
1310 nla_put_flag(msg, NL80211_ATTR_TDLS_SUPPORT))
1311 goto nla_put_failure;
1312 if ((rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP) &&
1313 nla_put_flag(msg, NL80211_ATTR_TDLS_EXTERNAL_SETUP))
1314 goto nla_put_failure;
1315 state->split_start++;
1316 if (state->split)
1317 break;
1318 case 1:
1319 if (nla_put(msg, NL80211_ATTR_CIPHER_SUITES,
1320 sizeof(u32) * rdev->wiphy.n_cipher_suites,
1321 rdev->wiphy.cipher_suites))
1322 goto nla_put_failure;
1323
1324 if (nla_put_u8(msg, NL80211_ATTR_MAX_NUM_PMKIDS,
1325 rdev->wiphy.max_num_pmkids))
1326 goto nla_put_failure;
1327
1328 if ((rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
1329 nla_put_flag(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE))
1330 goto nla_put_failure;
1331
1332 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_TX,
1333 rdev->wiphy.available_antennas_tx) ||
1334 nla_put_u32(msg, NL80211_ATTR_WIPHY_ANTENNA_AVAIL_RX,
1335 rdev->wiphy.available_antennas_rx))
1336 goto nla_put_failure;
1337
1338 if ((rdev->wiphy.flags & WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD) &&
1339 nla_put_u32(msg, NL80211_ATTR_PROBE_RESP_OFFLOAD,
1340 rdev->wiphy.probe_resp_offload))
1341 goto nla_put_failure;
1342
1343 if ((rdev->wiphy.available_antennas_tx ||
1344 rdev->wiphy.available_antennas_rx) &&
1345 rdev->ops->get_antenna) {
1346 u32 tx_ant = 0, rx_ant = 0;
1347 int res;
1348 res = rdev_get_antenna(rdev, &tx_ant, &rx_ant);
1349 if (!res) {
1350 if (nla_put_u32(msg,
1351 NL80211_ATTR_WIPHY_ANTENNA_TX,
1352 tx_ant) ||
1353 nla_put_u32(msg,
1354 NL80211_ATTR_WIPHY_ANTENNA_RX,
1355 rx_ant))
1356 goto nla_put_failure;
1357 }
1358 }
1359
1360 state->split_start++;
1361 if (state->split)
1362 break;
1363 case 2:
1364 if (nl80211_put_iftypes(msg, NL80211_ATTR_SUPPORTED_IFTYPES,
1365 rdev->wiphy.interface_modes))
1366 goto nla_put_failure;
1367 state->split_start++;
1368 if (state->split)
1369 break;
1370 case 3:
1371 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
1372 if (!nl_bands)
1373 goto nla_put_failure;
1374
1375 for (band = state->band_start;
1376 band < IEEE80211_NUM_BANDS; band++) {
1377 struct ieee80211_supported_band *sband;
1378
1379 sband = rdev->wiphy.bands[band];
1380
1381 if (!sband)
1382 continue;
1383
1384 nl_band = nla_nest_start(msg, band);
1385 if (!nl_band)
1386 goto nla_put_failure;
1387
1388 switch (state->chan_start) {
1389 case 0:
1390 if (nl80211_send_band_rateinfo(msg, sband))
1391 goto nla_put_failure;
1392 state->chan_start++;
1393 if (state->split)
1394 break;
1395 default:
1396 /* add frequencies */
1397 nl_freqs = nla_nest_start(
1398 msg, NL80211_BAND_ATTR_FREQS);
1399 if (!nl_freqs)
1400 goto nla_put_failure;
1401
1402 for (i = state->chan_start - 1;
1403 i < sband->n_channels;
1404 i++) {
1405 nl_freq = nla_nest_start(msg, i);
1406 if (!nl_freq)
1407 goto nla_put_failure;
1408
1409 chan = &sband->channels[i];
1410
1411 if (nl80211_msg_put_channel(
1412 msg, chan,
1413 state->split))
1414 goto nla_put_failure;
1415
1416 nla_nest_end(msg, nl_freq);
1417 if (state->split)
1418 break;
1419 }
1420 if (i < sband->n_channels)
1421 state->chan_start = i + 2;
1422 else
1423 state->chan_start = 0;
1424 nla_nest_end(msg, nl_freqs);
1425 }
1426
1427 nla_nest_end(msg, nl_band);
1428
1429 if (state->split) {
1430 /* start again here */
1431 if (state->chan_start)
1432 band--;
1433 break;
1434 }
1435 }
1436 nla_nest_end(msg, nl_bands);
1437
1438 if (band < IEEE80211_NUM_BANDS)
1439 state->band_start = band + 1;
1440 else
1441 state->band_start = 0;
1442
1443 /* if bands & channels are done, continue outside */
1444 if (state->band_start == 0 && state->chan_start == 0)
1445 state->split_start++;
1446 if (state->split)
1447 break;
1448 case 4:
1449 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
1450 if (!nl_cmds)
1451 goto nla_put_failure;
1452
1453 i = 0;
1454 #define CMD(op, n) \
1455 do { \
1456 if (rdev->ops->op) { \
1457 i++; \
1458 if (nla_put_u32(msg, i, NL80211_CMD_ ## n)) \
1459 goto nla_put_failure; \
1460 } \
1461 } while (0)
1462
1463 CMD(add_virtual_intf, NEW_INTERFACE);
1464 CMD(change_virtual_intf, SET_INTERFACE);
1465 CMD(add_key, NEW_KEY);
1466 CMD(start_ap, START_AP);
1467 CMD(add_station, NEW_STATION);
1468 CMD(add_mpath, NEW_MPATH);
1469 CMD(update_mesh_config, SET_MESH_CONFIG);
1470 CMD(change_bss, SET_BSS);
1471 CMD(auth, AUTHENTICATE);
1472 CMD(assoc, ASSOCIATE);
1473 CMD(deauth, DEAUTHENTICATE);
1474 CMD(disassoc, DISASSOCIATE);
1475 CMD(join_ibss, JOIN_IBSS);
1476 CMD(join_mesh, JOIN_MESH);
1477 CMD(set_pmksa, SET_PMKSA);
1478 CMD(del_pmksa, DEL_PMKSA);
1479 CMD(flush_pmksa, FLUSH_PMKSA);
1480 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL)
1481 CMD(remain_on_channel, REMAIN_ON_CHANNEL);
1482 CMD(set_bitrate_mask, SET_TX_BITRATE_MASK);
1483 CMD(mgmt_tx, FRAME);
1484 CMD(mgmt_tx_cancel_wait, FRAME_WAIT_CANCEL);
1485 if (rdev->wiphy.flags & WIPHY_FLAG_NETNS_OK) {
1486 i++;
1487 if (nla_put_u32(msg, i, NL80211_CMD_SET_WIPHY_NETNS))
1488 goto nla_put_failure;
1489 }
1490 if (rdev->ops->set_monitor_channel || rdev->ops->start_ap ||
1491 rdev->ops->join_mesh) {
1492 i++;
1493 if (nla_put_u32(msg, i, NL80211_CMD_SET_CHANNEL))
1494 goto nla_put_failure;
1495 }
1496 CMD(set_wds_peer, SET_WDS_PEER);
1497 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) {
1498 CMD(tdls_mgmt, TDLS_MGMT);
1499 CMD(tdls_oper, TDLS_OPER);
1500 }
1501 if (rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN)
1502 CMD(sched_scan_start, START_SCHED_SCAN);
1503 CMD(probe_client, PROBE_CLIENT);
1504 CMD(set_noack_map, SET_NOACK_MAP);
1505 if (rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS) {
1506 i++;
1507 if (nla_put_u32(msg, i, NL80211_CMD_REGISTER_BEACONS))
1508 goto nla_put_failure;
1509 }
1510 CMD(start_p2p_device, START_P2P_DEVICE);
1511 CMD(set_mcast_rate, SET_MCAST_RATE);
1512 #ifdef CONFIG_NL80211_TESTMODE
1513 CMD(testmode_cmd, TESTMODE);
1514 #endif
1515 if (state->split) {
1516 CMD(crit_proto_start, CRIT_PROTOCOL_START);
1517 CMD(crit_proto_stop, CRIT_PROTOCOL_STOP);
1518 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH)
1519 CMD(channel_switch, CHANNEL_SWITCH);
1520 CMD(set_qos_map, SET_QOS_MAP);
1521 if (rdev->wiphy.features &
1522 NL80211_FEATURE_SUPPORTS_WMM_ADMISSION)
1523 CMD(add_tx_ts, ADD_TX_TS);
1524 }
1525 /* add into the if now */
1526 #undef CMD
1527
1528 if (rdev->ops->connect || rdev->ops->auth) {
1529 i++;
1530 if (nla_put_u32(msg, i, NL80211_CMD_CONNECT))
1531 goto nla_put_failure;
1532 }
1533
1534 if (rdev->ops->disconnect || rdev->ops->deauth) {
1535 i++;
1536 if (nla_put_u32(msg, i, NL80211_CMD_DISCONNECT))
1537 goto nla_put_failure;
1538 }
1539
1540 nla_nest_end(msg, nl_cmds);
1541 state->split_start++;
1542 if (state->split)
1543 break;
1544 case 5:
1545 if (rdev->ops->remain_on_channel &&
1546 (rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL) &&
1547 nla_put_u32(msg,
1548 NL80211_ATTR_MAX_REMAIN_ON_CHANNEL_DURATION,
1549 rdev->wiphy.max_remain_on_channel_duration))
1550 goto nla_put_failure;
1551
1552 if ((rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX) &&
1553 nla_put_flag(msg, NL80211_ATTR_OFFCHANNEL_TX_OK))
1554 goto nla_put_failure;
1555
1556 if (nl80211_send_mgmt_stypes(msg, mgmt_stypes))
1557 goto nla_put_failure;
1558 state->split_start++;
1559 if (state->split)
1560 break;
1561 case 6:
1562 #ifdef CONFIG_PM
1563 if (nl80211_send_wowlan(msg, rdev, state->split))
1564 goto nla_put_failure;
1565 state->split_start++;
1566 if (state->split)
1567 break;
1568 #else
1569 state->split_start++;
1570 #endif
1571 case 7:
1572 if (nl80211_put_iftypes(msg, NL80211_ATTR_SOFTWARE_IFTYPES,
1573 rdev->wiphy.software_iftypes))
1574 goto nla_put_failure;
1575
1576 if (nl80211_put_iface_combinations(&rdev->wiphy, msg,
1577 state->split))
1578 goto nla_put_failure;
1579
1580 state->split_start++;
1581 if (state->split)
1582 break;
1583 case 8:
1584 if ((rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME) &&
1585 nla_put_u32(msg, NL80211_ATTR_DEVICE_AP_SME,
1586 rdev->wiphy.ap_sme_capa))
1587 goto nla_put_failure;
1588
1589 features = rdev->wiphy.features;
1590 /*
1591 * We can only add the per-channel limit information if the
1592 * dump is split, otherwise it makes it too big. Therefore
1593 * only advertise it in that case.
1594 */
1595 if (state->split)
1596 features |= NL80211_FEATURE_ADVERTISE_CHAN_LIMITS;
1597 if (nla_put_u32(msg, NL80211_ATTR_FEATURE_FLAGS, features))
1598 goto nla_put_failure;
1599
1600 if (rdev->wiphy.ht_capa_mod_mask &&
1601 nla_put(msg, NL80211_ATTR_HT_CAPABILITY_MASK,
1602 sizeof(*rdev->wiphy.ht_capa_mod_mask),
1603 rdev->wiphy.ht_capa_mod_mask))
1604 goto nla_put_failure;
1605
1606 if (rdev->wiphy.flags & WIPHY_FLAG_HAVE_AP_SME &&
1607 rdev->wiphy.max_acl_mac_addrs &&
1608 nla_put_u32(msg, NL80211_ATTR_MAC_ACL_MAX,
1609 rdev->wiphy.max_acl_mac_addrs))
1610 goto nla_put_failure;
1611
1612 /*
1613 * Any information below this point is only available to
1614 * applications that can deal with it being split. This
1615 * helps ensure that newly added capabilities don't break
1616 * older tools by overrunning their buffers.
1617 *
1618 * We still increment split_start so that in the split
1619 * case we'll continue with more data in the next round,
1620 * but break unconditionally so unsplit data stops here.
1621 */
1622 state->split_start++;
1623 break;
1624 case 9:
1625 if (rdev->wiphy.extended_capabilities &&
1626 (nla_put(msg, NL80211_ATTR_EXT_CAPA,
1627 rdev->wiphy.extended_capabilities_len,
1628 rdev->wiphy.extended_capabilities) ||
1629 nla_put(msg, NL80211_ATTR_EXT_CAPA_MASK,
1630 rdev->wiphy.extended_capabilities_len,
1631 rdev->wiphy.extended_capabilities_mask)))
1632 goto nla_put_failure;
1633
1634 if (rdev->wiphy.vht_capa_mod_mask &&
1635 nla_put(msg, NL80211_ATTR_VHT_CAPABILITY_MASK,
1636 sizeof(*rdev->wiphy.vht_capa_mod_mask),
1637 rdev->wiphy.vht_capa_mod_mask))
1638 goto nla_put_failure;
1639
1640 state->split_start++;
1641 break;
1642 case 10:
1643 if (nl80211_send_coalesce(msg, rdev))
1644 goto nla_put_failure;
1645
1646 if ((rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ) &&
1647 (nla_put_flag(msg, NL80211_ATTR_SUPPORT_5_MHZ) ||
1648 nla_put_flag(msg, NL80211_ATTR_SUPPORT_10_MHZ)))
1649 goto nla_put_failure;
1650
1651 if (rdev->wiphy.max_ap_assoc_sta &&
1652 nla_put_u32(msg, NL80211_ATTR_MAX_AP_ASSOC_STA,
1653 rdev->wiphy.max_ap_assoc_sta))
1654 goto nla_put_failure;
1655
1656 state->split_start++;
1657 break;
1658 case 11:
1659 if (rdev->wiphy.n_vendor_commands) {
1660 const struct nl80211_vendor_cmd_info *info;
1661 struct nlattr *nested;
1662
1663 nested = nla_nest_start(msg, NL80211_ATTR_VENDOR_DATA);
1664 if (!nested)
1665 goto nla_put_failure;
1666
1667 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
1668 info = &rdev->wiphy.vendor_commands[i].info;
1669 if (nla_put(msg, i + 1, sizeof(*info), info))
1670 goto nla_put_failure;
1671 }
1672 nla_nest_end(msg, nested);
1673 }
1674
1675 if (rdev->wiphy.n_vendor_events) {
1676 const struct nl80211_vendor_cmd_info *info;
1677 struct nlattr *nested;
1678
1679 nested = nla_nest_start(msg,
1680 NL80211_ATTR_VENDOR_EVENTS);
1681 if (!nested)
1682 goto nla_put_failure;
1683
1684 for (i = 0; i < rdev->wiphy.n_vendor_events; i++) {
1685 info = &rdev->wiphy.vendor_events[i];
1686 if (nla_put(msg, i + 1, sizeof(*info), info))
1687 goto nla_put_failure;
1688 }
1689 nla_nest_end(msg, nested);
1690 }
1691 state->split_start++;
1692 break;
1693 case 12:
1694 if (rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH &&
1695 nla_put_u8(msg, NL80211_ATTR_MAX_CSA_COUNTERS,
1696 rdev->wiphy.max_num_csa_counters))
1697 goto nla_put_failure;
1698
1699 /* done */
1700 state->split_start = 0;
1701 break;
1702 }
1703 finish:
1704 return genlmsg_end(msg, hdr);
1705
1706 nla_put_failure:
1707 genlmsg_cancel(msg, hdr);
1708 return -EMSGSIZE;
1709 }
1710
1711 static int nl80211_dump_wiphy_parse(struct sk_buff *skb,
1712 struct netlink_callback *cb,
1713 struct nl80211_dump_wiphy_state *state)
1714 {
1715 struct nlattr **tb = nl80211_fam.attrbuf;
1716 int ret = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1717 tb, nl80211_fam.maxattr, nl80211_policy);
1718 /* ignore parse errors for backward compatibility */
1719 if (ret)
1720 return 0;
1721
1722 state->split = tb[NL80211_ATTR_SPLIT_WIPHY_DUMP];
1723 if (tb[NL80211_ATTR_WIPHY])
1724 state->filter_wiphy = nla_get_u32(tb[NL80211_ATTR_WIPHY]);
1725 if (tb[NL80211_ATTR_WDEV])
1726 state->filter_wiphy = nla_get_u64(tb[NL80211_ATTR_WDEV]) >> 32;
1727 if (tb[NL80211_ATTR_IFINDEX]) {
1728 struct net_device *netdev;
1729 struct cfg80211_registered_device *rdev;
1730 int ifidx = nla_get_u32(tb[NL80211_ATTR_IFINDEX]);
1731
1732 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
1733 if (!netdev)
1734 return -ENODEV;
1735 if (netdev->ieee80211_ptr) {
1736 rdev = wiphy_to_rdev(
1737 netdev->ieee80211_ptr->wiphy);
1738 state->filter_wiphy = rdev->wiphy_idx;
1739 }
1740 }
1741
1742 return 0;
1743 }
1744
1745 static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
1746 {
1747 int idx = 0, ret;
1748 struct nl80211_dump_wiphy_state *state = (void *)cb->args[0];
1749 struct cfg80211_registered_device *rdev;
1750
1751 rtnl_lock();
1752 if (!state) {
1753 state = kzalloc(sizeof(*state), GFP_KERNEL);
1754 if (!state) {
1755 rtnl_unlock();
1756 return -ENOMEM;
1757 }
1758 state->filter_wiphy = -1;
1759 ret = nl80211_dump_wiphy_parse(skb, cb, state);
1760 if (ret) {
1761 kfree(state);
1762 rtnl_unlock();
1763 return ret;
1764 }
1765 cb->args[0] = (long)state;
1766 }
1767
1768 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
1769 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
1770 continue;
1771 if (++idx <= state->start)
1772 continue;
1773 if (state->filter_wiphy != -1 &&
1774 state->filter_wiphy != rdev->wiphy_idx)
1775 continue;
1776 /* attempt to fit multiple wiphy data chunks into the skb */
1777 do {
1778 ret = nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY,
1779 skb,
1780 NETLINK_CB(cb->skb).portid,
1781 cb->nlh->nlmsg_seq,
1782 NLM_F_MULTI, state);
1783 if (ret < 0) {
1784 /*
1785 * If sending the wiphy data didn't fit (ENOBUFS
1786 * or EMSGSIZE returned), this SKB is still
1787 * empty (so it's not too big because another
1788 * wiphy dataset is already in the skb) and
1789 * we've not tried to adjust the dump allocation
1790 * yet ... then adjust the alloc size to be
1791 * bigger, and return 1 but with the empty skb.
1792 * This results in an empty message being RX'ed
1793 * in userspace, but that is ignored.
1794 *
1795 * We can then retry with the larger buffer.
1796 */
1797 if ((ret == -ENOBUFS || ret == -EMSGSIZE) &&
1798 !skb->len && !state->split &&
1799 cb->min_dump_alloc < 4096) {
1800 cb->min_dump_alloc = 4096;
1801 state->split_start = 0;
1802 rtnl_unlock();
1803 return 1;
1804 }
1805 idx--;
1806 break;
1807 }
1808 } while (state->split_start > 0);
1809 break;
1810 }
1811 rtnl_unlock();
1812
1813 state->start = idx;
1814
1815 return skb->len;
1816 }
1817
1818 static int nl80211_dump_wiphy_done(struct netlink_callback *cb)
1819 {
1820 kfree((void *)cb->args[0]);
1821 return 0;
1822 }
1823
1824 static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
1825 {
1826 struct sk_buff *msg;
1827 struct cfg80211_registered_device *rdev = info->user_ptr[0];
1828 struct nl80211_dump_wiphy_state state = {};
1829
1830 msg = nlmsg_new(4096, GFP_KERNEL);
1831 if (!msg)
1832 return -ENOMEM;
1833
1834 if (nl80211_send_wiphy(rdev, NL80211_CMD_NEW_WIPHY, msg,
1835 info->snd_portid, info->snd_seq, 0,
1836 &state) < 0) {
1837 nlmsg_free(msg);
1838 return -ENOBUFS;
1839 }
1840
1841 return genlmsg_reply(msg, info);
1842 }
1843
1844 static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
1845 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
1846 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
1847 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
1848 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
1849 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
1850 };
1851
1852 static int parse_txq_params(struct nlattr *tb[],
1853 struct ieee80211_txq_params *txq_params)
1854 {
1855 if (!tb[NL80211_TXQ_ATTR_AC] || !tb[NL80211_TXQ_ATTR_TXOP] ||
1856 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
1857 !tb[NL80211_TXQ_ATTR_AIFS])
1858 return -EINVAL;
1859
1860 txq_params->ac = nla_get_u8(tb[NL80211_TXQ_ATTR_AC]);
1861 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
1862 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
1863 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
1864 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
1865
1866 if (txq_params->ac >= NL80211_NUM_ACS)
1867 return -EINVAL;
1868
1869 return 0;
1870 }
1871
1872 static bool nl80211_can_set_dev_channel(struct wireless_dev *wdev)
1873 {
1874 /*
1875 * You can only set the channel explicitly for WDS interfaces,
1876 * all others have their channel managed via their respective
1877 * "establish a connection" command (connect, join, ...)
1878 *
1879 * For AP/GO and mesh mode, the channel can be set with the
1880 * channel userspace API, but is only stored and passed to the
1881 * low-level driver when the AP starts or the mesh is joined.
1882 * This is for backward compatibility, userspace can also give
1883 * the channel in the start-ap or join-mesh commands instead.
1884 *
1885 * Monitors are special as they are normally slaved to
1886 * whatever else is going on, so they have their own special
1887 * operation to set the monitor channel if possible.
1888 */
1889 return !wdev ||
1890 wdev->iftype == NL80211_IFTYPE_AP ||
1891 wdev->iftype == NL80211_IFTYPE_MESH_POINT ||
1892 wdev->iftype == NL80211_IFTYPE_MONITOR ||
1893 wdev->iftype == NL80211_IFTYPE_P2P_GO;
1894 }
1895
1896 static int nl80211_parse_chandef(struct cfg80211_registered_device *rdev,
1897 struct genl_info *info,
1898 struct cfg80211_chan_def *chandef)
1899 {
1900 u32 control_freq;
1901
1902 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
1903 return -EINVAL;
1904
1905 control_freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
1906
1907 chandef->chan = ieee80211_get_channel(&rdev->wiphy, control_freq);
1908 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
1909 chandef->center_freq1 = control_freq;
1910 chandef->center_freq2 = 0;
1911
1912 /* Primary channel not allowed */
1913 if (!chandef->chan || chandef->chan->flags & IEEE80211_CHAN_DISABLED)
1914 return -EINVAL;
1915
1916 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
1917 enum nl80211_channel_type chantype;
1918
1919 chantype = nla_get_u32(
1920 info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
1921
1922 switch (chantype) {
1923 case NL80211_CHAN_NO_HT:
1924 case NL80211_CHAN_HT20:
1925 case NL80211_CHAN_HT40PLUS:
1926 case NL80211_CHAN_HT40MINUS:
1927 cfg80211_chandef_create(chandef, chandef->chan,
1928 chantype);
1929 break;
1930 default:
1931 return -EINVAL;
1932 }
1933 } else if (info->attrs[NL80211_ATTR_CHANNEL_WIDTH]) {
1934 chandef->width =
1935 nla_get_u32(info->attrs[NL80211_ATTR_CHANNEL_WIDTH]);
1936 if (info->attrs[NL80211_ATTR_CENTER_FREQ1])
1937 chandef->center_freq1 =
1938 nla_get_u32(
1939 info->attrs[NL80211_ATTR_CENTER_FREQ1]);
1940 if (info->attrs[NL80211_ATTR_CENTER_FREQ2])
1941 chandef->center_freq2 =
1942 nla_get_u32(
1943 info->attrs[NL80211_ATTR_CENTER_FREQ2]);
1944 }
1945
1946 if (!cfg80211_chandef_valid(chandef))
1947 return -EINVAL;
1948
1949 if (!cfg80211_chandef_usable(&rdev->wiphy, chandef,
1950 IEEE80211_CHAN_DISABLED))
1951 return -EINVAL;
1952
1953 if ((chandef->width == NL80211_CHAN_WIDTH_5 ||
1954 chandef->width == NL80211_CHAN_WIDTH_10) &&
1955 !(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_5_10_MHZ))
1956 return -EINVAL;
1957
1958 return 0;
1959 }
1960
1961 static int __nl80211_set_channel(struct cfg80211_registered_device *rdev,
1962 struct net_device *dev,
1963 struct genl_info *info)
1964 {
1965 struct cfg80211_chan_def chandef;
1966 int result;
1967 enum nl80211_iftype iftype = NL80211_IFTYPE_MONITOR;
1968 struct wireless_dev *wdev = NULL;
1969
1970 if (dev)
1971 wdev = dev->ieee80211_ptr;
1972 if (!nl80211_can_set_dev_channel(wdev))
1973 return -EOPNOTSUPP;
1974 if (wdev)
1975 iftype = wdev->iftype;
1976
1977 result = nl80211_parse_chandef(rdev, info, &chandef);
1978 if (result)
1979 return result;
1980
1981 switch (iftype) {
1982 case NL80211_IFTYPE_AP:
1983 case NL80211_IFTYPE_P2P_GO:
1984 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &chandef, iftype)) {
1985 result = -EINVAL;
1986 break;
1987 }
1988 if (wdev->beacon_interval) {
1989 if (!dev || !rdev->ops->set_ap_chanwidth ||
1990 !(rdev->wiphy.features &
1991 NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE)) {
1992 result = -EBUSY;
1993 break;
1994 }
1995
1996 /* Only allow dynamic channel width changes */
1997 if (chandef.chan != wdev->preset_chandef.chan) {
1998 result = -EBUSY;
1999 break;
2000 }
2001 result = rdev_set_ap_chanwidth(rdev, dev, &chandef);
2002 if (result)
2003 break;
2004 }
2005 wdev->preset_chandef = chandef;
2006 result = 0;
2007 break;
2008 case NL80211_IFTYPE_MESH_POINT:
2009 result = cfg80211_set_mesh_channel(rdev, wdev, &chandef);
2010 break;
2011 case NL80211_IFTYPE_MONITOR:
2012 result = cfg80211_set_monitor_channel(rdev, &chandef);
2013 break;
2014 default:
2015 result = -EINVAL;
2016 }
2017
2018 return result;
2019 }
2020
2021 static int nl80211_set_channel(struct sk_buff *skb, struct genl_info *info)
2022 {
2023 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2024 struct net_device *netdev = info->user_ptr[1];
2025
2026 return __nl80211_set_channel(rdev, netdev, info);
2027 }
2028
2029 static int nl80211_set_wds_peer(struct sk_buff *skb, struct genl_info *info)
2030 {
2031 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2032 struct net_device *dev = info->user_ptr[1];
2033 struct wireless_dev *wdev = dev->ieee80211_ptr;
2034 const u8 *bssid;
2035
2036 if (!info->attrs[NL80211_ATTR_MAC])
2037 return -EINVAL;
2038
2039 if (netif_running(dev))
2040 return -EBUSY;
2041
2042 if (!rdev->ops->set_wds_peer)
2043 return -EOPNOTSUPP;
2044
2045 if (wdev->iftype != NL80211_IFTYPE_WDS)
2046 return -EOPNOTSUPP;
2047
2048 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
2049 return rdev_set_wds_peer(rdev, dev, bssid);
2050 }
2051
2052
2053 static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
2054 {
2055 struct cfg80211_registered_device *rdev;
2056 struct net_device *netdev = NULL;
2057 struct wireless_dev *wdev;
2058 int result = 0, rem_txq_params = 0;
2059 struct nlattr *nl_txq_params;
2060 u32 changed;
2061 u8 retry_short = 0, retry_long = 0;
2062 u32 frag_threshold = 0, rts_threshold = 0;
2063 u8 coverage_class = 0;
2064
2065 ASSERT_RTNL();
2066
2067 /*
2068 * Try to find the wiphy and netdev. Normally this
2069 * function shouldn't need the netdev, but this is
2070 * done for backward compatibility -- previously
2071 * setting the channel was done per wiphy, but now
2072 * it is per netdev. Previous userland like hostapd
2073 * also passed a netdev to set_wiphy, so that it is
2074 * possible to let that go to the right netdev!
2075 */
2076
2077 if (info->attrs[NL80211_ATTR_IFINDEX]) {
2078 int ifindex = nla_get_u32(info->attrs[NL80211_ATTR_IFINDEX]);
2079
2080 netdev = __dev_get_by_index(genl_info_net(info), ifindex);
2081 if (netdev && netdev->ieee80211_ptr)
2082 rdev = wiphy_to_rdev(netdev->ieee80211_ptr->wiphy);
2083 else
2084 netdev = NULL;
2085 }
2086
2087 if (!netdev) {
2088 rdev = __cfg80211_rdev_from_attrs(genl_info_net(info),
2089 info->attrs);
2090 if (IS_ERR(rdev))
2091 return PTR_ERR(rdev);
2092 wdev = NULL;
2093 netdev = NULL;
2094 result = 0;
2095 } else
2096 wdev = netdev->ieee80211_ptr;
2097
2098 /*
2099 * end workaround code, by now the rdev is available
2100 * and locked, and wdev may or may not be NULL.
2101 */
2102
2103 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
2104 result = cfg80211_dev_rename(
2105 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
2106
2107 if (result)
2108 return result;
2109
2110 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
2111 struct ieee80211_txq_params txq_params;
2112 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
2113
2114 if (!rdev->ops->set_txq_params)
2115 return -EOPNOTSUPP;
2116
2117 if (!netdev)
2118 return -EINVAL;
2119
2120 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
2121 netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
2122 return -EINVAL;
2123
2124 if (!netif_running(netdev))
2125 return -ENETDOWN;
2126
2127 nla_for_each_nested(nl_txq_params,
2128 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
2129 rem_txq_params) {
2130 result = nla_parse(tb, NL80211_TXQ_ATTR_MAX,
2131 nla_data(nl_txq_params),
2132 nla_len(nl_txq_params),
2133 txq_params_policy);
2134 if (result)
2135 return result;
2136 result = parse_txq_params(tb, &txq_params);
2137 if (result)
2138 return result;
2139
2140 result = rdev_set_txq_params(rdev, netdev,
2141 &txq_params);
2142 if (result)
2143 return result;
2144 }
2145 }
2146
2147 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
2148 result = __nl80211_set_channel(
2149 rdev,
2150 nl80211_can_set_dev_channel(wdev) ? netdev : NULL,
2151 info);
2152 if (result)
2153 return result;
2154 }
2155
2156 if (info->attrs[NL80211_ATTR_WIPHY_TX_POWER_SETTING]) {
2157 struct wireless_dev *txp_wdev = wdev;
2158 enum nl80211_tx_power_setting type;
2159 int idx, mbm = 0;
2160
2161 if (!(rdev->wiphy.features & NL80211_FEATURE_VIF_TXPOWER))
2162 txp_wdev = NULL;
2163
2164 if (!rdev->ops->set_tx_power)
2165 return -EOPNOTSUPP;
2166
2167 idx = NL80211_ATTR_WIPHY_TX_POWER_SETTING;
2168 type = nla_get_u32(info->attrs[idx]);
2169
2170 if (!info->attrs[NL80211_ATTR_WIPHY_TX_POWER_LEVEL] &&
2171 (type != NL80211_TX_POWER_AUTOMATIC))
2172 return -EINVAL;
2173
2174 if (type != NL80211_TX_POWER_AUTOMATIC) {
2175 idx = NL80211_ATTR_WIPHY_TX_POWER_LEVEL;
2176 mbm = nla_get_u32(info->attrs[idx]);
2177 }
2178
2179 result = rdev_set_tx_power(rdev, txp_wdev, type, mbm);
2180 if (result)
2181 return result;
2182 }
2183
2184 if (info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX] &&
2185 info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]) {
2186 u32 tx_ant, rx_ant;
2187 if ((!rdev->wiphy.available_antennas_tx &&
2188 !rdev->wiphy.available_antennas_rx) ||
2189 !rdev->ops->set_antenna)
2190 return -EOPNOTSUPP;
2191
2192 tx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_TX]);
2193 rx_ant = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_ANTENNA_RX]);
2194
2195 /* reject antenna configurations which don't match the
2196 * available antenna masks, except for the "all" mask */
2197 if ((~tx_ant && (tx_ant & ~rdev->wiphy.available_antennas_tx)) ||
2198 (~rx_ant && (rx_ant & ~rdev->wiphy.available_antennas_rx)))
2199 return -EINVAL;
2200
2201 tx_ant = tx_ant & rdev->wiphy.available_antennas_tx;
2202 rx_ant = rx_ant & rdev->wiphy.available_antennas_rx;
2203
2204 result = rdev_set_antenna(rdev, tx_ant, rx_ant);
2205 if (result)
2206 return result;
2207 }
2208
2209 changed = 0;
2210
2211 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
2212 retry_short = nla_get_u8(
2213 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
2214 if (retry_short == 0)
2215 return -EINVAL;
2216
2217 changed |= WIPHY_PARAM_RETRY_SHORT;
2218 }
2219
2220 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
2221 retry_long = nla_get_u8(
2222 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
2223 if (retry_long == 0)
2224 return -EINVAL;
2225
2226 changed |= WIPHY_PARAM_RETRY_LONG;
2227 }
2228
2229 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
2230 frag_threshold = nla_get_u32(
2231 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
2232 if (frag_threshold < 256)
2233 return -EINVAL;
2234
2235 if (frag_threshold != (u32) -1) {
2236 /*
2237 * Fragments (apart from the last one) are required to
2238 * have even length. Make the fragmentation code
2239 * simpler by stripping LSB should someone try to use
2240 * odd threshold value.
2241 */
2242 frag_threshold &= ~0x1;
2243 }
2244 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
2245 }
2246
2247 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
2248 rts_threshold = nla_get_u32(
2249 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
2250 changed |= WIPHY_PARAM_RTS_THRESHOLD;
2251 }
2252
2253 if (info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]) {
2254 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK])
2255 return -EINVAL;
2256
2257 coverage_class = nla_get_u8(
2258 info->attrs[NL80211_ATTR_WIPHY_COVERAGE_CLASS]);
2259 changed |= WIPHY_PARAM_COVERAGE_CLASS;
2260 }
2261
2262 if (info->attrs[NL80211_ATTR_WIPHY_DYN_ACK]) {
2263 if (!(rdev->wiphy.features & NL80211_FEATURE_ACKTO_ESTIMATION))
2264 return -EOPNOTSUPP;
2265
2266 changed |= WIPHY_PARAM_DYN_ACK;
2267 }
2268
2269 if (changed) {
2270 u8 old_retry_short, old_retry_long;
2271 u32 old_frag_threshold, old_rts_threshold;
2272 u8 old_coverage_class;
2273
2274 if (!rdev->ops->set_wiphy_params)
2275 return -EOPNOTSUPP;
2276
2277 old_retry_short = rdev->wiphy.retry_short;
2278 old_retry_long = rdev->wiphy.retry_long;
2279 old_frag_threshold = rdev->wiphy.frag_threshold;
2280 old_rts_threshold = rdev->wiphy.rts_threshold;
2281 old_coverage_class = rdev->wiphy.coverage_class;
2282
2283 if (changed & WIPHY_PARAM_RETRY_SHORT)
2284 rdev->wiphy.retry_short = retry_short;
2285 if (changed & WIPHY_PARAM_RETRY_LONG)
2286 rdev->wiphy.retry_long = retry_long;
2287 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
2288 rdev->wiphy.frag_threshold = frag_threshold;
2289 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
2290 rdev->wiphy.rts_threshold = rts_threshold;
2291 if (changed & WIPHY_PARAM_COVERAGE_CLASS)
2292 rdev->wiphy.coverage_class = coverage_class;
2293
2294 result = rdev_set_wiphy_params(rdev, changed);
2295 if (result) {
2296 rdev->wiphy.retry_short = old_retry_short;
2297 rdev->wiphy.retry_long = old_retry_long;
2298 rdev->wiphy.frag_threshold = old_frag_threshold;
2299 rdev->wiphy.rts_threshold = old_rts_threshold;
2300 rdev->wiphy.coverage_class = old_coverage_class;
2301 }
2302 }
2303 return 0;
2304 }
2305
2306 static inline u64 wdev_id(struct wireless_dev *wdev)
2307 {
2308 return (u64)wdev->identifier |
2309 ((u64)wiphy_to_rdev(wdev->wiphy)->wiphy_idx << 32);
2310 }
2311
2312 static int nl80211_send_chandef(struct sk_buff *msg,
2313 const struct cfg80211_chan_def *chandef)
2314 {
2315 WARN_ON(!cfg80211_chandef_valid(chandef));
2316
2317 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ,
2318 chandef->chan->center_freq))
2319 return -ENOBUFS;
2320 switch (chandef->width) {
2321 case NL80211_CHAN_WIDTH_20_NOHT:
2322 case NL80211_CHAN_WIDTH_20:
2323 case NL80211_CHAN_WIDTH_40:
2324 if (nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
2325 cfg80211_get_chandef_type(chandef)))
2326 return -ENOBUFS;
2327 break;
2328 default:
2329 break;
2330 }
2331 if (nla_put_u32(msg, NL80211_ATTR_CHANNEL_WIDTH, chandef->width))
2332 return -ENOBUFS;
2333 if (nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ1, chandef->center_freq1))
2334 return -ENOBUFS;
2335 if (chandef->center_freq2 &&
2336 nla_put_u32(msg, NL80211_ATTR_CENTER_FREQ2, chandef->center_freq2))
2337 return -ENOBUFS;
2338 return 0;
2339 }
2340
2341 static int nl80211_send_iface(struct sk_buff *msg, u32 portid, u32 seq, int flags,
2342 struct cfg80211_registered_device *rdev,
2343 struct wireless_dev *wdev)
2344 {
2345 struct net_device *dev = wdev->netdev;
2346 void *hdr;
2347
2348 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_INTERFACE);
2349 if (!hdr)
2350 return -1;
2351
2352 if (dev &&
2353 (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2354 nla_put_string(msg, NL80211_ATTR_IFNAME, dev->name)))
2355 goto nla_put_failure;
2356
2357 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
2358 nla_put_u32(msg, NL80211_ATTR_IFTYPE, wdev->iftype) ||
2359 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
2360 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, wdev_address(wdev)) ||
2361 nla_put_u32(msg, NL80211_ATTR_GENERATION,
2362 rdev->devlist_generation ^
2363 (cfg80211_rdev_list_generation << 2)))
2364 goto nla_put_failure;
2365
2366 if (rdev->ops->get_channel) {
2367 int ret;
2368 struct cfg80211_chan_def chandef;
2369
2370 ret = rdev_get_channel(rdev, wdev, &chandef);
2371 if (ret == 0) {
2372 if (nl80211_send_chandef(msg, &chandef))
2373 goto nla_put_failure;
2374 }
2375 }
2376
2377 if (wdev->ssid_len) {
2378 if (nla_put(msg, NL80211_ATTR_SSID, wdev->ssid_len, wdev->ssid))
2379 goto nla_put_failure;
2380 }
2381
2382 return genlmsg_end(msg, hdr);
2383
2384 nla_put_failure:
2385 genlmsg_cancel(msg, hdr);
2386 return -EMSGSIZE;
2387 }
2388
2389 static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
2390 {
2391 int wp_idx = 0;
2392 int if_idx = 0;
2393 int wp_start = cb->args[0];
2394 int if_start = cb->args[1];
2395 struct cfg80211_registered_device *rdev;
2396 struct wireless_dev *wdev;
2397
2398 rtnl_lock();
2399 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
2400 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
2401 continue;
2402 if (wp_idx < wp_start) {
2403 wp_idx++;
2404 continue;
2405 }
2406 if_idx = 0;
2407
2408 list_for_each_entry(wdev, &rdev->wdev_list, list) {
2409 if (if_idx < if_start) {
2410 if_idx++;
2411 continue;
2412 }
2413 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).portid,
2414 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2415 rdev, wdev) < 0) {
2416 goto out;
2417 }
2418 if_idx++;
2419 }
2420
2421 wp_idx++;
2422 }
2423 out:
2424 rtnl_unlock();
2425
2426 cb->args[0] = wp_idx;
2427 cb->args[1] = if_idx;
2428
2429 return skb->len;
2430 }
2431
2432 static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
2433 {
2434 struct sk_buff *msg;
2435 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2436 struct wireless_dev *wdev = info->user_ptr[1];
2437
2438 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2439 if (!msg)
2440 return -ENOMEM;
2441
2442 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
2443 rdev, wdev) < 0) {
2444 nlmsg_free(msg);
2445 return -ENOBUFS;
2446 }
2447
2448 return genlmsg_reply(msg, info);
2449 }
2450
2451 static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
2452 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
2453 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
2454 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
2455 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
2456 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
2457 [NL80211_MNTR_FLAG_ACTIVE] = { .type = NLA_FLAG },
2458 };
2459
2460 static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
2461 {
2462 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
2463 int flag;
2464
2465 *mntrflags = 0;
2466
2467 if (!nla)
2468 return -EINVAL;
2469
2470 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
2471 nla, mntr_flags_policy))
2472 return -EINVAL;
2473
2474 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
2475 if (flags[flag])
2476 *mntrflags |= (1<<flag);
2477
2478 return 0;
2479 }
2480
2481 static int nl80211_valid_4addr(struct cfg80211_registered_device *rdev,
2482 struct net_device *netdev, u8 use_4addr,
2483 enum nl80211_iftype iftype)
2484 {
2485 if (!use_4addr) {
2486 if (netdev && (netdev->priv_flags & IFF_BRIDGE_PORT))
2487 return -EBUSY;
2488 return 0;
2489 }
2490
2491 switch (iftype) {
2492 case NL80211_IFTYPE_AP_VLAN:
2493 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_AP)
2494 return 0;
2495 break;
2496 case NL80211_IFTYPE_STATION:
2497 if (rdev->wiphy.flags & WIPHY_FLAG_4ADDR_STATION)
2498 return 0;
2499 break;
2500 default:
2501 break;
2502 }
2503
2504 return -EOPNOTSUPP;
2505 }
2506
2507 static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
2508 {
2509 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2510 struct vif_params params;
2511 int err;
2512 enum nl80211_iftype otype, ntype;
2513 struct net_device *dev = info->user_ptr[1];
2514 u32 _flags, *flags = NULL;
2515 bool change = false;
2516
2517 memset(&params, 0, sizeof(params));
2518
2519 otype = ntype = dev->ieee80211_ptr->iftype;
2520
2521 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2522 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2523 if (otype != ntype)
2524 change = true;
2525 if (ntype > NL80211_IFTYPE_MAX)
2526 return -EINVAL;
2527 }
2528
2529 if (info->attrs[NL80211_ATTR_MESH_ID]) {
2530 struct wireless_dev *wdev = dev->ieee80211_ptr;
2531
2532 if (ntype != NL80211_IFTYPE_MESH_POINT)
2533 return -EINVAL;
2534 if (netif_running(dev))
2535 return -EBUSY;
2536
2537 wdev_lock(wdev);
2538 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2539 IEEE80211_MAX_MESH_ID_LEN);
2540 wdev->mesh_id_up_len =
2541 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2542 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2543 wdev->mesh_id_up_len);
2544 wdev_unlock(wdev);
2545 }
2546
2547 if (info->attrs[NL80211_ATTR_4ADDR]) {
2548 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2549 change = true;
2550 err = nl80211_valid_4addr(rdev, dev, params.use_4addr, ntype);
2551 if (err)
2552 return err;
2553 } else {
2554 params.use_4addr = -1;
2555 }
2556
2557 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
2558 if (ntype != NL80211_IFTYPE_MONITOR)
2559 return -EINVAL;
2560 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
2561 &_flags);
2562 if (err)
2563 return err;
2564
2565 flags = &_flags;
2566 change = true;
2567 }
2568
2569 if (flags && (*flags & MONITOR_FLAG_ACTIVE) &&
2570 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2571 return -EOPNOTSUPP;
2572
2573 if (change)
2574 err = cfg80211_change_iface(rdev, dev, ntype, flags, &params);
2575 else
2576 err = 0;
2577
2578 if (!err && params.use_4addr != -1)
2579 dev->ieee80211_ptr->use_4addr = params.use_4addr;
2580
2581 return err;
2582 }
2583
2584 static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
2585 {
2586 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2587 struct vif_params params;
2588 struct wireless_dev *wdev;
2589 struct sk_buff *msg;
2590 int err;
2591 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
2592 u32 flags;
2593
2594 /* to avoid failing a new interface creation due to pending removal */
2595 cfg80211_destroy_ifaces(rdev);
2596
2597 memset(&params, 0, sizeof(params));
2598
2599 if (!info->attrs[NL80211_ATTR_IFNAME])
2600 return -EINVAL;
2601
2602 if (info->attrs[NL80211_ATTR_IFTYPE]) {
2603 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
2604 if (type > NL80211_IFTYPE_MAX)
2605 return -EINVAL;
2606 }
2607
2608 if (!rdev->ops->add_virtual_intf ||
2609 !(rdev->wiphy.interface_modes & (1 << type)))
2610 return -EOPNOTSUPP;
2611
2612 if ((type == NL80211_IFTYPE_P2P_DEVICE ||
2613 rdev->wiphy.features & NL80211_FEATURE_MAC_ON_CREATE) &&
2614 info->attrs[NL80211_ATTR_MAC]) {
2615 nla_memcpy(params.macaddr, info->attrs[NL80211_ATTR_MAC],
2616 ETH_ALEN);
2617 if (!is_valid_ether_addr(params.macaddr))
2618 return -EADDRNOTAVAIL;
2619 }
2620
2621 if (info->attrs[NL80211_ATTR_4ADDR]) {
2622 params.use_4addr = !!nla_get_u8(info->attrs[NL80211_ATTR_4ADDR]);
2623 err = nl80211_valid_4addr(rdev, NULL, params.use_4addr, type);
2624 if (err)
2625 return err;
2626 }
2627
2628 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2629 if (!msg)
2630 return -ENOMEM;
2631
2632 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
2633 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
2634 &flags);
2635
2636 if (!err && (flags & MONITOR_FLAG_ACTIVE) &&
2637 !(rdev->wiphy.features & NL80211_FEATURE_ACTIVE_MONITOR))
2638 return -EOPNOTSUPP;
2639
2640 wdev = rdev_add_virtual_intf(rdev,
2641 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
2642 type, err ? NULL : &flags, &params);
2643 if (IS_ERR(wdev)) {
2644 nlmsg_free(msg);
2645 return PTR_ERR(wdev);
2646 }
2647
2648 if (info->attrs[NL80211_ATTR_IFACE_SOCKET_OWNER])
2649 wdev->owner_nlportid = info->snd_portid;
2650
2651 switch (type) {
2652 case NL80211_IFTYPE_MESH_POINT:
2653 if (!info->attrs[NL80211_ATTR_MESH_ID])
2654 break;
2655 wdev_lock(wdev);
2656 BUILD_BUG_ON(IEEE80211_MAX_SSID_LEN !=
2657 IEEE80211_MAX_MESH_ID_LEN);
2658 wdev->mesh_id_up_len =
2659 nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
2660 memcpy(wdev->ssid, nla_data(info->attrs[NL80211_ATTR_MESH_ID]),
2661 wdev->mesh_id_up_len);
2662 wdev_unlock(wdev);
2663 break;
2664 case NL80211_IFTYPE_P2P_DEVICE:
2665 /*
2666 * P2P Device doesn't have a netdev, so doesn't go
2667 * through the netdev notifier and must be added here
2668 */
2669 mutex_init(&wdev->mtx);
2670 INIT_LIST_HEAD(&wdev->event_list);
2671 spin_lock_init(&wdev->event_lock);
2672 INIT_LIST_HEAD(&wdev->mgmt_registrations);
2673 spin_lock_init(&wdev->mgmt_registrations_lock);
2674
2675 wdev->identifier = ++rdev->wdev_id;
2676 list_add_rcu(&wdev->list, &rdev->wdev_list);
2677 rdev->devlist_generation++;
2678 break;
2679 default:
2680 break;
2681 }
2682
2683 if (nl80211_send_iface(msg, info->snd_portid, info->snd_seq, 0,
2684 rdev, wdev) < 0) {
2685 nlmsg_free(msg);
2686 return -ENOBUFS;
2687 }
2688
2689 return genlmsg_reply(msg, info);
2690 }
2691
2692 static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
2693 {
2694 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2695 struct wireless_dev *wdev = info->user_ptr[1];
2696
2697 if (!rdev->ops->del_virtual_intf)
2698 return -EOPNOTSUPP;
2699
2700 /*
2701 * If we remove a wireless device without a netdev then clear
2702 * user_ptr[1] so that nl80211_post_doit won't dereference it
2703 * to check if it needs to do dev_put(). Otherwise it crashes
2704 * since the wdev has been freed, unlike with a netdev where
2705 * we need the dev_put() for the netdev to really be freed.
2706 */
2707 if (!wdev->netdev)
2708 info->user_ptr[1] = NULL;
2709
2710 return rdev_del_virtual_intf(rdev, wdev);
2711 }
2712
2713 static int nl80211_set_noack_map(struct sk_buff *skb, struct genl_info *info)
2714 {
2715 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2716 struct net_device *dev = info->user_ptr[1];
2717 u16 noack_map;
2718
2719 if (!info->attrs[NL80211_ATTR_NOACK_MAP])
2720 return -EINVAL;
2721
2722 if (!rdev->ops->set_noack_map)
2723 return -EOPNOTSUPP;
2724
2725 noack_map = nla_get_u16(info->attrs[NL80211_ATTR_NOACK_MAP]);
2726
2727 return rdev_set_noack_map(rdev, dev, noack_map);
2728 }
2729
2730 struct get_key_cookie {
2731 struct sk_buff *msg;
2732 int error;
2733 int idx;
2734 };
2735
2736 static void get_key_callback(void *c, struct key_params *params)
2737 {
2738 struct nlattr *key;
2739 struct get_key_cookie *cookie = c;
2740
2741 if ((params->key &&
2742 nla_put(cookie->msg, NL80211_ATTR_KEY_DATA,
2743 params->key_len, params->key)) ||
2744 (params->seq &&
2745 nla_put(cookie->msg, NL80211_ATTR_KEY_SEQ,
2746 params->seq_len, params->seq)) ||
2747 (params->cipher &&
2748 nla_put_u32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
2749 params->cipher)))
2750 goto nla_put_failure;
2751
2752 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
2753 if (!key)
2754 goto nla_put_failure;
2755
2756 if ((params->key &&
2757 nla_put(cookie->msg, NL80211_KEY_DATA,
2758 params->key_len, params->key)) ||
2759 (params->seq &&
2760 nla_put(cookie->msg, NL80211_KEY_SEQ,
2761 params->seq_len, params->seq)) ||
2762 (params->cipher &&
2763 nla_put_u32(cookie->msg, NL80211_KEY_CIPHER,
2764 params->cipher)))
2765 goto nla_put_failure;
2766
2767 if (nla_put_u8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx))
2768 goto nla_put_failure;
2769
2770 nla_nest_end(cookie->msg, key);
2771
2772 return;
2773 nla_put_failure:
2774 cookie->error = 1;
2775 }
2776
2777 static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
2778 {
2779 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2780 int err;
2781 struct net_device *dev = info->user_ptr[1];
2782 u8 key_idx = 0;
2783 const u8 *mac_addr = NULL;
2784 bool pairwise;
2785 struct get_key_cookie cookie = {
2786 .error = 0,
2787 };
2788 void *hdr;
2789 struct sk_buff *msg;
2790
2791 if (info->attrs[NL80211_ATTR_KEY_IDX])
2792 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
2793
2794 if (key_idx > 5)
2795 return -EINVAL;
2796
2797 if (info->attrs[NL80211_ATTR_MAC])
2798 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2799
2800 pairwise = !!mac_addr;
2801 if (info->attrs[NL80211_ATTR_KEY_TYPE]) {
2802 u32 kt = nla_get_u32(info->attrs[NL80211_ATTR_KEY_TYPE]);
2803 if (kt >= NUM_NL80211_KEYTYPES)
2804 return -EINVAL;
2805 if (kt != NL80211_KEYTYPE_GROUP &&
2806 kt != NL80211_KEYTYPE_PAIRWISE)
2807 return -EINVAL;
2808 pairwise = kt == NL80211_KEYTYPE_PAIRWISE;
2809 }
2810
2811 if (!rdev->ops->get_key)
2812 return -EOPNOTSUPP;
2813
2814 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2815 if (!msg)
2816 return -ENOMEM;
2817
2818 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
2819 NL80211_CMD_NEW_KEY);
2820 if (!hdr)
2821 goto nla_put_failure;
2822
2823 cookie.msg = msg;
2824 cookie.idx = key_idx;
2825
2826 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
2827 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_idx))
2828 goto nla_put_failure;
2829 if (mac_addr &&
2830 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
2831 goto nla_put_failure;
2832
2833 if (pairwise && mac_addr &&
2834 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
2835 return -ENOENT;
2836
2837 err = rdev_get_key(rdev, dev, key_idx, pairwise, mac_addr, &cookie,
2838 get_key_callback);
2839
2840 if (err)
2841 goto free_msg;
2842
2843 if (cookie.error)
2844 goto nla_put_failure;
2845
2846 genlmsg_end(msg, hdr);
2847 return genlmsg_reply(msg, info);
2848
2849 nla_put_failure:
2850 err = -ENOBUFS;
2851 free_msg:
2852 nlmsg_free(msg);
2853 return err;
2854 }
2855
2856 static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
2857 {
2858 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2859 struct key_parse key;
2860 int err;
2861 struct net_device *dev = info->user_ptr[1];
2862
2863 err = nl80211_parse_key(info, &key);
2864 if (err)
2865 return err;
2866
2867 if (key.idx < 0)
2868 return -EINVAL;
2869
2870 /* only support setting default key */
2871 if (!key.def && !key.defmgmt)
2872 return -EINVAL;
2873
2874 wdev_lock(dev->ieee80211_ptr);
2875
2876 if (key.def) {
2877 if (!rdev->ops->set_default_key) {
2878 err = -EOPNOTSUPP;
2879 goto out;
2880 }
2881
2882 err = nl80211_key_allowed(dev->ieee80211_ptr);
2883 if (err)
2884 goto out;
2885
2886 err = rdev_set_default_key(rdev, dev, key.idx,
2887 key.def_uni, key.def_multi);
2888
2889 if (err)
2890 goto out;
2891
2892 #ifdef CONFIG_CFG80211_WEXT
2893 dev->ieee80211_ptr->wext.default_key = key.idx;
2894 #endif
2895 } else {
2896 if (key.def_uni || !key.def_multi) {
2897 err = -EINVAL;
2898 goto out;
2899 }
2900
2901 if (!rdev->ops->set_default_mgmt_key) {
2902 err = -EOPNOTSUPP;
2903 goto out;
2904 }
2905
2906 err = nl80211_key_allowed(dev->ieee80211_ptr);
2907 if (err)
2908 goto out;
2909
2910 err = rdev_set_default_mgmt_key(rdev, dev, key.idx);
2911 if (err)
2912 goto out;
2913
2914 #ifdef CONFIG_CFG80211_WEXT
2915 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
2916 #endif
2917 }
2918
2919 out:
2920 wdev_unlock(dev->ieee80211_ptr);
2921
2922 return err;
2923 }
2924
2925 static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
2926 {
2927 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2928 int err;
2929 struct net_device *dev = info->user_ptr[1];
2930 struct key_parse key;
2931 const u8 *mac_addr = NULL;
2932
2933 err = nl80211_parse_key(info, &key);
2934 if (err)
2935 return err;
2936
2937 if (!key.p.key)
2938 return -EINVAL;
2939
2940 if (info->attrs[NL80211_ATTR_MAC])
2941 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2942
2943 if (key.type == -1) {
2944 if (mac_addr)
2945 key.type = NL80211_KEYTYPE_PAIRWISE;
2946 else
2947 key.type = NL80211_KEYTYPE_GROUP;
2948 }
2949
2950 /* for now */
2951 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2952 key.type != NL80211_KEYTYPE_GROUP)
2953 return -EINVAL;
2954
2955 if (!rdev->ops->add_key)
2956 return -EOPNOTSUPP;
2957
2958 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx,
2959 key.type == NL80211_KEYTYPE_PAIRWISE,
2960 mac_addr))
2961 return -EINVAL;
2962
2963 wdev_lock(dev->ieee80211_ptr);
2964 err = nl80211_key_allowed(dev->ieee80211_ptr);
2965 if (!err)
2966 err = rdev_add_key(rdev, dev, key.idx,
2967 key.type == NL80211_KEYTYPE_PAIRWISE,
2968 mac_addr, &key.p);
2969 wdev_unlock(dev->ieee80211_ptr);
2970
2971 return err;
2972 }
2973
2974 static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
2975 {
2976 struct cfg80211_registered_device *rdev = info->user_ptr[0];
2977 int err;
2978 struct net_device *dev = info->user_ptr[1];
2979 u8 *mac_addr = NULL;
2980 struct key_parse key;
2981
2982 err = nl80211_parse_key(info, &key);
2983 if (err)
2984 return err;
2985
2986 if (info->attrs[NL80211_ATTR_MAC])
2987 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2988
2989 if (key.type == -1) {
2990 if (mac_addr)
2991 key.type = NL80211_KEYTYPE_PAIRWISE;
2992 else
2993 key.type = NL80211_KEYTYPE_GROUP;
2994 }
2995
2996 /* for now */
2997 if (key.type != NL80211_KEYTYPE_PAIRWISE &&
2998 key.type != NL80211_KEYTYPE_GROUP)
2999 return -EINVAL;
3000
3001 if (!rdev->ops->del_key)
3002 return -EOPNOTSUPP;
3003
3004 wdev_lock(dev->ieee80211_ptr);
3005 err = nl80211_key_allowed(dev->ieee80211_ptr);
3006
3007 if (key.type == NL80211_KEYTYPE_PAIRWISE && mac_addr &&
3008 !(rdev->wiphy.flags & WIPHY_FLAG_IBSS_RSN))
3009 err = -ENOENT;
3010
3011 if (!err)
3012 err = rdev_del_key(rdev, dev, key.idx,
3013 key.type == NL80211_KEYTYPE_PAIRWISE,
3014 mac_addr);
3015
3016 #ifdef CONFIG_CFG80211_WEXT
3017 if (!err) {
3018 if (key.idx == dev->ieee80211_ptr->wext.default_key)
3019 dev->ieee80211_ptr->wext.default_key = -1;
3020 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
3021 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
3022 }
3023 #endif
3024 wdev_unlock(dev->ieee80211_ptr);
3025
3026 return err;
3027 }
3028
3029 /* This function returns an error or the number of nested attributes */
3030 static int validate_acl_mac_addrs(struct nlattr *nl_attr)
3031 {
3032 struct nlattr *attr;
3033 int n_entries = 0, tmp;
3034
3035 nla_for_each_nested(attr, nl_attr, tmp) {
3036 if (nla_len(attr) != ETH_ALEN)
3037 return -EINVAL;
3038
3039 n_entries++;
3040 }
3041
3042 return n_entries;
3043 }
3044
3045 /*
3046 * This function parses ACL information and allocates memory for ACL data.
3047 * On successful return, the calling function is responsible to free the
3048 * ACL buffer returned by this function.
3049 */
3050 static struct cfg80211_acl_data *parse_acl_data(struct wiphy *wiphy,
3051 struct genl_info *info)
3052 {
3053 enum nl80211_acl_policy acl_policy;
3054 struct nlattr *attr;
3055 struct cfg80211_acl_data *acl;
3056 int i = 0, n_entries, tmp;
3057
3058 if (!wiphy->max_acl_mac_addrs)
3059 return ERR_PTR(-EOPNOTSUPP);
3060
3061 if (!info->attrs[NL80211_ATTR_ACL_POLICY])
3062 return ERR_PTR(-EINVAL);
3063
3064 acl_policy = nla_get_u32(info->attrs[NL80211_ATTR_ACL_POLICY]);
3065 if (acl_policy != NL80211_ACL_POLICY_ACCEPT_UNLESS_LISTED &&
3066 acl_policy != NL80211_ACL_POLICY_DENY_UNLESS_LISTED)
3067 return ERR_PTR(-EINVAL);
3068
3069 if (!info->attrs[NL80211_ATTR_MAC_ADDRS])
3070 return ERR_PTR(-EINVAL);
3071
3072 n_entries = validate_acl_mac_addrs(info->attrs[NL80211_ATTR_MAC_ADDRS]);
3073 if (n_entries < 0)
3074 return ERR_PTR(n_entries);
3075
3076 if (n_entries > wiphy->max_acl_mac_addrs)
3077 return ERR_PTR(-ENOTSUPP);
3078
3079 acl = kzalloc(sizeof(*acl) + (sizeof(struct mac_address) * n_entries),
3080 GFP_KERNEL);
3081 if (!acl)
3082 return ERR_PTR(-ENOMEM);
3083
3084 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_MAC_ADDRS], tmp) {
3085 memcpy(acl->mac_addrs[i].addr, nla_data(attr), ETH_ALEN);
3086 i++;
3087 }
3088
3089 acl->n_acl_entries = n_entries;
3090 acl->acl_policy = acl_policy;
3091
3092 return acl;
3093 }
3094
3095 static int nl80211_set_mac_acl(struct sk_buff *skb, struct genl_info *info)
3096 {
3097 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3098 struct net_device *dev = info->user_ptr[1];
3099 struct cfg80211_acl_data *acl;
3100 int err;
3101
3102 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3103 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3104 return -EOPNOTSUPP;
3105
3106 if (!dev->ieee80211_ptr->beacon_interval)
3107 return -EINVAL;
3108
3109 acl = parse_acl_data(&rdev->wiphy, info);
3110 if (IS_ERR(acl))
3111 return PTR_ERR(acl);
3112
3113 err = rdev_set_mac_acl(rdev, dev, acl);
3114
3115 kfree(acl);
3116
3117 return err;
3118 }
3119
3120 static int nl80211_parse_beacon(struct nlattr *attrs[],
3121 struct cfg80211_beacon_data *bcn)
3122 {
3123 bool haveinfo = false;
3124
3125 if (!is_valid_ie_attr(attrs[NL80211_ATTR_BEACON_TAIL]) ||
3126 !is_valid_ie_attr(attrs[NL80211_ATTR_IE]) ||
3127 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_PROBE_RESP]) ||
3128 !is_valid_ie_attr(attrs[NL80211_ATTR_IE_ASSOC_RESP]))
3129 return -EINVAL;
3130
3131 memset(bcn, 0, sizeof(*bcn));
3132
3133 if (attrs[NL80211_ATTR_BEACON_HEAD]) {
3134 bcn->head = nla_data(attrs[NL80211_ATTR_BEACON_HEAD]);
3135 bcn->head_len = nla_len(attrs[NL80211_ATTR_BEACON_HEAD]);
3136 if (!bcn->head_len)
3137 return -EINVAL;
3138 haveinfo = true;
3139 }
3140
3141 if (attrs[NL80211_ATTR_BEACON_TAIL]) {
3142 bcn->tail = nla_data(attrs[NL80211_ATTR_BEACON_TAIL]);
3143 bcn->tail_len = nla_len(attrs[NL80211_ATTR_BEACON_TAIL]);
3144 haveinfo = true;
3145 }
3146
3147 if (!haveinfo)
3148 return -EINVAL;
3149
3150 if (attrs[NL80211_ATTR_IE]) {
3151 bcn->beacon_ies = nla_data(attrs[NL80211_ATTR_IE]);
3152 bcn->beacon_ies_len = nla_len(attrs[NL80211_ATTR_IE]);
3153 }
3154
3155 if (attrs[NL80211_ATTR_IE_PROBE_RESP]) {
3156 bcn->proberesp_ies =
3157 nla_data(attrs[NL80211_ATTR_IE_PROBE_RESP]);
3158 bcn->proberesp_ies_len =
3159 nla_len(attrs[NL80211_ATTR_IE_PROBE_RESP]);
3160 }
3161
3162 if (attrs[NL80211_ATTR_IE_ASSOC_RESP]) {
3163 bcn->assocresp_ies =
3164 nla_data(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
3165 bcn->assocresp_ies_len =
3166 nla_len(attrs[NL80211_ATTR_IE_ASSOC_RESP]);
3167 }
3168
3169 if (attrs[NL80211_ATTR_PROBE_RESP]) {
3170 bcn->probe_resp = nla_data(attrs[NL80211_ATTR_PROBE_RESP]);
3171 bcn->probe_resp_len = nla_len(attrs[NL80211_ATTR_PROBE_RESP]);
3172 }
3173
3174 return 0;
3175 }
3176
3177 static bool nl80211_get_ap_channel(struct cfg80211_registered_device *rdev,
3178 struct cfg80211_ap_settings *params)
3179 {
3180 struct wireless_dev *wdev;
3181 bool ret = false;
3182
3183 list_for_each_entry(wdev, &rdev->wdev_list, list) {
3184 if (wdev->iftype != NL80211_IFTYPE_AP &&
3185 wdev->iftype != NL80211_IFTYPE_P2P_GO)
3186 continue;
3187
3188 if (!wdev->preset_chandef.chan)
3189 continue;
3190
3191 params->chandef = wdev->preset_chandef;
3192 ret = true;
3193 break;
3194 }
3195
3196 return ret;
3197 }
3198
3199 static bool nl80211_valid_auth_type(struct cfg80211_registered_device *rdev,
3200 enum nl80211_auth_type auth_type,
3201 enum nl80211_commands cmd)
3202 {
3203 if (auth_type > NL80211_AUTHTYPE_MAX)
3204 return false;
3205
3206 switch (cmd) {
3207 case NL80211_CMD_AUTHENTICATE:
3208 if (!(rdev->wiphy.features & NL80211_FEATURE_SAE) &&
3209 auth_type == NL80211_AUTHTYPE_SAE)
3210 return false;
3211 return true;
3212 case NL80211_CMD_CONNECT:
3213 case NL80211_CMD_START_AP:
3214 /* SAE not supported yet */
3215 if (auth_type == NL80211_AUTHTYPE_SAE)
3216 return false;
3217 return true;
3218 default:
3219 return false;
3220 }
3221 }
3222
3223 static int nl80211_start_ap(struct sk_buff *skb, struct genl_info *info)
3224 {
3225 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3226 struct net_device *dev = info->user_ptr[1];
3227 struct wireless_dev *wdev = dev->ieee80211_ptr;
3228 struct cfg80211_ap_settings params;
3229 int err;
3230
3231 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3232 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3233 return -EOPNOTSUPP;
3234
3235 if (!rdev->ops->start_ap)
3236 return -EOPNOTSUPP;
3237
3238 if (wdev->beacon_interval)
3239 return -EALREADY;
3240
3241 memset(&params, 0, sizeof(params));
3242
3243 /* these are required for START_AP */
3244 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
3245 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
3246 !info->attrs[NL80211_ATTR_BEACON_HEAD])
3247 return -EINVAL;
3248
3249 err = nl80211_parse_beacon(info->attrs, &params.beacon);
3250 if (err)
3251 return err;
3252
3253 params.beacon_interval =
3254 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3255 params.dtim_period =
3256 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
3257
3258 err = cfg80211_validate_beacon_int(rdev, params.beacon_interval);
3259 if (err)
3260 return err;
3261
3262 /*
3263 * In theory, some of these attributes should be required here
3264 * but since they were not used when the command was originally
3265 * added, keep them optional for old user space programs to let
3266 * them continue to work with drivers that do not need the
3267 * additional information -- drivers must check!
3268 */
3269 if (info->attrs[NL80211_ATTR_SSID]) {
3270 params.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3271 params.ssid_len =
3272 nla_len(info->attrs[NL80211_ATTR_SSID]);
3273 if (params.ssid_len == 0 ||
3274 params.ssid_len > IEEE80211_MAX_SSID_LEN)
3275 return -EINVAL;
3276 }
3277
3278 if (info->attrs[NL80211_ATTR_HIDDEN_SSID]) {
3279 params.hidden_ssid = nla_get_u32(
3280 info->attrs[NL80211_ATTR_HIDDEN_SSID]);
3281 if (params.hidden_ssid != NL80211_HIDDEN_SSID_NOT_IN_USE &&
3282 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_LEN &&
3283 params.hidden_ssid != NL80211_HIDDEN_SSID_ZERO_CONTENTS)
3284 return -EINVAL;
3285 }
3286
3287 params.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3288
3289 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3290 params.auth_type = nla_get_u32(
3291 info->attrs[NL80211_ATTR_AUTH_TYPE]);
3292 if (!nl80211_valid_auth_type(rdev, params.auth_type,
3293 NL80211_CMD_START_AP))
3294 return -EINVAL;
3295 } else
3296 params.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3297
3298 err = nl80211_crypto_settings(rdev, info, &params.crypto,
3299 NL80211_MAX_NR_CIPHER_SUITES);
3300 if (err)
3301 return err;
3302
3303 if (info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]) {
3304 if (!(rdev->wiphy.features & NL80211_FEATURE_INACTIVITY_TIMER))
3305 return -EOPNOTSUPP;
3306 params.inactivity_timeout = nla_get_u16(
3307 info->attrs[NL80211_ATTR_INACTIVITY_TIMEOUT]);
3308 }
3309
3310 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
3311 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3312 return -EINVAL;
3313 params.p2p_ctwindow =
3314 nla_get_u8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
3315 if (params.p2p_ctwindow > 127)
3316 return -EINVAL;
3317 if (params.p2p_ctwindow != 0 &&
3318 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
3319 return -EINVAL;
3320 }
3321
3322 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
3323 u8 tmp;
3324
3325 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3326 return -EINVAL;
3327 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
3328 if (tmp > 1)
3329 return -EINVAL;
3330 params.p2p_opp_ps = tmp;
3331 if (params.p2p_opp_ps != 0 &&
3332 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
3333 return -EINVAL;
3334 }
3335
3336 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3337 err = nl80211_parse_chandef(rdev, info, &params.chandef);
3338 if (err)
3339 return err;
3340 } else if (wdev->preset_chandef.chan) {
3341 params.chandef = wdev->preset_chandef;
3342 } else if (!nl80211_get_ap_channel(rdev, &params))
3343 return -EINVAL;
3344
3345 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef,
3346 wdev->iftype))
3347 return -EINVAL;
3348
3349 if (info->attrs[NL80211_ATTR_ACL_POLICY]) {
3350 params.acl = parse_acl_data(&rdev->wiphy, info);
3351 if (IS_ERR(params.acl))
3352 return PTR_ERR(params.acl);
3353 }
3354
3355 if (info->attrs[NL80211_ATTR_SMPS_MODE]) {
3356 params.smps_mode =
3357 nla_get_u8(info->attrs[NL80211_ATTR_SMPS_MODE]);
3358 switch (params.smps_mode) {
3359 case NL80211_SMPS_OFF:
3360 break;
3361 case NL80211_SMPS_STATIC:
3362 if (!(rdev->wiphy.features &
3363 NL80211_FEATURE_STATIC_SMPS))
3364 return -EINVAL;
3365 break;
3366 case NL80211_SMPS_DYNAMIC:
3367 if (!(rdev->wiphy.features &
3368 NL80211_FEATURE_DYNAMIC_SMPS))
3369 return -EINVAL;
3370 break;
3371 default:
3372 return -EINVAL;
3373 }
3374 } else {
3375 params.smps_mode = NL80211_SMPS_OFF;
3376 }
3377
3378 wdev_lock(wdev);
3379 err = rdev_start_ap(rdev, dev, &params);
3380 if (!err) {
3381 wdev->preset_chandef = params.chandef;
3382 wdev->beacon_interval = params.beacon_interval;
3383 wdev->chandef = params.chandef;
3384 wdev->ssid_len = params.ssid_len;
3385 memcpy(wdev->ssid, params.ssid, wdev->ssid_len);
3386 }
3387 wdev_unlock(wdev);
3388
3389 kfree(params.acl);
3390
3391 return err;
3392 }
3393
3394 static int nl80211_set_beacon(struct sk_buff *skb, struct genl_info *info)
3395 {
3396 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3397 struct net_device *dev = info->user_ptr[1];
3398 struct wireless_dev *wdev = dev->ieee80211_ptr;
3399 struct cfg80211_beacon_data params;
3400 int err;
3401
3402 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
3403 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
3404 return -EOPNOTSUPP;
3405
3406 if (!rdev->ops->change_beacon)
3407 return -EOPNOTSUPP;
3408
3409 if (!wdev->beacon_interval)
3410 return -EINVAL;
3411
3412 err = nl80211_parse_beacon(info->attrs, &params);
3413 if (err)
3414 return err;
3415
3416 wdev_lock(wdev);
3417 err = rdev_change_beacon(rdev, dev, &params);
3418 wdev_unlock(wdev);
3419
3420 return err;
3421 }
3422
3423 static int nl80211_stop_ap(struct sk_buff *skb, struct genl_info *info)
3424 {
3425 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3426 struct net_device *dev = info->user_ptr[1];
3427
3428 return cfg80211_stop_ap(rdev, dev, false);
3429 }
3430
3431 static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
3432 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
3433 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
3434 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
3435 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
3436 [NL80211_STA_FLAG_AUTHENTICATED] = { .type = NLA_FLAG },
3437 [NL80211_STA_FLAG_TDLS_PEER] = { .type = NLA_FLAG },
3438 };
3439
3440 static int parse_station_flags(struct genl_info *info,
3441 enum nl80211_iftype iftype,
3442 struct station_parameters *params)
3443 {
3444 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
3445 struct nlattr *nla;
3446 int flag;
3447
3448 /*
3449 * Try parsing the new attribute first so userspace
3450 * can specify both for older kernels.
3451 */
3452 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
3453 if (nla) {
3454 struct nl80211_sta_flag_update *sta_flags;
3455
3456 sta_flags = nla_data(nla);
3457 params->sta_flags_mask = sta_flags->mask;
3458 params->sta_flags_set = sta_flags->set;
3459 params->sta_flags_set &= params->sta_flags_mask;
3460 if ((params->sta_flags_mask |
3461 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
3462 return -EINVAL;
3463 return 0;
3464 }
3465
3466 /* if present, parse the old attribute */
3467
3468 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
3469 if (!nla)
3470 return 0;
3471
3472 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
3473 nla, sta_flags_policy))
3474 return -EINVAL;
3475
3476 /*
3477 * Only allow certain flags for interface types so that
3478 * other attributes are silently ignored. Remember that
3479 * this is backward compatibility code with old userspace
3480 * and shouldn't be hit in other cases anyway.
3481 */
3482 switch (iftype) {
3483 case NL80211_IFTYPE_AP:
3484 case NL80211_IFTYPE_AP_VLAN:
3485 case NL80211_IFTYPE_P2P_GO:
3486 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3487 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3488 BIT(NL80211_STA_FLAG_WME) |
3489 BIT(NL80211_STA_FLAG_MFP);
3490 break;
3491 case NL80211_IFTYPE_P2P_CLIENT:
3492 case NL80211_IFTYPE_STATION:
3493 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHORIZED) |
3494 BIT(NL80211_STA_FLAG_TDLS_PEER);
3495 break;
3496 case NL80211_IFTYPE_MESH_POINT:
3497 params->sta_flags_mask = BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3498 BIT(NL80211_STA_FLAG_MFP) |
3499 BIT(NL80211_STA_FLAG_AUTHORIZED);
3500 default:
3501 return -EINVAL;
3502 }
3503
3504 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++) {
3505 if (flags[flag]) {
3506 params->sta_flags_set |= (1<<flag);
3507
3508 /* no longer support new API additions in old API */
3509 if (flag > NL80211_STA_FLAG_MAX_OLD_API)
3510 return -EINVAL;
3511 }
3512 }
3513
3514 return 0;
3515 }
3516
3517 static bool nl80211_put_sta_rate(struct sk_buff *msg, struct rate_info *info,
3518 int attr)
3519 {
3520 struct nlattr *rate;
3521 u32 bitrate;
3522 u16 bitrate_compat;
3523
3524 rate = nla_nest_start(msg, attr);
3525 if (!rate)
3526 return false;
3527
3528 /* cfg80211_calculate_bitrate will return 0 for mcs >= 32 */
3529 bitrate = cfg80211_calculate_bitrate(info);
3530 /* report 16-bit bitrate only if we can */
3531 bitrate_compat = bitrate < (1UL << 16) ? bitrate : 0;
3532 if (bitrate > 0 &&
3533 nla_put_u32(msg, NL80211_RATE_INFO_BITRATE32, bitrate))
3534 return false;
3535 if (bitrate_compat > 0 &&
3536 nla_put_u16(msg, NL80211_RATE_INFO_BITRATE, bitrate_compat))
3537 return false;
3538
3539 if (info->flags & RATE_INFO_FLAGS_MCS) {
3540 if (nla_put_u8(msg, NL80211_RATE_INFO_MCS, info->mcs))
3541 return false;
3542 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3543 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3544 return false;
3545 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3546 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3547 return false;
3548 } else if (info->flags & RATE_INFO_FLAGS_VHT_MCS) {
3549 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_MCS, info->mcs))
3550 return false;
3551 if (nla_put_u8(msg, NL80211_RATE_INFO_VHT_NSS, info->nss))
3552 return false;
3553 if (info->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH &&
3554 nla_put_flag(msg, NL80211_RATE_INFO_40_MHZ_WIDTH))
3555 return false;
3556 if (info->flags & RATE_INFO_FLAGS_80_MHZ_WIDTH &&
3557 nla_put_flag(msg, NL80211_RATE_INFO_80_MHZ_WIDTH))
3558 return false;
3559 if (info->flags & RATE_INFO_FLAGS_80P80_MHZ_WIDTH &&
3560 nla_put_flag(msg, NL80211_RATE_INFO_80P80_MHZ_WIDTH))
3561 return false;
3562 if (info->flags & RATE_INFO_FLAGS_160_MHZ_WIDTH &&
3563 nla_put_flag(msg, NL80211_RATE_INFO_160_MHZ_WIDTH))
3564 return false;
3565 if (info->flags & RATE_INFO_FLAGS_SHORT_GI &&
3566 nla_put_flag(msg, NL80211_RATE_INFO_SHORT_GI))
3567 return false;
3568 }
3569
3570 nla_nest_end(msg, rate);
3571 return true;
3572 }
3573
3574 static bool nl80211_put_signal(struct sk_buff *msg, u8 mask, s8 *signal,
3575 int id)
3576 {
3577 void *attr;
3578 int i = 0;
3579
3580 if (!mask)
3581 return true;
3582
3583 attr = nla_nest_start(msg, id);
3584 if (!attr)
3585 return false;
3586
3587 for (i = 0; i < IEEE80211_MAX_CHAINS; i++) {
3588 if (!(mask & BIT(i)))
3589 continue;
3590
3591 if (nla_put_u8(msg, i, signal[i]))
3592 return false;
3593 }
3594
3595 nla_nest_end(msg, attr);
3596
3597 return true;
3598 }
3599
3600 static int nl80211_send_station(struct sk_buff *msg, u32 portid, u32 seq,
3601 int flags,
3602 struct cfg80211_registered_device *rdev,
3603 struct net_device *dev,
3604 const u8 *mac_addr, struct station_info *sinfo)
3605 {
3606 void *hdr;
3607 struct nlattr *sinfoattr, *bss_param;
3608
3609 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
3610 if (!hdr)
3611 return -1;
3612
3613 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
3614 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
3615 nla_put_u32(msg, NL80211_ATTR_GENERATION, sinfo->generation))
3616 goto nla_put_failure;
3617
3618 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
3619 if (!sinfoattr)
3620 goto nla_put_failure;
3621 if ((sinfo->filled & STATION_INFO_CONNECTED_TIME) &&
3622 nla_put_u32(msg, NL80211_STA_INFO_CONNECTED_TIME,
3623 sinfo->connected_time))
3624 goto nla_put_failure;
3625 if ((sinfo->filled & STATION_INFO_INACTIVE_TIME) &&
3626 nla_put_u32(msg, NL80211_STA_INFO_INACTIVE_TIME,
3627 sinfo->inactive_time))
3628 goto nla_put_failure;
3629 if ((sinfo->filled & (STATION_INFO_RX_BYTES |
3630 STATION_INFO_RX_BYTES64)) &&
3631 nla_put_u32(msg, NL80211_STA_INFO_RX_BYTES,
3632 (u32)sinfo->rx_bytes))
3633 goto nla_put_failure;
3634 if ((sinfo->filled & (STATION_INFO_TX_BYTES |
3635 STATION_INFO_TX_BYTES64)) &&
3636 nla_put_u32(msg, NL80211_STA_INFO_TX_BYTES,
3637 (u32)sinfo->tx_bytes))
3638 goto nla_put_failure;
3639 if ((sinfo->filled & STATION_INFO_RX_BYTES64) &&
3640 nla_put_u64(msg, NL80211_STA_INFO_RX_BYTES64,
3641 sinfo->rx_bytes))
3642 goto nla_put_failure;
3643 if ((sinfo->filled & STATION_INFO_TX_BYTES64) &&
3644 nla_put_u64(msg, NL80211_STA_INFO_TX_BYTES64,
3645 sinfo->tx_bytes))
3646 goto nla_put_failure;
3647 if ((sinfo->filled & STATION_INFO_LLID) &&
3648 nla_put_u16(msg, NL80211_STA_INFO_LLID, sinfo->llid))
3649 goto nla_put_failure;
3650 if ((sinfo->filled & STATION_INFO_PLID) &&
3651 nla_put_u16(msg, NL80211_STA_INFO_PLID, sinfo->plid))
3652 goto nla_put_failure;
3653 if ((sinfo->filled & STATION_INFO_PLINK_STATE) &&
3654 nla_put_u8(msg, NL80211_STA_INFO_PLINK_STATE,
3655 sinfo->plink_state))
3656 goto nla_put_failure;
3657 switch (rdev->wiphy.signal_type) {
3658 case CFG80211_SIGNAL_TYPE_MBM:
3659 if ((sinfo->filled & STATION_INFO_SIGNAL) &&
3660 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL,
3661 sinfo->signal))
3662 goto nla_put_failure;
3663 if ((sinfo->filled & STATION_INFO_SIGNAL_AVG) &&
3664 nla_put_u8(msg, NL80211_STA_INFO_SIGNAL_AVG,
3665 sinfo->signal_avg))
3666 goto nla_put_failure;
3667 break;
3668 default:
3669 break;
3670 }
3671 if (sinfo->filled & STATION_INFO_CHAIN_SIGNAL) {
3672 if (!nl80211_put_signal(msg, sinfo->chains,
3673 sinfo->chain_signal,
3674 NL80211_STA_INFO_CHAIN_SIGNAL))
3675 goto nla_put_failure;
3676 }
3677 if (sinfo->filled & STATION_INFO_CHAIN_SIGNAL_AVG) {
3678 if (!nl80211_put_signal(msg, sinfo->chains,
3679 sinfo->chain_signal_avg,
3680 NL80211_STA_INFO_CHAIN_SIGNAL_AVG))
3681 goto nla_put_failure;
3682 }
3683 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
3684 if (!nl80211_put_sta_rate(msg, &sinfo->txrate,
3685 NL80211_STA_INFO_TX_BITRATE))
3686 goto nla_put_failure;
3687 }
3688 if (sinfo->filled & STATION_INFO_RX_BITRATE) {
3689 if (!nl80211_put_sta_rate(msg, &sinfo->rxrate,
3690 NL80211_STA_INFO_RX_BITRATE))
3691 goto nla_put_failure;
3692 }
3693 if ((sinfo->filled & STATION_INFO_RX_PACKETS) &&
3694 nla_put_u32(msg, NL80211_STA_INFO_RX_PACKETS,
3695 sinfo->rx_packets))
3696 goto nla_put_failure;
3697 if ((sinfo->filled & STATION_INFO_TX_PACKETS) &&
3698 nla_put_u32(msg, NL80211_STA_INFO_TX_PACKETS,
3699 sinfo->tx_packets))
3700 goto nla_put_failure;
3701 if ((sinfo->filled & STATION_INFO_TX_RETRIES) &&
3702 nla_put_u32(msg, NL80211_STA_INFO_TX_RETRIES,
3703 sinfo->tx_retries))
3704 goto nla_put_failure;
3705 if ((sinfo->filled & STATION_INFO_TX_FAILED) &&
3706 nla_put_u32(msg, NL80211_STA_INFO_TX_FAILED,
3707 sinfo->tx_failed))
3708 goto nla_put_failure;
3709 if ((sinfo->filled & STATION_INFO_EXPECTED_THROUGHPUT) &&
3710 nla_put_u32(msg, NL80211_STA_INFO_EXPECTED_THROUGHPUT,
3711 sinfo->expected_throughput))
3712 goto nla_put_failure;
3713 if ((sinfo->filled & STATION_INFO_BEACON_LOSS_COUNT) &&
3714 nla_put_u32(msg, NL80211_STA_INFO_BEACON_LOSS,
3715 sinfo->beacon_loss_count))
3716 goto nla_put_failure;
3717 if ((sinfo->filled & STATION_INFO_LOCAL_PM) &&
3718 nla_put_u32(msg, NL80211_STA_INFO_LOCAL_PM,
3719 sinfo->local_pm))
3720 goto nla_put_failure;
3721 if ((sinfo->filled & STATION_INFO_PEER_PM) &&
3722 nla_put_u32(msg, NL80211_STA_INFO_PEER_PM,
3723 sinfo->peer_pm))
3724 goto nla_put_failure;
3725 if ((sinfo->filled & STATION_INFO_NONPEER_PM) &&
3726 nla_put_u32(msg, NL80211_STA_INFO_NONPEER_PM,
3727 sinfo->nonpeer_pm))
3728 goto nla_put_failure;
3729 if (sinfo->filled & STATION_INFO_BSS_PARAM) {
3730 bss_param = nla_nest_start(msg, NL80211_STA_INFO_BSS_PARAM);
3731 if (!bss_param)
3732 goto nla_put_failure;
3733
3734 if (((sinfo->bss_param.flags & BSS_PARAM_FLAGS_CTS_PROT) &&
3735 nla_put_flag(msg, NL80211_STA_BSS_PARAM_CTS_PROT)) ||
3736 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_PREAMBLE) &&
3737 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_PREAMBLE)) ||
3738 ((sinfo->bss_param.flags & BSS_PARAM_FLAGS_SHORT_SLOT_TIME) &&
3739 nla_put_flag(msg, NL80211_STA_BSS_PARAM_SHORT_SLOT_TIME)) ||
3740 nla_put_u8(msg, NL80211_STA_BSS_PARAM_DTIM_PERIOD,
3741 sinfo->bss_param.dtim_period) ||
3742 nla_put_u16(msg, NL80211_STA_BSS_PARAM_BEACON_INTERVAL,
3743 sinfo->bss_param.beacon_interval))
3744 goto nla_put_failure;
3745
3746 nla_nest_end(msg, bss_param);
3747 }
3748 if ((sinfo->filled & STATION_INFO_STA_FLAGS) &&
3749 nla_put(msg, NL80211_STA_INFO_STA_FLAGS,
3750 sizeof(struct nl80211_sta_flag_update),
3751 &sinfo->sta_flags))
3752 goto nla_put_failure;
3753 if ((sinfo->filled & STATION_INFO_T_OFFSET) &&
3754 nla_put_u64(msg, NL80211_STA_INFO_T_OFFSET,
3755 sinfo->t_offset))
3756 goto nla_put_failure;
3757 nla_nest_end(msg, sinfoattr);
3758
3759 if ((sinfo->filled & STATION_INFO_ASSOC_REQ_IES) &&
3760 nla_put(msg, NL80211_ATTR_IE, sinfo->assoc_req_ies_len,
3761 sinfo->assoc_req_ies))
3762 goto nla_put_failure;
3763
3764 return genlmsg_end(msg, hdr);
3765
3766 nla_put_failure:
3767 genlmsg_cancel(msg, hdr);
3768 return -EMSGSIZE;
3769 }
3770
3771 static int nl80211_dump_station(struct sk_buff *skb,
3772 struct netlink_callback *cb)
3773 {
3774 struct station_info sinfo;
3775 struct cfg80211_registered_device *rdev;
3776 struct wireless_dev *wdev;
3777 u8 mac_addr[ETH_ALEN];
3778 int sta_idx = cb->args[2];
3779 int err;
3780
3781 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
3782 if (err)
3783 return err;
3784
3785 if (!wdev->netdev) {
3786 err = -EINVAL;
3787 goto out_err;
3788 }
3789
3790 if (!rdev->ops->dump_station) {
3791 err = -EOPNOTSUPP;
3792 goto out_err;
3793 }
3794
3795 while (1) {
3796 memset(&sinfo, 0, sizeof(sinfo));
3797 err = rdev_dump_station(rdev, wdev->netdev, sta_idx,
3798 mac_addr, &sinfo);
3799 if (err == -ENOENT)
3800 break;
3801 if (err)
3802 goto out_err;
3803
3804 if (nl80211_send_station(skb,
3805 NETLINK_CB(cb->skb).portid,
3806 cb->nlh->nlmsg_seq, NLM_F_MULTI,
3807 rdev, wdev->netdev, mac_addr,
3808 &sinfo) < 0)
3809 goto out;
3810
3811 sta_idx++;
3812 }
3813
3814
3815 out:
3816 cb->args[2] = sta_idx;
3817 err = skb->len;
3818 out_err:
3819 nl80211_finish_wdev_dump(rdev);
3820
3821 return err;
3822 }
3823
3824 static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
3825 {
3826 struct cfg80211_registered_device *rdev = info->user_ptr[0];
3827 struct net_device *dev = info->user_ptr[1];
3828 struct station_info sinfo;
3829 struct sk_buff *msg;
3830 u8 *mac_addr = NULL;
3831 int err;
3832
3833 memset(&sinfo, 0, sizeof(sinfo));
3834
3835 if (!info->attrs[NL80211_ATTR_MAC])
3836 return -EINVAL;
3837
3838 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
3839
3840 if (!rdev->ops->get_station)
3841 return -EOPNOTSUPP;
3842
3843 err = rdev_get_station(rdev, dev, mac_addr, &sinfo);
3844 if (err)
3845 return err;
3846
3847 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
3848 if (!msg)
3849 return -ENOMEM;
3850
3851 if (nl80211_send_station(msg, info->snd_portid, info->snd_seq, 0,
3852 rdev, dev, mac_addr, &sinfo) < 0) {
3853 nlmsg_free(msg);
3854 return -ENOBUFS;
3855 }
3856
3857 return genlmsg_reply(msg, info);
3858 }
3859
3860 int cfg80211_check_station_change(struct wiphy *wiphy,
3861 struct station_parameters *params,
3862 enum cfg80211_station_type statype)
3863 {
3864 if (params->listen_interval != -1)
3865 return -EINVAL;
3866 if (params->aid &&
3867 !(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3868 return -EINVAL;
3869
3870 /* When you run into this, adjust the code below for the new flag */
3871 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
3872
3873 switch (statype) {
3874 case CFG80211_STA_MESH_PEER_KERNEL:
3875 case CFG80211_STA_MESH_PEER_USER:
3876 /*
3877 * No ignoring the TDLS flag here -- the userspace mesh
3878 * code doesn't have the bug of including TDLS in the
3879 * mask everywhere.
3880 */
3881 if (params->sta_flags_mask &
3882 ~(BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3883 BIT(NL80211_STA_FLAG_MFP) |
3884 BIT(NL80211_STA_FLAG_AUTHORIZED)))
3885 return -EINVAL;
3886 break;
3887 case CFG80211_STA_TDLS_PEER_SETUP:
3888 case CFG80211_STA_TDLS_PEER_ACTIVE:
3889 if (!(params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
3890 return -EINVAL;
3891 /* ignore since it can't change */
3892 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3893 break;
3894 default:
3895 /* disallow mesh-specific things */
3896 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3897 return -EINVAL;
3898 if (params->local_pm)
3899 return -EINVAL;
3900 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3901 return -EINVAL;
3902 }
3903
3904 if (statype != CFG80211_STA_TDLS_PEER_SETUP &&
3905 statype != CFG80211_STA_TDLS_PEER_ACTIVE) {
3906 /* TDLS can't be set, ... */
3907 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
3908 return -EINVAL;
3909 /*
3910 * ... but don't bother the driver with it. This works around
3911 * a hostapd/wpa_supplicant issue -- it always includes the
3912 * TLDS_PEER flag in the mask even for AP mode.
3913 */
3914 params->sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
3915 }
3916
3917 if (statype != CFG80211_STA_TDLS_PEER_SETUP) {
3918 /* reject other things that can't change */
3919 if (params->sta_modify_mask & STATION_PARAM_APPLY_UAPSD)
3920 return -EINVAL;
3921 if (params->sta_modify_mask & STATION_PARAM_APPLY_CAPABILITY)
3922 return -EINVAL;
3923 if (params->supported_rates)
3924 return -EINVAL;
3925 if (params->ext_capab || params->ht_capa || params->vht_capa)
3926 return -EINVAL;
3927 }
3928
3929 if (statype != CFG80211_STA_AP_CLIENT) {
3930 if (params->vlan)
3931 return -EINVAL;
3932 }
3933
3934 switch (statype) {
3935 case CFG80211_STA_AP_MLME_CLIENT:
3936 /* Use this only for authorizing/unauthorizing a station */
3937 if (!(params->sta_flags_mask & BIT(NL80211_STA_FLAG_AUTHORIZED)))
3938 return -EOPNOTSUPP;
3939 break;
3940 case CFG80211_STA_AP_CLIENT:
3941 /* accept only the listed bits */
3942 if (params->sta_flags_mask &
3943 ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3944 BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3945 BIT(NL80211_STA_FLAG_ASSOCIATED) |
3946 BIT(NL80211_STA_FLAG_SHORT_PREAMBLE) |
3947 BIT(NL80211_STA_FLAG_WME) |
3948 BIT(NL80211_STA_FLAG_MFP)))
3949 return -EINVAL;
3950
3951 /* but authenticated/associated only if driver handles it */
3952 if (!(wiphy->features & NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
3953 params->sta_flags_mask &
3954 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
3955 BIT(NL80211_STA_FLAG_ASSOCIATED)))
3956 return -EINVAL;
3957 break;
3958 case CFG80211_STA_IBSS:
3959 case CFG80211_STA_AP_STA:
3960 /* reject any changes other than AUTHORIZED */
3961 if (params->sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
3962 return -EINVAL;
3963 break;
3964 case CFG80211_STA_TDLS_PEER_SETUP:
3965 /* reject any changes other than AUTHORIZED or WME */
3966 if (params->sta_flags_mask & ~(BIT(NL80211_STA_FLAG_AUTHORIZED) |
3967 BIT(NL80211_STA_FLAG_WME)))
3968 return -EINVAL;
3969 /* force (at least) rates when authorizing */
3970 if (params->sta_flags_set & BIT(NL80211_STA_FLAG_AUTHORIZED) &&
3971 !params->supported_rates)
3972 return -EINVAL;
3973 break;
3974 case CFG80211_STA_TDLS_PEER_ACTIVE:
3975 /* reject any changes */
3976 return -EINVAL;
3977 case CFG80211_STA_MESH_PEER_KERNEL:
3978 if (params->sta_modify_mask & STATION_PARAM_APPLY_PLINK_STATE)
3979 return -EINVAL;
3980 break;
3981 case CFG80211_STA_MESH_PEER_USER:
3982 if (params->plink_action != NL80211_PLINK_ACTION_NO_ACTION)
3983 return -EINVAL;
3984 break;
3985 }
3986
3987 return 0;
3988 }
3989 EXPORT_SYMBOL(cfg80211_check_station_change);
3990
3991 /*
3992 * Get vlan interface making sure it is running and on the right wiphy.
3993 */
3994 static struct net_device *get_vlan(struct genl_info *info,
3995 struct cfg80211_registered_device *rdev)
3996 {
3997 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
3998 struct net_device *v;
3999 int ret;
4000
4001 if (!vlanattr)
4002 return NULL;
4003
4004 v = dev_get_by_index(genl_info_net(info), nla_get_u32(vlanattr));
4005 if (!v)
4006 return ERR_PTR(-ENODEV);
4007
4008 if (!v->ieee80211_ptr || v->ieee80211_ptr->wiphy != &rdev->wiphy) {
4009 ret = -EINVAL;
4010 goto error;
4011 }
4012
4013 if (v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4014 v->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4015 v->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO) {
4016 ret = -EINVAL;
4017 goto error;
4018 }
4019
4020 if (!netif_running(v)) {
4021 ret = -ENETDOWN;
4022 goto error;
4023 }
4024
4025 return v;
4026 error:
4027 dev_put(v);
4028 return ERR_PTR(ret);
4029 }
4030
4031 static const struct nla_policy
4032 nl80211_sta_wme_policy[NL80211_STA_WME_MAX + 1] = {
4033 [NL80211_STA_WME_UAPSD_QUEUES] = { .type = NLA_U8 },
4034 [NL80211_STA_WME_MAX_SP] = { .type = NLA_U8 },
4035 };
4036
4037 static int nl80211_parse_sta_wme(struct genl_info *info,
4038 struct station_parameters *params)
4039 {
4040 struct nlattr *tb[NL80211_STA_WME_MAX + 1];
4041 struct nlattr *nla;
4042 int err;
4043
4044 /* parse WME attributes if present */
4045 if (!info->attrs[NL80211_ATTR_STA_WME])
4046 return 0;
4047
4048 nla = info->attrs[NL80211_ATTR_STA_WME];
4049 err = nla_parse_nested(tb, NL80211_STA_WME_MAX, nla,
4050 nl80211_sta_wme_policy);
4051 if (err)
4052 return err;
4053
4054 if (tb[NL80211_STA_WME_UAPSD_QUEUES])
4055 params->uapsd_queues = nla_get_u8(
4056 tb[NL80211_STA_WME_UAPSD_QUEUES]);
4057 if (params->uapsd_queues & ~IEEE80211_WMM_IE_STA_QOSINFO_AC_MASK)
4058 return -EINVAL;
4059
4060 if (tb[NL80211_STA_WME_MAX_SP])
4061 params->max_sp = nla_get_u8(tb[NL80211_STA_WME_MAX_SP]);
4062
4063 if (params->max_sp & ~IEEE80211_WMM_IE_STA_QOSINFO_SP_MASK)
4064 return -EINVAL;
4065
4066 params->sta_modify_mask |= STATION_PARAM_APPLY_UAPSD;
4067
4068 return 0;
4069 }
4070
4071 static int nl80211_parse_sta_channel_info(struct genl_info *info,
4072 struct station_parameters *params)
4073 {
4074 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]) {
4075 params->supported_channels =
4076 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4077 params->supported_channels_len =
4078 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_CHANNELS]);
4079 /*
4080 * Need to include at least one (first channel, number of
4081 * channels) tuple for each subband, and must have proper
4082 * tuples for the rest of the data as well.
4083 */
4084 if (params->supported_channels_len < 2)
4085 return -EINVAL;
4086 if (params->supported_channels_len % 2)
4087 return -EINVAL;
4088 }
4089
4090 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]) {
4091 params->supported_oper_classes =
4092 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4093 params->supported_oper_classes_len =
4094 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_OPER_CLASSES]);
4095 /*
4096 * The value of the Length field of the Supported Operating
4097 * Classes element is between 2 and 253.
4098 */
4099 if (params->supported_oper_classes_len < 2 ||
4100 params->supported_oper_classes_len > 253)
4101 return -EINVAL;
4102 }
4103 return 0;
4104 }
4105
4106 static int nl80211_set_station_tdls(struct genl_info *info,
4107 struct station_parameters *params)
4108 {
4109 int err;
4110 /* Dummy STA entry gets updated once the peer capabilities are known */
4111 if (info->attrs[NL80211_ATTR_PEER_AID])
4112 params->aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
4113 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4114 params->ht_capa =
4115 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4116 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4117 params->vht_capa =
4118 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4119
4120 err = nl80211_parse_sta_channel_info(info, params);
4121 if (err)
4122 return err;
4123
4124 return nl80211_parse_sta_wme(info, params);
4125 }
4126
4127 static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
4128 {
4129 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4130 struct net_device *dev = info->user_ptr[1];
4131 struct station_parameters params;
4132 u8 *mac_addr;
4133 int err;
4134
4135 memset(&params, 0, sizeof(params));
4136
4137 params.listen_interval = -1;
4138
4139 if (!rdev->ops->change_station)
4140 return -EOPNOTSUPP;
4141
4142 if (info->attrs[NL80211_ATTR_STA_AID])
4143 return -EINVAL;
4144
4145 if (!info->attrs[NL80211_ATTR_MAC])
4146 return -EINVAL;
4147
4148 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4149
4150 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
4151 params.supported_rates =
4152 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4153 params.supported_rates_len =
4154 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4155 }
4156
4157 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4158 params.capability =
4159 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4160 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4161 }
4162
4163 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4164 params.ext_capab =
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]);
4168 }
4169
4170 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4171 return -EINVAL;
4172
4173 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
4174 return -EINVAL;
4175
4176 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
4177 params.plink_action =
4178 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4179 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4180 return -EINVAL;
4181 }
4182
4183 if (info->attrs[NL80211_ATTR_STA_PLINK_STATE]) {
4184 params.plink_state =
4185 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_STATE]);
4186 if (params.plink_state >= NUM_NL80211_PLINK_STATES)
4187 return -EINVAL;
4188 params.sta_modify_mask |= STATION_PARAM_APPLY_PLINK_STATE;
4189 }
4190
4191 if (info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]) {
4192 enum nl80211_mesh_power_mode pm = nla_get_u32(
4193 info->attrs[NL80211_ATTR_LOCAL_MESH_POWER_MODE]);
4194
4195 if (pm <= NL80211_MESH_POWER_UNKNOWN ||
4196 pm > NL80211_MESH_POWER_MAX)
4197 return -EINVAL;
4198
4199 params.local_pm = pm;
4200 }
4201
4202 /* Include parameters for TDLS peer (will check later) */
4203 err = nl80211_set_station_tdls(info, &params);
4204 if (err)
4205 return err;
4206
4207 params.vlan = get_vlan(info, rdev);
4208 if (IS_ERR(params.vlan))
4209 return PTR_ERR(params.vlan);
4210
4211 switch (dev->ieee80211_ptr->iftype) {
4212 case NL80211_IFTYPE_AP:
4213 case NL80211_IFTYPE_AP_VLAN:
4214 case NL80211_IFTYPE_P2P_GO:
4215 case NL80211_IFTYPE_P2P_CLIENT:
4216 case NL80211_IFTYPE_STATION:
4217 case NL80211_IFTYPE_ADHOC:
4218 case NL80211_IFTYPE_MESH_POINT:
4219 break;
4220 default:
4221 err = -EOPNOTSUPP;
4222 goto out_put_vlan;
4223 }
4224
4225 /* driver will call cfg80211_check_station_change() */
4226 err = rdev_change_station(rdev, dev, mac_addr, &params);
4227
4228 out_put_vlan:
4229 if (params.vlan)
4230 dev_put(params.vlan);
4231
4232 return err;
4233 }
4234
4235 static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
4236 {
4237 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4238 int err;
4239 struct net_device *dev = info->user_ptr[1];
4240 struct station_parameters params;
4241 u8 *mac_addr = NULL;
4242
4243 memset(&params, 0, sizeof(params));
4244
4245 if (!rdev->ops->add_station)
4246 return -EOPNOTSUPP;
4247
4248 if (!info->attrs[NL80211_ATTR_MAC])
4249 return -EINVAL;
4250
4251 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
4252 return -EINVAL;
4253
4254 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
4255 return -EINVAL;
4256
4257 if (!info->attrs[NL80211_ATTR_STA_AID] &&
4258 !info->attrs[NL80211_ATTR_PEER_AID])
4259 return -EINVAL;
4260
4261 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4262 params.supported_rates =
4263 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4264 params.supported_rates_len =
4265 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
4266 params.listen_interval =
4267 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
4268
4269 if (info->attrs[NL80211_ATTR_PEER_AID])
4270 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_PEER_AID]);
4271 else
4272 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
4273 if (!params.aid || params.aid > IEEE80211_MAX_AID)
4274 return -EINVAL;
4275
4276 if (info->attrs[NL80211_ATTR_STA_CAPABILITY]) {
4277 params.capability =
4278 nla_get_u16(info->attrs[NL80211_ATTR_STA_CAPABILITY]);
4279 params.sta_modify_mask |= STATION_PARAM_APPLY_CAPABILITY;
4280 }
4281
4282 if (info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]) {
4283 params.ext_capab =
4284 nla_data(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4285 params.ext_capab_len =
4286 nla_len(info->attrs[NL80211_ATTR_STA_EXT_CAPABILITY]);
4287 }
4288
4289 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
4290 params.ht_capa =
4291 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
4292
4293 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY])
4294 params.vht_capa =
4295 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]);
4296
4297 if (info->attrs[NL80211_ATTR_OPMODE_NOTIF]) {
4298 params.opmode_notif_used = true;
4299 params.opmode_notif =
4300 nla_get_u8(info->attrs[NL80211_ATTR_OPMODE_NOTIF]);
4301 }
4302
4303 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION]) {
4304 params.plink_action =
4305 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
4306 if (params.plink_action >= NUM_NL80211_PLINK_ACTIONS)
4307 return -EINVAL;
4308 }
4309
4310 err = nl80211_parse_sta_channel_info(info, &params);
4311 if (err)
4312 return err;
4313
4314 err = nl80211_parse_sta_wme(info, &params);
4315 if (err)
4316 return err;
4317
4318 if (parse_station_flags(info, dev->ieee80211_ptr->iftype, &params))
4319 return -EINVAL;
4320
4321 /* When you run into this, adjust the code below for the new flag */
4322 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4323
4324 switch (dev->ieee80211_ptr->iftype) {
4325 case NL80211_IFTYPE_AP:
4326 case NL80211_IFTYPE_AP_VLAN:
4327 case NL80211_IFTYPE_P2P_GO:
4328 /* ignore WME attributes if iface/sta is not capable */
4329 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
4330 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
4331 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4332
4333 /* TDLS peers cannot be added */
4334 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
4335 info->attrs[NL80211_ATTR_PEER_AID])
4336 return -EINVAL;
4337 /* but don't bother the driver with it */
4338 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4339
4340 /* allow authenticated/associated only if driver handles it */
4341 if (!(rdev->wiphy.features &
4342 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4343 params.sta_flags_mask &
4344 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4345 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4346 return -EINVAL;
4347
4348 /* must be last in here for error handling */
4349 params.vlan = get_vlan(info, rdev);
4350 if (IS_ERR(params.vlan))
4351 return PTR_ERR(params.vlan);
4352 break;
4353 case NL80211_IFTYPE_MESH_POINT:
4354 /* ignore uAPSD data */
4355 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4356
4357 /* associated is disallowed */
4358 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
4359 return -EINVAL;
4360 /* TDLS peers cannot be added */
4361 if ((params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)) ||
4362 info->attrs[NL80211_ATTR_PEER_AID])
4363 return -EINVAL;
4364 break;
4365 case NL80211_IFTYPE_STATION:
4366 case NL80211_IFTYPE_P2P_CLIENT:
4367 /* ignore uAPSD data */
4368 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4369
4370 /* these are disallowed */
4371 if (params.sta_flags_mask &
4372 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
4373 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
4374 return -EINVAL;
4375 /* Only TDLS peers can be added */
4376 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4377 return -EINVAL;
4378 /* Can only add if TDLS ... */
4379 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
4380 return -EOPNOTSUPP;
4381 /* ... with external setup is supported */
4382 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
4383 return -EOPNOTSUPP;
4384 /*
4385 * Older wpa_supplicant versions always mark the TDLS peer
4386 * as authorized, but it shouldn't yet be.
4387 */
4388 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
4389 break;
4390 default:
4391 return -EOPNOTSUPP;
4392 }
4393
4394 /* be aware of params.vlan when changing code here */
4395
4396 err = rdev_add_station(rdev, dev, mac_addr, &params);
4397
4398 if (params.vlan)
4399 dev_put(params.vlan);
4400 return err;
4401 }
4402
4403 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
4404 {
4405 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4406 struct net_device *dev = info->user_ptr[1];
4407 struct station_del_parameters params;
4408
4409 memset(&params, 0, sizeof(params));
4410
4411 if (info->attrs[NL80211_ATTR_MAC])
4412 params.mac = nla_data(info->attrs[NL80211_ATTR_MAC]);
4413
4414 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4415 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4416 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4417 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4418 return -EINVAL;
4419
4420 if (!rdev->ops->del_station)
4421 return -EOPNOTSUPP;
4422
4423 if (info->attrs[NL80211_ATTR_MGMT_SUBTYPE]) {
4424 params.subtype =
4425 nla_get_u8(info->attrs[NL80211_ATTR_MGMT_SUBTYPE]);
4426 if (params.subtype != IEEE80211_STYPE_DISASSOC >> 4 &&
4427 params.subtype != IEEE80211_STYPE_DEAUTH >> 4)
4428 return -EINVAL;
4429 } else {
4430 /* Default to Deauthentication frame */
4431 params.subtype = IEEE80211_STYPE_DEAUTH >> 4;
4432 }
4433
4434 if (info->attrs[NL80211_ATTR_REASON_CODE]) {
4435 params.reason_code =
4436 nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
4437 if (params.reason_code == 0)
4438 return -EINVAL; /* 0 is reserved */
4439 } else {
4440 /* Default to reason code 2 */
4441 params.reason_code = WLAN_REASON_PREV_AUTH_NOT_VALID;
4442 }
4443
4444 return rdev_del_station(rdev, dev, &params);
4445 }
4446
4447 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
4448 int flags, struct net_device *dev,
4449 u8 *dst, u8 *next_hop,
4450 struct mpath_info *pinfo)
4451 {
4452 void *hdr;
4453 struct nlattr *pinfoattr;
4454
4455 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
4456 if (!hdr)
4457 return -1;
4458
4459 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4460 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
4461 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
4462 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
4463 goto nla_put_failure;
4464
4465 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
4466 if (!pinfoattr)
4467 goto nla_put_failure;
4468 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
4469 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
4470 pinfo->frame_qlen))
4471 goto nla_put_failure;
4472 if (((pinfo->filled & MPATH_INFO_SN) &&
4473 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
4474 ((pinfo->filled & MPATH_INFO_METRIC) &&
4475 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
4476 pinfo->metric)) ||
4477 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
4478 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
4479 pinfo->exptime)) ||
4480 ((pinfo->filled & MPATH_INFO_FLAGS) &&
4481 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
4482 pinfo->flags)) ||
4483 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
4484 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
4485 pinfo->discovery_timeout)) ||
4486 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
4487 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
4488 pinfo->discovery_retries)))
4489 goto nla_put_failure;
4490
4491 nla_nest_end(msg, pinfoattr);
4492
4493 return genlmsg_end(msg, hdr);
4494
4495 nla_put_failure:
4496 genlmsg_cancel(msg, hdr);
4497 return -EMSGSIZE;
4498 }
4499
4500 static int nl80211_dump_mpath(struct sk_buff *skb,
4501 struct netlink_callback *cb)
4502 {
4503 struct mpath_info pinfo;
4504 struct cfg80211_registered_device *rdev;
4505 struct wireless_dev *wdev;
4506 u8 dst[ETH_ALEN];
4507 u8 next_hop[ETH_ALEN];
4508 int path_idx = cb->args[2];
4509 int err;
4510
4511 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
4512 if (err)
4513 return err;
4514
4515 if (!rdev->ops->dump_mpath) {
4516 err = -EOPNOTSUPP;
4517 goto out_err;
4518 }
4519
4520 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
4521 err = -EOPNOTSUPP;
4522 goto out_err;
4523 }
4524
4525 while (1) {
4526 err = rdev_dump_mpath(rdev, wdev->netdev, path_idx, dst,
4527 next_hop, &pinfo);
4528 if (err == -ENOENT)
4529 break;
4530 if (err)
4531 goto out_err;
4532
4533 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
4534 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4535 wdev->netdev, dst, next_hop,
4536 &pinfo) < 0)
4537 goto out;
4538
4539 path_idx++;
4540 }
4541
4542
4543 out:
4544 cb->args[2] = path_idx;
4545 err = skb->len;
4546 out_err:
4547 nl80211_finish_wdev_dump(rdev);
4548 return err;
4549 }
4550
4551 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
4552 {
4553 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4554 int err;
4555 struct net_device *dev = info->user_ptr[1];
4556 struct mpath_info pinfo;
4557 struct sk_buff *msg;
4558 u8 *dst = NULL;
4559 u8 next_hop[ETH_ALEN];
4560
4561 memset(&pinfo, 0, sizeof(pinfo));
4562
4563 if (!info->attrs[NL80211_ATTR_MAC])
4564 return -EINVAL;
4565
4566 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4567
4568 if (!rdev->ops->get_mpath)
4569 return -EOPNOTSUPP;
4570
4571 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4572 return -EOPNOTSUPP;
4573
4574 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
4575 if (err)
4576 return err;
4577
4578 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4579 if (!msg)
4580 return -ENOMEM;
4581
4582 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4583 dev, dst, next_hop, &pinfo) < 0) {
4584 nlmsg_free(msg);
4585 return -ENOBUFS;
4586 }
4587
4588 return genlmsg_reply(msg, info);
4589 }
4590
4591 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
4592 {
4593 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4594 struct net_device *dev = info->user_ptr[1];
4595 u8 *dst = NULL;
4596 u8 *next_hop = NULL;
4597
4598 if (!info->attrs[NL80211_ATTR_MAC])
4599 return -EINVAL;
4600
4601 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4602 return -EINVAL;
4603
4604 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4605 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4606
4607 if (!rdev->ops->change_mpath)
4608 return -EOPNOTSUPP;
4609
4610 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4611 return -EOPNOTSUPP;
4612
4613 return rdev_change_mpath(rdev, dev, dst, next_hop);
4614 }
4615
4616 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
4617 {
4618 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4619 struct net_device *dev = info->user_ptr[1];
4620 u8 *dst = NULL;
4621 u8 *next_hop = NULL;
4622
4623 if (!info->attrs[NL80211_ATTR_MAC])
4624 return -EINVAL;
4625
4626 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4627 return -EINVAL;
4628
4629 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4630 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4631
4632 if (!rdev->ops->add_mpath)
4633 return -EOPNOTSUPP;
4634
4635 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4636 return -EOPNOTSUPP;
4637
4638 return rdev_add_mpath(rdev, dev, dst, next_hop);
4639 }
4640
4641 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
4642 {
4643 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4644 struct net_device *dev = info->user_ptr[1];
4645 u8 *dst = NULL;
4646
4647 if (info->attrs[NL80211_ATTR_MAC])
4648 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4649
4650 if (!rdev->ops->del_mpath)
4651 return -EOPNOTSUPP;
4652
4653 return rdev_del_mpath(rdev, dev, dst);
4654 }
4655
4656 static int nl80211_get_mpp(struct sk_buff *skb, struct genl_info *info)
4657 {
4658 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4659 int err;
4660 struct net_device *dev = info->user_ptr[1];
4661 struct mpath_info pinfo;
4662 struct sk_buff *msg;
4663 u8 *dst = NULL;
4664 u8 mpp[ETH_ALEN];
4665
4666 memset(&pinfo, 0, sizeof(pinfo));
4667
4668 if (!info->attrs[NL80211_ATTR_MAC])
4669 return -EINVAL;
4670
4671 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4672
4673 if (!rdev->ops->get_mpp)
4674 return -EOPNOTSUPP;
4675
4676 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4677 return -EOPNOTSUPP;
4678
4679 err = rdev_get_mpp(rdev, dev, dst, mpp, &pinfo);
4680 if (err)
4681 return err;
4682
4683 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4684 if (!msg)
4685 return -ENOMEM;
4686
4687 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4688 dev, dst, mpp, &pinfo) < 0) {
4689 nlmsg_free(msg);
4690 return -ENOBUFS;
4691 }
4692
4693 return genlmsg_reply(msg, info);
4694 }
4695
4696 static int nl80211_dump_mpp(struct sk_buff *skb,
4697 struct netlink_callback *cb)
4698 {
4699 struct mpath_info pinfo;
4700 struct cfg80211_registered_device *rdev;
4701 struct wireless_dev *wdev;
4702 u8 dst[ETH_ALEN];
4703 u8 mpp[ETH_ALEN];
4704 int path_idx = cb->args[2];
4705 int err;
4706
4707 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
4708 if (err)
4709 return err;
4710
4711 if (!rdev->ops->dump_mpp) {
4712 err = -EOPNOTSUPP;
4713 goto out_err;
4714 }
4715
4716 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
4717 err = -EOPNOTSUPP;
4718 goto out_err;
4719 }
4720
4721 while (1) {
4722 err = rdev_dump_mpp(rdev, wdev->netdev, path_idx, dst,
4723 mpp, &pinfo);
4724 if (err == -ENOENT)
4725 break;
4726 if (err)
4727 goto out_err;
4728
4729 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
4730 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4731 wdev->netdev, dst, mpp,
4732 &pinfo) < 0)
4733 goto out;
4734
4735 path_idx++;
4736 }
4737
4738 out:
4739 cb->args[2] = path_idx;
4740 err = skb->len;
4741 out_err:
4742 nl80211_finish_wdev_dump(rdev);
4743 return err;
4744 }
4745
4746 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
4747 {
4748 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4749 struct net_device *dev = info->user_ptr[1];
4750 struct wireless_dev *wdev = dev->ieee80211_ptr;
4751 struct bss_parameters params;
4752 int err;
4753
4754 memset(&params, 0, sizeof(params));
4755 /* default to not changing parameters */
4756 params.use_cts_prot = -1;
4757 params.use_short_preamble = -1;
4758 params.use_short_slot_time = -1;
4759 params.ap_isolate = -1;
4760 params.ht_opmode = -1;
4761 params.p2p_ctwindow = -1;
4762 params.p2p_opp_ps = -1;
4763
4764 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
4765 params.use_cts_prot =
4766 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
4767 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
4768 params.use_short_preamble =
4769 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
4770 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
4771 params.use_short_slot_time =
4772 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
4773 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
4774 params.basic_rates =
4775 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4776 params.basic_rates_len =
4777 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4778 }
4779 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
4780 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
4781 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
4782 params.ht_opmode =
4783 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
4784
4785 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4786 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4787 return -EINVAL;
4788 params.p2p_ctwindow =
4789 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4790 if (params.p2p_ctwindow < 0)
4791 return -EINVAL;
4792 if (params.p2p_ctwindow != 0 &&
4793 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4794 return -EINVAL;
4795 }
4796
4797 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4798 u8 tmp;
4799
4800 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4801 return -EINVAL;
4802 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4803 if (tmp > 1)
4804 return -EINVAL;
4805 params.p2p_opp_ps = tmp;
4806 if (params.p2p_opp_ps &&
4807 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4808 return -EINVAL;
4809 }
4810
4811 if (!rdev->ops->change_bss)
4812 return -EOPNOTSUPP;
4813
4814 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4815 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4816 return -EOPNOTSUPP;
4817
4818 wdev_lock(wdev);
4819 err = rdev_change_bss(rdev, dev, &params);
4820 wdev_unlock(wdev);
4821
4822 return err;
4823 }
4824
4825 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
4826 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
4827 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
4828 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
4829 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
4830 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
4831 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
4832 [NL80211_ATTR_DFS_CAC_TIME] = { .type = NLA_U32 },
4833 };
4834
4835 static int parse_reg_rule(struct nlattr *tb[],
4836 struct ieee80211_reg_rule *reg_rule)
4837 {
4838 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
4839 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
4840
4841 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
4842 return -EINVAL;
4843 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
4844 return -EINVAL;
4845 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
4846 return -EINVAL;
4847 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
4848 return -EINVAL;
4849 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
4850 return -EINVAL;
4851
4852 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
4853
4854 freq_range->start_freq_khz =
4855 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
4856 freq_range->end_freq_khz =
4857 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
4858 freq_range->max_bandwidth_khz =
4859 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
4860
4861 power_rule->max_eirp =
4862 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
4863
4864 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
4865 power_rule->max_antenna_gain =
4866 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
4867
4868 if (tb[NL80211_ATTR_DFS_CAC_TIME])
4869 reg_rule->dfs_cac_ms =
4870 nla_get_u32(tb[NL80211_ATTR_DFS_CAC_TIME]);
4871
4872 return 0;
4873 }
4874
4875 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
4876 {
4877 char *data = NULL;
4878 enum nl80211_user_reg_hint_type user_reg_hint_type;
4879
4880 /*
4881 * You should only get this when cfg80211 hasn't yet initialized
4882 * completely when built-in to the kernel right between the time
4883 * window between nl80211_init() and regulatory_init(), if that is
4884 * even possible.
4885 */
4886 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
4887 return -EINPROGRESS;
4888
4889 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
4890 user_reg_hint_type =
4891 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
4892 else
4893 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
4894
4895 switch (user_reg_hint_type) {
4896 case NL80211_USER_REG_HINT_USER:
4897 case NL80211_USER_REG_HINT_CELL_BASE:
4898 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4899 return -EINVAL;
4900
4901 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4902 return regulatory_hint_user(data, user_reg_hint_type);
4903 case NL80211_USER_REG_HINT_INDOOR:
4904 return regulatory_hint_indoor_user();
4905 default:
4906 return -EINVAL;
4907 }
4908 }
4909
4910 static int nl80211_get_mesh_config(struct sk_buff *skb,
4911 struct genl_info *info)
4912 {
4913 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4914 struct net_device *dev = info->user_ptr[1];
4915 struct wireless_dev *wdev = dev->ieee80211_ptr;
4916 struct mesh_config cur_params;
4917 int err = 0;
4918 void *hdr;
4919 struct nlattr *pinfoattr;
4920 struct sk_buff *msg;
4921
4922 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4923 return -EOPNOTSUPP;
4924
4925 if (!rdev->ops->get_mesh_config)
4926 return -EOPNOTSUPP;
4927
4928 wdev_lock(wdev);
4929 /* If not connected, get default parameters */
4930 if (!wdev->mesh_id_len)
4931 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
4932 else
4933 err = rdev_get_mesh_config(rdev, dev, &cur_params);
4934 wdev_unlock(wdev);
4935
4936 if (err)
4937 return err;
4938
4939 /* Draw up a netlink message to send back */
4940 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4941 if (!msg)
4942 return -ENOMEM;
4943 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4944 NL80211_CMD_GET_MESH_CONFIG);
4945 if (!hdr)
4946 goto out;
4947 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
4948 if (!pinfoattr)
4949 goto nla_put_failure;
4950 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4951 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
4952 cur_params.dot11MeshRetryTimeout) ||
4953 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4954 cur_params.dot11MeshConfirmTimeout) ||
4955 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
4956 cur_params.dot11MeshHoldingTimeout) ||
4957 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
4958 cur_params.dot11MeshMaxPeerLinks) ||
4959 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
4960 cur_params.dot11MeshMaxRetries) ||
4961 nla_put_u8(msg, NL80211_MESHCONF_TTL,
4962 cur_params.dot11MeshTTL) ||
4963 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
4964 cur_params.element_ttl) ||
4965 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4966 cur_params.auto_open_plinks) ||
4967 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4968 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
4969 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4970 cur_params.dot11MeshHWMPmaxPREQretries) ||
4971 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
4972 cur_params.path_refresh_time) ||
4973 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4974 cur_params.min_discovery_timeout) ||
4975 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4976 cur_params.dot11MeshHWMPactivePathTimeout) ||
4977 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4978 cur_params.dot11MeshHWMPpreqMinInterval) ||
4979 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4980 cur_params.dot11MeshHWMPperrMinInterval) ||
4981 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4982 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
4983 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
4984 cur_params.dot11MeshHWMPRootMode) ||
4985 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4986 cur_params.dot11MeshHWMPRannInterval) ||
4987 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4988 cur_params.dot11MeshGateAnnouncementProtocol) ||
4989 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
4990 cur_params.dot11MeshForwarding) ||
4991 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
4992 cur_params.rssi_threshold) ||
4993 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
4994 cur_params.ht_opmode) ||
4995 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4996 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
4997 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4998 cur_params.dot11MeshHWMProotInterval) ||
4999 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
5000 cur_params.dot11MeshHWMPconfirmationInterval) ||
5001 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
5002 cur_params.power_mode) ||
5003 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
5004 cur_params.dot11MeshAwakeWindowDuration) ||
5005 nla_put_u32(msg, NL80211_MESHCONF_PLINK_TIMEOUT,
5006 cur_params.plink_timeout))
5007 goto nla_put_failure;
5008 nla_nest_end(msg, pinfoattr);
5009 genlmsg_end(msg, hdr);
5010 return genlmsg_reply(msg, info);
5011
5012 nla_put_failure:
5013 genlmsg_cancel(msg, hdr);
5014 out:
5015 nlmsg_free(msg);
5016 return -ENOBUFS;
5017 }
5018
5019 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
5020 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
5021 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
5022 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
5023 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
5024 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
5025 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
5026 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
5027 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
5028 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
5029 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
5030 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
5031 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
5032 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
5033 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
5034 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
5035 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
5036 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
5037 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
5038 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
5039 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
5040 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
5041 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
5042 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
5043 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
5044 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
5045 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
5046 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
5047 [NL80211_MESHCONF_PLINK_TIMEOUT] = { .type = NLA_U32 },
5048 };
5049
5050 static const struct nla_policy
5051 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
5052 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
5053 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
5054 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
5055 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
5056 [NL80211_MESH_SETUP_AUTH_PROTOCOL] = { .type = NLA_U8 },
5057 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
5058 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
5059 .len = IEEE80211_MAX_DATA_LEN },
5060 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
5061 };
5062
5063 static int nl80211_parse_mesh_config(struct genl_info *info,
5064 struct mesh_config *cfg,
5065 u32 *mask_out)
5066 {
5067 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
5068 u32 mask = 0;
5069
5070 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
5071 do { \
5072 if (tb[attr]) { \
5073 if (fn(tb[attr]) < min || fn(tb[attr]) > max) \
5074 return -EINVAL; \
5075 cfg->param = fn(tb[attr]); \
5076 mask |= (1 << (attr - 1)); \
5077 } \
5078 } while (0)
5079
5080
5081 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
5082 return -EINVAL;
5083 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
5084 info->attrs[NL80211_ATTR_MESH_CONFIG],
5085 nl80211_meshconf_params_policy))
5086 return -EINVAL;
5087
5088 /* This makes sure that there aren't more than 32 mesh config
5089 * parameters (otherwise our bitfield scheme would not work.) */
5090 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
5091
5092 /* Fill in the params struct */
5093 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
5094 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
5095 nla_get_u16);
5096 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
5097 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
5098 nla_get_u16);
5099 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
5100 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
5101 nla_get_u16);
5102 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
5103 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
5104 nla_get_u16);
5105 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
5106 mask, NL80211_MESHCONF_MAX_RETRIES,
5107 nla_get_u8);
5108 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
5109 mask, NL80211_MESHCONF_TTL, nla_get_u8);
5110 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
5111 mask, NL80211_MESHCONF_ELEMENT_TTL,
5112 nla_get_u8);
5113 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
5114 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
5115 nla_get_u8);
5116 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
5117 1, 255, mask,
5118 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
5119 nla_get_u32);
5120 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
5121 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
5122 nla_get_u8);
5123 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
5124 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
5125 nla_get_u32);
5126 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
5127 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
5128 nla_get_u16);
5129 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
5130 1, 65535, mask,
5131 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
5132 nla_get_u32);
5133 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
5134 1, 65535, mask,
5135 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
5136 nla_get_u16);
5137 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
5138 1, 65535, mask,
5139 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
5140 nla_get_u16);
5141 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
5142 dot11MeshHWMPnetDiameterTraversalTime,
5143 1, 65535, mask,
5144 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
5145 nla_get_u16);
5146 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
5147 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
5148 nla_get_u8);
5149 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
5150 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
5151 nla_get_u16);
5152 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
5153 dot11MeshGateAnnouncementProtocol, 0, 1,
5154 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
5155 nla_get_u8);
5156 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
5157 mask, NL80211_MESHCONF_FORWARDING,
5158 nla_get_u8);
5159 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, -255, 0,
5160 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
5161 nla_get_s32);
5162 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode, 0, 16,
5163 mask, NL80211_MESHCONF_HT_OPMODE,
5164 nla_get_u16);
5165 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
5166 1, 65535, mask,
5167 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
5168 nla_get_u32);
5169 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
5170 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
5171 nla_get_u16);
5172 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
5173 dot11MeshHWMPconfirmationInterval,
5174 1, 65535, mask,
5175 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
5176 nla_get_u16);
5177 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
5178 NL80211_MESH_POWER_ACTIVE,
5179 NL80211_MESH_POWER_MAX,
5180 mask, NL80211_MESHCONF_POWER_MODE,
5181 nla_get_u32);
5182 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
5183 0, 65535, mask,
5184 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
5185 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, plink_timeout, 1, 0xffffffff,
5186 mask, NL80211_MESHCONF_PLINK_TIMEOUT,
5187 nla_get_u32);
5188 if (mask_out)
5189 *mask_out = mask;
5190
5191 return 0;
5192
5193 #undef FILL_IN_MESH_PARAM_IF_SET
5194 }
5195
5196 static int nl80211_parse_mesh_setup(struct genl_info *info,
5197 struct mesh_setup *setup)
5198 {
5199 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5200 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
5201
5202 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
5203 return -EINVAL;
5204 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
5205 info->attrs[NL80211_ATTR_MESH_SETUP],
5206 nl80211_mesh_setup_params_policy))
5207 return -EINVAL;
5208
5209 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
5210 setup->sync_method =
5211 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
5212 IEEE80211_SYNC_METHOD_VENDOR :
5213 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
5214
5215 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
5216 setup->path_sel_proto =
5217 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
5218 IEEE80211_PATH_PROTOCOL_VENDOR :
5219 IEEE80211_PATH_PROTOCOL_HWMP;
5220
5221 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
5222 setup->path_metric =
5223 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
5224 IEEE80211_PATH_METRIC_VENDOR :
5225 IEEE80211_PATH_METRIC_AIRTIME;
5226
5227
5228 if (tb[NL80211_MESH_SETUP_IE]) {
5229 struct nlattr *ieattr =
5230 tb[NL80211_MESH_SETUP_IE];
5231 if (!is_valid_ie_attr(ieattr))
5232 return -EINVAL;
5233 setup->ie = nla_data(ieattr);
5234 setup->ie_len = nla_len(ieattr);
5235 }
5236 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
5237 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
5238 return -EINVAL;
5239 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
5240 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
5241 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
5242 if (setup->is_secure)
5243 setup->user_mpm = true;
5244
5245 if (tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]) {
5246 if (!setup->user_mpm)
5247 return -EINVAL;
5248 setup->auth_id =
5249 nla_get_u8(tb[NL80211_MESH_SETUP_AUTH_PROTOCOL]);
5250 }
5251
5252 return 0;
5253 }
5254
5255 static int nl80211_update_mesh_config(struct sk_buff *skb,
5256 struct genl_info *info)
5257 {
5258 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5259 struct net_device *dev = info->user_ptr[1];
5260 struct wireless_dev *wdev = dev->ieee80211_ptr;
5261 struct mesh_config cfg;
5262 u32 mask;
5263 int err;
5264
5265 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
5266 return -EOPNOTSUPP;
5267
5268 if (!rdev->ops->update_mesh_config)
5269 return -EOPNOTSUPP;
5270
5271 err = nl80211_parse_mesh_config(info, &cfg, &mask);
5272 if (err)
5273 return err;
5274
5275 wdev_lock(wdev);
5276 if (!wdev->mesh_id_len)
5277 err = -ENOLINK;
5278
5279 if (!err)
5280 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
5281
5282 wdev_unlock(wdev);
5283
5284 return err;
5285 }
5286
5287 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
5288 {
5289 const struct ieee80211_regdomain *regdom;
5290 struct sk_buff *msg;
5291 void *hdr = NULL;
5292 struct nlattr *nl_reg_rules;
5293 unsigned int i;
5294
5295 if (!cfg80211_regdomain)
5296 return -EINVAL;
5297
5298 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
5299 if (!msg)
5300 return -ENOBUFS;
5301
5302 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
5303 NL80211_CMD_GET_REG);
5304 if (!hdr)
5305 goto put_failure;
5306
5307 if (reg_last_request_cell_base() &&
5308 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
5309 NL80211_USER_REG_HINT_CELL_BASE))
5310 goto nla_put_failure;
5311
5312 rcu_read_lock();
5313 regdom = rcu_dereference(cfg80211_regdomain);
5314
5315 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
5316 (regdom->dfs_region &&
5317 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
5318 goto nla_put_failure_rcu;
5319
5320 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
5321 if (!nl_reg_rules)
5322 goto nla_put_failure_rcu;
5323
5324 for (i = 0; i < regdom->n_reg_rules; i++) {
5325 struct nlattr *nl_reg_rule;
5326 const struct ieee80211_reg_rule *reg_rule;
5327 const struct ieee80211_freq_range *freq_range;
5328 const struct ieee80211_power_rule *power_rule;
5329 unsigned int max_bandwidth_khz;
5330
5331 reg_rule = &regdom->reg_rules[i];
5332 freq_range = &reg_rule->freq_range;
5333 power_rule = &reg_rule->power_rule;
5334
5335 nl_reg_rule = nla_nest_start(msg, i);
5336 if (!nl_reg_rule)
5337 goto nla_put_failure_rcu;
5338
5339 max_bandwidth_khz = freq_range->max_bandwidth_khz;
5340 if (!max_bandwidth_khz)
5341 max_bandwidth_khz = reg_get_max_bandwidth(regdom,
5342 reg_rule);
5343
5344 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
5345 reg_rule->flags) ||
5346 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
5347 freq_range->start_freq_khz) ||
5348 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
5349 freq_range->end_freq_khz) ||
5350 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
5351 max_bandwidth_khz) ||
5352 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
5353 power_rule->max_antenna_gain) ||
5354 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
5355 power_rule->max_eirp) ||
5356 nla_put_u32(msg, NL80211_ATTR_DFS_CAC_TIME,
5357 reg_rule->dfs_cac_ms))
5358 goto nla_put_failure_rcu;
5359
5360 nla_nest_end(msg, nl_reg_rule);
5361 }
5362 rcu_read_unlock();
5363
5364 nla_nest_end(msg, nl_reg_rules);
5365
5366 genlmsg_end(msg, hdr);
5367 return genlmsg_reply(msg, info);
5368
5369 nla_put_failure_rcu:
5370 rcu_read_unlock();
5371 nla_put_failure:
5372 genlmsg_cancel(msg, hdr);
5373 put_failure:
5374 nlmsg_free(msg);
5375 return -EMSGSIZE;
5376 }
5377
5378 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
5379 {
5380 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
5381 struct nlattr *nl_reg_rule;
5382 char *alpha2 = NULL;
5383 int rem_reg_rules = 0, r = 0;
5384 u32 num_rules = 0, rule_idx = 0, size_of_regd;
5385 enum nl80211_dfs_regions dfs_region = NL80211_DFS_UNSET;
5386 struct ieee80211_regdomain *rd = NULL;
5387
5388 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5389 return -EINVAL;
5390
5391 if (!info->attrs[NL80211_ATTR_REG_RULES])
5392 return -EINVAL;
5393
5394 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5395
5396 if (info->attrs[NL80211_ATTR_DFS_REGION])
5397 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
5398
5399 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
5400 rem_reg_rules) {
5401 num_rules++;
5402 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
5403 return -EINVAL;
5404 }
5405
5406 if (!reg_is_valid_request(alpha2))
5407 return -EINVAL;
5408
5409 size_of_regd = sizeof(struct ieee80211_regdomain) +
5410 num_rules * sizeof(struct ieee80211_reg_rule);
5411
5412 rd = kzalloc(size_of_regd, GFP_KERNEL);
5413 if (!rd)
5414 return -ENOMEM;
5415
5416 rd->n_reg_rules = num_rules;
5417 rd->alpha2[0] = alpha2[0];
5418 rd->alpha2[1] = alpha2[1];
5419
5420 /*
5421 * Disable DFS master mode if the DFS region was
5422 * not supported or known on this kernel.
5423 */
5424 if (reg_supported_dfs_region(dfs_region))
5425 rd->dfs_region = dfs_region;
5426
5427 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
5428 rem_reg_rules) {
5429 r = nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
5430 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
5431 reg_rule_policy);
5432 if (r)
5433 goto bad_reg;
5434 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
5435 if (r)
5436 goto bad_reg;
5437
5438 rule_idx++;
5439
5440 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
5441 r = -EINVAL;
5442 goto bad_reg;
5443 }
5444 }
5445
5446 r = set_regdom(rd);
5447 /* set_regdom took ownership */
5448 rd = NULL;
5449
5450 bad_reg:
5451 kfree(rd);
5452 return r;
5453 }
5454
5455 static int validate_scan_freqs(struct nlattr *freqs)
5456 {
5457 struct nlattr *attr1, *attr2;
5458 int n_channels = 0, tmp1, tmp2;
5459
5460 nla_for_each_nested(attr1, freqs, tmp1) {
5461 n_channels++;
5462 /*
5463 * Some hardware has a limited channel list for
5464 * scanning, and it is pretty much nonsensical
5465 * to scan for a channel twice, so disallow that
5466 * and don't require drivers to check that the
5467 * channel list they get isn't longer than what
5468 * they can scan, as long as they can scan all
5469 * the channels they registered at once.
5470 */
5471 nla_for_each_nested(attr2, freqs, tmp2)
5472 if (attr1 != attr2 &&
5473 nla_get_u32(attr1) == nla_get_u32(attr2))
5474 return 0;
5475 }
5476
5477 return n_channels;
5478 }
5479
5480 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
5481 {
5482 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5483 struct wireless_dev *wdev = info->user_ptr[1];
5484 struct cfg80211_scan_request *request;
5485 struct nlattr *attr;
5486 struct wiphy *wiphy;
5487 int err, tmp, n_ssids = 0, n_channels, i;
5488 size_t ie_len;
5489
5490 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5491 return -EINVAL;
5492
5493 wiphy = &rdev->wiphy;
5494
5495 if (!rdev->ops->scan)
5496 return -EOPNOTSUPP;
5497
5498 if (rdev->scan_req || rdev->scan_msg) {
5499 err = -EBUSY;
5500 goto unlock;
5501 }
5502
5503 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5504 n_channels = validate_scan_freqs(
5505 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5506 if (!n_channels) {
5507 err = -EINVAL;
5508 goto unlock;
5509 }
5510 } else {
5511 n_channels = ieee80211_get_num_supported_channels(wiphy);
5512 }
5513
5514 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5515 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
5516 n_ssids++;
5517
5518 if (n_ssids > wiphy->max_scan_ssids) {
5519 err = -EINVAL;
5520 goto unlock;
5521 }
5522
5523 if (info->attrs[NL80211_ATTR_IE])
5524 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5525 else
5526 ie_len = 0;
5527
5528 if (ie_len > wiphy->max_scan_ie_len) {
5529 err = -EINVAL;
5530 goto unlock;
5531 }
5532
5533 request = kzalloc(sizeof(*request)
5534 + sizeof(*request->ssids) * n_ssids
5535 + sizeof(*request->channels) * n_channels
5536 + ie_len, GFP_KERNEL);
5537 if (!request) {
5538 err = -ENOMEM;
5539 goto unlock;
5540 }
5541
5542 if (n_ssids)
5543 request->ssids = (void *)&request->channels[n_channels];
5544 request->n_ssids = n_ssids;
5545 if (ie_len) {
5546 if (request->ssids)
5547 request->ie = (void *)(request->ssids + n_ssids);
5548 else
5549 request->ie = (void *)(request->channels + n_channels);
5550 }
5551
5552 i = 0;
5553 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5554 /* user specified, bail out if channel not found */
5555 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
5556 struct ieee80211_channel *chan;
5557
5558 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5559
5560 if (!chan) {
5561 err = -EINVAL;
5562 goto out_free;
5563 }
5564
5565 /* ignore disabled channels */
5566 if (chan->flags & IEEE80211_CHAN_DISABLED)
5567 continue;
5568
5569 request->channels[i] = chan;
5570 i++;
5571 }
5572 } else {
5573 enum ieee80211_band band;
5574
5575 /* all channels */
5576 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5577 int j;
5578 if (!wiphy->bands[band])
5579 continue;
5580 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5581 struct ieee80211_channel *chan;
5582
5583 chan = &wiphy->bands[band]->channels[j];
5584
5585 if (chan->flags & IEEE80211_CHAN_DISABLED)
5586 continue;
5587
5588 request->channels[i] = chan;
5589 i++;
5590 }
5591 }
5592 }
5593
5594 if (!i) {
5595 err = -EINVAL;
5596 goto out_free;
5597 }
5598
5599 request->n_channels = i;
5600
5601 i = 0;
5602 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5603 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
5604 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5605 err = -EINVAL;
5606 goto out_free;
5607 }
5608 request->ssids[i].ssid_len = nla_len(attr);
5609 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
5610 i++;
5611 }
5612 }
5613
5614 if (info->attrs[NL80211_ATTR_IE]) {
5615 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5616 memcpy((void *)request->ie,
5617 nla_data(info->attrs[NL80211_ATTR_IE]),
5618 request->ie_len);
5619 }
5620
5621 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
5622 if (wiphy->bands[i])
5623 request->rates[i] =
5624 (1 << wiphy->bands[i]->n_bitrates) - 1;
5625
5626 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
5627 nla_for_each_nested(attr,
5628 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
5629 tmp) {
5630 enum ieee80211_band band = nla_type(attr);
5631
5632 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
5633 err = -EINVAL;
5634 goto out_free;
5635 }
5636
5637 if (!wiphy->bands[band])
5638 continue;
5639
5640 err = ieee80211_get_ratemask(wiphy->bands[band],
5641 nla_data(attr),
5642 nla_len(attr),
5643 &request->rates[band]);
5644 if (err)
5645 goto out_free;
5646 }
5647 }
5648
5649 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5650 request->flags = nla_get_u32(
5651 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5652 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5653 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
5654 err = -EOPNOTSUPP;
5655 goto out_free;
5656 }
5657 }
5658
5659 request->no_cck =
5660 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5661
5662 request->wdev = wdev;
5663 request->wiphy = &rdev->wiphy;
5664 request->scan_start = jiffies;
5665
5666 rdev->scan_req = request;
5667 err = rdev_scan(rdev, request);
5668
5669 if (!err) {
5670 nl80211_send_scan_start(rdev, wdev);
5671 if (wdev->netdev)
5672 dev_hold(wdev->netdev);
5673 } else {
5674 out_free:
5675 rdev->scan_req = NULL;
5676 kfree(request);
5677 }
5678
5679 unlock:
5680 return err;
5681 }
5682
5683 static int nl80211_start_sched_scan(struct sk_buff *skb,
5684 struct genl_info *info)
5685 {
5686 struct cfg80211_sched_scan_request *request;
5687 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5688 struct net_device *dev = info->user_ptr[1];
5689 struct nlattr *attr;
5690 struct wiphy *wiphy;
5691 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
5692 u32 interval;
5693 enum ieee80211_band band;
5694 size_t ie_len;
5695 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
5696 s32 default_match_rssi = NL80211_SCAN_RSSI_THOLD_OFF;
5697
5698 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5699 !rdev->ops->sched_scan_start)
5700 return -EOPNOTSUPP;
5701
5702 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5703 return -EINVAL;
5704
5705 if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
5706 return -EINVAL;
5707
5708 interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
5709 if (interval == 0)
5710 return -EINVAL;
5711
5712 wiphy = &rdev->wiphy;
5713
5714 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5715 n_channels = validate_scan_freqs(
5716 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5717 if (!n_channels)
5718 return -EINVAL;
5719 } else {
5720 n_channels = ieee80211_get_num_supported_channels(wiphy);
5721 }
5722
5723 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5724 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5725 tmp)
5726 n_ssids++;
5727
5728 if (n_ssids > wiphy->max_sched_scan_ssids)
5729 return -EINVAL;
5730
5731 /*
5732 * First, count the number of 'real' matchsets. Due to an issue with
5733 * the old implementation, matchsets containing only the RSSI attribute
5734 * (NL80211_SCHED_SCAN_MATCH_ATTR_RSSI) are considered as the 'default'
5735 * RSSI for all matchsets, rather than their own matchset for reporting
5736 * all APs with a strong RSSI. This is needed to be compatible with
5737 * older userspace that treated a matchset with only the RSSI as the
5738 * global RSSI for all other matchsets - if there are other matchsets.
5739 */
5740 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
5741 nla_for_each_nested(attr,
5742 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5743 tmp) {
5744 struct nlattr *rssi;
5745
5746 err = nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
5747 nla_data(attr), nla_len(attr),
5748 nl80211_match_policy);
5749 if (err)
5750 return err;
5751 /* add other standalone attributes here */
5752 if (tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID]) {
5753 n_match_sets++;
5754 continue;
5755 }
5756 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
5757 if (rssi)
5758 default_match_rssi = nla_get_s32(rssi);
5759 }
5760 }
5761
5762 /* However, if there's no other matchset, add the RSSI one */
5763 if (!n_match_sets && default_match_rssi != NL80211_SCAN_RSSI_THOLD_OFF)
5764 n_match_sets = 1;
5765
5766 if (n_match_sets > wiphy->max_match_sets)
5767 return -EINVAL;
5768
5769 if (info->attrs[NL80211_ATTR_IE])
5770 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5771 else
5772 ie_len = 0;
5773
5774 if (ie_len > wiphy->max_sched_scan_ie_len)
5775 return -EINVAL;
5776
5777 if (rdev->sched_scan_req) {
5778 err = -EINPROGRESS;
5779 goto out;
5780 }
5781
5782 request = kzalloc(sizeof(*request)
5783 + sizeof(*request->ssids) * n_ssids
5784 + sizeof(*request->match_sets) * n_match_sets
5785 + sizeof(*request->channels) * n_channels
5786 + ie_len, GFP_KERNEL);
5787 if (!request) {
5788 err = -ENOMEM;
5789 goto out;
5790 }
5791
5792 if (n_ssids)
5793 request->ssids = (void *)&request->channels[n_channels];
5794 request->n_ssids = n_ssids;
5795 if (ie_len) {
5796 if (request->ssids)
5797 request->ie = (void *)(request->ssids + n_ssids);
5798 else
5799 request->ie = (void *)(request->channels + n_channels);
5800 }
5801
5802 if (n_match_sets) {
5803 if (request->ie)
5804 request->match_sets = (void *)(request->ie + ie_len);
5805 else if (request->ssids)
5806 request->match_sets =
5807 (void *)(request->ssids + n_ssids);
5808 else
5809 request->match_sets =
5810 (void *)(request->channels + n_channels);
5811 }
5812 request->n_match_sets = n_match_sets;
5813
5814 i = 0;
5815 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5816 /* user specified, bail out if channel not found */
5817 nla_for_each_nested(attr,
5818 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
5819 tmp) {
5820 struct ieee80211_channel *chan;
5821
5822 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5823
5824 if (!chan) {
5825 err = -EINVAL;
5826 goto out_free;
5827 }
5828
5829 /* ignore disabled channels */
5830 if (chan->flags & IEEE80211_CHAN_DISABLED)
5831 continue;
5832
5833 request->channels[i] = chan;
5834 i++;
5835 }
5836 } else {
5837 /* all channels */
5838 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5839 int j;
5840 if (!wiphy->bands[band])
5841 continue;
5842 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5843 struct ieee80211_channel *chan;
5844
5845 chan = &wiphy->bands[band]->channels[j];
5846
5847 if (chan->flags & IEEE80211_CHAN_DISABLED)
5848 continue;
5849
5850 request->channels[i] = chan;
5851 i++;
5852 }
5853 }
5854 }
5855
5856 if (!i) {
5857 err = -EINVAL;
5858 goto out_free;
5859 }
5860
5861 request->n_channels = i;
5862
5863 i = 0;
5864 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5865 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5866 tmp) {
5867 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5868 err = -EINVAL;
5869 goto out_free;
5870 }
5871 request->ssids[i].ssid_len = nla_len(attr);
5872 memcpy(request->ssids[i].ssid, nla_data(attr),
5873 nla_len(attr));
5874 i++;
5875 }
5876 }
5877
5878 i = 0;
5879 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
5880 nla_for_each_nested(attr,
5881 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5882 tmp) {
5883 struct nlattr *ssid, *rssi;
5884
5885 err = nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
5886 nla_data(attr), nla_len(attr),
5887 nl80211_match_policy);
5888 if (err)
5889 goto out_free;
5890 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
5891 if (ssid) {
5892 if (WARN_ON(i >= n_match_sets)) {
5893 /* this indicates a programming error,
5894 * the loop above should have verified
5895 * things properly
5896 */
5897 err = -EINVAL;
5898 goto out_free;
5899 }
5900
5901 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
5902 err = -EINVAL;
5903 goto out_free;
5904 }
5905 memcpy(request->match_sets[i].ssid.ssid,
5906 nla_data(ssid), nla_len(ssid));
5907 request->match_sets[i].ssid.ssid_len =
5908 nla_len(ssid);
5909 /* special attribute - old implemenation w/a */
5910 request->match_sets[i].rssi_thold =
5911 default_match_rssi;
5912 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
5913 if (rssi)
5914 request->match_sets[i].rssi_thold =
5915 nla_get_s32(rssi);
5916 }
5917 i++;
5918 }
5919
5920 /* there was no other matchset, so the RSSI one is alone */
5921 if (i == 0)
5922 request->match_sets[0].rssi_thold = default_match_rssi;
5923
5924 request->min_rssi_thold = INT_MAX;
5925 for (i = 0; i < n_match_sets; i++)
5926 request->min_rssi_thold =
5927 min(request->match_sets[i].rssi_thold,
5928 request->min_rssi_thold);
5929 } else {
5930 request->min_rssi_thold = NL80211_SCAN_RSSI_THOLD_OFF;
5931 }
5932
5933 if (ie_len) {
5934 request->ie_len = ie_len;
5935 memcpy((void *)request->ie,
5936 nla_data(info->attrs[NL80211_ATTR_IE]),
5937 request->ie_len);
5938 }
5939
5940 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5941 request->flags = nla_get_u32(
5942 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5943 if ((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5944 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) {
5945 err = -EOPNOTSUPP;
5946 goto out_free;
5947 }
5948 }
5949
5950 request->dev = dev;
5951 request->wiphy = &rdev->wiphy;
5952 request->interval = interval;
5953 request->scan_start = jiffies;
5954
5955 err = rdev_sched_scan_start(rdev, dev, request);
5956 if (!err) {
5957 rdev->sched_scan_req = request;
5958 nl80211_send_sched_scan(rdev, dev,
5959 NL80211_CMD_START_SCHED_SCAN);
5960 goto out;
5961 }
5962
5963 out_free:
5964 kfree(request);
5965 out:
5966 return err;
5967 }
5968
5969 static int nl80211_stop_sched_scan(struct sk_buff *skb,
5970 struct genl_info *info)
5971 {
5972 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5973
5974 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5975 !rdev->ops->sched_scan_stop)
5976 return -EOPNOTSUPP;
5977
5978 return __cfg80211_stop_sched_scan(rdev, false);
5979 }
5980
5981 static int nl80211_start_radar_detection(struct sk_buff *skb,
5982 struct genl_info *info)
5983 {
5984 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5985 struct net_device *dev = info->user_ptr[1];
5986 struct wireless_dev *wdev = dev->ieee80211_ptr;
5987 struct cfg80211_chan_def chandef;
5988 enum nl80211_dfs_regions dfs_region;
5989 unsigned int cac_time_ms;
5990 int err;
5991
5992 dfs_region = reg_get_dfs_region(wdev->wiphy);
5993 if (dfs_region == NL80211_DFS_UNSET)
5994 return -EINVAL;
5995
5996 err = nl80211_parse_chandef(rdev, info, &chandef);
5997 if (err)
5998 return err;
5999
6000 if (netif_carrier_ok(dev))
6001 return -EBUSY;
6002
6003 if (wdev->cac_started)
6004 return -EBUSY;
6005
6006 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef,
6007 wdev->iftype);
6008 if (err < 0)
6009 return err;
6010
6011 if (err == 0)
6012 return -EINVAL;
6013
6014 if (!cfg80211_chandef_dfs_usable(wdev->wiphy, &chandef))
6015 return -EINVAL;
6016
6017 if (!rdev->ops->start_radar_detection)
6018 return -EOPNOTSUPP;
6019
6020 cac_time_ms = cfg80211_chandef_dfs_cac_time(&rdev->wiphy, &chandef);
6021 if (WARN_ON(!cac_time_ms))
6022 cac_time_ms = IEEE80211_DFS_MIN_CAC_TIME_MS;
6023
6024 err = rdev->ops->start_radar_detection(&rdev->wiphy, dev, &chandef,
6025 cac_time_ms);
6026 if (!err) {
6027 wdev->chandef = chandef;
6028 wdev->cac_started = true;
6029 wdev->cac_start_time = jiffies;
6030 wdev->cac_time_ms = cac_time_ms;
6031 }
6032 return err;
6033 }
6034
6035 static int nl80211_channel_switch(struct sk_buff *skb, struct genl_info *info)
6036 {
6037 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6038 struct net_device *dev = info->user_ptr[1];
6039 struct wireless_dev *wdev = dev->ieee80211_ptr;
6040 struct cfg80211_csa_settings params;
6041 /* csa_attrs is defined static to avoid waste of stack size - this
6042 * function is called under RTNL lock, so this should not be a problem.
6043 */
6044 static struct nlattr *csa_attrs[NL80211_ATTR_MAX+1];
6045 int err;
6046 bool need_new_beacon = false;
6047 int len, i;
6048 u32 cs_count;
6049
6050 if (!rdev->ops->channel_switch ||
6051 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_CHANNEL_SWITCH))
6052 return -EOPNOTSUPP;
6053
6054 switch (dev->ieee80211_ptr->iftype) {
6055 case NL80211_IFTYPE_AP:
6056 case NL80211_IFTYPE_P2P_GO:
6057 need_new_beacon = true;
6058
6059 /* useless if AP is not running */
6060 if (!wdev->beacon_interval)
6061 return -ENOTCONN;
6062 break;
6063 case NL80211_IFTYPE_ADHOC:
6064 if (!wdev->ssid_len)
6065 return -ENOTCONN;
6066 break;
6067 case NL80211_IFTYPE_MESH_POINT:
6068 if (!wdev->mesh_id_len)
6069 return -ENOTCONN;
6070 break;
6071 default:
6072 return -EOPNOTSUPP;
6073 }
6074
6075 memset(&params, 0, sizeof(params));
6076
6077 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
6078 !info->attrs[NL80211_ATTR_CH_SWITCH_COUNT])
6079 return -EINVAL;
6080
6081 /* only important for AP, IBSS and mesh create IEs internally */
6082 if (need_new_beacon && !info->attrs[NL80211_ATTR_CSA_IES])
6083 return -EINVAL;
6084
6085 /* Even though the attribute is u32, the specification says
6086 * u8, so let's make sure we don't overflow.
6087 */
6088 cs_count = nla_get_u32(info->attrs[NL80211_ATTR_CH_SWITCH_COUNT]);
6089 if (cs_count > 255)
6090 return -EINVAL;
6091
6092 params.count = cs_count;
6093
6094 if (!need_new_beacon)
6095 goto skip_beacons;
6096
6097 err = nl80211_parse_beacon(info->attrs, &params.beacon_after);
6098 if (err)
6099 return err;
6100
6101 err = nla_parse_nested(csa_attrs, NL80211_ATTR_MAX,
6102 info->attrs[NL80211_ATTR_CSA_IES],
6103 nl80211_policy);
6104 if (err)
6105 return err;
6106
6107 err = nl80211_parse_beacon(csa_attrs, &params.beacon_csa);
6108 if (err)
6109 return err;
6110
6111 if (!csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON])
6112 return -EINVAL;
6113
6114 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
6115 if (!len || (len % sizeof(u16)))
6116 return -EINVAL;
6117
6118 params.n_counter_offsets_beacon = len / sizeof(u16);
6119 if (rdev->wiphy.max_num_csa_counters &&
6120 (params.n_counter_offsets_beacon >
6121 rdev->wiphy.max_num_csa_counters))
6122 return -EINVAL;
6123
6124 params.counter_offsets_beacon =
6125 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_BEACON]);
6126
6127 /* sanity checks - counters should fit and be the same */
6128 for (i = 0; i < params.n_counter_offsets_beacon; i++) {
6129 u16 offset = params.counter_offsets_beacon[i];
6130
6131 if (offset >= params.beacon_csa.tail_len)
6132 return -EINVAL;
6133
6134 if (params.beacon_csa.tail[offset] != params.count)
6135 return -EINVAL;
6136 }
6137
6138 if (csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]) {
6139 len = nla_len(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
6140 if (!len || (len % sizeof(u16)))
6141 return -EINVAL;
6142
6143 params.n_counter_offsets_presp = len / sizeof(u16);
6144 if (rdev->wiphy.max_num_csa_counters &&
6145 (params.n_counter_offsets_beacon >
6146 rdev->wiphy.max_num_csa_counters))
6147 return -EINVAL;
6148
6149 params.counter_offsets_presp =
6150 nla_data(csa_attrs[NL80211_ATTR_CSA_C_OFF_PRESP]);
6151
6152 /* sanity checks - counters should fit and be the same */
6153 for (i = 0; i < params.n_counter_offsets_presp; i++) {
6154 u16 offset = params.counter_offsets_presp[i];
6155
6156 if (offset >= params.beacon_csa.probe_resp_len)
6157 return -EINVAL;
6158
6159 if (params.beacon_csa.probe_resp[offset] !=
6160 params.count)
6161 return -EINVAL;
6162 }
6163 }
6164
6165 skip_beacons:
6166 err = nl80211_parse_chandef(rdev, info, &params.chandef);
6167 if (err)
6168 return err;
6169
6170 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &params.chandef,
6171 wdev->iftype))
6172 return -EINVAL;
6173
6174 err = cfg80211_chandef_dfs_required(wdev->wiphy,
6175 &params.chandef,
6176 wdev->iftype);
6177 if (err < 0)
6178 return err;
6179
6180 if (err > 0)
6181 params.radar_required = true;
6182
6183 if (info->attrs[NL80211_ATTR_CH_SWITCH_BLOCK_TX])
6184 params.block_tx = true;
6185
6186 wdev_lock(wdev);
6187 err = rdev_channel_switch(rdev, dev, &params);
6188 wdev_unlock(wdev);
6189
6190 return err;
6191 }
6192
6193 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
6194 u32 seq, int flags,
6195 struct cfg80211_registered_device *rdev,
6196 struct wireless_dev *wdev,
6197 struct cfg80211_internal_bss *intbss)
6198 {
6199 struct cfg80211_bss *res = &intbss->pub;
6200 const struct cfg80211_bss_ies *ies;
6201 void *hdr;
6202 struct nlattr *bss;
6203
6204 ASSERT_WDEV_LOCK(wdev);
6205
6206 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
6207 NL80211_CMD_NEW_SCAN_RESULTS);
6208 if (!hdr)
6209 return -1;
6210
6211 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
6212
6213 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
6214 goto nla_put_failure;
6215 if (wdev->netdev &&
6216 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
6217 goto nla_put_failure;
6218 if (nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
6219 goto nla_put_failure;
6220
6221 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
6222 if (!bss)
6223 goto nla_put_failure;
6224 if ((!is_zero_ether_addr(res->bssid) &&
6225 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
6226 goto nla_put_failure;
6227
6228 rcu_read_lock();
6229 /* indicate whether we have probe response data or not */
6230 if (rcu_access_pointer(res->proberesp_ies) &&
6231 nla_put_flag(msg, NL80211_BSS_PRESP_DATA))
6232 goto fail_unlock_rcu;
6233
6234 /* this pointer prefers to be pointed to probe response data
6235 * but is always valid
6236 */
6237 ies = rcu_dereference(res->ies);
6238 if (ies) {
6239 if (nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
6240 goto fail_unlock_rcu;
6241 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
6242 ies->len, ies->data))
6243 goto fail_unlock_rcu;
6244 }
6245
6246 /* and this pointer is always (unless driver didn't know) beacon data */
6247 ies = rcu_dereference(res->beacon_ies);
6248 if (ies && ies->from_beacon) {
6249 if (nla_put_u64(msg, NL80211_BSS_BEACON_TSF, ies->tsf))
6250 goto fail_unlock_rcu;
6251 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
6252 ies->len, ies->data))
6253 goto fail_unlock_rcu;
6254 }
6255 rcu_read_unlock();
6256
6257 if (res->beacon_interval &&
6258 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
6259 goto nla_put_failure;
6260 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
6261 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
6262 nla_put_u32(msg, NL80211_BSS_CHAN_WIDTH, res->scan_width) ||
6263 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
6264 jiffies_to_msecs(jiffies - intbss->ts)))
6265 goto nla_put_failure;
6266
6267 switch (rdev->wiphy.signal_type) {
6268 case CFG80211_SIGNAL_TYPE_MBM:
6269 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
6270 goto nla_put_failure;
6271 break;
6272 case CFG80211_SIGNAL_TYPE_UNSPEC:
6273 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
6274 goto nla_put_failure;
6275 break;
6276 default:
6277 break;
6278 }
6279
6280 switch (wdev->iftype) {
6281 case NL80211_IFTYPE_P2P_CLIENT:
6282 case NL80211_IFTYPE_STATION:
6283 if (intbss == wdev->current_bss &&
6284 nla_put_u32(msg, NL80211_BSS_STATUS,
6285 NL80211_BSS_STATUS_ASSOCIATED))
6286 goto nla_put_failure;
6287 break;
6288 case NL80211_IFTYPE_ADHOC:
6289 if (intbss == wdev->current_bss &&
6290 nla_put_u32(msg, NL80211_BSS_STATUS,
6291 NL80211_BSS_STATUS_IBSS_JOINED))
6292 goto nla_put_failure;
6293 break;
6294 default:
6295 break;
6296 }
6297
6298 nla_nest_end(msg, bss);
6299
6300 return genlmsg_end(msg, hdr);
6301
6302 fail_unlock_rcu:
6303 rcu_read_unlock();
6304 nla_put_failure:
6305 genlmsg_cancel(msg, hdr);
6306 return -EMSGSIZE;
6307 }
6308
6309 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
6310 {
6311 struct cfg80211_registered_device *rdev;
6312 struct cfg80211_internal_bss *scan;
6313 struct wireless_dev *wdev;
6314 int start = cb->args[2], idx = 0;
6315 int err;
6316
6317 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
6318 if (err)
6319 return err;
6320
6321 wdev_lock(wdev);
6322 spin_lock_bh(&rdev->bss_lock);
6323 cfg80211_bss_expire(rdev);
6324
6325 cb->seq = rdev->bss_generation;
6326
6327 list_for_each_entry(scan, &rdev->bss_list, list) {
6328 if (++idx <= start)
6329 continue;
6330 if (nl80211_send_bss(skb, cb,
6331 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6332 rdev, wdev, scan) < 0) {
6333 idx--;
6334 break;
6335 }
6336 }
6337
6338 spin_unlock_bh(&rdev->bss_lock);
6339 wdev_unlock(wdev);
6340
6341 cb->args[2] = idx;
6342 nl80211_finish_wdev_dump(rdev);
6343
6344 return skb->len;
6345 }
6346
6347 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
6348 int flags, struct net_device *dev,
6349 struct survey_info *survey)
6350 {
6351 void *hdr;
6352 struct nlattr *infoattr;
6353
6354 hdr = nl80211hdr_put(msg, portid, seq, flags,
6355 NL80211_CMD_NEW_SURVEY_RESULTS);
6356 if (!hdr)
6357 return -ENOMEM;
6358
6359 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
6360 goto nla_put_failure;
6361
6362 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
6363 if (!infoattr)
6364 goto nla_put_failure;
6365
6366 if (nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
6367 survey->channel->center_freq))
6368 goto nla_put_failure;
6369
6370 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
6371 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
6372 goto nla_put_failure;
6373 if ((survey->filled & SURVEY_INFO_IN_USE) &&
6374 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
6375 goto nla_put_failure;
6376 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME) &&
6377 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME,
6378 survey->channel_time))
6379 goto nla_put_failure;
6380 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_BUSY) &&
6381 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY,
6382 survey->channel_time_busy))
6383 goto nla_put_failure;
6384 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) &&
6385 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY,
6386 survey->channel_time_ext_busy))
6387 goto nla_put_failure;
6388 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_RX) &&
6389 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_RX,
6390 survey->channel_time_rx))
6391 goto nla_put_failure;
6392 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_TX) &&
6393 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_TX,
6394 survey->channel_time_tx))
6395 goto nla_put_failure;
6396
6397 nla_nest_end(msg, infoattr);
6398
6399 return genlmsg_end(msg, hdr);
6400
6401 nla_put_failure:
6402 genlmsg_cancel(msg, hdr);
6403 return -EMSGSIZE;
6404 }
6405
6406 static int nl80211_dump_survey(struct sk_buff *skb,
6407 struct netlink_callback *cb)
6408 {
6409 struct survey_info survey;
6410 struct cfg80211_registered_device *rdev;
6411 struct wireless_dev *wdev;
6412 int survey_idx = cb->args[2];
6413 int res;
6414
6415 res = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
6416 if (res)
6417 return res;
6418
6419 if (!wdev->netdev) {
6420 res = -EINVAL;
6421 goto out_err;
6422 }
6423
6424 if (!rdev->ops->dump_survey) {
6425 res = -EOPNOTSUPP;
6426 goto out_err;
6427 }
6428
6429 while (1) {
6430 struct ieee80211_channel *chan;
6431
6432 res = rdev_dump_survey(rdev, wdev->netdev, survey_idx, &survey);
6433 if (res == -ENOENT)
6434 break;
6435 if (res)
6436 goto out_err;
6437
6438 /* Survey without a channel doesn't make sense */
6439 if (!survey.channel) {
6440 res = -EINVAL;
6441 goto out;
6442 }
6443
6444 chan = ieee80211_get_channel(&rdev->wiphy,
6445 survey.channel->center_freq);
6446 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
6447 survey_idx++;
6448 continue;
6449 }
6450
6451 if (nl80211_send_survey(skb,
6452 NETLINK_CB(cb->skb).portid,
6453 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6454 wdev->netdev, &survey) < 0)
6455 goto out;
6456 survey_idx++;
6457 }
6458
6459 out:
6460 cb->args[2] = survey_idx;
6461 res = skb->len;
6462 out_err:
6463 nl80211_finish_wdev_dump(rdev);
6464 return res;
6465 }
6466
6467 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
6468 {
6469 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
6470 NL80211_WPA_VERSION_2));
6471 }
6472
6473 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
6474 {
6475 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6476 struct net_device *dev = info->user_ptr[1];
6477 struct ieee80211_channel *chan;
6478 const u8 *bssid, *ssid, *ie = NULL, *sae_data = NULL;
6479 int err, ssid_len, ie_len = 0, sae_data_len = 0;
6480 enum nl80211_auth_type auth_type;
6481 struct key_parse key;
6482 bool local_state_change;
6483
6484 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6485 return -EINVAL;
6486
6487 if (!info->attrs[NL80211_ATTR_MAC])
6488 return -EINVAL;
6489
6490 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
6491 return -EINVAL;
6492
6493 if (!info->attrs[NL80211_ATTR_SSID])
6494 return -EINVAL;
6495
6496 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
6497 return -EINVAL;
6498
6499 err = nl80211_parse_key(info, &key);
6500 if (err)
6501 return err;
6502
6503 if (key.idx >= 0) {
6504 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
6505 return -EINVAL;
6506 if (!key.p.key || !key.p.key_len)
6507 return -EINVAL;
6508 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
6509 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
6510 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
6511 key.p.key_len != WLAN_KEY_LEN_WEP104))
6512 return -EINVAL;
6513 if (key.idx > 4)
6514 return -EINVAL;
6515 } else {
6516 key.p.key_len = 0;
6517 key.p.key = NULL;
6518 }
6519
6520 if (key.idx >= 0) {
6521 int i;
6522 bool ok = false;
6523 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
6524 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
6525 ok = true;
6526 break;
6527 }
6528 }
6529 if (!ok)
6530 return -EINVAL;
6531 }
6532
6533 if (!rdev->ops->auth)
6534 return -EOPNOTSUPP;
6535
6536 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6537 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6538 return -EOPNOTSUPP;
6539
6540 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6541 chan = nl80211_get_valid_chan(&rdev->wiphy,
6542 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
6543 if (!chan)
6544 return -EINVAL;
6545
6546 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6547 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6548
6549 if (info->attrs[NL80211_ATTR_IE]) {
6550 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6551 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6552 }
6553
6554 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
6555 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
6556 return -EINVAL;
6557
6558 if (auth_type == NL80211_AUTHTYPE_SAE &&
6559 !info->attrs[NL80211_ATTR_SAE_DATA])
6560 return -EINVAL;
6561
6562 if (info->attrs[NL80211_ATTR_SAE_DATA]) {
6563 if (auth_type != NL80211_AUTHTYPE_SAE)
6564 return -EINVAL;
6565 sae_data = nla_data(info->attrs[NL80211_ATTR_SAE_DATA]);
6566 sae_data_len = nla_len(info->attrs[NL80211_ATTR_SAE_DATA]);
6567 /* need to include at least Auth Transaction and Status Code */
6568 if (sae_data_len < 4)
6569 return -EINVAL;
6570 }
6571
6572 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6573
6574 /*
6575 * Since we no longer track auth state, ignore
6576 * requests to only change local state.
6577 */
6578 if (local_state_change)
6579 return 0;
6580
6581 wdev_lock(dev->ieee80211_ptr);
6582 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
6583 ssid, ssid_len, ie, ie_len,
6584 key.p.key, key.p.key_len, key.idx,
6585 sae_data, sae_data_len);
6586 wdev_unlock(dev->ieee80211_ptr);
6587 return err;
6588 }
6589
6590 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
6591 struct genl_info *info,
6592 struct cfg80211_crypto_settings *settings,
6593 int cipher_limit)
6594 {
6595 memset(settings, 0, sizeof(*settings));
6596
6597 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
6598
6599 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
6600 u16 proto;
6601 proto = nla_get_u16(
6602 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
6603 settings->control_port_ethertype = cpu_to_be16(proto);
6604 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
6605 proto != ETH_P_PAE)
6606 return -EINVAL;
6607 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
6608 settings->control_port_no_encrypt = true;
6609 } else
6610 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
6611
6612 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
6613 void *data;
6614 int len, i;
6615
6616 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
6617 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
6618 settings->n_ciphers_pairwise = len / sizeof(u32);
6619
6620 if (len % sizeof(u32))
6621 return -EINVAL;
6622
6623 if (settings->n_ciphers_pairwise > cipher_limit)
6624 return -EINVAL;
6625
6626 memcpy(settings->ciphers_pairwise, data, len);
6627
6628 for (i = 0; i < settings->n_ciphers_pairwise; i++)
6629 if (!cfg80211_supported_cipher_suite(
6630 &rdev->wiphy,
6631 settings->ciphers_pairwise[i]))
6632 return -EINVAL;
6633 }
6634
6635 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
6636 settings->cipher_group =
6637 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
6638 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
6639 settings->cipher_group))
6640 return -EINVAL;
6641 }
6642
6643 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
6644 settings->wpa_versions =
6645 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
6646 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
6647 return -EINVAL;
6648 }
6649
6650 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
6651 void *data;
6652 int len;
6653
6654 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
6655 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
6656 settings->n_akm_suites = len / sizeof(u32);
6657
6658 if (len % sizeof(u32))
6659 return -EINVAL;
6660
6661 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
6662 return -EINVAL;
6663
6664 memcpy(settings->akm_suites, data, len);
6665 }
6666
6667 return 0;
6668 }
6669
6670 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
6671 {
6672 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6673 struct net_device *dev = info->user_ptr[1];
6674 struct ieee80211_channel *chan;
6675 struct cfg80211_assoc_request req = {};
6676 const u8 *bssid, *ssid;
6677 int err, ssid_len = 0;
6678
6679 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6680 return -EINVAL;
6681
6682 if (!info->attrs[NL80211_ATTR_MAC] ||
6683 !info->attrs[NL80211_ATTR_SSID] ||
6684 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
6685 return -EINVAL;
6686
6687 if (!rdev->ops->assoc)
6688 return -EOPNOTSUPP;
6689
6690 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6691 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6692 return -EOPNOTSUPP;
6693
6694 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6695
6696 chan = nl80211_get_valid_chan(&rdev->wiphy,
6697 info->attrs[NL80211_ATTR_WIPHY_FREQ]);
6698 if (!chan)
6699 return -EINVAL;
6700
6701 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6702 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6703
6704 if (info->attrs[NL80211_ATTR_IE]) {
6705 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6706 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6707 }
6708
6709 if (info->attrs[NL80211_ATTR_USE_MFP]) {
6710 enum nl80211_mfp mfp =
6711 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
6712 if (mfp == NL80211_MFP_REQUIRED)
6713 req.use_mfp = true;
6714 else if (mfp != NL80211_MFP_NO)
6715 return -EINVAL;
6716 }
6717
6718 if (info->attrs[NL80211_ATTR_PREV_BSSID])
6719 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
6720
6721 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
6722 req.flags |= ASSOC_REQ_DISABLE_HT;
6723
6724 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6725 memcpy(&req.ht_capa_mask,
6726 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6727 sizeof(req.ht_capa_mask));
6728
6729 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6730 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6731 return -EINVAL;
6732 memcpy(&req.ht_capa,
6733 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6734 sizeof(req.ht_capa));
6735 }
6736
6737 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
6738 req.flags |= ASSOC_REQ_DISABLE_VHT;
6739
6740 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6741 memcpy(&req.vht_capa_mask,
6742 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
6743 sizeof(req.vht_capa_mask));
6744
6745 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
6746 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6747 return -EINVAL;
6748 memcpy(&req.vht_capa,
6749 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
6750 sizeof(req.vht_capa));
6751 }
6752
6753 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
6754 if (!(rdev->wiphy.features &
6755 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) ||
6756 !(rdev->wiphy.features & NL80211_FEATURE_QUIET))
6757 return -EINVAL;
6758 req.flags |= ASSOC_REQ_USE_RRM;
6759 }
6760
6761 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
6762 if (!err) {
6763 wdev_lock(dev->ieee80211_ptr);
6764 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
6765 ssid, ssid_len, &req);
6766 wdev_unlock(dev->ieee80211_ptr);
6767 }
6768
6769 return err;
6770 }
6771
6772 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
6773 {
6774 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6775 struct net_device *dev = info->user_ptr[1];
6776 const u8 *ie = NULL, *bssid;
6777 int ie_len = 0, err;
6778 u16 reason_code;
6779 bool local_state_change;
6780
6781 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6782 return -EINVAL;
6783
6784 if (!info->attrs[NL80211_ATTR_MAC])
6785 return -EINVAL;
6786
6787 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6788 return -EINVAL;
6789
6790 if (!rdev->ops->deauth)
6791 return -EOPNOTSUPP;
6792
6793 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6794 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6795 return -EOPNOTSUPP;
6796
6797 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6798
6799 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6800 if (reason_code == 0) {
6801 /* Reason Code 0 is reserved */
6802 return -EINVAL;
6803 }
6804
6805 if (info->attrs[NL80211_ATTR_IE]) {
6806 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6807 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6808 }
6809
6810 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6811
6812 wdev_lock(dev->ieee80211_ptr);
6813 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
6814 local_state_change);
6815 wdev_unlock(dev->ieee80211_ptr);
6816 return err;
6817 }
6818
6819 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
6820 {
6821 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6822 struct net_device *dev = info->user_ptr[1];
6823 const u8 *ie = NULL, *bssid;
6824 int ie_len = 0, err;
6825 u16 reason_code;
6826 bool local_state_change;
6827
6828 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6829 return -EINVAL;
6830
6831 if (!info->attrs[NL80211_ATTR_MAC])
6832 return -EINVAL;
6833
6834 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6835 return -EINVAL;
6836
6837 if (!rdev->ops->disassoc)
6838 return -EOPNOTSUPP;
6839
6840 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6841 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6842 return -EOPNOTSUPP;
6843
6844 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6845
6846 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6847 if (reason_code == 0) {
6848 /* Reason Code 0 is reserved */
6849 return -EINVAL;
6850 }
6851
6852 if (info->attrs[NL80211_ATTR_IE]) {
6853 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6854 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6855 }
6856
6857 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6858
6859 wdev_lock(dev->ieee80211_ptr);
6860 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
6861 local_state_change);
6862 wdev_unlock(dev->ieee80211_ptr);
6863 return err;
6864 }
6865
6866 static bool
6867 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
6868 int mcast_rate[IEEE80211_NUM_BANDS],
6869 int rateval)
6870 {
6871 struct wiphy *wiphy = &rdev->wiphy;
6872 bool found = false;
6873 int band, i;
6874
6875 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
6876 struct ieee80211_supported_band *sband;
6877
6878 sband = wiphy->bands[band];
6879 if (!sband)
6880 continue;
6881
6882 for (i = 0; i < sband->n_bitrates; i++) {
6883 if (sband->bitrates[i].bitrate == rateval) {
6884 mcast_rate[band] = i + 1;
6885 found = true;
6886 break;
6887 }
6888 }
6889 }
6890
6891 return found;
6892 }
6893
6894 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
6895 {
6896 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6897 struct net_device *dev = info->user_ptr[1];
6898 struct cfg80211_ibss_params ibss;
6899 struct wiphy *wiphy;
6900 struct cfg80211_cached_keys *connkeys = NULL;
6901 int err;
6902
6903 memset(&ibss, 0, sizeof(ibss));
6904
6905 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6906 return -EINVAL;
6907
6908 if (!info->attrs[NL80211_ATTR_SSID] ||
6909 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6910 return -EINVAL;
6911
6912 ibss.beacon_interval = 100;
6913
6914 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
6915 ibss.beacon_interval =
6916 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
6917 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
6918 return -EINVAL;
6919 }
6920
6921 if (!rdev->ops->join_ibss)
6922 return -EOPNOTSUPP;
6923
6924 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6925 return -EOPNOTSUPP;
6926
6927 wiphy = &rdev->wiphy;
6928
6929 if (info->attrs[NL80211_ATTR_MAC]) {
6930 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6931
6932 if (!is_valid_ether_addr(ibss.bssid))
6933 return -EINVAL;
6934 }
6935 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6936 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6937
6938 if (info->attrs[NL80211_ATTR_IE]) {
6939 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6940 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6941 }
6942
6943 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
6944 if (err)
6945 return err;
6946
6947 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef,
6948 NL80211_IFTYPE_ADHOC))
6949 return -EINVAL;
6950
6951 switch (ibss.chandef.width) {
6952 case NL80211_CHAN_WIDTH_5:
6953 case NL80211_CHAN_WIDTH_10:
6954 case NL80211_CHAN_WIDTH_20_NOHT:
6955 break;
6956 case NL80211_CHAN_WIDTH_20:
6957 case NL80211_CHAN_WIDTH_40:
6958 if (rdev->wiphy.features & NL80211_FEATURE_HT_IBSS)
6959 break;
6960 default:
6961 return -EINVAL;
6962 }
6963
6964 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
6965 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
6966
6967 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6968 u8 *rates =
6969 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6970 int n_rates =
6971 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6972 struct ieee80211_supported_band *sband =
6973 wiphy->bands[ibss.chandef.chan->band];
6974
6975 err = ieee80211_get_ratemask(sband, rates, n_rates,
6976 &ibss.basic_rates);
6977 if (err)
6978 return err;
6979 }
6980
6981 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6982 memcpy(&ibss.ht_capa_mask,
6983 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6984 sizeof(ibss.ht_capa_mask));
6985
6986 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6987 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6988 return -EINVAL;
6989 memcpy(&ibss.ht_capa,
6990 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6991 sizeof(ibss.ht_capa));
6992 }
6993
6994 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
6995 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
6996 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
6997 return -EINVAL;
6998
6999 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
7000 bool no_ht = false;
7001
7002 connkeys = nl80211_parse_connkeys(rdev,
7003 info->attrs[NL80211_ATTR_KEYS],
7004 &no_ht);
7005 if (IS_ERR(connkeys))
7006 return PTR_ERR(connkeys);
7007
7008 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
7009 no_ht) {
7010 kfree(connkeys);
7011 return -EINVAL;
7012 }
7013 }
7014
7015 ibss.control_port =
7016 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
7017
7018 ibss.userspace_handles_dfs =
7019 nla_get_flag(info->attrs[NL80211_ATTR_HANDLE_DFS]);
7020
7021 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
7022 if (err)
7023 kzfree(connkeys);
7024 return err;
7025 }
7026
7027 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
7028 {
7029 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7030 struct net_device *dev = info->user_ptr[1];
7031
7032 if (!rdev->ops->leave_ibss)
7033 return -EOPNOTSUPP;
7034
7035 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
7036 return -EOPNOTSUPP;
7037
7038 return cfg80211_leave_ibss(rdev, dev, false);
7039 }
7040
7041 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
7042 {
7043 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7044 struct net_device *dev = info->user_ptr[1];
7045 int mcast_rate[IEEE80211_NUM_BANDS];
7046 u32 nla_rate;
7047 int err;
7048
7049 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
7050 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
7051 return -EOPNOTSUPP;
7052
7053 if (!rdev->ops->set_mcast_rate)
7054 return -EOPNOTSUPP;
7055
7056 memset(mcast_rate, 0, sizeof(mcast_rate));
7057
7058 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
7059 return -EINVAL;
7060
7061 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
7062 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
7063 return -EINVAL;
7064
7065 err = rdev->ops->set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
7066
7067 return err;
7068 }
7069
7070 static struct sk_buff *
7071 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
7072 int approxlen, u32 portid, u32 seq,
7073 enum nl80211_commands cmd,
7074 enum nl80211_attrs attr,
7075 const struct nl80211_vendor_cmd_info *info,
7076 gfp_t gfp)
7077 {
7078 struct sk_buff *skb;
7079 void *hdr;
7080 struct nlattr *data;
7081
7082 skb = nlmsg_new(approxlen + 100, gfp);
7083 if (!skb)
7084 return NULL;
7085
7086 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
7087 if (!hdr) {
7088 kfree_skb(skb);
7089 return NULL;
7090 }
7091
7092 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
7093 goto nla_put_failure;
7094
7095 if (info) {
7096 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
7097 info->vendor_id))
7098 goto nla_put_failure;
7099 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
7100 info->subcmd))
7101 goto nla_put_failure;
7102 }
7103
7104 data = nla_nest_start(skb, attr);
7105
7106 ((void **)skb->cb)[0] = rdev;
7107 ((void **)skb->cb)[1] = hdr;
7108 ((void **)skb->cb)[2] = data;
7109
7110 return skb;
7111
7112 nla_put_failure:
7113 kfree_skb(skb);
7114 return NULL;
7115 }
7116
7117 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
7118 enum nl80211_commands cmd,
7119 enum nl80211_attrs attr,
7120 int vendor_event_idx,
7121 int approxlen, gfp_t gfp)
7122 {
7123 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
7124 const struct nl80211_vendor_cmd_info *info;
7125
7126 switch (cmd) {
7127 case NL80211_CMD_TESTMODE:
7128 if (WARN_ON(vendor_event_idx != -1))
7129 return NULL;
7130 info = NULL;
7131 break;
7132 case NL80211_CMD_VENDOR:
7133 if (WARN_ON(vendor_event_idx < 0 ||
7134 vendor_event_idx >= wiphy->n_vendor_events))
7135 return NULL;
7136 info = &wiphy->vendor_events[vendor_event_idx];
7137 break;
7138 default:
7139 WARN_ON(1);
7140 return NULL;
7141 }
7142
7143 return __cfg80211_alloc_vendor_skb(rdev, approxlen, 0, 0,
7144 cmd, attr, info, gfp);
7145 }
7146 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
7147
7148 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
7149 {
7150 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
7151 void *hdr = ((void **)skb->cb)[1];
7152 struct nlattr *data = ((void **)skb->cb)[2];
7153 enum nl80211_multicast_groups mcgrp = NL80211_MCGRP_TESTMODE;
7154
7155 /* clear CB data for netlink core to own from now on */
7156 memset(skb->cb, 0, sizeof(skb->cb));
7157
7158 nla_nest_end(skb, data);
7159 genlmsg_end(skb, hdr);
7160
7161 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
7162 mcgrp = NL80211_MCGRP_VENDOR;
7163
7164 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), skb, 0,
7165 mcgrp, gfp);
7166 }
7167 EXPORT_SYMBOL(__cfg80211_send_event_skb);
7168
7169 #ifdef CONFIG_NL80211_TESTMODE
7170 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
7171 {
7172 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7173 struct wireless_dev *wdev =
7174 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
7175 int err;
7176
7177 if (!rdev->ops->testmode_cmd)
7178 return -EOPNOTSUPP;
7179
7180 if (IS_ERR(wdev)) {
7181 err = PTR_ERR(wdev);
7182 if (err != -EINVAL)
7183 return err;
7184 wdev = NULL;
7185 } else if (wdev->wiphy != &rdev->wiphy) {
7186 return -EINVAL;
7187 }
7188
7189 if (!info->attrs[NL80211_ATTR_TESTDATA])
7190 return -EINVAL;
7191
7192 rdev->cur_cmd_info = info;
7193 err = rdev_testmode_cmd(rdev, wdev,
7194 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
7195 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
7196 rdev->cur_cmd_info = NULL;
7197
7198 return err;
7199 }
7200
7201 static int nl80211_testmode_dump(struct sk_buff *skb,
7202 struct netlink_callback *cb)
7203 {
7204 struct cfg80211_registered_device *rdev;
7205 int err;
7206 long phy_idx;
7207 void *data = NULL;
7208 int data_len = 0;
7209
7210 rtnl_lock();
7211
7212 if (cb->args[0]) {
7213 /*
7214 * 0 is a valid index, but not valid for args[0],
7215 * so we need to offset by 1.
7216 */
7217 phy_idx = cb->args[0] - 1;
7218 } else {
7219 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
7220 nl80211_fam.attrbuf, nl80211_fam.maxattr,
7221 nl80211_policy);
7222 if (err)
7223 goto out_err;
7224
7225 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk),
7226 nl80211_fam.attrbuf);
7227 if (IS_ERR(rdev)) {
7228 err = PTR_ERR(rdev);
7229 goto out_err;
7230 }
7231 phy_idx = rdev->wiphy_idx;
7232 rdev = NULL;
7233
7234 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
7235 cb->args[1] =
7236 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
7237 }
7238
7239 if (cb->args[1]) {
7240 data = nla_data((void *)cb->args[1]);
7241 data_len = nla_len((void *)cb->args[1]);
7242 }
7243
7244 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
7245 if (!rdev) {
7246 err = -ENOENT;
7247 goto out_err;
7248 }
7249
7250 if (!rdev->ops->testmode_dump) {
7251 err = -EOPNOTSUPP;
7252 goto out_err;
7253 }
7254
7255 while (1) {
7256 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
7257 cb->nlh->nlmsg_seq, NLM_F_MULTI,
7258 NL80211_CMD_TESTMODE);
7259 struct nlattr *tmdata;
7260
7261 if (!hdr)
7262 break;
7263
7264 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
7265 genlmsg_cancel(skb, hdr);
7266 break;
7267 }
7268
7269 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
7270 if (!tmdata) {
7271 genlmsg_cancel(skb, hdr);
7272 break;
7273 }
7274 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
7275 nla_nest_end(skb, tmdata);
7276
7277 if (err == -ENOBUFS || err == -ENOENT) {
7278 genlmsg_cancel(skb, hdr);
7279 break;
7280 } else if (err) {
7281 genlmsg_cancel(skb, hdr);
7282 goto out_err;
7283 }
7284
7285 genlmsg_end(skb, hdr);
7286 }
7287
7288 err = skb->len;
7289 /* see above */
7290 cb->args[0] = phy_idx + 1;
7291 out_err:
7292 rtnl_unlock();
7293 return err;
7294 }
7295 #endif
7296
7297 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
7298 {
7299 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7300 struct net_device *dev = info->user_ptr[1];
7301 struct cfg80211_connect_params connect;
7302 struct wiphy *wiphy;
7303 struct cfg80211_cached_keys *connkeys = NULL;
7304 int err;
7305
7306 memset(&connect, 0, sizeof(connect));
7307
7308 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
7309 return -EINVAL;
7310
7311 if (!info->attrs[NL80211_ATTR_SSID] ||
7312 !nla_len(info->attrs[NL80211_ATTR_SSID]))
7313 return -EINVAL;
7314
7315 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
7316 connect.auth_type =
7317 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
7318 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
7319 NL80211_CMD_CONNECT))
7320 return -EINVAL;
7321 } else
7322 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
7323
7324 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
7325
7326 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
7327 NL80211_MAX_NR_CIPHER_SUITES);
7328 if (err)
7329 return err;
7330
7331 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
7332 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7333 return -EOPNOTSUPP;
7334
7335 wiphy = &rdev->wiphy;
7336
7337 connect.bg_scan_period = -1;
7338 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
7339 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
7340 connect.bg_scan_period =
7341 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
7342 }
7343
7344 if (info->attrs[NL80211_ATTR_MAC])
7345 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
7346 else if (info->attrs[NL80211_ATTR_MAC_HINT])
7347 connect.bssid_hint =
7348 nla_data(info->attrs[NL80211_ATTR_MAC_HINT]);
7349 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
7350 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
7351
7352 if (info->attrs[NL80211_ATTR_IE]) {
7353 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
7354 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
7355 }
7356
7357 if (info->attrs[NL80211_ATTR_USE_MFP]) {
7358 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
7359 if (connect.mfp != NL80211_MFP_REQUIRED &&
7360 connect.mfp != NL80211_MFP_NO)
7361 return -EINVAL;
7362 } else {
7363 connect.mfp = NL80211_MFP_NO;
7364 }
7365
7366 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
7367 connect.channel = nl80211_get_valid_chan(
7368 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ]);
7369 if (!connect.channel)
7370 return -EINVAL;
7371 } else if (info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]) {
7372 connect.channel_hint = nl80211_get_valid_chan(
7373 wiphy, info->attrs[NL80211_ATTR_WIPHY_FREQ_HINT]);
7374 if (!connect.channel_hint)
7375 return -EINVAL;
7376 }
7377
7378 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
7379 connkeys = nl80211_parse_connkeys(rdev,
7380 info->attrs[NL80211_ATTR_KEYS], NULL);
7381 if (IS_ERR(connkeys))
7382 return PTR_ERR(connkeys);
7383 }
7384
7385 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
7386 connect.flags |= ASSOC_REQ_DISABLE_HT;
7387
7388 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
7389 memcpy(&connect.ht_capa_mask,
7390 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
7391 sizeof(connect.ht_capa_mask));
7392
7393 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
7394 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
7395 kzfree(connkeys);
7396 return -EINVAL;
7397 }
7398 memcpy(&connect.ht_capa,
7399 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
7400 sizeof(connect.ht_capa));
7401 }
7402
7403 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
7404 connect.flags |= ASSOC_REQ_DISABLE_VHT;
7405
7406 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
7407 memcpy(&connect.vht_capa_mask,
7408 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
7409 sizeof(connect.vht_capa_mask));
7410
7411 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
7412 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
7413 kzfree(connkeys);
7414 return -EINVAL;
7415 }
7416 memcpy(&connect.vht_capa,
7417 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
7418 sizeof(connect.vht_capa));
7419 }
7420
7421 if (nla_get_flag(info->attrs[NL80211_ATTR_USE_RRM])) {
7422 if (!(rdev->wiphy.features &
7423 NL80211_FEATURE_DS_PARAM_SET_IE_IN_PROBES) ||
7424 !(rdev->wiphy.features & NL80211_FEATURE_QUIET))
7425 return -EINVAL;
7426 connect.flags |= ASSOC_REQ_USE_RRM;
7427 }
7428
7429 wdev_lock(dev->ieee80211_ptr);
7430 err = cfg80211_connect(rdev, dev, &connect, connkeys, NULL);
7431 wdev_unlock(dev->ieee80211_ptr);
7432 if (err)
7433 kzfree(connkeys);
7434 return err;
7435 }
7436
7437 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
7438 {
7439 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7440 struct net_device *dev = info->user_ptr[1];
7441 u16 reason;
7442 int ret;
7443
7444 if (!info->attrs[NL80211_ATTR_REASON_CODE])
7445 reason = WLAN_REASON_DEAUTH_LEAVING;
7446 else
7447 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
7448
7449 if (reason == 0)
7450 return -EINVAL;
7451
7452 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
7453 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7454 return -EOPNOTSUPP;
7455
7456 wdev_lock(dev->ieee80211_ptr);
7457 ret = cfg80211_disconnect(rdev, dev, reason, true);
7458 wdev_unlock(dev->ieee80211_ptr);
7459 return ret;
7460 }
7461
7462 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
7463 {
7464 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7465 struct net *net;
7466 int err;
7467 u32 pid;
7468
7469 if (!info->attrs[NL80211_ATTR_PID])
7470 return -EINVAL;
7471
7472 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
7473
7474 net = get_net_ns_by_pid(pid);
7475 if (IS_ERR(net))
7476 return PTR_ERR(net);
7477
7478 err = 0;
7479
7480 /* check if anything to do */
7481 if (!net_eq(wiphy_net(&rdev->wiphy), net))
7482 err = cfg80211_switch_netns(rdev, net);
7483
7484 put_net(net);
7485 return err;
7486 }
7487
7488 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
7489 {
7490 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7491 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
7492 struct cfg80211_pmksa *pmksa) = NULL;
7493 struct net_device *dev = info->user_ptr[1];
7494 struct cfg80211_pmksa pmksa;
7495
7496 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
7497
7498 if (!info->attrs[NL80211_ATTR_MAC])
7499 return -EINVAL;
7500
7501 if (!info->attrs[NL80211_ATTR_PMKID])
7502 return -EINVAL;
7503
7504 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
7505 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
7506
7507 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
7508 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7509 return -EOPNOTSUPP;
7510
7511 switch (info->genlhdr->cmd) {
7512 case NL80211_CMD_SET_PMKSA:
7513 rdev_ops = rdev->ops->set_pmksa;
7514 break;
7515 case NL80211_CMD_DEL_PMKSA:
7516 rdev_ops = rdev->ops->del_pmksa;
7517 break;
7518 default:
7519 WARN_ON(1);
7520 break;
7521 }
7522
7523 if (!rdev_ops)
7524 return -EOPNOTSUPP;
7525
7526 return rdev_ops(&rdev->wiphy, dev, &pmksa);
7527 }
7528
7529 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
7530 {
7531 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7532 struct net_device *dev = info->user_ptr[1];
7533
7534 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
7535 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
7536 return -EOPNOTSUPP;
7537
7538 if (!rdev->ops->flush_pmksa)
7539 return -EOPNOTSUPP;
7540
7541 return rdev_flush_pmksa(rdev, dev);
7542 }
7543
7544 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
7545 {
7546 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7547 struct net_device *dev = info->user_ptr[1];
7548 u8 action_code, dialog_token;
7549 u32 peer_capability = 0;
7550 u16 status_code;
7551 u8 *peer;
7552 bool initiator;
7553
7554 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
7555 !rdev->ops->tdls_mgmt)
7556 return -EOPNOTSUPP;
7557
7558 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
7559 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
7560 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
7561 !info->attrs[NL80211_ATTR_IE] ||
7562 !info->attrs[NL80211_ATTR_MAC])
7563 return -EINVAL;
7564
7565 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
7566 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
7567 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
7568 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
7569 initiator = nla_get_flag(info->attrs[NL80211_ATTR_TDLS_INITIATOR]);
7570 if (info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY])
7571 peer_capability =
7572 nla_get_u32(info->attrs[NL80211_ATTR_TDLS_PEER_CAPABILITY]);
7573
7574 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
7575 dialog_token, status_code, peer_capability,
7576 initiator,
7577 nla_data(info->attrs[NL80211_ATTR_IE]),
7578 nla_len(info->attrs[NL80211_ATTR_IE]));
7579 }
7580
7581 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
7582 {
7583 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7584 struct net_device *dev = info->user_ptr[1];
7585 enum nl80211_tdls_operation operation;
7586 u8 *peer;
7587
7588 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
7589 !rdev->ops->tdls_oper)
7590 return -EOPNOTSUPP;
7591
7592 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
7593 !info->attrs[NL80211_ATTR_MAC])
7594 return -EINVAL;
7595
7596 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
7597 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
7598
7599 return rdev_tdls_oper(rdev, dev, peer, operation);
7600 }
7601
7602 static int nl80211_remain_on_channel(struct sk_buff *skb,
7603 struct genl_info *info)
7604 {
7605 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7606 struct wireless_dev *wdev = info->user_ptr[1];
7607 struct cfg80211_chan_def chandef;
7608 struct sk_buff *msg;
7609 void *hdr;
7610 u64 cookie;
7611 u32 duration;
7612 int err;
7613
7614 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
7615 !info->attrs[NL80211_ATTR_DURATION])
7616 return -EINVAL;
7617
7618 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
7619
7620 if (!rdev->ops->remain_on_channel ||
7621 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
7622 return -EOPNOTSUPP;
7623
7624 /*
7625 * We should be on that channel for at least a minimum amount of
7626 * time (10ms) but no longer than the driver supports.
7627 */
7628 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
7629 duration > rdev->wiphy.max_remain_on_channel_duration)
7630 return -EINVAL;
7631
7632 err = nl80211_parse_chandef(rdev, info, &chandef);
7633 if (err)
7634 return err;
7635
7636 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7637 if (!msg)
7638 return -ENOMEM;
7639
7640 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7641 NL80211_CMD_REMAIN_ON_CHANNEL);
7642 if (!hdr) {
7643 err = -ENOBUFS;
7644 goto free_msg;
7645 }
7646
7647 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
7648 duration, &cookie);
7649
7650 if (err)
7651 goto free_msg;
7652
7653 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7654 goto nla_put_failure;
7655
7656 genlmsg_end(msg, hdr);
7657
7658 return genlmsg_reply(msg, info);
7659
7660 nla_put_failure:
7661 err = -ENOBUFS;
7662 free_msg:
7663 nlmsg_free(msg);
7664 return err;
7665 }
7666
7667 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
7668 struct genl_info *info)
7669 {
7670 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7671 struct wireless_dev *wdev = info->user_ptr[1];
7672 u64 cookie;
7673
7674 if (!info->attrs[NL80211_ATTR_COOKIE])
7675 return -EINVAL;
7676
7677 if (!rdev->ops->cancel_remain_on_channel)
7678 return -EOPNOTSUPP;
7679
7680 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7681
7682 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
7683 }
7684
7685 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
7686 u8 *rates, u8 rates_len)
7687 {
7688 u8 i;
7689 u32 mask = 0;
7690
7691 for (i = 0; i < rates_len; i++) {
7692 int rate = (rates[i] & 0x7f) * 5;
7693 int ridx;
7694 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
7695 struct ieee80211_rate *srate =
7696 &sband->bitrates[ridx];
7697 if (rate == srate->bitrate) {
7698 mask |= 1 << ridx;
7699 break;
7700 }
7701 }
7702 if (ridx == sband->n_bitrates)
7703 return 0; /* rate not found */
7704 }
7705
7706 return mask;
7707 }
7708
7709 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
7710 u8 *rates, u8 rates_len,
7711 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
7712 {
7713 u8 i;
7714
7715 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
7716
7717 for (i = 0; i < rates_len; i++) {
7718 int ridx, rbit;
7719
7720 ridx = rates[i] / 8;
7721 rbit = BIT(rates[i] % 8);
7722
7723 /* check validity */
7724 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
7725 return false;
7726
7727 /* check availability */
7728 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
7729 mcs[ridx] |= rbit;
7730 else
7731 return false;
7732 }
7733
7734 return true;
7735 }
7736
7737 static u16 vht_mcs_map_to_mcs_mask(u8 vht_mcs_map)
7738 {
7739 u16 mcs_mask = 0;
7740
7741 switch (vht_mcs_map) {
7742 case IEEE80211_VHT_MCS_NOT_SUPPORTED:
7743 break;
7744 case IEEE80211_VHT_MCS_SUPPORT_0_7:
7745 mcs_mask = 0x00FF;
7746 break;
7747 case IEEE80211_VHT_MCS_SUPPORT_0_8:
7748 mcs_mask = 0x01FF;
7749 break;
7750 case IEEE80211_VHT_MCS_SUPPORT_0_9:
7751 mcs_mask = 0x03FF;
7752 break;
7753 default:
7754 break;
7755 }
7756
7757 return mcs_mask;
7758 }
7759
7760 static void vht_build_mcs_mask(u16 vht_mcs_map,
7761 u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
7762 {
7763 u8 nss;
7764
7765 for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
7766 vht_mcs_mask[nss] = vht_mcs_map_to_mcs_mask(vht_mcs_map & 0x03);
7767 vht_mcs_map >>= 2;
7768 }
7769 }
7770
7771 static bool vht_set_mcs_mask(struct ieee80211_supported_band *sband,
7772 struct nl80211_txrate_vht *txrate,
7773 u16 mcs[NL80211_VHT_NSS_MAX])
7774 {
7775 u16 tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7776 u16 tx_mcs_mask[NL80211_VHT_NSS_MAX] = {};
7777 u8 i;
7778
7779 if (!sband->vht_cap.vht_supported)
7780 return false;
7781
7782 memset(mcs, 0, sizeof(u16) * NL80211_VHT_NSS_MAX);
7783
7784 /* Build vht_mcs_mask from VHT capabilities */
7785 vht_build_mcs_mask(tx_mcs_map, tx_mcs_mask);
7786
7787 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
7788 if ((tx_mcs_mask[i] & txrate->mcs[i]) == txrate->mcs[i])
7789 mcs[i] = txrate->mcs[i];
7790 else
7791 return false;
7792 }
7793
7794 return true;
7795 }
7796
7797 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
7798 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
7799 .len = NL80211_MAX_SUPP_RATES },
7800 [NL80211_TXRATE_HT] = { .type = NLA_BINARY,
7801 .len = NL80211_MAX_SUPP_HT_RATES },
7802 [NL80211_TXRATE_VHT] = { .len = sizeof(struct nl80211_txrate_vht)},
7803 [NL80211_TXRATE_GI] = { .type = NLA_U8 },
7804 };
7805
7806 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
7807 struct genl_info *info)
7808 {
7809 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
7810 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7811 struct cfg80211_bitrate_mask mask;
7812 int rem, i;
7813 struct net_device *dev = info->user_ptr[1];
7814 struct nlattr *tx_rates;
7815 struct ieee80211_supported_band *sband;
7816 u16 vht_tx_mcs_map;
7817
7818 if (!rdev->ops->set_bitrate_mask)
7819 return -EOPNOTSUPP;
7820
7821 memset(&mask, 0, sizeof(mask));
7822 /* Default to all rates enabled */
7823 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
7824 sband = rdev->wiphy.bands[i];
7825
7826 if (!sband)
7827 continue;
7828
7829 mask.control[i].legacy = (1 << sband->n_bitrates) - 1;
7830 memcpy(mask.control[i].ht_mcs,
7831 sband->ht_cap.mcs.rx_mask,
7832 sizeof(mask.control[i].ht_mcs));
7833
7834 if (!sband->vht_cap.vht_supported)
7835 continue;
7836
7837 vht_tx_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
7838 vht_build_mcs_mask(vht_tx_mcs_map, mask.control[i].vht_mcs);
7839 }
7840
7841 /* if no rates are given set it back to the defaults */
7842 if (!info->attrs[NL80211_ATTR_TX_RATES])
7843 goto out;
7844
7845 /*
7846 * The nested attribute uses enum nl80211_band as the index. This maps
7847 * directly to the enum ieee80211_band values used in cfg80211.
7848 */
7849 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
7850 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem) {
7851 enum ieee80211_band band = nla_type(tx_rates);
7852 int err;
7853
7854 if (band < 0 || band >= IEEE80211_NUM_BANDS)
7855 return -EINVAL;
7856 sband = rdev->wiphy.bands[band];
7857 if (sband == NULL)
7858 return -EINVAL;
7859 err = nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
7860 nla_len(tx_rates), nl80211_txattr_policy);
7861 if (err)
7862 return err;
7863 if (tb[NL80211_TXRATE_LEGACY]) {
7864 mask.control[band].legacy = rateset_to_mask(
7865 sband,
7866 nla_data(tb[NL80211_TXRATE_LEGACY]),
7867 nla_len(tb[NL80211_TXRATE_LEGACY]));
7868 if ((mask.control[band].legacy == 0) &&
7869 nla_len(tb[NL80211_TXRATE_LEGACY]))
7870 return -EINVAL;
7871 }
7872 if (tb[NL80211_TXRATE_HT]) {
7873 if (!ht_rateset_to_mask(
7874 sband,
7875 nla_data(tb[NL80211_TXRATE_HT]),
7876 nla_len(tb[NL80211_TXRATE_HT]),
7877 mask.control[band].ht_mcs))
7878 return -EINVAL;
7879 }
7880 if (tb[NL80211_TXRATE_VHT]) {
7881 if (!vht_set_mcs_mask(
7882 sband,
7883 nla_data(tb[NL80211_TXRATE_VHT]),
7884 mask.control[band].vht_mcs))
7885 return -EINVAL;
7886 }
7887 if (tb[NL80211_TXRATE_GI]) {
7888 mask.control[band].gi =
7889 nla_get_u8(tb[NL80211_TXRATE_GI]);
7890 if (mask.control[band].gi > NL80211_TXRATE_FORCE_LGI)
7891 return -EINVAL;
7892 }
7893
7894 if (mask.control[band].legacy == 0) {
7895 /* don't allow empty legacy rates if HT or VHT
7896 * are not even supported.
7897 */
7898 if (!(rdev->wiphy.bands[band]->ht_cap.ht_supported ||
7899 rdev->wiphy.bands[band]->vht_cap.vht_supported))
7900 return -EINVAL;
7901
7902 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
7903 if (mask.control[band].ht_mcs[i])
7904 goto out;
7905
7906 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
7907 if (mask.control[band].vht_mcs[i])
7908 goto out;
7909
7910 /* legacy and mcs rates may not be both empty */
7911 return -EINVAL;
7912 }
7913 }
7914
7915 out:
7916 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
7917 }
7918
7919 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
7920 {
7921 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7922 struct wireless_dev *wdev = info->user_ptr[1];
7923 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
7924
7925 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
7926 return -EINVAL;
7927
7928 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
7929 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
7930
7931 switch (wdev->iftype) {
7932 case NL80211_IFTYPE_STATION:
7933 case NL80211_IFTYPE_ADHOC:
7934 case NL80211_IFTYPE_P2P_CLIENT:
7935 case NL80211_IFTYPE_AP:
7936 case NL80211_IFTYPE_AP_VLAN:
7937 case NL80211_IFTYPE_MESH_POINT:
7938 case NL80211_IFTYPE_P2P_GO:
7939 case NL80211_IFTYPE_P2P_DEVICE:
7940 break;
7941 default:
7942 return -EOPNOTSUPP;
7943 }
7944
7945 /* not much point in registering if we can't reply */
7946 if (!rdev->ops->mgmt_tx)
7947 return -EOPNOTSUPP;
7948
7949 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
7950 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
7951 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
7952 }
7953
7954 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
7955 {
7956 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7957 struct wireless_dev *wdev = info->user_ptr[1];
7958 struct cfg80211_chan_def chandef;
7959 int err;
7960 void *hdr = NULL;
7961 u64 cookie;
7962 struct sk_buff *msg = NULL;
7963 struct cfg80211_mgmt_tx_params params = {
7964 .dont_wait_for_ack =
7965 info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK],
7966 };
7967
7968 if (!info->attrs[NL80211_ATTR_FRAME])
7969 return -EINVAL;
7970
7971 if (!rdev->ops->mgmt_tx)
7972 return -EOPNOTSUPP;
7973
7974 switch (wdev->iftype) {
7975 case NL80211_IFTYPE_P2P_DEVICE:
7976 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
7977 return -EINVAL;
7978 case NL80211_IFTYPE_STATION:
7979 case NL80211_IFTYPE_ADHOC:
7980 case NL80211_IFTYPE_P2P_CLIENT:
7981 case NL80211_IFTYPE_AP:
7982 case NL80211_IFTYPE_AP_VLAN:
7983 case NL80211_IFTYPE_MESH_POINT:
7984 case NL80211_IFTYPE_P2P_GO:
7985 break;
7986 default:
7987 return -EOPNOTSUPP;
7988 }
7989
7990 if (info->attrs[NL80211_ATTR_DURATION]) {
7991 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7992 return -EINVAL;
7993 params.wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
7994
7995 /*
7996 * We should wait on the channel for at least a minimum amount
7997 * of time (10ms) but no longer than the driver supports.
7998 */
7999 if (params.wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
8000 params.wait > rdev->wiphy.max_remain_on_channel_duration)
8001 return -EINVAL;
8002
8003 }
8004
8005 params.offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
8006
8007 if (params.offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
8008 return -EINVAL;
8009
8010 params.no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
8011
8012 /* get the channel if any has been specified, otherwise pass NULL to
8013 * the driver. The latter will use the current one
8014 */
8015 chandef.chan = NULL;
8016 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
8017 err = nl80211_parse_chandef(rdev, info, &chandef);
8018 if (err)
8019 return err;
8020 }
8021
8022 if (!chandef.chan && params.offchan)
8023 return -EINVAL;
8024
8025 params.buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
8026 params.len = nla_len(info->attrs[NL80211_ATTR_FRAME]);
8027
8028 if (info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]) {
8029 int len = nla_len(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
8030 int i;
8031
8032 if (len % sizeof(u16))
8033 return -EINVAL;
8034
8035 params.n_csa_offsets = len / sizeof(u16);
8036 params.csa_offsets =
8037 nla_data(info->attrs[NL80211_ATTR_CSA_C_OFFSETS_TX]);
8038
8039 /* check that all the offsets fit the frame */
8040 for (i = 0; i < params.n_csa_offsets; i++) {
8041 if (params.csa_offsets[i] >= params.len)
8042 return -EINVAL;
8043 }
8044 }
8045
8046 if (!params.dont_wait_for_ack) {
8047 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8048 if (!msg)
8049 return -ENOMEM;
8050
8051 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8052 NL80211_CMD_FRAME);
8053 if (!hdr) {
8054 err = -ENOBUFS;
8055 goto free_msg;
8056 }
8057 }
8058
8059 params.chan = chandef.chan;
8060 err = cfg80211_mlme_mgmt_tx(rdev, wdev, &params, &cookie);
8061 if (err)
8062 goto free_msg;
8063
8064 if (msg) {
8065 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
8066 goto nla_put_failure;
8067
8068 genlmsg_end(msg, hdr);
8069 return genlmsg_reply(msg, info);
8070 }
8071
8072 return 0;
8073
8074 nla_put_failure:
8075 err = -ENOBUFS;
8076 free_msg:
8077 nlmsg_free(msg);
8078 return err;
8079 }
8080
8081 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
8082 {
8083 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8084 struct wireless_dev *wdev = info->user_ptr[1];
8085 u64 cookie;
8086
8087 if (!info->attrs[NL80211_ATTR_COOKIE])
8088 return -EINVAL;
8089
8090 if (!rdev->ops->mgmt_tx_cancel_wait)
8091 return -EOPNOTSUPP;
8092
8093 switch (wdev->iftype) {
8094 case NL80211_IFTYPE_STATION:
8095 case NL80211_IFTYPE_ADHOC:
8096 case NL80211_IFTYPE_P2P_CLIENT:
8097 case NL80211_IFTYPE_AP:
8098 case NL80211_IFTYPE_AP_VLAN:
8099 case NL80211_IFTYPE_P2P_GO:
8100 case NL80211_IFTYPE_P2P_DEVICE:
8101 break;
8102 default:
8103 return -EOPNOTSUPP;
8104 }
8105
8106 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
8107
8108 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
8109 }
8110
8111 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
8112 {
8113 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8114 struct wireless_dev *wdev;
8115 struct net_device *dev = info->user_ptr[1];
8116 u8 ps_state;
8117 bool state;
8118 int err;
8119
8120 if (!info->attrs[NL80211_ATTR_PS_STATE])
8121 return -EINVAL;
8122
8123 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
8124
8125 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
8126 return -EINVAL;
8127
8128 wdev = dev->ieee80211_ptr;
8129
8130 if (!rdev->ops->set_power_mgmt)
8131 return -EOPNOTSUPP;
8132
8133 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
8134
8135 if (state == wdev->ps)
8136 return 0;
8137
8138 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
8139 if (!err)
8140 wdev->ps = state;
8141 return err;
8142 }
8143
8144 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
8145 {
8146 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8147 enum nl80211_ps_state ps_state;
8148 struct wireless_dev *wdev;
8149 struct net_device *dev = info->user_ptr[1];
8150 struct sk_buff *msg;
8151 void *hdr;
8152 int err;
8153
8154 wdev = dev->ieee80211_ptr;
8155
8156 if (!rdev->ops->set_power_mgmt)
8157 return -EOPNOTSUPP;
8158
8159 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8160 if (!msg)
8161 return -ENOMEM;
8162
8163 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8164 NL80211_CMD_GET_POWER_SAVE);
8165 if (!hdr) {
8166 err = -ENOBUFS;
8167 goto free_msg;
8168 }
8169
8170 if (wdev->ps)
8171 ps_state = NL80211_PS_ENABLED;
8172 else
8173 ps_state = NL80211_PS_DISABLED;
8174
8175 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
8176 goto nla_put_failure;
8177
8178 genlmsg_end(msg, hdr);
8179 return genlmsg_reply(msg, info);
8180
8181 nla_put_failure:
8182 err = -ENOBUFS;
8183 free_msg:
8184 nlmsg_free(msg);
8185 return err;
8186 }
8187
8188 static const struct nla_policy
8189 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] = {
8190 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
8191 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
8192 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
8193 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
8194 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
8195 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
8196 };
8197
8198 static int nl80211_set_cqm_txe(struct genl_info *info,
8199 u32 rate, u32 pkts, u32 intvl)
8200 {
8201 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8202 struct net_device *dev = info->user_ptr[1];
8203 struct wireless_dev *wdev = dev->ieee80211_ptr;
8204
8205 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
8206 return -EINVAL;
8207
8208 if (!rdev->ops->set_cqm_txe_config)
8209 return -EOPNOTSUPP;
8210
8211 if (wdev->iftype != NL80211_IFTYPE_STATION &&
8212 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
8213 return -EOPNOTSUPP;
8214
8215 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
8216 }
8217
8218 static int nl80211_set_cqm_rssi(struct genl_info *info,
8219 s32 threshold, u32 hysteresis)
8220 {
8221 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8222 struct net_device *dev = info->user_ptr[1];
8223 struct wireless_dev *wdev = dev->ieee80211_ptr;
8224
8225 if (threshold > 0)
8226 return -EINVAL;
8227
8228 /* disabling - hysteresis should also be zero then */
8229 if (threshold == 0)
8230 hysteresis = 0;
8231
8232 if (!rdev->ops->set_cqm_rssi_config)
8233 return -EOPNOTSUPP;
8234
8235 if (wdev->iftype != NL80211_IFTYPE_STATION &&
8236 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
8237 return -EOPNOTSUPP;
8238
8239 return rdev_set_cqm_rssi_config(rdev, dev, threshold, hysteresis);
8240 }
8241
8242 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
8243 {
8244 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
8245 struct nlattr *cqm;
8246 int err;
8247
8248 cqm = info->attrs[NL80211_ATTR_CQM];
8249 if (!cqm)
8250 return -EINVAL;
8251
8252 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
8253 nl80211_attr_cqm_policy);
8254 if (err)
8255 return err;
8256
8257 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
8258 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
8259 s32 threshold = nla_get_s32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
8260 u32 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
8261
8262 return nl80211_set_cqm_rssi(info, threshold, hysteresis);
8263 }
8264
8265 if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
8266 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
8267 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
8268 u32 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
8269 u32 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
8270 u32 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
8271
8272 return nl80211_set_cqm_txe(info, rate, pkts, intvl);
8273 }
8274
8275 return -EINVAL;
8276 }
8277
8278 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
8279 {
8280 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8281 struct net_device *dev = info->user_ptr[1];
8282 struct mesh_config cfg;
8283 struct mesh_setup setup;
8284 int err;
8285
8286 /* start with default */
8287 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
8288 memcpy(&setup, &default_mesh_setup, sizeof(setup));
8289
8290 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
8291 /* and parse parameters if given */
8292 err = nl80211_parse_mesh_config(info, &cfg, NULL);
8293 if (err)
8294 return err;
8295 }
8296
8297 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
8298 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
8299 return -EINVAL;
8300
8301 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
8302 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
8303
8304 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
8305 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
8306 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
8307 return -EINVAL;
8308
8309 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
8310 setup.beacon_interval =
8311 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
8312 if (setup.beacon_interval < 10 ||
8313 setup.beacon_interval > 10000)
8314 return -EINVAL;
8315 }
8316
8317 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
8318 setup.dtim_period =
8319 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
8320 if (setup.dtim_period < 1 || setup.dtim_period > 100)
8321 return -EINVAL;
8322 }
8323
8324 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
8325 /* parse additional setup parameters if given */
8326 err = nl80211_parse_mesh_setup(info, &setup);
8327 if (err)
8328 return err;
8329 }
8330
8331 if (setup.user_mpm)
8332 cfg.auto_open_plinks = false;
8333
8334 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
8335 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
8336 if (err)
8337 return err;
8338 } else {
8339 /* cfg80211_join_mesh() will sort it out */
8340 setup.chandef.chan = NULL;
8341 }
8342
8343 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
8344 u8 *rates = nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8345 int n_rates =
8346 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
8347 struct ieee80211_supported_band *sband;
8348
8349 if (!setup.chandef.chan)
8350 return -EINVAL;
8351
8352 sband = rdev->wiphy.bands[setup.chandef.chan->band];
8353
8354 err = ieee80211_get_ratemask(sband, rates, n_rates,
8355 &setup.basic_rates);
8356 if (err)
8357 return err;
8358 }
8359
8360 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
8361 }
8362
8363 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
8364 {
8365 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8366 struct net_device *dev = info->user_ptr[1];
8367
8368 return cfg80211_leave_mesh(rdev, dev);
8369 }
8370
8371 #ifdef CONFIG_PM
8372 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
8373 struct cfg80211_registered_device *rdev)
8374 {
8375 struct cfg80211_wowlan *wowlan = rdev->wiphy.wowlan_config;
8376 struct nlattr *nl_pats, *nl_pat;
8377 int i, pat_len;
8378
8379 if (!wowlan->n_patterns)
8380 return 0;
8381
8382 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
8383 if (!nl_pats)
8384 return -ENOBUFS;
8385
8386 for (i = 0; i < wowlan->n_patterns; i++) {
8387 nl_pat = nla_nest_start(msg, i + 1);
8388 if (!nl_pat)
8389 return -ENOBUFS;
8390 pat_len = wowlan->patterns[i].pattern_len;
8391 if (nla_put(msg, NL80211_PKTPAT_MASK, DIV_ROUND_UP(pat_len, 8),
8392 wowlan->patterns[i].mask) ||
8393 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
8394 wowlan->patterns[i].pattern) ||
8395 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
8396 wowlan->patterns[i].pkt_offset))
8397 return -ENOBUFS;
8398 nla_nest_end(msg, nl_pat);
8399 }
8400 nla_nest_end(msg, nl_pats);
8401
8402 return 0;
8403 }
8404
8405 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
8406 struct cfg80211_wowlan_tcp *tcp)
8407 {
8408 struct nlattr *nl_tcp;
8409
8410 if (!tcp)
8411 return 0;
8412
8413 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
8414 if (!nl_tcp)
8415 return -ENOBUFS;
8416
8417 if (nla_put_be32(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
8418 nla_put_be32(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
8419 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
8420 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
8421 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
8422 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
8423 tcp->payload_len, tcp->payload) ||
8424 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
8425 tcp->data_interval) ||
8426 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
8427 tcp->wake_len, tcp->wake_data) ||
8428 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
8429 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
8430 return -ENOBUFS;
8431
8432 if (tcp->payload_seq.len &&
8433 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
8434 sizeof(tcp->payload_seq), &tcp->payload_seq))
8435 return -ENOBUFS;
8436
8437 if (tcp->payload_tok.len &&
8438 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
8439 sizeof(tcp->payload_tok) + tcp->tokens_size,
8440 &tcp->payload_tok))
8441 return -ENOBUFS;
8442
8443 nla_nest_end(msg, nl_tcp);
8444
8445 return 0;
8446 }
8447
8448 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
8449 {
8450 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8451 struct sk_buff *msg;
8452 void *hdr;
8453 u32 size = NLMSG_DEFAULT_SIZE;
8454
8455 if (!rdev->wiphy.wowlan)
8456 return -EOPNOTSUPP;
8457
8458 if (rdev->wiphy.wowlan_config && rdev->wiphy.wowlan_config->tcp) {
8459 /* adjust size to have room for all the data */
8460 size += rdev->wiphy.wowlan_config->tcp->tokens_size +
8461 rdev->wiphy.wowlan_config->tcp->payload_len +
8462 rdev->wiphy.wowlan_config->tcp->wake_len +
8463 rdev->wiphy.wowlan_config->tcp->wake_len / 8;
8464 }
8465
8466 msg = nlmsg_new(size, GFP_KERNEL);
8467 if (!msg)
8468 return -ENOMEM;
8469
8470 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8471 NL80211_CMD_GET_WOWLAN);
8472 if (!hdr)
8473 goto nla_put_failure;
8474
8475 if (rdev->wiphy.wowlan_config) {
8476 struct nlattr *nl_wowlan;
8477
8478 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
8479 if (!nl_wowlan)
8480 goto nla_put_failure;
8481
8482 if ((rdev->wiphy.wowlan_config->any &&
8483 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
8484 (rdev->wiphy.wowlan_config->disconnect &&
8485 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
8486 (rdev->wiphy.wowlan_config->magic_pkt &&
8487 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
8488 (rdev->wiphy.wowlan_config->gtk_rekey_failure &&
8489 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
8490 (rdev->wiphy.wowlan_config->eap_identity_req &&
8491 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
8492 (rdev->wiphy.wowlan_config->four_way_handshake &&
8493 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
8494 (rdev->wiphy.wowlan_config->rfkill_release &&
8495 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
8496 goto nla_put_failure;
8497
8498 if (nl80211_send_wowlan_patterns(msg, rdev))
8499 goto nla_put_failure;
8500
8501 if (nl80211_send_wowlan_tcp(msg,
8502 rdev->wiphy.wowlan_config->tcp))
8503 goto nla_put_failure;
8504
8505 nla_nest_end(msg, nl_wowlan);
8506 }
8507
8508 genlmsg_end(msg, hdr);
8509 return genlmsg_reply(msg, info);
8510
8511 nla_put_failure:
8512 nlmsg_free(msg);
8513 return -ENOBUFS;
8514 }
8515
8516 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
8517 struct nlattr *attr,
8518 struct cfg80211_wowlan *trig)
8519 {
8520 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
8521 struct cfg80211_wowlan_tcp *cfg;
8522 struct nl80211_wowlan_tcp_data_token *tok = NULL;
8523 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
8524 u32 size;
8525 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
8526 int err, port;
8527
8528 if (!rdev->wiphy.wowlan->tcp)
8529 return -EINVAL;
8530
8531 err = nla_parse(tb, MAX_NL80211_WOWLAN_TCP,
8532 nla_data(attr), nla_len(attr),
8533 nl80211_wowlan_tcp_policy);
8534 if (err)
8535 return err;
8536
8537 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
8538 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
8539 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
8540 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
8541 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
8542 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
8543 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
8544 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
8545 return -EINVAL;
8546
8547 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
8548 if (data_size > rdev->wiphy.wowlan->tcp->data_payload_max)
8549 return -EINVAL;
8550
8551 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
8552 rdev->wiphy.wowlan->tcp->data_interval_max ||
8553 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
8554 return -EINVAL;
8555
8556 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
8557 if (wake_size > rdev->wiphy.wowlan->tcp->wake_payload_max)
8558 return -EINVAL;
8559
8560 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
8561 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
8562 return -EINVAL;
8563
8564 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
8565 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
8566
8567 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
8568 tokens_size = tokln - sizeof(*tok);
8569
8570 if (!tok->len || tokens_size % tok->len)
8571 return -EINVAL;
8572 if (!rdev->wiphy.wowlan->tcp->tok)
8573 return -EINVAL;
8574 if (tok->len > rdev->wiphy.wowlan->tcp->tok->max_len)
8575 return -EINVAL;
8576 if (tok->len < rdev->wiphy.wowlan->tcp->tok->min_len)
8577 return -EINVAL;
8578 if (tokens_size > rdev->wiphy.wowlan->tcp->tok->bufsize)
8579 return -EINVAL;
8580 if (tok->offset + tok->len > data_size)
8581 return -EINVAL;
8582 }
8583
8584 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
8585 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
8586 if (!rdev->wiphy.wowlan->tcp->seq)
8587 return -EINVAL;
8588 if (seq->len == 0 || seq->len > 4)
8589 return -EINVAL;
8590 if (seq->len + seq->offset > data_size)
8591 return -EINVAL;
8592 }
8593
8594 size = sizeof(*cfg);
8595 size += data_size;
8596 size += wake_size + wake_mask_size;
8597 size += tokens_size;
8598
8599 cfg = kzalloc(size, GFP_KERNEL);
8600 if (!cfg)
8601 return -ENOMEM;
8602 cfg->src = nla_get_be32(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
8603 cfg->dst = nla_get_be32(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
8604 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
8605 ETH_ALEN);
8606 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
8607 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
8608 else
8609 port = 0;
8610 #ifdef CONFIG_INET
8611 /* allocate a socket and port for it and use it */
8612 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
8613 IPPROTO_TCP, &cfg->sock, 1);
8614 if (err) {
8615 kfree(cfg);
8616 return err;
8617 }
8618 if (inet_csk_get_port(cfg->sock->sk, port)) {
8619 sock_release(cfg->sock);
8620 kfree(cfg);
8621 return -EADDRINUSE;
8622 }
8623 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
8624 #else
8625 if (!port) {
8626 kfree(cfg);
8627 return -EINVAL;
8628 }
8629 cfg->src_port = port;
8630 #endif
8631
8632 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
8633 cfg->payload_len = data_size;
8634 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
8635 memcpy((void *)cfg->payload,
8636 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
8637 data_size);
8638 if (seq)
8639 cfg->payload_seq = *seq;
8640 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
8641 cfg->wake_len = wake_size;
8642 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
8643 memcpy((void *)cfg->wake_data,
8644 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
8645 wake_size);
8646 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
8647 data_size + wake_size;
8648 memcpy((void *)cfg->wake_mask,
8649 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
8650 wake_mask_size);
8651 if (tok) {
8652 cfg->tokens_size = tokens_size;
8653 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
8654 }
8655
8656 trig->tcp = cfg;
8657
8658 return 0;
8659 }
8660
8661 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
8662 {
8663 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8664 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
8665 struct cfg80211_wowlan new_triggers = {};
8666 struct cfg80211_wowlan *ntrig;
8667 const struct wiphy_wowlan_support *wowlan = rdev->wiphy.wowlan;
8668 int err, i;
8669 bool prev_enabled = rdev->wiphy.wowlan_config;
8670
8671 if (!wowlan)
8672 return -EOPNOTSUPP;
8673
8674 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
8675 cfg80211_rdev_free_wowlan(rdev);
8676 rdev->wiphy.wowlan_config = NULL;
8677 goto set_wakeup;
8678 }
8679
8680 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
8681 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
8682 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
8683 nl80211_wowlan_policy);
8684 if (err)
8685 return err;
8686
8687 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
8688 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
8689 return -EINVAL;
8690 new_triggers.any = true;
8691 }
8692
8693 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
8694 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
8695 return -EINVAL;
8696 new_triggers.disconnect = true;
8697 }
8698
8699 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
8700 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
8701 return -EINVAL;
8702 new_triggers.magic_pkt = true;
8703 }
8704
8705 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
8706 return -EINVAL;
8707
8708 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
8709 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
8710 return -EINVAL;
8711 new_triggers.gtk_rekey_failure = true;
8712 }
8713
8714 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
8715 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
8716 return -EINVAL;
8717 new_triggers.eap_identity_req = true;
8718 }
8719
8720 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
8721 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
8722 return -EINVAL;
8723 new_triggers.four_way_handshake = true;
8724 }
8725
8726 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
8727 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
8728 return -EINVAL;
8729 new_triggers.rfkill_release = true;
8730 }
8731
8732 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
8733 struct nlattr *pat;
8734 int n_patterns = 0;
8735 int rem, pat_len, mask_len, pkt_offset;
8736 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
8737
8738 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
8739 rem)
8740 n_patterns++;
8741 if (n_patterns > wowlan->n_patterns)
8742 return -EINVAL;
8743
8744 new_triggers.patterns = kcalloc(n_patterns,
8745 sizeof(new_triggers.patterns[0]),
8746 GFP_KERNEL);
8747 if (!new_triggers.patterns)
8748 return -ENOMEM;
8749
8750 new_triggers.n_patterns = n_patterns;
8751 i = 0;
8752
8753 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
8754 rem) {
8755 u8 *mask_pat;
8756
8757 nla_parse(pat_tb, MAX_NL80211_PKTPAT, nla_data(pat),
8758 nla_len(pat), NULL);
8759 err = -EINVAL;
8760 if (!pat_tb[NL80211_PKTPAT_MASK] ||
8761 !pat_tb[NL80211_PKTPAT_PATTERN])
8762 goto error;
8763 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
8764 mask_len = DIV_ROUND_UP(pat_len, 8);
8765 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
8766 goto error;
8767 if (pat_len > wowlan->pattern_max_len ||
8768 pat_len < wowlan->pattern_min_len)
8769 goto error;
8770
8771 if (!pat_tb[NL80211_PKTPAT_OFFSET])
8772 pkt_offset = 0;
8773 else
8774 pkt_offset = nla_get_u32(
8775 pat_tb[NL80211_PKTPAT_OFFSET]);
8776 if (pkt_offset > wowlan->max_pkt_offset)
8777 goto error;
8778 new_triggers.patterns[i].pkt_offset = pkt_offset;
8779
8780 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
8781 if (!mask_pat) {
8782 err = -ENOMEM;
8783 goto error;
8784 }
8785 new_triggers.patterns[i].mask = mask_pat;
8786 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
8787 mask_len);
8788 mask_pat += mask_len;
8789 new_triggers.patterns[i].pattern = mask_pat;
8790 new_triggers.patterns[i].pattern_len = pat_len;
8791 memcpy(mask_pat,
8792 nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
8793 pat_len);
8794 i++;
8795 }
8796 }
8797
8798 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
8799 err = nl80211_parse_wowlan_tcp(
8800 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
8801 &new_triggers);
8802 if (err)
8803 goto error;
8804 }
8805
8806 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
8807 if (!ntrig) {
8808 err = -ENOMEM;
8809 goto error;
8810 }
8811 cfg80211_rdev_free_wowlan(rdev);
8812 rdev->wiphy.wowlan_config = ntrig;
8813
8814 set_wakeup:
8815 if (rdev->ops->set_wakeup &&
8816 prev_enabled != !!rdev->wiphy.wowlan_config)
8817 rdev_set_wakeup(rdev, rdev->wiphy.wowlan_config);
8818
8819 return 0;
8820 error:
8821 for (i = 0; i < new_triggers.n_patterns; i++)
8822 kfree(new_triggers.patterns[i].mask);
8823 kfree(new_triggers.patterns);
8824 if (new_triggers.tcp && new_triggers.tcp->sock)
8825 sock_release(new_triggers.tcp->sock);
8826 kfree(new_triggers.tcp);
8827 return err;
8828 }
8829 #endif
8830
8831 static int nl80211_send_coalesce_rules(struct sk_buff *msg,
8832 struct cfg80211_registered_device *rdev)
8833 {
8834 struct nlattr *nl_pats, *nl_pat, *nl_rule, *nl_rules;
8835 int i, j, pat_len;
8836 struct cfg80211_coalesce_rules *rule;
8837
8838 if (!rdev->coalesce->n_rules)
8839 return 0;
8840
8841 nl_rules = nla_nest_start(msg, NL80211_ATTR_COALESCE_RULE);
8842 if (!nl_rules)
8843 return -ENOBUFS;
8844
8845 for (i = 0; i < rdev->coalesce->n_rules; i++) {
8846 nl_rule = nla_nest_start(msg, i + 1);
8847 if (!nl_rule)
8848 return -ENOBUFS;
8849
8850 rule = &rdev->coalesce->rules[i];
8851 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_DELAY,
8852 rule->delay))
8853 return -ENOBUFS;
8854
8855 if (nla_put_u32(msg, NL80211_ATTR_COALESCE_RULE_CONDITION,
8856 rule->condition))
8857 return -ENOBUFS;
8858
8859 nl_pats = nla_nest_start(msg,
8860 NL80211_ATTR_COALESCE_RULE_PKT_PATTERN);
8861 if (!nl_pats)
8862 return -ENOBUFS;
8863
8864 for (j = 0; j < rule->n_patterns; j++) {
8865 nl_pat = nla_nest_start(msg, j + 1);
8866 if (!nl_pat)
8867 return -ENOBUFS;
8868 pat_len = rule->patterns[j].pattern_len;
8869 if (nla_put(msg, NL80211_PKTPAT_MASK,
8870 DIV_ROUND_UP(pat_len, 8),
8871 rule->patterns[j].mask) ||
8872 nla_put(msg, NL80211_PKTPAT_PATTERN, pat_len,
8873 rule->patterns[j].pattern) ||
8874 nla_put_u32(msg, NL80211_PKTPAT_OFFSET,
8875 rule->patterns[j].pkt_offset))
8876 return -ENOBUFS;
8877 nla_nest_end(msg, nl_pat);
8878 }
8879 nla_nest_end(msg, nl_pats);
8880 nla_nest_end(msg, nl_rule);
8881 }
8882 nla_nest_end(msg, nl_rules);
8883
8884 return 0;
8885 }
8886
8887 static int nl80211_get_coalesce(struct sk_buff *skb, struct genl_info *info)
8888 {
8889 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8890 struct sk_buff *msg;
8891 void *hdr;
8892
8893 if (!rdev->wiphy.coalesce)
8894 return -EOPNOTSUPP;
8895
8896 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8897 if (!msg)
8898 return -ENOMEM;
8899
8900 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8901 NL80211_CMD_GET_COALESCE);
8902 if (!hdr)
8903 goto nla_put_failure;
8904
8905 if (rdev->coalesce && nl80211_send_coalesce_rules(msg, rdev))
8906 goto nla_put_failure;
8907
8908 genlmsg_end(msg, hdr);
8909 return genlmsg_reply(msg, info);
8910
8911 nla_put_failure:
8912 nlmsg_free(msg);
8913 return -ENOBUFS;
8914 }
8915
8916 void cfg80211_rdev_free_coalesce(struct cfg80211_registered_device *rdev)
8917 {
8918 struct cfg80211_coalesce *coalesce = rdev->coalesce;
8919 int i, j;
8920 struct cfg80211_coalesce_rules *rule;
8921
8922 if (!coalesce)
8923 return;
8924
8925 for (i = 0; i < coalesce->n_rules; i++) {
8926 rule = &coalesce->rules[i];
8927 for (j = 0; j < rule->n_patterns; j++)
8928 kfree(rule->patterns[j].mask);
8929 kfree(rule->patterns);
8930 }
8931 kfree(coalesce->rules);
8932 kfree(coalesce);
8933 rdev->coalesce = NULL;
8934 }
8935
8936 static int nl80211_parse_coalesce_rule(struct cfg80211_registered_device *rdev,
8937 struct nlattr *rule,
8938 struct cfg80211_coalesce_rules *new_rule)
8939 {
8940 int err, i;
8941 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
8942 struct nlattr *tb[NUM_NL80211_ATTR_COALESCE_RULE], *pat;
8943 int rem, pat_len, mask_len, pkt_offset, n_patterns = 0;
8944 struct nlattr *pat_tb[NUM_NL80211_PKTPAT];
8945
8946 err = nla_parse(tb, NL80211_ATTR_COALESCE_RULE_MAX, nla_data(rule),
8947 nla_len(rule), nl80211_coalesce_policy);
8948 if (err)
8949 return err;
8950
8951 if (tb[NL80211_ATTR_COALESCE_RULE_DELAY])
8952 new_rule->delay =
8953 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_DELAY]);
8954 if (new_rule->delay > coalesce->max_delay)
8955 return -EINVAL;
8956
8957 if (tb[NL80211_ATTR_COALESCE_RULE_CONDITION])
8958 new_rule->condition =
8959 nla_get_u32(tb[NL80211_ATTR_COALESCE_RULE_CONDITION]);
8960 if (new_rule->condition != NL80211_COALESCE_CONDITION_MATCH &&
8961 new_rule->condition != NL80211_COALESCE_CONDITION_NO_MATCH)
8962 return -EINVAL;
8963
8964 if (!tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN])
8965 return -EINVAL;
8966
8967 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
8968 rem)
8969 n_patterns++;
8970 if (n_patterns > coalesce->n_patterns)
8971 return -EINVAL;
8972
8973 new_rule->patterns = kcalloc(n_patterns, sizeof(new_rule->patterns[0]),
8974 GFP_KERNEL);
8975 if (!new_rule->patterns)
8976 return -ENOMEM;
8977
8978 new_rule->n_patterns = n_patterns;
8979 i = 0;
8980
8981 nla_for_each_nested(pat, tb[NL80211_ATTR_COALESCE_RULE_PKT_PATTERN],
8982 rem) {
8983 u8 *mask_pat;
8984
8985 nla_parse(pat_tb, MAX_NL80211_PKTPAT, nla_data(pat),
8986 nla_len(pat), NULL);
8987 if (!pat_tb[NL80211_PKTPAT_MASK] ||
8988 !pat_tb[NL80211_PKTPAT_PATTERN])
8989 return -EINVAL;
8990 pat_len = nla_len(pat_tb[NL80211_PKTPAT_PATTERN]);
8991 mask_len = DIV_ROUND_UP(pat_len, 8);
8992 if (nla_len(pat_tb[NL80211_PKTPAT_MASK]) != mask_len)
8993 return -EINVAL;
8994 if (pat_len > coalesce->pattern_max_len ||
8995 pat_len < coalesce->pattern_min_len)
8996 return -EINVAL;
8997
8998 if (!pat_tb[NL80211_PKTPAT_OFFSET])
8999 pkt_offset = 0;
9000 else
9001 pkt_offset = nla_get_u32(pat_tb[NL80211_PKTPAT_OFFSET]);
9002 if (pkt_offset > coalesce->max_pkt_offset)
9003 return -EINVAL;
9004 new_rule->patterns[i].pkt_offset = pkt_offset;
9005
9006 mask_pat = kmalloc(mask_len + pat_len, GFP_KERNEL);
9007 if (!mask_pat)
9008 return -ENOMEM;
9009
9010 new_rule->patterns[i].mask = mask_pat;
9011 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_MASK]),
9012 mask_len);
9013
9014 mask_pat += mask_len;
9015 new_rule->patterns[i].pattern = mask_pat;
9016 new_rule->patterns[i].pattern_len = pat_len;
9017 memcpy(mask_pat, nla_data(pat_tb[NL80211_PKTPAT_PATTERN]),
9018 pat_len);
9019 i++;
9020 }
9021
9022 return 0;
9023 }
9024
9025 static int nl80211_set_coalesce(struct sk_buff *skb, struct genl_info *info)
9026 {
9027 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9028 const struct wiphy_coalesce_support *coalesce = rdev->wiphy.coalesce;
9029 struct cfg80211_coalesce new_coalesce = {};
9030 struct cfg80211_coalesce *n_coalesce;
9031 int err, rem_rule, n_rules = 0, i, j;
9032 struct nlattr *rule;
9033 struct cfg80211_coalesce_rules *tmp_rule;
9034
9035 if (!rdev->wiphy.coalesce || !rdev->ops->set_coalesce)
9036 return -EOPNOTSUPP;
9037
9038 if (!info->attrs[NL80211_ATTR_COALESCE_RULE]) {
9039 cfg80211_rdev_free_coalesce(rdev);
9040 rdev->ops->set_coalesce(&rdev->wiphy, NULL);
9041 return 0;
9042 }
9043
9044 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
9045 rem_rule)
9046 n_rules++;
9047 if (n_rules > coalesce->n_rules)
9048 return -EINVAL;
9049
9050 new_coalesce.rules = kcalloc(n_rules, sizeof(new_coalesce.rules[0]),
9051 GFP_KERNEL);
9052 if (!new_coalesce.rules)
9053 return -ENOMEM;
9054
9055 new_coalesce.n_rules = n_rules;
9056 i = 0;
9057
9058 nla_for_each_nested(rule, info->attrs[NL80211_ATTR_COALESCE_RULE],
9059 rem_rule) {
9060 err = nl80211_parse_coalesce_rule(rdev, rule,
9061 &new_coalesce.rules[i]);
9062 if (err)
9063 goto error;
9064
9065 i++;
9066 }
9067
9068 err = rdev->ops->set_coalesce(&rdev->wiphy, &new_coalesce);
9069 if (err)
9070 goto error;
9071
9072 n_coalesce = kmemdup(&new_coalesce, sizeof(new_coalesce), GFP_KERNEL);
9073 if (!n_coalesce) {
9074 err = -ENOMEM;
9075 goto error;
9076 }
9077 cfg80211_rdev_free_coalesce(rdev);
9078 rdev->coalesce = n_coalesce;
9079
9080 return 0;
9081 error:
9082 for (i = 0; i < new_coalesce.n_rules; i++) {
9083 tmp_rule = &new_coalesce.rules[i];
9084 for (j = 0; j < tmp_rule->n_patterns; j++)
9085 kfree(tmp_rule->patterns[j].mask);
9086 kfree(tmp_rule->patterns);
9087 }
9088 kfree(new_coalesce.rules);
9089
9090 return err;
9091 }
9092
9093 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
9094 {
9095 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9096 struct net_device *dev = info->user_ptr[1];
9097 struct wireless_dev *wdev = dev->ieee80211_ptr;
9098 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
9099 struct cfg80211_gtk_rekey_data rekey_data;
9100 int err;
9101
9102 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
9103 return -EINVAL;
9104
9105 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
9106 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
9107 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
9108 nl80211_rekey_policy);
9109 if (err)
9110 return err;
9111
9112 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
9113 return -ERANGE;
9114 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
9115 return -ERANGE;
9116 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
9117 return -ERANGE;
9118
9119 rekey_data.kek = nla_data(tb[NL80211_REKEY_DATA_KEK]);
9120 rekey_data.kck = nla_data(tb[NL80211_REKEY_DATA_KCK]);
9121 rekey_data.replay_ctr = nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]);
9122
9123 wdev_lock(wdev);
9124 if (!wdev->current_bss) {
9125 err = -ENOTCONN;
9126 goto out;
9127 }
9128
9129 if (!rdev->ops->set_rekey_data) {
9130 err = -EOPNOTSUPP;
9131 goto out;
9132 }
9133
9134 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
9135 out:
9136 wdev_unlock(wdev);
9137 return err;
9138 }
9139
9140 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
9141 struct genl_info *info)
9142 {
9143 struct net_device *dev = info->user_ptr[1];
9144 struct wireless_dev *wdev = dev->ieee80211_ptr;
9145
9146 if (wdev->iftype != NL80211_IFTYPE_AP &&
9147 wdev->iftype != NL80211_IFTYPE_P2P_GO)
9148 return -EINVAL;
9149
9150 if (wdev->ap_unexpected_nlportid)
9151 return -EBUSY;
9152
9153 wdev->ap_unexpected_nlportid = info->snd_portid;
9154 return 0;
9155 }
9156
9157 static int nl80211_probe_client(struct sk_buff *skb,
9158 struct genl_info *info)
9159 {
9160 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9161 struct net_device *dev = info->user_ptr[1];
9162 struct wireless_dev *wdev = dev->ieee80211_ptr;
9163 struct sk_buff *msg;
9164 void *hdr;
9165 const u8 *addr;
9166 u64 cookie;
9167 int err;
9168
9169 if (wdev->iftype != NL80211_IFTYPE_AP &&
9170 wdev->iftype != NL80211_IFTYPE_P2P_GO)
9171 return -EOPNOTSUPP;
9172
9173 if (!info->attrs[NL80211_ATTR_MAC])
9174 return -EINVAL;
9175
9176 if (!rdev->ops->probe_client)
9177 return -EOPNOTSUPP;
9178
9179 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9180 if (!msg)
9181 return -ENOMEM;
9182
9183 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9184 NL80211_CMD_PROBE_CLIENT);
9185 if (!hdr) {
9186 err = -ENOBUFS;
9187 goto free_msg;
9188 }
9189
9190 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
9191
9192 err = rdev_probe_client(rdev, dev, addr, &cookie);
9193 if (err)
9194 goto free_msg;
9195
9196 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
9197 goto nla_put_failure;
9198
9199 genlmsg_end(msg, hdr);
9200
9201 return genlmsg_reply(msg, info);
9202
9203 nla_put_failure:
9204 err = -ENOBUFS;
9205 free_msg:
9206 nlmsg_free(msg);
9207 return err;
9208 }
9209
9210 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
9211 {
9212 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9213 struct cfg80211_beacon_registration *reg, *nreg;
9214 int rv;
9215
9216 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
9217 return -EOPNOTSUPP;
9218
9219 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
9220 if (!nreg)
9221 return -ENOMEM;
9222
9223 /* First, check if already registered. */
9224 spin_lock_bh(&rdev->beacon_registrations_lock);
9225 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
9226 if (reg->nlportid == info->snd_portid) {
9227 rv = -EALREADY;
9228 goto out_err;
9229 }
9230 }
9231 /* Add it to the list */
9232 nreg->nlportid = info->snd_portid;
9233 list_add(&nreg->list, &rdev->beacon_registrations);
9234
9235 spin_unlock_bh(&rdev->beacon_registrations_lock);
9236
9237 return 0;
9238 out_err:
9239 spin_unlock_bh(&rdev->beacon_registrations_lock);
9240 kfree(nreg);
9241 return rv;
9242 }
9243
9244 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
9245 {
9246 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9247 struct wireless_dev *wdev = info->user_ptr[1];
9248 int err;
9249
9250 if (!rdev->ops->start_p2p_device)
9251 return -EOPNOTSUPP;
9252
9253 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
9254 return -EOPNOTSUPP;
9255
9256 if (wdev->p2p_started)
9257 return 0;
9258
9259 if (rfkill_blocked(rdev->rfkill))
9260 return -ERFKILL;
9261
9262 err = rdev_start_p2p_device(rdev, wdev);
9263 if (err)
9264 return err;
9265
9266 wdev->p2p_started = true;
9267 rdev->opencount++;
9268
9269 return 0;
9270 }
9271
9272 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
9273 {
9274 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9275 struct wireless_dev *wdev = info->user_ptr[1];
9276
9277 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
9278 return -EOPNOTSUPP;
9279
9280 if (!rdev->ops->stop_p2p_device)
9281 return -EOPNOTSUPP;
9282
9283 cfg80211_stop_p2p_device(rdev, wdev);
9284
9285 return 0;
9286 }
9287
9288 static int nl80211_get_protocol_features(struct sk_buff *skb,
9289 struct genl_info *info)
9290 {
9291 void *hdr;
9292 struct sk_buff *msg;
9293
9294 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9295 if (!msg)
9296 return -ENOMEM;
9297
9298 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
9299 NL80211_CMD_GET_PROTOCOL_FEATURES);
9300 if (!hdr)
9301 goto nla_put_failure;
9302
9303 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
9304 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
9305 goto nla_put_failure;
9306
9307 genlmsg_end(msg, hdr);
9308 return genlmsg_reply(msg, info);
9309
9310 nla_put_failure:
9311 kfree_skb(msg);
9312 return -ENOBUFS;
9313 }
9314
9315 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
9316 {
9317 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9318 struct cfg80211_update_ft_ies_params ft_params;
9319 struct net_device *dev = info->user_ptr[1];
9320
9321 if (!rdev->ops->update_ft_ies)
9322 return -EOPNOTSUPP;
9323
9324 if (!info->attrs[NL80211_ATTR_MDID] ||
9325 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
9326 return -EINVAL;
9327
9328 memset(&ft_params, 0, sizeof(ft_params));
9329 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
9330 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
9331 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
9332
9333 return rdev_update_ft_ies(rdev, dev, &ft_params);
9334 }
9335
9336 static int nl80211_crit_protocol_start(struct sk_buff *skb,
9337 struct genl_info *info)
9338 {
9339 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9340 struct wireless_dev *wdev = info->user_ptr[1];
9341 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
9342 u16 duration;
9343 int ret;
9344
9345 if (!rdev->ops->crit_proto_start)
9346 return -EOPNOTSUPP;
9347
9348 if (WARN_ON(!rdev->ops->crit_proto_stop))
9349 return -EINVAL;
9350
9351 if (rdev->crit_proto_nlportid)
9352 return -EBUSY;
9353
9354 /* determine protocol if provided */
9355 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
9356 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
9357
9358 if (proto >= NUM_NL80211_CRIT_PROTO)
9359 return -EINVAL;
9360
9361 /* timeout must be provided */
9362 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
9363 return -EINVAL;
9364
9365 duration =
9366 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
9367
9368 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
9369 return -ERANGE;
9370
9371 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
9372 if (!ret)
9373 rdev->crit_proto_nlportid = info->snd_portid;
9374
9375 return ret;
9376 }
9377
9378 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
9379 struct genl_info *info)
9380 {
9381 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9382 struct wireless_dev *wdev = info->user_ptr[1];
9383
9384 if (!rdev->ops->crit_proto_stop)
9385 return -EOPNOTSUPP;
9386
9387 if (rdev->crit_proto_nlportid) {
9388 rdev->crit_proto_nlportid = 0;
9389 rdev_crit_proto_stop(rdev, wdev);
9390 }
9391 return 0;
9392 }
9393
9394 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
9395 {
9396 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9397 struct wireless_dev *wdev =
9398 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
9399 int i, err;
9400 u32 vid, subcmd;
9401
9402 if (!rdev->wiphy.vendor_commands)
9403 return -EOPNOTSUPP;
9404
9405 if (IS_ERR(wdev)) {
9406 err = PTR_ERR(wdev);
9407 if (err != -EINVAL)
9408 return err;
9409 wdev = NULL;
9410 } else if (wdev->wiphy != &rdev->wiphy) {
9411 return -EINVAL;
9412 }
9413
9414 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
9415 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
9416 return -EINVAL;
9417
9418 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
9419 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
9420 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
9421 const struct wiphy_vendor_command *vcmd;
9422 void *data = NULL;
9423 int len = 0;
9424
9425 vcmd = &rdev->wiphy.vendor_commands[i];
9426
9427 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
9428 continue;
9429
9430 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
9431 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
9432 if (!wdev)
9433 return -EINVAL;
9434 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
9435 !wdev->netdev)
9436 return -EINVAL;
9437
9438 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
9439 if (wdev->netdev &&
9440 !netif_running(wdev->netdev))
9441 return -ENETDOWN;
9442 if (!wdev->netdev && !wdev->p2p_started)
9443 return -ENETDOWN;
9444 }
9445 } else {
9446 wdev = NULL;
9447 }
9448
9449 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
9450 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
9451 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
9452 }
9453
9454 rdev->cur_cmd_info = info;
9455 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
9456 data, len);
9457 rdev->cur_cmd_info = NULL;
9458 return err;
9459 }
9460
9461 return -EOPNOTSUPP;
9462 }
9463
9464 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
9465 enum nl80211_commands cmd,
9466 enum nl80211_attrs attr,
9467 int approxlen)
9468 {
9469 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
9470
9471 if (WARN_ON(!rdev->cur_cmd_info))
9472 return NULL;
9473
9474 return __cfg80211_alloc_vendor_skb(rdev, approxlen,
9475 rdev->cur_cmd_info->snd_portid,
9476 rdev->cur_cmd_info->snd_seq,
9477 cmd, attr, NULL, GFP_KERNEL);
9478 }
9479 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
9480
9481 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
9482 {
9483 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
9484 void *hdr = ((void **)skb->cb)[1];
9485 struct nlattr *data = ((void **)skb->cb)[2];
9486
9487 /* clear CB data for netlink core to own from now on */
9488 memset(skb->cb, 0, sizeof(skb->cb));
9489
9490 if (WARN_ON(!rdev->cur_cmd_info)) {
9491 kfree_skb(skb);
9492 return -EINVAL;
9493 }
9494
9495 nla_nest_end(skb, data);
9496 genlmsg_end(skb, hdr);
9497 return genlmsg_reply(skb, rdev->cur_cmd_info);
9498 }
9499 EXPORT_SYMBOL_GPL(cfg80211_vendor_cmd_reply);
9500
9501
9502 static int nl80211_set_qos_map(struct sk_buff *skb,
9503 struct genl_info *info)
9504 {
9505 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9506 struct cfg80211_qos_map *qos_map = NULL;
9507 struct net_device *dev = info->user_ptr[1];
9508 u8 *pos, len, num_des, des_len, des;
9509 int ret;
9510
9511 if (!rdev->ops->set_qos_map)
9512 return -EOPNOTSUPP;
9513
9514 if (info->attrs[NL80211_ATTR_QOS_MAP]) {
9515 pos = nla_data(info->attrs[NL80211_ATTR_QOS_MAP]);
9516 len = nla_len(info->attrs[NL80211_ATTR_QOS_MAP]);
9517
9518 if (len % 2 || len < IEEE80211_QOS_MAP_LEN_MIN ||
9519 len > IEEE80211_QOS_MAP_LEN_MAX)
9520 return -EINVAL;
9521
9522 qos_map = kzalloc(sizeof(struct cfg80211_qos_map), GFP_KERNEL);
9523 if (!qos_map)
9524 return -ENOMEM;
9525
9526 num_des = (len - IEEE80211_QOS_MAP_LEN_MIN) >> 1;
9527 if (num_des) {
9528 des_len = num_des *
9529 sizeof(struct cfg80211_dscp_exception);
9530 memcpy(qos_map->dscp_exception, pos, des_len);
9531 qos_map->num_des = num_des;
9532 for (des = 0; des < num_des; des++) {
9533 if (qos_map->dscp_exception[des].up > 7) {
9534 kfree(qos_map);
9535 return -EINVAL;
9536 }
9537 }
9538 pos += des_len;
9539 }
9540 memcpy(qos_map->up, pos, IEEE80211_QOS_MAP_LEN_MIN);
9541 }
9542
9543 wdev_lock(dev->ieee80211_ptr);
9544 ret = nl80211_key_allowed(dev->ieee80211_ptr);
9545 if (!ret)
9546 ret = rdev_set_qos_map(rdev, dev, qos_map);
9547 wdev_unlock(dev->ieee80211_ptr);
9548
9549 kfree(qos_map);
9550 return ret;
9551 }
9552
9553 static int nl80211_add_tx_ts(struct sk_buff *skb, struct genl_info *info)
9554 {
9555 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9556 struct net_device *dev = info->user_ptr[1];
9557 struct wireless_dev *wdev = dev->ieee80211_ptr;
9558 const u8 *peer;
9559 u8 tsid, up;
9560 u16 admitted_time = 0;
9561 int err;
9562
9563 if (!(rdev->wiphy.features & NL80211_FEATURE_SUPPORTS_WMM_ADMISSION))
9564 return -EOPNOTSUPP;
9565
9566 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC] ||
9567 !info->attrs[NL80211_ATTR_USER_PRIO])
9568 return -EINVAL;
9569
9570 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
9571 if (tsid >= IEEE80211_NUM_TIDS)
9572 return -EINVAL;
9573
9574 up = nla_get_u8(info->attrs[NL80211_ATTR_USER_PRIO]);
9575 if (up >= IEEE80211_NUM_UPS)
9576 return -EINVAL;
9577
9578 /* WMM uses TIDs 0-7 even for TSPEC */
9579 if (tsid >= IEEE80211_FIRST_TSPEC_TSID) {
9580 /* TODO: handle 802.11 TSPEC/admission control
9581 * need more attributes for that (e.g. BA session requirement);
9582 * change the WMM adminssion test above to allow both then
9583 */
9584 return -EINVAL;
9585 }
9586
9587 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9588
9589 if (info->attrs[NL80211_ATTR_ADMITTED_TIME]) {
9590 admitted_time =
9591 nla_get_u16(info->attrs[NL80211_ATTR_ADMITTED_TIME]);
9592 if (!admitted_time)
9593 return -EINVAL;
9594 }
9595
9596 wdev_lock(wdev);
9597 switch (wdev->iftype) {
9598 case NL80211_IFTYPE_STATION:
9599 case NL80211_IFTYPE_P2P_CLIENT:
9600 if (wdev->current_bss)
9601 break;
9602 err = -ENOTCONN;
9603 goto out;
9604 default:
9605 err = -EOPNOTSUPP;
9606 goto out;
9607 }
9608
9609 err = rdev_add_tx_ts(rdev, dev, tsid, peer, up, admitted_time);
9610
9611 out:
9612 wdev_unlock(wdev);
9613 return err;
9614 }
9615
9616 static int nl80211_del_tx_ts(struct sk_buff *skb, struct genl_info *info)
9617 {
9618 struct cfg80211_registered_device *rdev = info->user_ptr[0];
9619 struct net_device *dev = info->user_ptr[1];
9620 struct wireless_dev *wdev = dev->ieee80211_ptr;
9621 const u8 *peer;
9622 u8 tsid;
9623 int err;
9624
9625 if (!info->attrs[NL80211_ATTR_TSID] || !info->attrs[NL80211_ATTR_MAC])
9626 return -EINVAL;
9627
9628 tsid = nla_get_u8(info->attrs[NL80211_ATTR_TSID]);
9629 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
9630
9631 wdev_lock(wdev);
9632 err = rdev_del_tx_ts(rdev, dev, tsid, peer);
9633 wdev_unlock(wdev);
9634
9635 return err;
9636 }
9637
9638 #define NL80211_FLAG_NEED_WIPHY 0x01
9639 #define NL80211_FLAG_NEED_NETDEV 0x02
9640 #define NL80211_FLAG_NEED_RTNL 0x04
9641 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
9642 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
9643 NL80211_FLAG_CHECK_NETDEV_UP)
9644 #define NL80211_FLAG_NEED_WDEV 0x10
9645 /* If a netdev is associated, it must be UP, P2P must be started */
9646 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
9647 NL80211_FLAG_CHECK_NETDEV_UP)
9648 #define NL80211_FLAG_CLEAR_SKB 0x20
9649
9650 static int nl80211_pre_doit(const struct genl_ops *ops, struct sk_buff *skb,
9651 struct genl_info *info)
9652 {
9653 struct cfg80211_registered_device *rdev;
9654 struct wireless_dev *wdev;
9655 struct net_device *dev;
9656 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
9657
9658 if (rtnl)
9659 rtnl_lock();
9660
9661 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
9662 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
9663 if (IS_ERR(rdev)) {
9664 if (rtnl)
9665 rtnl_unlock();
9666 return PTR_ERR(rdev);
9667 }
9668 info->user_ptr[0] = rdev;
9669 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
9670 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
9671 ASSERT_RTNL();
9672
9673 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
9674 info->attrs);
9675 if (IS_ERR(wdev)) {
9676 if (rtnl)
9677 rtnl_unlock();
9678 return PTR_ERR(wdev);
9679 }
9680
9681 dev = wdev->netdev;
9682 rdev = wiphy_to_rdev(wdev->wiphy);
9683
9684 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
9685 if (!dev) {
9686 if (rtnl)
9687 rtnl_unlock();
9688 return -EINVAL;
9689 }
9690
9691 info->user_ptr[1] = dev;
9692 } else {
9693 info->user_ptr[1] = wdev;
9694 }
9695
9696 if (dev) {
9697 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
9698 !netif_running(dev)) {
9699 if (rtnl)
9700 rtnl_unlock();
9701 return -ENETDOWN;
9702 }
9703
9704 dev_hold(dev);
9705 } else if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP) {
9706 if (!wdev->p2p_started) {
9707 if (rtnl)
9708 rtnl_unlock();
9709 return -ENETDOWN;
9710 }
9711 }
9712
9713 info->user_ptr[0] = rdev;
9714 }
9715
9716 return 0;
9717 }
9718
9719 static void nl80211_post_doit(const struct genl_ops *ops, struct sk_buff *skb,
9720 struct genl_info *info)
9721 {
9722 if (info->user_ptr[1]) {
9723 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
9724 struct wireless_dev *wdev = info->user_ptr[1];
9725
9726 if (wdev->netdev)
9727 dev_put(wdev->netdev);
9728 } else {
9729 dev_put(info->user_ptr[1]);
9730 }
9731 }
9732
9733 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
9734 rtnl_unlock();
9735
9736 /* If needed, clear the netlink message payload from the SKB
9737 * as it might contain key data that shouldn't stick around on
9738 * the heap after the SKB is freed. The netlink message header
9739 * is still needed for further processing, so leave it intact.
9740 */
9741 if (ops->internal_flags & NL80211_FLAG_CLEAR_SKB) {
9742 struct nlmsghdr *nlh = nlmsg_hdr(skb);
9743
9744 memset(nlmsg_data(nlh), 0, nlmsg_len(nlh));
9745 }
9746 }
9747
9748 static const struct genl_ops nl80211_ops[] = {
9749 {
9750 .cmd = NL80211_CMD_GET_WIPHY,
9751 .doit = nl80211_get_wiphy,
9752 .dumpit = nl80211_dump_wiphy,
9753 .done = nl80211_dump_wiphy_done,
9754 .policy = nl80211_policy,
9755 /* can be retrieved by unprivileged users */
9756 .internal_flags = NL80211_FLAG_NEED_WIPHY |
9757 NL80211_FLAG_NEED_RTNL,
9758 },
9759 {
9760 .cmd = NL80211_CMD_SET_WIPHY,
9761 .doit = nl80211_set_wiphy,
9762 .policy = nl80211_policy,
9763 .flags = GENL_ADMIN_PERM,
9764 .internal_flags = NL80211_FLAG_NEED_RTNL,
9765 },
9766 {
9767 .cmd = NL80211_CMD_GET_INTERFACE,
9768 .doit = nl80211_get_interface,
9769 .dumpit = nl80211_dump_interface,
9770 .policy = nl80211_policy,
9771 /* can be retrieved by unprivileged users */
9772 .internal_flags = NL80211_FLAG_NEED_WDEV |
9773 NL80211_FLAG_NEED_RTNL,
9774 },
9775 {
9776 .cmd = NL80211_CMD_SET_INTERFACE,
9777 .doit = nl80211_set_interface,
9778 .policy = nl80211_policy,
9779 .flags = GENL_ADMIN_PERM,
9780 .internal_flags = NL80211_FLAG_NEED_NETDEV |
9781 NL80211_FLAG_NEED_RTNL,
9782 },
9783 {
9784 .cmd = NL80211_CMD_NEW_INTERFACE,
9785 .doit = nl80211_new_interface,
9786 .policy = nl80211_policy,
9787 .flags = GENL_ADMIN_PERM,
9788 .internal_flags = NL80211_FLAG_NEED_WIPHY |
9789 NL80211_FLAG_NEED_RTNL,
9790 },
9791 {
9792 .cmd = NL80211_CMD_DEL_INTERFACE,
9793 .doit = nl80211_del_interface,
9794 .policy = nl80211_policy,
9795 .flags = GENL_ADMIN_PERM,
9796 .internal_flags = NL80211_FLAG_NEED_WDEV |
9797 NL80211_FLAG_NEED_RTNL,
9798 },
9799 {
9800 .cmd = NL80211_CMD_GET_KEY,
9801 .doit = nl80211_get_key,
9802 .policy = nl80211_policy,
9803 .flags = GENL_ADMIN_PERM,
9804 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9805 NL80211_FLAG_NEED_RTNL,
9806 },
9807 {
9808 .cmd = NL80211_CMD_SET_KEY,
9809 .doit = nl80211_set_key,
9810 .policy = nl80211_policy,
9811 .flags = GENL_ADMIN_PERM,
9812 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9813 NL80211_FLAG_NEED_RTNL |
9814 NL80211_FLAG_CLEAR_SKB,
9815 },
9816 {
9817 .cmd = NL80211_CMD_NEW_KEY,
9818 .doit = nl80211_new_key,
9819 .policy = nl80211_policy,
9820 .flags = GENL_ADMIN_PERM,
9821 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9822 NL80211_FLAG_NEED_RTNL |
9823 NL80211_FLAG_CLEAR_SKB,
9824 },
9825 {
9826 .cmd = NL80211_CMD_DEL_KEY,
9827 .doit = nl80211_del_key,
9828 .policy = nl80211_policy,
9829 .flags = GENL_ADMIN_PERM,
9830 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9831 NL80211_FLAG_NEED_RTNL,
9832 },
9833 {
9834 .cmd = NL80211_CMD_SET_BEACON,
9835 .policy = nl80211_policy,
9836 .flags = GENL_ADMIN_PERM,
9837 .doit = nl80211_set_beacon,
9838 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9839 NL80211_FLAG_NEED_RTNL,
9840 },
9841 {
9842 .cmd = NL80211_CMD_START_AP,
9843 .policy = nl80211_policy,
9844 .flags = GENL_ADMIN_PERM,
9845 .doit = nl80211_start_ap,
9846 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9847 NL80211_FLAG_NEED_RTNL,
9848 },
9849 {
9850 .cmd = NL80211_CMD_STOP_AP,
9851 .policy = nl80211_policy,
9852 .flags = GENL_ADMIN_PERM,
9853 .doit = nl80211_stop_ap,
9854 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9855 NL80211_FLAG_NEED_RTNL,
9856 },
9857 {
9858 .cmd = NL80211_CMD_GET_STATION,
9859 .doit = nl80211_get_station,
9860 .dumpit = nl80211_dump_station,
9861 .policy = nl80211_policy,
9862 .internal_flags = NL80211_FLAG_NEED_NETDEV |
9863 NL80211_FLAG_NEED_RTNL,
9864 },
9865 {
9866 .cmd = NL80211_CMD_SET_STATION,
9867 .doit = nl80211_set_station,
9868 .policy = nl80211_policy,
9869 .flags = GENL_ADMIN_PERM,
9870 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9871 NL80211_FLAG_NEED_RTNL,
9872 },
9873 {
9874 .cmd = NL80211_CMD_NEW_STATION,
9875 .doit = nl80211_new_station,
9876 .policy = nl80211_policy,
9877 .flags = GENL_ADMIN_PERM,
9878 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9879 NL80211_FLAG_NEED_RTNL,
9880 },
9881 {
9882 .cmd = NL80211_CMD_DEL_STATION,
9883 .doit = nl80211_del_station,
9884 .policy = nl80211_policy,
9885 .flags = GENL_ADMIN_PERM,
9886 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9887 NL80211_FLAG_NEED_RTNL,
9888 },
9889 {
9890 .cmd = NL80211_CMD_GET_MPATH,
9891 .doit = nl80211_get_mpath,
9892 .dumpit = nl80211_dump_mpath,
9893 .policy = nl80211_policy,
9894 .flags = GENL_ADMIN_PERM,
9895 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9896 NL80211_FLAG_NEED_RTNL,
9897 },
9898 {
9899 .cmd = NL80211_CMD_GET_MPP,
9900 .doit = nl80211_get_mpp,
9901 .dumpit = nl80211_dump_mpp,
9902 .policy = nl80211_policy,
9903 .flags = GENL_ADMIN_PERM,
9904 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9905 NL80211_FLAG_NEED_RTNL,
9906 },
9907 {
9908 .cmd = NL80211_CMD_SET_MPATH,
9909 .doit = nl80211_set_mpath,
9910 .policy = nl80211_policy,
9911 .flags = GENL_ADMIN_PERM,
9912 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9913 NL80211_FLAG_NEED_RTNL,
9914 },
9915 {
9916 .cmd = NL80211_CMD_NEW_MPATH,
9917 .doit = nl80211_new_mpath,
9918 .policy = nl80211_policy,
9919 .flags = GENL_ADMIN_PERM,
9920 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9921 NL80211_FLAG_NEED_RTNL,
9922 },
9923 {
9924 .cmd = NL80211_CMD_DEL_MPATH,
9925 .doit = nl80211_del_mpath,
9926 .policy = nl80211_policy,
9927 .flags = GENL_ADMIN_PERM,
9928 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9929 NL80211_FLAG_NEED_RTNL,
9930 },
9931 {
9932 .cmd = NL80211_CMD_SET_BSS,
9933 .doit = nl80211_set_bss,
9934 .policy = nl80211_policy,
9935 .flags = GENL_ADMIN_PERM,
9936 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9937 NL80211_FLAG_NEED_RTNL,
9938 },
9939 {
9940 .cmd = NL80211_CMD_GET_REG,
9941 .doit = nl80211_get_reg,
9942 .policy = nl80211_policy,
9943 .internal_flags = NL80211_FLAG_NEED_RTNL,
9944 /* can be retrieved by unprivileged users */
9945 },
9946 {
9947 .cmd = NL80211_CMD_SET_REG,
9948 .doit = nl80211_set_reg,
9949 .policy = nl80211_policy,
9950 .flags = GENL_ADMIN_PERM,
9951 .internal_flags = NL80211_FLAG_NEED_RTNL,
9952 },
9953 {
9954 .cmd = NL80211_CMD_REQ_SET_REG,
9955 .doit = nl80211_req_set_reg,
9956 .policy = nl80211_policy,
9957 .flags = GENL_ADMIN_PERM,
9958 },
9959 {
9960 .cmd = NL80211_CMD_GET_MESH_CONFIG,
9961 .doit = nl80211_get_mesh_config,
9962 .policy = nl80211_policy,
9963 /* can be retrieved by unprivileged users */
9964 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9965 NL80211_FLAG_NEED_RTNL,
9966 },
9967 {
9968 .cmd = NL80211_CMD_SET_MESH_CONFIG,
9969 .doit = nl80211_update_mesh_config,
9970 .policy = nl80211_policy,
9971 .flags = GENL_ADMIN_PERM,
9972 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9973 NL80211_FLAG_NEED_RTNL,
9974 },
9975 {
9976 .cmd = NL80211_CMD_TRIGGER_SCAN,
9977 .doit = nl80211_trigger_scan,
9978 .policy = nl80211_policy,
9979 .flags = GENL_ADMIN_PERM,
9980 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
9981 NL80211_FLAG_NEED_RTNL,
9982 },
9983 {
9984 .cmd = NL80211_CMD_GET_SCAN,
9985 .policy = nl80211_policy,
9986 .dumpit = nl80211_dump_scan,
9987 },
9988 {
9989 .cmd = NL80211_CMD_START_SCHED_SCAN,
9990 .doit = nl80211_start_sched_scan,
9991 .policy = nl80211_policy,
9992 .flags = GENL_ADMIN_PERM,
9993 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9994 NL80211_FLAG_NEED_RTNL,
9995 },
9996 {
9997 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
9998 .doit = nl80211_stop_sched_scan,
9999 .policy = nl80211_policy,
10000 .flags = GENL_ADMIN_PERM,
10001 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10002 NL80211_FLAG_NEED_RTNL,
10003 },
10004 {
10005 .cmd = NL80211_CMD_AUTHENTICATE,
10006 .doit = nl80211_authenticate,
10007 .policy = nl80211_policy,
10008 .flags = GENL_ADMIN_PERM,
10009 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10010 NL80211_FLAG_NEED_RTNL |
10011 NL80211_FLAG_CLEAR_SKB,
10012 },
10013 {
10014 .cmd = NL80211_CMD_ASSOCIATE,
10015 .doit = nl80211_associate,
10016 .policy = nl80211_policy,
10017 .flags = GENL_ADMIN_PERM,
10018 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10019 NL80211_FLAG_NEED_RTNL,
10020 },
10021 {
10022 .cmd = NL80211_CMD_DEAUTHENTICATE,
10023 .doit = nl80211_deauthenticate,
10024 .policy = nl80211_policy,
10025 .flags = GENL_ADMIN_PERM,
10026 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10027 NL80211_FLAG_NEED_RTNL,
10028 },
10029 {
10030 .cmd = NL80211_CMD_DISASSOCIATE,
10031 .doit = nl80211_disassociate,
10032 .policy = nl80211_policy,
10033 .flags = GENL_ADMIN_PERM,
10034 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10035 NL80211_FLAG_NEED_RTNL,
10036 },
10037 {
10038 .cmd = NL80211_CMD_JOIN_IBSS,
10039 .doit = nl80211_join_ibss,
10040 .policy = nl80211_policy,
10041 .flags = GENL_ADMIN_PERM,
10042 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10043 NL80211_FLAG_NEED_RTNL,
10044 },
10045 {
10046 .cmd = NL80211_CMD_LEAVE_IBSS,
10047 .doit = nl80211_leave_ibss,
10048 .policy = nl80211_policy,
10049 .flags = GENL_ADMIN_PERM,
10050 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10051 NL80211_FLAG_NEED_RTNL,
10052 },
10053 #ifdef CONFIG_NL80211_TESTMODE
10054 {
10055 .cmd = NL80211_CMD_TESTMODE,
10056 .doit = nl80211_testmode_do,
10057 .dumpit = nl80211_testmode_dump,
10058 .policy = nl80211_policy,
10059 .flags = GENL_ADMIN_PERM,
10060 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10061 NL80211_FLAG_NEED_RTNL,
10062 },
10063 #endif
10064 {
10065 .cmd = NL80211_CMD_CONNECT,
10066 .doit = nl80211_connect,
10067 .policy = nl80211_policy,
10068 .flags = GENL_ADMIN_PERM,
10069 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10070 NL80211_FLAG_NEED_RTNL,
10071 },
10072 {
10073 .cmd = NL80211_CMD_DISCONNECT,
10074 .doit = nl80211_disconnect,
10075 .policy = nl80211_policy,
10076 .flags = GENL_ADMIN_PERM,
10077 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10078 NL80211_FLAG_NEED_RTNL,
10079 },
10080 {
10081 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
10082 .doit = nl80211_wiphy_netns,
10083 .policy = nl80211_policy,
10084 .flags = GENL_ADMIN_PERM,
10085 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10086 NL80211_FLAG_NEED_RTNL,
10087 },
10088 {
10089 .cmd = NL80211_CMD_GET_SURVEY,
10090 .policy = nl80211_policy,
10091 .dumpit = nl80211_dump_survey,
10092 },
10093 {
10094 .cmd = NL80211_CMD_SET_PMKSA,
10095 .doit = nl80211_setdel_pmksa,
10096 .policy = nl80211_policy,
10097 .flags = GENL_ADMIN_PERM,
10098 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10099 NL80211_FLAG_NEED_RTNL,
10100 },
10101 {
10102 .cmd = NL80211_CMD_DEL_PMKSA,
10103 .doit = nl80211_setdel_pmksa,
10104 .policy = nl80211_policy,
10105 .flags = GENL_ADMIN_PERM,
10106 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10107 NL80211_FLAG_NEED_RTNL,
10108 },
10109 {
10110 .cmd = NL80211_CMD_FLUSH_PMKSA,
10111 .doit = nl80211_flush_pmksa,
10112 .policy = nl80211_policy,
10113 .flags = GENL_ADMIN_PERM,
10114 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10115 NL80211_FLAG_NEED_RTNL,
10116 },
10117 {
10118 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
10119 .doit = nl80211_remain_on_channel,
10120 .policy = nl80211_policy,
10121 .flags = GENL_ADMIN_PERM,
10122 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10123 NL80211_FLAG_NEED_RTNL,
10124 },
10125 {
10126 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
10127 .doit = nl80211_cancel_remain_on_channel,
10128 .policy = nl80211_policy,
10129 .flags = GENL_ADMIN_PERM,
10130 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10131 NL80211_FLAG_NEED_RTNL,
10132 },
10133 {
10134 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
10135 .doit = nl80211_set_tx_bitrate_mask,
10136 .policy = nl80211_policy,
10137 .flags = GENL_ADMIN_PERM,
10138 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10139 NL80211_FLAG_NEED_RTNL,
10140 },
10141 {
10142 .cmd = NL80211_CMD_REGISTER_FRAME,
10143 .doit = nl80211_register_mgmt,
10144 .policy = nl80211_policy,
10145 .flags = GENL_ADMIN_PERM,
10146 .internal_flags = NL80211_FLAG_NEED_WDEV |
10147 NL80211_FLAG_NEED_RTNL,
10148 },
10149 {
10150 .cmd = NL80211_CMD_FRAME,
10151 .doit = nl80211_tx_mgmt,
10152 .policy = nl80211_policy,
10153 .flags = GENL_ADMIN_PERM,
10154 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10155 NL80211_FLAG_NEED_RTNL,
10156 },
10157 {
10158 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
10159 .doit = nl80211_tx_mgmt_cancel_wait,
10160 .policy = nl80211_policy,
10161 .flags = GENL_ADMIN_PERM,
10162 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10163 NL80211_FLAG_NEED_RTNL,
10164 },
10165 {
10166 .cmd = NL80211_CMD_SET_POWER_SAVE,
10167 .doit = nl80211_set_power_save,
10168 .policy = nl80211_policy,
10169 .flags = GENL_ADMIN_PERM,
10170 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10171 NL80211_FLAG_NEED_RTNL,
10172 },
10173 {
10174 .cmd = NL80211_CMD_GET_POWER_SAVE,
10175 .doit = nl80211_get_power_save,
10176 .policy = nl80211_policy,
10177 /* can be retrieved by unprivileged users */
10178 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10179 NL80211_FLAG_NEED_RTNL,
10180 },
10181 {
10182 .cmd = NL80211_CMD_SET_CQM,
10183 .doit = nl80211_set_cqm,
10184 .policy = nl80211_policy,
10185 .flags = GENL_ADMIN_PERM,
10186 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10187 NL80211_FLAG_NEED_RTNL,
10188 },
10189 {
10190 .cmd = NL80211_CMD_SET_CHANNEL,
10191 .doit = nl80211_set_channel,
10192 .policy = nl80211_policy,
10193 .flags = GENL_ADMIN_PERM,
10194 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10195 NL80211_FLAG_NEED_RTNL,
10196 },
10197 {
10198 .cmd = NL80211_CMD_SET_WDS_PEER,
10199 .doit = nl80211_set_wds_peer,
10200 .policy = nl80211_policy,
10201 .flags = GENL_ADMIN_PERM,
10202 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10203 NL80211_FLAG_NEED_RTNL,
10204 },
10205 {
10206 .cmd = NL80211_CMD_JOIN_MESH,
10207 .doit = nl80211_join_mesh,
10208 .policy = nl80211_policy,
10209 .flags = GENL_ADMIN_PERM,
10210 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10211 NL80211_FLAG_NEED_RTNL,
10212 },
10213 {
10214 .cmd = NL80211_CMD_LEAVE_MESH,
10215 .doit = nl80211_leave_mesh,
10216 .policy = nl80211_policy,
10217 .flags = GENL_ADMIN_PERM,
10218 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10219 NL80211_FLAG_NEED_RTNL,
10220 },
10221 #ifdef CONFIG_PM
10222 {
10223 .cmd = NL80211_CMD_GET_WOWLAN,
10224 .doit = nl80211_get_wowlan,
10225 .policy = nl80211_policy,
10226 /* can be retrieved by unprivileged users */
10227 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10228 NL80211_FLAG_NEED_RTNL,
10229 },
10230 {
10231 .cmd = NL80211_CMD_SET_WOWLAN,
10232 .doit = nl80211_set_wowlan,
10233 .policy = nl80211_policy,
10234 .flags = GENL_ADMIN_PERM,
10235 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10236 NL80211_FLAG_NEED_RTNL,
10237 },
10238 #endif
10239 {
10240 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
10241 .doit = nl80211_set_rekey_data,
10242 .policy = nl80211_policy,
10243 .flags = GENL_ADMIN_PERM,
10244 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10245 NL80211_FLAG_NEED_RTNL |
10246 NL80211_FLAG_CLEAR_SKB,
10247 },
10248 {
10249 .cmd = NL80211_CMD_TDLS_MGMT,
10250 .doit = nl80211_tdls_mgmt,
10251 .policy = nl80211_policy,
10252 .flags = GENL_ADMIN_PERM,
10253 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10254 NL80211_FLAG_NEED_RTNL,
10255 },
10256 {
10257 .cmd = NL80211_CMD_TDLS_OPER,
10258 .doit = nl80211_tdls_oper,
10259 .policy = nl80211_policy,
10260 .flags = GENL_ADMIN_PERM,
10261 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10262 NL80211_FLAG_NEED_RTNL,
10263 },
10264 {
10265 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
10266 .doit = nl80211_register_unexpected_frame,
10267 .policy = nl80211_policy,
10268 .flags = GENL_ADMIN_PERM,
10269 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10270 NL80211_FLAG_NEED_RTNL,
10271 },
10272 {
10273 .cmd = NL80211_CMD_PROBE_CLIENT,
10274 .doit = nl80211_probe_client,
10275 .policy = nl80211_policy,
10276 .flags = GENL_ADMIN_PERM,
10277 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10278 NL80211_FLAG_NEED_RTNL,
10279 },
10280 {
10281 .cmd = NL80211_CMD_REGISTER_BEACONS,
10282 .doit = nl80211_register_beacons,
10283 .policy = nl80211_policy,
10284 .flags = GENL_ADMIN_PERM,
10285 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10286 NL80211_FLAG_NEED_RTNL,
10287 },
10288 {
10289 .cmd = NL80211_CMD_SET_NOACK_MAP,
10290 .doit = nl80211_set_noack_map,
10291 .policy = nl80211_policy,
10292 .flags = GENL_ADMIN_PERM,
10293 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10294 NL80211_FLAG_NEED_RTNL,
10295 },
10296 {
10297 .cmd = NL80211_CMD_START_P2P_DEVICE,
10298 .doit = nl80211_start_p2p_device,
10299 .policy = nl80211_policy,
10300 .flags = GENL_ADMIN_PERM,
10301 .internal_flags = NL80211_FLAG_NEED_WDEV |
10302 NL80211_FLAG_NEED_RTNL,
10303 },
10304 {
10305 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
10306 .doit = nl80211_stop_p2p_device,
10307 .policy = nl80211_policy,
10308 .flags = GENL_ADMIN_PERM,
10309 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10310 NL80211_FLAG_NEED_RTNL,
10311 },
10312 {
10313 .cmd = NL80211_CMD_SET_MCAST_RATE,
10314 .doit = nl80211_set_mcast_rate,
10315 .policy = nl80211_policy,
10316 .flags = GENL_ADMIN_PERM,
10317 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10318 NL80211_FLAG_NEED_RTNL,
10319 },
10320 {
10321 .cmd = NL80211_CMD_SET_MAC_ACL,
10322 .doit = nl80211_set_mac_acl,
10323 .policy = nl80211_policy,
10324 .flags = GENL_ADMIN_PERM,
10325 .internal_flags = NL80211_FLAG_NEED_NETDEV |
10326 NL80211_FLAG_NEED_RTNL,
10327 },
10328 {
10329 .cmd = NL80211_CMD_RADAR_DETECT,
10330 .doit = nl80211_start_radar_detection,
10331 .policy = nl80211_policy,
10332 .flags = GENL_ADMIN_PERM,
10333 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10334 NL80211_FLAG_NEED_RTNL,
10335 },
10336 {
10337 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
10338 .doit = nl80211_get_protocol_features,
10339 .policy = nl80211_policy,
10340 },
10341 {
10342 .cmd = NL80211_CMD_UPDATE_FT_IES,
10343 .doit = nl80211_update_ft_ies,
10344 .policy = nl80211_policy,
10345 .flags = GENL_ADMIN_PERM,
10346 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10347 NL80211_FLAG_NEED_RTNL,
10348 },
10349 {
10350 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
10351 .doit = nl80211_crit_protocol_start,
10352 .policy = nl80211_policy,
10353 .flags = GENL_ADMIN_PERM,
10354 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10355 NL80211_FLAG_NEED_RTNL,
10356 },
10357 {
10358 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
10359 .doit = nl80211_crit_protocol_stop,
10360 .policy = nl80211_policy,
10361 .flags = GENL_ADMIN_PERM,
10362 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
10363 NL80211_FLAG_NEED_RTNL,
10364 },
10365 {
10366 .cmd = NL80211_CMD_GET_COALESCE,
10367 .doit = nl80211_get_coalesce,
10368 .policy = nl80211_policy,
10369 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10370 NL80211_FLAG_NEED_RTNL,
10371 },
10372 {
10373 .cmd = NL80211_CMD_SET_COALESCE,
10374 .doit = nl80211_set_coalesce,
10375 .policy = nl80211_policy,
10376 .flags = GENL_ADMIN_PERM,
10377 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10378 NL80211_FLAG_NEED_RTNL,
10379 },
10380 {
10381 .cmd = NL80211_CMD_CHANNEL_SWITCH,
10382 .doit = nl80211_channel_switch,
10383 .policy = nl80211_policy,
10384 .flags = GENL_ADMIN_PERM,
10385 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10386 NL80211_FLAG_NEED_RTNL,
10387 },
10388 {
10389 .cmd = NL80211_CMD_VENDOR,
10390 .doit = nl80211_vendor_cmd,
10391 .policy = nl80211_policy,
10392 .flags = GENL_ADMIN_PERM,
10393 .internal_flags = NL80211_FLAG_NEED_WIPHY |
10394 NL80211_FLAG_NEED_RTNL,
10395 },
10396 {
10397 .cmd = NL80211_CMD_SET_QOS_MAP,
10398 .doit = nl80211_set_qos_map,
10399 .policy = nl80211_policy,
10400 .flags = GENL_ADMIN_PERM,
10401 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10402 NL80211_FLAG_NEED_RTNL,
10403 },
10404 {
10405 .cmd = NL80211_CMD_ADD_TX_TS,
10406 .doit = nl80211_add_tx_ts,
10407 .policy = nl80211_policy,
10408 .flags = GENL_ADMIN_PERM,
10409 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10410 NL80211_FLAG_NEED_RTNL,
10411 },
10412 {
10413 .cmd = NL80211_CMD_DEL_TX_TS,
10414 .doit = nl80211_del_tx_ts,
10415 .policy = nl80211_policy,
10416 .flags = GENL_ADMIN_PERM,
10417 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
10418 NL80211_FLAG_NEED_RTNL,
10419 },
10420 };
10421
10422 /* notification functions */
10423
10424 void nl80211_notify_wiphy(struct cfg80211_registered_device *rdev,
10425 enum nl80211_commands cmd)
10426 {
10427 struct sk_buff *msg;
10428 struct nl80211_dump_wiphy_state state = {};
10429
10430 WARN_ON(cmd != NL80211_CMD_NEW_WIPHY &&
10431 cmd != NL80211_CMD_DEL_WIPHY);
10432
10433 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10434 if (!msg)
10435 return;
10436
10437 if (nl80211_send_wiphy(rdev, cmd, msg, 0, 0, 0, &state) < 0) {
10438 nlmsg_free(msg);
10439 return;
10440 }
10441
10442 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10443 NL80211_MCGRP_CONFIG, GFP_KERNEL);
10444 }
10445
10446 static int nl80211_add_scan_req(struct sk_buff *msg,
10447 struct cfg80211_registered_device *rdev)
10448 {
10449 struct cfg80211_scan_request *req = rdev->scan_req;
10450 struct nlattr *nest;
10451 int i;
10452
10453 if (WARN_ON(!req))
10454 return 0;
10455
10456 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
10457 if (!nest)
10458 goto nla_put_failure;
10459 for (i = 0; i < req->n_ssids; i++) {
10460 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
10461 goto nla_put_failure;
10462 }
10463 nla_nest_end(msg, nest);
10464
10465 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
10466 if (!nest)
10467 goto nla_put_failure;
10468 for (i = 0; i < req->n_channels; i++) {
10469 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
10470 goto nla_put_failure;
10471 }
10472 nla_nest_end(msg, nest);
10473
10474 if (req->ie &&
10475 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
10476 goto nla_put_failure;
10477
10478 if (req->flags &&
10479 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags))
10480 goto nla_put_failure;
10481
10482 return 0;
10483 nla_put_failure:
10484 return -ENOBUFS;
10485 }
10486
10487 static int nl80211_send_scan_msg(struct sk_buff *msg,
10488 struct cfg80211_registered_device *rdev,
10489 struct wireless_dev *wdev,
10490 u32 portid, u32 seq, int flags,
10491 u32 cmd)
10492 {
10493 void *hdr;
10494
10495 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
10496 if (!hdr)
10497 return -1;
10498
10499 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10500 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10501 wdev->netdev->ifindex)) ||
10502 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10503 goto nla_put_failure;
10504
10505 /* ignore errors and send incomplete event anyway */
10506 nl80211_add_scan_req(msg, rdev);
10507
10508 return genlmsg_end(msg, hdr);
10509
10510 nla_put_failure:
10511 genlmsg_cancel(msg, hdr);
10512 return -EMSGSIZE;
10513 }
10514
10515 static int
10516 nl80211_send_sched_scan_msg(struct sk_buff *msg,
10517 struct cfg80211_registered_device *rdev,
10518 struct net_device *netdev,
10519 u32 portid, u32 seq, int flags, u32 cmd)
10520 {
10521 void *hdr;
10522
10523 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
10524 if (!hdr)
10525 return -1;
10526
10527 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10528 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
10529 goto nla_put_failure;
10530
10531 return genlmsg_end(msg, hdr);
10532
10533 nla_put_failure:
10534 genlmsg_cancel(msg, hdr);
10535 return -EMSGSIZE;
10536 }
10537
10538 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
10539 struct wireless_dev *wdev)
10540 {
10541 struct sk_buff *msg;
10542
10543 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10544 if (!msg)
10545 return;
10546
10547 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
10548 NL80211_CMD_TRIGGER_SCAN) < 0) {
10549 nlmsg_free(msg);
10550 return;
10551 }
10552
10553 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10554 NL80211_MCGRP_SCAN, GFP_KERNEL);
10555 }
10556
10557 struct sk_buff *nl80211_build_scan_msg(struct cfg80211_registered_device *rdev,
10558 struct wireless_dev *wdev, bool aborted)
10559 {
10560 struct sk_buff *msg;
10561
10562 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10563 if (!msg)
10564 return NULL;
10565
10566 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
10567 aborted ? NL80211_CMD_SCAN_ABORTED :
10568 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
10569 nlmsg_free(msg);
10570 return NULL;
10571 }
10572
10573 return msg;
10574 }
10575
10576 void nl80211_send_scan_result(struct cfg80211_registered_device *rdev,
10577 struct sk_buff *msg)
10578 {
10579 if (!msg)
10580 return;
10581
10582 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10583 NL80211_MCGRP_SCAN, GFP_KERNEL);
10584 }
10585
10586 void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
10587 struct net_device *netdev)
10588 {
10589 struct sk_buff *msg;
10590
10591 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10592 if (!msg)
10593 return;
10594
10595 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
10596 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
10597 nlmsg_free(msg);
10598 return;
10599 }
10600
10601 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10602 NL80211_MCGRP_SCAN, GFP_KERNEL);
10603 }
10604
10605 void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
10606 struct net_device *netdev, u32 cmd)
10607 {
10608 struct sk_buff *msg;
10609
10610 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10611 if (!msg)
10612 return;
10613
10614 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
10615 nlmsg_free(msg);
10616 return;
10617 }
10618
10619 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10620 NL80211_MCGRP_SCAN, GFP_KERNEL);
10621 }
10622
10623 /*
10624 * This can happen on global regulatory changes or device specific settings
10625 * based on custom world regulatory domains.
10626 */
10627 void nl80211_send_reg_change_event(struct regulatory_request *request)
10628 {
10629 struct sk_buff *msg;
10630 void *hdr;
10631
10632 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10633 if (!msg)
10634 return;
10635
10636 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
10637 if (!hdr) {
10638 nlmsg_free(msg);
10639 return;
10640 }
10641
10642 /* Userspace can always count this one always being set */
10643 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
10644 goto nla_put_failure;
10645
10646 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
10647 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
10648 NL80211_REGDOM_TYPE_WORLD))
10649 goto nla_put_failure;
10650 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
10651 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
10652 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
10653 goto nla_put_failure;
10654 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
10655 request->intersect) {
10656 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
10657 NL80211_REGDOM_TYPE_INTERSECTION))
10658 goto nla_put_failure;
10659 } else {
10660 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
10661 NL80211_REGDOM_TYPE_COUNTRY) ||
10662 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
10663 request->alpha2))
10664 goto nla_put_failure;
10665 }
10666
10667 if (request->wiphy_idx != WIPHY_IDX_INVALID &&
10668 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
10669 goto nla_put_failure;
10670
10671 genlmsg_end(msg, hdr);
10672
10673 rcu_read_lock();
10674 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
10675 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
10676 rcu_read_unlock();
10677
10678 return;
10679
10680 nla_put_failure:
10681 genlmsg_cancel(msg, hdr);
10682 nlmsg_free(msg);
10683 }
10684
10685 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
10686 struct net_device *netdev,
10687 const u8 *buf, size_t len,
10688 enum nl80211_commands cmd, gfp_t gfp,
10689 int uapsd_queues)
10690 {
10691 struct sk_buff *msg;
10692 void *hdr;
10693
10694 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10695 if (!msg)
10696 return;
10697
10698 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
10699 if (!hdr) {
10700 nlmsg_free(msg);
10701 return;
10702 }
10703
10704 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10705 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10706 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
10707 goto nla_put_failure;
10708
10709 if (uapsd_queues >= 0) {
10710 struct nlattr *nla_wmm =
10711 nla_nest_start(msg, NL80211_ATTR_STA_WME);
10712 if (!nla_wmm)
10713 goto nla_put_failure;
10714
10715 if (nla_put_u8(msg, NL80211_STA_WME_UAPSD_QUEUES,
10716 uapsd_queues))
10717 goto nla_put_failure;
10718
10719 nla_nest_end(msg, nla_wmm);
10720 }
10721
10722 genlmsg_end(msg, hdr);
10723
10724 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10725 NL80211_MCGRP_MLME, gfp);
10726 return;
10727
10728 nla_put_failure:
10729 genlmsg_cancel(msg, hdr);
10730 nlmsg_free(msg);
10731 }
10732
10733 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
10734 struct net_device *netdev, const u8 *buf,
10735 size_t len, gfp_t gfp)
10736 {
10737 nl80211_send_mlme_event(rdev, netdev, buf, len,
10738 NL80211_CMD_AUTHENTICATE, gfp, -1);
10739 }
10740
10741 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
10742 struct net_device *netdev, const u8 *buf,
10743 size_t len, gfp_t gfp, int uapsd_queues)
10744 {
10745 nl80211_send_mlme_event(rdev, netdev, buf, len,
10746 NL80211_CMD_ASSOCIATE, gfp, uapsd_queues);
10747 }
10748
10749 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
10750 struct net_device *netdev, const u8 *buf,
10751 size_t len, gfp_t gfp)
10752 {
10753 nl80211_send_mlme_event(rdev, netdev, buf, len,
10754 NL80211_CMD_DEAUTHENTICATE, gfp, -1);
10755 }
10756
10757 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
10758 struct net_device *netdev, const u8 *buf,
10759 size_t len, gfp_t gfp)
10760 {
10761 nl80211_send_mlme_event(rdev, netdev, buf, len,
10762 NL80211_CMD_DISASSOCIATE, gfp, -1);
10763 }
10764
10765 void cfg80211_rx_unprot_mlme_mgmt(struct net_device *dev, const u8 *buf,
10766 size_t len)
10767 {
10768 struct wireless_dev *wdev = dev->ieee80211_ptr;
10769 struct wiphy *wiphy = wdev->wiphy;
10770 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
10771 const struct ieee80211_mgmt *mgmt = (void *)buf;
10772 u32 cmd;
10773
10774 if (WARN_ON(len < 2))
10775 return;
10776
10777 if (ieee80211_is_deauth(mgmt->frame_control))
10778 cmd = NL80211_CMD_UNPROT_DEAUTHENTICATE;
10779 else
10780 cmd = NL80211_CMD_UNPROT_DISASSOCIATE;
10781
10782 trace_cfg80211_rx_unprot_mlme_mgmt(dev, buf, len);
10783 nl80211_send_mlme_event(rdev, dev, buf, len, cmd, GFP_ATOMIC, -1);
10784 }
10785 EXPORT_SYMBOL(cfg80211_rx_unprot_mlme_mgmt);
10786
10787 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
10788 struct net_device *netdev, int cmd,
10789 const u8 *addr, gfp_t gfp)
10790 {
10791 struct sk_buff *msg;
10792 void *hdr;
10793
10794 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10795 if (!msg)
10796 return;
10797
10798 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
10799 if (!hdr) {
10800 nlmsg_free(msg);
10801 return;
10802 }
10803
10804 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10805 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10806 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
10807 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
10808 goto nla_put_failure;
10809
10810 genlmsg_end(msg, hdr);
10811
10812 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10813 NL80211_MCGRP_MLME, gfp);
10814 return;
10815
10816 nla_put_failure:
10817 genlmsg_cancel(msg, hdr);
10818 nlmsg_free(msg);
10819 }
10820
10821 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
10822 struct net_device *netdev, const u8 *addr,
10823 gfp_t gfp)
10824 {
10825 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
10826 addr, gfp);
10827 }
10828
10829 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
10830 struct net_device *netdev, const u8 *addr,
10831 gfp_t gfp)
10832 {
10833 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
10834 addr, gfp);
10835 }
10836
10837 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
10838 struct net_device *netdev, const u8 *bssid,
10839 const u8 *req_ie, size_t req_ie_len,
10840 const u8 *resp_ie, size_t resp_ie_len,
10841 u16 status, gfp_t gfp)
10842 {
10843 struct sk_buff *msg;
10844 void *hdr;
10845
10846 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10847 if (!msg)
10848 return;
10849
10850 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
10851 if (!hdr) {
10852 nlmsg_free(msg);
10853 return;
10854 }
10855
10856 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10857 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10858 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
10859 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
10860 (req_ie &&
10861 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
10862 (resp_ie &&
10863 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
10864 goto nla_put_failure;
10865
10866 genlmsg_end(msg, hdr);
10867
10868 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10869 NL80211_MCGRP_MLME, gfp);
10870 return;
10871
10872 nla_put_failure:
10873 genlmsg_cancel(msg, hdr);
10874 nlmsg_free(msg);
10875
10876 }
10877
10878 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
10879 struct net_device *netdev, const u8 *bssid,
10880 const u8 *req_ie, size_t req_ie_len,
10881 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
10882 {
10883 struct sk_buff *msg;
10884 void *hdr;
10885
10886 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10887 if (!msg)
10888 return;
10889
10890 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
10891 if (!hdr) {
10892 nlmsg_free(msg);
10893 return;
10894 }
10895
10896 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10897 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10898 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
10899 (req_ie &&
10900 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
10901 (resp_ie &&
10902 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
10903 goto nla_put_failure;
10904
10905 genlmsg_end(msg, hdr);
10906
10907 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10908 NL80211_MCGRP_MLME, gfp);
10909 return;
10910
10911 nla_put_failure:
10912 genlmsg_cancel(msg, hdr);
10913 nlmsg_free(msg);
10914
10915 }
10916
10917 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
10918 struct net_device *netdev, u16 reason,
10919 const u8 *ie, size_t ie_len, bool from_ap)
10920 {
10921 struct sk_buff *msg;
10922 void *hdr;
10923
10924 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10925 if (!msg)
10926 return;
10927
10928 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
10929 if (!hdr) {
10930 nlmsg_free(msg);
10931 return;
10932 }
10933
10934 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10935 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10936 (from_ap && reason &&
10937 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
10938 (from_ap &&
10939 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
10940 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
10941 goto nla_put_failure;
10942
10943 genlmsg_end(msg, hdr);
10944
10945 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10946 NL80211_MCGRP_MLME, GFP_KERNEL);
10947 return;
10948
10949 nla_put_failure:
10950 genlmsg_cancel(msg, hdr);
10951 nlmsg_free(msg);
10952
10953 }
10954
10955 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
10956 struct net_device *netdev, const u8 *bssid,
10957 gfp_t gfp)
10958 {
10959 struct sk_buff *msg;
10960 void *hdr;
10961
10962 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10963 if (!msg)
10964 return;
10965
10966 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
10967 if (!hdr) {
10968 nlmsg_free(msg);
10969 return;
10970 }
10971
10972 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10973 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10974 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
10975 goto nla_put_failure;
10976
10977 genlmsg_end(msg, hdr);
10978
10979 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
10980 NL80211_MCGRP_MLME, gfp);
10981 return;
10982
10983 nla_put_failure:
10984 genlmsg_cancel(msg, hdr);
10985 nlmsg_free(msg);
10986 }
10987
10988 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
10989 const u8* ie, u8 ie_len, gfp_t gfp)
10990 {
10991 struct wireless_dev *wdev = dev->ieee80211_ptr;
10992 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
10993 struct sk_buff *msg;
10994 void *hdr;
10995
10996 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
10997 return;
10998
10999 trace_cfg80211_notify_new_peer_candidate(dev, addr);
11000
11001 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11002 if (!msg)
11003 return;
11004
11005 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
11006 if (!hdr) {
11007 nlmsg_free(msg);
11008 return;
11009 }
11010
11011 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11012 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11013 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
11014 (ie_len && ie &&
11015 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
11016 goto nla_put_failure;
11017
11018 genlmsg_end(msg, hdr);
11019
11020 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11021 NL80211_MCGRP_MLME, gfp);
11022 return;
11023
11024 nla_put_failure:
11025 genlmsg_cancel(msg, hdr);
11026 nlmsg_free(msg);
11027 }
11028 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
11029
11030 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
11031 struct net_device *netdev, const u8 *addr,
11032 enum nl80211_key_type key_type, int key_id,
11033 const u8 *tsc, gfp_t gfp)
11034 {
11035 struct sk_buff *msg;
11036 void *hdr;
11037
11038 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11039 if (!msg)
11040 return;
11041
11042 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
11043 if (!hdr) {
11044 nlmsg_free(msg);
11045 return;
11046 }
11047
11048 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11049 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11050 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
11051 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
11052 (key_id != -1 &&
11053 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
11054 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
11055 goto nla_put_failure;
11056
11057 genlmsg_end(msg, hdr);
11058
11059 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11060 NL80211_MCGRP_MLME, gfp);
11061 return;
11062
11063 nla_put_failure:
11064 genlmsg_cancel(msg, hdr);
11065 nlmsg_free(msg);
11066 }
11067
11068 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
11069 struct ieee80211_channel *channel_before,
11070 struct ieee80211_channel *channel_after)
11071 {
11072 struct sk_buff *msg;
11073 void *hdr;
11074 struct nlattr *nl_freq;
11075
11076 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
11077 if (!msg)
11078 return;
11079
11080 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
11081 if (!hdr) {
11082 nlmsg_free(msg);
11083 return;
11084 }
11085
11086 /*
11087 * Since we are applying the beacon hint to a wiphy we know its
11088 * wiphy_idx is valid
11089 */
11090 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
11091 goto nla_put_failure;
11092
11093 /* Before */
11094 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
11095 if (!nl_freq)
11096 goto nla_put_failure;
11097 if (nl80211_msg_put_channel(msg, channel_before, false))
11098 goto nla_put_failure;
11099 nla_nest_end(msg, nl_freq);
11100
11101 /* After */
11102 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
11103 if (!nl_freq)
11104 goto nla_put_failure;
11105 if (nl80211_msg_put_channel(msg, channel_after, false))
11106 goto nla_put_failure;
11107 nla_nest_end(msg, nl_freq);
11108
11109 genlmsg_end(msg, hdr);
11110
11111 rcu_read_lock();
11112 genlmsg_multicast_allns(&nl80211_fam, msg, 0,
11113 NL80211_MCGRP_REGULATORY, GFP_ATOMIC);
11114 rcu_read_unlock();
11115
11116 return;
11117
11118 nla_put_failure:
11119 genlmsg_cancel(msg, hdr);
11120 nlmsg_free(msg);
11121 }
11122
11123 static void nl80211_send_remain_on_chan_event(
11124 int cmd, struct cfg80211_registered_device *rdev,
11125 struct wireless_dev *wdev, u64 cookie,
11126 struct ieee80211_channel *chan,
11127 unsigned int duration, gfp_t gfp)
11128 {
11129 struct sk_buff *msg;
11130 void *hdr;
11131
11132 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11133 if (!msg)
11134 return;
11135
11136 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
11137 if (!hdr) {
11138 nlmsg_free(msg);
11139 return;
11140 }
11141
11142 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11143 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11144 wdev->netdev->ifindex)) ||
11145 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
11146 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
11147 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
11148 NL80211_CHAN_NO_HT) ||
11149 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
11150 goto nla_put_failure;
11151
11152 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
11153 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
11154 goto nla_put_failure;
11155
11156 genlmsg_end(msg, hdr);
11157
11158 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11159 NL80211_MCGRP_MLME, gfp);
11160 return;
11161
11162 nla_put_failure:
11163 genlmsg_cancel(msg, hdr);
11164 nlmsg_free(msg);
11165 }
11166
11167 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
11168 struct ieee80211_channel *chan,
11169 unsigned int duration, gfp_t gfp)
11170 {
11171 struct wiphy *wiphy = wdev->wiphy;
11172 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11173
11174 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
11175 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
11176 rdev, wdev, cookie, chan,
11177 duration, gfp);
11178 }
11179 EXPORT_SYMBOL(cfg80211_ready_on_channel);
11180
11181 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
11182 struct ieee80211_channel *chan,
11183 gfp_t gfp)
11184 {
11185 struct wiphy *wiphy = wdev->wiphy;
11186 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11187
11188 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
11189 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
11190 rdev, wdev, cookie, chan, 0, gfp);
11191 }
11192 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
11193
11194 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
11195 struct station_info *sinfo, gfp_t gfp)
11196 {
11197 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
11198 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11199 struct sk_buff *msg;
11200
11201 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
11202
11203 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11204 if (!msg)
11205 return;
11206
11207 if (nl80211_send_station(msg, 0, 0, 0,
11208 rdev, dev, mac_addr, sinfo) < 0) {
11209 nlmsg_free(msg);
11210 return;
11211 }
11212
11213 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11214 NL80211_MCGRP_MLME, gfp);
11215 }
11216 EXPORT_SYMBOL(cfg80211_new_sta);
11217
11218 void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp)
11219 {
11220 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
11221 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11222 struct sk_buff *msg;
11223 void *hdr;
11224
11225 trace_cfg80211_del_sta(dev, mac_addr);
11226
11227 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11228 if (!msg)
11229 return;
11230
11231 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
11232 if (!hdr) {
11233 nlmsg_free(msg);
11234 return;
11235 }
11236
11237 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11238 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
11239 goto nla_put_failure;
11240
11241 genlmsg_end(msg, hdr);
11242
11243 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11244 NL80211_MCGRP_MLME, gfp);
11245 return;
11246
11247 nla_put_failure:
11248 genlmsg_cancel(msg, hdr);
11249 nlmsg_free(msg);
11250 }
11251 EXPORT_SYMBOL(cfg80211_del_sta);
11252
11253 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
11254 enum nl80211_connect_failed_reason reason,
11255 gfp_t gfp)
11256 {
11257 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
11258 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11259 struct sk_buff *msg;
11260 void *hdr;
11261
11262 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
11263 if (!msg)
11264 return;
11265
11266 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
11267 if (!hdr) {
11268 nlmsg_free(msg);
11269 return;
11270 }
11271
11272 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11273 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
11274 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
11275 goto nla_put_failure;
11276
11277 genlmsg_end(msg, hdr);
11278
11279 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11280 NL80211_MCGRP_MLME, gfp);
11281 return;
11282
11283 nla_put_failure:
11284 genlmsg_cancel(msg, hdr);
11285 nlmsg_free(msg);
11286 }
11287 EXPORT_SYMBOL(cfg80211_conn_failed);
11288
11289 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
11290 const u8 *addr, gfp_t gfp)
11291 {
11292 struct wireless_dev *wdev = dev->ieee80211_ptr;
11293 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
11294 struct sk_buff *msg;
11295 void *hdr;
11296 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
11297
11298 if (!nlportid)
11299 return false;
11300
11301 msg = nlmsg_new(100, gfp);
11302 if (!msg)
11303 return true;
11304
11305 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
11306 if (!hdr) {
11307 nlmsg_free(msg);
11308 return true;
11309 }
11310
11311 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11312 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11313 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
11314 goto nla_put_failure;
11315
11316 genlmsg_end(msg, hdr);
11317 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
11318 return true;
11319
11320 nla_put_failure:
11321 genlmsg_cancel(msg, hdr);
11322 nlmsg_free(msg);
11323 return true;
11324 }
11325
11326 bool cfg80211_rx_spurious_frame(struct net_device *dev,
11327 const u8 *addr, gfp_t gfp)
11328 {
11329 struct wireless_dev *wdev = dev->ieee80211_ptr;
11330 bool ret;
11331
11332 trace_cfg80211_rx_spurious_frame(dev, addr);
11333
11334 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
11335 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
11336 trace_cfg80211_return_bool(false);
11337 return false;
11338 }
11339 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
11340 addr, gfp);
11341 trace_cfg80211_return_bool(ret);
11342 return ret;
11343 }
11344 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
11345
11346 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
11347 const u8 *addr, gfp_t gfp)
11348 {
11349 struct wireless_dev *wdev = dev->ieee80211_ptr;
11350 bool ret;
11351
11352 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
11353
11354 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
11355 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
11356 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
11357 trace_cfg80211_return_bool(false);
11358 return false;
11359 }
11360 ret = __nl80211_unexpected_frame(dev,
11361 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
11362 addr, gfp);
11363 trace_cfg80211_return_bool(ret);
11364 return ret;
11365 }
11366 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
11367
11368 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
11369 struct wireless_dev *wdev, u32 nlportid,
11370 int freq, int sig_dbm,
11371 const u8 *buf, size_t len, u32 flags, gfp_t gfp)
11372 {
11373 struct net_device *netdev = wdev->netdev;
11374 struct sk_buff *msg;
11375 void *hdr;
11376
11377 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11378 if (!msg)
11379 return -ENOMEM;
11380
11381 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
11382 if (!hdr) {
11383 nlmsg_free(msg);
11384 return -ENOMEM;
11385 }
11386
11387 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11388 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11389 netdev->ifindex)) ||
11390 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
11391 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
11392 (sig_dbm &&
11393 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
11394 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
11395 (flags &&
11396 nla_put_u32(msg, NL80211_ATTR_RXMGMT_FLAGS, flags)))
11397 goto nla_put_failure;
11398
11399 genlmsg_end(msg, hdr);
11400
11401 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
11402
11403 nla_put_failure:
11404 genlmsg_cancel(msg, hdr);
11405 nlmsg_free(msg);
11406 return -ENOBUFS;
11407 }
11408
11409 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
11410 const u8 *buf, size_t len, bool ack, gfp_t gfp)
11411 {
11412 struct wiphy *wiphy = wdev->wiphy;
11413 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11414 struct net_device *netdev = wdev->netdev;
11415 struct sk_buff *msg;
11416 void *hdr;
11417
11418 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
11419
11420 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11421 if (!msg)
11422 return;
11423
11424 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
11425 if (!hdr) {
11426 nlmsg_free(msg);
11427 return;
11428 }
11429
11430 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11431 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11432 netdev->ifindex)) ||
11433 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
11434 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
11435 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
11436 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
11437 goto nla_put_failure;
11438
11439 genlmsg_end(msg, hdr);
11440
11441 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11442 NL80211_MCGRP_MLME, gfp);
11443 return;
11444
11445 nla_put_failure:
11446 genlmsg_cancel(msg, hdr);
11447 nlmsg_free(msg);
11448 }
11449 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
11450
11451 void cfg80211_cqm_rssi_notify(struct net_device *dev,
11452 enum nl80211_cqm_rssi_threshold_event rssi_event,
11453 gfp_t gfp)
11454 {
11455 struct wireless_dev *wdev = dev->ieee80211_ptr;
11456 struct wiphy *wiphy = wdev->wiphy;
11457 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11458 struct sk_buff *msg;
11459 struct nlattr *pinfoattr;
11460 void *hdr;
11461
11462 trace_cfg80211_cqm_rssi_notify(dev, rssi_event);
11463
11464 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11465 if (!msg)
11466 return;
11467
11468 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
11469 if (!hdr) {
11470 nlmsg_free(msg);
11471 return;
11472 }
11473
11474 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11475 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
11476 goto nla_put_failure;
11477
11478 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
11479 if (!pinfoattr)
11480 goto nla_put_failure;
11481
11482 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
11483 rssi_event))
11484 goto nla_put_failure;
11485
11486 nla_nest_end(msg, pinfoattr);
11487
11488 genlmsg_end(msg, hdr);
11489
11490 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11491 NL80211_MCGRP_MLME, gfp);
11492 return;
11493
11494 nla_put_failure:
11495 genlmsg_cancel(msg, hdr);
11496 nlmsg_free(msg);
11497 }
11498 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
11499
11500 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
11501 struct net_device *netdev, const u8 *bssid,
11502 const u8 *replay_ctr, gfp_t gfp)
11503 {
11504 struct sk_buff *msg;
11505 struct nlattr *rekey_attr;
11506 void *hdr;
11507
11508 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11509 if (!msg)
11510 return;
11511
11512 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
11513 if (!hdr) {
11514 nlmsg_free(msg);
11515 return;
11516 }
11517
11518 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11519 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11520 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
11521 goto nla_put_failure;
11522
11523 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
11524 if (!rekey_attr)
11525 goto nla_put_failure;
11526
11527 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
11528 NL80211_REPLAY_CTR_LEN, replay_ctr))
11529 goto nla_put_failure;
11530
11531 nla_nest_end(msg, rekey_attr);
11532
11533 genlmsg_end(msg, hdr);
11534
11535 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11536 NL80211_MCGRP_MLME, gfp);
11537 return;
11538
11539 nla_put_failure:
11540 genlmsg_cancel(msg, hdr);
11541 nlmsg_free(msg);
11542 }
11543
11544 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
11545 const u8 *replay_ctr, gfp_t gfp)
11546 {
11547 struct wireless_dev *wdev = dev->ieee80211_ptr;
11548 struct wiphy *wiphy = wdev->wiphy;
11549 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11550
11551 trace_cfg80211_gtk_rekey_notify(dev, bssid);
11552 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
11553 }
11554 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
11555
11556 static void
11557 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
11558 struct net_device *netdev, int index,
11559 const u8 *bssid, bool preauth, gfp_t gfp)
11560 {
11561 struct sk_buff *msg;
11562 struct nlattr *attr;
11563 void *hdr;
11564
11565 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11566 if (!msg)
11567 return;
11568
11569 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
11570 if (!hdr) {
11571 nlmsg_free(msg);
11572 return;
11573 }
11574
11575 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11576 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
11577 goto nla_put_failure;
11578
11579 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
11580 if (!attr)
11581 goto nla_put_failure;
11582
11583 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
11584 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
11585 (preauth &&
11586 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
11587 goto nla_put_failure;
11588
11589 nla_nest_end(msg, attr);
11590
11591 genlmsg_end(msg, hdr);
11592
11593 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11594 NL80211_MCGRP_MLME, gfp);
11595 return;
11596
11597 nla_put_failure:
11598 genlmsg_cancel(msg, hdr);
11599 nlmsg_free(msg);
11600 }
11601
11602 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
11603 const u8 *bssid, bool preauth, gfp_t gfp)
11604 {
11605 struct wireless_dev *wdev = dev->ieee80211_ptr;
11606 struct wiphy *wiphy = wdev->wiphy;
11607 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11608
11609 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
11610 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
11611 }
11612 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
11613
11614 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
11615 struct net_device *netdev,
11616 struct cfg80211_chan_def *chandef,
11617 gfp_t gfp)
11618 {
11619 struct sk_buff *msg;
11620 void *hdr;
11621
11622 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11623 if (!msg)
11624 return;
11625
11626 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY);
11627 if (!hdr) {
11628 nlmsg_free(msg);
11629 return;
11630 }
11631
11632 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
11633 goto nla_put_failure;
11634
11635 if (nl80211_send_chandef(msg, chandef))
11636 goto nla_put_failure;
11637
11638 genlmsg_end(msg, hdr);
11639
11640 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11641 NL80211_MCGRP_MLME, gfp);
11642 return;
11643
11644 nla_put_failure:
11645 genlmsg_cancel(msg, hdr);
11646 nlmsg_free(msg);
11647 }
11648
11649 void cfg80211_ch_switch_notify(struct net_device *dev,
11650 struct cfg80211_chan_def *chandef)
11651 {
11652 struct wireless_dev *wdev = dev->ieee80211_ptr;
11653 struct wiphy *wiphy = wdev->wiphy;
11654 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11655
11656 ASSERT_WDEV_LOCK(wdev);
11657
11658 trace_cfg80211_ch_switch_notify(dev, chandef);
11659
11660 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
11661 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
11662 wdev->iftype != NL80211_IFTYPE_ADHOC &&
11663 wdev->iftype != NL80211_IFTYPE_MESH_POINT))
11664 return;
11665
11666 wdev->chandef = *chandef;
11667 wdev->preset_chandef = *chandef;
11668 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL);
11669 }
11670 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
11671
11672 void cfg80211_cqm_txe_notify(struct net_device *dev,
11673 const u8 *peer, u32 num_packets,
11674 u32 rate, u32 intvl, gfp_t gfp)
11675 {
11676 struct wireless_dev *wdev = dev->ieee80211_ptr;
11677 struct wiphy *wiphy = wdev->wiphy;
11678 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11679 struct sk_buff *msg;
11680 struct nlattr *pinfoattr;
11681 void *hdr;
11682
11683 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
11684 if (!msg)
11685 return;
11686
11687 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
11688 if (!hdr) {
11689 nlmsg_free(msg);
11690 return;
11691 }
11692
11693 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11694 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11695 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
11696 goto nla_put_failure;
11697
11698 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
11699 if (!pinfoattr)
11700 goto nla_put_failure;
11701
11702 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
11703 goto nla_put_failure;
11704
11705 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
11706 goto nla_put_failure;
11707
11708 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
11709 goto nla_put_failure;
11710
11711 nla_nest_end(msg, pinfoattr);
11712
11713 genlmsg_end(msg, hdr);
11714
11715 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11716 NL80211_MCGRP_MLME, gfp);
11717 return;
11718
11719 nla_put_failure:
11720 genlmsg_cancel(msg, hdr);
11721 nlmsg_free(msg);
11722 }
11723 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
11724
11725 void
11726 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
11727 const struct cfg80211_chan_def *chandef,
11728 enum nl80211_radar_event event,
11729 struct net_device *netdev, gfp_t gfp)
11730 {
11731 struct sk_buff *msg;
11732 void *hdr;
11733
11734 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11735 if (!msg)
11736 return;
11737
11738 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
11739 if (!hdr) {
11740 nlmsg_free(msg);
11741 return;
11742 }
11743
11744 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
11745 goto nla_put_failure;
11746
11747 /* NOP and radar events don't need a netdev parameter */
11748 if (netdev) {
11749 struct wireless_dev *wdev = netdev->ieee80211_ptr;
11750
11751 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
11752 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
11753 goto nla_put_failure;
11754 }
11755
11756 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
11757 goto nla_put_failure;
11758
11759 if (nl80211_send_chandef(msg, chandef))
11760 goto nla_put_failure;
11761
11762 genlmsg_end(msg, hdr);
11763
11764 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11765 NL80211_MCGRP_MLME, gfp);
11766 return;
11767
11768 nla_put_failure:
11769 genlmsg_cancel(msg, hdr);
11770 nlmsg_free(msg);
11771 }
11772
11773 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
11774 const u8 *peer, u32 num_packets, gfp_t gfp)
11775 {
11776 struct wireless_dev *wdev = dev->ieee80211_ptr;
11777 struct wiphy *wiphy = wdev->wiphy;
11778 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11779 struct sk_buff *msg;
11780 struct nlattr *pinfoattr;
11781 void *hdr;
11782
11783 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
11784
11785 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11786 if (!msg)
11787 return;
11788
11789 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
11790 if (!hdr) {
11791 nlmsg_free(msg);
11792 return;
11793 }
11794
11795 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11796 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11797 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
11798 goto nla_put_failure;
11799
11800 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
11801 if (!pinfoattr)
11802 goto nla_put_failure;
11803
11804 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
11805 goto nla_put_failure;
11806
11807 nla_nest_end(msg, pinfoattr);
11808
11809 genlmsg_end(msg, hdr);
11810
11811 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11812 NL80211_MCGRP_MLME, gfp);
11813 return;
11814
11815 nla_put_failure:
11816 genlmsg_cancel(msg, hdr);
11817 nlmsg_free(msg);
11818 }
11819 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
11820
11821 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
11822 u64 cookie, bool acked, gfp_t gfp)
11823 {
11824 struct wireless_dev *wdev = dev->ieee80211_ptr;
11825 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
11826 struct sk_buff *msg;
11827 void *hdr;
11828
11829 trace_cfg80211_probe_status(dev, addr, cookie, acked);
11830
11831 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
11832
11833 if (!msg)
11834 return;
11835
11836 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
11837 if (!hdr) {
11838 nlmsg_free(msg);
11839 return;
11840 }
11841
11842 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11843 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
11844 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
11845 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
11846 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
11847 goto nla_put_failure;
11848
11849 genlmsg_end(msg, hdr);
11850
11851 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
11852 NL80211_MCGRP_MLME, gfp);
11853 return;
11854
11855 nla_put_failure:
11856 genlmsg_cancel(msg, hdr);
11857 nlmsg_free(msg);
11858 }
11859 EXPORT_SYMBOL(cfg80211_probe_status);
11860
11861 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
11862 const u8 *frame, size_t len,
11863 int freq, int sig_dbm)
11864 {
11865 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
11866 struct sk_buff *msg;
11867 void *hdr;
11868 struct cfg80211_beacon_registration *reg;
11869
11870 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
11871
11872 spin_lock_bh(&rdev->beacon_registrations_lock);
11873 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
11874 msg = nlmsg_new(len + 100, GFP_ATOMIC);
11875 if (!msg) {
11876 spin_unlock_bh(&rdev->beacon_registrations_lock);
11877 return;
11878 }
11879
11880 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
11881 if (!hdr)
11882 goto nla_put_failure;
11883
11884 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11885 (freq &&
11886 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
11887 (sig_dbm &&
11888 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
11889 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
11890 goto nla_put_failure;
11891
11892 genlmsg_end(msg, hdr);
11893
11894 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
11895 }
11896 spin_unlock_bh(&rdev->beacon_registrations_lock);
11897 return;
11898
11899 nla_put_failure:
11900 spin_unlock_bh(&rdev->beacon_registrations_lock);
11901 if (hdr)
11902 genlmsg_cancel(msg, hdr);
11903 nlmsg_free(msg);
11904 }
11905 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
11906
11907 #ifdef CONFIG_PM
11908 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
11909 struct cfg80211_wowlan_wakeup *wakeup,
11910 gfp_t gfp)
11911 {
11912 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
11913 struct sk_buff *msg;
11914 void *hdr;
11915 int size = 200;
11916
11917 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
11918
11919 if (wakeup)
11920 size += wakeup->packet_present_len;
11921
11922 msg = nlmsg_new(size, gfp);
11923 if (!msg)
11924 return;
11925
11926 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
11927 if (!hdr)
11928 goto free_msg;
11929
11930 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
11931 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
11932 goto free_msg;
11933
11934 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
11935 wdev->netdev->ifindex))
11936 goto free_msg;
11937
11938 if (wakeup) {
11939 struct nlattr *reasons;
11940
11941 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
11942 if (!reasons)
11943 goto free_msg;
11944
11945 if (wakeup->disconnect &&
11946 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
11947 goto free_msg;
11948 if (wakeup->magic_pkt &&
11949 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
11950 goto free_msg;
11951 if (wakeup->gtk_rekey_failure &&
11952 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
11953 goto free_msg;
11954 if (wakeup->eap_identity_req &&
11955 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
11956 goto free_msg;
11957 if (wakeup->four_way_handshake &&
11958 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
11959 goto free_msg;
11960 if (wakeup->rfkill_release &&
11961 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
11962 goto free_msg;
11963
11964 if (wakeup->pattern_idx >= 0 &&
11965 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
11966 wakeup->pattern_idx))
11967 goto free_msg;
11968
11969 if (wakeup->tcp_match &&
11970 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH))
11971 goto free_msg;
11972
11973 if (wakeup->tcp_connlost &&
11974 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST))
11975 goto free_msg;
11976
11977 if (wakeup->tcp_nomoretokens &&
11978 nla_put_flag(msg,
11979 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS))
11980 goto free_msg;
11981
11982 if (wakeup->packet) {
11983 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
11984 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
11985
11986 if (!wakeup->packet_80211) {
11987 pkt_attr =
11988 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
11989 len_attr =
11990 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
11991 }
11992
11993 if (wakeup->packet_len &&
11994 nla_put_u32(msg, len_attr, wakeup->packet_len))
11995 goto free_msg;
11996
11997 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
11998 wakeup->packet))
11999 goto free_msg;
12000 }
12001
12002 nla_nest_end(msg, reasons);
12003 }
12004
12005 genlmsg_end(msg, hdr);
12006
12007 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
12008 NL80211_MCGRP_MLME, gfp);
12009 return;
12010
12011 free_msg:
12012 nlmsg_free(msg);
12013 }
12014 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
12015 #endif
12016
12017 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
12018 enum nl80211_tdls_operation oper,
12019 u16 reason_code, gfp_t gfp)
12020 {
12021 struct wireless_dev *wdev = dev->ieee80211_ptr;
12022 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
12023 struct sk_buff *msg;
12024 void *hdr;
12025
12026 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
12027 reason_code);
12028
12029 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12030 if (!msg)
12031 return;
12032
12033 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
12034 if (!hdr) {
12035 nlmsg_free(msg);
12036 return;
12037 }
12038
12039 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12040 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
12041 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
12042 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
12043 (reason_code > 0 &&
12044 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
12045 goto nla_put_failure;
12046
12047 genlmsg_end(msg, hdr);
12048
12049 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
12050 NL80211_MCGRP_MLME, gfp);
12051 return;
12052
12053 nla_put_failure:
12054 genlmsg_cancel(msg, hdr);
12055 nlmsg_free(msg);
12056 }
12057 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
12058
12059 static int nl80211_netlink_notify(struct notifier_block * nb,
12060 unsigned long state,
12061 void *_notify)
12062 {
12063 struct netlink_notify *notify = _notify;
12064 struct cfg80211_registered_device *rdev;
12065 struct wireless_dev *wdev;
12066 struct cfg80211_beacon_registration *reg, *tmp;
12067
12068 if (state != NETLINK_URELEASE)
12069 return NOTIFY_DONE;
12070
12071 rcu_read_lock();
12072
12073 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
12074 bool schedule_destroy_work = false;
12075
12076 list_for_each_entry_rcu(wdev, &rdev->wdev_list, list) {
12077 cfg80211_mlme_unregister_socket(wdev, notify->portid);
12078
12079 if (wdev->owner_nlportid == notify->portid)
12080 schedule_destroy_work = true;
12081 }
12082
12083 spin_lock_bh(&rdev->beacon_registrations_lock);
12084 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
12085 list) {
12086 if (reg->nlportid == notify->portid) {
12087 list_del(&reg->list);
12088 kfree(reg);
12089 break;
12090 }
12091 }
12092 spin_unlock_bh(&rdev->beacon_registrations_lock);
12093
12094 if (schedule_destroy_work) {
12095 struct cfg80211_iface_destroy *destroy;
12096
12097 destroy = kzalloc(sizeof(*destroy), GFP_ATOMIC);
12098 if (destroy) {
12099 destroy->nlportid = notify->portid;
12100 spin_lock(&rdev->destroy_list_lock);
12101 list_add(&destroy->list, &rdev->destroy_list);
12102 spin_unlock(&rdev->destroy_list_lock);
12103 schedule_work(&rdev->destroy_work);
12104 }
12105 }
12106 }
12107
12108 rcu_read_unlock();
12109
12110 return NOTIFY_OK;
12111 }
12112
12113 static struct notifier_block nl80211_netlink_notifier = {
12114 .notifier_call = nl80211_netlink_notify,
12115 };
12116
12117 void cfg80211_ft_event(struct net_device *netdev,
12118 struct cfg80211_ft_event_params *ft_event)
12119 {
12120 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
12121 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12122 struct sk_buff *msg;
12123 void *hdr;
12124
12125 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
12126
12127 if (!ft_event->target_ap)
12128 return;
12129
12130 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12131 if (!msg)
12132 return;
12133
12134 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
12135 if (!hdr)
12136 goto out;
12137
12138 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12139 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
12140 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap))
12141 goto out;
12142
12143 if (ft_event->ies &&
12144 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies))
12145 goto out;
12146 if (ft_event->ric_ies &&
12147 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
12148 ft_event->ric_ies))
12149 goto out;
12150
12151 genlmsg_end(msg, hdr);
12152
12153 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
12154 NL80211_MCGRP_MLME, GFP_KERNEL);
12155 return;
12156 out:
12157 nlmsg_free(msg);
12158 }
12159 EXPORT_SYMBOL(cfg80211_ft_event);
12160
12161 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
12162 {
12163 struct cfg80211_registered_device *rdev;
12164 struct sk_buff *msg;
12165 void *hdr;
12166 u32 nlportid;
12167
12168 rdev = wiphy_to_rdev(wdev->wiphy);
12169 if (!rdev->crit_proto_nlportid)
12170 return;
12171
12172 nlportid = rdev->crit_proto_nlportid;
12173 rdev->crit_proto_nlportid = 0;
12174
12175 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
12176 if (!msg)
12177 return;
12178
12179 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
12180 if (!hdr)
12181 goto nla_put_failure;
12182
12183 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12184 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
12185 goto nla_put_failure;
12186
12187 genlmsg_end(msg, hdr);
12188
12189 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
12190 return;
12191
12192 nla_put_failure:
12193 if (hdr)
12194 genlmsg_cancel(msg, hdr);
12195 nlmsg_free(msg);
12196
12197 }
12198 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
12199
12200 void nl80211_send_ap_stopped(struct wireless_dev *wdev)
12201 {
12202 struct wiphy *wiphy = wdev->wiphy;
12203 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
12204 struct sk_buff *msg;
12205 void *hdr;
12206
12207 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
12208 if (!msg)
12209 return;
12210
12211 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_STOP_AP);
12212 if (!hdr)
12213 goto out;
12214
12215 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
12216 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex) ||
12217 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
12218 goto out;
12219
12220 genlmsg_end(msg, hdr);
12221
12222 genlmsg_multicast_netns(&nl80211_fam, wiphy_net(wiphy), msg, 0,
12223 NL80211_MCGRP_MLME, GFP_KERNEL);
12224 return;
12225 out:
12226 nlmsg_free(msg);
12227 }
12228
12229 /* initialisation/exit functions */
12230
12231 int nl80211_init(void)
12232 {
12233 int err;
12234
12235 err = genl_register_family_with_ops_groups(&nl80211_fam, nl80211_ops,
12236 nl80211_mcgrps);
12237 if (err)
12238 return err;
12239
12240 err = netlink_register_notifier(&nl80211_netlink_notifier);
12241 if (err)
12242 goto err_out;
12243
12244 return 0;
12245 err_out:
12246 genl_unregister_family(&nl80211_fam);
12247 return err;
12248 }
12249
12250 void nl80211_exit(void)
12251 {
12252 netlink_unregister_notifier(&nl80211_netlink_notifier);
12253 genl_unregister_family(&nl80211_fam);
12254 }
Linux kernel - Deliverables
This page took 0.273757 seconds and 6 git commands to generate.