projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'v3.10.68' 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 /* When you run into this, adjust the code below for the new flag */
4075 BUILD_BUG_ON(NL80211_STA_FLAG_MAX != 7);
4076
4077 switch (dev->ieee80211_ptr->iftype) {
4078 case NL80211_IFTYPE_AP:
4079 case NL80211_IFTYPE_AP_VLAN:
4080 case NL80211_IFTYPE_P2P_GO:
4081 /* ignore WME attributes if iface/sta is not capable */
4082 if (!(rdev->wiphy.flags & WIPHY_FLAG_AP_UAPSD) ||
4083 !(params.sta_flags_set & BIT(NL80211_STA_FLAG_WME)))
4084 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4085
4086 /* TDLS peers cannot be added */
4087 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4088 return -EINVAL;
4089 /* but don't bother the driver with it */
4090 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_TDLS_PEER);
4091
4092 /* allow authenticated/associated only if driver handles it */
4093 if (!(rdev->wiphy.features &
4094 NL80211_FEATURE_FULL_AP_CLIENT_STATE) &&
4095 params.sta_flags_mask &
4096 (BIT(NL80211_STA_FLAG_AUTHENTICATED) |
4097 BIT(NL80211_STA_FLAG_ASSOCIATED)))
4098 return -EINVAL;
4099
4100 /* must be last in here for error handling */
4101 params.vlan = get_vlan(info, rdev);
4102 if (IS_ERR(params.vlan))
4103 return PTR_ERR(params.vlan);
4104 break;
4105 case NL80211_IFTYPE_MESH_POINT:
4106 /* ignore uAPSD data */
4107 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4108
4109 /* associated is disallowed */
4110 if (params.sta_flags_mask & BIT(NL80211_STA_FLAG_ASSOCIATED))
4111 return -EINVAL;
4112 /* TDLS peers cannot be added */
4113 if (params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER))
4114 return -EINVAL;
4115 break;
4116 case NL80211_IFTYPE_STATION:
4117 case NL80211_IFTYPE_P2P_CLIENT:
4118 /* ignore uAPSD data */
4119 params.sta_modify_mask &= ~STATION_PARAM_APPLY_UAPSD;
4120
4121 /* these are disallowed */
4122 if (params.sta_flags_mask &
4123 (BIT(NL80211_STA_FLAG_ASSOCIATED) |
4124 BIT(NL80211_STA_FLAG_AUTHENTICATED)))
4125 return -EINVAL;
4126 /* Only TDLS peers can be added */
4127 if (!(params.sta_flags_set & BIT(NL80211_STA_FLAG_TDLS_PEER)))
4128 return -EINVAL;
4129 /* Can only add if TDLS ... */
4130 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS))
4131 return -EOPNOTSUPP;
4132 /* ... with external setup is supported */
4133 if (!(rdev->wiphy.flags & WIPHY_FLAG_TDLS_EXTERNAL_SETUP))
4134 return -EOPNOTSUPP;
4135 /*
4136 * Older wpa_supplicant versions always mark the TDLS peer
4137 * as authorized, but it shouldn't yet be.
4138 */
4139 params.sta_flags_mask &= ~BIT(NL80211_STA_FLAG_AUTHORIZED);
4140 break;
4141 default:
4142 return -EOPNOTSUPP;
4143 }
4144
4145 /* be aware of params.vlan when changing code here */
4146
4147 err = rdev_add_station(rdev, dev, mac_addr, &params);
4148
4149 if (params.vlan)
4150 dev_put(params.vlan);
4151 return err;
4152 }
4153
4154 static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
4155 {
4156 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4157 struct net_device *dev = info->user_ptr[1];
4158 u8 *mac_addr = NULL;
4159
4160 if (info->attrs[NL80211_ATTR_MAC])
4161 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
4162
4163 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4164 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
4165 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT &&
4166 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4167 return -EINVAL;
4168
4169 if (!rdev->ops->del_station)
4170 return -EOPNOTSUPP;
4171
4172 return rdev_del_station(rdev, dev, mac_addr);
4173 }
4174
4175 static int nl80211_send_mpath(struct sk_buff *msg, u32 portid, u32 seq,
4176 int flags, struct net_device *dev,
4177 u8 *dst, u8 *next_hop,
4178 struct mpath_info *pinfo)
4179 {
4180 void *hdr;
4181 struct nlattr *pinfoattr;
4182
4183 hdr = nl80211hdr_put(msg, portid, seq, flags, NL80211_CMD_NEW_STATION);
4184 if (!hdr)
4185 return -1;
4186
4187 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4188 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, dst) ||
4189 nla_put(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop) ||
4190 nla_put_u32(msg, NL80211_ATTR_GENERATION, pinfo->generation))
4191 goto nla_put_failure;
4192
4193 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
4194 if (!pinfoattr)
4195 goto nla_put_failure;
4196 if ((pinfo->filled & MPATH_INFO_FRAME_QLEN) &&
4197 nla_put_u32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
4198 pinfo->frame_qlen))
4199 goto nla_put_failure;
4200 if (((pinfo->filled & MPATH_INFO_SN) &&
4201 nla_put_u32(msg, NL80211_MPATH_INFO_SN, pinfo->sn)) ||
4202 ((pinfo->filled & MPATH_INFO_METRIC) &&
4203 nla_put_u32(msg, NL80211_MPATH_INFO_METRIC,
4204 pinfo->metric)) ||
4205 ((pinfo->filled & MPATH_INFO_EXPTIME) &&
4206 nla_put_u32(msg, NL80211_MPATH_INFO_EXPTIME,
4207 pinfo->exptime)) ||
4208 ((pinfo->filled & MPATH_INFO_FLAGS) &&
4209 nla_put_u8(msg, NL80211_MPATH_INFO_FLAGS,
4210 pinfo->flags)) ||
4211 ((pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT) &&
4212 nla_put_u32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
4213 pinfo->discovery_timeout)) ||
4214 ((pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES) &&
4215 nla_put_u8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
4216 pinfo->discovery_retries)))
4217 goto nla_put_failure;
4218
4219 nla_nest_end(msg, pinfoattr);
4220
4221 return genlmsg_end(msg, hdr);
4222
4223 nla_put_failure:
4224 genlmsg_cancel(msg, hdr);
4225 return -EMSGSIZE;
4226 }
4227
4228 static int nl80211_dump_mpath(struct sk_buff *skb,
4229 struct netlink_callback *cb)
4230 {
4231 struct mpath_info pinfo;
4232 struct cfg80211_registered_device *dev;
4233 struct wireless_dev *wdev;
4234 u8 dst[ETH_ALEN];
4235 u8 next_hop[ETH_ALEN];
4236 int path_idx = cb->args[2];
4237 int err;
4238
4239 err = nl80211_prepare_wdev_dump(skb, cb, &dev, &wdev);
4240 if (err)
4241 return err;
4242
4243 if (!dev->ops->dump_mpath) {
4244 err = -EOPNOTSUPP;
4245 goto out_err;
4246 }
4247
4248 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT) {
4249 err = -EOPNOTSUPP;
4250 goto out_err;
4251 }
4252
4253 while (1) {
4254 err = rdev_dump_mpath(dev, wdev->netdev, path_idx, dst,
4255 next_hop, &pinfo);
4256 if (err == -ENOENT)
4257 break;
4258 if (err)
4259 goto out_err;
4260
4261 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).portid,
4262 cb->nlh->nlmsg_seq, NLM_F_MULTI,
4263 wdev->netdev, dst, next_hop,
4264 &pinfo) < 0)
4265 goto out;
4266
4267 path_idx++;
4268 }
4269
4270
4271 out:
4272 cb->args[2] = path_idx;
4273 err = skb->len;
4274 out_err:
4275 nl80211_finish_wdev_dump(dev);
4276 return err;
4277 }
4278
4279 static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
4280 {
4281 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4282 int err;
4283 struct net_device *dev = info->user_ptr[1];
4284 struct mpath_info pinfo;
4285 struct sk_buff *msg;
4286 u8 *dst = NULL;
4287 u8 next_hop[ETH_ALEN];
4288
4289 memset(&pinfo, 0, sizeof(pinfo));
4290
4291 if (!info->attrs[NL80211_ATTR_MAC])
4292 return -EINVAL;
4293
4294 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4295
4296 if (!rdev->ops->get_mpath)
4297 return -EOPNOTSUPP;
4298
4299 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4300 return -EOPNOTSUPP;
4301
4302 err = rdev_get_mpath(rdev, dev, dst, next_hop, &pinfo);
4303 if (err)
4304 return err;
4305
4306 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4307 if (!msg)
4308 return -ENOMEM;
4309
4310 if (nl80211_send_mpath(msg, info->snd_portid, info->snd_seq, 0,
4311 dev, dst, next_hop, &pinfo) < 0) {
4312 nlmsg_free(msg);
4313 return -ENOBUFS;
4314 }
4315
4316 return genlmsg_reply(msg, info);
4317 }
4318
4319 static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
4320 {
4321 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4322 struct net_device *dev = info->user_ptr[1];
4323 u8 *dst = NULL;
4324 u8 *next_hop = NULL;
4325
4326 if (!info->attrs[NL80211_ATTR_MAC])
4327 return -EINVAL;
4328
4329 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4330 return -EINVAL;
4331
4332 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4333 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4334
4335 if (!rdev->ops->change_mpath)
4336 return -EOPNOTSUPP;
4337
4338 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4339 return -EOPNOTSUPP;
4340
4341 return rdev_change_mpath(rdev, dev, dst, next_hop);
4342 }
4343
4344 static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
4345 {
4346 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4347 struct net_device *dev = info->user_ptr[1];
4348 u8 *dst = NULL;
4349 u8 *next_hop = NULL;
4350
4351 if (!info->attrs[NL80211_ATTR_MAC])
4352 return -EINVAL;
4353
4354 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
4355 return -EINVAL;
4356
4357 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4358 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
4359
4360 if (!rdev->ops->add_mpath)
4361 return -EOPNOTSUPP;
4362
4363 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
4364 return -EOPNOTSUPP;
4365
4366 return rdev_add_mpath(rdev, dev, dst, next_hop);
4367 }
4368
4369 static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
4370 {
4371 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4372 struct net_device *dev = info->user_ptr[1];
4373 u8 *dst = NULL;
4374
4375 if (info->attrs[NL80211_ATTR_MAC])
4376 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
4377
4378 if (!rdev->ops->del_mpath)
4379 return -EOPNOTSUPP;
4380
4381 return rdev_del_mpath(rdev, dev, dst);
4382 }
4383
4384 static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
4385 {
4386 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4387 struct net_device *dev = info->user_ptr[1];
4388 struct bss_parameters params;
4389
4390 memset(&params, 0, sizeof(params));
4391 /* default to not changing parameters */
4392 params.use_cts_prot = -1;
4393 params.use_short_preamble = -1;
4394 params.use_short_slot_time = -1;
4395 params.ap_isolate = -1;
4396 params.ht_opmode = -1;
4397 params.p2p_ctwindow = -1;
4398 params.p2p_opp_ps = -1;
4399
4400 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
4401 params.use_cts_prot =
4402 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
4403 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
4404 params.use_short_preamble =
4405 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
4406 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
4407 params.use_short_slot_time =
4408 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
4409 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
4410 params.basic_rates =
4411 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4412 params.basic_rates_len =
4413 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
4414 }
4415 if (info->attrs[NL80211_ATTR_AP_ISOLATE])
4416 params.ap_isolate = !!nla_get_u8(info->attrs[NL80211_ATTR_AP_ISOLATE]);
4417 if (info->attrs[NL80211_ATTR_BSS_HT_OPMODE])
4418 params.ht_opmode =
4419 nla_get_u16(info->attrs[NL80211_ATTR_BSS_HT_OPMODE]);
4420
4421 if (info->attrs[NL80211_ATTR_P2P_CTWINDOW]) {
4422 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4423 return -EINVAL;
4424 params.p2p_ctwindow =
4425 nla_get_s8(info->attrs[NL80211_ATTR_P2P_CTWINDOW]);
4426 if (params.p2p_ctwindow < 0)
4427 return -EINVAL;
4428 if (params.p2p_ctwindow != 0 &&
4429 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_CTWIN))
4430 return -EINVAL;
4431 }
4432
4433 if (info->attrs[NL80211_ATTR_P2P_OPPPS]) {
4434 u8 tmp;
4435
4436 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4437 return -EINVAL;
4438 tmp = nla_get_u8(info->attrs[NL80211_ATTR_P2P_OPPPS]);
4439 if (tmp > 1)
4440 return -EINVAL;
4441 params.p2p_opp_ps = tmp;
4442 if (params.p2p_opp_ps &&
4443 !(rdev->wiphy.features & NL80211_FEATURE_P2P_GO_OPPPS))
4444 return -EINVAL;
4445 }
4446
4447 if (!rdev->ops->change_bss)
4448 return -EOPNOTSUPP;
4449
4450 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
4451 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_GO)
4452 return -EOPNOTSUPP;
4453
4454 return rdev_change_bss(rdev, dev, &params);
4455 }
4456
4457 static const struct nla_policy reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
4458 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
4459 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
4460 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
4461 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
4462 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
4463 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
4464 };
4465
4466 static int parse_reg_rule(struct nlattr *tb[],
4467 struct ieee80211_reg_rule *reg_rule)
4468 {
4469 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
4470 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
4471
4472 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
4473 return -EINVAL;
4474 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
4475 return -EINVAL;
4476 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
4477 return -EINVAL;
4478 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
4479 return -EINVAL;
4480 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
4481 return -EINVAL;
4482
4483 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
4484
4485 freq_range->start_freq_khz =
4486 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
4487 freq_range->end_freq_khz =
4488 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
4489 freq_range->max_bandwidth_khz =
4490 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
4491
4492 power_rule->max_eirp =
4493 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
4494
4495 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
4496 power_rule->max_antenna_gain =
4497 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
4498
4499 return 0;
4500 }
4501
4502 static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
4503 {
4504 int r;
4505 char *data = NULL;
4506 enum nl80211_user_reg_hint_type user_reg_hint_type;
4507
4508 /*
4509 * You should only get this when cfg80211 hasn't yet initialized
4510 * completely when built-in to the kernel right between the time
4511 * window between nl80211_init() and regulatory_init(), if that is
4512 * even possible.
4513 */
4514 if (unlikely(!rcu_access_pointer(cfg80211_regdomain)))
4515 return -EINPROGRESS;
4516
4517 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
4518 return -EINVAL;
4519
4520 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
4521
4522 if (info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE])
4523 user_reg_hint_type =
4524 nla_get_u32(info->attrs[NL80211_ATTR_USER_REG_HINT_TYPE]);
4525 else
4526 user_reg_hint_type = NL80211_USER_REG_HINT_USER;
4527
4528 switch (user_reg_hint_type) {
4529 case NL80211_USER_REG_HINT_USER:
4530 case NL80211_USER_REG_HINT_CELL_BASE:
4531 break;
4532 default:
4533 return -EINVAL;
4534 }
4535
4536 r = regulatory_hint_user(data, user_reg_hint_type);
4537
4538 return r;
4539 }
4540
4541 static int nl80211_get_mesh_config(struct sk_buff *skb,
4542 struct genl_info *info)
4543 {
4544 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4545 struct net_device *dev = info->user_ptr[1];
4546 struct wireless_dev *wdev = dev->ieee80211_ptr;
4547 struct mesh_config cur_params;
4548 int err = 0;
4549 void *hdr;
4550 struct nlattr *pinfoattr;
4551 struct sk_buff *msg;
4552
4553 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4554 return -EOPNOTSUPP;
4555
4556 if (!rdev->ops->get_mesh_config)
4557 return -EOPNOTSUPP;
4558
4559 wdev_lock(wdev);
4560 /* If not connected, get default parameters */
4561 if (!wdev->mesh_id_len)
4562 memcpy(&cur_params, &default_mesh_config, sizeof(cur_params));
4563 else
4564 err = rdev_get_mesh_config(rdev, dev, &cur_params);
4565 wdev_unlock(wdev);
4566
4567 if (err)
4568 return err;
4569
4570 /* Draw up a netlink message to send back */
4571 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4572 if (!msg)
4573 return -ENOMEM;
4574 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4575 NL80211_CMD_GET_MESH_CONFIG);
4576 if (!hdr)
4577 goto out;
4578 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_CONFIG);
4579 if (!pinfoattr)
4580 goto nla_put_failure;
4581 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
4582 nla_put_u16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
4583 cur_params.dot11MeshRetryTimeout) ||
4584 nla_put_u16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4585 cur_params.dot11MeshConfirmTimeout) ||
4586 nla_put_u16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
4587 cur_params.dot11MeshHoldingTimeout) ||
4588 nla_put_u16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
4589 cur_params.dot11MeshMaxPeerLinks) ||
4590 nla_put_u8(msg, NL80211_MESHCONF_MAX_RETRIES,
4591 cur_params.dot11MeshMaxRetries) ||
4592 nla_put_u8(msg, NL80211_MESHCONF_TTL,
4593 cur_params.dot11MeshTTL) ||
4594 nla_put_u8(msg, NL80211_MESHCONF_ELEMENT_TTL,
4595 cur_params.element_ttl) ||
4596 nla_put_u8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4597 cur_params.auto_open_plinks) ||
4598 nla_put_u32(msg, NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4599 cur_params.dot11MeshNbrOffsetMaxNeighbor) ||
4600 nla_put_u8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4601 cur_params.dot11MeshHWMPmaxPREQretries) ||
4602 nla_put_u32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
4603 cur_params.path_refresh_time) ||
4604 nla_put_u16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4605 cur_params.min_discovery_timeout) ||
4606 nla_put_u32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4607 cur_params.dot11MeshHWMPactivePathTimeout) ||
4608 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4609 cur_params.dot11MeshHWMPpreqMinInterval) ||
4610 nla_put_u16(msg, NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4611 cur_params.dot11MeshHWMPperrMinInterval) ||
4612 nla_put_u16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4613 cur_params.dot11MeshHWMPnetDiameterTraversalTime) ||
4614 nla_put_u8(msg, NL80211_MESHCONF_HWMP_ROOTMODE,
4615 cur_params.dot11MeshHWMPRootMode) ||
4616 nla_put_u16(msg, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4617 cur_params.dot11MeshHWMPRannInterval) ||
4618 nla_put_u8(msg, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4619 cur_params.dot11MeshGateAnnouncementProtocol) ||
4620 nla_put_u8(msg, NL80211_MESHCONF_FORWARDING,
4621 cur_params.dot11MeshForwarding) ||
4622 nla_put_u32(msg, NL80211_MESHCONF_RSSI_THRESHOLD,
4623 cur_params.rssi_threshold) ||
4624 nla_put_u32(msg, NL80211_MESHCONF_HT_OPMODE,
4625 cur_params.ht_opmode) ||
4626 nla_put_u32(msg, NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4627 cur_params.dot11MeshHWMPactivePathToRootTimeout) ||
4628 nla_put_u16(msg, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4629 cur_params.dot11MeshHWMProotInterval) ||
4630 nla_put_u16(msg, NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
4631 cur_params.dot11MeshHWMPconfirmationInterval) ||
4632 nla_put_u32(msg, NL80211_MESHCONF_POWER_MODE,
4633 cur_params.power_mode) ||
4634 nla_put_u16(msg, NL80211_MESHCONF_AWAKE_WINDOW,
4635 cur_params.dot11MeshAwakeWindowDuration))
4636 goto nla_put_failure;
4637 nla_nest_end(msg, pinfoattr);
4638 genlmsg_end(msg, hdr);
4639 return genlmsg_reply(msg, info);
4640
4641 nla_put_failure:
4642 genlmsg_cancel(msg, hdr);
4643 out:
4644 nlmsg_free(msg);
4645 return -ENOBUFS;
4646 }
4647
4648 static const struct nla_policy nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] = {
4649 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
4650 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
4651 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
4652 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
4653 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
4654 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
4655 [NL80211_MESHCONF_ELEMENT_TTL] = { .type = NLA_U8 },
4656 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
4657 [NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR] = { .type = NLA_U32 },
4658 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
4659 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
4660 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
4661 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
4662 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
4663 [NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL] = { .type = NLA_U16 },
4664 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
4665 [NL80211_MESHCONF_HWMP_ROOTMODE] = { .type = NLA_U8 },
4666 [NL80211_MESHCONF_HWMP_RANN_INTERVAL] = { .type = NLA_U16 },
4667 [NL80211_MESHCONF_GATE_ANNOUNCEMENTS] = { .type = NLA_U8 },
4668 [NL80211_MESHCONF_FORWARDING] = { .type = NLA_U8 },
4669 [NL80211_MESHCONF_RSSI_THRESHOLD] = { .type = NLA_U32 },
4670 [NL80211_MESHCONF_HT_OPMODE] = { .type = NLA_U16 },
4671 [NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT] = { .type = NLA_U32 },
4672 [NL80211_MESHCONF_HWMP_ROOT_INTERVAL] = { .type = NLA_U16 },
4673 [NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL] = { .type = NLA_U16 },
4674 [NL80211_MESHCONF_POWER_MODE] = { .type = NLA_U32 },
4675 [NL80211_MESHCONF_AWAKE_WINDOW] = { .type = NLA_U16 },
4676 };
4677
4678 static const struct nla_policy
4679 nl80211_mesh_setup_params_policy[NL80211_MESH_SETUP_ATTR_MAX+1] = {
4680 [NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC] = { .type = NLA_U8 },
4681 [NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL] = { .type = NLA_U8 },
4682 [NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC] = { .type = NLA_U8 },
4683 [NL80211_MESH_SETUP_USERSPACE_AUTH] = { .type = NLA_FLAG },
4684 [NL80211_MESH_SETUP_USERSPACE_MPM] = { .type = NLA_FLAG },
4685 [NL80211_MESH_SETUP_IE] = { .type = NLA_BINARY,
4686 .len = IEEE80211_MAX_DATA_LEN },
4687 [NL80211_MESH_SETUP_USERSPACE_AMPE] = { .type = NLA_FLAG },
4688 };
4689
4690 static int nl80211_parse_mesh_config(struct genl_info *info,
4691 struct mesh_config *cfg,
4692 u32 *mask_out)
4693 {
4694 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
4695 u32 mask = 0;
4696
4697 #define FILL_IN_MESH_PARAM_IF_SET(tb, cfg, param, min, max, mask, attr, fn) \
4698 do { \
4699 if (tb[attr]) { \
4700 if (fn(tb[attr]) < min || fn(tb[attr]) > max) \
4701 return -EINVAL; \
4702 cfg->param = fn(tb[attr]); \
4703 mask |= (1 << (attr - 1)); \
4704 } \
4705 } while (0)
4706
4707
4708 if (!info->attrs[NL80211_ATTR_MESH_CONFIG])
4709 return -EINVAL;
4710 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
4711 info->attrs[NL80211_ATTR_MESH_CONFIG],
4712 nl80211_meshconf_params_policy))
4713 return -EINVAL;
4714
4715 /* This makes sure that there aren't more than 32 mesh config
4716 * parameters (otherwise our bitfield scheme would not work.) */
4717 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
4718
4719 /* Fill in the params struct */
4720 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout, 1, 255,
4721 mask, NL80211_MESHCONF_RETRY_TIMEOUT,
4722 nla_get_u16);
4723 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout, 1, 255,
4724 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT,
4725 nla_get_u16);
4726 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout, 1, 255,
4727 mask, NL80211_MESHCONF_HOLDING_TIMEOUT,
4728 nla_get_u16);
4729 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks, 0, 255,
4730 mask, NL80211_MESHCONF_MAX_PEER_LINKS,
4731 nla_get_u16);
4732 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries, 0, 16,
4733 mask, NL80211_MESHCONF_MAX_RETRIES,
4734 nla_get_u8);
4735 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL, 1, 255,
4736 mask, NL80211_MESHCONF_TTL, nla_get_u8);
4737 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, element_ttl, 1, 255,
4738 mask, NL80211_MESHCONF_ELEMENT_TTL,
4739 nla_get_u8);
4740 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks, 0, 1,
4741 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
4742 nla_get_u8);
4743 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshNbrOffsetMaxNeighbor,
4744 1, 255, mask,
4745 NL80211_MESHCONF_SYNC_OFFSET_MAX_NEIGHBOR,
4746 nla_get_u32);
4747 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries, 0, 255,
4748 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
4749 nla_get_u8);
4750 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time, 1, 65535,
4751 mask, NL80211_MESHCONF_PATH_REFRESH_TIME,
4752 nla_get_u32);
4753 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout, 1, 65535,
4754 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
4755 nla_get_u16);
4756 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
4757 1, 65535, mask,
4758 NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
4759 nla_get_u32);
4760 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
4761 1, 65535, mask,
4762 NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
4763 nla_get_u16);
4764 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPperrMinInterval,
4765 1, 65535, mask,
4766 NL80211_MESHCONF_HWMP_PERR_MIN_INTERVAL,
4767 nla_get_u16);
4768 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4769 dot11MeshHWMPnetDiameterTraversalTime,
4770 1, 65535, mask,
4771 NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
4772 nla_get_u16);
4773 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRootMode, 0, 4,
4774 mask, NL80211_MESHCONF_HWMP_ROOTMODE,
4775 nla_get_u8);
4776 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPRannInterval, 1, 65535,
4777 mask, NL80211_MESHCONF_HWMP_RANN_INTERVAL,
4778 nla_get_u16);
4779 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4780 dot11MeshGateAnnouncementProtocol, 0, 1,
4781 mask, NL80211_MESHCONF_GATE_ANNOUNCEMENTS,
4782 nla_get_u8);
4783 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshForwarding, 0, 1,
4784 mask, NL80211_MESHCONF_FORWARDING,
4785 nla_get_u8);
4786 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, rssi_threshold, 1, 255,
4787 mask, NL80211_MESHCONF_RSSI_THRESHOLD,
4788 nla_get_u32);
4789 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, ht_opmode, 0, 16,
4790 mask, NL80211_MESHCONF_HT_OPMODE,
4791 nla_get_u16);
4792 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathToRootTimeout,
4793 1, 65535, mask,
4794 NL80211_MESHCONF_HWMP_PATH_TO_ROOT_TIMEOUT,
4795 nla_get_u32);
4796 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMProotInterval, 1, 65535,
4797 mask, NL80211_MESHCONF_HWMP_ROOT_INTERVAL,
4798 nla_get_u16);
4799 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
4800 dot11MeshHWMPconfirmationInterval,
4801 1, 65535, mask,
4802 NL80211_MESHCONF_HWMP_CONFIRMATION_INTERVAL,
4803 nla_get_u16);
4804 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, power_mode,
4805 NL80211_MESH_POWER_ACTIVE,
4806 NL80211_MESH_POWER_MAX,
4807 mask, NL80211_MESHCONF_POWER_MODE,
4808 nla_get_u32);
4809 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshAwakeWindowDuration,
4810 0, 65535, mask,
4811 NL80211_MESHCONF_AWAKE_WINDOW, nla_get_u16);
4812 if (mask_out)
4813 *mask_out = mask;
4814
4815 return 0;
4816
4817 #undef FILL_IN_MESH_PARAM_IF_SET
4818 }
4819
4820 static int nl80211_parse_mesh_setup(struct genl_info *info,
4821 struct mesh_setup *setup)
4822 {
4823 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4824 struct nlattr *tb[NL80211_MESH_SETUP_ATTR_MAX + 1];
4825
4826 if (!info->attrs[NL80211_ATTR_MESH_SETUP])
4827 return -EINVAL;
4828 if (nla_parse_nested(tb, NL80211_MESH_SETUP_ATTR_MAX,
4829 info->attrs[NL80211_ATTR_MESH_SETUP],
4830 nl80211_mesh_setup_params_policy))
4831 return -EINVAL;
4832
4833 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])
4834 setup->sync_method =
4835 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_SYNC])) ?
4836 IEEE80211_SYNC_METHOD_VENDOR :
4837 IEEE80211_SYNC_METHOD_NEIGHBOR_OFFSET;
4838
4839 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])
4840 setup->path_sel_proto =
4841 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_PATH_SEL])) ?
4842 IEEE80211_PATH_PROTOCOL_VENDOR :
4843 IEEE80211_PATH_PROTOCOL_HWMP;
4844
4845 if (tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])
4846 setup->path_metric =
4847 (nla_get_u8(tb[NL80211_MESH_SETUP_ENABLE_VENDOR_METRIC])) ?
4848 IEEE80211_PATH_METRIC_VENDOR :
4849 IEEE80211_PATH_METRIC_AIRTIME;
4850
4851
4852 if (tb[NL80211_MESH_SETUP_IE]) {
4853 struct nlattr *ieattr =
4854 tb[NL80211_MESH_SETUP_IE];
4855 if (!is_valid_ie_attr(ieattr))
4856 return -EINVAL;
4857 setup->ie = nla_data(ieattr);
4858 setup->ie_len = nla_len(ieattr);
4859 }
4860 if (tb[NL80211_MESH_SETUP_USERSPACE_MPM] &&
4861 !(rdev->wiphy.features & NL80211_FEATURE_USERSPACE_MPM))
4862 return -EINVAL;
4863 setup->user_mpm = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_MPM]);
4864 setup->is_authenticated = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AUTH]);
4865 setup->is_secure = nla_get_flag(tb[NL80211_MESH_SETUP_USERSPACE_AMPE]);
4866 if (setup->is_secure)
4867 setup->user_mpm = true;
4868
4869 return 0;
4870 }
4871
4872 static int nl80211_update_mesh_config(struct sk_buff *skb,
4873 struct genl_info *info)
4874 {
4875 struct cfg80211_registered_device *rdev = info->user_ptr[0];
4876 struct net_device *dev = info->user_ptr[1];
4877 struct wireless_dev *wdev = dev->ieee80211_ptr;
4878 struct mesh_config cfg;
4879 u32 mask;
4880 int err;
4881
4882 if (wdev->iftype != NL80211_IFTYPE_MESH_POINT)
4883 return -EOPNOTSUPP;
4884
4885 if (!rdev->ops->update_mesh_config)
4886 return -EOPNOTSUPP;
4887
4888 err = nl80211_parse_mesh_config(info, &cfg, &mask);
4889 if (err)
4890 return err;
4891
4892 wdev_lock(wdev);
4893 if (!wdev->mesh_id_len)
4894 err = -ENOLINK;
4895
4896 if (!err)
4897 err = rdev_update_mesh_config(rdev, dev, mask, &cfg);
4898
4899 wdev_unlock(wdev);
4900
4901 return err;
4902 }
4903
4904 static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
4905 {
4906 const struct ieee80211_regdomain *regdom;
4907 struct sk_buff *msg;
4908 void *hdr = NULL;
4909 struct nlattr *nl_reg_rules;
4910 unsigned int i;
4911 int err = -EINVAL;
4912
4913 mutex_lock(&cfg80211_mutex);
4914
4915 if (!cfg80211_regdomain)
4916 goto out;
4917
4918 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
4919 if (!msg) {
4920 err = -ENOBUFS;
4921 goto out;
4922 }
4923
4924 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
4925 NL80211_CMD_GET_REG);
4926 if (!hdr)
4927 goto put_failure;
4928
4929 if (reg_last_request_cell_base() &&
4930 nla_put_u32(msg, NL80211_ATTR_USER_REG_HINT_TYPE,
4931 NL80211_USER_REG_HINT_CELL_BASE))
4932 goto nla_put_failure;
4933
4934 rcu_read_lock();
4935 regdom = rcu_dereference(cfg80211_regdomain);
4936
4937 if (nla_put_string(msg, NL80211_ATTR_REG_ALPHA2, regdom->alpha2) ||
4938 (regdom->dfs_region &&
4939 nla_put_u8(msg, NL80211_ATTR_DFS_REGION, regdom->dfs_region)))
4940 goto nla_put_failure_rcu;
4941
4942 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
4943 if (!nl_reg_rules)
4944 goto nla_put_failure_rcu;
4945
4946 for (i = 0; i < regdom->n_reg_rules; i++) {
4947 struct nlattr *nl_reg_rule;
4948 const struct ieee80211_reg_rule *reg_rule;
4949 const struct ieee80211_freq_range *freq_range;
4950 const struct ieee80211_power_rule *power_rule;
4951
4952 reg_rule = &regdom->reg_rules[i];
4953 freq_range = &reg_rule->freq_range;
4954 power_rule = &reg_rule->power_rule;
4955
4956 nl_reg_rule = nla_nest_start(msg, i);
4957 if (!nl_reg_rule)
4958 goto nla_put_failure_rcu;
4959
4960 if (nla_put_u32(msg, NL80211_ATTR_REG_RULE_FLAGS,
4961 reg_rule->flags) ||
4962 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_START,
4963 freq_range->start_freq_khz) ||
4964 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_END,
4965 freq_range->end_freq_khz) ||
4966 nla_put_u32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
4967 freq_range->max_bandwidth_khz) ||
4968 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
4969 power_rule->max_antenna_gain) ||
4970 nla_put_u32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
4971 power_rule->max_eirp))
4972 goto nla_put_failure_rcu;
4973
4974 nla_nest_end(msg, nl_reg_rule);
4975 }
4976 rcu_read_unlock();
4977
4978 nla_nest_end(msg, nl_reg_rules);
4979
4980 genlmsg_end(msg, hdr);
4981 err = genlmsg_reply(msg, info);
4982 goto out;
4983
4984 nla_put_failure_rcu:
4985 rcu_read_unlock();
4986 nla_put_failure:
4987 genlmsg_cancel(msg, hdr);
4988 put_failure:
4989 nlmsg_free(msg);
4990 err = -EMSGSIZE;
4991 out:
4992 mutex_unlock(&cfg80211_mutex);
4993 return err;
4994 }
4995
4996 static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
4997 {
4998 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
4999 struct nlattr *nl_reg_rule;
5000 char *alpha2 = NULL;
5001 int rem_reg_rules = 0, r = 0;
5002 u32 num_rules = 0, rule_idx = 0, size_of_regd;
5003 u8 dfs_region = 0;
5004 struct ieee80211_regdomain *rd = NULL;
5005
5006 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
5007 return -EINVAL;
5008
5009 if (!info->attrs[NL80211_ATTR_REG_RULES])
5010 return -EINVAL;
5011
5012 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
5013
5014 if (info->attrs[NL80211_ATTR_DFS_REGION])
5015 dfs_region = nla_get_u8(info->attrs[NL80211_ATTR_DFS_REGION]);
5016
5017 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
5018 rem_reg_rules) {
5019 num_rules++;
5020 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
5021 return -EINVAL;
5022 }
5023
5024 size_of_regd = sizeof(struct ieee80211_regdomain) +
5025 num_rules * sizeof(struct ieee80211_reg_rule);
5026
5027 rd = kzalloc(size_of_regd, GFP_KERNEL);
5028 if (!rd)
5029 return -ENOMEM;
5030
5031 rd->n_reg_rules = num_rules;
5032 rd->alpha2[0] = alpha2[0];
5033 rd->alpha2[1] = alpha2[1];
5034
5035 /*
5036 * Disable DFS master mode if the DFS region was
5037 * not supported or known on this kernel.
5038 */
5039 if (reg_supported_dfs_region(dfs_region))
5040 rd->dfs_region = dfs_region;
5041
5042 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
5043 rem_reg_rules) {
5044 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
5045 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
5046 reg_rule_policy);
5047 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
5048 if (r)
5049 goto bad_reg;
5050
5051 rule_idx++;
5052
5053 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
5054 r = -EINVAL;
5055 goto bad_reg;
5056 }
5057 }
5058
5059 mutex_lock(&cfg80211_mutex);
5060
5061 r = set_regdom(rd);
5062 /* set_regdom took ownership */
5063 rd = NULL;
5064 mutex_unlock(&cfg80211_mutex);
5065
5066 bad_reg:
5067 kfree(rd);
5068 return r;
5069 }
5070
5071 static int validate_scan_freqs(struct nlattr *freqs)
5072 {
5073 struct nlattr *attr1, *attr2;
5074 int n_channels = 0, tmp1, tmp2;
5075
5076 nla_for_each_nested(attr1, freqs, tmp1) {
5077 n_channels++;
5078 /*
5079 * Some hardware has a limited channel list for
5080 * scanning, and it is pretty much nonsensical
5081 * to scan for a channel twice, so disallow that
5082 * and don't require drivers to check that the
5083 * channel list they get isn't longer than what
5084 * they can scan, as long as they can scan all
5085 * the channels they registered at once.
5086 */
5087 nla_for_each_nested(attr2, freqs, tmp2)
5088 if (attr1 != attr2 &&
5089 nla_get_u32(attr1) == nla_get_u32(attr2))
5090 return 0;
5091 }
5092
5093 return n_channels;
5094 }
5095
5096 static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
5097 {
5098 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5099 struct wireless_dev *wdev = info->user_ptr[1];
5100 struct cfg80211_scan_request *request;
5101 struct nlattr *attr;
5102 struct wiphy *wiphy;
5103 int err, tmp, n_ssids = 0, n_channels, i;
5104 size_t ie_len;
5105
5106 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5107 return -EINVAL;
5108
5109 wiphy = &rdev->wiphy;
5110
5111 if (!rdev->ops->scan)
5112 return -EOPNOTSUPP;
5113
5114 mutex_lock(&rdev->sched_scan_mtx);
5115 if (rdev->scan_req) {
5116 err = -EBUSY;
5117 goto unlock;
5118 }
5119
5120 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5121 n_channels = validate_scan_freqs(
5122 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5123 if (!n_channels) {
5124 err = -EINVAL;
5125 goto unlock;
5126 }
5127 } else {
5128 enum ieee80211_band band;
5129 n_channels = 0;
5130
5131 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
5132 if (wiphy->bands[band])
5133 n_channels += wiphy->bands[band]->n_channels;
5134 }
5135
5136 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5137 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
5138 n_ssids++;
5139
5140 if (n_ssids > wiphy->max_scan_ssids) {
5141 err = -EINVAL;
5142 goto unlock;
5143 }
5144
5145 if (info->attrs[NL80211_ATTR_IE])
5146 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5147 else
5148 ie_len = 0;
5149
5150 if (ie_len > wiphy->max_scan_ie_len) {
5151 err = -EINVAL;
5152 goto unlock;
5153 }
5154
5155 request = kzalloc(sizeof(*request)
5156 + sizeof(*request->ssids) * n_ssids
5157 + sizeof(*request->channels) * n_channels
5158 + ie_len, GFP_KERNEL);
5159 if (!request) {
5160 err = -ENOMEM;
5161 goto unlock;
5162 }
5163
5164 if (n_ssids)
5165 request->ssids = (void *)&request->channels[n_channels];
5166 request->n_ssids = n_ssids;
5167 if (ie_len) {
5168 if (request->ssids)
5169 request->ie = (void *)(request->ssids + n_ssids);
5170 else
5171 request->ie = (void *)(request->channels + n_channels);
5172 }
5173
5174 i = 0;
5175 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5176 /* user specified, bail out if channel not found */
5177 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
5178 struct ieee80211_channel *chan;
5179
5180 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5181
5182 if (!chan) {
5183 err = -EINVAL;
5184 goto out_free;
5185 }
5186
5187 /* ignore disabled channels */
5188 if (chan->flags & IEEE80211_CHAN_DISABLED)
5189 continue;
5190
5191 request->channels[i] = chan;
5192 i++;
5193 }
5194 } else {
5195 enum ieee80211_band band;
5196
5197 /* all channels */
5198 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5199 int j;
5200 if (!wiphy->bands[band])
5201 continue;
5202 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5203 struct ieee80211_channel *chan;
5204
5205 chan = &wiphy->bands[band]->channels[j];
5206
5207 if (chan->flags & IEEE80211_CHAN_DISABLED)
5208 continue;
5209
5210 request->channels[i] = chan;
5211 i++;
5212 }
5213 }
5214 }
5215
5216 if (!i) {
5217 err = -EINVAL;
5218 goto out_free;
5219 }
5220
5221 request->n_channels = i;
5222
5223 i = 0;
5224 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5225 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
5226 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5227 err = -EINVAL;
5228 goto out_free;
5229 }
5230 request->ssids[i].ssid_len = nla_len(attr);
5231 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
5232 i++;
5233 }
5234 }
5235
5236 if (info->attrs[NL80211_ATTR_IE]) {
5237 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5238 memcpy((void *)request->ie,
5239 nla_data(info->attrs[NL80211_ATTR_IE]),
5240 request->ie_len);
5241 }
5242
5243 for (i = 0; i < IEEE80211_NUM_BANDS; i++)
5244 if (wiphy->bands[i])
5245 request->rates[i] =
5246 (1 << wiphy->bands[i]->n_bitrates) - 1;
5247
5248 if (info->attrs[NL80211_ATTR_SCAN_SUPP_RATES]) {
5249 nla_for_each_nested(attr,
5250 info->attrs[NL80211_ATTR_SCAN_SUPP_RATES],
5251 tmp) {
5252 enum ieee80211_band band = nla_type(attr);
5253
5254 if (band < 0 || band >= IEEE80211_NUM_BANDS) {
5255 err = -EINVAL;
5256 goto out_free;
5257 }
5258 err = ieee80211_get_ratemask(wiphy->bands[band],
5259 nla_data(attr),
5260 nla_len(attr),
5261 &request->rates[band]);
5262 if (err)
5263 goto out_free;
5264 }
5265 }
5266
5267 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5268 request->flags = nla_get_u32(
5269 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5270 if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5271 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
5272 ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
5273 !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
5274 err = -EOPNOTSUPP;
5275 goto out_free;
5276 }
5277 }
5278
5279 request->no_cck =
5280 nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
5281
5282 request->wdev = wdev;
5283 request->wiphy = &rdev->wiphy;
5284 request->scan_start = jiffies;
5285
5286 rdev->scan_req = request;
5287 err = rdev_scan(rdev, request);
5288
5289 if (!err) {
5290 nl80211_send_scan_start(rdev, wdev);
5291 if (wdev->netdev)
5292 dev_hold(wdev->netdev);
5293 } else {
5294 out_free:
5295 rdev->scan_req = NULL;
5296 kfree(request);
5297 }
5298
5299 unlock:
5300 mutex_unlock(&rdev->sched_scan_mtx);
5301 return err;
5302 }
5303
5304 static int nl80211_start_sched_scan(struct sk_buff *skb,
5305 struct genl_info *info)
5306 {
5307 struct cfg80211_sched_scan_request *request;
5308 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5309 struct net_device *dev = info->user_ptr[1];
5310 struct nlattr *attr;
5311 struct wiphy *wiphy;
5312 int err, tmp, n_ssids = 0, n_match_sets = 0, n_channels, i;
5313 u32 interval;
5314 enum ieee80211_band band;
5315 size_t ie_len;
5316 struct nlattr *tb[NL80211_SCHED_SCAN_MATCH_ATTR_MAX + 1];
5317
5318 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5319 !rdev->ops->sched_scan_start)
5320 return -EOPNOTSUPP;
5321
5322 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5323 return -EINVAL;
5324
5325 if (!info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL])
5326 return -EINVAL;
5327
5328 interval = nla_get_u32(info->attrs[NL80211_ATTR_SCHED_SCAN_INTERVAL]);
5329 if (interval == 0)
5330 return -EINVAL;
5331
5332 wiphy = &rdev->wiphy;
5333
5334 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5335 n_channels = validate_scan_freqs(
5336 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
5337 if (!n_channels)
5338 return -EINVAL;
5339 } else {
5340 n_channels = 0;
5341
5342 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
5343 if (wiphy->bands[band])
5344 n_channels += wiphy->bands[band]->n_channels;
5345 }
5346
5347 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
5348 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5349 tmp)
5350 n_ssids++;
5351
5352 if (n_ssids > wiphy->max_sched_scan_ssids)
5353 return -EINVAL;
5354
5355 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH])
5356 nla_for_each_nested(attr,
5357 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5358 tmp)
5359 n_match_sets++;
5360
5361 if (n_match_sets > wiphy->max_match_sets)
5362 return -EINVAL;
5363
5364 if (info->attrs[NL80211_ATTR_IE])
5365 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5366 else
5367 ie_len = 0;
5368
5369 if (ie_len > wiphy->max_sched_scan_ie_len)
5370 return -EINVAL;
5371
5372 mutex_lock(&rdev->sched_scan_mtx);
5373
5374 if (rdev->sched_scan_req) {
5375 err = -EINPROGRESS;
5376 goto out;
5377 }
5378
5379 request = kzalloc(sizeof(*request)
5380 + sizeof(*request->ssids) * n_ssids
5381 + sizeof(*request->match_sets) * n_match_sets
5382 + sizeof(*request->channels) * n_channels
5383 + ie_len, GFP_KERNEL);
5384 if (!request) {
5385 err = -ENOMEM;
5386 goto out;
5387 }
5388
5389 if (n_ssids)
5390 request->ssids = (void *)&request->channels[n_channels];
5391 request->n_ssids = n_ssids;
5392 if (ie_len) {
5393 if (request->ssids)
5394 request->ie = (void *)(request->ssids + n_ssids);
5395 else
5396 request->ie = (void *)(request->channels + n_channels);
5397 }
5398
5399 if (n_match_sets) {
5400 if (request->ie)
5401 request->match_sets = (void *)(request->ie + ie_len);
5402 else if (request->ssids)
5403 request->match_sets =
5404 (void *)(request->ssids + n_ssids);
5405 else
5406 request->match_sets =
5407 (void *)(request->channels + n_channels);
5408 }
5409 request->n_match_sets = n_match_sets;
5410
5411 i = 0;
5412 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
5413 /* user specified, bail out if channel not found */
5414 nla_for_each_nested(attr,
5415 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES],
5416 tmp) {
5417 struct ieee80211_channel *chan;
5418
5419 chan = ieee80211_get_channel(wiphy, nla_get_u32(attr));
5420
5421 if (!chan) {
5422 err = -EINVAL;
5423 goto out_free;
5424 }
5425
5426 /* ignore disabled channels */
5427 if (chan->flags & IEEE80211_CHAN_DISABLED)
5428 continue;
5429
5430 request->channels[i] = chan;
5431 i++;
5432 }
5433 } else {
5434 /* all channels */
5435 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
5436 int j;
5437 if (!wiphy->bands[band])
5438 continue;
5439 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
5440 struct ieee80211_channel *chan;
5441
5442 chan = &wiphy->bands[band]->channels[j];
5443
5444 if (chan->flags & IEEE80211_CHAN_DISABLED)
5445 continue;
5446
5447 request->channels[i] = chan;
5448 i++;
5449 }
5450 }
5451 }
5452
5453 if (!i) {
5454 err = -EINVAL;
5455 goto out_free;
5456 }
5457
5458 request->n_channels = i;
5459
5460 i = 0;
5461 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
5462 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS],
5463 tmp) {
5464 if (nla_len(attr) > IEEE80211_MAX_SSID_LEN) {
5465 err = -EINVAL;
5466 goto out_free;
5467 }
5468 request->ssids[i].ssid_len = nla_len(attr);
5469 memcpy(request->ssids[i].ssid, nla_data(attr),
5470 nla_len(attr));
5471 i++;
5472 }
5473 }
5474
5475 i = 0;
5476 if (info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH]) {
5477 nla_for_each_nested(attr,
5478 info->attrs[NL80211_ATTR_SCHED_SCAN_MATCH],
5479 tmp) {
5480 struct nlattr *ssid, *rssi;
5481
5482 nla_parse(tb, NL80211_SCHED_SCAN_MATCH_ATTR_MAX,
5483 nla_data(attr), nla_len(attr),
5484 nl80211_match_policy);
5485 ssid = tb[NL80211_SCHED_SCAN_MATCH_ATTR_SSID];
5486 if (ssid) {
5487 if (nla_len(ssid) > IEEE80211_MAX_SSID_LEN) {
5488 err = -EINVAL;
5489 goto out_free;
5490 }
5491 memcpy(request->match_sets[i].ssid.ssid,
5492 nla_data(ssid), nla_len(ssid));
5493 request->match_sets[i].ssid.ssid_len =
5494 nla_len(ssid);
5495 }
5496 rssi = tb[NL80211_SCHED_SCAN_MATCH_ATTR_RSSI];
5497 if (rssi)
5498 request->rssi_thold = nla_get_u32(rssi);
5499 else
5500 request->rssi_thold =
5501 NL80211_SCAN_RSSI_THOLD_OFF;
5502 i++;
5503 }
5504 }
5505
5506 if (info->attrs[NL80211_ATTR_IE]) {
5507 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5508 memcpy((void *)request->ie,
5509 nla_data(info->attrs[NL80211_ATTR_IE]),
5510 request->ie_len);
5511 }
5512
5513 if (info->attrs[NL80211_ATTR_SCAN_FLAGS]) {
5514 request->flags = nla_get_u32(
5515 info->attrs[NL80211_ATTR_SCAN_FLAGS]);
5516 if (((request->flags & NL80211_SCAN_FLAG_LOW_PRIORITY) &&
5517 !(wiphy->features & NL80211_FEATURE_LOW_PRIORITY_SCAN)) ||
5518 ((request->flags & NL80211_SCAN_FLAG_FLUSH) &&
5519 !(wiphy->features & NL80211_FEATURE_SCAN_FLUSH))) {
5520 err = -EOPNOTSUPP;
5521 goto out_free;
5522 }
5523 }
5524
5525 request->dev = dev;
5526 request->wiphy = &rdev->wiphy;
5527 request->interval = interval;
5528 request->scan_start = jiffies;
5529
5530 err = rdev_sched_scan_start(rdev, dev, request);
5531 if (!err) {
5532 rdev->sched_scan_req = request;
5533 nl80211_send_sched_scan(rdev, dev,
5534 NL80211_CMD_START_SCHED_SCAN);
5535 goto out;
5536 }
5537
5538 out_free:
5539 kfree(request);
5540 out:
5541 mutex_unlock(&rdev->sched_scan_mtx);
5542 return err;
5543 }
5544
5545 static int nl80211_stop_sched_scan(struct sk_buff *skb,
5546 struct genl_info *info)
5547 {
5548 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5549 int err;
5550
5551 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_SCHED_SCAN) ||
5552 !rdev->ops->sched_scan_stop)
5553 return -EOPNOTSUPP;
5554
5555 mutex_lock(&rdev->sched_scan_mtx);
5556 err = __cfg80211_stop_sched_scan(rdev, false);
5557 mutex_unlock(&rdev->sched_scan_mtx);
5558
5559 return err;
5560 }
5561
5562 static int nl80211_start_radar_detection(struct sk_buff *skb,
5563 struct genl_info *info)
5564 {
5565 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5566 struct net_device *dev = info->user_ptr[1];
5567 struct wireless_dev *wdev = dev->ieee80211_ptr;
5568 struct cfg80211_chan_def chandef;
5569 int err;
5570
5571 err = nl80211_parse_chandef(rdev, info, &chandef);
5572 if (err)
5573 return err;
5574
5575 if (wdev->cac_started)
5576 return -EBUSY;
5577
5578 err = cfg80211_chandef_dfs_required(wdev->wiphy, &chandef);
5579 if (err < 0)
5580 return err;
5581
5582 if (err == 0)
5583 return -EINVAL;
5584
5585 if (chandef.chan->dfs_state != NL80211_DFS_USABLE)
5586 return -EINVAL;
5587
5588 if (!rdev->ops->start_radar_detection)
5589 return -EOPNOTSUPP;
5590
5591 mutex_lock(&rdev->devlist_mtx);
5592 err = cfg80211_can_use_iftype_chan(rdev, wdev, wdev->iftype,
5593 chandef.chan, CHAN_MODE_SHARED,
5594 BIT(chandef.width));
5595 if (err)
5596 goto err_locked;
5597
5598 err = rdev->ops->start_radar_detection(&rdev->wiphy, dev, &chandef);
5599 if (!err) {
5600 wdev->channel = chandef.chan;
5601 wdev->cac_started = true;
5602 wdev->cac_start_time = jiffies;
5603 }
5604 err_locked:
5605 mutex_unlock(&rdev->devlist_mtx);
5606
5607 return err;
5608 }
5609
5610 static int nl80211_send_bss(struct sk_buff *msg, struct netlink_callback *cb,
5611 u32 seq, int flags,
5612 struct cfg80211_registered_device *rdev,
5613 struct wireless_dev *wdev,
5614 struct cfg80211_internal_bss *intbss)
5615 {
5616 struct cfg80211_bss *res = &intbss->pub;
5617 const struct cfg80211_bss_ies *ies;
5618 void *hdr;
5619 struct nlattr *bss;
5620 bool tsf = false;
5621
5622 ASSERT_WDEV_LOCK(wdev);
5623
5624 hdr = nl80211hdr_put(msg, NETLINK_CB(cb->skb).portid, seq, flags,
5625 NL80211_CMD_NEW_SCAN_RESULTS);
5626 if (!hdr)
5627 return -1;
5628
5629 genl_dump_check_consistent(cb, hdr, &nl80211_fam);
5630
5631 if (nla_put_u32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation))
5632 goto nla_put_failure;
5633 if (wdev->netdev &&
5634 nla_put_u32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex))
5635 goto nla_put_failure;
5636 if (nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
5637 goto nla_put_failure;
5638
5639 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
5640 if (!bss)
5641 goto nla_put_failure;
5642 if ((!is_zero_ether_addr(res->bssid) &&
5643 nla_put(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid)))
5644 goto nla_put_failure;
5645
5646 rcu_read_lock();
5647 ies = rcu_dereference(res->ies);
5648 if (ies) {
5649 if (nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
5650 goto fail_unlock_rcu;
5651 tsf = true;
5652 if (ies->len && nla_put(msg, NL80211_BSS_INFORMATION_ELEMENTS,
5653 ies->len, ies->data))
5654 goto fail_unlock_rcu;
5655 }
5656 ies = rcu_dereference(res->beacon_ies);
5657 if (ies) {
5658 if (!tsf && nla_put_u64(msg, NL80211_BSS_TSF, ies->tsf))
5659 goto fail_unlock_rcu;
5660 if (ies->len && nla_put(msg, NL80211_BSS_BEACON_IES,
5661 ies->len, ies->data))
5662 goto fail_unlock_rcu;
5663 }
5664 rcu_read_unlock();
5665
5666 if (res->beacon_interval &&
5667 nla_put_u16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval))
5668 goto nla_put_failure;
5669 if (nla_put_u16(msg, NL80211_BSS_CAPABILITY, res->capability) ||
5670 nla_put_u32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq) ||
5671 nla_put_u32(msg, NL80211_BSS_SEEN_MS_AGO,
5672 jiffies_to_msecs(jiffies - intbss->ts)))
5673 goto nla_put_failure;
5674
5675 switch (rdev->wiphy.signal_type) {
5676 case CFG80211_SIGNAL_TYPE_MBM:
5677 if (nla_put_u32(msg, NL80211_BSS_SIGNAL_MBM, res->signal))
5678 goto nla_put_failure;
5679 break;
5680 case CFG80211_SIGNAL_TYPE_UNSPEC:
5681 if (nla_put_u8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal))
5682 goto nla_put_failure;
5683 break;
5684 default:
5685 break;
5686 }
5687
5688 switch (wdev->iftype) {
5689 case NL80211_IFTYPE_P2P_CLIENT:
5690 case NL80211_IFTYPE_STATION:
5691 if (intbss == wdev->current_bss &&
5692 nla_put_u32(msg, NL80211_BSS_STATUS,
5693 NL80211_BSS_STATUS_ASSOCIATED))
5694 goto nla_put_failure;
5695 break;
5696 case NL80211_IFTYPE_ADHOC:
5697 if (intbss == wdev->current_bss &&
5698 nla_put_u32(msg, NL80211_BSS_STATUS,
5699 NL80211_BSS_STATUS_IBSS_JOINED))
5700 goto nla_put_failure;
5701 break;
5702 default:
5703 break;
5704 }
5705
5706 nla_nest_end(msg, bss);
5707
5708 return genlmsg_end(msg, hdr);
5709
5710 fail_unlock_rcu:
5711 rcu_read_unlock();
5712 nla_put_failure:
5713 genlmsg_cancel(msg, hdr);
5714 return -EMSGSIZE;
5715 }
5716
5717 static int nl80211_dump_scan(struct sk_buff *skb, struct netlink_callback *cb)
5718 {
5719 struct cfg80211_registered_device *rdev;
5720 struct cfg80211_internal_bss *scan;
5721 struct wireless_dev *wdev;
5722 int start = cb->args[2], idx = 0;
5723 int err;
5724
5725 err = nl80211_prepare_wdev_dump(skb, cb, &rdev, &wdev);
5726 if (err)
5727 return err;
5728
5729 wdev_lock(wdev);
5730 spin_lock_bh(&rdev->bss_lock);
5731 cfg80211_bss_expire(rdev);
5732
5733 cb->seq = rdev->bss_generation;
5734
5735 list_for_each_entry(scan, &rdev->bss_list, list) {
5736 if (++idx <= start)
5737 continue;
5738 if (nl80211_send_bss(skb, cb,
5739 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5740 rdev, wdev, scan) < 0) {
5741 idx--;
5742 break;
5743 }
5744 }
5745
5746 spin_unlock_bh(&rdev->bss_lock);
5747 wdev_unlock(wdev);
5748
5749 cb->args[2] = idx;
5750 nl80211_finish_wdev_dump(rdev);
5751
5752 return skb->len;
5753 }
5754
5755 static int nl80211_send_survey(struct sk_buff *msg, u32 portid, u32 seq,
5756 int flags, struct net_device *dev,
5757 struct survey_info *survey)
5758 {
5759 void *hdr;
5760 struct nlattr *infoattr;
5761
5762 hdr = nl80211hdr_put(msg, portid, seq, flags,
5763 NL80211_CMD_NEW_SURVEY_RESULTS);
5764 if (!hdr)
5765 return -ENOMEM;
5766
5767 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
5768 goto nla_put_failure;
5769
5770 infoattr = nla_nest_start(msg, NL80211_ATTR_SURVEY_INFO);
5771 if (!infoattr)
5772 goto nla_put_failure;
5773
5774 if (nla_put_u32(msg, NL80211_SURVEY_INFO_FREQUENCY,
5775 survey->channel->center_freq))
5776 goto nla_put_failure;
5777
5778 if ((survey->filled & SURVEY_INFO_NOISE_DBM) &&
5779 nla_put_u8(msg, NL80211_SURVEY_INFO_NOISE, survey->noise))
5780 goto nla_put_failure;
5781 if ((survey->filled & SURVEY_INFO_IN_USE) &&
5782 nla_put_flag(msg, NL80211_SURVEY_INFO_IN_USE))
5783 goto nla_put_failure;
5784 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME) &&
5785 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME,
5786 survey->channel_time))
5787 goto nla_put_failure;
5788 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_BUSY) &&
5789 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_BUSY,
5790 survey->channel_time_busy))
5791 goto nla_put_failure;
5792 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_EXT_BUSY) &&
5793 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_EXT_BUSY,
5794 survey->channel_time_ext_busy))
5795 goto nla_put_failure;
5796 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_RX) &&
5797 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_RX,
5798 survey->channel_time_rx))
5799 goto nla_put_failure;
5800 if ((survey->filled & SURVEY_INFO_CHANNEL_TIME_TX) &&
5801 nla_put_u64(msg, NL80211_SURVEY_INFO_CHANNEL_TIME_TX,
5802 survey->channel_time_tx))
5803 goto nla_put_failure;
5804
5805 nla_nest_end(msg, infoattr);
5806
5807 return genlmsg_end(msg, hdr);
5808
5809 nla_put_failure:
5810 genlmsg_cancel(msg, hdr);
5811 return -EMSGSIZE;
5812 }
5813
5814 static int nl80211_dump_survey(struct sk_buff *skb,
5815 struct netlink_callback *cb)
5816 {
5817 struct survey_info survey;
5818 struct cfg80211_registered_device *dev;
5819 struct wireless_dev *wdev;
5820 int survey_idx = cb->args[2];
5821 int res;
5822
5823 res = nl80211_prepare_wdev_dump(skb, cb, &dev, &wdev);
5824 if (res)
5825 return res;
5826
5827 if (!wdev->netdev) {
5828 res = -EINVAL;
5829 goto out_err;
5830 }
5831
5832 if (!dev->ops->dump_survey) {
5833 res = -EOPNOTSUPP;
5834 goto out_err;
5835 }
5836
5837 while (1) {
5838 struct ieee80211_channel *chan;
5839
5840 res = rdev_dump_survey(dev, wdev->netdev, survey_idx, &survey);
5841 if (res == -ENOENT)
5842 break;
5843 if (res)
5844 goto out_err;
5845
5846 /* Survey without a channel doesn't make sense */
5847 if (!survey.channel) {
5848 res = -EINVAL;
5849 goto out;
5850 }
5851
5852 chan = ieee80211_get_channel(&dev->wiphy,
5853 survey.channel->center_freq);
5854 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED) {
5855 survey_idx++;
5856 continue;
5857 }
5858
5859 if (nl80211_send_survey(skb,
5860 NETLINK_CB(cb->skb).portid,
5861 cb->nlh->nlmsg_seq, NLM_F_MULTI,
5862 wdev->netdev, &survey) < 0)
5863 goto out;
5864 survey_idx++;
5865 }
5866
5867 out:
5868 cb->args[2] = survey_idx;
5869 res = skb->len;
5870 out_err:
5871 nl80211_finish_wdev_dump(dev);
5872 return res;
5873 }
5874
5875 static bool nl80211_valid_wpa_versions(u32 wpa_versions)
5876 {
5877 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
5878 NL80211_WPA_VERSION_2));
5879 }
5880
5881 static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
5882 {
5883 struct cfg80211_registered_device *rdev = info->user_ptr[0];
5884 struct net_device *dev = info->user_ptr[1];
5885 struct ieee80211_channel *chan;
5886 const u8 *bssid, *ssid, *ie = NULL, *sae_data = NULL;
5887 int err, ssid_len, ie_len = 0, sae_data_len = 0;
5888 enum nl80211_auth_type auth_type;
5889 struct key_parse key;
5890 bool local_state_change;
5891
5892 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
5893 return -EINVAL;
5894
5895 if (!info->attrs[NL80211_ATTR_MAC])
5896 return -EINVAL;
5897
5898 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
5899 return -EINVAL;
5900
5901 if (!info->attrs[NL80211_ATTR_SSID])
5902 return -EINVAL;
5903
5904 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
5905 return -EINVAL;
5906
5907 err = nl80211_parse_key(info, &key);
5908 if (err)
5909 return err;
5910
5911 if (key.idx >= 0) {
5912 if (key.type != -1 && key.type != NL80211_KEYTYPE_GROUP)
5913 return -EINVAL;
5914 if (!key.p.key || !key.p.key_len)
5915 return -EINVAL;
5916 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
5917 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
5918 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
5919 key.p.key_len != WLAN_KEY_LEN_WEP104))
5920 return -EINVAL;
5921 if (key.idx > 4)
5922 return -EINVAL;
5923 } else {
5924 key.p.key_len = 0;
5925 key.p.key = NULL;
5926 }
5927
5928 if (key.idx >= 0) {
5929 int i;
5930 bool ok = false;
5931 for (i = 0; i < rdev->wiphy.n_cipher_suites; i++) {
5932 if (key.p.cipher == rdev->wiphy.cipher_suites[i]) {
5933 ok = true;
5934 break;
5935 }
5936 }
5937 if (!ok)
5938 return -EINVAL;
5939 }
5940
5941 if (!rdev->ops->auth)
5942 return -EOPNOTSUPP;
5943
5944 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
5945 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
5946 return -EOPNOTSUPP;
5947
5948 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
5949 chan = ieee80211_get_channel(&rdev->wiphy,
5950 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
5951 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
5952 return -EINVAL;
5953
5954 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
5955 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
5956
5957 if (info->attrs[NL80211_ATTR_IE]) {
5958 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
5959 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
5960 }
5961
5962 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
5963 if (!nl80211_valid_auth_type(rdev, auth_type, NL80211_CMD_AUTHENTICATE))
5964 return -EINVAL;
5965
5966 if (auth_type == NL80211_AUTHTYPE_SAE &&
5967 !info->attrs[NL80211_ATTR_SAE_DATA])
5968 return -EINVAL;
5969
5970 if (info->attrs[NL80211_ATTR_SAE_DATA]) {
5971 if (auth_type != NL80211_AUTHTYPE_SAE)
5972 return -EINVAL;
5973 sae_data = nla_data(info->attrs[NL80211_ATTR_SAE_DATA]);
5974 sae_data_len = nla_len(info->attrs[NL80211_ATTR_SAE_DATA]);
5975 /* need to include at least Auth Transaction and Status Code */
5976 if (sae_data_len < 4)
5977 return -EINVAL;
5978 }
5979
5980 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
5981
5982 /*
5983 * Since we no longer track auth state, ignore
5984 * requests to only change local state.
5985 */
5986 if (local_state_change)
5987 return 0;
5988
5989 return cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
5990 ssid, ssid_len, ie, ie_len,
5991 key.p.key, key.p.key_len, key.idx,
5992 sae_data, sae_data_len);
5993 }
5994
5995 static int nl80211_crypto_settings(struct cfg80211_registered_device *rdev,
5996 struct genl_info *info,
5997 struct cfg80211_crypto_settings *settings,
5998 int cipher_limit)
5999 {
6000 memset(settings, 0, sizeof(*settings));
6001
6002 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
6003
6004 if (info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]) {
6005 u16 proto;
6006 proto = nla_get_u16(
6007 info->attrs[NL80211_ATTR_CONTROL_PORT_ETHERTYPE]);
6008 settings->control_port_ethertype = cpu_to_be16(proto);
6009 if (!(rdev->wiphy.flags & WIPHY_FLAG_CONTROL_PORT_PROTOCOL) &&
6010 proto != ETH_P_PAE)
6011 return -EINVAL;
6012 if (info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT])
6013 settings->control_port_no_encrypt = true;
6014 } else
6015 settings->control_port_ethertype = cpu_to_be16(ETH_P_PAE);
6016
6017 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
6018 void *data;
6019 int len, i;
6020
6021 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
6022 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
6023 settings->n_ciphers_pairwise = len / sizeof(u32);
6024
6025 if (len % sizeof(u32))
6026 return -EINVAL;
6027
6028 if (settings->n_ciphers_pairwise > cipher_limit)
6029 return -EINVAL;
6030
6031 memcpy(settings->ciphers_pairwise, data, len);
6032
6033 for (i = 0; i < settings->n_ciphers_pairwise; i++)
6034 if (!cfg80211_supported_cipher_suite(
6035 &rdev->wiphy,
6036 settings->ciphers_pairwise[i]))
6037 return -EINVAL;
6038 }
6039
6040 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
6041 settings->cipher_group =
6042 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
6043 if (!cfg80211_supported_cipher_suite(&rdev->wiphy,
6044 settings->cipher_group))
6045 return -EINVAL;
6046 }
6047
6048 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
6049 settings->wpa_versions =
6050 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
6051 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
6052 return -EINVAL;
6053 }
6054
6055 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
6056 void *data;
6057 int len;
6058
6059 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
6060 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
6061 settings->n_akm_suites = len / sizeof(u32);
6062
6063 if (len % sizeof(u32))
6064 return -EINVAL;
6065
6066 if (settings->n_akm_suites > NL80211_MAX_NR_AKM_SUITES)
6067 return -EINVAL;
6068
6069 memcpy(settings->akm_suites, data, len);
6070 }
6071
6072 return 0;
6073 }
6074
6075 static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
6076 {
6077 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6078 struct net_device *dev = info->user_ptr[1];
6079 struct ieee80211_channel *chan;
6080 struct cfg80211_assoc_request req = {};
6081 const u8 *bssid, *ssid;
6082 int err, ssid_len = 0;
6083
6084 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6085 return -EINVAL;
6086
6087 if (!info->attrs[NL80211_ATTR_MAC] ||
6088 !info->attrs[NL80211_ATTR_SSID] ||
6089 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
6090 return -EINVAL;
6091
6092 if (!rdev->ops->assoc)
6093 return -EOPNOTSUPP;
6094
6095 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6096 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6097 return -EOPNOTSUPP;
6098
6099 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6100
6101 chan = ieee80211_get_channel(&rdev->wiphy,
6102 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
6103 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED))
6104 return -EINVAL;
6105
6106 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6107 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6108
6109 if (info->attrs[NL80211_ATTR_IE]) {
6110 req.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6111 req.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6112 }
6113
6114 if (info->attrs[NL80211_ATTR_USE_MFP]) {
6115 enum nl80211_mfp mfp =
6116 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
6117 if (mfp == NL80211_MFP_REQUIRED)
6118 req.use_mfp = true;
6119 else if (mfp != NL80211_MFP_NO)
6120 return -EINVAL;
6121 }
6122
6123 if (info->attrs[NL80211_ATTR_PREV_BSSID])
6124 req.prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
6125
6126 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
6127 req.flags |= ASSOC_REQ_DISABLE_HT;
6128
6129 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6130 memcpy(&req.ht_capa_mask,
6131 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6132 sizeof(req.ht_capa_mask));
6133
6134 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6135 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6136 return -EINVAL;
6137 memcpy(&req.ht_capa,
6138 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6139 sizeof(req.ht_capa));
6140 }
6141
6142 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
6143 req.flags |= ASSOC_REQ_DISABLE_VHT;
6144
6145 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6146 memcpy(&req.vht_capa_mask,
6147 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
6148 sizeof(req.vht_capa_mask));
6149
6150 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
6151 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6152 return -EINVAL;
6153 memcpy(&req.vht_capa,
6154 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
6155 sizeof(req.vht_capa));
6156 }
6157
6158 err = nl80211_crypto_settings(rdev, info, &req.crypto, 1);
6159 if (!err)
6160 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid,
6161 ssid, ssid_len, &req);
6162
6163 return err;
6164 }
6165
6166 static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
6167 {
6168 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6169 struct net_device *dev = info->user_ptr[1];
6170 const u8 *ie = NULL, *bssid;
6171 int ie_len = 0;
6172 u16 reason_code;
6173 bool local_state_change;
6174
6175 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6176 return -EINVAL;
6177
6178 if (!info->attrs[NL80211_ATTR_MAC])
6179 return -EINVAL;
6180
6181 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6182 return -EINVAL;
6183
6184 if (!rdev->ops->deauth)
6185 return -EOPNOTSUPP;
6186
6187 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6188 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6189 return -EOPNOTSUPP;
6190
6191 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6192
6193 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6194 if (reason_code == 0) {
6195 /* Reason Code 0 is reserved */
6196 return -EINVAL;
6197 }
6198
6199 if (info->attrs[NL80211_ATTR_IE]) {
6200 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6201 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6202 }
6203
6204 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6205
6206 return cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code,
6207 local_state_change);
6208 }
6209
6210 static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
6211 {
6212 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6213 struct net_device *dev = info->user_ptr[1];
6214 const u8 *ie = NULL, *bssid;
6215 int ie_len = 0;
6216 u16 reason_code;
6217 bool local_state_change;
6218
6219 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6220 return -EINVAL;
6221
6222 if (!info->attrs[NL80211_ATTR_MAC])
6223 return -EINVAL;
6224
6225 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6226 return -EINVAL;
6227
6228 if (!rdev->ops->disassoc)
6229 return -EOPNOTSUPP;
6230
6231 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6232 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6233 return -EOPNOTSUPP;
6234
6235 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6236
6237 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6238 if (reason_code == 0) {
6239 /* Reason Code 0 is reserved */
6240 return -EINVAL;
6241 }
6242
6243 if (info->attrs[NL80211_ATTR_IE]) {
6244 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6245 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6246 }
6247
6248 local_state_change = !!info->attrs[NL80211_ATTR_LOCAL_STATE_CHANGE];
6249
6250 return cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code,
6251 local_state_change);
6252 }
6253
6254 static bool
6255 nl80211_parse_mcast_rate(struct cfg80211_registered_device *rdev,
6256 int mcast_rate[IEEE80211_NUM_BANDS],
6257 int rateval)
6258 {
6259 struct wiphy *wiphy = &rdev->wiphy;
6260 bool found = false;
6261 int band, i;
6262
6263 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
6264 struct ieee80211_supported_band *sband;
6265
6266 sband = wiphy->bands[band];
6267 if (!sband)
6268 continue;
6269
6270 for (i = 0; i < sband->n_bitrates; i++) {
6271 if (sband->bitrates[i].bitrate == rateval) {
6272 mcast_rate[band] = i + 1;
6273 found = true;
6274 break;
6275 }
6276 }
6277 }
6278
6279 return found;
6280 }
6281
6282 static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
6283 {
6284 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6285 struct net_device *dev = info->user_ptr[1];
6286 struct cfg80211_ibss_params ibss;
6287 struct wiphy *wiphy;
6288 struct cfg80211_cached_keys *connkeys = NULL;
6289 int err;
6290
6291 memset(&ibss, 0, sizeof(ibss));
6292
6293 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6294 return -EINVAL;
6295
6296 if (!info->attrs[NL80211_ATTR_SSID] ||
6297 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6298 return -EINVAL;
6299
6300 ibss.beacon_interval = 100;
6301
6302 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
6303 ibss.beacon_interval =
6304 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
6305 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
6306 return -EINVAL;
6307 }
6308
6309 if (!rdev->ops->join_ibss)
6310 return -EOPNOTSUPP;
6311
6312 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6313 return -EOPNOTSUPP;
6314
6315 wiphy = &rdev->wiphy;
6316
6317 if (info->attrs[NL80211_ATTR_MAC]) {
6318 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6319
6320 if (!is_valid_ether_addr(ibss.bssid))
6321 return -EINVAL;
6322 }
6323 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6324 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6325
6326 if (info->attrs[NL80211_ATTR_IE]) {
6327 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6328 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6329 }
6330
6331 err = nl80211_parse_chandef(rdev, info, &ibss.chandef);
6332 if (err)
6333 return err;
6334
6335 if (!cfg80211_reg_can_beacon(&rdev->wiphy, &ibss.chandef))
6336 return -EINVAL;
6337
6338 if (ibss.chandef.width > NL80211_CHAN_WIDTH_40)
6339 return -EINVAL;
6340 if (ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT &&
6341 !(rdev->wiphy.features & NL80211_FEATURE_HT_IBSS))
6342 return -EINVAL;
6343
6344 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
6345 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
6346
6347 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
6348 u8 *rates =
6349 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6350 int n_rates =
6351 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
6352 struct ieee80211_supported_band *sband =
6353 wiphy->bands[ibss.chandef.chan->band];
6354
6355 err = ieee80211_get_ratemask(sband, rates, n_rates,
6356 &ibss.basic_rates);
6357 if (err)
6358 return err;
6359 }
6360
6361 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
6362 !nl80211_parse_mcast_rate(rdev, ibss.mcast_rate,
6363 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
6364 return -EINVAL;
6365
6366 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
6367 bool no_ht = false;
6368
6369 connkeys = nl80211_parse_connkeys(rdev,
6370 info->attrs[NL80211_ATTR_KEYS],
6371 &no_ht);
6372 if (IS_ERR(connkeys))
6373 return PTR_ERR(connkeys);
6374
6375 if ((ibss.chandef.width != NL80211_CHAN_WIDTH_20_NOHT) &&
6376 no_ht) {
6377 kfree(connkeys);
6378 return -EINVAL;
6379 }
6380 }
6381
6382 ibss.control_port =
6383 nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT]);
6384
6385 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
6386 if (err)
6387 kfree(connkeys);
6388 return err;
6389 }
6390
6391 static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
6392 {
6393 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6394 struct net_device *dev = info->user_ptr[1];
6395
6396 if (!rdev->ops->leave_ibss)
6397 return -EOPNOTSUPP;
6398
6399 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC)
6400 return -EOPNOTSUPP;
6401
6402 return cfg80211_leave_ibss(rdev, dev, false);
6403 }
6404
6405 static int nl80211_set_mcast_rate(struct sk_buff *skb, struct genl_info *info)
6406 {
6407 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6408 struct net_device *dev = info->user_ptr[1];
6409 int mcast_rate[IEEE80211_NUM_BANDS];
6410 u32 nla_rate;
6411 int err;
6412
6413 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC &&
6414 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT)
6415 return -EOPNOTSUPP;
6416
6417 if (!rdev->ops->set_mcast_rate)
6418 return -EOPNOTSUPP;
6419
6420 memset(mcast_rate, 0, sizeof(mcast_rate));
6421
6422 if (!info->attrs[NL80211_ATTR_MCAST_RATE])
6423 return -EINVAL;
6424
6425 nla_rate = nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE]);
6426 if (!nl80211_parse_mcast_rate(rdev, mcast_rate, nla_rate))
6427 return -EINVAL;
6428
6429 err = rdev->ops->set_mcast_rate(&rdev->wiphy, dev, mcast_rate);
6430
6431 return err;
6432 }
6433
6434 static struct sk_buff *
6435 __cfg80211_alloc_vendor_skb(struct cfg80211_registered_device *rdev,
6436 int approxlen, u32 portid, u32 seq,
6437 enum nl80211_commands cmd,
6438 enum nl80211_attrs attr,
6439 const struct nl80211_vendor_cmd_info *info,
6440 gfp_t gfp)
6441 {
6442 struct sk_buff *skb;
6443 void *hdr;
6444 struct nlattr *data;
6445
6446 skb = nlmsg_new(approxlen + 100, gfp);
6447 if (!skb)
6448 return NULL;
6449
6450 hdr = nl80211hdr_put(skb, portid, seq, 0, cmd);
6451 if (!hdr) {
6452 kfree_skb(skb);
6453 return NULL;
6454 }
6455
6456 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
6457 goto nla_put_failure;
6458
6459 if (info) {
6460 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_ID,
6461 info->vendor_id))
6462 goto nla_put_failure;
6463 if (nla_put_u32(skb, NL80211_ATTR_VENDOR_SUBCMD,
6464 info->subcmd))
6465 goto nla_put_failure;
6466 }
6467
6468 data = nla_nest_start(skb, attr);
6469
6470 ((void **)skb->cb)[0] = rdev;
6471 ((void **)skb->cb)[1] = hdr;
6472 ((void **)skb->cb)[2] = data;
6473
6474 return skb;
6475
6476 nla_put_failure:
6477 kfree_skb(skb);
6478 return NULL;
6479 }
6480
6481 #ifdef CONFIG_NL80211_TESTMODE
6482 static struct genl_multicast_group nl80211_testmode_mcgrp = {
6483 .name = "testmode",
6484 };
6485
6486 static struct genl_multicast_group nl80211_vendor_mcgrp = {
6487 .name = "vendor",
6488 };
6489
6490 static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
6491 {
6492 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6493 int err;
6494
6495 if (!info->attrs[NL80211_ATTR_TESTDATA])
6496 return -EINVAL;
6497
6498 err = -EOPNOTSUPP;
6499 if (rdev->ops->testmode_cmd) {
6500 rdev->cur_cmd_info = info;
6501 err = rdev_testmode_cmd(rdev,
6502 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
6503 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
6504 rdev->cur_cmd_info = NULL;
6505 }
6506
6507 return err;
6508 }
6509
6510 static int nl80211_testmode_dump(struct sk_buff *skb,
6511 struct netlink_callback *cb)
6512 {
6513 struct cfg80211_registered_device *rdev;
6514 int err;
6515 long phy_idx;
6516 void *data = NULL;
6517 int data_len = 0;
6518
6519 if (cb->args[0]) {
6520 /*
6521 * 0 is a valid index, but not valid for args[0],
6522 * so we need to offset by 1.
6523 */
6524 phy_idx = cb->args[0] - 1;
6525 } else {
6526 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
6527 nl80211_fam.attrbuf, nl80211_fam.maxattr,
6528 nl80211_policy);
6529 if (err)
6530 return err;
6531
6532 mutex_lock(&cfg80211_mutex);
6533 rdev = __cfg80211_rdev_from_attrs(sock_net(skb->sk),
6534 nl80211_fam.attrbuf);
6535 if (IS_ERR(rdev)) {
6536 mutex_unlock(&cfg80211_mutex);
6537 return PTR_ERR(rdev);
6538 }
6539 phy_idx = rdev->wiphy_idx;
6540 rdev = NULL;
6541 mutex_unlock(&cfg80211_mutex);
6542
6543 if (nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA])
6544 cb->args[1] =
6545 (long)nl80211_fam.attrbuf[NL80211_ATTR_TESTDATA];
6546 }
6547
6548 if (cb->args[1]) {
6549 data = nla_data((void *)cb->args[1]);
6550 data_len = nla_len((void *)cb->args[1]);
6551 }
6552
6553 mutex_lock(&cfg80211_mutex);
6554 rdev = cfg80211_rdev_by_wiphy_idx(phy_idx);
6555 if (!rdev) {
6556 mutex_unlock(&cfg80211_mutex);
6557 return -ENOENT;
6558 }
6559 cfg80211_lock_rdev(rdev);
6560 mutex_unlock(&cfg80211_mutex);
6561
6562 if (!rdev->ops->testmode_dump) {
6563 err = -EOPNOTSUPP;
6564 goto out_err;
6565 }
6566
6567 while (1) {
6568 void *hdr = nl80211hdr_put(skb, NETLINK_CB(cb->skb).portid,
6569 cb->nlh->nlmsg_seq, NLM_F_MULTI,
6570 NL80211_CMD_TESTMODE);
6571 struct nlattr *tmdata;
6572
6573 if (!hdr)
6574 break;
6575
6576 if (nla_put_u32(skb, NL80211_ATTR_WIPHY, phy_idx)) {
6577 genlmsg_cancel(skb, hdr);
6578 break;
6579 }
6580
6581 tmdata = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
6582 if (!tmdata) {
6583 genlmsg_cancel(skb, hdr);
6584 break;
6585 }
6586 err = rdev_testmode_dump(rdev, skb, cb, data, data_len);
6587 nla_nest_end(skb, tmdata);
6588
6589 if (err == -ENOBUFS || err == -ENOENT) {
6590 genlmsg_cancel(skb, hdr);
6591 break;
6592 } else if (err) {
6593 genlmsg_cancel(skb, hdr);
6594 goto out_err;
6595 }
6596
6597 genlmsg_end(skb, hdr);
6598 }
6599
6600 err = skb->len;
6601 /* see above */
6602 cb->args[0] = phy_idx + 1;
6603 out_err:
6604 cfg80211_unlock_rdev(rdev);
6605 return err;
6606 }
6607
6608 struct sk_buff *__cfg80211_alloc_event_skb(struct wiphy *wiphy,
6609 enum nl80211_commands cmd,
6610 enum nl80211_attrs attr,
6611 int vendor_event_idx,
6612 int approxlen, gfp_t gfp)
6613 {
6614 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
6615 const struct nl80211_vendor_cmd_info *info;
6616
6617 switch (cmd) {
6618 case NL80211_CMD_TESTMODE:
6619 if (WARN_ON(vendor_event_idx != -1))
6620 return NULL;
6621 info = NULL;
6622 break;
6623 case NL80211_CMD_VENDOR:
6624 if (WARN_ON(vendor_event_idx < 0 ||
6625 vendor_event_idx >= wiphy->n_vendor_events))
6626 return NULL;
6627 info = &wiphy->vendor_events[vendor_event_idx];
6628 break;
6629 default:
6630 WARN_ON(1);
6631 return NULL;
6632 }
6633 return __cfg80211_alloc_vendor_skb(rdev, approxlen, 0, 0,
6634 cmd, attr, info, gfp);
6635 }
6636 EXPORT_SYMBOL(__cfg80211_alloc_event_skb);
6637
6638 void __cfg80211_send_event_skb(struct sk_buff *skb, gfp_t gfp)
6639 {
6640 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
6641 void *hdr = ((void **)skb->cb)[1];
6642 struct nlattr *data = ((void **)skb->cb)[2];
6643
6644 /* clear CB data for netlink core to own from now on */
6645 memset(skb->cb, 0, sizeof(skb->cb));
6646
6647 nla_nest_end(skb, data);
6648 genlmsg_end(skb, hdr);
6649
6650 if (data->nla_type == NL80211_ATTR_VENDOR_DATA)
6651 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), skb, 0,
6652 nl80211_vendor_mcgrp.id, gfp);
6653 else
6654 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), skb, 0,
6655 nl80211_testmode_mcgrp.id, gfp);
6656 }
6657 EXPORT_SYMBOL(__cfg80211_send_event_skb);
6658 #endif
6659
6660 static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
6661 {
6662 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6663 struct net_device *dev = info->user_ptr[1];
6664 struct cfg80211_connect_params connect;
6665 struct wiphy *wiphy;
6666 struct cfg80211_cached_keys *connkeys = NULL;
6667 int err;
6668
6669 memset(&connect, 0, sizeof(connect));
6670
6671 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
6672 return -EINVAL;
6673
6674 if (!info->attrs[NL80211_ATTR_SSID] ||
6675 !nla_len(info->attrs[NL80211_ATTR_SSID]))
6676 return -EINVAL;
6677
6678 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
6679 connect.auth_type =
6680 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
6681 if (!nl80211_valid_auth_type(rdev, connect.auth_type,
6682 NL80211_CMD_CONNECT))
6683 return -EINVAL;
6684 } else
6685 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
6686
6687 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
6688
6689 err = nl80211_crypto_settings(rdev, info, &connect.crypto,
6690 NL80211_MAX_NR_CIPHER_SUITES);
6691 if (err)
6692 return err;
6693
6694 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6695 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6696 return -EOPNOTSUPP;
6697
6698 wiphy = &rdev->wiphy;
6699
6700 connect.bg_scan_period = -1;
6701 if (info->attrs[NL80211_ATTR_BG_SCAN_PERIOD] &&
6702 (wiphy->flags & WIPHY_FLAG_SUPPORTS_FW_ROAM)) {
6703 connect.bg_scan_period =
6704 nla_get_u16(info->attrs[NL80211_ATTR_BG_SCAN_PERIOD]);
6705 }
6706
6707 if (info->attrs[NL80211_ATTR_MAC])
6708 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6709 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
6710 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
6711
6712 if (info->attrs[NL80211_ATTR_IE]) {
6713 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
6714 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
6715 }
6716
6717 if (info->attrs[NL80211_ATTR_USE_MFP]) {
6718 connect.mfp = nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
6719 if (connect.mfp != NL80211_MFP_REQUIRED &&
6720 connect.mfp != NL80211_MFP_NO)
6721 return -EINVAL;
6722 } else {
6723 connect.mfp = NL80211_MFP_NO;
6724 }
6725
6726 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
6727 connect.channel =
6728 ieee80211_get_channel(wiphy,
6729 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
6730 if (!connect.channel ||
6731 connect.channel->flags & IEEE80211_CHAN_DISABLED)
6732 return -EINVAL;
6733 }
6734
6735 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
6736 connkeys = nl80211_parse_connkeys(rdev,
6737 info->attrs[NL80211_ATTR_KEYS], NULL);
6738 if (IS_ERR(connkeys))
6739 return PTR_ERR(connkeys);
6740 }
6741
6742 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_HT]))
6743 connect.flags |= ASSOC_REQ_DISABLE_HT;
6744
6745 if (info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK])
6746 memcpy(&connect.ht_capa_mask,
6747 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]),
6748 sizeof(connect.ht_capa_mask));
6749
6750 if (info->attrs[NL80211_ATTR_HT_CAPABILITY]) {
6751 if (!info->attrs[NL80211_ATTR_HT_CAPABILITY_MASK]) {
6752 kfree(connkeys);
6753 return -EINVAL;
6754 }
6755 memcpy(&connect.ht_capa,
6756 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]),
6757 sizeof(connect.ht_capa));
6758 }
6759
6760 if (nla_get_flag(info->attrs[NL80211_ATTR_DISABLE_VHT]))
6761 connect.flags |= ASSOC_REQ_DISABLE_VHT;
6762
6763 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK])
6764 memcpy(&connect.vht_capa_mask,
6765 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]),
6766 sizeof(connect.vht_capa_mask));
6767
6768 if (info->attrs[NL80211_ATTR_VHT_CAPABILITY]) {
6769 if (!info->attrs[NL80211_ATTR_VHT_CAPABILITY_MASK]) {
6770 kfree(connkeys);
6771 return -EINVAL;
6772 }
6773 memcpy(&connect.vht_capa,
6774 nla_data(info->attrs[NL80211_ATTR_VHT_CAPABILITY]),
6775 sizeof(connect.vht_capa));
6776 }
6777
6778 err = cfg80211_connect(rdev, dev, &connect, connkeys);
6779 if (err)
6780 kfree(connkeys);
6781 return err;
6782 }
6783
6784 static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
6785 {
6786 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6787 struct net_device *dev = info->user_ptr[1];
6788 u16 reason;
6789
6790 if (!info->attrs[NL80211_ATTR_REASON_CODE])
6791 reason = WLAN_REASON_DEAUTH_LEAVING;
6792 else
6793 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
6794
6795 if (reason == 0)
6796 return -EINVAL;
6797
6798 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6799 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6800 return -EOPNOTSUPP;
6801
6802 return cfg80211_disconnect(rdev, dev, reason, true);
6803 }
6804
6805 static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
6806 {
6807 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6808 struct net *net;
6809 int err;
6810 u32 pid;
6811
6812 if (!info->attrs[NL80211_ATTR_PID])
6813 return -EINVAL;
6814
6815 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
6816
6817 net = get_net_ns_by_pid(pid);
6818 if (IS_ERR(net))
6819 return PTR_ERR(net);
6820
6821 err = 0;
6822
6823 /* check if anything to do */
6824 if (!net_eq(wiphy_net(&rdev->wiphy), net))
6825 err = cfg80211_switch_netns(rdev, net);
6826
6827 put_net(net);
6828 return err;
6829 }
6830
6831 static int nl80211_setdel_pmksa(struct sk_buff *skb, struct genl_info *info)
6832 {
6833 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6834 int (*rdev_ops)(struct wiphy *wiphy, struct net_device *dev,
6835 struct cfg80211_pmksa *pmksa) = NULL;
6836 struct net_device *dev = info->user_ptr[1];
6837 struct cfg80211_pmksa pmksa;
6838
6839 memset(&pmksa, 0, sizeof(struct cfg80211_pmksa));
6840
6841 if (!info->attrs[NL80211_ATTR_MAC])
6842 return -EINVAL;
6843
6844 if (!info->attrs[NL80211_ATTR_PMKID])
6845 return -EINVAL;
6846
6847 pmksa.pmkid = nla_data(info->attrs[NL80211_ATTR_PMKID]);
6848 pmksa.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
6849
6850 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6851 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6852 return -EOPNOTSUPP;
6853
6854 switch (info->genlhdr->cmd) {
6855 case NL80211_CMD_SET_PMKSA:
6856 rdev_ops = rdev->ops->set_pmksa;
6857 break;
6858 case NL80211_CMD_DEL_PMKSA:
6859 rdev_ops = rdev->ops->del_pmksa;
6860 break;
6861 default:
6862 WARN_ON(1);
6863 break;
6864 }
6865
6866 if (!rdev_ops)
6867 return -EOPNOTSUPP;
6868
6869 return rdev_ops(&rdev->wiphy, dev, &pmksa);
6870 }
6871
6872 static int nl80211_flush_pmksa(struct sk_buff *skb, struct genl_info *info)
6873 {
6874 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6875 struct net_device *dev = info->user_ptr[1];
6876
6877 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION &&
6878 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_P2P_CLIENT)
6879 return -EOPNOTSUPP;
6880
6881 if (!rdev->ops->flush_pmksa)
6882 return -EOPNOTSUPP;
6883
6884 return rdev_flush_pmksa(rdev, dev);
6885 }
6886
6887 static int nl80211_tdls_mgmt(struct sk_buff *skb, struct genl_info *info)
6888 {
6889 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6890 struct net_device *dev = info->user_ptr[1];
6891 u8 action_code, dialog_token;
6892 u16 status_code;
6893 u8 *peer;
6894
6895 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
6896 !rdev->ops->tdls_mgmt)
6897 return -EOPNOTSUPP;
6898
6899 if (!info->attrs[NL80211_ATTR_TDLS_ACTION] ||
6900 !info->attrs[NL80211_ATTR_STATUS_CODE] ||
6901 !info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN] ||
6902 !info->attrs[NL80211_ATTR_IE] ||
6903 !info->attrs[NL80211_ATTR_MAC])
6904 return -EINVAL;
6905
6906 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
6907 action_code = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_ACTION]);
6908 status_code = nla_get_u16(info->attrs[NL80211_ATTR_STATUS_CODE]);
6909 dialog_token = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_DIALOG_TOKEN]);
6910
6911 return rdev_tdls_mgmt(rdev, dev, peer, action_code,
6912 dialog_token, status_code,
6913 nla_data(info->attrs[NL80211_ATTR_IE]),
6914 nla_len(info->attrs[NL80211_ATTR_IE]));
6915 }
6916
6917 static int nl80211_tdls_oper(struct sk_buff *skb, struct genl_info *info)
6918 {
6919 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6920 struct net_device *dev = info->user_ptr[1];
6921 enum nl80211_tdls_operation operation;
6922 u8 *peer;
6923
6924 if (!(rdev->wiphy.flags & WIPHY_FLAG_SUPPORTS_TDLS) ||
6925 !rdev->ops->tdls_oper)
6926 return -EOPNOTSUPP;
6927
6928 if (!info->attrs[NL80211_ATTR_TDLS_OPERATION] ||
6929 !info->attrs[NL80211_ATTR_MAC])
6930 return -EINVAL;
6931
6932 operation = nla_get_u8(info->attrs[NL80211_ATTR_TDLS_OPERATION]);
6933 peer = nla_data(info->attrs[NL80211_ATTR_MAC]);
6934
6935 return rdev_tdls_oper(rdev, dev, peer, operation);
6936 }
6937
6938 static int nl80211_remain_on_channel(struct sk_buff *skb,
6939 struct genl_info *info)
6940 {
6941 struct cfg80211_registered_device *rdev = info->user_ptr[0];
6942 struct wireless_dev *wdev = info->user_ptr[1];
6943 struct cfg80211_chan_def chandef;
6944 struct sk_buff *msg;
6945 void *hdr;
6946 u64 cookie;
6947 u32 duration;
6948 int err;
6949
6950 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
6951 !info->attrs[NL80211_ATTR_DURATION])
6952 return -EINVAL;
6953
6954 duration = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
6955
6956 if (!rdev->ops->remain_on_channel ||
6957 !(rdev->wiphy.flags & WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL))
6958 return -EOPNOTSUPP;
6959
6960 /*
6961 * We should be on that channel for at least a minimum amount of
6962 * time (10ms) but no longer than the driver supports.
6963 */
6964 if (duration < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
6965 duration > rdev->wiphy.max_remain_on_channel_duration)
6966 return -EINVAL;
6967
6968 err = nl80211_parse_chandef(rdev, info, &chandef);
6969 if (err)
6970 return err;
6971
6972 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
6973 if (!msg)
6974 return -ENOMEM;
6975
6976 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
6977 NL80211_CMD_REMAIN_ON_CHANNEL);
6978 if (!hdr) {
6979 err = -ENOBUFS;
6980 goto free_msg;
6981 }
6982
6983 err = rdev_remain_on_channel(rdev, wdev, chandef.chan,
6984 duration, &cookie);
6985
6986 if (err)
6987 goto free_msg;
6988
6989 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
6990 goto nla_put_failure;
6991
6992 genlmsg_end(msg, hdr);
6993
6994 return genlmsg_reply(msg, info);
6995
6996 nla_put_failure:
6997 err = -ENOBUFS;
6998 free_msg:
6999 nlmsg_free(msg);
7000 return err;
7001 }
7002
7003 static int nl80211_cancel_remain_on_channel(struct sk_buff *skb,
7004 struct genl_info *info)
7005 {
7006 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7007 struct wireless_dev *wdev = info->user_ptr[1];
7008 u64 cookie;
7009
7010 if (!info->attrs[NL80211_ATTR_COOKIE])
7011 return -EINVAL;
7012
7013 if (!rdev->ops->cancel_remain_on_channel)
7014 return -EOPNOTSUPP;
7015
7016 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7017
7018 return rdev_cancel_remain_on_channel(rdev, wdev, cookie);
7019 }
7020
7021 static u32 rateset_to_mask(struct ieee80211_supported_band *sband,
7022 u8 *rates, u8 rates_len)
7023 {
7024 u8 i;
7025 u32 mask = 0;
7026
7027 for (i = 0; i < rates_len; i++) {
7028 int rate = (rates[i] & 0x7f) * 5;
7029 int ridx;
7030 for (ridx = 0; ridx < sband->n_bitrates; ridx++) {
7031 struct ieee80211_rate *srate =
7032 &sband->bitrates[ridx];
7033 if (rate == srate->bitrate) {
7034 mask |= 1 << ridx;
7035 break;
7036 }
7037 }
7038 if (ridx == sband->n_bitrates)
7039 return 0; /* rate not found */
7040 }
7041
7042 return mask;
7043 }
7044
7045 static bool ht_rateset_to_mask(struct ieee80211_supported_band *sband,
7046 u8 *rates, u8 rates_len,
7047 u8 mcs[IEEE80211_HT_MCS_MASK_LEN])
7048 {
7049 u8 i;
7050
7051 memset(mcs, 0, IEEE80211_HT_MCS_MASK_LEN);
7052
7053 for (i = 0; i < rates_len; i++) {
7054 int ridx, rbit;
7055
7056 ridx = rates[i] / 8;
7057 rbit = BIT(rates[i] % 8);
7058
7059 /* check validity */
7060 if ((ridx < 0) || (ridx >= IEEE80211_HT_MCS_MASK_LEN))
7061 return false;
7062
7063 /* check availability */
7064 if (sband->ht_cap.mcs.rx_mask[ridx] & rbit)
7065 mcs[ridx] |= rbit;
7066 else
7067 return false;
7068 }
7069
7070 return true;
7071 }
7072
7073 static const struct nla_policy nl80211_txattr_policy[NL80211_TXRATE_MAX + 1] = {
7074 [NL80211_TXRATE_LEGACY] = { .type = NLA_BINARY,
7075 .len = NL80211_MAX_SUPP_RATES },
7076 [NL80211_TXRATE_MCS] = { .type = NLA_BINARY,
7077 .len = NL80211_MAX_SUPP_HT_RATES },
7078 };
7079
7080 static int nl80211_set_tx_bitrate_mask(struct sk_buff *skb,
7081 struct genl_info *info)
7082 {
7083 struct nlattr *tb[NL80211_TXRATE_MAX + 1];
7084 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7085 struct cfg80211_bitrate_mask mask;
7086 int rem, i;
7087 struct net_device *dev = info->user_ptr[1];
7088 struct nlattr *tx_rates;
7089 struct ieee80211_supported_band *sband;
7090
7091 if (info->attrs[NL80211_ATTR_TX_RATES] == NULL)
7092 return -EINVAL;
7093
7094 if (!rdev->ops->set_bitrate_mask)
7095 return -EOPNOTSUPP;
7096
7097 memset(&mask, 0, sizeof(mask));
7098 /* Default to all rates enabled */
7099 for (i = 0; i < IEEE80211_NUM_BANDS; i++) {
7100 sband = rdev->wiphy.bands[i];
7101 mask.control[i].legacy =
7102 sband ? (1 << sband->n_bitrates) - 1 : 0;
7103 if (sband)
7104 memcpy(mask.control[i].mcs,
7105 sband->ht_cap.mcs.rx_mask,
7106 sizeof(mask.control[i].mcs));
7107 else
7108 memset(mask.control[i].mcs, 0,
7109 sizeof(mask.control[i].mcs));
7110 }
7111
7112 /*
7113 * The nested attribute uses enum nl80211_band as the index. This maps
7114 * directly to the enum ieee80211_band values used in cfg80211.
7115 */
7116 BUILD_BUG_ON(NL80211_MAX_SUPP_HT_RATES > IEEE80211_HT_MCS_MASK_LEN * 8);
7117 nla_for_each_nested(tx_rates, info->attrs[NL80211_ATTR_TX_RATES], rem)
7118 {
7119 enum ieee80211_band band = nla_type(tx_rates);
7120 if (band < 0 || band >= IEEE80211_NUM_BANDS)
7121 return -EINVAL;
7122 sband = rdev->wiphy.bands[band];
7123 if (sband == NULL)
7124 return -EINVAL;
7125 nla_parse(tb, NL80211_TXRATE_MAX, nla_data(tx_rates),
7126 nla_len(tx_rates), nl80211_txattr_policy);
7127 if (tb[NL80211_TXRATE_LEGACY]) {
7128 mask.control[band].legacy = rateset_to_mask(
7129 sband,
7130 nla_data(tb[NL80211_TXRATE_LEGACY]),
7131 nla_len(tb[NL80211_TXRATE_LEGACY]));
7132 if ((mask.control[band].legacy == 0) &&
7133 nla_len(tb[NL80211_TXRATE_LEGACY]))
7134 return -EINVAL;
7135 }
7136 if (tb[NL80211_TXRATE_MCS]) {
7137 if (!ht_rateset_to_mask(
7138 sband,
7139 nla_data(tb[NL80211_TXRATE_MCS]),
7140 nla_len(tb[NL80211_TXRATE_MCS]),
7141 mask.control[band].mcs))
7142 return -EINVAL;
7143 }
7144
7145 if (mask.control[band].legacy == 0) {
7146 /* don't allow empty legacy rates if HT
7147 * is not even supported. */
7148 if (!rdev->wiphy.bands[band]->ht_cap.ht_supported)
7149 return -EINVAL;
7150
7151 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
7152 if (mask.control[band].mcs[i])
7153 break;
7154
7155 /* legacy and mcs rates may not be both empty */
7156 if (i == IEEE80211_HT_MCS_MASK_LEN)
7157 return -EINVAL;
7158 }
7159 }
7160
7161 return rdev_set_bitrate_mask(rdev, dev, NULL, &mask);
7162 }
7163
7164 static int nl80211_register_mgmt(struct sk_buff *skb, struct genl_info *info)
7165 {
7166 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7167 struct wireless_dev *wdev = info->user_ptr[1];
7168 u16 frame_type = IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_ACTION;
7169
7170 if (!info->attrs[NL80211_ATTR_FRAME_MATCH])
7171 return -EINVAL;
7172
7173 if (info->attrs[NL80211_ATTR_FRAME_TYPE])
7174 frame_type = nla_get_u16(info->attrs[NL80211_ATTR_FRAME_TYPE]);
7175
7176 switch (wdev->iftype) {
7177 case NL80211_IFTYPE_STATION:
7178 case NL80211_IFTYPE_ADHOC:
7179 case NL80211_IFTYPE_P2P_CLIENT:
7180 case NL80211_IFTYPE_AP:
7181 case NL80211_IFTYPE_AP_VLAN:
7182 case NL80211_IFTYPE_MESH_POINT:
7183 case NL80211_IFTYPE_P2P_GO:
7184 case NL80211_IFTYPE_P2P_DEVICE:
7185 break;
7186 default:
7187 return -EOPNOTSUPP;
7188 }
7189
7190 /* not much point in registering if we can't reply */
7191 if (!rdev->ops->mgmt_tx)
7192 return -EOPNOTSUPP;
7193
7194 return cfg80211_mlme_register_mgmt(wdev, info->snd_portid, frame_type,
7195 nla_data(info->attrs[NL80211_ATTR_FRAME_MATCH]),
7196 nla_len(info->attrs[NL80211_ATTR_FRAME_MATCH]));
7197 }
7198
7199 static int nl80211_tx_mgmt(struct sk_buff *skb, struct genl_info *info)
7200 {
7201 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7202 struct wireless_dev *wdev = info->user_ptr[1];
7203 struct cfg80211_chan_def chandef;
7204 int err;
7205 void *hdr = NULL;
7206 u64 cookie;
7207 struct sk_buff *msg = NULL;
7208 unsigned int wait = 0;
7209 bool offchan, no_cck, dont_wait_for_ack;
7210
7211 dont_wait_for_ack = info->attrs[NL80211_ATTR_DONT_WAIT_FOR_ACK];
7212
7213 if (!info->attrs[NL80211_ATTR_FRAME])
7214 return -EINVAL;
7215
7216 if (!rdev->ops->mgmt_tx)
7217 return -EOPNOTSUPP;
7218
7219 switch (wdev->iftype) {
7220 case NL80211_IFTYPE_STATION:
7221 case NL80211_IFTYPE_ADHOC:
7222 case NL80211_IFTYPE_P2P_CLIENT:
7223 case NL80211_IFTYPE_AP:
7224 case NL80211_IFTYPE_AP_VLAN:
7225 case NL80211_IFTYPE_MESH_POINT:
7226 case NL80211_IFTYPE_P2P_GO:
7227 case NL80211_IFTYPE_P2P_DEVICE:
7228 break;
7229 default:
7230 return -EOPNOTSUPP;
7231 }
7232
7233 if (info->attrs[NL80211_ATTR_DURATION]) {
7234 if (!(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7235 return -EINVAL;
7236 wait = nla_get_u32(info->attrs[NL80211_ATTR_DURATION]);
7237
7238 /*
7239 * We should wait on the channel for at least a minimum amount
7240 * of time (10ms) but no longer than the driver supports.
7241 */
7242 if (wait < NL80211_MIN_REMAIN_ON_CHANNEL_TIME ||
7243 wait > rdev->wiphy.max_remain_on_channel_duration)
7244 return -EINVAL;
7245
7246 }
7247
7248 offchan = info->attrs[NL80211_ATTR_OFFCHANNEL_TX_OK];
7249
7250 if (offchan && !(rdev->wiphy.flags & WIPHY_FLAG_OFFCHAN_TX))
7251 return -EINVAL;
7252
7253 no_cck = nla_get_flag(info->attrs[NL80211_ATTR_TX_NO_CCK_RATE]);
7254
7255 err = nl80211_parse_chandef(rdev, info, &chandef);
7256 if (err)
7257 return err;
7258
7259 if (!dont_wait_for_ack) {
7260 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7261 if (!msg)
7262 return -ENOMEM;
7263
7264 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7265 NL80211_CMD_FRAME);
7266 if (!hdr) {
7267 err = -ENOBUFS;
7268 goto free_msg;
7269 }
7270 }
7271
7272 err = cfg80211_mlme_mgmt_tx(rdev, wdev, chandef.chan, offchan, wait,
7273 nla_data(info->attrs[NL80211_ATTR_FRAME]),
7274 nla_len(info->attrs[NL80211_ATTR_FRAME]),
7275 no_cck, dont_wait_for_ack, &cookie);
7276 if (err)
7277 goto free_msg;
7278
7279 if (msg) {
7280 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
7281 goto nla_put_failure;
7282
7283 genlmsg_end(msg, hdr);
7284 return genlmsg_reply(msg, info);
7285 }
7286
7287 return 0;
7288
7289 nla_put_failure:
7290 err = -ENOBUFS;
7291 free_msg:
7292 nlmsg_free(msg);
7293 return err;
7294 }
7295
7296 static int nl80211_tx_mgmt_cancel_wait(struct sk_buff *skb, struct genl_info *info)
7297 {
7298 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7299 struct wireless_dev *wdev = info->user_ptr[1];
7300 u64 cookie;
7301
7302 if (!info->attrs[NL80211_ATTR_COOKIE])
7303 return -EINVAL;
7304
7305 if (!rdev->ops->mgmt_tx_cancel_wait)
7306 return -EOPNOTSUPP;
7307
7308 switch (wdev->iftype) {
7309 case NL80211_IFTYPE_STATION:
7310 case NL80211_IFTYPE_ADHOC:
7311 case NL80211_IFTYPE_P2P_CLIENT:
7312 case NL80211_IFTYPE_AP:
7313 case NL80211_IFTYPE_AP_VLAN:
7314 case NL80211_IFTYPE_P2P_GO:
7315 case NL80211_IFTYPE_P2P_DEVICE:
7316 break;
7317 default:
7318 return -EOPNOTSUPP;
7319 }
7320
7321 cookie = nla_get_u64(info->attrs[NL80211_ATTR_COOKIE]);
7322
7323 return rdev_mgmt_tx_cancel_wait(rdev, wdev, cookie);
7324 }
7325
7326 static int nl80211_set_power_save(struct sk_buff *skb, struct genl_info *info)
7327 {
7328 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7329 struct wireless_dev *wdev;
7330 struct net_device *dev = info->user_ptr[1];
7331 u8 ps_state;
7332 bool state;
7333 int err;
7334
7335 if (!info->attrs[NL80211_ATTR_PS_STATE])
7336 return -EINVAL;
7337
7338 ps_state = nla_get_u32(info->attrs[NL80211_ATTR_PS_STATE]);
7339
7340 if (ps_state != NL80211_PS_DISABLED && ps_state != NL80211_PS_ENABLED)
7341 return -EINVAL;
7342
7343 wdev = dev->ieee80211_ptr;
7344
7345 if (!rdev->ops->set_power_mgmt)
7346 return -EOPNOTSUPP;
7347
7348 state = (ps_state == NL80211_PS_ENABLED) ? true : false;
7349
7350 if (state == wdev->ps)
7351 return 0;
7352
7353 err = rdev_set_power_mgmt(rdev, dev, state, wdev->ps_timeout);
7354 if (!err)
7355 wdev->ps = state;
7356 return err;
7357 }
7358
7359 static int nl80211_get_power_save(struct sk_buff *skb, struct genl_info *info)
7360 {
7361 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7362 enum nl80211_ps_state ps_state;
7363 struct wireless_dev *wdev;
7364 struct net_device *dev = info->user_ptr[1];
7365 struct sk_buff *msg;
7366 void *hdr;
7367 int err;
7368
7369 wdev = dev->ieee80211_ptr;
7370
7371 if (!rdev->ops->set_power_mgmt)
7372 return -EOPNOTSUPP;
7373
7374 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
7375 if (!msg)
7376 return -ENOMEM;
7377
7378 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7379 NL80211_CMD_GET_POWER_SAVE);
7380 if (!hdr) {
7381 err = -ENOBUFS;
7382 goto free_msg;
7383 }
7384
7385 if (wdev->ps)
7386 ps_state = NL80211_PS_ENABLED;
7387 else
7388 ps_state = NL80211_PS_DISABLED;
7389
7390 if (nla_put_u32(msg, NL80211_ATTR_PS_STATE, ps_state))
7391 goto nla_put_failure;
7392
7393 genlmsg_end(msg, hdr);
7394 return genlmsg_reply(msg, info);
7395
7396 nla_put_failure:
7397 err = -ENOBUFS;
7398 free_msg:
7399 nlmsg_free(msg);
7400 return err;
7401 }
7402
7403 static struct nla_policy
7404 nl80211_attr_cqm_policy[NL80211_ATTR_CQM_MAX + 1] __read_mostly = {
7405 [NL80211_ATTR_CQM_RSSI_THOLD] = { .type = NLA_U32 },
7406 [NL80211_ATTR_CQM_RSSI_HYST] = { .type = NLA_U32 },
7407 [NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT] = { .type = NLA_U32 },
7408 [NL80211_ATTR_CQM_TXE_RATE] = { .type = NLA_U32 },
7409 [NL80211_ATTR_CQM_TXE_PKTS] = { .type = NLA_U32 },
7410 [NL80211_ATTR_CQM_TXE_INTVL] = { .type = NLA_U32 },
7411 };
7412
7413 static int nl80211_set_cqm_txe(struct genl_info *info,
7414 u32 rate, u32 pkts, u32 intvl)
7415 {
7416 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7417 struct wireless_dev *wdev;
7418 struct net_device *dev = info->user_ptr[1];
7419
7420 if (rate > 100 || intvl > NL80211_CQM_TXE_MAX_INTVL)
7421 return -EINVAL;
7422
7423 wdev = dev->ieee80211_ptr;
7424
7425 if (!rdev->ops->set_cqm_txe_config)
7426 return -EOPNOTSUPP;
7427
7428 if (wdev->iftype != NL80211_IFTYPE_STATION &&
7429 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
7430 return -EOPNOTSUPP;
7431
7432 return rdev_set_cqm_txe_config(rdev, dev, rate, pkts, intvl);
7433 }
7434
7435 static int nl80211_set_cqm_rssi(struct genl_info *info,
7436 s32 threshold, u32 hysteresis)
7437 {
7438 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7439 struct wireless_dev *wdev;
7440 struct net_device *dev = info->user_ptr[1];
7441
7442 if (threshold > 0)
7443 return -EINVAL;
7444
7445 wdev = dev->ieee80211_ptr;
7446
7447 if (!rdev->ops->set_cqm_rssi_config)
7448 return -EOPNOTSUPP;
7449
7450 if (wdev->iftype != NL80211_IFTYPE_STATION &&
7451 wdev->iftype != NL80211_IFTYPE_P2P_CLIENT)
7452 return -EOPNOTSUPP;
7453
7454 return rdev_set_cqm_rssi_config(rdev, dev, threshold, hysteresis);
7455 }
7456
7457 static int nl80211_set_cqm(struct sk_buff *skb, struct genl_info *info)
7458 {
7459 struct nlattr *attrs[NL80211_ATTR_CQM_MAX + 1];
7460 struct nlattr *cqm;
7461 int err;
7462
7463 cqm = info->attrs[NL80211_ATTR_CQM];
7464 if (!cqm) {
7465 err = -EINVAL;
7466 goto out;
7467 }
7468
7469 err = nla_parse_nested(attrs, NL80211_ATTR_CQM_MAX, cqm,
7470 nl80211_attr_cqm_policy);
7471 if (err)
7472 goto out;
7473
7474 if (attrs[NL80211_ATTR_CQM_RSSI_THOLD] &&
7475 attrs[NL80211_ATTR_CQM_RSSI_HYST]) {
7476 s32 threshold;
7477 u32 hysteresis;
7478 threshold = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_THOLD]);
7479 hysteresis = nla_get_u32(attrs[NL80211_ATTR_CQM_RSSI_HYST]);
7480 err = nl80211_set_cqm_rssi(info, threshold, hysteresis);
7481 } else if (attrs[NL80211_ATTR_CQM_TXE_RATE] &&
7482 attrs[NL80211_ATTR_CQM_TXE_PKTS] &&
7483 attrs[NL80211_ATTR_CQM_TXE_INTVL]) {
7484 u32 rate, pkts, intvl;
7485 rate = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_RATE]);
7486 pkts = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_PKTS]);
7487 intvl = nla_get_u32(attrs[NL80211_ATTR_CQM_TXE_INTVL]);
7488 err = nl80211_set_cqm_txe(info, rate, pkts, intvl);
7489 } else
7490 err = -EINVAL;
7491
7492 out:
7493 return err;
7494 }
7495
7496 static int nl80211_join_mesh(struct sk_buff *skb, struct genl_info *info)
7497 {
7498 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7499 struct net_device *dev = info->user_ptr[1];
7500 struct mesh_config cfg;
7501 struct mesh_setup setup;
7502 int err;
7503
7504 /* start with default */
7505 memcpy(&cfg, &default_mesh_config, sizeof(cfg));
7506 memcpy(&setup, &default_mesh_setup, sizeof(setup));
7507
7508 if (info->attrs[NL80211_ATTR_MESH_CONFIG]) {
7509 /* and parse parameters if given */
7510 err = nl80211_parse_mesh_config(info, &cfg, NULL);
7511 if (err)
7512 return err;
7513 }
7514
7515 if (!info->attrs[NL80211_ATTR_MESH_ID] ||
7516 !nla_len(info->attrs[NL80211_ATTR_MESH_ID]))
7517 return -EINVAL;
7518
7519 setup.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
7520 setup.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
7521
7522 if (info->attrs[NL80211_ATTR_MCAST_RATE] &&
7523 !nl80211_parse_mcast_rate(rdev, setup.mcast_rate,
7524 nla_get_u32(info->attrs[NL80211_ATTR_MCAST_RATE])))
7525 return -EINVAL;
7526
7527 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
7528 setup.beacon_interval =
7529 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
7530 if (setup.beacon_interval < 10 ||
7531 setup.beacon_interval > 10000)
7532 return -EINVAL;
7533 }
7534
7535 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
7536 setup.dtim_period =
7537 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
7538 if (setup.dtim_period < 1 || setup.dtim_period > 100)
7539 return -EINVAL;
7540 }
7541
7542 if (info->attrs[NL80211_ATTR_MESH_SETUP]) {
7543 /* parse additional setup parameters if given */
7544 err = nl80211_parse_mesh_setup(info, &setup);
7545 if (err)
7546 return err;
7547 }
7548
7549 if (setup.user_mpm)
7550 cfg.auto_open_plinks = false;
7551
7552 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
7553 err = nl80211_parse_chandef(rdev, info, &setup.chandef);
7554 if (err)
7555 return err;
7556 } else {
7557 /* cfg80211_join_mesh() will sort it out */
7558 setup.chandef.chan = NULL;
7559 }
7560
7561 return cfg80211_join_mesh(rdev, dev, &setup, &cfg);
7562 }
7563
7564 static int nl80211_leave_mesh(struct sk_buff *skb, struct genl_info *info)
7565 {
7566 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7567 struct net_device *dev = info->user_ptr[1];
7568
7569 return cfg80211_leave_mesh(rdev, dev);
7570 }
7571
7572 #ifdef CONFIG_PM
7573 static int nl80211_send_wowlan_patterns(struct sk_buff *msg,
7574 struct cfg80211_registered_device *rdev)
7575 {
7576 struct nlattr *nl_pats, *nl_pat;
7577 int i, pat_len;
7578
7579 if (!rdev->wowlan->n_patterns)
7580 return 0;
7581
7582 nl_pats = nla_nest_start(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN);
7583 if (!nl_pats)
7584 return -ENOBUFS;
7585
7586 for (i = 0; i < rdev->wowlan->n_patterns; i++) {
7587 nl_pat = nla_nest_start(msg, i + 1);
7588 if (!nl_pat)
7589 return -ENOBUFS;
7590 pat_len = rdev->wowlan->patterns[i].pattern_len;
7591 if (nla_put(msg, NL80211_WOWLAN_PKTPAT_MASK,
7592 DIV_ROUND_UP(pat_len, 8),
7593 rdev->wowlan->patterns[i].mask) ||
7594 nla_put(msg, NL80211_WOWLAN_PKTPAT_PATTERN,
7595 pat_len, rdev->wowlan->patterns[i].pattern) ||
7596 nla_put_u32(msg, NL80211_WOWLAN_PKTPAT_OFFSET,
7597 rdev->wowlan->patterns[i].pkt_offset))
7598 return -ENOBUFS;
7599 nla_nest_end(msg, nl_pat);
7600 }
7601 nla_nest_end(msg, nl_pats);
7602
7603 return 0;
7604 }
7605
7606 static int nl80211_send_wowlan_tcp(struct sk_buff *msg,
7607 struct cfg80211_wowlan_tcp *tcp)
7608 {
7609 struct nlattr *nl_tcp;
7610
7611 if (!tcp)
7612 return 0;
7613
7614 nl_tcp = nla_nest_start(msg, NL80211_WOWLAN_TRIG_TCP_CONNECTION);
7615 if (!nl_tcp)
7616 return -ENOBUFS;
7617
7618 if (nla_put_be32(msg, NL80211_WOWLAN_TCP_SRC_IPV4, tcp->src) ||
7619 nla_put_be32(msg, NL80211_WOWLAN_TCP_DST_IPV4, tcp->dst) ||
7620 nla_put(msg, NL80211_WOWLAN_TCP_DST_MAC, ETH_ALEN, tcp->dst_mac) ||
7621 nla_put_u16(msg, NL80211_WOWLAN_TCP_SRC_PORT, tcp->src_port) ||
7622 nla_put_u16(msg, NL80211_WOWLAN_TCP_DST_PORT, tcp->dst_port) ||
7623 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD,
7624 tcp->payload_len, tcp->payload) ||
7625 nla_put_u32(msg, NL80211_WOWLAN_TCP_DATA_INTERVAL,
7626 tcp->data_interval) ||
7627 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_PAYLOAD,
7628 tcp->wake_len, tcp->wake_data) ||
7629 nla_put(msg, NL80211_WOWLAN_TCP_WAKE_MASK,
7630 DIV_ROUND_UP(tcp->wake_len, 8), tcp->wake_mask))
7631 return -ENOBUFS;
7632
7633 if (tcp->payload_seq.len &&
7634 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ,
7635 sizeof(tcp->payload_seq), &tcp->payload_seq))
7636 return -ENOBUFS;
7637
7638 if (tcp->payload_tok.len &&
7639 nla_put(msg, NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN,
7640 sizeof(tcp->payload_tok) + tcp->tokens_size,
7641 &tcp->payload_tok))
7642 return -ENOBUFS;
7643
7644 nla_nest_end(msg, nl_tcp);
7645
7646 return 0;
7647 }
7648
7649 static int nl80211_get_wowlan(struct sk_buff *skb, struct genl_info *info)
7650 {
7651 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7652 struct sk_buff *msg;
7653 void *hdr;
7654 u32 size = NLMSG_DEFAULT_SIZE;
7655
7656 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns &&
7657 !rdev->wiphy.wowlan.tcp)
7658 return -EOPNOTSUPP;
7659
7660 if (rdev->wowlan && rdev->wowlan->tcp) {
7661 /* adjust size to have room for all the data */
7662 size += rdev->wowlan->tcp->tokens_size +
7663 rdev->wowlan->tcp->payload_len +
7664 rdev->wowlan->tcp->wake_len +
7665 rdev->wowlan->tcp->wake_len / 8;
7666 }
7667
7668 msg = nlmsg_new(size, GFP_KERNEL);
7669 if (!msg)
7670 return -ENOMEM;
7671
7672 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
7673 NL80211_CMD_GET_WOWLAN);
7674 if (!hdr)
7675 goto nla_put_failure;
7676
7677 if (rdev->wowlan) {
7678 struct nlattr *nl_wowlan;
7679
7680 nl_wowlan = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
7681 if (!nl_wowlan)
7682 goto nla_put_failure;
7683
7684 if ((rdev->wowlan->any &&
7685 nla_put_flag(msg, NL80211_WOWLAN_TRIG_ANY)) ||
7686 (rdev->wowlan->disconnect &&
7687 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT)) ||
7688 (rdev->wowlan->magic_pkt &&
7689 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT)) ||
7690 (rdev->wowlan->gtk_rekey_failure &&
7691 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE)) ||
7692 (rdev->wowlan->eap_identity_req &&
7693 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST)) ||
7694 (rdev->wowlan->four_way_handshake &&
7695 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE)) ||
7696 (rdev->wowlan->rfkill_release &&
7697 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE)))
7698 goto nla_put_failure;
7699
7700 if (nl80211_send_wowlan_patterns(msg, rdev))
7701 goto nla_put_failure;
7702
7703 if (nl80211_send_wowlan_tcp(msg, rdev->wowlan->tcp))
7704 goto nla_put_failure;
7705
7706 nla_nest_end(msg, nl_wowlan);
7707 }
7708
7709 genlmsg_end(msg, hdr);
7710 return genlmsg_reply(msg, info);
7711
7712 nla_put_failure:
7713 nlmsg_free(msg);
7714 return -ENOBUFS;
7715 }
7716
7717 static int nl80211_parse_wowlan_tcp(struct cfg80211_registered_device *rdev,
7718 struct nlattr *attr,
7719 struct cfg80211_wowlan *trig)
7720 {
7721 struct nlattr *tb[NUM_NL80211_WOWLAN_TCP];
7722 struct cfg80211_wowlan_tcp *cfg;
7723 struct nl80211_wowlan_tcp_data_token *tok = NULL;
7724 struct nl80211_wowlan_tcp_data_seq *seq = NULL;
7725 u32 size;
7726 u32 data_size, wake_size, tokens_size = 0, wake_mask_size;
7727 int err, port;
7728
7729 if (!rdev->wiphy.wowlan.tcp)
7730 return -EINVAL;
7731
7732 err = nla_parse(tb, MAX_NL80211_WOWLAN_TCP,
7733 nla_data(attr), nla_len(attr),
7734 nl80211_wowlan_tcp_policy);
7735 if (err)
7736 return err;
7737
7738 if (!tb[NL80211_WOWLAN_TCP_SRC_IPV4] ||
7739 !tb[NL80211_WOWLAN_TCP_DST_IPV4] ||
7740 !tb[NL80211_WOWLAN_TCP_DST_MAC] ||
7741 !tb[NL80211_WOWLAN_TCP_DST_PORT] ||
7742 !tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD] ||
7743 !tb[NL80211_WOWLAN_TCP_DATA_INTERVAL] ||
7744 !tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD] ||
7745 !tb[NL80211_WOWLAN_TCP_WAKE_MASK])
7746 return -EINVAL;
7747
7748 data_size = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]);
7749 if (data_size > rdev->wiphy.wowlan.tcp->data_payload_max)
7750 return -EINVAL;
7751
7752 if (nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) >
7753 rdev->wiphy.wowlan.tcp->data_interval_max ||
7754 nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]) == 0)
7755 return -EINVAL;
7756
7757 wake_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]);
7758 if (wake_size > rdev->wiphy.wowlan.tcp->wake_payload_max)
7759 return -EINVAL;
7760
7761 wake_mask_size = nla_len(tb[NL80211_WOWLAN_TCP_WAKE_MASK]);
7762 if (wake_mask_size != DIV_ROUND_UP(wake_size, 8))
7763 return -EINVAL;
7764
7765 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]) {
7766 u32 tokln = nla_len(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
7767
7768 tok = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_TOKEN]);
7769 tokens_size = tokln - sizeof(*tok);
7770
7771 if (!tok->len || tokens_size % tok->len)
7772 return -EINVAL;
7773 if (!rdev->wiphy.wowlan.tcp->tok)
7774 return -EINVAL;
7775 if (tok->len > rdev->wiphy.wowlan.tcp->tok->max_len)
7776 return -EINVAL;
7777 if (tok->len < rdev->wiphy.wowlan.tcp->tok->min_len)
7778 return -EINVAL;
7779 if (tokens_size > rdev->wiphy.wowlan.tcp->tok->bufsize)
7780 return -EINVAL;
7781 if (tok->offset + tok->len > data_size)
7782 return -EINVAL;
7783 }
7784
7785 if (tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]) {
7786 seq = nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD_SEQ]);
7787 if (!rdev->wiphy.wowlan.tcp->seq)
7788 return -EINVAL;
7789 if (seq->len == 0 || seq->len > 4)
7790 return -EINVAL;
7791 if (seq->len + seq->offset > data_size)
7792 return -EINVAL;
7793 }
7794
7795 size = sizeof(*cfg);
7796 size += data_size;
7797 size += wake_size + wake_mask_size;
7798 size += tokens_size;
7799
7800 cfg = kzalloc(size, GFP_KERNEL);
7801 if (!cfg)
7802 return -ENOMEM;
7803 cfg->src = nla_get_be32(tb[NL80211_WOWLAN_TCP_SRC_IPV4]);
7804 cfg->dst = nla_get_be32(tb[NL80211_WOWLAN_TCP_DST_IPV4]);
7805 memcpy(cfg->dst_mac, nla_data(tb[NL80211_WOWLAN_TCP_DST_MAC]),
7806 ETH_ALEN);
7807 if (tb[NL80211_WOWLAN_TCP_SRC_PORT])
7808 port = nla_get_u16(tb[NL80211_WOWLAN_TCP_SRC_PORT]);
7809 else
7810 port = 0;
7811 #ifdef CONFIG_INET
7812 /* allocate a socket and port for it and use it */
7813 err = __sock_create(wiphy_net(&rdev->wiphy), PF_INET, SOCK_STREAM,
7814 IPPROTO_TCP, &cfg->sock, 1);
7815 if (err) {
7816 kfree(cfg);
7817 return err;
7818 }
7819 if (inet_csk_get_port(cfg->sock->sk, port)) {
7820 sock_release(cfg->sock);
7821 kfree(cfg);
7822 return -EADDRINUSE;
7823 }
7824 cfg->src_port = inet_sk(cfg->sock->sk)->inet_num;
7825 #else
7826 if (!port) {
7827 kfree(cfg);
7828 return -EINVAL;
7829 }
7830 cfg->src_port = port;
7831 #endif
7832
7833 cfg->dst_port = nla_get_u16(tb[NL80211_WOWLAN_TCP_DST_PORT]);
7834 cfg->payload_len = data_size;
7835 cfg->payload = (u8 *)cfg + sizeof(*cfg) + tokens_size;
7836 memcpy((void *)cfg->payload,
7837 nla_data(tb[NL80211_WOWLAN_TCP_DATA_PAYLOAD]),
7838 data_size);
7839 if (seq)
7840 cfg->payload_seq = *seq;
7841 cfg->data_interval = nla_get_u32(tb[NL80211_WOWLAN_TCP_DATA_INTERVAL]);
7842 cfg->wake_len = wake_size;
7843 cfg->wake_data = (u8 *)cfg + sizeof(*cfg) + tokens_size + data_size;
7844 memcpy((void *)cfg->wake_data,
7845 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_PAYLOAD]),
7846 wake_size);
7847 cfg->wake_mask = (u8 *)cfg + sizeof(*cfg) + tokens_size +
7848 data_size + wake_size;
7849 memcpy((void *)cfg->wake_mask,
7850 nla_data(tb[NL80211_WOWLAN_TCP_WAKE_MASK]),
7851 wake_mask_size);
7852 if (tok) {
7853 cfg->tokens_size = tokens_size;
7854 memcpy(&cfg->payload_tok, tok, sizeof(*tok) + tokens_size);
7855 }
7856
7857 trig->tcp = cfg;
7858
7859 return 0;
7860 }
7861
7862 static int nl80211_set_wowlan(struct sk_buff *skb, struct genl_info *info)
7863 {
7864 struct cfg80211_registered_device *rdev = info->user_ptr[0];
7865 struct nlattr *tb[NUM_NL80211_WOWLAN_TRIG];
7866 struct cfg80211_wowlan new_triggers = {};
7867 struct cfg80211_wowlan *ntrig;
7868 struct wiphy_wowlan_support *wowlan = &rdev->wiphy.wowlan;
7869 int err, i;
7870 bool prev_enabled = rdev->wowlan;
7871
7872 if (!rdev->wiphy.wowlan.flags && !rdev->wiphy.wowlan.n_patterns &&
7873 !rdev->wiphy.wowlan.tcp)
7874 return -EOPNOTSUPP;
7875
7876 if (!info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]) {
7877 cfg80211_rdev_free_wowlan(rdev);
7878 rdev->wowlan = NULL;
7879 goto set_wakeup;
7880 }
7881
7882 err = nla_parse(tb, MAX_NL80211_WOWLAN_TRIG,
7883 nla_data(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
7884 nla_len(info->attrs[NL80211_ATTR_WOWLAN_TRIGGERS]),
7885 nl80211_wowlan_policy);
7886 if (err)
7887 return err;
7888
7889 if (tb[NL80211_WOWLAN_TRIG_ANY]) {
7890 if (!(wowlan->flags & WIPHY_WOWLAN_ANY))
7891 return -EINVAL;
7892 new_triggers.any = true;
7893 }
7894
7895 if (tb[NL80211_WOWLAN_TRIG_DISCONNECT]) {
7896 if (!(wowlan->flags & WIPHY_WOWLAN_DISCONNECT))
7897 return -EINVAL;
7898 new_triggers.disconnect = true;
7899 }
7900
7901 if (tb[NL80211_WOWLAN_TRIG_MAGIC_PKT]) {
7902 if (!(wowlan->flags & WIPHY_WOWLAN_MAGIC_PKT))
7903 return -EINVAL;
7904 new_triggers.magic_pkt = true;
7905 }
7906
7907 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_SUPPORTED])
7908 return -EINVAL;
7909
7910 if (tb[NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE]) {
7911 if (!(wowlan->flags & WIPHY_WOWLAN_GTK_REKEY_FAILURE))
7912 return -EINVAL;
7913 new_triggers.gtk_rekey_failure = true;
7914 }
7915
7916 if (tb[NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST]) {
7917 if (!(wowlan->flags & WIPHY_WOWLAN_EAP_IDENTITY_REQ))
7918 return -EINVAL;
7919 new_triggers.eap_identity_req = true;
7920 }
7921
7922 if (tb[NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE]) {
7923 if (!(wowlan->flags & WIPHY_WOWLAN_4WAY_HANDSHAKE))
7924 return -EINVAL;
7925 new_triggers.four_way_handshake = true;
7926 }
7927
7928 if (tb[NL80211_WOWLAN_TRIG_RFKILL_RELEASE]) {
7929 if (!(wowlan->flags & WIPHY_WOWLAN_RFKILL_RELEASE))
7930 return -EINVAL;
7931 new_triggers.rfkill_release = true;
7932 }
7933
7934 if (tb[NL80211_WOWLAN_TRIG_PKT_PATTERN]) {
7935 struct nlattr *pat;
7936 int n_patterns = 0;
7937 int rem, pat_len, mask_len, pkt_offset;
7938 struct nlattr *pat_tb[NUM_NL80211_WOWLAN_PKTPAT];
7939
7940 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
7941 rem)
7942 n_patterns++;
7943 if (n_patterns > wowlan->n_patterns)
7944 return -EINVAL;
7945
7946 new_triggers.patterns = kcalloc(n_patterns,
7947 sizeof(new_triggers.patterns[0]),
7948 GFP_KERNEL);
7949 if (!new_triggers.patterns)
7950 return -ENOMEM;
7951
7952 new_triggers.n_patterns = n_patterns;
7953 i = 0;
7954
7955 nla_for_each_nested(pat, tb[NL80211_WOWLAN_TRIG_PKT_PATTERN],
7956 rem) {
7957 nla_parse(pat_tb, MAX_NL80211_WOWLAN_PKTPAT,
7958 nla_data(pat), nla_len(pat), NULL);
7959 err = -EINVAL;
7960 if (!pat_tb[NL80211_WOWLAN_PKTPAT_MASK] ||
7961 !pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN])
7962 goto error;
7963 pat_len = nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]);
7964 mask_len = DIV_ROUND_UP(pat_len, 8);
7965 if (nla_len(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]) !=
7966 mask_len)
7967 goto error;
7968 if (pat_len > wowlan->pattern_max_len ||
7969 pat_len < wowlan->pattern_min_len)
7970 goto error;
7971
7972 if (!pat_tb[NL80211_WOWLAN_PKTPAT_OFFSET])
7973 pkt_offset = 0;
7974 else
7975 pkt_offset = nla_get_u32(
7976 pat_tb[NL80211_WOWLAN_PKTPAT_OFFSET]);
7977 if (pkt_offset > wowlan->max_pkt_offset)
7978 goto error;
7979 new_triggers.patterns[i].pkt_offset = pkt_offset;
7980
7981 new_triggers.patterns[i].mask =
7982 kmalloc(mask_len + pat_len, GFP_KERNEL);
7983 if (!new_triggers.patterns[i].mask) {
7984 err = -ENOMEM;
7985 goto error;
7986 }
7987 new_triggers.patterns[i].pattern =
7988 new_triggers.patterns[i].mask + mask_len;
7989 memcpy(new_triggers.patterns[i].mask,
7990 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_MASK]),
7991 mask_len);
7992 new_triggers.patterns[i].pattern_len = pat_len;
7993 memcpy(new_triggers.patterns[i].pattern,
7994 nla_data(pat_tb[NL80211_WOWLAN_PKTPAT_PATTERN]),
7995 pat_len);
7996 i++;
7997 }
7998 }
7999
8000 if (tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION]) {
8001 err = nl80211_parse_wowlan_tcp(
8002 rdev, tb[NL80211_WOWLAN_TRIG_TCP_CONNECTION],
8003 &new_triggers);
8004 if (err)
8005 goto error;
8006 }
8007
8008 ntrig = kmemdup(&new_triggers, sizeof(new_triggers), GFP_KERNEL);
8009 if (!ntrig) {
8010 err = -ENOMEM;
8011 goto error;
8012 }
8013 cfg80211_rdev_free_wowlan(rdev);
8014 rdev->wowlan = ntrig;
8015
8016 set_wakeup:
8017 if (rdev->ops->set_wakeup && prev_enabled != !!rdev->wowlan)
8018 rdev_set_wakeup(rdev, rdev->wowlan);
8019
8020 return 0;
8021 error:
8022 for (i = 0; i < new_triggers.n_patterns; i++)
8023 kfree(new_triggers.patterns[i].mask);
8024 kfree(new_triggers.patterns);
8025 if (new_triggers.tcp && new_triggers.tcp->sock)
8026 sock_release(new_triggers.tcp->sock);
8027 kfree(new_triggers.tcp);
8028 return err;
8029 }
8030 #endif
8031
8032 static int nl80211_set_rekey_data(struct sk_buff *skb, struct genl_info *info)
8033 {
8034 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8035 struct net_device *dev = info->user_ptr[1];
8036 struct wireless_dev *wdev = dev->ieee80211_ptr;
8037 struct nlattr *tb[NUM_NL80211_REKEY_DATA];
8038 struct cfg80211_gtk_rekey_data rekey_data;
8039 int err;
8040
8041 if (!info->attrs[NL80211_ATTR_REKEY_DATA])
8042 return -EINVAL;
8043
8044 err = nla_parse(tb, MAX_NL80211_REKEY_DATA,
8045 nla_data(info->attrs[NL80211_ATTR_REKEY_DATA]),
8046 nla_len(info->attrs[NL80211_ATTR_REKEY_DATA]),
8047 nl80211_rekey_policy);
8048 if (err)
8049 return err;
8050
8051 if (nla_len(tb[NL80211_REKEY_DATA_REPLAY_CTR]) != NL80211_REPLAY_CTR_LEN)
8052 return -ERANGE;
8053 if (nla_len(tb[NL80211_REKEY_DATA_KEK]) != NL80211_KEK_LEN)
8054 return -ERANGE;
8055 if (nla_len(tb[NL80211_REKEY_DATA_KCK]) != NL80211_KCK_LEN)
8056 return -ERANGE;
8057
8058 memcpy(rekey_data.kek, nla_data(tb[NL80211_REKEY_DATA_KEK]),
8059 NL80211_KEK_LEN);
8060 memcpy(rekey_data.kck, nla_data(tb[NL80211_REKEY_DATA_KCK]),
8061 NL80211_KCK_LEN);
8062 memcpy(rekey_data.replay_ctr,
8063 nla_data(tb[NL80211_REKEY_DATA_REPLAY_CTR]),
8064 NL80211_REPLAY_CTR_LEN);
8065
8066 wdev_lock(wdev);
8067 if (!wdev->current_bss) {
8068 err = -ENOTCONN;
8069 goto out;
8070 }
8071
8072 if (!rdev->ops->set_rekey_data) {
8073 err = -EOPNOTSUPP;
8074 goto out;
8075 }
8076
8077 err = rdev_set_rekey_data(rdev, dev, &rekey_data);
8078 out:
8079 wdev_unlock(wdev);
8080 return err;
8081 }
8082
8083 static int nl80211_register_unexpected_frame(struct sk_buff *skb,
8084 struct genl_info *info)
8085 {
8086 struct net_device *dev = info->user_ptr[1];
8087 struct wireless_dev *wdev = dev->ieee80211_ptr;
8088
8089 if (wdev->iftype != NL80211_IFTYPE_AP &&
8090 wdev->iftype != NL80211_IFTYPE_P2P_GO)
8091 return -EINVAL;
8092
8093 if (wdev->ap_unexpected_nlportid)
8094 return -EBUSY;
8095
8096 wdev->ap_unexpected_nlportid = info->snd_portid;
8097 return 0;
8098 }
8099
8100 static int nl80211_probe_client(struct sk_buff *skb,
8101 struct genl_info *info)
8102 {
8103 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8104 struct net_device *dev = info->user_ptr[1];
8105 struct wireless_dev *wdev = dev->ieee80211_ptr;
8106 struct sk_buff *msg;
8107 void *hdr;
8108 const u8 *addr;
8109 u64 cookie;
8110 int err;
8111
8112 if (wdev->iftype != NL80211_IFTYPE_AP &&
8113 wdev->iftype != NL80211_IFTYPE_P2P_GO)
8114 return -EOPNOTSUPP;
8115
8116 if (!info->attrs[NL80211_ATTR_MAC])
8117 return -EINVAL;
8118
8119 if (!rdev->ops->probe_client)
8120 return -EOPNOTSUPP;
8121
8122 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8123 if (!msg)
8124 return -ENOMEM;
8125
8126 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8127 NL80211_CMD_PROBE_CLIENT);
8128 if (!hdr) {
8129 err = -ENOBUFS;
8130 goto free_msg;
8131 }
8132
8133 addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
8134
8135 err = rdev_probe_client(rdev, dev, addr, &cookie);
8136 if (err)
8137 goto free_msg;
8138
8139 if (nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
8140 goto nla_put_failure;
8141
8142 genlmsg_end(msg, hdr);
8143
8144 return genlmsg_reply(msg, info);
8145
8146 nla_put_failure:
8147 err = -ENOBUFS;
8148 free_msg:
8149 nlmsg_free(msg);
8150 return err;
8151 }
8152
8153 static int nl80211_register_beacons(struct sk_buff *skb, struct genl_info *info)
8154 {
8155 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8156 struct cfg80211_beacon_registration *reg, *nreg;
8157 int rv;
8158
8159 if (!(rdev->wiphy.flags & WIPHY_FLAG_REPORTS_OBSS))
8160 return -EOPNOTSUPP;
8161
8162 nreg = kzalloc(sizeof(*nreg), GFP_KERNEL);
8163 if (!nreg)
8164 return -ENOMEM;
8165
8166 /* First, check if already registered. */
8167 spin_lock_bh(&rdev->beacon_registrations_lock);
8168 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
8169 if (reg->nlportid == info->snd_portid) {
8170 rv = -EALREADY;
8171 goto out_err;
8172 }
8173 }
8174 /* Add it to the list */
8175 nreg->nlportid = info->snd_portid;
8176 list_add(&nreg->list, &rdev->beacon_registrations);
8177
8178 spin_unlock_bh(&rdev->beacon_registrations_lock);
8179
8180 return 0;
8181 out_err:
8182 spin_unlock_bh(&rdev->beacon_registrations_lock);
8183 kfree(nreg);
8184 return rv;
8185 }
8186
8187 static int nl80211_start_p2p_device(struct sk_buff *skb, struct genl_info *info)
8188 {
8189 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8190 struct wireless_dev *wdev = info->user_ptr[1];
8191 int err;
8192
8193 if (!rdev->ops->start_p2p_device)
8194 return -EOPNOTSUPP;
8195
8196 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
8197 return -EOPNOTSUPP;
8198
8199 if (wdev->p2p_started)
8200 return 0;
8201
8202 mutex_lock(&rdev->devlist_mtx);
8203 err = cfg80211_can_add_interface(rdev, wdev->iftype);
8204 mutex_unlock(&rdev->devlist_mtx);
8205 if (err)
8206 return err;
8207
8208 err = rdev_start_p2p_device(rdev, wdev);
8209 if (err)
8210 return err;
8211
8212 wdev->p2p_started = true;
8213 mutex_lock(&rdev->devlist_mtx);
8214 rdev->opencount++;
8215 mutex_unlock(&rdev->devlist_mtx);
8216
8217 return 0;
8218 }
8219
8220 static int nl80211_stop_p2p_device(struct sk_buff *skb, struct genl_info *info)
8221 {
8222 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8223 struct wireless_dev *wdev = info->user_ptr[1];
8224
8225 if (wdev->iftype != NL80211_IFTYPE_P2P_DEVICE)
8226 return -EOPNOTSUPP;
8227
8228 if (!rdev->ops->stop_p2p_device)
8229 return -EOPNOTSUPP;
8230
8231 mutex_lock(&rdev->devlist_mtx);
8232 mutex_lock(&rdev->sched_scan_mtx);
8233 cfg80211_stop_p2p_device(rdev, wdev);
8234 mutex_unlock(&rdev->sched_scan_mtx);
8235 mutex_unlock(&rdev->devlist_mtx);
8236
8237 return 0;
8238 }
8239
8240 static int nl80211_get_protocol_features(struct sk_buff *skb,
8241 struct genl_info *info)
8242 {
8243 void *hdr;
8244 struct sk_buff *msg;
8245
8246 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
8247 if (!msg)
8248 return -ENOMEM;
8249
8250 hdr = nl80211hdr_put(msg, info->snd_portid, info->snd_seq, 0,
8251 NL80211_CMD_GET_PROTOCOL_FEATURES);
8252 if (!hdr)
8253 goto nla_put_failure;
8254
8255 if (nla_put_u32(msg, NL80211_ATTR_PROTOCOL_FEATURES,
8256 NL80211_PROTOCOL_FEATURE_SPLIT_WIPHY_DUMP))
8257 goto nla_put_failure;
8258
8259 genlmsg_end(msg, hdr);
8260 return genlmsg_reply(msg, info);
8261
8262 nla_put_failure:
8263 kfree_skb(msg);
8264 return -ENOBUFS;
8265 }
8266
8267 static int nl80211_update_ft_ies(struct sk_buff *skb, struct genl_info *info)
8268 {
8269 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8270 struct cfg80211_update_ft_ies_params ft_params;
8271 struct net_device *dev = info->user_ptr[1];
8272
8273 if (!rdev->ops->update_ft_ies)
8274 return -EOPNOTSUPP;
8275
8276 if (!info->attrs[NL80211_ATTR_MDID] ||
8277 !is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
8278 return -EINVAL;
8279
8280 memset(&ft_params, 0, sizeof(ft_params));
8281 ft_params.md = nla_get_u16(info->attrs[NL80211_ATTR_MDID]);
8282 ft_params.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
8283 ft_params.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
8284
8285 return rdev_update_ft_ies(rdev, dev, &ft_params);
8286 }
8287
8288 static int nl80211_crit_protocol_start(struct sk_buff *skb,
8289 struct genl_info *info)
8290 {
8291 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8292 struct wireless_dev *wdev = info->user_ptr[1];
8293 enum nl80211_crit_proto_id proto = NL80211_CRIT_PROTO_UNSPEC;
8294 u16 duration;
8295 int ret;
8296
8297 if (!rdev->ops->crit_proto_start)
8298 return -EOPNOTSUPP;
8299
8300 if (WARN_ON(!rdev->ops->crit_proto_stop))
8301 return -EINVAL;
8302
8303 if (rdev->crit_proto_nlportid)
8304 return -EBUSY;
8305
8306 /* determine protocol if provided */
8307 if (info->attrs[NL80211_ATTR_CRIT_PROT_ID])
8308 proto = nla_get_u16(info->attrs[NL80211_ATTR_CRIT_PROT_ID]);
8309
8310 if (proto >= NUM_NL80211_CRIT_PROTO)
8311 return -EINVAL;
8312
8313 /* timeout must be provided */
8314 if (!info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION])
8315 return -EINVAL;
8316
8317 duration =
8318 nla_get_u16(info->attrs[NL80211_ATTR_MAX_CRIT_PROT_DURATION]);
8319
8320 if (duration > NL80211_CRIT_PROTO_MAX_DURATION)
8321 return -ERANGE;
8322
8323 ret = rdev_crit_proto_start(rdev, wdev, proto, duration);
8324 if (!ret)
8325 rdev->crit_proto_nlportid = info->snd_portid;
8326
8327 return ret;
8328 }
8329
8330 static int nl80211_crit_protocol_stop(struct sk_buff *skb,
8331 struct genl_info *info)
8332 {
8333 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8334 struct wireless_dev *wdev = info->user_ptr[1];
8335
8336 if (!rdev->ops->crit_proto_stop)
8337 return -EOPNOTSUPP;
8338
8339 if (rdev->crit_proto_nlportid) {
8340 rdev->crit_proto_nlportid = 0;
8341 rdev_crit_proto_stop(rdev, wdev);
8342 }
8343 return 0;
8344 }
8345
8346 static int nl80211_vendor_cmd(struct sk_buff *skb, struct genl_info *info)
8347 {
8348 struct cfg80211_registered_device *rdev = info->user_ptr[0];
8349 struct wireless_dev *wdev =
8350 __cfg80211_wdev_from_attrs(genl_info_net(info), info->attrs);
8351 int i, err;
8352 u32 vid, subcmd;
8353
8354 if (!rdev || !rdev->wiphy.vendor_commands)
8355 return -EOPNOTSUPP;
8356
8357 if (IS_ERR(wdev)) {
8358 err = PTR_ERR(wdev);
8359 if (err != -EINVAL)
8360 return err;
8361 wdev = NULL;
8362 } else if (wdev->wiphy != &rdev->wiphy) {
8363 return -EINVAL;
8364 }
8365
8366 if (!info->attrs[NL80211_ATTR_VENDOR_ID] ||
8367 !info->attrs[NL80211_ATTR_VENDOR_SUBCMD])
8368 return -EINVAL;
8369
8370 vid = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_ID]);
8371 subcmd = nla_get_u32(info->attrs[NL80211_ATTR_VENDOR_SUBCMD]);
8372 for (i = 0; i < rdev->wiphy.n_vendor_commands; i++) {
8373 const struct wiphy_vendor_command *vcmd;
8374 void *data = NULL;
8375 int len = 0;
8376
8377 vcmd = &rdev->wiphy.vendor_commands[i];
8378
8379 if (vcmd->info.vendor_id != vid || vcmd->info.subcmd != subcmd)
8380 continue;
8381
8382 if (vcmd->flags & (WIPHY_VENDOR_CMD_NEED_WDEV |
8383 WIPHY_VENDOR_CMD_NEED_NETDEV)) {
8384 if (!wdev)
8385 return -EINVAL;
8386 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_NETDEV &&
8387 !wdev->netdev)
8388 return -EINVAL;
8389
8390 if (vcmd->flags & WIPHY_VENDOR_CMD_NEED_RUNNING) {
8391 if (!wdev->netdev ||
8392 !netif_running(wdev->netdev))
8393 return -ENETDOWN;
8394 }
8395 } else {
8396 wdev = NULL;
8397 }
8398
8399 if (info->attrs[NL80211_ATTR_VENDOR_DATA]) {
8400 data = nla_data(info->attrs[NL80211_ATTR_VENDOR_DATA]);
8401 len = nla_len(info->attrs[NL80211_ATTR_VENDOR_DATA]);
8402 }
8403
8404 rdev->cur_cmd_info = info;
8405 err = rdev->wiphy.vendor_commands[i].doit(&rdev->wiphy, wdev,
8406 data, len);
8407 rdev->cur_cmd_info = NULL;
8408 return err;
8409 }
8410
8411 return -EOPNOTSUPP;
8412 }
8413
8414 struct sk_buff *__cfg80211_alloc_reply_skb(struct wiphy *wiphy,
8415 enum nl80211_commands cmd,
8416 enum nl80211_attrs attr,
8417 int approxlen)
8418 {
8419 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
8420
8421 if (WARN_ON(!rdev->cur_cmd_info))
8422 return NULL;
8423
8424 return __cfg80211_alloc_vendor_skb(rdev, approxlen,
8425 0,
8426 0,
8427 cmd, attr, NULL, GFP_KERNEL);
8428 }
8429 EXPORT_SYMBOL(__cfg80211_alloc_reply_skb);
8430
8431 int cfg80211_vendor_cmd_reply(struct sk_buff *skb)
8432 {
8433 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
8434 void *hdr = ((void **)skb->cb)[1];
8435 struct nlattr *data = ((void **)skb->cb)[2];
8436
8437 if (WARN_ON(!rdev->cur_cmd_info)) {
8438 kfree_skb(skb);
8439 return -EINVAL;
8440 }
8441
8442 nla_nest_end(skb, data);
8443 genlmsg_end(skb, hdr);
8444 return genlmsg_reply(skb, rdev->cur_cmd_info);
8445 }
8446 EXPORT_SYMBOL(cfg80211_vendor_cmd_reply);
8447
8448 #define NL80211_FLAG_NEED_WIPHY 0x01
8449 #define NL80211_FLAG_NEED_NETDEV 0x02
8450 #define NL80211_FLAG_NEED_RTNL 0x04
8451 #define NL80211_FLAG_CHECK_NETDEV_UP 0x08
8452 #define NL80211_FLAG_NEED_NETDEV_UP (NL80211_FLAG_NEED_NETDEV |\
8453 NL80211_FLAG_CHECK_NETDEV_UP)
8454 #define NL80211_FLAG_NEED_WDEV 0x10
8455 /* If a netdev is associated, it must be UP, P2P must be started */
8456 #define NL80211_FLAG_NEED_WDEV_UP (NL80211_FLAG_NEED_WDEV |\
8457 NL80211_FLAG_CHECK_NETDEV_UP)
8458
8459 static int nl80211_pre_doit(struct genl_ops *ops, struct sk_buff *skb,
8460 struct genl_info *info)
8461 {
8462 struct cfg80211_registered_device *rdev;
8463 struct wireless_dev *wdev;
8464 struct net_device *dev;
8465 bool rtnl = ops->internal_flags & NL80211_FLAG_NEED_RTNL;
8466
8467 if (rtnl)
8468 rtnl_lock();
8469
8470 if (ops->internal_flags & NL80211_FLAG_NEED_WIPHY) {
8471 rdev = cfg80211_get_dev_from_info(genl_info_net(info), info);
8472 if (IS_ERR(rdev)) {
8473 if (rtnl)
8474 rtnl_unlock();
8475 return PTR_ERR(rdev);
8476 }
8477 info->user_ptr[0] = rdev;
8478 } else if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV ||
8479 ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
8480 mutex_lock(&cfg80211_mutex);
8481 wdev = __cfg80211_wdev_from_attrs(genl_info_net(info),
8482 info->attrs);
8483 if (IS_ERR(wdev)) {
8484 mutex_unlock(&cfg80211_mutex);
8485 if (rtnl)
8486 rtnl_unlock();
8487 return PTR_ERR(wdev);
8488 }
8489
8490 dev = wdev->netdev;
8491 rdev = wiphy_to_dev(wdev->wiphy);
8492
8493 if (ops->internal_flags & NL80211_FLAG_NEED_NETDEV) {
8494 if (!dev) {
8495 mutex_unlock(&cfg80211_mutex);
8496 if (rtnl)
8497 rtnl_unlock();
8498 return -EINVAL;
8499 }
8500
8501 info->user_ptr[1] = dev;
8502 } else {
8503 info->user_ptr[1] = wdev;
8504 }
8505
8506 if (dev) {
8507 if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP &&
8508 !netif_running(dev)) {
8509 mutex_unlock(&cfg80211_mutex);
8510 if (rtnl)
8511 rtnl_unlock();
8512 return -ENETDOWN;
8513 }
8514
8515 dev_hold(dev);
8516 } else if (ops->internal_flags & NL80211_FLAG_CHECK_NETDEV_UP) {
8517 if (!wdev->p2p_started) {
8518 mutex_unlock(&cfg80211_mutex);
8519 if (rtnl)
8520 rtnl_unlock();
8521 return -ENETDOWN;
8522 }
8523 }
8524
8525 cfg80211_lock_rdev(rdev);
8526
8527 mutex_unlock(&cfg80211_mutex);
8528
8529 info->user_ptr[0] = rdev;
8530 }
8531
8532 return 0;
8533 }
8534
8535 static void nl80211_post_doit(struct genl_ops *ops, struct sk_buff *skb,
8536 struct genl_info *info)
8537 {
8538 if (info->user_ptr[0])
8539 cfg80211_unlock_rdev(info->user_ptr[0]);
8540 if (info->user_ptr[1]) {
8541 if (ops->internal_flags & NL80211_FLAG_NEED_WDEV) {
8542 struct wireless_dev *wdev = info->user_ptr[1];
8543
8544 if (wdev->netdev)
8545 dev_put(wdev->netdev);
8546 } else {
8547 dev_put(info->user_ptr[1]);
8548 }
8549 }
8550 if (ops->internal_flags & NL80211_FLAG_NEED_RTNL)
8551 rtnl_unlock();
8552 }
8553
8554 static struct genl_ops nl80211_ops[] = {
8555 {
8556 .cmd = NL80211_CMD_GET_WIPHY,
8557 .doit = nl80211_get_wiphy,
8558 .dumpit = nl80211_dump_wiphy,
8559 .policy = nl80211_policy,
8560 /* can be retrieved by unprivileged users */
8561 .internal_flags = NL80211_FLAG_NEED_WIPHY,
8562 },
8563 {
8564 .cmd = NL80211_CMD_SET_WIPHY,
8565 .doit = nl80211_set_wiphy,
8566 .policy = nl80211_policy,
8567 .flags = GENL_ADMIN_PERM,
8568 .internal_flags = NL80211_FLAG_NEED_RTNL,
8569 },
8570 {
8571 .cmd = NL80211_CMD_GET_INTERFACE,
8572 .doit = nl80211_get_interface,
8573 .dumpit = nl80211_dump_interface,
8574 .policy = nl80211_policy,
8575 /* can be retrieved by unprivileged users */
8576 .internal_flags = NL80211_FLAG_NEED_WDEV,
8577 },
8578 {
8579 .cmd = NL80211_CMD_SET_INTERFACE,
8580 .doit = nl80211_set_interface,
8581 .policy = nl80211_policy,
8582 .flags = GENL_ADMIN_PERM,
8583 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8584 NL80211_FLAG_NEED_RTNL,
8585 },
8586 {
8587 .cmd = NL80211_CMD_NEW_INTERFACE,
8588 .doit = nl80211_new_interface,
8589 .policy = nl80211_policy,
8590 .flags = GENL_ADMIN_PERM,
8591 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8592 NL80211_FLAG_NEED_RTNL,
8593 },
8594 {
8595 .cmd = NL80211_CMD_DEL_INTERFACE,
8596 .doit = nl80211_del_interface,
8597 .policy = nl80211_policy,
8598 .flags = GENL_ADMIN_PERM,
8599 .internal_flags = NL80211_FLAG_NEED_WDEV |
8600 NL80211_FLAG_NEED_RTNL,
8601 },
8602 {
8603 .cmd = NL80211_CMD_GET_KEY,
8604 .doit = nl80211_get_key,
8605 .policy = nl80211_policy,
8606 .flags = GENL_ADMIN_PERM,
8607 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8608 NL80211_FLAG_NEED_RTNL,
8609 },
8610 {
8611 .cmd = NL80211_CMD_SET_KEY,
8612 .doit = nl80211_set_key,
8613 .policy = nl80211_policy,
8614 .flags = GENL_ADMIN_PERM,
8615 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8616 NL80211_FLAG_NEED_RTNL,
8617 },
8618 {
8619 .cmd = NL80211_CMD_NEW_KEY,
8620 .doit = nl80211_new_key,
8621 .policy = nl80211_policy,
8622 .flags = GENL_ADMIN_PERM,
8623 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8624 NL80211_FLAG_NEED_RTNL,
8625 },
8626 {
8627 .cmd = NL80211_CMD_DEL_KEY,
8628 .doit = nl80211_del_key,
8629 .policy = nl80211_policy,
8630 .flags = GENL_ADMIN_PERM,
8631 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8632 NL80211_FLAG_NEED_RTNL,
8633 },
8634 {
8635 .cmd = NL80211_CMD_SET_BEACON,
8636 .policy = nl80211_policy,
8637 .flags = GENL_ADMIN_PERM,
8638 .doit = nl80211_set_beacon,
8639 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8640 NL80211_FLAG_NEED_RTNL,
8641 },
8642 {
8643 .cmd = NL80211_CMD_START_AP,
8644 .policy = nl80211_policy,
8645 .flags = GENL_ADMIN_PERM,
8646 .doit = nl80211_start_ap,
8647 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8648 NL80211_FLAG_NEED_RTNL,
8649 },
8650 {
8651 .cmd = NL80211_CMD_STOP_AP,
8652 .policy = nl80211_policy,
8653 .flags = GENL_ADMIN_PERM,
8654 .doit = nl80211_stop_ap,
8655 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8656 NL80211_FLAG_NEED_RTNL,
8657 },
8658 {
8659 .cmd = NL80211_CMD_GET_STATION,
8660 .doit = nl80211_get_station,
8661 .dumpit = nl80211_dump_station,
8662 .policy = nl80211_policy,
8663 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8664 NL80211_FLAG_NEED_RTNL,
8665 },
8666 {
8667 .cmd = NL80211_CMD_SET_STATION,
8668 .doit = nl80211_set_station,
8669 .policy = nl80211_policy,
8670 .flags = GENL_ADMIN_PERM,
8671 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8672 NL80211_FLAG_NEED_RTNL,
8673 },
8674 {
8675 .cmd = NL80211_CMD_NEW_STATION,
8676 .doit = nl80211_new_station,
8677 .policy = nl80211_policy,
8678 .flags = GENL_ADMIN_PERM,
8679 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8680 NL80211_FLAG_NEED_RTNL,
8681 },
8682 {
8683 .cmd = NL80211_CMD_DEL_STATION,
8684 .doit = nl80211_del_station,
8685 .policy = nl80211_policy,
8686 .flags = GENL_ADMIN_PERM,
8687 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8688 NL80211_FLAG_NEED_RTNL,
8689 },
8690 {
8691 .cmd = NL80211_CMD_GET_MPATH,
8692 .doit = nl80211_get_mpath,
8693 .dumpit = nl80211_dump_mpath,
8694 .policy = nl80211_policy,
8695 .flags = GENL_ADMIN_PERM,
8696 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8697 NL80211_FLAG_NEED_RTNL,
8698 },
8699 {
8700 .cmd = NL80211_CMD_SET_MPATH,
8701 .doit = nl80211_set_mpath,
8702 .policy = nl80211_policy,
8703 .flags = GENL_ADMIN_PERM,
8704 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8705 NL80211_FLAG_NEED_RTNL,
8706 },
8707 {
8708 .cmd = NL80211_CMD_NEW_MPATH,
8709 .doit = nl80211_new_mpath,
8710 .policy = nl80211_policy,
8711 .flags = GENL_ADMIN_PERM,
8712 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8713 NL80211_FLAG_NEED_RTNL,
8714 },
8715 {
8716 .cmd = NL80211_CMD_DEL_MPATH,
8717 .doit = nl80211_del_mpath,
8718 .policy = nl80211_policy,
8719 .flags = GENL_ADMIN_PERM,
8720 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8721 NL80211_FLAG_NEED_RTNL,
8722 },
8723 {
8724 .cmd = NL80211_CMD_SET_BSS,
8725 .doit = nl80211_set_bss,
8726 .policy = nl80211_policy,
8727 .flags = GENL_ADMIN_PERM,
8728 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8729 NL80211_FLAG_NEED_RTNL,
8730 },
8731 {
8732 .cmd = NL80211_CMD_GET_REG,
8733 .doit = nl80211_get_reg,
8734 .policy = nl80211_policy,
8735 /* can be retrieved by unprivileged users */
8736 },
8737 {
8738 .cmd = NL80211_CMD_SET_REG,
8739 .doit = nl80211_set_reg,
8740 .policy = nl80211_policy,
8741 .flags = GENL_ADMIN_PERM,
8742 },
8743 {
8744 .cmd = NL80211_CMD_REQ_SET_REG,
8745 .doit = nl80211_req_set_reg,
8746 .policy = nl80211_policy,
8747 .flags = GENL_ADMIN_PERM,
8748 },
8749 {
8750 .cmd = NL80211_CMD_GET_MESH_CONFIG,
8751 .doit = nl80211_get_mesh_config,
8752 .policy = nl80211_policy,
8753 /* can be retrieved by unprivileged users */
8754 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8755 NL80211_FLAG_NEED_RTNL,
8756 },
8757 {
8758 .cmd = NL80211_CMD_SET_MESH_CONFIG,
8759 .doit = nl80211_update_mesh_config,
8760 .policy = nl80211_policy,
8761 .flags = GENL_ADMIN_PERM,
8762 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8763 NL80211_FLAG_NEED_RTNL,
8764 },
8765 {
8766 .cmd = NL80211_CMD_TRIGGER_SCAN,
8767 .doit = nl80211_trigger_scan,
8768 .policy = nl80211_policy,
8769 .flags = GENL_ADMIN_PERM,
8770 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8771 NL80211_FLAG_NEED_RTNL,
8772 },
8773 {
8774 .cmd = NL80211_CMD_GET_SCAN,
8775 .policy = nl80211_policy,
8776 .dumpit = nl80211_dump_scan,
8777 },
8778 {
8779 .cmd = NL80211_CMD_START_SCHED_SCAN,
8780 .doit = nl80211_start_sched_scan,
8781 .policy = nl80211_policy,
8782 .flags = GENL_ADMIN_PERM,
8783 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8784 NL80211_FLAG_NEED_RTNL,
8785 },
8786 {
8787 .cmd = NL80211_CMD_STOP_SCHED_SCAN,
8788 .doit = nl80211_stop_sched_scan,
8789 .policy = nl80211_policy,
8790 .flags = GENL_ADMIN_PERM,
8791 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8792 NL80211_FLAG_NEED_RTNL,
8793 },
8794 {
8795 .cmd = NL80211_CMD_AUTHENTICATE,
8796 .doit = nl80211_authenticate,
8797 .policy = nl80211_policy,
8798 .flags = GENL_ADMIN_PERM,
8799 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8800 NL80211_FLAG_NEED_RTNL,
8801 },
8802 {
8803 .cmd = NL80211_CMD_ASSOCIATE,
8804 .doit = nl80211_associate,
8805 .policy = nl80211_policy,
8806 .flags = GENL_ADMIN_PERM,
8807 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8808 NL80211_FLAG_NEED_RTNL,
8809 },
8810 {
8811 .cmd = NL80211_CMD_DEAUTHENTICATE,
8812 .doit = nl80211_deauthenticate,
8813 .policy = nl80211_policy,
8814 .flags = GENL_ADMIN_PERM,
8815 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8816 NL80211_FLAG_NEED_RTNL,
8817 },
8818 {
8819 .cmd = NL80211_CMD_DISASSOCIATE,
8820 .doit = nl80211_disassociate,
8821 .policy = nl80211_policy,
8822 .flags = GENL_ADMIN_PERM,
8823 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8824 NL80211_FLAG_NEED_RTNL,
8825 },
8826 {
8827 .cmd = NL80211_CMD_JOIN_IBSS,
8828 .doit = nl80211_join_ibss,
8829 .policy = nl80211_policy,
8830 .flags = GENL_ADMIN_PERM,
8831 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8832 NL80211_FLAG_NEED_RTNL,
8833 },
8834 {
8835 .cmd = NL80211_CMD_LEAVE_IBSS,
8836 .doit = nl80211_leave_ibss,
8837 .policy = nl80211_policy,
8838 .flags = GENL_ADMIN_PERM,
8839 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8840 NL80211_FLAG_NEED_RTNL,
8841 },
8842 #ifdef CONFIG_NL80211_TESTMODE
8843 {
8844 .cmd = NL80211_CMD_TESTMODE,
8845 .doit = nl80211_testmode_do,
8846 .dumpit = nl80211_testmode_dump,
8847 .policy = nl80211_policy,
8848 .flags = GENL_ADMIN_PERM,
8849 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8850 NL80211_FLAG_NEED_RTNL,
8851 },
8852 #endif
8853 {
8854 .cmd = NL80211_CMD_CONNECT,
8855 .doit = nl80211_connect,
8856 .policy = nl80211_policy,
8857 .flags = GENL_ADMIN_PERM,
8858 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8859 NL80211_FLAG_NEED_RTNL,
8860 },
8861 {
8862 .cmd = NL80211_CMD_DISCONNECT,
8863 .doit = nl80211_disconnect,
8864 .policy = nl80211_policy,
8865 .flags = GENL_ADMIN_PERM,
8866 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8867 NL80211_FLAG_NEED_RTNL,
8868 },
8869 {
8870 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
8871 .doit = nl80211_wiphy_netns,
8872 .policy = nl80211_policy,
8873 .flags = GENL_ADMIN_PERM,
8874 .internal_flags = NL80211_FLAG_NEED_WIPHY |
8875 NL80211_FLAG_NEED_RTNL,
8876 },
8877 {
8878 .cmd = NL80211_CMD_GET_SURVEY,
8879 .policy = nl80211_policy,
8880 .dumpit = nl80211_dump_survey,
8881 },
8882 {
8883 .cmd = NL80211_CMD_SET_PMKSA,
8884 .doit = nl80211_setdel_pmksa,
8885 .policy = nl80211_policy,
8886 .flags = GENL_ADMIN_PERM,
8887 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8888 NL80211_FLAG_NEED_RTNL,
8889 },
8890 {
8891 .cmd = NL80211_CMD_DEL_PMKSA,
8892 .doit = nl80211_setdel_pmksa,
8893 .policy = nl80211_policy,
8894 .flags = GENL_ADMIN_PERM,
8895 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8896 NL80211_FLAG_NEED_RTNL,
8897 },
8898 {
8899 .cmd = NL80211_CMD_FLUSH_PMKSA,
8900 .doit = nl80211_flush_pmksa,
8901 .policy = nl80211_policy,
8902 .flags = GENL_ADMIN_PERM,
8903 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
8904 NL80211_FLAG_NEED_RTNL,
8905 },
8906 {
8907 .cmd = NL80211_CMD_REMAIN_ON_CHANNEL,
8908 .doit = nl80211_remain_on_channel,
8909 .policy = nl80211_policy,
8910 .flags = GENL_ADMIN_PERM,
8911 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8912 NL80211_FLAG_NEED_RTNL,
8913 },
8914 {
8915 .cmd = NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
8916 .doit = nl80211_cancel_remain_on_channel,
8917 .policy = nl80211_policy,
8918 .flags = GENL_ADMIN_PERM,
8919 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8920 NL80211_FLAG_NEED_RTNL,
8921 },
8922 {
8923 .cmd = NL80211_CMD_SET_TX_BITRATE_MASK,
8924 .doit = nl80211_set_tx_bitrate_mask,
8925 .policy = nl80211_policy,
8926 .flags = GENL_ADMIN_PERM,
8927 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8928 NL80211_FLAG_NEED_RTNL,
8929 },
8930 {
8931 .cmd = NL80211_CMD_REGISTER_FRAME,
8932 .doit = nl80211_register_mgmt,
8933 .policy = nl80211_policy,
8934 .flags = GENL_ADMIN_PERM,
8935 .internal_flags = NL80211_FLAG_NEED_WDEV |
8936 NL80211_FLAG_NEED_RTNL,
8937 },
8938 {
8939 .cmd = NL80211_CMD_FRAME,
8940 .doit = nl80211_tx_mgmt,
8941 .policy = nl80211_policy,
8942 .flags = GENL_ADMIN_PERM,
8943 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8944 NL80211_FLAG_NEED_RTNL,
8945 },
8946 {
8947 .cmd = NL80211_CMD_FRAME_WAIT_CANCEL,
8948 .doit = nl80211_tx_mgmt_cancel_wait,
8949 .policy = nl80211_policy,
8950 .flags = GENL_ADMIN_PERM,
8951 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
8952 NL80211_FLAG_NEED_RTNL,
8953 },
8954 {
8955 .cmd = NL80211_CMD_SET_POWER_SAVE,
8956 .doit = nl80211_set_power_save,
8957 .policy = nl80211_policy,
8958 .flags = GENL_ADMIN_PERM,
8959 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8960 NL80211_FLAG_NEED_RTNL,
8961 },
8962 {
8963 .cmd = NL80211_CMD_GET_POWER_SAVE,
8964 .doit = nl80211_get_power_save,
8965 .policy = nl80211_policy,
8966 /* can be retrieved by unprivileged users */
8967 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8968 NL80211_FLAG_NEED_RTNL,
8969 },
8970 {
8971 .cmd = NL80211_CMD_SET_CQM,
8972 .doit = nl80211_set_cqm,
8973 .policy = nl80211_policy,
8974 .flags = GENL_ADMIN_PERM,
8975 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8976 NL80211_FLAG_NEED_RTNL,
8977 },
8978 {
8979 .cmd = NL80211_CMD_SET_CHANNEL,
8980 .doit = nl80211_set_channel,
8981 .policy = nl80211_policy,
8982 .flags = GENL_ADMIN_PERM,
8983 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8984 NL80211_FLAG_NEED_RTNL,
8985 },
8986 {
8987 .cmd = NL80211_CMD_SET_WDS_PEER,
8988 .doit = nl80211_set_wds_peer,
8989 .policy = nl80211_policy,
8990 .flags = GENL_ADMIN_PERM,
8991 .internal_flags = NL80211_FLAG_NEED_NETDEV |
8992 NL80211_FLAG_NEED_RTNL,
8993 },
8994 {
8995 .cmd = NL80211_CMD_JOIN_MESH,
8996 .doit = nl80211_join_mesh,
8997 .policy = nl80211_policy,
8998 .flags = GENL_ADMIN_PERM,
8999 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9000 NL80211_FLAG_NEED_RTNL,
9001 },
9002 {
9003 .cmd = NL80211_CMD_LEAVE_MESH,
9004 .doit = nl80211_leave_mesh,
9005 .policy = nl80211_policy,
9006 .flags = GENL_ADMIN_PERM,
9007 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9008 NL80211_FLAG_NEED_RTNL,
9009 },
9010 #ifdef CONFIG_PM
9011 {
9012 .cmd = NL80211_CMD_GET_WOWLAN,
9013 .doit = nl80211_get_wowlan,
9014 .policy = nl80211_policy,
9015 /* can be retrieved by unprivileged users */
9016 .internal_flags = NL80211_FLAG_NEED_WIPHY |
9017 NL80211_FLAG_NEED_RTNL,
9018 },
9019 {
9020 .cmd = NL80211_CMD_SET_WOWLAN,
9021 .doit = nl80211_set_wowlan,
9022 .policy = nl80211_policy,
9023 .flags = GENL_ADMIN_PERM,
9024 .internal_flags = NL80211_FLAG_NEED_WIPHY |
9025 NL80211_FLAG_NEED_RTNL,
9026 },
9027 #endif
9028 {
9029 .cmd = NL80211_CMD_SET_REKEY_OFFLOAD,
9030 .doit = nl80211_set_rekey_data,
9031 .policy = nl80211_policy,
9032 .flags = GENL_ADMIN_PERM,
9033 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9034 NL80211_FLAG_NEED_RTNL,
9035 },
9036 {
9037 .cmd = NL80211_CMD_TDLS_MGMT,
9038 .doit = nl80211_tdls_mgmt,
9039 .policy = nl80211_policy,
9040 .flags = GENL_ADMIN_PERM,
9041 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9042 NL80211_FLAG_NEED_RTNL,
9043 },
9044 {
9045 .cmd = NL80211_CMD_TDLS_OPER,
9046 .doit = nl80211_tdls_oper,
9047 .policy = nl80211_policy,
9048 .flags = GENL_ADMIN_PERM,
9049 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9050 NL80211_FLAG_NEED_RTNL,
9051 },
9052 {
9053 .cmd = NL80211_CMD_UNEXPECTED_FRAME,
9054 .doit = nl80211_register_unexpected_frame,
9055 .policy = nl80211_policy,
9056 .flags = GENL_ADMIN_PERM,
9057 .internal_flags = NL80211_FLAG_NEED_NETDEV |
9058 NL80211_FLAG_NEED_RTNL,
9059 },
9060 {
9061 .cmd = NL80211_CMD_PROBE_CLIENT,
9062 .doit = nl80211_probe_client,
9063 .policy = nl80211_policy,
9064 .flags = GENL_ADMIN_PERM,
9065 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9066 NL80211_FLAG_NEED_RTNL,
9067 },
9068 {
9069 .cmd = NL80211_CMD_REGISTER_BEACONS,
9070 .doit = nl80211_register_beacons,
9071 .policy = nl80211_policy,
9072 .flags = GENL_ADMIN_PERM,
9073 .internal_flags = NL80211_FLAG_NEED_WIPHY |
9074 NL80211_FLAG_NEED_RTNL,
9075 },
9076 {
9077 .cmd = NL80211_CMD_SET_NOACK_MAP,
9078 .doit = nl80211_set_noack_map,
9079 .policy = nl80211_policy,
9080 .flags = GENL_ADMIN_PERM,
9081 .internal_flags = NL80211_FLAG_NEED_NETDEV |
9082 NL80211_FLAG_NEED_RTNL,
9083 },
9084 {
9085 .cmd = NL80211_CMD_START_P2P_DEVICE,
9086 .doit = nl80211_start_p2p_device,
9087 .policy = nl80211_policy,
9088 .flags = GENL_ADMIN_PERM,
9089 .internal_flags = NL80211_FLAG_NEED_WDEV |
9090 NL80211_FLAG_NEED_RTNL,
9091 },
9092 {
9093 .cmd = NL80211_CMD_STOP_P2P_DEVICE,
9094 .doit = nl80211_stop_p2p_device,
9095 .policy = nl80211_policy,
9096 .flags = GENL_ADMIN_PERM,
9097 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
9098 NL80211_FLAG_NEED_RTNL,
9099 },
9100 {
9101 .cmd = NL80211_CMD_SET_MCAST_RATE,
9102 .doit = nl80211_set_mcast_rate,
9103 .policy = nl80211_policy,
9104 .flags = GENL_ADMIN_PERM,
9105 .internal_flags = NL80211_FLAG_NEED_NETDEV |
9106 NL80211_FLAG_NEED_RTNL,
9107 },
9108 {
9109 .cmd = NL80211_CMD_SET_MAC_ACL,
9110 .doit = nl80211_set_mac_acl,
9111 .policy = nl80211_policy,
9112 .flags = GENL_ADMIN_PERM,
9113 .internal_flags = NL80211_FLAG_NEED_NETDEV |
9114 NL80211_FLAG_NEED_RTNL,
9115 },
9116 {
9117 .cmd = NL80211_CMD_RADAR_DETECT,
9118 .doit = nl80211_start_radar_detection,
9119 .policy = nl80211_policy,
9120 .flags = GENL_ADMIN_PERM,
9121 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9122 NL80211_FLAG_NEED_RTNL,
9123 },
9124 {
9125 .cmd = NL80211_CMD_GET_PROTOCOL_FEATURES,
9126 .doit = nl80211_get_protocol_features,
9127 .policy = nl80211_policy,
9128 },
9129 {
9130 .cmd = NL80211_CMD_UPDATE_FT_IES,
9131 .doit = nl80211_update_ft_ies,
9132 .policy = nl80211_policy,
9133 .flags = GENL_ADMIN_PERM,
9134 .internal_flags = NL80211_FLAG_NEED_NETDEV_UP |
9135 NL80211_FLAG_NEED_RTNL,
9136 },
9137 {
9138 .cmd = NL80211_CMD_CRIT_PROTOCOL_START,
9139 .doit = nl80211_crit_protocol_start,
9140 .policy = nl80211_policy,
9141 .flags = GENL_ADMIN_PERM,
9142 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
9143 NL80211_FLAG_NEED_RTNL,
9144 },
9145 {
9146 .cmd = NL80211_CMD_CRIT_PROTOCOL_STOP,
9147 .doit = nl80211_crit_protocol_stop,
9148 .policy = nl80211_policy,
9149 .flags = GENL_ADMIN_PERM,
9150 .internal_flags = NL80211_FLAG_NEED_WDEV_UP |
9151 NL80211_FLAG_NEED_RTNL,
9152 },
9153 {
9154 .cmd = NL80211_CMD_VENDOR,
9155 .doit = nl80211_vendor_cmd,
9156 .policy = nl80211_policy,
9157 .flags = GENL_ADMIN_PERM,
9158 .internal_flags = NL80211_FLAG_NEED_WIPHY |
9159 NL80211_FLAG_NEED_RTNL,
9160 },
9161 };
9162
9163 static struct genl_multicast_group nl80211_mlme_mcgrp = {
9164 .name = "mlme",
9165 };
9166
9167 /* multicast groups */
9168 static struct genl_multicast_group nl80211_config_mcgrp = {
9169 .name = "config",
9170 };
9171 static struct genl_multicast_group nl80211_scan_mcgrp = {
9172 .name = "scan",
9173 };
9174 static struct genl_multicast_group nl80211_regulatory_mcgrp = {
9175 .name = "regulatory",
9176 };
9177
9178 /* notification functions */
9179
9180 void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
9181 {
9182 struct sk_buff *msg;
9183
9184 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9185 if (!msg)
9186 return;
9187
9188 if (nl80211_send_wiphy(rdev, msg, 0, 0, 0,
9189 false, NULL, NULL, NULL) < 0) {
9190 nlmsg_free(msg);
9191 return;
9192 }
9193
9194 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9195 nl80211_config_mcgrp.id, GFP_KERNEL);
9196 }
9197
9198 static int nl80211_add_scan_req(struct sk_buff *msg,
9199 struct cfg80211_registered_device *rdev)
9200 {
9201 struct cfg80211_scan_request *req = rdev->scan_req;
9202 struct nlattr *nest;
9203 int i;
9204
9205 lockdep_assert_held(&rdev->sched_scan_mtx);
9206
9207 if (WARN_ON(!req))
9208 return 0;
9209
9210 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
9211 if (!nest)
9212 goto nla_put_failure;
9213 for (i = 0; i < req->n_ssids; i++) {
9214 if (nla_put(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid))
9215 goto nla_put_failure;
9216 }
9217 nla_nest_end(msg, nest);
9218
9219 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
9220 if (!nest)
9221 goto nla_put_failure;
9222 for (i = 0; i < req->n_channels; i++) {
9223 if (nla_put_u32(msg, i, req->channels[i]->center_freq))
9224 goto nla_put_failure;
9225 }
9226 nla_nest_end(msg, nest);
9227
9228 if (req->ie &&
9229 nla_put(msg, NL80211_ATTR_IE, req->ie_len, req->ie))
9230 goto nla_put_failure;
9231
9232 if (req->flags)
9233 nla_put_u32(msg, NL80211_ATTR_SCAN_FLAGS, req->flags);
9234
9235 return 0;
9236 nla_put_failure:
9237 return -ENOBUFS;
9238 }
9239
9240 static int nl80211_send_scan_msg(struct sk_buff *msg,
9241 struct cfg80211_registered_device *rdev,
9242 struct wireless_dev *wdev,
9243 u32 portid, u32 seq, int flags,
9244 u32 cmd)
9245 {
9246 void *hdr;
9247
9248 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
9249 if (!hdr)
9250 return -1;
9251
9252 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9253 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9254 wdev->netdev->ifindex)) ||
9255 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
9256 goto nla_put_failure;
9257
9258 /* ignore errors and send incomplete event anyway */
9259 nl80211_add_scan_req(msg, rdev);
9260
9261 return genlmsg_end(msg, hdr);
9262
9263 nla_put_failure:
9264 genlmsg_cancel(msg, hdr);
9265 return -EMSGSIZE;
9266 }
9267
9268 static int
9269 nl80211_send_sched_scan_msg(struct sk_buff *msg,
9270 struct cfg80211_registered_device *rdev,
9271 struct net_device *netdev,
9272 u32 portid, u32 seq, int flags, u32 cmd)
9273 {
9274 void *hdr;
9275
9276 hdr = nl80211hdr_put(msg, portid, seq, flags, cmd);
9277 if (!hdr)
9278 return -1;
9279
9280 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9281 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
9282 goto nla_put_failure;
9283
9284 return genlmsg_end(msg, hdr);
9285
9286 nla_put_failure:
9287 genlmsg_cancel(msg, hdr);
9288 return -EMSGSIZE;
9289 }
9290
9291 void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
9292 struct wireless_dev *wdev)
9293 {
9294 struct sk_buff *msg;
9295
9296 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9297 if (!msg)
9298 return;
9299
9300 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
9301 NL80211_CMD_TRIGGER_SCAN) < 0) {
9302 nlmsg_free(msg);
9303 return;
9304 }
9305
9306 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9307 nl80211_scan_mcgrp.id, GFP_KERNEL);
9308 }
9309
9310 void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
9311 struct wireless_dev *wdev)
9312 {
9313 struct sk_buff *msg;
9314
9315 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9316 if (!msg)
9317 return;
9318
9319 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
9320 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
9321 nlmsg_free(msg);
9322 return;
9323 }
9324
9325 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9326 nl80211_scan_mcgrp.id, GFP_KERNEL);
9327 }
9328
9329 void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
9330 struct wireless_dev *wdev)
9331 {
9332 struct sk_buff *msg;
9333
9334 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9335 if (!msg)
9336 return;
9337
9338 if (nl80211_send_scan_msg(msg, rdev, wdev, 0, 0, 0,
9339 NL80211_CMD_SCAN_ABORTED) < 0) {
9340 nlmsg_free(msg);
9341 return;
9342 }
9343
9344 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9345 nl80211_scan_mcgrp.id, GFP_KERNEL);
9346 }
9347
9348 void nl80211_send_sched_scan_results(struct cfg80211_registered_device *rdev,
9349 struct net_device *netdev)
9350 {
9351 struct sk_buff *msg;
9352
9353 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9354 if (!msg)
9355 return;
9356
9357 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0,
9358 NL80211_CMD_SCHED_SCAN_RESULTS) < 0) {
9359 nlmsg_free(msg);
9360 return;
9361 }
9362
9363 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9364 nl80211_scan_mcgrp.id, GFP_KERNEL);
9365 }
9366
9367 void nl80211_send_sched_scan(struct cfg80211_registered_device *rdev,
9368 struct net_device *netdev, u32 cmd)
9369 {
9370 struct sk_buff *msg;
9371
9372 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9373 if (!msg)
9374 return;
9375
9376 if (nl80211_send_sched_scan_msg(msg, rdev, netdev, 0, 0, 0, cmd) < 0) {
9377 nlmsg_free(msg);
9378 return;
9379 }
9380
9381 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9382 nl80211_scan_mcgrp.id, GFP_KERNEL);
9383 }
9384
9385 /*
9386 * This can happen on global regulatory changes or device specific settings
9387 * based on custom world regulatory domains.
9388 */
9389 void nl80211_send_reg_change_event(struct regulatory_request *request)
9390 {
9391 struct sk_buff *msg;
9392 void *hdr;
9393
9394 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9395 if (!msg)
9396 return;
9397
9398 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
9399 if (!hdr) {
9400 nlmsg_free(msg);
9401 return;
9402 }
9403
9404 /* Userspace can always count this one always being set */
9405 if (nla_put_u8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator))
9406 goto nla_put_failure;
9407
9408 if (request->alpha2[0] == '0' && request->alpha2[1] == '0') {
9409 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9410 NL80211_REGDOM_TYPE_WORLD))
9411 goto nla_put_failure;
9412 } else if (request->alpha2[0] == '9' && request->alpha2[1] == '9') {
9413 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9414 NL80211_REGDOM_TYPE_CUSTOM_WORLD))
9415 goto nla_put_failure;
9416 } else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
9417 request->intersect) {
9418 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9419 NL80211_REGDOM_TYPE_INTERSECTION))
9420 goto nla_put_failure;
9421 } else {
9422 if (nla_put_u8(msg, NL80211_ATTR_REG_TYPE,
9423 NL80211_REGDOM_TYPE_COUNTRY) ||
9424 nla_put_string(msg, NL80211_ATTR_REG_ALPHA2,
9425 request->alpha2))
9426 goto nla_put_failure;
9427 }
9428
9429 if (request->wiphy_idx != WIPHY_IDX_INVALID &&
9430 nla_put_u32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx))
9431 goto nla_put_failure;
9432
9433 genlmsg_end(msg, hdr);
9434
9435 rcu_read_lock();
9436 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
9437 GFP_ATOMIC);
9438 rcu_read_unlock();
9439
9440 return;
9441
9442 nla_put_failure:
9443 genlmsg_cancel(msg, hdr);
9444 nlmsg_free(msg);
9445 }
9446
9447 static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
9448 struct net_device *netdev,
9449 const u8 *buf, size_t len,
9450 enum nl80211_commands cmd, gfp_t gfp)
9451 {
9452 struct sk_buff *msg;
9453 void *hdr;
9454
9455 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9456 if (!msg)
9457 return;
9458
9459 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9460 if (!hdr) {
9461 nlmsg_free(msg);
9462 return;
9463 }
9464
9465 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9466 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9467 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
9468 goto nla_put_failure;
9469
9470 genlmsg_end(msg, hdr);
9471
9472 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9473 nl80211_mlme_mcgrp.id, gfp);
9474 return;
9475
9476 nla_put_failure:
9477 genlmsg_cancel(msg, hdr);
9478 nlmsg_free(msg);
9479 }
9480
9481 void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
9482 struct net_device *netdev, const u8 *buf,
9483 size_t len, gfp_t gfp)
9484 {
9485 nl80211_send_mlme_event(rdev, netdev, buf, len,
9486 NL80211_CMD_AUTHENTICATE, gfp);
9487 }
9488
9489 void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
9490 struct net_device *netdev, const u8 *buf,
9491 size_t len, gfp_t gfp)
9492 {
9493 nl80211_send_mlme_event(rdev, netdev, buf, len,
9494 NL80211_CMD_ASSOCIATE, gfp);
9495 }
9496
9497 void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
9498 struct net_device *netdev, const u8 *buf,
9499 size_t len, gfp_t gfp)
9500 {
9501 nl80211_send_mlme_event(rdev, netdev, buf, len,
9502 NL80211_CMD_DEAUTHENTICATE, gfp);
9503 }
9504
9505 void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
9506 struct net_device *netdev, const u8 *buf,
9507 size_t len, gfp_t gfp)
9508 {
9509 nl80211_send_mlme_event(rdev, netdev, buf, len,
9510 NL80211_CMD_DISASSOCIATE, gfp);
9511 }
9512
9513 void cfg80211_send_unprot_deauth(struct net_device *dev, const u8 *buf,
9514 size_t len)
9515 {
9516 struct wireless_dev *wdev = dev->ieee80211_ptr;
9517 struct wiphy *wiphy = wdev->wiphy;
9518 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9519
9520 trace_cfg80211_send_unprot_deauth(dev);
9521 nl80211_send_mlme_event(rdev, dev, buf, len,
9522 NL80211_CMD_UNPROT_DEAUTHENTICATE, GFP_ATOMIC);
9523 }
9524 EXPORT_SYMBOL(cfg80211_send_unprot_deauth);
9525
9526 void cfg80211_send_unprot_disassoc(struct net_device *dev, const u8 *buf,
9527 size_t len)
9528 {
9529 struct wireless_dev *wdev = dev->ieee80211_ptr;
9530 struct wiphy *wiphy = wdev->wiphy;
9531 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9532
9533 trace_cfg80211_send_unprot_disassoc(dev);
9534 nl80211_send_mlme_event(rdev, dev, buf, len,
9535 NL80211_CMD_UNPROT_DISASSOCIATE, GFP_ATOMIC);
9536 }
9537 EXPORT_SYMBOL(cfg80211_send_unprot_disassoc);
9538
9539 static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
9540 struct net_device *netdev, int cmd,
9541 const u8 *addr, gfp_t gfp)
9542 {
9543 struct sk_buff *msg;
9544 void *hdr;
9545
9546 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9547 if (!msg)
9548 return;
9549
9550 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9551 if (!hdr) {
9552 nlmsg_free(msg);
9553 return;
9554 }
9555
9556 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9557 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9558 nla_put_flag(msg, NL80211_ATTR_TIMED_OUT) ||
9559 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
9560 goto nla_put_failure;
9561
9562 genlmsg_end(msg, hdr);
9563
9564 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9565 nl80211_mlme_mcgrp.id, gfp);
9566 return;
9567
9568 nla_put_failure:
9569 genlmsg_cancel(msg, hdr);
9570 nlmsg_free(msg);
9571 }
9572
9573 void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
9574 struct net_device *netdev, const u8 *addr,
9575 gfp_t gfp)
9576 {
9577 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
9578 addr, gfp);
9579 }
9580
9581 void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
9582 struct net_device *netdev, const u8 *addr,
9583 gfp_t gfp)
9584 {
9585 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
9586 addr, gfp);
9587 }
9588
9589 void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
9590 struct net_device *netdev, const u8 *bssid,
9591 const u8 *req_ie, size_t req_ie_len,
9592 const u8 *resp_ie, size_t resp_ie_len,
9593 u16 status, gfp_t gfp)
9594 {
9595 struct sk_buff *msg;
9596 void *hdr;
9597
9598 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9599 if (!msg)
9600 return;
9601
9602 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
9603 if (!hdr) {
9604 nlmsg_free(msg);
9605 return;
9606 }
9607
9608 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9609 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9610 (bssid && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid)) ||
9611 nla_put_u16(msg, NL80211_ATTR_STATUS_CODE, status) ||
9612 (req_ie &&
9613 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
9614 (resp_ie &&
9615 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
9616 goto nla_put_failure;
9617
9618 genlmsg_end(msg, hdr);
9619
9620 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9621 nl80211_mlme_mcgrp.id, gfp);
9622 return;
9623
9624 nla_put_failure:
9625 genlmsg_cancel(msg, hdr);
9626 nlmsg_free(msg);
9627
9628 }
9629
9630 void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
9631 struct net_device *netdev, const u8 *bssid,
9632 const u8 *req_ie, size_t req_ie_len,
9633 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
9634 {
9635 struct sk_buff *msg;
9636 void *hdr;
9637
9638 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9639 if (!msg)
9640 return;
9641
9642 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
9643 if (!hdr) {
9644 nlmsg_free(msg);
9645 return;
9646 }
9647
9648 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9649 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9650 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid) ||
9651 (req_ie &&
9652 nla_put(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie)) ||
9653 (resp_ie &&
9654 nla_put(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie)))
9655 goto nla_put_failure;
9656
9657 genlmsg_end(msg, hdr);
9658
9659 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9660 nl80211_mlme_mcgrp.id, gfp);
9661 return;
9662
9663 nla_put_failure:
9664 genlmsg_cancel(msg, hdr);
9665 nlmsg_free(msg);
9666
9667 }
9668
9669 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
9670 struct net_device *netdev, u16 reason,
9671 const u8 *ie, size_t ie_len, bool from_ap)
9672 {
9673 struct sk_buff *msg;
9674 void *hdr;
9675
9676 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
9677 if (!msg)
9678 return;
9679
9680 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
9681 if (!hdr) {
9682 nlmsg_free(msg);
9683 return;
9684 }
9685
9686 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9687 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9688 (from_ap && reason &&
9689 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason)) ||
9690 (from_ap &&
9691 nla_put_flag(msg, NL80211_ATTR_DISCONNECTED_BY_AP)) ||
9692 (ie && nla_put(msg, NL80211_ATTR_IE, ie_len, ie)))
9693 goto nla_put_failure;
9694
9695 genlmsg_end(msg, hdr);
9696
9697 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9698 nl80211_mlme_mcgrp.id, GFP_KERNEL);
9699 return;
9700
9701 nla_put_failure:
9702 genlmsg_cancel(msg, hdr);
9703 nlmsg_free(msg);
9704
9705 }
9706
9707 void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
9708 struct net_device *netdev, const u8 *bssid,
9709 gfp_t gfp)
9710 {
9711 struct sk_buff *msg;
9712 void *hdr;
9713
9714 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9715 if (!msg)
9716 return;
9717
9718 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
9719 if (!hdr) {
9720 nlmsg_free(msg);
9721 return;
9722 }
9723
9724 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9725 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9726 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
9727 goto nla_put_failure;
9728
9729 genlmsg_end(msg, hdr);
9730
9731 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9732 nl80211_mlme_mcgrp.id, gfp);
9733 return;
9734
9735 nla_put_failure:
9736 genlmsg_cancel(msg, hdr);
9737 nlmsg_free(msg);
9738 }
9739
9740 void cfg80211_notify_new_peer_candidate(struct net_device *dev, const u8 *addr,
9741 const u8* ie, u8 ie_len, gfp_t gfp)
9742 {
9743 struct wireless_dev *wdev = dev->ieee80211_ptr;
9744 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
9745 struct sk_buff *msg;
9746 void *hdr;
9747
9748 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_MESH_POINT))
9749 return;
9750
9751 trace_cfg80211_notify_new_peer_candidate(dev, addr);
9752
9753 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9754 if (!msg)
9755 return;
9756
9757 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NEW_PEER_CANDIDATE);
9758 if (!hdr) {
9759 nlmsg_free(msg);
9760 return;
9761 }
9762
9763 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9764 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9765 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
9766 (ie_len && ie &&
9767 nla_put(msg, NL80211_ATTR_IE, ie_len , ie)))
9768 goto nla_put_failure;
9769
9770 genlmsg_end(msg, hdr);
9771
9772 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9773 nl80211_mlme_mcgrp.id, gfp);
9774 return;
9775
9776 nla_put_failure:
9777 genlmsg_cancel(msg, hdr);
9778 nlmsg_free(msg);
9779 }
9780 EXPORT_SYMBOL(cfg80211_notify_new_peer_candidate);
9781
9782 void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
9783 struct net_device *netdev, const u8 *addr,
9784 enum nl80211_key_type key_type, int key_id,
9785 const u8 *tsc, gfp_t gfp)
9786 {
9787 struct sk_buff *msg;
9788 void *hdr;
9789
9790 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9791 if (!msg)
9792 return;
9793
9794 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
9795 if (!hdr) {
9796 nlmsg_free(msg);
9797 return;
9798 }
9799
9800 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9801 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
9802 (addr && nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr)) ||
9803 nla_put_u32(msg, NL80211_ATTR_KEY_TYPE, key_type) ||
9804 (key_id != -1 &&
9805 nla_put_u8(msg, NL80211_ATTR_KEY_IDX, key_id)) ||
9806 (tsc && nla_put(msg, NL80211_ATTR_KEY_SEQ, 6, tsc)))
9807 goto nla_put_failure;
9808
9809 genlmsg_end(msg, hdr);
9810
9811 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9812 nl80211_mlme_mcgrp.id, gfp);
9813 return;
9814
9815 nla_put_failure:
9816 genlmsg_cancel(msg, hdr);
9817 nlmsg_free(msg);
9818 }
9819
9820 void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
9821 struct ieee80211_channel *channel_before,
9822 struct ieee80211_channel *channel_after)
9823 {
9824 struct sk_buff *msg;
9825 void *hdr;
9826 struct nlattr *nl_freq;
9827
9828 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
9829 if (!msg)
9830 return;
9831
9832 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
9833 if (!hdr) {
9834 nlmsg_free(msg);
9835 return;
9836 }
9837
9838 /*
9839 * Since we are applying the beacon hint to a wiphy we know its
9840 * wiphy_idx is valid
9841 */
9842 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy)))
9843 goto nla_put_failure;
9844
9845 /* Before */
9846 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
9847 if (!nl_freq)
9848 goto nla_put_failure;
9849 if (nl80211_msg_put_channel(msg, channel_before, false))
9850 goto nla_put_failure;
9851 nla_nest_end(msg, nl_freq);
9852
9853 /* After */
9854 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
9855 if (!nl_freq)
9856 goto nla_put_failure;
9857 if (nl80211_msg_put_channel(msg, channel_after, false))
9858 goto nla_put_failure;
9859 nla_nest_end(msg, nl_freq);
9860
9861 genlmsg_end(msg, hdr);
9862
9863 rcu_read_lock();
9864 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
9865 GFP_ATOMIC);
9866 rcu_read_unlock();
9867
9868 return;
9869
9870 nla_put_failure:
9871 genlmsg_cancel(msg, hdr);
9872 nlmsg_free(msg);
9873 }
9874
9875 static void nl80211_send_remain_on_chan_event(
9876 int cmd, struct cfg80211_registered_device *rdev,
9877 struct wireless_dev *wdev, u64 cookie,
9878 struct ieee80211_channel *chan,
9879 unsigned int duration, gfp_t gfp)
9880 {
9881 struct sk_buff *msg;
9882 void *hdr;
9883
9884 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9885 if (!msg)
9886 return;
9887
9888 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
9889 if (!hdr) {
9890 nlmsg_free(msg);
9891 return;
9892 }
9893
9894 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
9895 (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
9896 wdev->netdev->ifindex)) ||
9897 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
9898 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, chan->center_freq) ||
9899 nla_put_u32(msg, NL80211_ATTR_WIPHY_CHANNEL_TYPE,
9900 NL80211_CHAN_NO_HT) ||
9901 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie))
9902 goto nla_put_failure;
9903
9904 if (cmd == NL80211_CMD_REMAIN_ON_CHANNEL &&
9905 nla_put_u32(msg, NL80211_ATTR_DURATION, duration))
9906 goto nla_put_failure;
9907
9908 genlmsg_end(msg, hdr);
9909
9910 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9911 nl80211_mlme_mcgrp.id, gfp);
9912 return;
9913
9914 nla_put_failure:
9915 genlmsg_cancel(msg, hdr);
9916 nlmsg_free(msg);
9917 }
9918
9919 void cfg80211_ready_on_channel(struct wireless_dev *wdev, u64 cookie,
9920 struct ieee80211_channel *chan,
9921 unsigned int duration, gfp_t gfp)
9922 {
9923 struct wiphy *wiphy = wdev->wiphy;
9924 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9925
9926 trace_cfg80211_ready_on_channel(wdev, cookie, chan, duration);
9927 nl80211_send_remain_on_chan_event(NL80211_CMD_REMAIN_ON_CHANNEL,
9928 rdev, wdev, cookie, chan,
9929 duration, gfp);
9930 }
9931 EXPORT_SYMBOL(cfg80211_ready_on_channel);
9932
9933 void cfg80211_remain_on_channel_expired(struct wireless_dev *wdev, u64 cookie,
9934 struct ieee80211_channel *chan,
9935 gfp_t gfp)
9936 {
9937 struct wiphy *wiphy = wdev->wiphy;
9938 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9939
9940 trace_cfg80211_ready_on_channel_expired(wdev, cookie, chan);
9941 nl80211_send_remain_on_chan_event(NL80211_CMD_CANCEL_REMAIN_ON_CHANNEL,
9942 rdev, wdev, cookie, chan, 0, gfp);
9943 }
9944 EXPORT_SYMBOL(cfg80211_remain_on_channel_expired);
9945
9946 void cfg80211_new_sta(struct net_device *dev, const u8 *mac_addr,
9947 struct station_info *sinfo, gfp_t gfp)
9948 {
9949 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
9950 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9951 struct sk_buff *msg;
9952
9953 trace_cfg80211_new_sta(dev, mac_addr, sinfo);
9954
9955 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9956 if (!msg)
9957 return;
9958
9959 if (nl80211_send_station(msg, 0, 0, 0,
9960 rdev, dev, mac_addr, sinfo) < 0) {
9961 nlmsg_free(msg);
9962 return;
9963 }
9964
9965 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9966 nl80211_mlme_mcgrp.id, gfp);
9967 }
9968 EXPORT_SYMBOL(cfg80211_new_sta);
9969
9970 void cfg80211_del_sta(struct net_device *dev, const u8 *mac_addr, gfp_t gfp)
9971 {
9972 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
9973 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
9974 struct sk_buff *msg;
9975 void *hdr;
9976
9977 trace_cfg80211_del_sta(dev, mac_addr);
9978
9979 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
9980 if (!msg)
9981 return;
9982
9983 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DEL_STATION);
9984 if (!hdr) {
9985 nlmsg_free(msg);
9986 return;
9987 }
9988
9989 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
9990 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr))
9991 goto nla_put_failure;
9992
9993 genlmsg_end(msg, hdr);
9994
9995 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
9996 nl80211_mlme_mcgrp.id, gfp);
9997 return;
9998
9999 nla_put_failure:
10000 genlmsg_cancel(msg, hdr);
10001 nlmsg_free(msg);
10002 }
10003 EXPORT_SYMBOL(cfg80211_del_sta);
10004
10005 void cfg80211_conn_failed(struct net_device *dev, const u8 *mac_addr,
10006 enum nl80211_connect_failed_reason reason,
10007 gfp_t gfp)
10008 {
10009 struct wiphy *wiphy = dev->ieee80211_ptr->wiphy;
10010 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10011 struct sk_buff *msg;
10012 void *hdr;
10013
10014 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
10015 if (!msg)
10016 return;
10017
10018 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONN_FAILED);
10019 if (!hdr) {
10020 nlmsg_free(msg);
10021 return;
10022 }
10023
10024 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10025 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr) ||
10026 nla_put_u32(msg, NL80211_ATTR_CONN_FAILED_REASON, reason))
10027 goto nla_put_failure;
10028
10029 genlmsg_end(msg, hdr);
10030
10031 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10032 nl80211_mlme_mcgrp.id, gfp);
10033 return;
10034
10035 nla_put_failure:
10036 genlmsg_cancel(msg, hdr);
10037 nlmsg_free(msg);
10038 }
10039 EXPORT_SYMBOL(cfg80211_conn_failed);
10040
10041 static bool __nl80211_unexpected_frame(struct net_device *dev, u8 cmd,
10042 const u8 *addr, gfp_t gfp)
10043 {
10044 struct wireless_dev *wdev = dev->ieee80211_ptr;
10045 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10046 struct sk_buff *msg;
10047 void *hdr;
10048 int err;
10049 u32 nlportid = ACCESS_ONCE(wdev->ap_unexpected_nlportid);
10050
10051 if (!nlportid)
10052 return false;
10053
10054 msg = nlmsg_new(100, gfp);
10055 if (!msg)
10056 return true;
10057
10058 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
10059 if (!hdr) {
10060 nlmsg_free(msg);
10061 return true;
10062 }
10063
10064 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10065 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10066 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr))
10067 goto nla_put_failure;
10068
10069 err = genlmsg_end(msg, hdr);
10070 if (err < 0) {
10071 nlmsg_free(msg);
10072 return true;
10073 }
10074
10075 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
10076 return true;
10077
10078 nla_put_failure:
10079 genlmsg_cancel(msg, hdr);
10080 nlmsg_free(msg);
10081 return true;
10082 }
10083
10084 bool cfg80211_rx_spurious_frame(struct net_device *dev,
10085 const u8 *addr, gfp_t gfp)
10086 {
10087 struct wireless_dev *wdev = dev->ieee80211_ptr;
10088 bool ret;
10089
10090 trace_cfg80211_rx_spurious_frame(dev, addr);
10091
10092 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
10093 wdev->iftype != NL80211_IFTYPE_P2P_GO)) {
10094 trace_cfg80211_return_bool(false);
10095 return false;
10096 }
10097 ret = __nl80211_unexpected_frame(dev, NL80211_CMD_UNEXPECTED_FRAME,
10098 addr, gfp);
10099 trace_cfg80211_return_bool(ret);
10100 return ret;
10101 }
10102 EXPORT_SYMBOL(cfg80211_rx_spurious_frame);
10103
10104 bool cfg80211_rx_unexpected_4addr_frame(struct net_device *dev,
10105 const u8 *addr, gfp_t gfp)
10106 {
10107 struct wireless_dev *wdev = dev->ieee80211_ptr;
10108 bool ret;
10109
10110 trace_cfg80211_rx_unexpected_4addr_frame(dev, addr);
10111
10112 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
10113 wdev->iftype != NL80211_IFTYPE_P2P_GO &&
10114 wdev->iftype != NL80211_IFTYPE_AP_VLAN)) {
10115 trace_cfg80211_return_bool(false);
10116 return false;
10117 }
10118 ret = __nl80211_unexpected_frame(dev,
10119 NL80211_CMD_UNEXPECTED_4ADDR_FRAME,
10120 addr, gfp);
10121 trace_cfg80211_return_bool(ret);
10122 return ret;
10123 }
10124 EXPORT_SYMBOL(cfg80211_rx_unexpected_4addr_frame);
10125
10126 int nl80211_send_mgmt(struct cfg80211_registered_device *rdev,
10127 struct wireless_dev *wdev, u32 nlportid,
10128 int freq, int sig_dbm,
10129 const u8 *buf, size_t len, gfp_t gfp)
10130 {
10131 struct net_device *netdev = wdev->netdev;
10132 struct sk_buff *msg;
10133 void *hdr;
10134
10135 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10136 if (!msg)
10137 return -ENOMEM;
10138
10139 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
10140 if (!hdr) {
10141 nlmsg_free(msg);
10142 return -ENOMEM;
10143 }
10144
10145 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10146 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10147 netdev->ifindex)) ||
10148 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
10149 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq) ||
10150 (sig_dbm &&
10151 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
10152 nla_put(msg, NL80211_ATTR_FRAME, len, buf))
10153 goto nla_put_failure;
10154
10155 genlmsg_end(msg, hdr);
10156
10157 return genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
10158
10159 nla_put_failure:
10160 genlmsg_cancel(msg, hdr);
10161 nlmsg_free(msg);
10162 return -ENOBUFS;
10163 }
10164
10165 void cfg80211_mgmt_tx_status(struct wireless_dev *wdev, u64 cookie,
10166 const u8 *buf, size_t len, bool ack, gfp_t gfp)
10167 {
10168 struct wiphy *wiphy = wdev->wiphy;
10169 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10170 struct net_device *netdev = wdev->netdev;
10171 struct sk_buff *msg;
10172 void *hdr;
10173
10174 trace_cfg80211_mgmt_tx_status(wdev, cookie, ack);
10175
10176 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10177 if (!msg)
10178 return;
10179
10180 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME_TX_STATUS);
10181 if (!hdr) {
10182 nlmsg_free(msg);
10183 return;
10184 }
10185
10186 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10187 (netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10188 netdev->ifindex)) ||
10189 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)) ||
10190 nla_put(msg, NL80211_ATTR_FRAME, len, buf) ||
10191 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
10192 (ack && nla_put_flag(msg, NL80211_ATTR_ACK)))
10193 goto nla_put_failure;
10194
10195 genlmsg_end(msg, hdr);
10196
10197 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10198 nl80211_mlme_mcgrp.id, gfp);
10199 return;
10200
10201 nla_put_failure:
10202 genlmsg_cancel(msg, hdr);
10203 nlmsg_free(msg);
10204 }
10205 EXPORT_SYMBOL(cfg80211_mgmt_tx_status);
10206
10207 void cfg80211_cqm_rssi_notify(struct net_device *dev,
10208 enum nl80211_cqm_rssi_threshold_event rssi_event,
10209 gfp_t gfp)
10210 {
10211 struct wireless_dev *wdev = dev->ieee80211_ptr;
10212 struct wiphy *wiphy = wdev->wiphy;
10213 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10214 struct sk_buff *msg;
10215 struct nlattr *pinfoattr;
10216 void *hdr;
10217
10218 trace_cfg80211_cqm_rssi_notify(dev, rssi_event);
10219
10220 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10221 if (!msg)
10222 return;
10223
10224 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
10225 if (!hdr) {
10226 nlmsg_free(msg);
10227 return;
10228 }
10229
10230 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10231 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex))
10232 goto nla_put_failure;
10233
10234 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
10235 if (!pinfoattr)
10236 goto nla_put_failure;
10237
10238 if (nla_put_u32(msg, NL80211_ATTR_CQM_RSSI_THRESHOLD_EVENT,
10239 rssi_event))
10240 goto nla_put_failure;
10241
10242 nla_nest_end(msg, pinfoattr);
10243
10244 genlmsg_end(msg, hdr);
10245
10246 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10247 nl80211_mlme_mcgrp.id, gfp);
10248 return;
10249
10250 nla_put_failure:
10251 genlmsg_cancel(msg, hdr);
10252 nlmsg_free(msg);
10253 }
10254 EXPORT_SYMBOL(cfg80211_cqm_rssi_notify);
10255
10256 static void nl80211_gtk_rekey_notify(struct cfg80211_registered_device *rdev,
10257 struct net_device *netdev, const u8 *bssid,
10258 const u8 *replay_ctr, gfp_t gfp)
10259 {
10260 struct sk_buff *msg;
10261 struct nlattr *rekey_attr;
10262 void *hdr;
10263
10264 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10265 if (!msg)
10266 return;
10267
10268 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_REKEY_OFFLOAD);
10269 if (!hdr) {
10270 nlmsg_free(msg);
10271 return;
10272 }
10273
10274 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10275 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10276 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
10277 goto nla_put_failure;
10278
10279 rekey_attr = nla_nest_start(msg, NL80211_ATTR_REKEY_DATA);
10280 if (!rekey_attr)
10281 goto nla_put_failure;
10282
10283 if (nla_put(msg, NL80211_REKEY_DATA_REPLAY_CTR,
10284 NL80211_REPLAY_CTR_LEN, replay_ctr))
10285 goto nla_put_failure;
10286
10287 nla_nest_end(msg, rekey_attr);
10288
10289 genlmsg_end(msg, hdr);
10290
10291 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10292 nl80211_mlme_mcgrp.id, gfp);
10293 return;
10294
10295 nla_put_failure:
10296 genlmsg_cancel(msg, hdr);
10297 nlmsg_free(msg);
10298 }
10299
10300 void cfg80211_gtk_rekey_notify(struct net_device *dev, const u8 *bssid,
10301 const u8 *replay_ctr, gfp_t gfp)
10302 {
10303 struct wireless_dev *wdev = dev->ieee80211_ptr;
10304 struct wiphy *wiphy = wdev->wiphy;
10305 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10306
10307 trace_cfg80211_gtk_rekey_notify(dev, bssid);
10308 nl80211_gtk_rekey_notify(rdev, dev, bssid, replay_ctr, gfp);
10309 }
10310 EXPORT_SYMBOL(cfg80211_gtk_rekey_notify);
10311
10312 static void
10313 nl80211_pmksa_candidate_notify(struct cfg80211_registered_device *rdev,
10314 struct net_device *netdev, int index,
10315 const u8 *bssid, bool preauth, gfp_t gfp)
10316 {
10317 struct sk_buff *msg;
10318 struct nlattr *attr;
10319 void *hdr;
10320
10321 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10322 if (!msg)
10323 return;
10324
10325 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PMKSA_CANDIDATE);
10326 if (!hdr) {
10327 nlmsg_free(msg);
10328 return;
10329 }
10330
10331 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10332 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
10333 goto nla_put_failure;
10334
10335 attr = nla_nest_start(msg, NL80211_ATTR_PMKSA_CANDIDATE);
10336 if (!attr)
10337 goto nla_put_failure;
10338
10339 if (nla_put_u32(msg, NL80211_PMKSA_CANDIDATE_INDEX, index) ||
10340 nla_put(msg, NL80211_PMKSA_CANDIDATE_BSSID, ETH_ALEN, bssid) ||
10341 (preauth &&
10342 nla_put_flag(msg, NL80211_PMKSA_CANDIDATE_PREAUTH)))
10343 goto nla_put_failure;
10344
10345 nla_nest_end(msg, attr);
10346
10347 genlmsg_end(msg, hdr);
10348
10349 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10350 nl80211_mlme_mcgrp.id, gfp);
10351 return;
10352
10353 nla_put_failure:
10354 genlmsg_cancel(msg, hdr);
10355 nlmsg_free(msg);
10356 }
10357
10358 void cfg80211_pmksa_candidate_notify(struct net_device *dev, int index,
10359 const u8 *bssid, bool preauth, gfp_t gfp)
10360 {
10361 struct wireless_dev *wdev = dev->ieee80211_ptr;
10362 struct wiphy *wiphy = wdev->wiphy;
10363 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10364
10365 trace_cfg80211_pmksa_candidate_notify(dev, index, bssid, preauth);
10366 nl80211_pmksa_candidate_notify(rdev, dev, index, bssid, preauth, gfp);
10367 }
10368 EXPORT_SYMBOL(cfg80211_pmksa_candidate_notify);
10369
10370 static void nl80211_ch_switch_notify(struct cfg80211_registered_device *rdev,
10371 struct net_device *netdev,
10372 struct cfg80211_chan_def *chandef,
10373 gfp_t gfp)
10374 {
10375 struct sk_buff *msg;
10376 void *hdr;
10377
10378 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10379 if (!msg)
10380 return;
10381
10382 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CH_SWITCH_NOTIFY);
10383 if (!hdr) {
10384 nlmsg_free(msg);
10385 return;
10386 }
10387
10388 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex))
10389 goto nla_put_failure;
10390
10391 if (nl80211_send_chandef(msg, chandef))
10392 goto nla_put_failure;
10393
10394 genlmsg_end(msg, hdr);
10395
10396 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10397 nl80211_mlme_mcgrp.id, gfp);
10398 return;
10399
10400 nla_put_failure:
10401 genlmsg_cancel(msg, hdr);
10402 nlmsg_free(msg);
10403 }
10404
10405 void cfg80211_ch_switch_notify(struct net_device *dev,
10406 struct cfg80211_chan_def *chandef)
10407 {
10408 struct wireless_dev *wdev = dev->ieee80211_ptr;
10409 struct wiphy *wiphy = wdev->wiphy;
10410 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10411
10412 trace_cfg80211_ch_switch_notify(dev, chandef);
10413
10414 wdev_lock(wdev);
10415
10416 if (WARN_ON(wdev->iftype != NL80211_IFTYPE_AP &&
10417 wdev->iftype != NL80211_IFTYPE_P2P_GO))
10418 goto out;
10419
10420 wdev->channel = chandef->chan;
10421 nl80211_ch_switch_notify(rdev, dev, chandef, GFP_KERNEL);
10422 out:
10423 wdev_unlock(wdev);
10424 return;
10425 }
10426 EXPORT_SYMBOL(cfg80211_ch_switch_notify);
10427
10428 void cfg80211_cqm_txe_notify(struct net_device *dev,
10429 const u8 *peer, u32 num_packets,
10430 u32 rate, u32 intvl, gfp_t gfp)
10431 {
10432 struct wireless_dev *wdev = dev->ieee80211_ptr;
10433 struct wiphy *wiphy = wdev->wiphy;
10434 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10435 struct sk_buff *msg;
10436 struct nlattr *pinfoattr;
10437 void *hdr;
10438
10439 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
10440 if (!msg)
10441 return;
10442
10443 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
10444 if (!hdr) {
10445 nlmsg_free(msg);
10446 return;
10447 }
10448
10449 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10450 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10451 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
10452 goto nla_put_failure;
10453
10454 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
10455 if (!pinfoattr)
10456 goto nla_put_failure;
10457
10458 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_PKTS, num_packets))
10459 goto nla_put_failure;
10460
10461 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_RATE, rate))
10462 goto nla_put_failure;
10463
10464 if (nla_put_u32(msg, NL80211_ATTR_CQM_TXE_INTVL, intvl))
10465 goto nla_put_failure;
10466
10467 nla_nest_end(msg, pinfoattr);
10468
10469 genlmsg_end(msg, hdr);
10470
10471 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10472 nl80211_mlme_mcgrp.id, gfp);
10473 return;
10474
10475 nla_put_failure:
10476 genlmsg_cancel(msg, hdr);
10477 nlmsg_free(msg);
10478 }
10479 EXPORT_SYMBOL(cfg80211_cqm_txe_notify);
10480
10481 void
10482 nl80211_radar_notify(struct cfg80211_registered_device *rdev,
10483 struct cfg80211_chan_def *chandef,
10484 enum nl80211_radar_event event,
10485 struct net_device *netdev, gfp_t gfp)
10486 {
10487 struct sk_buff *msg;
10488 void *hdr;
10489
10490 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10491 if (!msg)
10492 return;
10493
10494 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_RADAR_DETECT);
10495 if (!hdr) {
10496 nlmsg_free(msg);
10497 return;
10498 }
10499
10500 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx))
10501 goto nla_put_failure;
10502
10503 /* NOP and radar events don't need a netdev parameter */
10504 if (netdev) {
10505 struct wireless_dev *wdev = netdev->ieee80211_ptr;
10506
10507 if (nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex) ||
10508 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10509 goto nla_put_failure;
10510 }
10511
10512 if (nla_put_u32(msg, NL80211_ATTR_RADAR_EVENT, event))
10513 goto nla_put_failure;
10514
10515 if (nl80211_send_chandef(msg, chandef))
10516 goto nla_put_failure;
10517
10518 if (genlmsg_end(msg, hdr) < 0) {
10519 nlmsg_free(msg);
10520 return;
10521 }
10522
10523 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10524 nl80211_mlme_mcgrp.id, gfp);
10525 return;
10526
10527 nla_put_failure:
10528 genlmsg_cancel(msg, hdr);
10529 nlmsg_free(msg);
10530 }
10531
10532 void cfg80211_cqm_pktloss_notify(struct net_device *dev,
10533 const u8 *peer, u32 num_packets, gfp_t gfp)
10534 {
10535 struct wireless_dev *wdev = dev->ieee80211_ptr;
10536 struct wiphy *wiphy = wdev->wiphy;
10537 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10538 struct sk_buff *msg;
10539 struct nlattr *pinfoattr;
10540 void *hdr;
10541
10542 trace_cfg80211_cqm_pktloss_notify(dev, peer, num_packets);
10543
10544 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10545 if (!msg)
10546 return;
10547
10548 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_NOTIFY_CQM);
10549 if (!hdr) {
10550 nlmsg_free(msg);
10551 return;
10552 }
10553
10554 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10555 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10556 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer))
10557 goto nla_put_failure;
10558
10559 pinfoattr = nla_nest_start(msg, NL80211_ATTR_CQM);
10560 if (!pinfoattr)
10561 goto nla_put_failure;
10562
10563 if (nla_put_u32(msg, NL80211_ATTR_CQM_PKT_LOSS_EVENT, num_packets))
10564 goto nla_put_failure;
10565
10566 nla_nest_end(msg, pinfoattr);
10567
10568 genlmsg_end(msg, hdr);
10569
10570 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10571 nl80211_mlme_mcgrp.id, gfp);
10572 return;
10573
10574 nla_put_failure:
10575 genlmsg_cancel(msg, hdr);
10576 nlmsg_free(msg);
10577 }
10578 EXPORT_SYMBOL(cfg80211_cqm_pktloss_notify);
10579
10580 void cfg80211_probe_status(struct net_device *dev, const u8 *addr,
10581 u64 cookie, bool acked, gfp_t gfp)
10582 {
10583 struct wireless_dev *wdev = dev->ieee80211_ptr;
10584 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10585 struct sk_buff *msg;
10586 void *hdr;
10587 int err;
10588
10589 trace_cfg80211_probe_status(dev, addr, cookie, acked);
10590
10591 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10592
10593 if (!msg)
10594 return;
10595
10596 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_PROBE_CLIENT);
10597 if (!hdr) {
10598 nlmsg_free(msg);
10599 return;
10600 }
10601
10602 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10603 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10604 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
10605 nla_put_u64(msg, NL80211_ATTR_COOKIE, cookie) ||
10606 (acked && nla_put_flag(msg, NL80211_ATTR_ACK)))
10607 goto nla_put_failure;
10608
10609 err = genlmsg_end(msg, hdr);
10610 if (err < 0) {
10611 nlmsg_free(msg);
10612 return;
10613 }
10614
10615 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10616 nl80211_mlme_mcgrp.id, gfp);
10617 return;
10618
10619 nla_put_failure:
10620 genlmsg_cancel(msg, hdr);
10621 nlmsg_free(msg);
10622 }
10623 EXPORT_SYMBOL(cfg80211_probe_status);
10624
10625 void cfg80211_report_obss_beacon(struct wiphy *wiphy,
10626 const u8 *frame, size_t len,
10627 int freq, int sig_dbm)
10628 {
10629 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10630 struct sk_buff *msg;
10631 void *hdr;
10632 struct cfg80211_beacon_registration *reg;
10633
10634 trace_cfg80211_report_obss_beacon(wiphy, frame, len, freq, sig_dbm);
10635
10636 spin_lock_bh(&rdev->beacon_registrations_lock);
10637 list_for_each_entry(reg, &rdev->beacon_registrations, list) {
10638 msg = nlmsg_new(len + 100, GFP_ATOMIC);
10639 if (!msg) {
10640 spin_unlock_bh(&rdev->beacon_registrations_lock);
10641 return;
10642 }
10643
10644 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FRAME);
10645 if (!hdr)
10646 goto nla_put_failure;
10647
10648 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10649 (freq &&
10650 nla_put_u32(msg, NL80211_ATTR_WIPHY_FREQ, freq)) ||
10651 (sig_dbm &&
10652 nla_put_u32(msg, NL80211_ATTR_RX_SIGNAL_DBM, sig_dbm)) ||
10653 nla_put(msg, NL80211_ATTR_FRAME, len, frame))
10654 goto nla_put_failure;
10655
10656 genlmsg_end(msg, hdr);
10657
10658 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, reg->nlportid);
10659 }
10660 spin_unlock_bh(&rdev->beacon_registrations_lock);
10661 return;
10662
10663 nla_put_failure:
10664 spin_unlock_bh(&rdev->beacon_registrations_lock);
10665 if (hdr)
10666 genlmsg_cancel(msg, hdr);
10667 nlmsg_free(msg);
10668 }
10669 EXPORT_SYMBOL(cfg80211_report_obss_beacon);
10670
10671 #ifdef CONFIG_PM
10672 void cfg80211_report_wowlan_wakeup(struct wireless_dev *wdev,
10673 struct cfg80211_wowlan_wakeup *wakeup,
10674 gfp_t gfp)
10675 {
10676 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10677 struct sk_buff *msg;
10678 void *hdr;
10679 int err, size = 200;
10680
10681 trace_cfg80211_report_wowlan_wakeup(wdev->wiphy, wdev, wakeup);
10682
10683 if (wakeup)
10684 size += wakeup->packet_present_len;
10685
10686 msg = nlmsg_new(size, gfp);
10687 if (!msg)
10688 return;
10689
10690 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_SET_WOWLAN);
10691 if (!hdr)
10692 goto free_msg;
10693
10694 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10695 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10696 goto free_msg;
10697
10698 if (wdev->netdev && nla_put_u32(msg, NL80211_ATTR_IFINDEX,
10699 wdev->netdev->ifindex))
10700 goto free_msg;
10701
10702 if (wakeup) {
10703 struct nlattr *reasons;
10704
10705 reasons = nla_nest_start(msg, NL80211_ATTR_WOWLAN_TRIGGERS);
10706
10707 if (wakeup->disconnect &&
10708 nla_put_flag(msg, NL80211_WOWLAN_TRIG_DISCONNECT))
10709 goto free_msg;
10710 if (wakeup->magic_pkt &&
10711 nla_put_flag(msg, NL80211_WOWLAN_TRIG_MAGIC_PKT))
10712 goto free_msg;
10713 if (wakeup->gtk_rekey_failure &&
10714 nla_put_flag(msg, NL80211_WOWLAN_TRIG_GTK_REKEY_FAILURE))
10715 goto free_msg;
10716 if (wakeup->eap_identity_req &&
10717 nla_put_flag(msg, NL80211_WOWLAN_TRIG_EAP_IDENT_REQUEST))
10718 goto free_msg;
10719 if (wakeup->four_way_handshake &&
10720 nla_put_flag(msg, NL80211_WOWLAN_TRIG_4WAY_HANDSHAKE))
10721 goto free_msg;
10722 if (wakeup->rfkill_release &&
10723 nla_put_flag(msg, NL80211_WOWLAN_TRIG_RFKILL_RELEASE))
10724 goto free_msg;
10725
10726 if (wakeup->pattern_idx >= 0 &&
10727 nla_put_u32(msg, NL80211_WOWLAN_TRIG_PKT_PATTERN,
10728 wakeup->pattern_idx))
10729 goto free_msg;
10730
10731 if (wakeup->tcp_match)
10732 nla_put_flag(msg, NL80211_WOWLAN_TRIG_WAKEUP_TCP_MATCH);
10733
10734 if (wakeup->tcp_connlost)
10735 nla_put_flag(msg,
10736 NL80211_WOWLAN_TRIG_WAKEUP_TCP_CONNLOST);
10737
10738 if (wakeup->tcp_nomoretokens)
10739 nla_put_flag(msg,
10740 NL80211_WOWLAN_TRIG_WAKEUP_TCP_NOMORETOKENS);
10741
10742 if (wakeup->packet) {
10743 u32 pkt_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211;
10744 u32 len_attr = NL80211_WOWLAN_TRIG_WAKEUP_PKT_80211_LEN;
10745
10746 if (!wakeup->packet_80211) {
10747 pkt_attr =
10748 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023;
10749 len_attr =
10750 NL80211_WOWLAN_TRIG_WAKEUP_PKT_8023_LEN;
10751 }
10752
10753 if (wakeup->packet_len &&
10754 nla_put_u32(msg, len_attr, wakeup->packet_len))
10755 goto free_msg;
10756
10757 if (nla_put(msg, pkt_attr, wakeup->packet_present_len,
10758 wakeup->packet))
10759 goto free_msg;
10760 }
10761
10762 nla_nest_end(msg, reasons);
10763 }
10764
10765 err = genlmsg_end(msg, hdr);
10766 if (err < 0)
10767 goto free_msg;
10768
10769 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10770 nl80211_mlme_mcgrp.id, gfp);
10771 return;
10772
10773 free_msg:
10774 nlmsg_free(msg);
10775 }
10776 EXPORT_SYMBOL(cfg80211_report_wowlan_wakeup);
10777 #endif
10778
10779 void cfg80211_tdls_oper_request(struct net_device *dev, const u8 *peer,
10780 enum nl80211_tdls_operation oper,
10781 u16 reason_code, gfp_t gfp)
10782 {
10783 struct wireless_dev *wdev = dev->ieee80211_ptr;
10784 struct cfg80211_registered_device *rdev = wiphy_to_dev(wdev->wiphy);
10785 struct sk_buff *msg;
10786 void *hdr;
10787 int err;
10788
10789 trace_cfg80211_tdls_oper_request(wdev->wiphy, dev, peer, oper,
10790 reason_code);
10791
10792 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10793 if (!msg)
10794 return;
10795
10796 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_TDLS_OPER);
10797 if (!hdr) {
10798 nlmsg_free(msg);
10799 return;
10800 }
10801
10802 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10803 nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
10804 nla_put_u8(msg, NL80211_ATTR_TDLS_OPERATION, oper) ||
10805 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, peer) ||
10806 (reason_code > 0 &&
10807 nla_put_u16(msg, NL80211_ATTR_REASON_CODE, reason_code)))
10808 goto nla_put_failure;
10809
10810 err = genlmsg_end(msg, hdr);
10811 if (err < 0) {
10812 nlmsg_free(msg);
10813 return;
10814 }
10815
10816 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10817 nl80211_mlme_mcgrp.id, gfp);
10818 return;
10819
10820 nla_put_failure:
10821 genlmsg_cancel(msg, hdr);
10822 nlmsg_free(msg);
10823 }
10824 EXPORT_SYMBOL(cfg80211_tdls_oper_request);
10825
10826 static int nl80211_netlink_notify(struct notifier_block * nb,
10827 unsigned long state,
10828 void *_notify)
10829 {
10830 struct netlink_notify *notify = _notify;
10831 struct cfg80211_registered_device *rdev;
10832 struct wireless_dev *wdev;
10833 struct cfg80211_beacon_registration *reg, *tmp;
10834
10835 if (state != NETLINK_URELEASE)
10836 return NOTIFY_DONE;
10837
10838 rcu_read_lock();
10839
10840 list_for_each_entry_rcu(rdev, &cfg80211_rdev_list, list) {
10841 list_for_each_entry_rcu(wdev, &rdev->wdev_list, list)
10842 cfg80211_mlme_unregister_socket(wdev, notify->portid);
10843
10844 spin_lock_bh(&rdev->beacon_registrations_lock);
10845 list_for_each_entry_safe(reg, tmp, &rdev->beacon_registrations,
10846 list) {
10847 if (reg->nlportid == notify->portid) {
10848 list_del(&reg->list);
10849 kfree(reg);
10850 break;
10851 }
10852 }
10853 spin_unlock_bh(&rdev->beacon_registrations_lock);
10854 }
10855
10856 rcu_read_unlock();
10857
10858 return NOTIFY_DONE;
10859 }
10860
10861 static struct notifier_block nl80211_netlink_notifier = {
10862 .notifier_call = nl80211_netlink_notify,
10863 };
10864
10865 void cfg80211_ft_event(struct net_device *netdev,
10866 struct cfg80211_ft_event_params *ft_event)
10867 {
10868 struct wiphy *wiphy = netdev->ieee80211_ptr->wiphy;
10869 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
10870 struct sk_buff *msg;
10871 void *hdr;
10872 int err;
10873
10874 trace_cfg80211_ft_event(wiphy, netdev, ft_event);
10875
10876 if (!ft_event->target_ap)
10877 return;
10878
10879 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
10880 if (!msg)
10881 return;
10882
10883 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_FT_EVENT);
10884 if (!hdr) {
10885 nlmsg_free(msg);
10886 return;
10887 }
10888
10889 nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
10890 nla_put_u32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
10891 nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, ft_event->target_ap);
10892 if (ft_event->ies)
10893 nla_put(msg, NL80211_ATTR_IE, ft_event->ies_len, ft_event->ies);
10894 if (ft_event->ric_ies)
10895 nla_put(msg, NL80211_ATTR_IE_RIC, ft_event->ric_ies_len,
10896 ft_event->ric_ies);
10897
10898 err = genlmsg_end(msg, hdr);
10899 if (err < 0) {
10900 nlmsg_free(msg);
10901 return;
10902 }
10903
10904 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
10905 nl80211_mlme_mcgrp.id, GFP_KERNEL);
10906 }
10907 EXPORT_SYMBOL(cfg80211_ft_event);
10908
10909 void cfg80211_crit_proto_stopped(struct wireless_dev *wdev, gfp_t gfp)
10910 {
10911 struct cfg80211_registered_device *rdev;
10912 struct sk_buff *msg;
10913 void *hdr;
10914 u32 nlportid;
10915
10916 rdev = wiphy_to_dev(wdev->wiphy);
10917 if (!rdev->crit_proto_nlportid)
10918 return;
10919
10920 nlportid = rdev->crit_proto_nlportid;
10921 rdev->crit_proto_nlportid = 0;
10922
10923 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
10924 if (!msg)
10925 return;
10926
10927 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CRIT_PROTOCOL_STOP);
10928 if (!hdr)
10929 goto nla_put_failure;
10930
10931 if (nla_put_u32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx) ||
10932 nla_put_u64(msg, NL80211_ATTR_WDEV, wdev_id(wdev)))
10933 goto nla_put_failure;
10934
10935 genlmsg_end(msg, hdr);
10936
10937 genlmsg_unicast(wiphy_net(&rdev->wiphy), msg, nlportid);
10938 return;
10939
10940 nla_put_failure:
10941 if (hdr)
10942 genlmsg_cancel(msg, hdr);
10943 nlmsg_free(msg);
10944
10945 }
10946 EXPORT_SYMBOL(cfg80211_crit_proto_stopped);
10947
10948 /* initialisation/exit functions */
10949
10950 int nl80211_init(void)
10951 {
10952 int err;
10953
10954 err = genl_register_family_with_ops(&nl80211_fam,
10955 nl80211_ops, ARRAY_SIZE(nl80211_ops));
10956 if (err)
10957 return err;
10958
10959 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
10960 if (err)
10961 goto err_out;
10962
10963 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
10964 if (err)
10965 goto err_out;
10966
10967 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
10968 if (err)
10969 goto err_out;
10970
10971 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
10972 if (err)
10973 goto err_out;
10974
10975 #ifdef CONFIG_NL80211_TESTMODE
10976 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
10977 if (err)
10978 goto err_out;
10979
10980 err = genl_register_mc_group(&nl80211_fam, &nl80211_vendor_mcgrp);
10981 if (err)
10982 goto err_out;
10983 #endif
10984
10985 err = netlink_register_notifier(&nl80211_netlink_notifier);
10986 if (err)
10987 goto err_out;
10988
10989 return 0;
10990 err_out:
10991 genl_unregister_family(&nl80211_fam);
10992 return err;
10993 }
10994
10995 void nl80211_exit(void)
10996 {
10997 netlink_unregister_notifier(&nl80211_netlink_notifier);
10998 genl_unregister_family(&nl80211_fam);
10999 }
kernel source for telekom puls (alcatel/mediatek)