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