projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ar9170: remove unnecessary call to ar9170_set_beacon_timers
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / net / wireless / nl80211.c
CommitLineData
55682965
JB		 1/*
2 * This is the new netlink-based wireless configuration interface.
3 *
08645126 4 * Copyright 2006-2009 Johannes Berg <johannes@sipsolutions.net>
55682965
JB		 5 */
6
7#include <linux/if.h>
8#include <linux/module.h>
9#include <linux/err.h>
55682965
JB		 10#include <linux/list.h>
11#include <linux/if_ether.h>
12#include <linux/ieee80211.h>
13#include <linux/nl80211.h>
14#include <linux/rtnetlink.h>
15#include <linux/netlink.h>
2a519311 16#include <linux/etherdevice.h>
463d0183 17#include <net/net_namespace.h>
55682965
JB		 18#include <net/genetlink.h>
19#include <net/cfg80211.h>
463d0183 20#include <net/sock.h>
55682965
JB		 21#include "core.h"
22#include "nl80211.h"
b2e1b302 23#include "reg.h"
55682965
JB		 24
25/* the netlink family */
26static struct genl_family nl80211_fam = {
27 .id = GENL_ID_GENERATE, /* don't bother with a hardcoded ID */
28 .name = "nl80211", /* have users key off the name instead */
29 .hdrsize = 0, /* no private header */
30 .version = 1, /* no particular meaning now */
31 .maxattr = NL80211_ATTR_MAX,
463d0183 32 .netnsok = true,
55682965
JB		 33};
34
79c97e97 35/* internal helper: get rdev and dev */
463d0183 36static int get_rdev_dev_by_info_ifindex(struct genl_info *info,
79c97e97 37 struct cfg80211_registered_device **rdev,
55682965
JB		 38 struct net_device **dev)
39{
463d0183 40 struct nlattr **attrs = info->attrs;
55682965
JB		 41 int ifindex;
42
bba95fef 43 if (!attrs[NL80211_ATTR_IFINDEX])
55682965
JB		 44 return -EINVAL;
45
bba95fef 46 ifindex = nla_get_u32(attrs[NL80211_ATTR_IFINDEX]);
463d0183 47 *dev = dev_get_by_index(genl_info_net(info), ifindex);
55682965
JB		 48 if (!*dev)
49 return -ENODEV;
50
463d0183 51 *rdev = cfg80211_get_dev_from_ifindex(genl_info_net(info), ifindex);
79c97e97 52 if (IS_ERR(*rdev)) {
55682965 53 dev_put(*dev);
79c97e97 54 return PTR_ERR(*rdev);
55682965
JB		 55 }
56
57 return 0;
58}
59
60/* policy for the attributes */
61static struct nla_policy nl80211_policy[NL80211_ATTR_MAX+1] __read_mostly = {
62 [NL80211_ATTR_WIPHY] = { .type = NLA_U32 },
63 [NL80211_ATTR_WIPHY_NAME] = { .type = NLA_NUL_STRING,
079e24ed 64 .len = 20-1 },
31888487 65 [NL80211_ATTR_WIPHY_TXQ_PARAMS] = { .type = NLA_NESTED },
72bdcf34 66 [NL80211_ATTR_WIPHY_FREQ] = { .type = NLA_U32 },
094d05dc 67 [NL80211_ATTR_WIPHY_CHANNEL_TYPE] = { .type = NLA_U32 },
b9a5f8ca
JM		 68 [NL80211_ATTR_WIPHY_RETRY_SHORT] = { .type = NLA_U8 },
69 [NL80211_ATTR_WIPHY_RETRY_LONG] = { .type = NLA_U8 },
70 [NL80211_ATTR_WIPHY_FRAG_THRESHOLD] = { .type = NLA_U32 },
71 [NL80211_ATTR_WIPHY_RTS_THRESHOLD] = { .type = NLA_U32 },
55682965
JB		 72
73 [NL80211_ATTR_IFTYPE] = { .type = NLA_U32 },
74 [NL80211_ATTR_IFINDEX] = { .type = NLA_U32 },
75 [NL80211_ATTR_IFNAME] = { .type = NLA_NUL_STRING, .len = IFNAMSIZ-1 },
41ade00f
JB		 76
77 [NL80211_ATTR_MAC] = { .type = NLA_BINARY, .len = ETH_ALEN },
3e5d7649 78 [NL80211_ATTR_PREV_BSSID] = { .type = NLA_BINARY, .len = ETH_ALEN },
41ade00f 79
b9454e83 80 [NL80211_ATTR_KEY] = { .type = NLA_NESTED, },
41ade00f
JB		 81 [NL80211_ATTR_KEY_DATA] = { .type = NLA_BINARY,
82 .len = WLAN_MAX_KEY_LEN },
83 [NL80211_ATTR_KEY_IDX] = { .type = NLA_U8 },
84 [NL80211_ATTR_KEY_CIPHER] = { .type = NLA_U32 },
85 [NL80211_ATTR_KEY_DEFAULT] = { .type = NLA_FLAG },
9f26a952 86 [NL80211_ATTR_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
ed1b6cc7
JB		 87
88 [NL80211_ATTR_BEACON_INTERVAL] = { .type = NLA_U32 },
89 [NL80211_ATTR_DTIM_PERIOD] = { .type = NLA_U32 },
90 [NL80211_ATTR_BEACON_HEAD] = { .type = NLA_BINARY,
91 .len = IEEE80211_MAX_DATA_LEN },
92 [NL80211_ATTR_BEACON_TAIL] = { .type = NLA_BINARY,
93 .len = IEEE80211_MAX_DATA_LEN },
5727ef1b
JB		 94 [NL80211_ATTR_STA_AID] = { .type = NLA_U16 },
95 [NL80211_ATTR_STA_FLAGS] = { .type = NLA_NESTED },
96 [NL80211_ATTR_STA_LISTEN_INTERVAL] = { .type = NLA_U16 },
97 [NL80211_ATTR_STA_SUPPORTED_RATES] = { .type = NLA_BINARY,
98 .len = NL80211_MAX_SUPP_RATES },
2ec600d6 99 [NL80211_ATTR_STA_PLINK_ACTION] = { .type = NLA_U8 },
5727ef1b 100 [NL80211_ATTR_STA_VLAN] = { .type = NLA_U32 },
0a9542ee 101 [NL80211_ATTR_MNTR_FLAGS] = { /* NLA_NESTED can't be empty */ },
2ec600d6
LCC		 102 [NL80211_ATTR_MESH_ID] = { .type = NLA_BINARY,
103 .len = IEEE80211_MAX_MESH_ID_LEN },
104 [NL80211_ATTR_MPATH_NEXT_HOP] = { .type = NLA_U32 },
9f1ba906 105
b2e1b302
LR		 106 [NL80211_ATTR_REG_ALPHA2] = { .type = NLA_STRING, .len = 2 },
107 [NL80211_ATTR_REG_RULES] = { .type = NLA_NESTED },
108
9f1ba906
JM		 109 [NL80211_ATTR_BSS_CTS_PROT] = { .type = NLA_U8 },
110 [NL80211_ATTR_BSS_SHORT_PREAMBLE] = { .type = NLA_U8 },
111 [NL80211_ATTR_BSS_SHORT_SLOT_TIME] = { .type = NLA_U8 },
90c97a04
JM		 112 [NL80211_ATTR_BSS_BASIC_RATES] = { .type = NLA_BINARY,
113 .len = NL80211_MAX_SUPP_RATES },
36aedc90 114
93da9cc1 115 [NL80211_ATTR_MESH_PARAMS] = { .type = NLA_NESTED },
116
36aedc90
JM		 117 [NL80211_ATTR_HT_CAPABILITY] = { .type = NLA_BINARY,
118 .len = NL80211_HT_CAPABILITY_LEN },
9aed3cc1
JM		 119
120 [NL80211_ATTR_MGMT_SUBTYPE] = { .type = NLA_U8 },
121 [NL80211_ATTR_IE] = { .type = NLA_BINARY,
122 .len = IEEE80211_MAX_DATA_LEN },
2a519311
JB		 123 [NL80211_ATTR_SCAN_FREQUENCIES] = { .type = NLA_NESTED },
124 [NL80211_ATTR_SCAN_SSIDS] = { .type = NLA_NESTED },
636a5d36
JM		 125
126 [NL80211_ATTR_SSID] = { .type = NLA_BINARY,
127 .len = IEEE80211_MAX_SSID_LEN },
128 [NL80211_ATTR_AUTH_TYPE] = { .type = NLA_U32 },
129 [NL80211_ATTR_REASON_CODE] = { .type = NLA_U16 },
04a773ad 130 [NL80211_ATTR_FREQ_FIXED] = { .type = NLA_FLAG },
1965c853 131 [NL80211_ATTR_TIMED_OUT] = { .type = NLA_FLAG },
dc6382ce 132 [NL80211_ATTR_USE_MFP] = { .type = NLA_U32 },
eccb8e8f
JB		 133 [NL80211_ATTR_STA_FLAGS2] = {
134 .len = sizeof(struct nl80211_sta_flag_update),
135 },
3f77316c 136 [NL80211_ATTR_CONTROL_PORT] = { .type = NLA_FLAG },
b23aa676
SO		 137 [NL80211_ATTR_PRIVACY] = { .type = NLA_FLAG },
138 [NL80211_ATTR_CIPHER_SUITE_GROUP] = { .type = NLA_U32 },
139 [NL80211_ATTR_WPA_VERSIONS] = { .type = NLA_U32 },
463d0183 140 [NL80211_ATTR_PID] = { .type = NLA_U32 },
55682965
JB		 141};
142
b9454e83
JB		 143/* policy for the attributes */
144static struct nla_policy
145nl80211_key_policy[NL80211_KEY_MAX + 1] __read_mostly = {
fffd0934 146 [NL80211_KEY_DATA] = { .type = NLA_BINARY, .len = WLAN_MAX_KEY_LEN },
b9454e83
JB		 147 [NL80211_KEY_IDX] = { .type = NLA_U8 },
148 [NL80211_KEY_CIPHER] = { .type = NLA_U32 },
149 [NL80211_KEY_SEQ] = { .type = NLA_BINARY, .len = 8 },
150 [NL80211_KEY_DEFAULT] = { .type = NLA_FLAG },
151 [NL80211_KEY_DEFAULT_MGMT] = { .type = NLA_FLAG },
152};
153
f4a11bb0
JB		 154/* IE validation */
155static bool is_valid_ie_attr(const struct nlattr *attr)
156{
157 const u8 *pos;
158 int len;
159
160 if (!attr)
161 return true;
162
163 pos = nla_data(attr);
164 len = nla_len(attr);
165
166 while (len) {
167 u8 elemlen;
168
169 if (len < 2)
170 return false;
171 len -= 2;
172
173 elemlen = pos[1];
174 if (elemlen > len)
175 return false;
176
177 len -= elemlen;
178 pos += 2 + elemlen;
179 }
180
181 return true;
182}
183
55682965
JB		 184/* message building helper */
185static inline void *nl80211hdr_put(struct sk_buff *skb, u32 pid, u32 seq,
186 int flags, u8 cmd)
187{
188 /* since there is no private header just add the generic one */
189 return genlmsg_put(skb, pid, seq, &nl80211_fam, flags, cmd);
190}
191
5dab3b8a
LR		 192static int nl80211_msg_put_channel(struct sk_buff *msg,
193 struct ieee80211_channel *chan)
194{
195 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_FREQ,
196 chan->center_freq);
197
198 if (chan->flags & IEEE80211_CHAN_DISABLED)
199 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_DISABLED);
200 if (chan->flags & IEEE80211_CHAN_PASSIVE_SCAN)
201 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_PASSIVE_SCAN);
202 if (chan->flags & IEEE80211_CHAN_NO_IBSS)
203 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_NO_IBSS);
204 if (chan->flags & IEEE80211_CHAN_RADAR)
205 NLA_PUT_FLAG(msg, NL80211_FREQUENCY_ATTR_RADAR);
206
207 NLA_PUT_U32(msg, NL80211_FREQUENCY_ATTR_MAX_TX_POWER,
208 DBM_TO_MBM(chan->max_power));
209
210 return 0;
211
212 nla_put_failure:
213 return -ENOBUFS;
214}
215
55682965
JB		 216/* netlink command implementations */
217
b9454e83
JB		 218struct key_parse {
219 struct key_params p;
220 int idx;
221 bool def, defmgmt;
222};
223
224static int nl80211_parse_key_new(struct nlattr *key, struct key_parse *k)
225{
226 struct nlattr *tb[NL80211_KEY_MAX + 1];
227 int err = nla_parse_nested(tb, NL80211_KEY_MAX, key,
228 nl80211_key_policy);
229 if (err)
230 return err;
231
232 k->def = !!tb[NL80211_KEY_DEFAULT];
233 k->defmgmt = !!tb[NL80211_KEY_DEFAULT_MGMT];
234
235 if (tb[NL80211_KEY_IDX])
236 k->idx = nla_get_u8(tb[NL80211_KEY_IDX]);
237
238 if (tb[NL80211_KEY_DATA]) {
239 k->p.key = nla_data(tb[NL80211_KEY_DATA]);
240 k->p.key_len = nla_len(tb[NL80211_KEY_DATA]);
241 }
242
243 if (tb[NL80211_KEY_SEQ]) {
244 k->p.seq = nla_data(tb[NL80211_KEY_SEQ]);
245 k->p.seq_len = nla_len(tb[NL80211_KEY_SEQ]);
246 }
247
248 if (tb[NL80211_KEY_CIPHER])
249 k->p.cipher = nla_get_u32(tb[NL80211_KEY_CIPHER]);
250
251 return 0;
252}
253
254static int nl80211_parse_key_old(struct genl_info *info, struct key_parse *k)
255{
256 if (info->attrs[NL80211_ATTR_KEY_DATA]) {
257 k->p.key = nla_data(info->attrs[NL80211_ATTR_KEY_DATA]);
258 k->p.key_len = nla_len(info->attrs[NL80211_ATTR_KEY_DATA]);
259 }
260
261 if (info->attrs[NL80211_ATTR_KEY_SEQ]) {
262 k->p.seq = nla_data(info->attrs[NL80211_ATTR_KEY_SEQ]);
263 k->p.seq_len = nla_len(info->attrs[NL80211_ATTR_KEY_SEQ]);
264 }
265
266 if (info->attrs[NL80211_ATTR_KEY_IDX])
267 k->idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
268
269 if (info->attrs[NL80211_ATTR_KEY_CIPHER])
270 k->p.cipher = nla_get_u32(info->attrs[NL80211_ATTR_KEY_CIPHER]);
271
272 k->def = !!info->attrs[NL80211_ATTR_KEY_DEFAULT];
273 k->defmgmt = !!info->attrs[NL80211_ATTR_KEY_DEFAULT_MGMT];
274
275 return 0;
276}
277
278static int nl80211_parse_key(struct genl_info *info, struct key_parse *k)
279{
280 int err;
281
282 memset(k, 0, sizeof(*k));
283 k->idx = -1;
284
285 if (info->attrs[NL80211_ATTR_KEY])
286 err = nl80211_parse_key_new(info->attrs[NL80211_ATTR_KEY], k);
287 else
288 err = nl80211_parse_key_old(info, k);
289
290 if (err)
291 return err;
292
293 if (k->def && k->defmgmt)
294 return -EINVAL;
295
296 if (k->idx != -1) {
297 if (k->defmgmt) {
298 if (k->idx < 4 || k->idx > 5)
299 return -EINVAL;
300 } else if (k->def) {
301 if (k->idx < 0 || k->idx > 3)
302 return -EINVAL;
303 } else {
304 if (k->idx < 0 || k->idx > 5)
305 return -EINVAL;
306 }
307 }
308
309 return 0;
310}
311
fffd0934
JB		 312static struct cfg80211_cached_keys *
313nl80211_parse_connkeys(struct cfg80211_registered_device *rdev,
314 struct nlattr *keys)
315{
316 struct key_parse parse;
317 struct nlattr *key;
318 struct cfg80211_cached_keys *result;
319 int rem, err, def = 0;
320
321 result = kzalloc(sizeof(*result), GFP_KERNEL);
322 if (!result)
323 return ERR_PTR(-ENOMEM);
324
325 result->def = -1;
326 result->defmgmt = -1;
327
328 nla_for_each_nested(key, keys, rem) {
329 memset(&parse, 0, sizeof(parse));
330 parse.idx = -1;
331
332 err = nl80211_parse_key_new(key, &parse);
333 if (err)
334 goto error;
335 err = -EINVAL;
336 if (!parse.p.key)
337 goto error;
338 if (parse.idx < 0 || parse.idx > 4)
339 goto error;
340 if (parse.def) {
341 if (def)
342 goto error;
343 def = 1;
344 result->def = parse.idx;
345 } else if (parse.defmgmt)
346 goto error;
347 err = cfg80211_validate_key_settings(rdev, &parse.p,
348 parse.idx, NULL);
349 if (err)
350 goto error;
351 result->params[parse.idx].cipher = parse.p.cipher;
352 result->params[parse.idx].key_len = parse.p.key_len;
353 result->params[parse.idx].key = result->data[parse.idx];
354 memcpy(result->data[parse.idx], parse.p.key, parse.p.key_len);
355 }
356
357 return result;
358 error:
359 kfree(result);
360 return ERR_PTR(err);
361}
362
363static int nl80211_key_allowed(struct wireless_dev *wdev)
364{
365 ASSERT_WDEV_LOCK(wdev);
366
367 if (!netif_running(wdev->netdev))
368 return -ENETDOWN;
369
370 switch (wdev->iftype) {
371 case NL80211_IFTYPE_AP:
372 case NL80211_IFTYPE_AP_VLAN:
373 break;
374 case NL80211_IFTYPE_ADHOC:
375 if (!wdev->current_bss)
376 return -ENOLINK;
377 break;
378 case NL80211_IFTYPE_STATION:
379 if (wdev->sme_state != CFG80211_SME_CONNECTED)
380 return -ENOLINK;
381 break;
382 default:
383 return -EINVAL;
384 }
385
386 return 0;
387}
388
55682965
JB		 389static int nl80211_send_wiphy(struct sk_buff *msg, u32 pid, u32 seq, int flags,
390 struct cfg80211_registered_device *dev)
391{
392 void *hdr;
ee688b00
JB		 393 struct nlattr *nl_bands, *nl_band;
394 struct nlattr *nl_freqs, *nl_freq;
395 struct nlattr *nl_rates, *nl_rate;
f59ac048 396 struct nlattr *nl_modes;
8fdc621d 397 struct nlattr *nl_cmds;
ee688b00
JB		 398 enum ieee80211_band band;
399 struct ieee80211_channel *chan;
400 struct ieee80211_rate *rate;
401 int i;
f59ac048 402 u16 ifmodes = dev->wiphy.interface_modes;
55682965
JB		 403
404 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_WIPHY);
405 if (!hdr)
406 return -1;
407
b5850a7a 408 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, dev->wiphy_idx);
55682965 409 NLA_PUT_STRING(msg, NL80211_ATTR_WIPHY_NAME, wiphy_name(&dev->wiphy));
b9a5f8ca 410
f5ea9120
JB		 411 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION,
412 cfg80211_rdev_list_generation);
413
b9a5f8ca
JM		 414 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_SHORT,
415 dev->wiphy.retry_short);
416 NLA_PUT_U8(msg, NL80211_ATTR_WIPHY_RETRY_LONG,
417 dev->wiphy.retry_long);
418 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_FRAG_THRESHOLD,
419 dev->wiphy.frag_threshold);
420 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY_RTS_THRESHOLD,
421 dev->wiphy.rts_threshold);
422
2a519311
JB		 423 NLA_PUT_U8(msg, NL80211_ATTR_MAX_NUM_SCAN_SSIDS,
424 dev->wiphy.max_scan_ssids);
18a83659
JB		 425 NLA_PUT_U16(msg, NL80211_ATTR_MAX_SCAN_IE_LEN,
426 dev->wiphy.max_scan_ie_len);
ee688b00 427
25e47c18
JB		 428 NLA_PUT(msg, NL80211_ATTR_CIPHER_SUITES,
429 sizeof(u32) * dev->wiphy.n_cipher_suites,
430 dev->wiphy.cipher_suites);
431
f59ac048
LR		 432 nl_modes = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_IFTYPES);
433 if (!nl_modes)
434 goto nla_put_failure;
435
436 i = 0;
437 while (ifmodes) {
438 if (ifmodes & 1)
439 NLA_PUT_FLAG(msg, i);
440 ifmodes >>= 1;
441 i++;
442 }
443
444 nla_nest_end(msg, nl_modes);
445
ee688b00
JB		 446 nl_bands = nla_nest_start(msg, NL80211_ATTR_WIPHY_BANDS);
447 if (!nl_bands)
448 goto nla_put_failure;
449
450 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
451 if (!dev->wiphy.bands[band])
452 continue;
453
454 nl_band = nla_nest_start(msg, band);
455 if (!nl_band)
456 goto nla_put_failure;
457
d51626df
JB		 458 /* add HT info */
459 if (dev->wiphy.bands[band]->ht_cap.ht_supported) {
460 NLA_PUT(msg, NL80211_BAND_ATTR_HT_MCS_SET,
461 sizeof(dev->wiphy.bands[band]->ht_cap.mcs),
462 &dev->wiphy.bands[band]->ht_cap.mcs);
463 NLA_PUT_U16(msg, NL80211_BAND_ATTR_HT_CAPA,
464 dev->wiphy.bands[band]->ht_cap.cap);
465 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_FACTOR,
466 dev->wiphy.bands[band]->ht_cap.ampdu_factor);
467 NLA_PUT_U8(msg, NL80211_BAND_ATTR_HT_AMPDU_DENSITY,
468 dev->wiphy.bands[band]->ht_cap.ampdu_density);
469 }
470
ee688b00
JB		 471 /* add frequencies */
472 nl_freqs = nla_nest_start(msg, NL80211_BAND_ATTR_FREQS);
473 if (!nl_freqs)
474 goto nla_put_failure;
475
476 for (i = 0; i < dev->wiphy.bands[band]->n_channels; i++) {
477 nl_freq = nla_nest_start(msg, i);
478 if (!nl_freq)
479 goto nla_put_failure;
480
481 chan = &dev->wiphy.bands[band]->channels[i];
5dab3b8a
LR		 482
483 if (nl80211_msg_put_channel(msg, chan))
484 goto nla_put_failure;
e2f367f2 485
ee688b00
JB		 486 nla_nest_end(msg, nl_freq);
487 }
488
489 nla_nest_end(msg, nl_freqs);
490
491 /* add bitrates */
492 nl_rates = nla_nest_start(msg, NL80211_BAND_ATTR_RATES);
493 if (!nl_rates)
494 goto nla_put_failure;
495
496 for (i = 0; i < dev->wiphy.bands[band]->n_bitrates; i++) {
497 nl_rate = nla_nest_start(msg, i);
498 if (!nl_rate)
499 goto nla_put_failure;
500
501 rate = &dev->wiphy.bands[band]->bitrates[i];
502 NLA_PUT_U32(msg, NL80211_BITRATE_ATTR_RATE,
503 rate->bitrate);
504 if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE)
505 NLA_PUT_FLAG(msg,
506 NL80211_BITRATE_ATTR_2GHZ_SHORTPREAMBLE);
507
508 nla_nest_end(msg, nl_rate);
509 }
510
511 nla_nest_end(msg, nl_rates);
512
513 nla_nest_end(msg, nl_band);
514 }
515 nla_nest_end(msg, nl_bands);
516
8fdc621d
JB		 517 nl_cmds = nla_nest_start(msg, NL80211_ATTR_SUPPORTED_COMMANDS);
518 if (!nl_cmds)
519 goto nla_put_failure;
520
521 i = 0;
522#define CMD(op, n) \
523 do { \
524 if (dev->ops->op) { \
525 i++; \
526 NLA_PUT_U32(msg, i, NL80211_CMD_ ## n); \
527 } \
528 } while (0)
529
530 CMD(add_virtual_intf, NEW_INTERFACE);
531 CMD(change_virtual_intf, SET_INTERFACE);
532 CMD(add_key, NEW_KEY);
533 CMD(add_beacon, NEW_BEACON);
534 CMD(add_station, NEW_STATION);
535 CMD(add_mpath, NEW_MPATH);
536 CMD(set_mesh_params, SET_MESH_PARAMS);
537 CMD(change_bss, SET_BSS);
636a5d36
JM		 538 CMD(auth, AUTHENTICATE);
539 CMD(assoc, ASSOCIATE);
540 CMD(deauth, DEAUTHENTICATE);
541 CMD(disassoc, DISASSOCIATE);
04a773ad 542 CMD(join_ibss, JOIN_IBSS);
463d0183
JB		 543 if (dev->wiphy.netnsok) {
544 i++;
545 NLA_PUT_U32(msg, i, NL80211_CMD_SET_WIPHY_NETNS);
546 }
8fdc621d
JB		 547
548#undef CMD
b23aa676 549
6829c878 550 if (dev->ops->connect || dev->ops->auth) {
b23aa676
SO		 551 i++;
552 NLA_PUT_U32(msg, i, NL80211_CMD_CONNECT);
553 }
554
6829c878 555 if (dev->ops->disconnect || dev->ops->deauth) {
b23aa676
SO		 556 i++;
557 NLA_PUT_U32(msg, i, NL80211_CMD_DISCONNECT);
558 }
559
8fdc621d
JB		 560 nla_nest_end(msg, nl_cmds);
561
55682965
JB		 562 return genlmsg_end(msg, hdr);
563
564 nla_put_failure:
bc3ed28c
TG		 565 genlmsg_cancel(msg, hdr);
566 return -EMSGSIZE;
55682965
JB		 567}
568
569static int nl80211_dump_wiphy(struct sk_buff *skb, struct netlink_callback *cb)
570{
571 int idx = 0;
572 int start = cb->args[0];
573 struct cfg80211_registered_device *dev;
574
a1794390 575 mutex_lock(&cfg80211_mutex);
79c97e97 576 list_for_each_entry(dev, &cfg80211_rdev_list, list) {
463d0183
JB		 577 if (!net_eq(wiphy_net(&dev->wiphy), sock_net(skb->sk)))
578 continue;
b4637271 579 if (++idx <= start)
55682965
JB		 580 continue;
581 if (nl80211_send_wiphy(skb, NETLINK_CB(cb->skb).pid,
582 cb->nlh->nlmsg_seq, NLM_F_MULTI,
b4637271
JV		 583 dev) < 0) {
584 idx--;
55682965 585 break;
b4637271 586 }
55682965 587 }
a1794390 588 mutex_unlock(&cfg80211_mutex);
55682965
JB		 589
590 cb->args[0] = idx;
591
592 return skb->len;
593}
594
595static int nl80211_get_wiphy(struct sk_buff *skb, struct genl_info *info)
596{
597 struct sk_buff *msg;
598 struct cfg80211_registered_device *dev;
599
600 dev = cfg80211_get_dev_from_info(info);
601 if (IS_ERR(dev))
602 return PTR_ERR(dev);
603
fd2120ca 604 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 605 if (!msg)
606 goto out_err;
607
608 if (nl80211_send_wiphy(msg, info->snd_pid, info->snd_seq, 0, dev) < 0)
609 goto out_free;
610
4d0c8aea 611 cfg80211_unlock_rdev(dev);
55682965 612
134e6375 613 return genlmsg_reply(msg, info);
55682965
JB		 614
615 out_free:
616 nlmsg_free(msg);
617 out_err:
4d0c8aea 618 cfg80211_unlock_rdev(dev);
55682965
JB		 619 return -ENOBUFS;
620}
621
31888487
JM		 622static const struct nla_policy txq_params_policy[NL80211_TXQ_ATTR_MAX + 1] = {
623 [NL80211_TXQ_ATTR_QUEUE] = { .type = NLA_U8 },
624 [NL80211_TXQ_ATTR_TXOP] = { .type = NLA_U16 },
625 [NL80211_TXQ_ATTR_CWMIN] = { .type = NLA_U16 },
626 [NL80211_TXQ_ATTR_CWMAX] = { .type = NLA_U16 },
627 [NL80211_TXQ_ATTR_AIFS] = { .type = NLA_U8 },
628};
629
630static int parse_txq_params(struct nlattr *tb[],
631 struct ieee80211_txq_params *txq_params)
632{
633 if (!tb[NL80211_TXQ_ATTR_QUEUE] || !tb[NL80211_TXQ_ATTR_TXOP] ||
634 !tb[NL80211_TXQ_ATTR_CWMIN] || !tb[NL80211_TXQ_ATTR_CWMAX] ||
635 !tb[NL80211_TXQ_ATTR_AIFS])
636 return -EINVAL;
637
638 txq_params->queue = nla_get_u8(tb[NL80211_TXQ_ATTR_QUEUE]);
639 txq_params->txop = nla_get_u16(tb[NL80211_TXQ_ATTR_TXOP]);
640 txq_params->cwmin = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMIN]);
641 txq_params->cwmax = nla_get_u16(tb[NL80211_TXQ_ATTR_CWMAX]);
642 txq_params->aifs = nla_get_u8(tb[NL80211_TXQ_ATTR_AIFS]);
643
644 return 0;
645}
646
55682965
JB		 647static int nl80211_set_wiphy(struct sk_buff *skb, struct genl_info *info)
648{
649 struct cfg80211_registered_device *rdev;
31888487
JM		 650 int result = 0, rem_txq_params = 0;
651 struct nlattr *nl_txq_params;
b9a5f8ca
JM		 652 u32 changed;
653 u8 retry_short = 0, retry_long = 0;
654 u32 frag_threshold = 0, rts_threshold = 0;
55682965 655
4bbf4d56 656 rtnl_lock();
55682965 657
4bbf4d56
JB		 658 mutex_lock(&cfg80211_mutex);
659
79c97e97 660 rdev = __cfg80211_rdev_from_info(info);
4bbf4d56 661 if (IS_ERR(rdev)) {
1f5fc70a 662 mutex_unlock(&cfg80211_mutex);
4bbf4d56
JB		 663 result = PTR_ERR(rdev);
664 goto unlock;
665 }
666
667 mutex_lock(&rdev->mtx);
668
669 if (info->attrs[NL80211_ATTR_WIPHY_NAME])
31888487
JM		 670 result = cfg80211_dev_rename(
671 rdev, nla_data(info->attrs[NL80211_ATTR_WIPHY_NAME]));
4bbf4d56
JB		 672
673 mutex_unlock(&cfg80211_mutex);
674
675 if (result)
676 goto bad_res;
31888487
JM		 677
678 if (info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS]) {
679 struct ieee80211_txq_params txq_params;
680 struct nlattr *tb[NL80211_TXQ_ATTR_MAX + 1];
681
682 if (!rdev->ops->set_txq_params) {
683 result = -EOPNOTSUPP;
684 goto bad_res;
685 }
686
687 nla_for_each_nested(nl_txq_params,
688 info->attrs[NL80211_ATTR_WIPHY_TXQ_PARAMS],
689 rem_txq_params) {
690 nla_parse(tb, NL80211_TXQ_ATTR_MAX,
691 nla_data(nl_txq_params),
692 nla_len(nl_txq_params),
693 txq_params_policy);
694 result = parse_txq_params(tb, &txq_params);
695 if (result)
696 goto bad_res;
697
698 result = rdev->ops->set_txq_params(&rdev->wiphy,
699 &txq_params);
700 if (result)
701 goto bad_res;
702 }
703 }
55682965 704
72bdcf34 705 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
094d05dc 706 enum nl80211_channel_type channel_type = NL80211_CHAN_NO_HT;
294196ab 707 u32 freq;
72bdcf34 708
306d6112
JB		 709 result = -EINVAL;
710
094d05dc
S		 711 if (info->attrs[NL80211_ATTR_WIPHY_CHANNEL_TYPE]) {
712 channel_type = nla_get_u32(info->attrs[
713 NL80211_ATTR_WIPHY_CHANNEL_TYPE]);
714 if (channel_type != NL80211_CHAN_NO_HT &&
715 channel_type != NL80211_CHAN_HT20 &&
716 channel_type != NL80211_CHAN_HT40PLUS &&
717 channel_type != NL80211_CHAN_HT40MINUS)
72bdcf34 718 goto bad_res;
72bdcf34
JM		 719 }
720
721 freq = nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]);
306d6112 722
59bbb6f7 723 mutex_lock(&rdev->devlist_mtx);
4b181144 724 result = rdev_set_freq(rdev, NULL, freq, channel_type);
59bbb6f7 725 mutex_unlock(&rdev->devlist_mtx);
72bdcf34
JM		 726 if (result)
727 goto bad_res;
728 }
729
b9a5f8ca
JM		 730 changed = 0;
731
732 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]) {
733 retry_short = nla_get_u8(
734 info->attrs[NL80211_ATTR_WIPHY_RETRY_SHORT]);
735 if (retry_short == 0) {
736 result = -EINVAL;
737 goto bad_res;
738 }
739 changed |= WIPHY_PARAM_RETRY_SHORT;
740 }
741
742 if (info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]) {
743 retry_long = nla_get_u8(
744 info->attrs[NL80211_ATTR_WIPHY_RETRY_LONG]);
745 if (retry_long == 0) {
746 result = -EINVAL;
747 goto bad_res;
748 }
749 changed |= WIPHY_PARAM_RETRY_LONG;
750 }
751
752 if (info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]) {
753 frag_threshold = nla_get_u32(
754 info->attrs[NL80211_ATTR_WIPHY_FRAG_THRESHOLD]);
755 if (frag_threshold < 256) {
756 result = -EINVAL;
757 goto bad_res;
758 }
759 if (frag_threshold != (u32) -1) {
760 /*
761 * Fragments (apart from the last one) are required to
762 * have even length. Make the fragmentation code
763 * simpler by stripping LSB should someone try to use
764 * odd threshold value.
765 */
766 frag_threshold &= ~0x1;
767 }
768 changed |= WIPHY_PARAM_FRAG_THRESHOLD;
769 }
770
771 if (info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]) {
772 rts_threshold = nla_get_u32(
773 info->attrs[NL80211_ATTR_WIPHY_RTS_THRESHOLD]);
774 changed |= WIPHY_PARAM_RTS_THRESHOLD;
775 }
776
777 if (changed) {
778 u8 old_retry_short, old_retry_long;
779 u32 old_frag_threshold, old_rts_threshold;
780
781 if (!rdev->ops->set_wiphy_params) {
782 result = -EOPNOTSUPP;
783 goto bad_res;
784 }
785
786 old_retry_short = rdev->wiphy.retry_short;
787 old_retry_long = rdev->wiphy.retry_long;
788 old_frag_threshold = rdev->wiphy.frag_threshold;
789 old_rts_threshold = rdev->wiphy.rts_threshold;
790
791 if (changed & WIPHY_PARAM_RETRY_SHORT)
792 rdev->wiphy.retry_short = retry_short;
793 if (changed & WIPHY_PARAM_RETRY_LONG)
794 rdev->wiphy.retry_long = retry_long;
795 if (changed & WIPHY_PARAM_FRAG_THRESHOLD)
796 rdev->wiphy.frag_threshold = frag_threshold;
797 if (changed & WIPHY_PARAM_RTS_THRESHOLD)
798 rdev->wiphy.rts_threshold = rts_threshold;
799
800 result = rdev->ops->set_wiphy_params(&rdev->wiphy, changed);
801 if (result) {
802 rdev->wiphy.retry_short = old_retry_short;
803 rdev->wiphy.retry_long = old_retry_long;
804 rdev->wiphy.frag_threshold = old_frag_threshold;
805 rdev->wiphy.rts_threshold = old_rts_threshold;
806 }
807 }
72bdcf34 808
306d6112 809 bad_res:
4bbf4d56
JB		 810 mutex_unlock(&rdev->mtx);
811 unlock:
812 rtnl_unlock();
55682965
JB		 813 return result;
814}
815
816
817static int nl80211_send_iface(struct sk_buff *msg, u32 pid, u32 seq, int flags,
d726405a 818 struct cfg80211_registered_device *rdev,
55682965
JB		 819 struct net_device *dev)
820{
821 void *hdr;
822
823 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_INTERFACE);
824 if (!hdr)
825 return -1;
826
827 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
d726405a 828 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
55682965 829 NLA_PUT_STRING(msg, NL80211_ATTR_IFNAME, dev->name);
60719ffd 830 NLA_PUT_U32(msg, NL80211_ATTR_IFTYPE, dev->ieee80211_ptr->iftype);
f5ea9120
JB		 831
832 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION,
833 rdev->devlist_generation ^
834 (cfg80211_rdev_list_generation << 2));
835
55682965
JB		 836 return genlmsg_end(msg, hdr);
837
838 nla_put_failure:
bc3ed28c
TG		 839 genlmsg_cancel(msg, hdr);
840 return -EMSGSIZE;
55682965
JB		 841}
842
843static int nl80211_dump_interface(struct sk_buff *skb, struct netlink_callback *cb)
844{
845 int wp_idx = 0;
846 int if_idx = 0;
847 int wp_start = cb->args[0];
848 int if_start = cb->args[1];
f5ea9120 849 struct cfg80211_registered_device *rdev;
55682965
JB		 850 struct wireless_dev *wdev;
851
a1794390 852 mutex_lock(&cfg80211_mutex);
f5ea9120
JB		 853 list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
854 if (!net_eq(wiphy_net(&rdev->wiphy), sock_net(skb->sk)))
463d0183 855 continue;
bba95fef
JB		 856 if (wp_idx < wp_start) {
857 wp_idx++;
55682965 858 continue;
bba95fef 859 }
55682965
JB		 860 if_idx = 0;
861
f5ea9120
JB		 862 mutex_lock(&rdev->devlist_mtx);
863 list_for_each_entry(wdev, &rdev->netdev_list, list) {
bba95fef
JB		 864 if (if_idx < if_start) {
865 if_idx++;
55682965 866 continue;
bba95fef 867 }
55682965
JB		 868 if (nl80211_send_iface(skb, NETLINK_CB(cb->skb).pid,
869 cb->nlh->nlmsg_seq, NLM_F_MULTI,
f5ea9120
JB		 870 rdev, wdev->netdev) < 0) {
871 mutex_unlock(&rdev->devlist_mtx);
bba95fef
JB		 872 goto out;
873 }
874 if_idx++;
55682965 875 }
f5ea9120 876 mutex_unlock(&rdev->devlist_mtx);
bba95fef
JB		 877
878 wp_idx++;
55682965 879 }
bba95fef 880 out:
a1794390 881 mutex_unlock(&cfg80211_mutex);
55682965
JB		 882
883 cb->args[0] = wp_idx;
884 cb->args[1] = if_idx;
885
886 return skb->len;
887}
888
889static int nl80211_get_interface(struct sk_buff *skb, struct genl_info *info)
890{
891 struct sk_buff *msg;
892 struct cfg80211_registered_device *dev;
893 struct net_device *netdev;
894 int err;
895
463d0183 896 err = get_rdev_dev_by_info_ifindex(info, &dev, &netdev);
55682965
JB		 897 if (err)
898 return err;
899
fd2120ca 900 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 901 if (!msg)
902 goto out_err;
903
d726405a
JB		 904 if (nl80211_send_iface(msg, info->snd_pid, info->snd_seq, 0,
905 dev, netdev) < 0)
55682965
JB		 906 goto out_free;
907
908 dev_put(netdev);
4d0c8aea 909 cfg80211_unlock_rdev(dev);
55682965 910
134e6375 911 return genlmsg_reply(msg, info);
55682965
JB		 912
913 out_free:
914 nlmsg_free(msg);
915 out_err:
916 dev_put(netdev);
4d0c8aea 917 cfg80211_unlock_rdev(dev);
55682965
JB		 918 return -ENOBUFS;
919}
920
66f7ac50
MW		 921static const struct nla_policy mntr_flags_policy[NL80211_MNTR_FLAG_MAX + 1] = {
922 [NL80211_MNTR_FLAG_FCSFAIL] = { .type = NLA_FLAG },
923 [NL80211_MNTR_FLAG_PLCPFAIL] = { .type = NLA_FLAG },
924 [NL80211_MNTR_FLAG_CONTROL] = { .type = NLA_FLAG },
925 [NL80211_MNTR_FLAG_OTHER_BSS] = { .type = NLA_FLAG },
926 [NL80211_MNTR_FLAG_COOK_FRAMES] = { .type = NLA_FLAG },
927};
928
929static int parse_monitor_flags(struct nlattr *nla, u32 *mntrflags)
930{
931 struct nlattr *flags[NL80211_MNTR_FLAG_MAX + 1];
932 int flag;
933
934 *mntrflags = 0;
935
936 if (!nla)
937 return -EINVAL;
938
939 if (nla_parse_nested(flags, NL80211_MNTR_FLAG_MAX,
940 nla, mntr_flags_policy))
941 return -EINVAL;
942
943 for (flag = 1; flag <= NL80211_MNTR_FLAG_MAX; flag++)
944 if (flags[flag])
945 *mntrflags |= (1<<flag);
946
947 return 0;
948}
949
55682965
JB		 950static int nl80211_set_interface(struct sk_buff *skb, struct genl_info *info)
951{
79c97e97 952 struct cfg80211_registered_device *rdev;
2ec600d6 953 struct vif_params params;
e36d56b6 954 int err;
04a773ad 955 enum nl80211_iftype otype, ntype;
55682965 956 struct net_device *dev;
92ffe055 957 u32 _flags, *flags = NULL;
ac7f9cfa 958 bool change = false;
55682965 959
2ec600d6
LCC		 960 memset(&params, 0, sizeof(params));
961
3b85875a
JB		 962 rtnl_lock();
963
463d0183 964 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
55682965 965 if (err)
3b85875a
JB		 966 goto unlock_rtnl;
967
04a773ad 968 otype = ntype = dev->ieee80211_ptr->iftype;
55682965 969
723b038d 970 if (info->attrs[NL80211_ATTR_IFTYPE]) {
ac7f9cfa 971 ntype = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
04a773ad 972 if (otype != ntype)
ac7f9cfa 973 change = true;
04a773ad 974 if (ntype > NL80211_IFTYPE_MAX) {
ac7f9cfa 975 err = -EINVAL;
723b038d 976 goto unlock;
ac7f9cfa 977 }
723b038d
JB		 978 }
979
92ffe055 980 if (info->attrs[NL80211_ATTR_MESH_ID]) {
04a773ad 981 if (ntype != NL80211_IFTYPE_MESH_POINT) {
92ffe055
JB		 982 err = -EINVAL;
983 goto unlock;
984 }
2ec600d6
LCC		 985 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
986 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
ac7f9cfa 987 change = true;
2ec600d6
LCC		 988 }
989
92ffe055 990 if (info->attrs[NL80211_ATTR_MNTR_FLAGS]) {
04a773ad 991 if (ntype != NL80211_IFTYPE_MONITOR) {
92ffe055
JB		 992 err = -EINVAL;
993 goto unlock;
994 }
995 err = parse_monitor_flags(info->attrs[NL80211_ATTR_MNTR_FLAGS],
996 &_flags);
ac7f9cfa
JB		 997 if (err)
998 goto unlock;
999
1000 flags = &_flags;
1001 change = true;
92ffe055 1002 }
3b85875a 1003
ac7f9cfa 1004 if (change)
3d54d255 1005 err = cfg80211_change_iface(rdev, dev, ntype, flags, &params);
ac7f9cfa
JB		 1006 else
1007 err = 0;
60719ffd 1008
55682965 1009 unlock:
e36d56b6 1010 dev_put(dev);
79c97e97 1011 cfg80211_unlock_rdev(rdev);
3b85875a
JB		 1012 unlock_rtnl:
1013 rtnl_unlock();
55682965
JB		 1014 return err;
1015}
1016
1017static int nl80211_new_interface(struct sk_buff *skb, struct genl_info *info)
1018{
79c97e97 1019 struct cfg80211_registered_device *rdev;
2ec600d6 1020 struct vif_params params;
55682965
JB		 1021 int err;
1022 enum nl80211_iftype type = NL80211_IFTYPE_UNSPECIFIED;
66f7ac50 1023 u32 flags;
55682965 1024
2ec600d6
LCC		 1025 memset(&params, 0, sizeof(params));
1026
55682965
JB		 1027 if (!info->attrs[NL80211_ATTR_IFNAME])
1028 return -EINVAL;
1029
1030 if (info->attrs[NL80211_ATTR_IFTYPE]) {
1031 type = nla_get_u32(info->attrs[NL80211_ATTR_IFTYPE]);
1032 if (type > NL80211_IFTYPE_MAX)
1033 return -EINVAL;
1034 }
1035
3b85875a
JB		 1036 rtnl_lock();
1037
79c97e97
JB		 1038 rdev = cfg80211_get_dev_from_info(info);
1039 if (IS_ERR(rdev)) {
1040 err = PTR_ERR(rdev);
3b85875a
JB		 1041 goto unlock_rtnl;
1042 }
55682965 1043
79c97e97
JB		 1044 if (!rdev->ops->add_virtual_intf ||
1045 !(rdev->wiphy.interface_modes & (1 << type))) {
55682965
JB		 1046 err = -EOPNOTSUPP;
1047 goto unlock;
1048 }
1049
2ec600d6
LCC		 1050 if (type == NL80211_IFTYPE_MESH_POINT &&
1051 info->attrs[NL80211_ATTR_MESH_ID]) {
1052 params.mesh_id = nla_data(info->attrs[NL80211_ATTR_MESH_ID]);
1053 params.mesh_id_len = nla_len(info->attrs[NL80211_ATTR_MESH_ID]);
1054 }
1055
66f7ac50
MW		 1056 err = parse_monitor_flags(type == NL80211_IFTYPE_MONITOR ?
1057 info->attrs[NL80211_ATTR_MNTR_FLAGS] : NULL,
1058 &flags);
79c97e97 1059 err = rdev->ops->add_virtual_intf(&rdev->wiphy,
66f7ac50 1060 nla_data(info->attrs[NL80211_ATTR_IFNAME]),
2ec600d6 1061 type, err ? NULL : &flags, &params);
2ec600d6 1062
55682965 1063 unlock:
79c97e97 1064 cfg80211_unlock_rdev(rdev);
3b85875a
JB		 1065 unlock_rtnl:
1066 rtnl_unlock();
55682965
JB		 1067 return err;
1068}
1069
1070static int nl80211_del_interface(struct sk_buff *skb, struct genl_info *info)
1071{
79c97e97 1072 struct cfg80211_registered_device *rdev;
463d0183 1073 int err;
55682965
JB		 1074 struct net_device *dev;
1075
3b85875a
JB		 1076 rtnl_lock();
1077
463d0183 1078 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
55682965 1079 if (err)
3b85875a 1080 goto unlock_rtnl;
55682965 1081
79c97e97 1082 if (!rdev->ops->del_virtual_intf) {
55682965
JB		 1083 err = -EOPNOTSUPP;
1084 goto out;
1085 }
1086
463d0183 1087 err = rdev->ops->del_virtual_intf(&rdev->wiphy, dev);
55682965
JB		 1088
1089 out:
79c97e97 1090 cfg80211_unlock_rdev(rdev);
463d0183 1091 dev_put(dev);
3b85875a
JB		 1092 unlock_rtnl:
1093 rtnl_unlock();
55682965
JB		 1094 return err;
1095}
1096
41ade00f
JB		 1097struct get_key_cookie {
1098 struct sk_buff *msg;
1099 int error;
b9454e83 1100 int idx;
41ade00f
JB		 1101};
1102
1103static void get_key_callback(void *c, struct key_params *params)
1104{
b9454e83 1105 struct nlattr *key;
41ade00f
JB		 1106 struct get_key_cookie *cookie = c;
1107
1108 if (params->key)
1109 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_DATA,
1110 params->key_len, params->key);
1111
1112 if (params->seq)
1113 NLA_PUT(cookie->msg, NL80211_ATTR_KEY_SEQ,
1114 params->seq_len, params->seq);
1115
1116 if (params->cipher)
1117 NLA_PUT_U32(cookie->msg, NL80211_ATTR_KEY_CIPHER,
1118 params->cipher);
1119
b9454e83
JB		 1120 key = nla_nest_start(cookie->msg, NL80211_ATTR_KEY);
1121 if (!key)
1122 goto nla_put_failure;
1123
1124 if (params->key)
1125 NLA_PUT(cookie->msg, NL80211_KEY_DATA,
1126 params->key_len, params->key);
1127
1128 if (params->seq)
1129 NLA_PUT(cookie->msg, NL80211_KEY_SEQ,
1130 params->seq_len, params->seq);
1131
1132 if (params->cipher)
1133 NLA_PUT_U32(cookie->msg, NL80211_KEY_CIPHER,
1134 params->cipher);
1135
1136 NLA_PUT_U8(cookie->msg, NL80211_ATTR_KEY_IDX, cookie->idx);
1137
1138 nla_nest_end(cookie->msg, key);
1139
41ade00f
JB		 1140 return;
1141 nla_put_failure:
1142 cookie->error = 1;
1143}
1144
1145static int nl80211_get_key(struct sk_buff *skb, struct genl_info *info)
1146{
79c97e97 1147 struct cfg80211_registered_device *rdev;
41ade00f
JB		 1148 int err;
1149 struct net_device *dev;
1150 u8 key_idx = 0;
1151 u8 *mac_addr = NULL;
1152 struct get_key_cookie cookie = {
1153 .error = 0,
1154 };
1155 void *hdr;
1156 struct sk_buff *msg;
1157
1158 if (info->attrs[NL80211_ATTR_KEY_IDX])
1159 key_idx = nla_get_u8(info->attrs[NL80211_ATTR_KEY_IDX]);
1160
3cfcf6ac 1161 if (key_idx > 5)
41ade00f
JB		 1162 return -EINVAL;
1163
1164 if (info->attrs[NL80211_ATTR_MAC])
1165 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1166
3b85875a
JB		 1167 rtnl_lock();
1168
463d0183 1169 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
41ade00f 1170 if (err)
3b85875a 1171 goto unlock_rtnl;
41ade00f 1172
79c97e97 1173 if (!rdev->ops->get_key) {
41ade00f
JB		 1174 err = -EOPNOTSUPP;
1175 goto out;
1176 }
1177
fd2120ca 1178 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
41ade00f
JB		 1179 if (!msg) {
1180 err = -ENOMEM;
1181 goto out;
1182 }
1183
1184 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
1185 NL80211_CMD_NEW_KEY);
1186
1187 if (IS_ERR(hdr)) {
1188 err = PTR_ERR(hdr);
6c95e2a2 1189 goto free_msg;
41ade00f
JB		 1190 }
1191
1192 cookie.msg = msg;
b9454e83 1193 cookie.idx = key_idx;
41ade00f
JB		 1194
1195 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1196 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_idx);
1197 if (mac_addr)
1198 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1199
79c97e97 1200 err = rdev->ops->get_key(&rdev->wiphy, dev, key_idx, mac_addr,
41ade00f 1201 &cookie, get_key_callback);
41ade00f
JB		 1202
1203 if (err)
6c95e2a2 1204 goto free_msg;
41ade00f
JB		 1205
1206 if (cookie.error)
1207 goto nla_put_failure;
1208
1209 genlmsg_end(msg, hdr);
134e6375 1210 err = genlmsg_reply(msg, info);
41ade00f
JB		 1211 goto out;
1212
1213 nla_put_failure:
1214 err = -ENOBUFS;
6c95e2a2 1215 free_msg:
41ade00f
JB		 1216 nlmsg_free(msg);
1217 out:
79c97e97 1218 cfg80211_unlock_rdev(rdev);
41ade00f 1219 dev_put(dev);
3b85875a
JB		 1220 unlock_rtnl:
1221 rtnl_unlock();
1222
41ade00f
JB		 1223 return err;
1224}
1225
1226static int nl80211_set_key(struct sk_buff *skb, struct genl_info *info)
1227{
79c97e97 1228 struct cfg80211_registered_device *rdev;
b9454e83 1229 struct key_parse key;
41ade00f
JB		 1230 int err;
1231 struct net_device *dev;
3cfcf6ac
JM		 1232 int (*func)(struct wiphy *wiphy, struct net_device *netdev,
1233 u8 key_index);
41ade00f 1234
b9454e83
JB		 1235 err = nl80211_parse_key(info, &key);
1236 if (err)
1237 return err;
41ade00f 1238
b9454e83 1239 if (key.idx < 0)
41ade00f
JB		 1240 return -EINVAL;
1241
b9454e83
JB		 1242 /* only support setting default key */
1243 if (!key.def && !key.defmgmt)
41ade00f
JB		 1244 return -EINVAL;
1245
3b85875a
JB		 1246 rtnl_lock();
1247
463d0183 1248 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
41ade00f 1249 if (err)
3b85875a 1250 goto unlock_rtnl;
41ade00f 1251
b9454e83 1252 if (key.def)
79c97e97 1253 func = rdev->ops->set_default_key;
3cfcf6ac 1254 else
79c97e97 1255 func = rdev->ops->set_default_mgmt_key;
3cfcf6ac
JM		 1256
1257 if (!func) {
41ade00f
JB		 1258 err = -EOPNOTSUPP;
1259 goto out;
1260 }
1261
fffd0934
JB		 1262 wdev_lock(dev->ieee80211_ptr);
1263 err = nl80211_key_allowed(dev->ieee80211_ptr);
1264 if (!err)
1265 err = func(&rdev->wiphy, dev, key.idx);
1266
08645126
JB		 1267#ifdef CONFIG_WIRELESS_EXT
1268 if (!err) {
79c97e97 1269 if (func == rdev->ops->set_default_key)
b9454e83 1270 dev->ieee80211_ptr->wext.default_key = key.idx;
08645126 1271 else
b9454e83 1272 dev->ieee80211_ptr->wext.default_mgmt_key = key.idx;
08645126
JB		 1273 }
1274#endif
fffd0934 1275 wdev_unlock(dev->ieee80211_ptr);
41ade00f
JB		 1276
1277 out:
79c97e97 1278 cfg80211_unlock_rdev(rdev);
41ade00f 1279 dev_put(dev);
3b85875a
JB		 1280
1281 unlock_rtnl:
1282 rtnl_unlock();
1283
41ade00f
JB		 1284 return err;
1285}
1286
1287static int nl80211_new_key(struct sk_buff *skb, struct genl_info *info)
1288{
79c97e97 1289 struct cfg80211_registered_device *rdev;
fffd0934 1290 int err;
41ade00f 1291 struct net_device *dev;
b9454e83 1292 struct key_parse key;
41ade00f
JB		 1293 u8 *mac_addr = NULL;
1294
b9454e83
JB		 1295 err = nl80211_parse_key(info, &key);
1296 if (err)
1297 return err;
41ade00f 1298
b9454e83 1299 if (!key.p.key)
41ade00f
JB		 1300 return -EINVAL;
1301
41ade00f
JB		 1302 if (info->attrs[NL80211_ATTR_MAC])
1303 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1304
3b85875a
JB		 1305 rtnl_lock();
1306
463d0183 1307 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
41ade00f 1308 if (err)
3b85875a 1309 goto unlock_rtnl;
41ade00f 1310
fffd0934
JB		 1311 if (!rdev->ops->add_key) {
1312 err = -EOPNOTSUPP;
25e47c18
JB		 1313 goto out;
1314 }
1315
fffd0934
JB		 1316 if (cfg80211_validate_key_settings(rdev, &key.p, key.idx, mac_addr)) {
1317 err = -EINVAL;
41ade00f
JB		 1318 goto out;
1319 }
1320
fffd0934
JB		 1321 wdev_lock(dev->ieee80211_ptr);
1322 err = nl80211_key_allowed(dev->ieee80211_ptr);
1323 if (!err)
1324 err = rdev->ops->add_key(&rdev->wiphy, dev, key.idx,
1325 mac_addr, &key.p);
1326 wdev_unlock(dev->ieee80211_ptr);
41ade00f
JB		 1327
1328 out:
79c97e97 1329 cfg80211_unlock_rdev(rdev);
41ade00f 1330 dev_put(dev);
3b85875a
JB		 1331 unlock_rtnl:
1332 rtnl_unlock();
1333
41ade00f
JB		 1334 return err;
1335}
1336
1337static int nl80211_del_key(struct sk_buff *skb, struct genl_info *info)
1338{
79c97e97 1339 struct cfg80211_registered_device *rdev;
41ade00f
JB		 1340 int err;
1341 struct net_device *dev;
41ade00f 1342 u8 *mac_addr = NULL;
b9454e83 1343 struct key_parse key;
41ade00f 1344
b9454e83
JB		 1345 err = nl80211_parse_key(info, &key);
1346 if (err)
1347 return err;
41ade00f
JB		 1348
1349 if (info->attrs[NL80211_ATTR_MAC])
1350 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1351
3b85875a
JB		 1352 rtnl_lock();
1353
463d0183 1354 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
41ade00f 1355 if (err)
3b85875a 1356 goto unlock_rtnl;
41ade00f 1357
79c97e97 1358 if (!rdev->ops->del_key) {
41ade00f
JB		 1359 err = -EOPNOTSUPP;
1360 goto out;
1361 }
1362
fffd0934
JB		 1363 wdev_lock(dev->ieee80211_ptr);
1364 err = nl80211_key_allowed(dev->ieee80211_ptr);
1365 if (!err)
1366 err = rdev->ops->del_key(&rdev->wiphy, dev, key.idx, mac_addr);
41ade00f 1367
08645126
JB		 1368#ifdef CONFIG_WIRELESS_EXT
1369 if (!err) {
b9454e83 1370 if (key.idx == dev->ieee80211_ptr->wext.default_key)
08645126 1371 dev->ieee80211_ptr->wext.default_key = -1;
b9454e83 1372 else if (key.idx == dev->ieee80211_ptr->wext.default_mgmt_key)
08645126
JB		 1373 dev->ieee80211_ptr->wext.default_mgmt_key = -1;
1374 }
1375#endif
fffd0934 1376 wdev_unlock(dev->ieee80211_ptr);
08645126 1377
41ade00f 1378 out:
79c97e97 1379 cfg80211_unlock_rdev(rdev);
41ade00f 1380 dev_put(dev);
3b85875a
JB		 1381
1382 unlock_rtnl:
1383 rtnl_unlock();
1384
41ade00f
JB		 1385 return err;
1386}
1387
ed1b6cc7
JB		 1388static int nl80211_addset_beacon(struct sk_buff *skb, struct genl_info *info)
1389{
1390 int (*call)(struct wiphy *wiphy, struct net_device *dev,
1391 struct beacon_parameters *info);
79c97e97 1392 struct cfg80211_registered_device *rdev;
ed1b6cc7
JB		 1393 int err;
1394 struct net_device *dev;
1395 struct beacon_parameters params;
1396 int haveinfo = 0;
1397
f4a11bb0
JB		 1398 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_BEACON_TAIL]))
1399 return -EINVAL;
1400
3b85875a
JB		 1401 rtnl_lock();
1402
463d0183 1403 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
ed1b6cc7 1404 if (err)
3b85875a 1405 goto unlock_rtnl;
ed1b6cc7 1406
eec60b03
JM		 1407 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1408 err = -EOPNOTSUPP;
1409 goto out;
1410 }
1411
ed1b6cc7
JB		 1412 switch (info->genlhdr->cmd) {
1413 case NL80211_CMD_NEW_BEACON:
1414 /* these are required for NEW_BEACON */
1415 if (!info->attrs[NL80211_ATTR_BEACON_INTERVAL] ||
1416 !info->attrs[NL80211_ATTR_DTIM_PERIOD] ||
1417 !info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1418 err = -EINVAL;
1419 goto out;
1420 }
1421
79c97e97 1422 call = rdev->ops->add_beacon;
ed1b6cc7
JB		 1423 break;
1424 case NL80211_CMD_SET_BEACON:
79c97e97 1425 call = rdev->ops->set_beacon;
ed1b6cc7
JB		 1426 break;
1427 default:
1428 WARN_ON(1);
1429 err = -EOPNOTSUPP;
1430 goto out;
1431 }
1432
1433 if (!call) {
1434 err = -EOPNOTSUPP;
1435 goto out;
1436 }
1437
1438 memset(&params, 0, sizeof(params));
1439
1440 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
1441 params.interval =
1442 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
1443 haveinfo = 1;
1444 }
1445
1446 if (info->attrs[NL80211_ATTR_DTIM_PERIOD]) {
1447 params.dtim_period =
1448 nla_get_u32(info->attrs[NL80211_ATTR_DTIM_PERIOD]);
1449 haveinfo = 1;
1450 }
1451
1452 if (info->attrs[NL80211_ATTR_BEACON_HEAD]) {
1453 params.head = nla_data(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1454 params.head_len =
1455 nla_len(info->attrs[NL80211_ATTR_BEACON_HEAD]);
1456 haveinfo = 1;
1457 }
1458
1459 if (info->attrs[NL80211_ATTR_BEACON_TAIL]) {
1460 params.tail = nla_data(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1461 params.tail_len =
1462 nla_len(info->attrs[NL80211_ATTR_BEACON_TAIL]);
1463 haveinfo = 1;
1464 }
1465
1466 if (!haveinfo) {
1467 err = -EINVAL;
1468 goto out;
1469 }
1470
79c97e97 1471 err = call(&rdev->wiphy, dev, &params);
ed1b6cc7
JB		 1472
1473 out:
79c97e97 1474 cfg80211_unlock_rdev(rdev);
ed1b6cc7 1475 dev_put(dev);
3b85875a
JB		 1476 unlock_rtnl:
1477 rtnl_unlock();
1478
ed1b6cc7
JB		 1479 return err;
1480}
1481
1482static int nl80211_del_beacon(struct sk_buff *skb, struct genl_info *info)
1483{
79c97e97 1484 struct cfg80211_registered_device *rdev;
ed1b6cc7
JB		 1485 int err;
1486 struct net_device *dev;
1487
3b85875a
JB		 1488 rtnl_lock();
1489
463d0183 1490 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
ed1b6cc7 1491 if (err)
3b85875a 1492 goto unlock_rtnl;
ed1b6cc7 1493
79c97e97 1494 if (!rdev->ops->del_beacon) {
ed1b6cc7
JB		 1495 err = -EOPNOTSUPP;
1496 goto out;
1497 }
1498
eec60b03
JM		 1499 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
1500 err = -EOPNOTSUPP;
1501 goto out;
1502 }
79c97e97 1503 err = rdev->ops->del_beacon(&rdev->wiphy, dev);
ed1b6cc7
JB		 1504
1505 out:
79c97e97 1506 cfg80211_unlock_rdev(rdev);
ed1b6cc7 1507 dev_put(dev);
3b85875a
JB		 1508 unlock_rtnl:
1509 rtnl_unlock();
1510
ed1b6cc7
JB		 1511 return err;
1512}
1513
5727ef1b
JB		 1514static const struct nla_policy sta_flags_policy[NL80211_STA_FLAG_MAX + 1] = {
1515 [NL80211_STA_FLAG_AUTHORIZED] = { .type = NLA_FLAG },
1516 [NL80211_STA_FLAG_SHORT_PREAMBLE] = { .type = NLA_FLAG },
1517 [NL80211_STA_FLAG_WME] = { .type = NLA_FLAG },
0e46724a 1518 [NL80211_STA_FLAG_MFP] = { .type = NLA_FLAG },
5727ef1b
JB		 1519};
1520
eccb8e8f
JB		 1521static int parse_station_flags(struct genl_info *info,
1522 struct station_parameters *params)
5727ef1b
JB		 1523{
1524 struct nlattr *flags[NL80211_STA_FLAG_MAX + 1];
eccb8e8f 1525 struct nlattr *nla;
5727ef1b
JB		 1526 int flag;
1527
eccb8e8f
JB		 1528 /*
1529 * Try parsing the new attribute first so userspace
1530 * can specify both for older kernels.
1531 */
1532 nla = info->attrs[NL80211_ATTR_STA_FLAGS2];
1533 if (nla) {
1534 struct nl80211_sta_flag_update *sta_flags;
1535
1536 sta_flags = nla_data(nla);
1537 params->sta_flags_mask = sta_flags->mask;
1538 params->sta_flags_set = sta_flags->set;
1539 if ((params->sta_flags_mask |
1540 params->sta_flags_set) & BIT(__NL80211_STA_FLAG_INVALID))
1541 return -EINVAL;
1542 return 0;
1543 }
1544
1545 /* if present, parse the old attribute */
5727ef1b 1546
eccb8e8f 1547 nla = info->attrs[NL80211_ATTR_STA_FLAGS];
5727ef1b
JB		 1548 if (!nla)
1549 return 0;
1550
1551 if (nla_parse_nested(flags, NL80211_STA_FLAG_MAX,
1552 nla, sta_flags_policy))
1553 return -EINVAL;
1554
eccb8e8f
JB		 1555 params->sta_flags_mask = (1 << __NL80211_STA_FLAG_AFTER_LAST) - 1;
1556 params->sta_flags_mask &= ~1;
5727ef1b
JB		 1557
1558 for (flag = 1; flag <= NL80211_STA_FLAG_MAX; flag++)
1559 if (flags[flag])
eccb8e8f 1560 params->sta_flags_set |= (1<<flag);
5727ef1b
JB		 1561
1562 return 0;
1563}
1564
420e7fab
HR		 1565static u16 nl80211_calculate_bitrate(struct rate_info *rate)
1566{
1567 int modulation, streams, bitrate;
1568
1569 if (!(rate->flags & RATE_INFO_FLAGS_MCS))
1570 return rate->legacy;
1571
1572 /* the formula below does only work for MCS values smaller than 32 */
1573 if (rate->mcs >= 32)
1574 return 0;
1575
1576 modulation = rate->mcs & 7;
1577 streams = (rate->mcs >> 3) + 1;
1578
1579 bitrate = (rate->flags & RATE_INFO_FLAGS_40_MHZ_WIDTH) ?
1580 13500000 : 6500000;
1581
1582 if (modulation < 4)
1583 bitrate *= (modulation + 1);
1584 else if (modulation == 4)
1585 bitrate *= (modulation + 2);
1586 else
1587 bitrate *= (modulation + 3);
1588
1589 bitrate *= streams;
1590
1591 if (rate->flags & RATE_INFO_FLAGS_SHORT_GI)
1592 bitrate = (bitrate / 9) * 10;
1593
1594 /* do NOT round down here */
1595 return (bitrate + 50000) / 100000;
1596}
1597
fd5b74dc
JB		 1598static int nl80211_send_station(struct sk_buff *msg, u32 pid, u32 seq,
1599 int flags, struct net_device *dev,
2ec600d6 1600 u8 *mac_addr, struct station_info *sinfo)
fd5b74dc
JB		 1601{
1602 void *hdr;
420e7fab
HR		 1603 struct nlattr *sinfoattr, *txrate;
1604 u16 bitrate;
fd5b74dc
JB		 1605
1606 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
1607 if (!hdr)
1608 return -1;
1609
1610 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
1611 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, mac_addr);
1612
f5ea9120
JB		 1613 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, sinfo->generation);
1614
2ec600d6
LCC		 1615 sinfoattr = nla_nest_start(msg, NL80211_ATTR_STA_INFO);
1616 if (!sinfoattr)
fd5b74dc 1617 goto nla_put_failure;
2ec600d6
LCC		 1618 if (sinfo->filled & STATION_INFO_INACTIVE_TIME)
1619 NLA_PUT_U32(msg, NL80211_STA_INFO_INACTIVE_TIME,
1620 sinfo->inactive_time);
1621 if (sinfo->filled & STATION_INFO_RX_BYTES)
1622 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_BYTES,
1623 sinfo->rx_bytes);
1624 if (sinfo->filled & STATION_INFO_TX_BYTES)
1625 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_BYTES,
1626 sinfo->tx_bytes);
1627 if (sinfo->filled & STATION_INFO_LLID)
1628 NLA_PUT_U16(msg, NL80211_STA_INFO_LLID,
1629 sinfo->llid);
1630 if (sinfo->filled & STATION_INFO_PLID)
1631 NLA_PUT_U16(msg, NL80211_STA_INFO_PLID,
1632 sinfo->plid);
1633 if (sinfo->filled & STATION_INFO_PLINK_STATE)
1634 NLA_PUT_U8(msg, NL80211_STA_INFO_PLINK_STATE,
1635 sinfo->plink_state);
420e7fab
HR		 1636 if (sinfo->filled & STATION_INFO_SIGNAL)
1637 NLA_PUT_U8(msg, NL80211_STA_INFO_SIGNAL,
1638 sinfo->signal);
1639 if (sinfo->filled & STATION_INFO_TX_BITRATE) {
1640 txrate = nla_nest_start(msg, NL80211_STA_INFO_TX_BITRATE);
1641 if (!txrate)
1642 goto nla_put_failure;
1643
1644 /* nl80211_calculate_bitrate will return 0 for mcs >= 32 */
1645 bitrate = nl80211_calculate_bitrate(&sinfo->txrate);
1646 if (bitrate > 0)
1647 NLA_PUT_U16(msg, NL80211_RATE_INFO_BITRATE, bitrate);
2ec600d6 1648
420e7fab
HR		 1649 if (sinfo->txrate.flags & RATE_INFO_FLAGS_MCS)
1650 NLA_PUT_U8(msg, NL80211_RATE_INFO_MCS,
1651 sinfo->txrate.mcs);
1652 if (sinfo->txrate.flags & RATE_INFO_FLAGS_40_MHZ_WIDTH)
1653 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_40_MHZ_WIDTH);
1654 if (sinfo->txrate.flags & RATE_INFO_FLAGS_SHORT_GI)
1655 NLA_PUT_FLAG(msg, NL80211_RATE_INFO_SHORT_GI);
1656
1657 nla_nest_end(msg, txrate);
1658 }
98c8a60a
JM		 1659 if (sinfo->filled & STATION_INFO_RX_PACKETS)
1660 NLA_PUT_U32(msg, NL80211_STA_INFO_RX_PACKETS,
1661 sinfo->rx_packets);
1662 if (sinfo->filled & STATION_INFO_TX_PACKETS)
1663 NLA_PUT_U32(msg, NL80211_STA_INFO_TX_PACKETS,
1664 sinfo->tx_packets);
2ec600d6 1665 nla_nest_end(msg, sinfoattr);
fd5b74dc
JB		 1666
1667 return genlmsg_end(msg, hdr);
1668
1669 nla_put_failure:
bc3ed28c
TG		 1670 genlmsg_cancel(msg, hdr);
1671 return -EMSGSIZE;
fd5b74dc
JB		 1672}
1673
2ec600d6 1674static int nl80211_dump_station(struct sk_buff *skb,
bba95fef 1675 struct netlink_callback *cb)
2ec600d6 1676{
2ec600d6
LCC		 1677 struct station_info sinfo;
1678 struct cfg80211_registered_device *dev;
bba95fef 1679 struct net_device *netdev;
2ec600d6 1680 u8 mac_addr[ETH_ALEN];
bba95fef
JB		 1681 int ifidx = cb->args[0];
1682 int sta_idx = cb->args[1];
2ec600d6 1683 int err;
2ec600d6 1684
bba95fef
JB		 1685 if (!ifidx) {
1686 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
1687 nl80211_fam.attrbuf, nl80211_fam.maxattr,
1688 nl80211_policy);
1689 if (err)
1690 return err;
2ec600d6 1691
bba95fef
JB		 1692 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
1693 return -EINVAL;
2ec600d6 1694
bba95fef
JB		 1695 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
1696 if (!ifidx)
1697 return -EINVAL;
2ec600d6 1698 }
2ec600d6 1699
3b85875a
JB		 1700 rtnl_lock();
1701
463d0183 1702 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
3b85875a
JB		 1703 if (!netdev) {
1704 err = -ENODEV;
1705 goto out_rtnl;
1706 }
2ec600d6 1707
463d0183 1708 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
bba95fef
JB		 1709 if (IS_ERR(dev)) {
1710 err = PTR_ERR(dev);
3b85875a 1711 goto out_rtnl;
bba95fef
JB		 1712 }
1713
1714 if (!dev->ops->dump_station) {
eec60b03 1715 err = -EOPNOTSUPP;
bba95fef
JB		 1716 goto out_err;
1717 }
1718
bba95fef
JB		 1719 while (1) {
1720 err = dev->ops->dump_station(&dev->wiphy, netdev, sta_idx,
1721 mac_addr, &sinfo);
1722 if (err == -ENOENT)
1723 break;
1724 if (err)
3b85875a 1725 goto out_err;
bba95fef
JB		 1726
1727 if (nl80211_send_station(skb,
1728 NETLINK_CB(cb->skb).pid,
1729 cb->nlh->nlmsg_seq, NLM_F_MULTI,
1730 netdev, mac_addr,
1731 &sinfo) < 0)
1732 goto out;
1733
1734 sta_idx++;
1735 }
1736
1737
1738 out:
1739 cb->args[1] = sta_idx;
1740 err = skb->len;
bba95fef 1741 out_err:
4d0c8aea 1742 cfg80211_unlock_rdev(dev);
3b85875a
JB		 1743 out_rtnl:
1744 rtnl_unlock();
bba95fef
JB		 1745
1746 return err;
2ec600d6 1747}
fd5b74dc 1748
5727ef1b
JB		 1749static int nl80211_get_station(struct sk_buff *skb, struct genl_info *info)
1750{
79c97e97 1751 struct cfg80211_registered_device *rdev;
fd5b74dc
JB		 1752 int err;
1753 struct net_device *dev;
2ec600d6 1754 struct station_info sinfo;
fd5b74dc
JB		 1755 struct sk_buff *msg;
1756 u8 *mac_addr = NULL;
1757
2ec600d6 1758 memset(&sinfo, 0, sizeof(sinfo));
fd5b74dc
JB		 1759
1760 if (!info->attrs[NL80211_ATTR_MAC])
1761 return -EINVAL;
1762
1763 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1764
3b85875a
JB		 1765 rtnl_lock();
1766
463d0183 1767 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
fd5b74dc 1768 if (err)
3b85875a 1769 goto out_rtnl;
fd5b74dc 1770
79c97e97 1771 if (!rdev->ops->get_station) {
fd5b74dc
JB		 1772 err = -EOPNOTSUPP;
1773 goto out;
1774 }
1775
79c97e97 1776 err = rdev->ops->get_station(&rdev->wiphy, dev, mac_addr, &sinfo);
2ec600d6
LCC		 1777 if (err)
1778 goto out;
1779
fd2120ca 1780 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
fd5b74dc
JB		 1781 if (!msg)
1782 goto out;
1783
1784 if (nl80211_send_station(msg, info->snd_pid, info->snd_seq, 0,
2ec600d6 1785 dev, mac_addr, &sinfo) < 0)
fd5b74dc
JB		 1786 goto out_free;
1787
134e6375 1788 err = genlmsg_reply(msg, info);
fd5b74dc
JB		 1789 goto out;
1790
1791 out_free:
1792 nlmsg_free(msg);
fd5b74dc 1793 out:
79c97e97 1794 cfg80211_unlock_rdev(rdev);
fd5b74dc 1795 dev_put(dev);
3b85875a
JB		 1796 out_rtnl:
1797 rtnl_unlock();
1798
fd5b74dc 1799 return err;
5727ef1b
JB		 1800}
1801
1802/*
1803 * Get vlan interface making sure it is on the right wiphy.
1804 */
463d0183 1805static int get_vlan(struct genl_info *info,
5727ef1b
JB		 1806 struct cfg80211_registered_device *rdev,
1807 struct net_device **vlan)
1808{
463d0183 1809 struct nlattr *vlanattr = info->attrs[NL80211_ATTR_STA_VLAN];
5727ef1b
JB		 1810 *vlan = NULL;
1811
1812 if (vlanattr) {
463d0183
JB		 1813 *vlan = dev_get_by_index(genl_info_net(info),
1814 nla_get_u32(vlanattr));
5727ef1b
JB		 1815 if (!*vlan)
1816 return -ENODEV;
1817 if (!(*vlan)->ieee80211_ptr)
1818 return -EINVAL;
1819 if ((*vlan)->ieee80211_ptr->wiphy != &rdev->wiphy)
1820 return -EINVAL;
1821 }
1822 return 0;
1823}
1824
1825static int nl80211_set_station(struct sk_buff *skb, struct genl_info *info)
1826{
79c97e97 1827 struct cfg80211_registered_device *rdev;
5727ef1b
JB		 1828 int err;
1829 struct net_device *dev;
1830 struct station_parameters params;
1831 u8 *mac_addr = NULL;
1832
1833 memset(&params, 0, sizeof(params));
1834
1835 params.listen_interval = -1;
1836
1837 if (info->attrs[NL80211_ATTR_STA_AID])
1838 return -EINVAL;
1839
1840 if (!info->attrs[NL80211_ATTR_MAC])
1841 return -EINVAL;
1842
1843 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1844
1845 if (info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]) {
1846 params.supported_rates =
1847 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1848 params.supported_rates_len =
1849 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1850 }
1851
1852 if (info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1853 params.listen_interval =
1854 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
1855
36aedc90
JM		 1856 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1857 params.ht_capa =
1858 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
1859
eccb8e8f 1860 if (parse_station_flags(info, &params))
5727ef1b
JB		 1861 return -EINVAL;
1862
2ec600d6
LCC		 1863 if (info->attrs[NL80211_ATTR_STA_PLINK_ACTION])
1864 params.plink_action =
1865 nla_get_u8(info->attrs[NL80211_ATTR_STA_PLINK_ACTION]);
1866
3b85875a
JB		 1867 rtnl_lock();
1868
463d0183 1869 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
5727ef1b 1870 if (err)
3b85875a 1871 goto out_rtnl;
5727ef1b 1872
463d0183 1873 err = get_vlan(info, rdev, &params.vlan);
a97f4424 1874 if (err)
034d655e 1875 goto out;
a97f4424
JB		 1876
1877 /* validate settings */
1878 err = 0;
1879
1880 switch (dev->ieee80211_ptr->iftype) {
1881 case NL80211_IFTYPE_AP:
1882 case NL80211_IFTYPE_AP_VLAN:
1883 /* disallow mesh-specific things */
1884 if (params.plink_action)
1885 err = -EINVAL;
1886 break;
1887 case NL80211_IFTYPE_STATION:
1888 /* disallow everything but AUTHORIZED flag */
1889 if (params.plink_action)
1890 err = -EINVAL;
1891 if (params.vlan)
1892 err = -EINVAL;
1893 if (params.supported_rates)
1894 err = -EINVAL;
1895 if (params.ht_capa)
1896 err = -EINVAL;
1897 if (params.listen_interval >= 0)
1898 err = -EINVAL;
1899 if (params.sta_flags_mask & ~BIT(NL80211_STA_FLAG_AUTHORIZED))
1900 err = -EINVAL;
1901 break;
1902 case NL80211_IFTYPE_MESH_POINT:
1903 /* disallow things mesh doesn't support */
1904 if (params.vlan)
1905 err = -EINVAL;
1906 if (params.ht_capa)
1907 err = -EINVAL;
1908 if (params.listen_interval >= 0)
1909 err = -EINVAL;
1910 if (params.supported_rates)
1911 err = -EINVAL;
1912 if (params.sta_flags_mask)
1913 err = -EINVAL;
1914 break;
1915 default:
1916 err = -EINVAL;
034d655e
JB		 1917 }
1918
5727ef1b
JB		 1919 if (err)
1920 goto out;
1921
79c97e97 1922 if (!rdev->ops->change_station) {
5727ef1b
JB		 1923 err = -EOPNOTSUPP;
1924 goto out;
1925 }
1926
79c97e97 1927 err = rdev->ops->change_station(&rdev->wiphy, dev, mac_addr, &params);
5727ef1b
JB		 1928
1929 out:
1930 if (params.vlan)
1931 dev_put(params.vlan);
79c97e97 1932 cfg80211_unlock_rdev(rdev);
5727ef1b 1933 dev_put(dev);
3b85875a
JB		 1934 out_rtnl:
1935 rtnl_unlock();
1936
5727ef1b
JB		 1937 return err;
1938}
1939
1940static int nl80211_new_station(struct sk_buff *skb, struct genl_info *info)
1941{
79c97e97 1942 struct cfg80211_registered_device *rdev;
5727ef1b
JB		 1943 int err;
1944 struct net_device *dev;
1945 struct station_parameters params;
1946 u8 *mac_addr = NULL;
1947
1948 memset(&params, 0, sizeof(params));
1949
1950 if (!info->attrs[NL80211_ATTR_MAC])
1951 return -EINVAL;
1952
5727ef1b
JB		 1953 if (!info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL])
1954 return -EINVAL;
1955
1956 if (!info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES])
1957 return -EINVAL;
1958
1959 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
1960 params.supported_rates =
1961 nla_data(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1962 params.supported_rates_len =
1963 nla_len(info->attrs[NL80211_ATTR_STA_SUPPORTED_RATES]);
1964 params.listen_interval =
1965 nla_get_u16(info->attrs[NL80211_ATTR_STA_LISTEN_INTERVAL]);
51b50fbe 1966
a97f4424
JB		 1967 if (info->attrs[NL80211_ATTR_STA_AID]) {
1968 params.aid = nla_get_u16(info->attrs[NL80211_ATTR_STA_AID]);
1969 if (!params.aid || params.aid > IEEE80211_MAX_AID)
1970 return -EINVAL;
1971 }
51b50fbe 1972
36aedc90
JM		 1973 if (info->attrs[NL80211_ATTR_HT_CAPABILITY])
1974 params.ht_capa =
1975 nla_data(info->attrs[NL80211_ATTR_HT_CAPABILITY]);
5727ef1b 1976
eccb8e8f 1977 if (parse_station_flags(info, &params))
5727ef1b
JB		 1978 return -EINVAL;
1979
3b85875a
JB		 1980 rtnl_lock();
1981
463d0183 1982 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
5727ef1b 1983 if (err)
3b85875a 1984 goto out_rtnl;
5727ef1b 1985
463d0183 1986 err = get_vlan(info, rdev, &params.vlan);
a97f4424 1987 if (err)
e80cf853 1988 goto out;
a97f4424
JB		 1989
1990 /* validate settings */
1991 err = 0;
1992
1993 switch (dev->ieee80211_ptr->iftype) {
1994 case NL80211_IFTYPE_AP:
1995 case NL80211_IFTYPE_AP_VLAN:
1996 /* all ok but must have AID */
1997 if (!params.aid)
1998 err = -EINVAL;
1999 break;
2000 case NL80211_IFTYPE_MESH_POINT:
2001 /* disallow things mesh doesn't support */
2002 if (params.vlan)
2003 err = -EINVAL;
2004 if (params.aid)
2005 err = -EINVAL;
2006 if (params.ht_capa)
2007 err = -EINVAL;
2008 if (params.listen_interval >= 0)
2009 err = -EINVAL;
2010 if (params.supported_rates)
2011 err = -EINVAL;
2012 if (params.sta_flags_mask)
2013 err = -EINVAL;
2014 break;
2015 default:
2016 err = -EINVAL;
e80cf853
JB		 2017 }
2018
5727ef1b
JB		 2019 if (err)
2020 goto out;
2021
79c97e97 2022 if (!rdev->ops->add_station) {
5727ef1b
JB		 2023 err = -EOPNOTSUPP;
2024 goto out;
2025 }
2026
35a8efe1
JM		 2027 if (!netif_running(dev)) {
2028 err = -ENETDOWN;
2029 goto out;
2030 }
2031
79c97e97 2032 err = rdev->ops->add_station(&rdev->wiphy, dev, mac_addr, &params);
5727ef1b
JB		 2033
2034 out:
2035 if (params.vlan)
2036 dev_put(params.vlan);
79c97e97 2037 cfg80211_unlock_rdev(rdev);
5727ef1b 2038 dev_put(dev);
3b85875a
JB		 2039 out_rtnl:
2040 rtnl_unlock();
2041
5727ef1b
JB		 2042 return err;
2043}
2044
2045static int nl80211_del_station(struct sk_buff *skb, struct genl_info *info)
2046{
79c97e97 2047 struct cfg80211_registered_device *rdev;
5727ef1b
JB		 2048 int err;
2049 struct net_device *dev;
2050 u8 *mac_addr = NULL;
2051
2052 if (info->attrs[NL80211_ATTR_MAC])
2053 mac_addr = nla_data(info->attrs[NL80211_ATTR_MAC]);
2054
3b85875a
JB		 2055 rtnl_lock();
2056
463d0183 2057 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
5727ef1b 2058 if (err)
3b85875a 2059 goto out_rtnl;
5727ef1b 2060
e80cf853 2061 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP &&
155cc9e4
AY		 2062 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP_VLAN &&
2063 dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
e80cf853
JB		 2064 err = -EINVAL;
2065 goto out;
2066 }
2067
79c97e97 2068 if (!rdev->ops->del_station) {
5727ef1b
JB		 2069 err = -EOPNOTSUPP;
2070 goto out;
2071 }
2072
79c97e97 2073 err = rdev->ops->del_station(&rdev->wiphy, dev, mac_addr);
5727ef1b
JB		 2074
2075 out:
79c97e97 2076 cfg80211_unlock_rdev(rdev);
5727ef1b 2077 dev_put(dev);
3b85875a
JB		 2078 out_rtnl:
2079 rtnl_unlock();
2080
5727ef1b
JB		 2081 return err;
2082}
2083
2ec600d6
LCC		 2084static int nl80211_send_mpath(struct sk_buff *msg, u32 pid, u32 seq,
2085 int flags, struct net_device *dev,
2086 u8 *dst, u8 *next_hop,
2087 struct mpath_info *pinfo)
2088{
2089 void *hdr;
2090 struct nlattr *pinfoattr;
2091
2092 hdr = nl80211hdr_put(msg, pid, seq, flags, NL80211_CMD_NEW_STATION);
2093 if (!hdr)
2094 return -1;
2095
2096 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2097 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, dst);
2098 NLA_PUT(msg, NL80211_ATTR_MPATH_NEXT_HOP, ETH_ALEN, next_hop);
2099
f5ea9120
JB		 2100 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, pinfo->generation);
2101
2ec600d6
LCC		 2102 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MPATH_INFO);
2103 if (!pinfoattr)
2104 goto nla_put_failure;
2105 if (pinfo->filled & MPATH_INFO_FRAME_QLEN)
2106 NLA_PUT_U32(msg, NL80211_MPATH_INFO_FRAME_QLEN,
2107 pinfo->frame_qlen);
2108 if (pinfo->filled & MPATH_INFO_DSN)
2109 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DSN,
2110 pinfo->dsn);
2111 if (pinfo->filled & MPATH_INFO_METRIC)
2112 NLA_PUT_U32(msg, NL80211_MPATH_INFO_METRIC,
2113 pinfo->metric);
2114 if (pinfo->filled & MPATH_INFO_EXPTIME)
2115 NLA_PUT_U32(msg, NL80211_MPATH_INFO_EXPTIME,
2116 pinfo->exptime);
2117 if (pinfo->filled & MPATH_INFO_FLAGS)
2118 NLA_PUT_U8(msg, NL80211_MPATH_INFO_FLAGS,
2119 pinfo->flags);
2120 if (pinfo->filled & MPATH_INFO_DISCOVERY_TIMEOUT)
2121 NLA_PUT_U32(msg, NL80211_MPATH_INFO_DISCOVERY_TIMEOUT,
2122 pinfo->discovery_timeout);
2123 if (pinfo->filled & MPATH_INFO_DISCOVERY_RETRIES)
2124 NLA_PUT_U8(msg, NL80211_MPATH_INFO_DISCOVERY_RETRIES,
2125 pinfo->discovery_retries);
2126
2127 nla_nest_end(msg, pinfoattr);
2128
2129 return genlmsg_end(msg, hdr);
2130
2131 nla_put_failure:
bc3ed28c
TG		 2132 genlmsg_cancel(msg, hdr);
2133 return -EMSGSIZE;
2ec600d6
LCC		 2134}
2135
2136static int nl80211_dump_mpath(struct sk_buff *skb,
bba95fef 2137 struct netlink_callback *cb)
2ec600d6 2138{
2ec600d6
LCC		 2139 struct mpath_info pinfo;
2140 struct cfg80211_registered_device *dev;
bba95fef 2141 struct net_device *netdev;
2ec600d6
LCC		 2142 u8 dst[ETH_ALEN];
2143 u8 next_hop[ETH_ALEN];
bba95fef
JB		 2144 int ifidx = cb->args[0];
2145 int path_idx = cb->args[1];
2ec600d6 2146 int err;
2ec600d6 2147
bba95fef
JB		 2148 if (!ifidx) {
2149 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
2150 nl80211_fam.attrbuf, nl80211_fam.maxattr,
2151 nl80211_policy);
2152 if (err)
2153 return err;
2154
2155 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
2156 return -EINVAL;
2157
2158 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
2159 if (!ifidx)
2160 return -EINVAL;
2161 }
2162
3b85875a
JB		 2163 rtnl_lock();
2164
463d0183 2165 netdev = __dev_get_by_index(sock_net(skb->sk), ifidx);
3b85875a
JB		 2166 if (!netdev) {
2167 err = -ENODEV;
2168 goto out_rtnl;
2169 }
bba95fef 2170
463d0183 2171 dev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
bba95fef
JB		 2172 if (IS_ERR(dev)) {
2173 err = PTR_ERR(dev);
3b85875a 2174 goto out_rtnl;
bba95fef
JB		 2175 }
2176
2177 if (!dev->ops->dump_mpath) {
eec60b03 2178 err = -EOPNOTSUPP;
bba95fef
JB		 2179 goto out_err;
2180 }
2181
eec60b03
JM		 2182 if (netdev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2183 err = -EOPNOTSUPP;
2184 goto out;
2185 }
2186
bba95fef
JB		 2187 while (1) {
2188 err = dev->ops->dump_mpath(&dev->wiphy, netdev, path_idx,
2189 dst, next_hop, &pinfo);
2190 if (err == -ENOENT)
2ec600d6 2191 break;
bba95fef 2192 if (err)
3b85875a 2193 goto out_err;
2ec600d6 2194
bba95fef
JB		 2195 if (nl80211_send_mpath(skb, NETLINK_CB(cb->skb).pid,
2196 cb->nlh->nlmsg_seq, NLM_F_MULTI,
2197 netdev, dst, next_hop,
2198 &pinfo) < 0)
2199 goto out;
2ec600d6 2200
bba95fef 2201 path_idx++;
2ec600d6 2202 }
2ec600d6 2203
2ec600d6 2204
bba95fef
JB		 2205 out:
2206 cb->args[1] = path_idx;
2207 err = skb->len;
bba95fef 2208 out_err:
4d0c8aea 2209 cfg80211_unlock_rdev(dev);
3b85875a
JB		 2210 out_rtnl:
2211 rtnl_unlock();
bba95fef
JB		 2212
2213 return err;
2ec600d6
LCC		 2214}
2215
2216static int nl80211_get_mpath(struct sk_buff *skb, struct genl_info *info)
2217{
79c97e97 2218 struct cfg80211_registered_device *rdev;
2ec600d6
LCC		 2219 int err;
2220 struct net_device *dev;
2221 struct mpath_info pinfo;
2222 struct sk_buff *msg;
2223 u8 *dst = NULL;
2224 u8 next_hop[ETH_ALEN];
2225
2226 memset(&pinfo, 0, sizeof(pinfo));
2227
2228 if (!info->attrs[NL80211_ATTR_MAC])
2229 return -EINVAL;
2230
2231 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2232
3b85875a
JB		 2233 rtnl_lock();
2234
463d0183 2235 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2ec600d6 2236 if (err)
3b85875a 2237 goto out_rtnl;
2ec600d6 2238
79c97e97 2239 if (!rdev->ops->get_mpath) {
2ec600d6
LCC		 2240 err = -EOPNOTSUPP;
2241 goto out;
2242 }
2243
eec60b03
JM		 2244 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2245 err = -EOPNOTSUPP;
2246 goto out;
2247 }
2248
79c97e97 2249 err = rdev->ops->get_mpath(&rdev->wiphy, dev, dst, next_hop, &pinfo);
2ec600d6
LCC		 2250 if (err)
2251 goto out;
2252
fd2120ca 2253 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2ec600d6
LCC		 2254 if (!msg)
2255 goto out;
2256
2257 if (nl80211_send_mpath(msg, info->snd_pid, info->snd_seq, 0,
2258 dev, dst, next_hop, &pinfo) < 0)
2259 goto out_free;
2260
134e6375 2261 err = genlmsg_reply(msg, info);
2ec600d6
LCC		 2262 goto out;
2263
2264 out_free:
2265 nlmsg_free(msg);
2ec600d6 2266 out:
79c97e97 2267 cfg80211_unlock_rdev(rdev);
2ec600d6 2268 dev_put(dev);
3b85875a
JB		 2269 out_rtnl:
2270 rtnl_unlock();
2271
2ec600d6
LCC		 2272 return err;
2273}
2274
2275static int nl80211_set_mpath(struct sk_buff *skb, struct genl_info *info)
2276{
79c97e97 2277 struct cfg80211_registered_device *rdev;
2ec600d6
LCC		 2278 int err;
2279 struct net_device *dev;
2280 u8 *dst = NULL;
2281 u8 *next_hop = NULL;
2282
2283 if (!info->attrs[NL80211_ATTR_MAC])
2284 return -EINVAL;
2285
2286 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2287 return -EINVAL;
2288
2289 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2290 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2291
3b85875a
JB		 2292 rtnl_lock();
2293
463d0183 2294 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2ec600d6 2295 if (err)
3b85875a 2296 goto out_rtnl;
2ec600d6 2297
79c97e97 2298 if (!rdev->ops->change_mpath) {
2ec600d6
LCC		 2299 err = -EOPNOTSUPP;
2300 goto out;
2301 }
2302
eec60b03
JM		 2303 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2304 err = -EOPNOTSUPP;
2305 goto out;
2306 }
2307
35a8efe1
JM		 2308 if (!netif_running(dev)) {
2309 err = -ENETDOWN;
2310 goto out;
2311 }
2312
79c97e97 2313 err = rdev->ops->change_mpath(&rdev->wiphy, dev, dst, next_hop);
2ec600d6
LCC		 2314
2315 out:
79c97e97 2316 cfg80211_unlock_rdev(rdev);
2ec600d6 2317 dev_put(dev);
3b85875a
JB		 2318 out_rtnl:
2319 rtnl_unlock();
2320
2ec600d6
LCC		 2321 return err;
2322}
2323static int nl80211_new_mpath(struct sk_buff *skb, struct genl_info *info)
2324{
79c97e97 2325 struct cfg80211_registered_device *rdev;
2ec600d6
LCC		 2326 int err;
2327 struct net_device *dev;
2328 u8 *dst = NULL;
2329 u8 *next_hop = NULL;
2330
2331 if (!info->attrs[NL80211_ATTR_MAC])
2332 return -EINVAL;
2333
2334 if (!info->attrs[NL80211_ATTR_MPATH_NEXT_HOP])
2335 return -EINVAL;
2336
2337 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2338 next_hop = nla_data(info->attrs[NL80211_ATTR_MPATH_NEXT_HOP]);
2339
3b85875a
JB		 2340 rtnl_lock();
2341
463d0183 2342 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2ec600d6 2343 if (err)
3b85875a 2344 goto out_rtnl;
2ec600d6 2345
79c97e97 2346 if (!rdev->ops->add_mpath) {
2ec600d6
LCC		 2347 err = -EOPNOTSUPP;
2348 goto out;
2349 }
2350
eec60b03
JM		 2351 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_MESH_POINT) {
2352 err = -EOPNOTSUPP;
2353 goto out;
2354 }
2355
35a8efe1
JM		 2356 if (!netif_running(dev)) {
2357 err = -ENETDOWN;
2358 goto out;
2359 }
2360
79c97e97 2361 err = rdev->ops->add_mpath(&rdev->wiphy, dev, dst, next_hop);
2ec600d6
LCC		 2362
2363 out:
79c97e97 2364 cfg80211_unlock_rdev(rdev);
2ec600d6 2365 dev_put(dev);
3b85875a
JB		 2366 out_rtnl:
2367 rtnl_unlock();
2368
2ec600d6
LCC		 2369 return err;
2370}
2371
2372static int nl80211_del_mpath(struct sk_buff *skb, struct genl_info *info)
2373{
79c97e97 2374 struct cfg80211_registered_device *rdev;
2ec600d6
LCC		 2375 int err;
2376 struct net_device *dev;
2377 u8 *dst = NULL;
2378
2379 if (info->attrs[NL80211_ATTR_MAC])
2380 dst = nla_data(info->attrs[NL80211_ATTR_MAC]);
2381
3b85875a
JB		 2382 rtnl_lock();
2383
463d0183 2384 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2ec600d6 2385 if (err)
3b85875a 2386 goto out_rtnl;
2ec600d6 2387
79c97e97 2388 if (!rdev->ops->del_mpath) {
2ec600d6
LCC		 2389 err = -EOPNOTSUPP;
2390 goto out;
2391 }
2392
79c97e97 2393 err = rdev->ops->del_mpath(&rdev->wiphy, dev, dst);
2ec600d6
LCC		 2394
2395 out:
79c97e97 2396 cfg80211_unlock_rdev(rdev);
2ec600d6 2397 dev_put(dev);
3b85875a
JB		 2398 out_rtnl:
2399 rtnl_unlock();
2400
2ec600d6
LCC		 2401 return err;
2402}
2403
9f1ba906
JM		 2404static int nl80211_set_bss(struct sk_buff *skb, struct genl_info *info)
2405{
79c97e97 2406 struct cfg80211_registered_device *rdev;
9f1ba906
JM		 2407 int err;
2408 struct net_device *dev;
2409 struct bss_parameters params;
2410
2411 memset(&params, 0, sizeof(params));
2412 /* default to not changing parameters */
2413 params.use_cts_prot = -1;
2414 params.use_short_preamble = -1;
2415 params.use_short_slot_time = -1;
2416
2417 if (info->attrs[NL80211_ATTR_BSS_CTS_PROT])
2418 params.use_cts_prot =
2419 nla_get_u8(info->attrs[NL80211_ATTR_BSS_CTS_PROT]);
2420 if (info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE])
2421 params.use_short_preamble =
2422 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_PREAMBLE]);
2423 if (info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME])
2424 params.use_short_slot_time =
2425 nla_get_u8(info->attrs[NL80211_ATTR_BSS_SHORT_SLOT_TIME]);
90c97a04
JM		 2426 if (info->attrs[NL80211_ATTR_BSS_BASIC_RATES]) {
2427 params.basic_rates =
2428 nla_data(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2429 params.basic_rates_len =
2430 nla_len(info->attrs[NL80211_ATTR_BSS_BASIC_RATES]);
2431 }
9f1ba906 2432
3b85875a
JB		 2433 rtnl_lock();
2434
463d0183 2435 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
9f1ba906 2436 if (err)
3b85875a 2437 goto out_rtnl;
9f1ba906 2438
79c97e97 2439 if (!rdev->ops->change_bss) {
9f1ba906
JM		 2440 err = -EOPNOTSUPP;
2441 goto out;
2442 }
2443
eec60b03
JM		 2444 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_AP) {
2445 err = -EOPNOTSUPP;
2446 goto out;
2447 }
2448
79c97e97 2449 err = rdev->ops->change_bss(&rdev->wiphy, dev, &params);
9f1ba906
JM		 2450
2451 out:
79c97e97 2452 cfg80211_unlock_rdev(rdev);
9f1ba906 2453 dev_put(dev);
3b85875a
JB		 2454 out_rtnl:
2455 rtnl_unlock();
2456
9f1ba906
JM		 2457 return err;
2458}
2459
b2e1b302
LR		 2460static const struct nla_policy
2461 reg_rule_policy[NL80211_REG_RULE_ATTR_MAX + 1] = {
2462 [NL80211_ATTR_REG_RULE_FLAGS] = { .type = NLA_U32 },
2463 [NL80211_ATTR_FREQ_RANGE_START] = { .type = NLA_U32 },
2464 [NL80211_ATTR_FREQ_RANGE_END] = { .type = NLA_U32 },
2465 [NL80211_ATTR_FREQ_RANGE_MAX_BW] = { .type = NLA_U32 },
2466 [NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN] = { .type = NLA_U32 },
2467 [NL80211_ATTR_POWER_RULE_MAX_EIRP] = { .type = NLA_U32 },
2468};
2469
2470static int parse_reg_rule(struct nlattr *tb[],
2471 struct ieee80211_reg_rule *reg_rule)
2472{
2473 struct ieee80211_freq_range *freq_range = &reg_rule->freq_range;
2474 struct ieee80211_power_rule *power_rule = &reg_rule->power_rule;
2475
2476 if (!tb[NL80211_ATTR_REG_RULE_FLAGS])
2477 return -EINVAL;
2478 if (!tb[NL80211_ATTR_FREQ_RANGE_START])
2479 return -EINVAL;
2480 if (!tb[NL80211_ATTR_FREQ_RANGE_END])
2481 return -EINVAL;
2482 if (!tb[NL80211_ATTR_FREQ_RANGE_MAX_BW])
2483 return -EINVAL;
2484 if (!tb[NL80211_ATTR_POWER_RULE_MAX_EIRP])
2485 return -EINVAL;
2486
2487 reg_rule->flags = nla_get_u32(tb[NL80211_ATTR_REG_RULE_FLAGS]);
2488
2489 freq_range->start_freq_khz =
2490 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_START]);
2491 freq_range->end_freq_khz =
2492 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_END]);
2493 freq_range->max_bandwidth_khz =
2494 nla_get_u32(tb[NL80211_ATTR_FREQ_RANGE_MAX_BW]);
2495
2496 power_rule->max_eirp =
2497 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_EIRP]);
2498
2499 if (tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN])
2500 power_rule->max_antenna_gain =
2501 nla_get_u32(tb[NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN]);
2502
2503 return 0;
2504}
2505
2506static int nl80211_req_set_reg(struct sk_buff *skb, struct genl_info *info)
2507{
2508 int r;
2509 char *data = NULL;
2510
80778f18
LR		 2511 /*
2512 * You should only get this when cfg80211 hasn't yet initialized
2513 * completely when built-in to the kernel right between the time
2514 * window between nl80211_init() and regulatory_init(), if that is
2515 * even possible.
2516 */
2517 mutex_lock(&cfg80211_mutex);
2518 if (unlikely(!cfg80211_regdomain)) {
fe33eb39
LR		 2519 mutex_unlock(&cfg80211_mutex);
2520 return -EINPROGRESS;
80778f18 2521 }
fe33eb39 2522 mutex_unlock(&cfg80211_mutex);
80778f18 2523
fe33eb39
LR		 2524 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2525 return -EINVAL;
b2e1b302
LR		 2526
2527 data = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2528
2529#ifdef CONFIG_WIRELESS_OLD_REGULATORY
2530 /* We ignore world regdom requests with the old regdom setup */
fe33eb39
LR		 2531 if (is_world_regdom(data))
2532 return -EINVAL;
b2e1b302 2533#endif
fe33eb39
LR		 2534
2535 r = regulatory_hint_user(data);
2536
b2e1b302
LR		 2537 return r;
2538}
2539
93da9cc1 2540static int nl80211_get_mesh_params(struct sk_buff *skb,
2541 struct genl_info *info)
2542{
79c97e97 2543 struct cfg80211_registered_device *rdev;
93da9cc1 2544 struct mesh_config cur_params;
2545 int err;
2546 struct net_device *dev;
2547 void *hdr;
2548 struct nlattr *pinfoattr;
2549 struct sk_buff *msg;
2550
3b85875a
JB		 2551 rtnl_lock();
2552
93da9cc1 2553 /* Look up our device */
463d0183 2554 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
93da9cc1 2555 if (err)
3b85875a 2556 goto out_rtnl;
93da9cc1 2557
79c97e97 2558 if (!rdev->ops->get_mesh_params) {
f3f92586
JM		 2559 err = -EOPNOTSUPP;
2560 goto out;
2561 }
2562
93da9cc1 2563 /* Get the mesh params */
79c97e97 2564 err = rdev->ops->get_mesh_params(&rdev->wiphy, dev, &cur_params);
93da9cc1 2565 if (err)
2566 goto out;
2567
2568 /* Draw up a netlink message to send back */
fd2120ca 2569 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
93da9cc1 2570 if (!msg) {
2571 err = -ENOBUFS;
2572 goto out;
2573 }
2574 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2575 NL80211_CMD_GET_MESH_PARAMS);
2576 if (!hdr)
2577 goto nla_put_failure;
2578 pinfoattr = nla_nest_start(msg, NL80211_ATTR_MESH_PARAMS);
2579 if (!pinfoattr)
2580 goto nla_put_failure;
2581 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, dev->ifindex);
2582 NLA_PUT_U16(msg, NL80211_MESHCONF_RETRY_TIMEOUT,
2583 cur_params.dot11MeshRetryTimeout);
2584 NLA_PUT_U16(msg, NL80211_MESHCONF_CONFIRM_TIMEOUT,
2585 cur_params.dot11MeshConfirmTimeout);
2586 NLA_PUT_U16(msg, NL80211_MESHCONF_HOLDING_TIMEOUT,
2587 cur_params.dot11MeshHoldingTimeout);
2588 NLA_PUT_U16(msg, NL80211_MESHCONF_MAX_PEER_LINKS,
2589 cur_params.dot11MeshMaxPeerLinks);
2590 NLA_PUT_U8(msg, NL80211_MESHCONF_MAX_RETRIES,
2591 cur_params.dot11MeshMaxRetries);
2592 NLA_PUT_U8(msg, NL80211_MESHCONF_TTL,
2593 cur_params.dot11MeshTTL);
2594 NLA_PUT_U8(msg, NL80211_MESHCONF_AUTO_OPEN_PLINKS,
2595 cur_params.auto_open_plinks);
2596 NLA_PUT_U8(msg, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2597 cur_params.dot11MeshHWMPmaxPREQretries);
2598 NLA_PUT_U32(msg, NL80211_MESHCONF_PATH_REFRESH_TIME,
2599 cur_params.path_refresh_time);
2600 NLA_PUT_U16(msg, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2601 cur_params.min_discovery_timeout);
2602 NLA_PUT_U32(msg, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2603 cur_params.dot11MeshHWMPactivePathTimeout);
2604 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2605 cur_params.dot11MeshHWMPpreqMinInterval);
2606 NLA_PUT_U16(msg, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2607 cur_params.dot11MeshHWMPnetDiameterTraversalTime);
2608 nla_nest_end(msg, pinfoattr);
2609 genlmsg_end(msg, hdr);
134e6375 2610 err = genlmsg_reply(msg, info);
93da9cc1 2611 goto out;
2612
3b85875a 2613 nla_put_failure:
93da9cc1 2614 genlmsg_cancel(msg, hdr);
2615 err = -EMSGSIZE;
3b85875a 2616 out:
93da9cc1 2617 /* Cleanup */
79c97e97 2618 cfg80211_unlock_rdev(rdev);
93da9cc1 2619 dev_put(dev);
3b85875a
JB		 2620 out_rtnl:
2621 rtnl_unlock();
2622
93da9cc1 2623 return err;
2624}
2625
2626#define FILL_IN_MESH_PARAM_IF_SET(table, cfg, param, mask, attr_num, nla_fn) \
2627do {\
2628 if (table[attr_num]) {\
2629 cfg.param = nla_fn(table[attr_num]); \
2630 mask |= (1 << (attr_num - 1)); \
2631 } \
2632} while (0);\
2633
2634static struct nla_policy
2635nl80211_meshconf_params_policy[NL80211_MESHCONF_ATTR_MAX+1] __read_mostly = {
2636 [NL80211_MESHCONF_RETRY_TIMEOUT] = { .type = NLA_U16 },
2637 [NL80211_MESHCONF_CONFIRM_TIMEOUT] = { .type = NLA_U16 },
2638 [NL80211_MESHCONF_HOLDING_TIMEOUT] = { .type = NLA_U16 },
2639 [NL80211_MESHCONF_MAX_PEER_LINKS] = { .type = NLA_U16 },
2640 [NL80211_MESHCONF_MAX_RETRIES] = { .type = NLA_U8 },
2641 [NL80211_MESHCONF_TTL] = { .type = NLA_U8 },
2642 [NL80211_MESHCONF_AUTO_OPEN_PLINKS] = { .type = NLA_U8 },
2643
2644 [NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES] = { .type = NLA_U8 },
2645 [NL80211_MESHCONF_PATH_REFRESH_TIME] = { .type = NLA_U32 },
2646 [NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT] = { .type = NLA_U16 },
2647 [NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT] = { .type = NLA_U32 },
2648 [NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL] = { .type = NLA_U16 },
2649 [NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME] = { .type = NLA_U16 },
2650};
2651
2652static int nl80211_set_mesh_params(struct sk_buff *skb, struct genl_info *info)
2653{
2654 int err;
2655 u32 mask;
79c97e97 2656 struct cfg80211_registered_device *rdev;
93da9cc1 2657 struct net_device *dev;
2658 struct mesh_config cfg;
2659 struct nlattr *tb[NL80211_MESHCONF_ATTR_MAX + 1];
2660 struct nlattr *parent_attr;
2661
2662 parent_attr = info->attrs[NL80211_ATTR_MESH_PARAMS];
2663 if (!parent_attr)
2664 return -EINVAL;
2665 if (nla_parse_nested(tb, NL80211_MESHCONF_ATTR_MAX,
2666 parent_attr, nl80211_meshconf_params_policy))
2667 return -EINVAL;
2668
3b85875a
JB		 2669 rtnl_lock();
2670
463d0183 2671 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
93da9cc1 2672 if (err)
3b85875a 2673 goto out_rtnl;
93da9cc1 2674
79c97e97 2675 if (!rdev->ops->set_mesh_params) {
f3f92586
JM		 2676 err = -EOPNOTSUPP;
2677 goto out;
2678 }
2679
93da9cc1 2680 /* This makes sure that there aren't more than 32 mesh config
2681 * parameters (otherwise our bitfield scheme would not work.) */
2682 BUILD_BUG_ON(NL80211_MESHCONF_ATTR_MAX > 32);
2683
2684 /* Fill in the params struct */
2685 mask = 0;
2686 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshRetryTimeout,
2687 mask, NL80211_MESHCONF_RETRY_TIMEOUT, nla_get_u16);
2688 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshConfirmTimeout,
2689 mask, NL80211_MESHCONF_CONFIRM_TIMEOUT, nla_get_u16);
2690 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHoldingTimeout,
2691 mask, NL80211_MESHCONF_HOLDING_TIMEOUT, nla_get_u16);
2692 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxPeerLinks,
2693 mask, NL80211_MESHCONF_MAX_PEER_LINKS, nla_get_u16);
2694 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshMaxRetries,
2695 mask, NL80211_MESHCONF_MAX_RETRIES, nla_get_u8);
2696 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshTTL,
2697 mask, NL80211_MESHCONF_TTL, nla_get_u8);
2698 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, auto_open_plinks,
2699 mask, NL80211_MESHCONF_AUTO_OPEN_PLINKS, nla_get_u8);
2700 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPmaxPREQretries,
2701 mask, NL80211_MESHCONF_HWMP_MAX_PREQ_RETRIES,
2702 nla_get_u8);
2703 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, path_refresh_time,
2704 mask, NL80211_MESHCONF_PATH_REFRESH_TIME, nla_get_u32);
2705 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, min_discovery_timeout,
2706 mask, NL80211_MESHCONF_MIN_DISCOVERY_TIMEOUT,
2707 nla_get_u16);
2708 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPactivePathTimeout,
2709 mask, NL80211_MESHCONF_HWMP_ACTIVE_PATH_TIMEOUT,
2710 nla_get_u32);
2711 FILL_IN_MESH_PARAM_IF_SET(tb, cfg, dot11MeshHWMPpreqMinInterval,
2712 mask, NL80211_MESHCONF_HWMP_PREQ_MIN_INTERVAL,
2713 nla_get_u16);
2714 FILL_IN_MESH_PARAM_IF_SET(tb, cfg,
2715 dot11MeshHWMPnetDiameterTraversalTime,
2716 mask, NL80211_MESHCONF_HWMP_NET_DIAM_TRVS_TIME,
2717 nla_get_u16);
2718
2719 /* Apply changes */
79c97e97 2720 err = rdev->ops->set_mesh_params(&rdev->wiphy, dev, &cfg, mask);
93da9cc1 2721
f3f92586 2722 out:
93da9cc1 2723 /* cleanup */
79c97e97 2724 cfg80211_unlock_rdev(rdev);
93da9cc1 2725 dev_put(dev);
3b85875a
JB		 2726 out_rtnl:
2727 rtnl_unlock();
2728
93da9cc1 2729 return err;
2730}
2731
2732#undef FILL_IN_MESH_PARAM_IF_SET
2733
f130347c
LR		 2734static int nl80211_get_reg(struct sk_buff *skb, struct genl_info *info)
2735{
2736 struct sk_buff *msg;
2737 void *hdr = NULL;
2738 struct nlattr *nl_reg_rules;
2739 unsigned int i;
2740 int err = -EINVAL;
2741
a1794390 2742 mutex_lock(&cfg80211_mutex);
f130347c
LR		 2743
2744 if (!cfg80211_regdomain)
2745 goto out;
2746
fd2120ca 2747 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
f130347c
LR		 2748 if (!msg) {
2749 err = -ENOBUFS;
2750 goto out;
2751 }
2752
2753 hdr = nl80211hdr_put(msg, info->snd_pid, info->snd_seq, 0,
2754 NL80211_CMD_GET_REG);
2755 if (!hdr)
2756 goto nla_put_failure;
2757
2758 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2,
2759 cfg80211_regdomain->alpha2);
2760
2761 nl_reg_rules = nla_nest_start(msg, NL80211_ATTR_REG_RULES);
2762 if (!nl_reg_rules)
2763 goto nla_put_failure;
2764
2765 for (i = 0; i < cfg80211_regdomain->n_reg_rules; i++) {
2766 struct nlattr *nl_reg_rule;
2767 const struct ieee80211_reg_rule *reg_rule;
2768 const struct ieee80211_freq_range *freq_range;
2769 const struct ieee80211_power_rule *power_rule;
2770
2771 reg_rule = &cfg80211_regdomain->reg_rules[i];
2772 freq_range = &reg_rule->freq_range;
2773 power_rule = &reg_rule->power_rule;
2774
2775 nl_reg_rule = nla_nest_start(msg, i);
2776 if (!nl_reg_rule)
2777 goto nla_put_failure;
2778
2779 NLA_PUT_U32(msg, NL80211_ATTR_REG_RULE_FLAGS,
2780 reg_rule->flags);
2781 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_START,
2782 freq_range->start_freq_khz);
2783 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_END,
2784 freq_range->end_freq_khz);
2785 NLA_PUT_U32(msg, NL80211_ATTR_FREQ_RANGE_MAX_BW,
2786 freq_range->max_bandwidth_khz);
2787 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_ANT_GAIN,
2788 power_rule->max_antenna_gain);
2789 NLA_PUT_U32(msg, NL80211_ATTR_POWER_RULE_MAX_EIRP,
2790 power_rule->max_eirp);
2791
2792 nla_nest_end(msg, nl_reg_rule);
2793 }
2794
2795 nla_nest_end(msg, nl_reg_rules);
2796
2797 genlmsg_end(msg, hdr);
134e6375 2798 err = genlmsg_reply(msg, info);
f130347c
LR		 2799 goto out;
2800
2801nla_put_failure:
2802 genlmsg_cancel(msg, hdr);
2803 err = -EMSGSIZE;
2804out:
a1794390 2805 mutex_unlock(&cfg80211_mutex);
f130347c
LR		 2806 return err;
2807}
2808
b2e1b302
LR		 2809static int nl80211_set_reg(struct sk_buff *skb, struct genl_info *info)
2810{
2811 struct nlattr *tb[NL80211_REG_RULE_ATTR_MAX + 1];
2812 struct nlattr *nl_reg_rule;
2813 char *alpha2 = NULL;
2814 int rem_reg_rules = 0, r = 0;
2815 u32 num_rules = 0, rule_idx = 0, size_of_regd;
2816 struct ieee80211_regdomain *rd = NULL;
2817
2818 if (!info->attrs[NL80211_ATTR_REG_ALPHA2])
2819 return -EINVAL;
2820
2821 if (!info->attrs[NL80211_ATTR_REG_RULES])
2822 return -EINVAL;
2823
2824 alpha2 = nla_data(info->attrs[NL80211_ATTR_REG_ALPHA2]);
2825
2826 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2827 rem_reg_rules) {
2828 num_rules++;
2829 if (num_rules > NL80211_MAX_SUPP_REG_RULES)
4776c6e7 2830 return -EINVAL;
b2e1b302
LR		 2831 }
2832
61405e97
LR		 2833 mutex_lock(&cfg80211_mutex);
2834
d0e18f83
LR		 2835 if (!reg_is_valid_request(alpha2)) {
2836 r = -EINVAL;
2837 goto bad_reg;
2838 }
b2e1b302
LR		 2839
2840 size_of_regd = sizeof(struct ieee80211_regdomain) +
2841 (num_rules * sizeof(struct ieee80211_reg_rule));
2842
2843 rd = kzalloc(size_of_regd, GFP_KERNEL);
d0e18f83
LR		 2844 if (!rd) {
2845 r = -ENOMEM;
2846 goto bad_reg;
2847 }
b2e1b302
LR		 2848
2849 rd->n_reg_rules = num_rules;
2850 rd->alpha2[0] = alpha2[0];
2851 rd->alpha2[1] = alpha2[1];
2852
2853 nla_for_each_nested(nl_reg_rule, info->attrs[NL80211_ATTR_REG_RULES],
2854 rem_reg_rules) {
2855 nla_parse(tb, NL80211_REG_RULE_ATTR_MAX,
2856 nla_data(nl_reg_rule), nla_len(nl_reg_rule),
2857 reg_rule_policy);
2858 r = parse_reg_rule(tb, &rd->reg_rules[rule_idx]);
2859 if (r)
2860 goto bad_reg;
2861
2862 rule_idx++;
2863
d0e18f83
LR		 2864 if (rule_idx > NL80211_MAX_SUPP_REG_RULES) {
2865 r = -EINVAL;
b2e1b302 2866 goto bad_reg;
d0e18f83 2867 }
b2e1b302
LR		 2868 }
2869
2870 BUG_ON(rule_idx != num_rules);
2871
b2e1b302 2872 r = set_regdom(rd);
61405e97 2873
a1794390 2874 mutex_unlock(&cfg80211_mutex);
d0e18f83 2875
b2e1b302
LR		 2876 return r;
2877
d2372b31 2878 bad_reg:
61405e97 2879 mutex_unlock(&cfg80211_mutex);
b2e1b302 2880 kfree(rd);
d0e18f83 2881 return r;
b2e1b302
LR		 2882}
2883
83f5e2cf
JB		 2884static int validate_scan_freqs(struct nlattr *freqs)
2885{
2886 struct nlattr *attr1, *attr2;
2887 int n_channels = 0, tmp1, tmp2;
2888
2889 nla_for_each_nested(attr1, freqs, tmp1) {
2890 n_channels++;
2891 /*
2892 * Some hardware has a limited channel list for
2893 * scanning, and it is pretty much nonsensical
2894 * to scan for a channel twice, so disallow that
2895 * and don't require drivers to check that the
2896 * channel list they get isn't longer than what
2897 * they can scan, as long as they can scan all
2898 * the channels they registered at once.
2899 */
2900 nla_for_each_nested(attr2, freqs, tmp2)
2901 if (attr1 != attr2 &&
2902 nla_get_u32(attr1) == nla_get_u32(attr2))
2903 return 0;
2904 }
2905
2906 return n_channels;
2907}
2908
2a519311
JB		 2909static int nl80211_trigger_scan(struct sk_buff *skb, struct genl_info *info)
2910{
79c97e97 2911 struct cfg80211_registered_device *rdev;
2a519311
JB		 2912 struct net_device *dev;
2913 struct cfg80211_scan_request *request;
2914 struct cfg80211_ssid *ssid;
2915 struct ieee80211_channel *channel;
2916 struct nlattr *attr;
2917 struct wiphy *wiphy;
83f5e2cf 2918 int err, tmp, n_ssids = 0, n_channels, i;
2a519311 2919 enum ieee80211_band band;
70692ad2 2920 size_t ie_len;
2a519311 2921
f4a11bb0
JB		 2922 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
2923 return -EINVAL;
2924
3b85875a
JB		 2925 rtnl_lock();
2926
463d0183 2927 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
2a519311 2928 if (err)
3b85875a 2929 goto out_rtnl;
2a519311 2930
79c97e97 2931 wiphy = &rdev->wiphy;
2a519311 2932
79c97e97 2933 if (!rdev->ops->scan) {
2a519311
JB		 2934 err = -EOPNOTSUPP;
2935 goto out;
2936 }
2937
35a8efe1
JM		 2938 if (!netif_running(dev)) {
2939 err = -ENETDOWN;
2940 goto out;
2941 }
2942
79c97e97 2943 if (rdev->scan_req) {
2a519311 2944 err = -EBUSY;
3b85875a 2945 goto out;
2a519311
JB		 2946 }
2947
2948 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
83f5e2cf
JB		 2949 n_channels = validate_scan_freqs(
2950 info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]);
2a519311
JB		 2951 if (!n_channels) {
2952 err = -EINVAL;
3b85875a 2953 goto out;
2a519311
JB		 2954 }
2955 } else {
83f5e2cf
JB		 2956 n_channels = 0;
2957
2a519311
JB		 2958 for (band = 0; band < IEEE80211_NUM_BANDS; band++)
2959 if (wiphy->bands[band])
2960 n_channels += wiphy->bands[band]->n_channels;
2961 }
2962
2963 if (info->attrs[NL80211_ATTR_SCAN_SSIDS])
2964 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp)
2965 n_ssids++;
2966
2967 if (n_ssids > wiphy->max_scan_ssids) {
2968 err = -EINVAL;
3b85875a 2969 goto out;
2a519311
JB		 2970 }
2971
70692ad2
JM		 2972 if (info->attrs[NL80211_ATTR_IE])
2973 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
2974 else
2975 ie_len = 0;
2976
18a83659
JB		 2977 if (ie_len > wiphy->max_scan_ie_len) {
2978 err = -EINVAL;
2979 goto out;
2980 }
2981
2a519311
JB		 2982 request = kzalloc(sizeof(*request)
2983 + sizeof(*ssid) * n_ssids
70692ad2
JM		 2984 + sizeof(channel) * n_channels
2985 + ie_len, GFP_KERNEL);
2a519311
JB		 2986 if (!request) {
2987 err = -ENOMEM;
3b85875a 2988 goto out;
2a519311
JB		 2989 }
2990
2a519311
JB		 2991 request->n_channels = n_channels;
2992 if (n_ssids)
5ba63533 2993 request->ssids = (void *)&request->channels[n_channels];
2a519311 2994 request->n_ssids = n_ssids;
70692ad2
JM		 2995 if (ie_len) {
2996 if (request->ssids)
2997 request->ie = (void *)(request->ssids + n_ssids);
2998 else
2999 request->ie = (void *)(request->channels + n_channels);
3000 }
2a519311
JB		 3001
3002 if (info->attrs[NL80211_ATTR_SCAN_FREQUENCIES]) {
3003 /* user specified, bail out if channel not found */
3004 request->n_channels = n_channels;
3005 i = 0;
3006 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_FREQUENCIES], tmp) {
3007 request->channels[i] = ieee80211_get_channel(wiphy, nla_get_u32(attr));
3008 if (!request->channels[i]) {
3009 err = -EINVAL;
3010 goto out_free;
3011 }
3012 i++;
3013 }
3014 } else {
3015 /* all channels */
3016 i = 0;
3017 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
3018 int j;
3019 if (!wiphy->bands[band])
3020 continue;
3021 for (j = 0; j < wiphy->bands[band]->n_channels; j++) {
3022 request->channels[i] = &wiphy->bands[band]->channels[j];
3023 i++;
3024 }
3025 }
3026 }
3027
3028 i = 0;
3029 if (info->attrs[NL80211_ATTR_SCAN_SSIDS]) {
3030 nla_for_each_nested(attr, info->attrs[NL80211_ATTR_SCAN_SSIDS], tmp) {
3031 if (request->ssids[i].ssid_len > IEEE80211_MAX_SSID_LEN) {
3032 err = -EINVAL;
3033 goto out_free;
3034 }
3035 memcpy(request->ssids[i].ssid, nla_data(attr), nla_len(attr));
3036 request->ssids[i].ssid_len = nla_len(attr);
3037 i++;
3038 }
3039 }
3040
70692ad2
JM		 3041 if (info->attrs[NL80211_ATTR_IE]) {
3042 request->ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
de95a54b
JB		 3043 memcpy((void *)request->ie,
3044 nla_data(info->attrs[NL80211_ATTR_IE]),
70692ad2
JM		 3045 request->ie_len);
3046 }
3047
463d0183 3048 request->dev = dev;
79c97e97 3049 request->wiphy = &rdev->wiphy;
2a519311 3050
79c97e97
JB		 3051 rdev->scan_req = request;
3052 err = rdev->ops->scan(&rdev->wiphy, dev, request);
2a519311 3053
463d0183 3054 if (!err) {
79c97e97 3055 nl80211_send_scan_start(rdev, dev);
463d0183
JB		 3056 dev_hold(dev);
3057 }
a538e2d5 3058
2a519311
JB		 3059 out_free:
3060 if (err) {
79c97e97 3061 rdev->scan_req = NULL;
2a519311
JB		 3062 kfree(request);
3063 }
2a519311 3064 out:
79c97e97 3065 cfg80211_unlock_rdev(rdev);
2a519311 3066 dev_put(dev);
3b85875a
JB		 3067 out_rtnl:
3068 rtnl_unlock();
3069
2a519311
JB		 3070 return err;
3071}
3072
3073static int nl80211_send_bss(struct sk_buff *msg, u32 pid, u32 seq, int flags,
3074 struct cfg80211_registered_device *rdev,
48ab905d
JB		 3075 struct wireless_dev *wdev,
3076 struct cfg80211_internal_bss *intbss)
2a519311 3077{
48ab905d 3078 struct cfg80211_bss *res = &intbss->pub;
2a519311
JB		 3079 void *hdr;
3080 struct nlattr *bss;
48ab905d
JB		 3081 int i;
3082
3083 ASSERT_WDEV_LOCK(wdev);
2a519311
JB		 3084
3085 hdr = nl80211hdr_put(msg, pid, seq, flags,
3086 NL80211_CMD_NEW_SCAN_RESULTS);
3087 if (!hdr)
3088 return -1;
3089
f5ea9120 3090 NLA_PUT_U32(msg, NL80211_ATTR_GENERATION, rdev->bss_generation);
48ab905d 3091 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, wdev->netdev->ifindex);
2a519311
JB		 3092
3093 bss = nla_nest_start(msg, NL80211_ATTR_BSS);
3094 if (!bss)
3095 goto nla_put_failure;
3096 if (!is_zero_ether_addr(res->bssid))
3097 NLA_PUT(msg, NL80211_BSS_BSSID, ETH_ALEN, res->bssid);
3098 if (res->information_elements && res->len_information_elements)
3099 NLA_PUT(msg, NL80211_BSS_INFORMATION_ELEMENTS,
3100 res->len_information_elements,
3101 res->information_elements);
3102 if (res->tsf)
3103 NLA_PUT_U64(msg, NL80211_BSS_TSF, res->tsf);
3104 if (res->beacon_interval)
3105 NLA_PUT_U16(msg, NL80211_BSS_BEACON_INTERVAL, res->beacon_interval);
3106 NLA_PUT_U16(msg, NL80211_BSS_CAPABILITY, res->capability);
3107 NLA_PUT_U32(msg, NL80211_BSS_FREQUENCY, res->channel->center_freq);
3108
77965c97 3109 switch (rdev->wiphy.signal_type) {
2a519311
JB		 3110 case CFG80211_SIGNAL_TYPE_MBM:
3111 NLA_PUT_U32(msg, NL80211_BSS_SIGNAL_MBM, res->signal);
3112 break;
3113 case CFG80211_SIGNAL_TYPE_UNSPEC:
3114 NLA_PUT_U8(msg, NL80211_BSS_SIGNAL_UNSPEC, res->signal);
3115 break;
3116 default:
3117 break;
3118 }
3119
48ab905d
JB		 3120 switch (wdev->iftype) {
3121 case NL80211_IFTYPE_STATION:
3122 if (intbss == wdev->current_bss)
3123 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3124 NL80211_BSS_STATUS_ASSOCIATED);
3125 else for (i = 0; i < MAX_AUTH_BSSES; i++) {
3126 if (intbss != wdev->auth_bsses[i])
3127 continue;
3128 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3129 NL80211_BSS_STATUS_AUTHENTICATED);
3130 break;
3131 }
3132 break;
3133 case NL80211_IFTYPE_ADHOC:
3134 if (intbss == wdev->current_bss)
3135 NLA_PUT_U32(msg, NL80211_BSS_STATUS,
3136 NL80211_BSS_STATUS_IBSS_JOINED);
3137 break;
3138 default:
3139 break;
3140 }
3141
2a519311
JB		 3142 nla_nest_end(msg, bss);
3143
3144 return genlmsg_end(msg, hdr);
3145
3146 nla_put_failure:
3147 genlmsg_cancel(msg, hdr);
3148 return -EMSGSIZE;
3149}
3150
3151static int nl80211_dump_scan(struct sk_buff *skb,
3152 struct netlink_callback *cb)
3153{
48ab905d
JB		 3154 struct cfg80211_registered_device *rdev;
3155 struct net_device *dev;
2a519311 3156 struct cfg80211_internal_bss *scan;
48ab905d 3157 struct wireless_dev *wdev;
2a519311
JB		 3158 int ifidx = cb->args[0];
3159 int start = cb->args[1], idx = 0;
3160 int err;
3161
3162 if (!ifidx) {
3163 err = nlmsg_parse(cb->nlh, GENL_HDRLEN + nl80211_fam.hdrsize,
3164 nl80211_fam.attrbuf, nl80211_fam.maxattr,
3165 nl80211_policy);
3166 if (err)
3167 return err;
3168
3169 if (!nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX])
3170 return -EINVAL;
3171
3172 ifidx = nla_get_u32(nl80211_fam.attrbuf[NL80211_ATTR_IFINDEX]);
3173 if (!ifidx)
3174 return -EINVAL;
3175 cb->args[0] = ifidx;
3176 }
3177
463d0183 3178 dev = dev_get_by_index(sock_net(skb->sk), ifidx);
48ab905d 3179 if (!dev)
2a519311
JB		 3180 return -ENODEV;
3181
463d0183 3182 rdev = cfg80211_get_dev_from_ifindex(sock_net(skb->sk), ifidx);
48ab905d
JB		 3183 if (IS_ERR(rdev)) {
3184 err = PTR_ERR(rdev);
2a519311
JB		 3185 goto out_put_netdev;
3186 }
3187
48ab905d 3188 wdev = dev->ieee80211_ptr;
2a519311 3189
48ab905d
JB		 3190 wdev_lock(wdev);
3191 spin_lock_bh(&rdev->bss_lock);
3192 cfg80211_bss_expire(rdev);
3193
3194 list_for_each_entry(scan, &rdev->bss_list, list) {
2a519311
JB		 3195 if (++idx <= start)
3196 continue;
3197 if (nl80211_send_bss(skb,
3198 NETLINK_CB(cb->skb).pid,
3199 cb->nlh->nlmsg_seq, NLM_F_MULTI,
48ab905d 3200 rdev, wdev, scan) < 0) {
2a519311
JB		 3201 idx--;
3202 goto out;
3203 }
3204 }
3205
3206 out:
48ab905d
JB		 3207 spin_unlock_bh(&rdev->bss_lock);
3208 wdev_unlock(wdev);
2a519311
JB		 3209
3210 cb->args[1] = idx;
3211 err = skb->len;
48ab905d 3212 cfg80211_unlock_rdev(rdev);
2a519311 3213 out_put_netdev:
48ab905d 3214 dev_put(dev);
2a519311
JB		 3215
3216 return err;
3217}
3218
255e737e
JM		 3219static bool nl80211_valid_auth_type(enum nl80211_auth_type auth_type)
3220{
b23aa676
SO		 3221 return auth_type <= NL80211_AUTHTYPE_MAX;
3222}
3223
3224static bool nl80211_valid_wpa_versions(u32 wpa_versions)
3225{
3226 return !(wpa_versions & ~(NL80211_WPA_VERSION_1 |
3227 NL80211_WPA_VERSION_2));
3228}
3229
3230static bool nl80211_valid_akm_suite(u32 akm)
3231{
3232 return akm == WLAN_AKM_SUITE_8021X ||
3233 akm == WLAN_AKM_SUITE_PSK;
3234}
3235
3236static bool nl80211_valid_cipher_suite(u32 cipher)
3237{
3238 return cipher == WLAN_CIPHER_SUITE_WEP40 ||
3239 cipher == WLAN_CIPHER_SUITE_WEP104 ||
3240 cipher == WLAN_CIPHER_SUITE_TKIP ||
3241 cipher == WLAN_CIPHER_SUITE_CCMP ||
3242 cipher == WLAN_CIPHER_SUITE_AES_CMAC;
255e737e
JM		 3243}
3244
b23aa676 3245
636a5d36
JM		 3246static int nl80211_authenticate(struct sk_buff *skb, struct genl_info *info)
3247{
79c97e97 3248 struct cfg80211_registered_device *rdev;
636a5d36 3249 struct net_device *dev;
19957bb3
JB		 3250 struct ieee80211_channel *chan;
3251 const u8 *bssid, *ssid, *ie = NULL;
3252 int err, ssid_len, ie_len = 0;
3253 enum nl80211_auth_type auth_type;
fffd0934 3254 struct key_parse key;
636a5d36 3255
f4a11bb0
JB		 3256 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3257 return -EINVAL;
3258
3259 if (!info->attrs[NL80211_ATTR_MAC])
3260 return -EINVAL;
3261
1778092e
JM		 3262 if (!info->attrs[NL80211_ATTR_AUTH_TYPE])
3263 return -EINVAL;
3264
19957bb3
JB		 3265 if (!info->attrs[NL80211_ATTR_SSID])
3266 return -EINVAL;
3267
3268 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ])
3269 return -EINVAL;
3270
fffd0934
JB		 3271 err = nl80211_parse_key(info, &key);
3272 if (err)
3273 return err;
3274
3275 if (key.idx >= 0) {
3276 if (!key.p.key || !key.p.key_len)
3277 return -EINVAL;
3278 if ((key.p.cipher != WLAN_CIPHER_SUITE_WEP40 ||
3279 key.p.key_len != WLAN_KEY_LEN_WEP40) &&
3280 (key.p.cipher != WLAN_CIPHER_SUITE_WEP104 ||
3281 key.p.key_len != WLAN_KEY_LEN_WEP104))
3282 return -EINVAL;
3283 if (key.idx > 4)
3284 return -EINVAL;
3285 } else {
3286 key.p.key_len = 0;
3287 key.p.key = NULL;
3288 }
3289
636a5d36
JM		 3290 rtnl_lock();
3291
463d0183 3292 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
636a5d36
JM		 3293 if (err)
3294 goto unlock_rtnl;
3295
79c97e97 3296 if (!rdev->ops->auth) {
636a5d36
JM		 3297 err = -EOPNOTSUPP;
3298 goto out;
3299 }
3300
eec60b03
JM		 3301 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3302 err = -EOPNOTSUPP;
3303 goto out;
3304 }
3305
35a8efe1
JM		 3306 if (!netif_running(dev)) {
3307 err = -ENETDOWN;
3308 goto out;
3309 }
3310
19957bb3 3311 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
79c97e97 3312 chan = ieee80211_get_channel(&rdev->wiphy,
19957bb3
JB		 3313 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3314 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3315 err = -EINVAL;
3316 goto out;
636a5d36
JM		 3317 }
3318
19957bb3
JB		 3319 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3320 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 3321
3322 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 3323 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3324 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 3325 }
3326
19957bb3
JB		 3327 auth_type = nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3328 if (!nl80211_valid_auth_type(auth_type)) {
1778092e
JM		 3329 err = -EINVAL;
3330 goto out;
636a5d36
JM		 3331 }
3332
79c97e97 3333 err = cfg80211_mlme_auth(rdev, dev, chan, auth_type, bssid,
fffd0934
JB		 3334 ssid, ssid_len, ie, ie_len,
3335 key.p.key, key.p.key_len, key.idx);
636a5d36
JM		 3336
3337out:
79c97e97 3338 cfg80211_unlock_rdev(rdev);
636a5d36
JM		 3339 dev_put(dev);
3340unlock_rtnl:
3341 rtnl_unlock();
3342 return err;
3343}
3344
b23aa676 3345static int nl80211_crypto_settings(struct genl_info *info,
3dc27d25
JB		 3346 struct cfg80211_crypto_settings *settings,
3347 int cipher_limit)
b23aa676 3348{
c0b2bbd8
JB		 3349 memset(settings, 0, sizeof(*settings));
3350
b23aa676
SO		 3351 settings->control_port = info->attrs[NL80211_ATTR_CONTROL_PORT];
3352
3353 if (info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]) {
3354 void *data;
3355 int len, i;
3356
3357 data = nla_data(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3358 len = nla_len(info->attrs[NL80211_ATTR_CIPHER_SUITES_PAIRWISE]);
3359 settings->n_ciphers_pairwise = len / sizeof(u32);
3360
3361 if (len % sizeof(u32))
3362 return -EINVAL;
3363
3dc27d25 3364 if (settings->n_ciphers_pairwise > cipher_limit)
b23aa676
SO		 3365 return -EINVAL;
3366
3367 memcpy(settings->ciphers_pairwise, data, len);
3368
3369 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3370 if (!nl80211_valid_cipher_suite(
3371 settings->ciphers_pairwise[i]))
3372 return -EINVAL;
3373 }
3374
3375 if (info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]) {
3376 settings->cipher_group =
3377 nla_get_u32(info->attrs[NL80211_ATTR_CIPHER_SUITE_GROUP]);
3378 if (!nl80211_valid_cipher_suite(settings->cipher_group))
3379 return -EINVAL;
3380 }
3381
3382 if (info->attrs[NL80211_ATTR_WPA_VERSIONS]) {
3383 settings->wpa_versions =
3384 nla_get_u32(info->attrs[NL80211_ATTR_WPA_VERSIONS]);
3385 if (!nl80211_valid_wpa_versions(settings->wpa_versions))
3386 return -EINVAL;
3387 }
3388
3389 if (info->attrs[NL80211_ATTR_AKM_SUITES]) {
3390 void *data;
3391 int len, i;
3392
3393 data = nla_data(info->attrs[NL80211_ATTR_AKM_SUITES]);
3394 len = nla_len(info->attrs[NL80211_ATTR_AKM_SUITES]);
3395 settings->n_akm_suites = len / sizeof(u32);
3396
3397 if (len % sizeof(u32))
3398 return -EINVAL;
3399
3400 memcpy(settings->akm_suites, data, len);
3401
3402 for (i = 0; i < settings->n_ciphers_pairwise; i++)
3403 if (!nl80211_valid_akm_suite(settings->akm_suites[i]))
3404 return -EINVAL;
3405 }
3406
3407 return 0;
3408}
3409
636a5d36
JM		 3410static int nl80211_associate(struct sk_buff *skb, struct genl_info *info)
3411{
19957bb3 3412 struct cfg80211_registered_device *rdev;
636a5d36 3413 struct net_device *dev;
19957bb3 3414 struct cfg80211_crypto_settings crypto;
59bbb6f7 3415 struct ieee80211_channel *chan, *fixedchan;
3e5d7649 3416 const u8 *bssid, *ssid, *ie = NULL, *prev_bssid = NULL;
19957bb3
JB		 3417 int err, ssid_len, ie_len = 0;
3418 bool use_mfp = false;
636a5d36 3419
f4a11bb0
JB		 3420 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3421 return -EINVAL;
3422
3423 if (!info->attrs[NL80211_ATTR_MAC] ||
19957bb3
JB		 3424 !info->attrs[NL80211_ATTR_SSID] ||
3425 !info->attrs[NL80211_ATTR_WIPHY_FREQ])
f4a11bb0
JB		 3426 return -EINVAL;
3427
636a5d36
JM		 3428 rtnl_lock();
3429
463d0183 3430 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
636a5d36
JM		 3431 if (err)
3432 goto unlock_rtnl;
3433
19957bb3 3434 if (!rdev->ops->assoc) {
636a5d36
JM		 3435 err = -EOPNOTSUPP;
3436 goto out;
3437 }
3438
eec60b03
JM		 3439 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3440 err = -EOPNOTSUPP;
3441 goto out;
3442 }
3443
35a8efe1
JM		 3444 if (!netif_running(dev)) {
3445 err = -ENETDOWN;
3446 goto out;
3447 }
3448
19957bb3 3449 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 3450
19957bb3
JB		 3451 chan = ieee80211_get_channel(&rdev->wiphy,
3452 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3453 if (!chan || (chan->flags & IEEE80211_CHAN_DISABLED)) {
3454 err = -EINVAL;
3455 goto out;
636a5d36
JM		 3456 }
3457
59bbb6f7
JB		 3458 mutex_lock(&rdev->devlist_mtx);
3459 fixedchan = rdev_fixed_channel(rdev, NULL);
3460 if (fixedchan && chan != fixedchan) {
3461 err = -EBUSY;
3462 mutex_unlock(&rdev->devlist_mtx);
3463 goto out;
3464 }
3465 mutex_unlock(&rdev->devlist_mtx);
3466
19957bb3
JB		 3467 ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3468 ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
636a5d36
JM		 3469
3470 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 3471 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3472 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 3473 }
3474
dc6382ce 3475 if (info->attrs[NL80211_ATTR_USE_MFP]) {
4f5dadce 3476 enum nl80211_mfp mfp =
dc6382ce 3477 nla_get_u32(info->attrs[NL80211_ATTR_USE_MFP]);
4f5dadce 3478 if (mfp == NL80211_MFP_REQUIRED)
19957bb3 3479 use_mfp = true;
4f5dadce 3480 else if (mfp != NL80211_MFP_NO) {
dc6382ce
JM		 3481 err = -EINVAL;
3482 goto out;
3483 }
3484 }
3485
3e5d7649
JB		 3486 if (info->attrs[NL80211_ATTR_PREV_BSSID])
3487 prev_bssid = nla_data(info->attrs[NL80211_ATTR_PREV_BSSID]);
3488
3dc27d25 3489 err = nl80211_crypto_settings(info, &crypto, 1);
b23aa676 3490 if (!err)
3e5d7649
JB		 3491 err = cfg80211_mlme_assoc(rdev, dev, chan, bssid, prev_bssid,
3492 ssid, ssid_len, ie, ie_len, use_mfp,
19957bb3 3493 &crypto);
636a5d36
JM		 3494
3495out:
4d0c8aea 3496 cfg80211_unlock_rdev(rdev);
636a5d36
JM		 3497 dev_put(dev);
3498unlock_rtnl:
3499 rtnl_unlock();
3500 return err;
3501}
3502
3503static int nl80211_deauthenticate(struct sk_buff *skb, struct genl_info *info)
3504{
79c97e97 3505 struct cfg80211_registered_device *rdev;
636a5d36 3506 struct net_device *dev;
19957bb3
JB		 3507 const u8 *ie = NULL, *bssid;
3508 int err, ie_len = 0;
3509 u16 reason_code;
636a5d36 3510
f4a11bb0
JB		 3511 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3512 return -EINVAL;
3513
3514 if (!info->attrs[NL80211_ATTR_MAC])
3515 return -EINVAL;
3516
3517 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3518 return -EINVAL;
3519
636a5d36
JM		 3520 rtnl_lock();
3521
463d0183 3522 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
636a5d36
JM		 3523 if (err)
3524 goto unlock_rtnl;
3525
79c97e97 3526 if (!rdev->ops->deauth) {
636a5d36
JM		 3527 err = -EOPNOTSUPP;
3528 goto out;
3529 }
3530
eec60b03
JM		 3531 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3532 err = -EOPNOTSUPP;
3533 goto out;
3534 }
3535
35a8efe1
JM		 3536 if (!netif_running(dev)) {
3537 err = -ENETDOWN;
3538 goto out;
3539 }
3540
19957bb3 3541 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 3542
19957bb3
JB		 3543 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3544 if (reason_code == 0) {
f4a11bb0
JB		 3545 /* Reason Code 0 is reserved */
3546 err = -EINVAL;
3547 goto out;
255e737e 3548 }
636a5d36
JM		 3549
3550 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 3551 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3552 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 3553 }
3554
79c97e97 3555 err = cfg80211_mlme_deauth(rdev, dev, bssid, ie, ie_len, reason_code);
636a5d36
JM		 3556
3557out:
79c97e97 3558 cfg80211_unlock_rdev(rdev);
636a5d36
JM		 3559 dev_put(dev);
3560unlock_rtnl:
3561 rtnl_unlock();
3562 return err;
3563}
3564
3565static int nl80211_disassociate(struct sk_buff *skb, struct genl_info *info)
3566{
79c97e97 3567 struct cfg80211_registered_device *rdev;
636a5d36 3568 struct net_device *dev;
19957bb3
JB		 3569 const u8 *ie = NULL, *bssid;
3570 int err, ie_len = 0;
3571 u16 reason_code;
636a5d36 3572
f4a11bb0
JB		 3573 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3574 return -EINVAL;
3575
3576 if (!info->attrs[NL80211_ATTR_MAC])
3577 return -EINVAL;
3578
3579 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3580 return -EINVAL;
3581
636a5d36
JM		 3582 rtnl_lock();
3583
463d0183 3584 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
636a5d36
JM		 3585 if (err)
3586 goto unlock_rtnl;
3587
79c97e97 3588 if (!rdev->ops->disassoc) {
636a5d36
JM		 3589 err = -EOPNOTSUPP;
3590 goto out;
3591 }
3592
eec60b03
JM		 3593 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3594 err = -EOPNOTSUPP;
3595 goto out;
3596 }
3597
35a8efe1
JM		 3598 if (!netif_running(dev)) {
3599 err = -ENETDOWN;
3600 goto out;
3601 }
3602
19957bb3 3603 bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
636a5d36 3604
19957bb3
JB		 3605 reason_code = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3606 if (reason_code == 0) {
f4a11bb0
JB		 3607 /* Reason Code 0 is reserved */
3608 err = -EINVAL;
3609 goto out;
255e737e 3610 }
636a5d36
JM		 3611
3612 if (info->attrs[NL80211_ATTR_IE]) {
19957bb3
JB		 3613 ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3614 ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
636a5d36
JM		 3615 }
3616
79c97e97 3617 err = cfg80211_mlme_disassoc(rdev, dev, bssid, ie, ie_len, reason_code);
636a5d36
JM		 3618
3619out:
79c97e97 3620 cfg80211_unlock_rdev(rdev);
636a5d36
JM		 3621 dev_put(dev);
3622unlock_rtnl:
3623 rtnl_unlock();
3624 return err;
3625}
3626
04a773ad
JB		 3627static int nl80211_join_ibss(struct sk_buff *skb, struct genl_info *info)
3628{
79c97e97 3629 struct cfg80211_registered_device *rdev;
04a773ad
JB		 3630 struct net_device *dev;
3631 struct cfg80211_ibss_params ibss;
3632 struct wiphy *wiphy;
fffd0934 3633 struct cfg80211_cached_keys *connkeys = NULL;
04a773ad
JB		 3634 int err;
3635
8e30bc55
JB		 3636 memset(&ibss, 0, sizeof(ibss));
3637
04a773ad
JB		 3638 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3639 return -EINVAL;
3640
3641 if (!info->attrs[NL80211_ATTR_WIPHY_FREQ] ||
3642 !info->attrs[NL80211_ATTR_SSID] ||
3643 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3644 return -EINVAL;
3645
8e30bc55
JB		 3646 ibss.beacon_interval = 100;
3647
3648 if (info->attrs[NL80211_ATTR_BEACON_INTERVAL]) {
3649 ibss.beacon_interval =
3650 nla_get_u32(info->attrs[NL80211_ATTR_BEACON_INTERVAL]);
3651 if (ibss.beacon_interval < 1 || ibss.beacon_interval > 10000)
3652 return -EINVAL;
3653 }
3654
04a773ad
JB		 3655 rtnl_lock();
3656
463d0183 3657 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
04a773ad
JB		 3658 if (err)
3659 goto unlock_rtnl;
3660
79c97e97 3661 if (!rdev->ops->join_ibss) {
04a773ad
JB		 3662 err = -EOPNOTSUPP;
3663 goto out;
3664 }
3665
3666 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3667 err = -EOPNOTSUPP;
3668 goto out;
3669 }
3670
3671 if (!netif_running(dev)) {
3672 err = -ENETDOWN;
3673 goto out;
3674 }
3675
79c97e97 3676 wiphy = &rdev->wiphy;
04a773ad
JB		 3677
3678 if (info->attrs[NL80211_ATTR_MAC])
3679 ibss.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3680 ibss.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3681 ibss.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3682
3683 if (info->attrs[NL80211_ATTR_IE]) {
3684 ibss.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3685 ibss.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3686 }
3687
3688 ibss.channel = ieee80211_get_channel(wiphy,
3689 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3690 if (!ibss.channel ||
3691 ibss.channel->flags & IEEE80211_CHAN_NO_IBSS ||
3692 ibss.channel->flags & IEEE80211_CHAN_DISABLED) {
3693 err = -EINVAL;
3694 goto out;
3695 }
3696
3697 ibss.channel_fixed = !!info->attrs[NL80211_ATTR_FREQ_FIXED];
fffd0934
JB		 3698 ibss.privacy = !!info->attrs[NL80211_ATTR_PRIVACY];
3699
3700 if (ibss.privacy && info->attrs[NL80211_ATTR_KEYS]) {
3701 connkeys = nl80211_parse_connkeys(rdev,
3702 info->attrs[NL80211_ATTR_KEYS]);
3703 if (IS_ERR(connkeys)) {
3704 err = PTR_ERR(connkeys);
3705 connkeys = NULL;
3706 goto out;
3707 }
3708 }
04a773ad 3709
fffd0934 3710 err = cfg80211_join_ibss(rdev, dev, &ibss, connkeys);
04a773ad
JB		 3711
3712out:
79c97e97 3713 cfg80211_unlock_rdev(rdev);
04a773ad
JB		 3714 dev_put(dev);
3715unlock_rtnl:
fffd0934
JB		 3716 if (err)
3717 kfree(connkeys);
04a773ad
JB		 3718 rtnl_unlock();
3719 return err;
3720}
3721
3722static int nl80211_leave_ibss(struct sk_buff *skb, struct genl_info *info)
3723{
79c97e97 3724 struct cfg80211_registered_device *rdev;
04a773ad
JB		 3725 struct net_device *dev;
3726 int err;
3727
3728 rtnl_lock();
3729
463d0183 3730 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
04a773ad
JB		 3731 if (err)
3732 goto unlock_rtnl;
3733
79c97e97 3734 if (!rdev->ops->leave_ibss) {
04a773ad
JB		 3735 err = -EOPNOTSUPP;
3736 goto out;
3737 }
3738
3739 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_ADHOC) {
3740 err = -EOPNOTSUPP;
3741 goto out;
3742 }
3743
3744 if (!netif_running(dev)) {
3745 err = -ENETDOWN;
3746 goto out;
3747 }
3748
79c97e97 3749 err = cfg80211_leave_ibss(rdev, dev, false);
04a773ad
JB		 3750
3751out:
79c97e97 3752 cfg80211_unlock_rdev(rdev);
04a773ad
JB		 3753 dev_put(dev);
3754unlock_rtnl:
3755 rtnl_unlock();
3756 return err;
3757}
3758
aff89a9b
JB		 3759#ifdef CONFIG_NL80211_TESTMODE
3760static struct genl_multicast_group nl80211_testmode_mcgrp = {
3761 .name = "testmode",
3762};
3763
3764static int nl80211_testmode_do(struct sk_buff *skb, struct genl_info *info)
3765{
3766 struct cfg80211_registered_device *rdev;
3767 int err;
3768
3769 if (!info->attrs[NL80211_ATTR_TESTDATA])
3770 return -EINVAL;
3771
3772 rtnl_lock();
3773
3774 rdev = cfg80211_get_dev_from_info(info);
3775 if (IS_ERR(rdev)) {
3776 err = PTR_ERR(rdev);
3777 goto unlock_rtnl;
3778 }
3779
3780 err = -EOPNOTSUPP;
3781 if (rdev->ops->testmode_cmd) {
3782 rdev->testmode_info = info;
3783 err = rdev->ops->testmode_cmd(&rdev->wiphy,
3784 nla_data(info->attrs[NL80211_ATTR_TESTDATA]),
3785 nla_len(info->attrs[NL80211_ATTR_TESTDATA]));
3786 rdev->testmode_info = NULL;
3787 }
3788
4d0c8aea 3789 cfg80211_unlock_rdev(rdev);
aff89a9b
JB		 3790
3791 unlock_rtnl:
3792 rtnl_unlock();
3793 return err;
3794}
3795
3796static struct sk_buff *
3797__cfg80211_testmode_alloc_skb(struct cfg80211_registered_device *rdev,
3798 int approxlen, u32 pid, u32 seq, gfp_t gfp)
3799{
3800 struct sk_buff *skb;
3801 void *hdr;
3802 struct nlattr *data;
3803
3804 skb = nlmsg_new(approxlen + 100, gfp);
3805 if (!skb)
3806 return NULL;
3807
3808 hdr = nl80211hdr_put(skb, pid, seq, 0, NL80211_CMD_TESTMODE);
3809 if (!hdr) {
3810 kfree_skb(skb);
3811 return NULL;
3812 }
3813
3814 NLA_PUT_U32(skb, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
3815 data = nla_nest_start(skb, NL80211_ATTR_TESTDATA);
3816
3817 ((void **)skb->cb)[0] = rdev;
3818 ((void **)skb->cb)[1] = hdr;
3819 ((void **)skb->cb)[2] = data;
3820
3821 return skb;
3822
3823 nla_put_failure:
3824 kfree_skb(skb);
3825 return NULL;
3826}
3827
3828struct sk_buff *cfg80211_testmode_alloc_reply_skb(struct wiphy *wiphy,
3829 int approxlen)
3830{
3831 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3832
3833 if (WARN_ON(!rdev->testmode_info))
3834 return NULL;
3835
3836 return __cfg80211_testmode_alloc_skb(rdev, approxlen,
3837 rdev->testmode_info->snd_pid,
3838 rdev->testmode_info->snd_seq,
3839 GFP_KERNEL);
3840}
3841EXPORT_SYMBOL(cfg80211_testmode_alloc_reply_skb);
3842
3843int cfg80211_testmode_reply(struct sk_buff *skb)
3844{
3845 struct cfg80211_registered_device *rdev = ((void **)skb->cb)[0];
3846 void *hdr = ((void **)skb->cb)[1];
3847 struct nlattr *data = ((void **)skb->cb)[2];
3848
3849 if (WARN_ON(!rdev->testmode_info)) {
3850 kfree_skb(skb);
3851 return -EINVAL;
3852 }
3853
3854 nla_nest_end(skb, data);
3855 genlmsg_end(skb, hdr);
3856 return genlmsg_reply(skb, rdev->testmode_info);
3857}
3858EXPORT_SYMBOL(cfg80211_testmode_reply);
3859
3860struct sk_buff *cfg80211_testmode_alloc_event_skb(struct wiphy *wiphy,
3861 int approxlen, gfp_t gfp)
3862{
3863 struct cfg80211_registered_device *rdev = wiphy_to_dev(wiphy);
3864
3865 return __cfg80211_testmode_alloc_skb(rdev, approxlen, 0, 0, gfp);
3866}
3867EXPORT_SYMBOL(cfg80211_testmode_alloc_event_skb);
3868
3869void cfg80211_testmode_event(struct sk_buff *skb, gfp_t gfp)
3870{
3871 void *hdr = ((void **)skb->cb)[1];
3872 struct nlattr *data = ((void **)skb->cb)[2];
3873
3874 nla_nest_end(skb, data);
3875 genlmsg_end(skb, hdr);
3876 genlmsg_multicast(skb, 0, nl80211_testmode_mcgrp.id, gfp);
3877}
3878EXPORT_SYMBOL(cfg80211_testmode_event);
3879#endif
3880
b23aa676
SO		 3881static int nl80211_connect(struct sk_buff *skb, struct genl_info *info)
3882{
79c97e97 3883 struct cfg80211_registered_device *rdev;
b23aa676
SO		 3884 struct net_device *dev;
3885 struct cfg80211_connect_params connect;
3886 struct wiphy *wiphy;
fffd0934 3887 struct cfg80211_cached_keys *connkeys = NULL;
b23aa676
SO		 3888 int err;
3889
3890 memset(&connect, 0, sizeof(connect));
3891
3892 if (!is_valid_ie_attr(info->attrs[NL80211_ATTR_IE]))
3893 return -EINVAL;
3894
3895 if (!info->attrs[NL80211_ATTR_SSID] ||
3896 !nla_len(info->attrs[NL80211_ATTR_SSID]))
3897 return -EINVAL;
3898
3899 if (info->attrs[NL80211_ATTR_AUTH_TYPE]) {
3900 connect.auth_type =
3901 nla_get_u32(info->attrs[NL80211_ATTR_AUTH_TYPE]);
3902 if (!nl80211_valid_auth_type(connect.auth_type))
3903 return -EINVAL;
3904 } else
3905 connect.auth_type = NL80211_AUTHTYPE_AUTOMATIC;
3906
3907 connect.privacy = info->attrs[NL80211_ATTR_PRIVACY];
3908
3dc27d25
JB		 3909 err = nl80211_crypto_settings(info, &connect.crypto,
3910 NL80211_MAX_NR_CIPHER_SUITES);
b23aa676
SO		 3911 if (err)
3912 return err;
3913 rtnl_lock();
3914
463d0183 3915 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
b23aa676
SO		 3916 if (err)
3917 goto unlock_rtnl;
3918
3919 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3920 err = -EOPNOTSUPP;
3921 goto out;
3922 }
3923
3924 if (!netif_running(dev)) {
3925 err = -ENETDOWN;
3926 goto out;
3927 }
3928
79c97e97 3929 wiphy = &rdev->wiphy;
b23aa676 3930
b23aa676
SO		 3931 if (info->attrs[NL80211_ATTR_MAC])
3932 connect.bssid = nla_data(info->attrs[NL80211_ATTR_MAC]);
3933 connect.ssid = nla_data(info->attrs[NL80211_ATTR_SSID]);
3934 connect.ssid_len = nla_len(info->attrs[NL80211_ATTR_SSID]);
3935
3936 if (info->attrs[NL80211_ATTR_IE]) {
3937 connect.ie = nla_data(info->attrs[NL80211_ATTR_IE]);
3938 connect.ie_len = nla_len(info->attrs[NL80211_ATTR_IE]);
3939 }
3940
3941 if (info->attrs[NL80211_ATTR_WIPHY_FREQ]) {
3942 connect.channel =
3943 ieee80211_get_channel(wiphy,
3944 nla_get_u32(info->attrs[NL80211_ATTR_WIPHY_FREQ]));
3945 if (!connect.channel ||
3946 connect.channel->flags & IEEE80211_CHAN_DISABLED) {
3947 err = -EINVAL;
3948 goto out;
3949 }
3950 }
3951
fffd0934
JB		 3952 if (connect.privacy && info->attrs[NL80211_ATTR_KEYS]) {
3953 connkeys = nl80211_parse_connkeys(rdev,
3954 info->attrs[NL80211_ATTR_KEYS]);
3955 if (IS_ERR(connkeys)) {
3956 err = PTR_ERR(connkeys);
3957 connkeys = NULL;
3958 goto out;
3959 }
3960 }
3961
3962 err = cfg80211_connect(rdev, dev, &connect, connkeys);
b23aa676
SO		 3963
3964out:
79c97e97 3965 cfg80211_unlock_rdev(rdev);
b23aa676
SO		 3966 dev_put(dev);
3967unlock_rtnl:
fffd0934
JB		 3968 if (err)
3969 kfree(connkeys);
b23aa676
SO		 3970 rtnl_unlock();
3971 return err;
3972}
3973
3974static int nl80211_disconnect(struct sk_buff *skb, struct genl_info *info)
3975{
79c97e97 3976 struct cfg80211_registered_device *rdev;
b23aa676
SO		 3977 struct net_device *dev;
3978 int err;
3979 u16 reason;
3980
3981 if (!info->attrs[NL80211_ATTR_REASON_CODE])
3982 reason = WLAN_REASON_DEAUTH_LEAVING;
3983 else
3984 reason = nla_get_u16(info->attrs[NL80211_ATTR_REASON_CODE]);
3985
3986 if (reason == 0)
3987 return -EINVAL;
3988
3989 rtnl_lock();
3990
463d0183 3991 err = get_rdev_dev_by_info_ifindex(info, &rdev, &dev);
b23aa676
SO		 3992 if (err)
3993 goto unlock_rtnl;
3994
3995 if (dev->ieee80211_ptr->iftype != NL80211_IFTYPE_STATION) {
3996 err = -EOPNOTSUPP;
3997 goto out;
3998 }
3999
4000 if (!netif_running(dev)) {
4001 err = -ENETDOWN;
4002 goto out;
4003 }
4004
79c97e97 4005 err = cfg80211_disconnect(rdev, dev, reason, true);
b23aa676
SO		 4006
4007out:
79c97e97 4008 cfg80211_unlock_rdev(rdev);
b23aa676
SO		 4009 dev_put(dev);
4010unlock_rtnl:
4011 rtnl_unlock();
4012 return err;
4013}
4014
463d0183
JB		 4015static int nl80211_wiphy_netns(struct sk_buff *skb, struct genl_info *info)
4016{
4017 struct cfg80211_registered_device *rdev;
4018 struct net *net;
4019 int err;
4020 u32 pid;
4021
4022 if (!info->attrs[NL80211_ATTR_PID])
4023 return -EINVAL;
4024
4025 pid = nla_get_u32(info->attrs[NL80211_ATTR_PID]);
4026
4027 rtnl_lock();
4028
4029 rdev = cfg80211_get_dev_from_info(info);
4030 if (IS_ERR(rdev)) {
4031 err = PTR_ERR(rdev);
4032 goto out;
4033 }
4034
4035 net = get_net_ns_by_pid(pid);
4036 if (IS_ERR(net)) {
4037 err = PTR_ERR(net);
4038 goto out;
4039 }
4040
4041 err = 0;
4042
4043 /* check if anything to do */
4044 if (net_eq(wiphy_net(&rdev->wiphy), net))
4045 goto out_put_net;
4046
4047 err = cfg80211_switch_netns(rdev, net);
4048 out_put_net:
4049 put_net(net);
4050 out:
4051 cfg80211_unlock_rdev(rdev);
4052 rtnl_unlock();
4053 return err;
4054}
4055
55682965
JB		 4056static struct genl_ops nl80211_ops[] = {
4057 {
4058 .cmd = NL80211_CMD_GET_WIPHY,
4059 .doit = nl80211_get_wiphy,
4060 .dumpit = nl80211_dump_wiphy,
4061 .policy = nl80211_policy,
4062 /* can be retrieved by unprivileged users */
4063 },
4064 {
4065 .cmd = NL80211_CMD_SET_WIPHY,
4066 .doit = nl80211_set_wiphy,
4067 .policy = nl80211_policy,
4068 .flags = GENL_ADMIN_PERM,
4069 },
4070 {
4071 .cmd = NL80211_CMD_GET_INTERFACE,
4072 .doit = nl80211_get_interface,
4073 .dumpit = nl80211_dump_interface,
4074 .policy = nl80211_policy,
4075 /* can be retrieved by unprivileged users */
4076 },
4077 {
4078 .cmd = NL80211_CMD_SET_INTERFACE,
4079 .doit = nl80211_set_interface,
4080 .policy = nl80211_policy,
4081 .flags = GENL_ADMIN_PERM,
4082 },
4083 {
4084 .cmd = NL80211_CMD_NEW_INTERFACE,
4085 .doit = nl80211_new_interface,
4086 .policy = nl80211_policy,
4087 .flags = GENL_ADMIN_PERM,
4088 },
4089 {
4090 .cmd = NL80211_CMD_DEL_INTERFACE,
4091 .doit = nl80211_del_interface,
4092 .policy = nl80211_policy,
41ade00f
JB		 4093 .flags = GENL_ADMIN_PERM,
4094 },
4095 {
4096 .cmd = NL80211_CMD_GET_KEY,
4097 .doit = nl80211_get_key,
4098 .policy = nl80211_policy,
4099 .flags = GENL_ADMIN_PERM,
4100 },
4101 {
4102 .cmd = NL80211_CMD_SET_KEY,
4103 .doit = nl80211_set_key,
4104 .policy = nl80211_policy,
4105 .flags = GENL_ADMIN_PERM,
4106 },
4107 {
4108 .cmd = NL80211_CMD_NEW_KEY,
4109 .doit = nl80211_new_key,
4110 .policy = nl80211_policy,
4111 .flags = GENL_ADMIN_PERM,
4112 },
4113 {
4114 .cmd = NL80211_CMD_DEL_KEY,
4115 .doit = nl80211_del_key,
4116 .policy = nl80211_policy,
55682965
JB		 4117 .flags = GENL_ADMIN_PERM,
4118 },
ed1b6cc7
JB		 4119 {
4120 .cmd = NL80211_CMD_SET_BEACON,
4121 .policy = nl80211_policy,
4122 .flags = GENL_ADMIN_PERM,
4123 .doit = nl80211_addset_beacon,
4124 },
4125 {
4126 .cmd = NL80211_CMD_NEW_BEACON,
4127 .policy = nl80211_policy,
4128 .flags = GENL_ADMIN_PERM,
4129 .doit = nl80211_addset_beacon,
4130 },
4131 {
4132 .cmd = NL80211_CMD_DEL_BEACON,
4133 .policy = nl80211_policy,
4134 .flags = GENL_ADMIN_PERM,
4135 .doit = nl80211_del_beacon,
4136 },
5727ef1b
JB		 4137 {
4138 .cmd = NL80211_CMD_GET_STATION,
4139 .doit = nl80211_get_station,
2ec600d6 4140 .dumpit = nl80211_dump_station,
5727ef1b 4141 .policy = nl80211_policy,
5727ef1b
JB		 4142 },
4143 {
4144 .cmd = NL80211_CMD_SET_STATION,
4145 .doit = nl80211_set_station,
4146 .policy = nl80211_policy,
4147 .flags = GENL_ADMIN_PERM,
4148 },
4149 {
4150 .cmd = NL80211_CMD_NEW_STATION,
4151 .doit = nl80211_new_station,
4152 .policy = nl80211_policy,
4153 .flags = GENL_ADMIN_PERM,
4154 },
4155 {
4156 .cmd = NL80211_CMD_DEL_STATION,
4157 .doit = nl80211_del_station,
4158 .policy = nl80211_policy,
2ec600d6
LCC		 4159 .flags = GENL_ADMIN_PERM,
4160 },
4161 {
4162 .cmd = NL80211_CMD_GET_MPATH,
4163 .doit = nl80211_get_mpath,
4164 .dumpit = nl80211_dump_mpath,
4165 .policy = nl80211_policy,
4166 .flags = GENL_ADMIN_PERM,
4167 },
4168 {
4169 .cmd = NL80211_CMD_SET_MPATH,
4170 .doit = nl80211_set_mpath,
4171 .policy = nl80211_policy,
4172 .flags = GENL_ADMIN_PERM,
4173 },
4174 {
4175 .cmd = NL80211_CMD_NEW_MPATH,
4176 .doit = nl80211_new_mpath,
4177 .policy = nl80211_policy,
4178 .flags = GENL_ADMIN_PERM,
4179 },
4180 {
4181 .cmd = NL80211_CMD_DEL_MPATH,
4182 .doit = nl80211_del_mpath,
4183 .policy = nl80211_policy,
9f1ba906
JM		 4184 .flags = GENL_ADMIN_PERM,
4185 },
4186 {
4187 .cmd = NL80211_CMD_SET_BSS,
4188 .doit = nl80211_set_bss,
4189 .policy = nl80211_policy,
b2e1b302
LR		 4190 .flags = GENL_ADMIN_PERM,
4191 },
f130347c
LR		 4192 {
4193 .cmd = NL80211_CMD_GET_REG,
4194 .doit = nl80211_get_reg,
4195 .policy = nl80211_policy,
4196 /* can be retrieved by unprivileged users */
4197 },
b2e1b302
LR		 4198 {
4199 .cmd = NL80211_CMD_SET_REG,
4200 .doit = nl80211_set_reg,
4201 .policy = nl80211_policy,
4202 .flags = GENL_ADMIN_PERM,
4203 },
4204 {
4205 .cmd = NL80211_CMD_REQ_SET_REG,
4206 .doit = nl80211_req_set_reg,
4207 .policy = nl80211_policy,
93da9cc1 4208 .flags = GENL_ADMIN_PERM,
4209 },
4210 {
4211 .cmd = NL80211_CMD_GET_MESH_PARAMS,
4212 .doit = nl80211_get_mesh_params,
4213 .policy = nl80211_policy,
4214 /* can be retrieved by unprivileged users */
4215 },
4216 {
4217 .cmd = NL80211_CMD_SET_MESH_PARAMS,
4218 .doit = nl80211_set_mesh_params,
4219 .policy = nl80211_policy,
9aed3cc1
JM		 4220 .flags = GENL_ADMIN_PERM,
4221 },
2a519311
JB		 4222 {
4223 .cmd = NL80211_CMD_TRIGGER_SCAN,
4224 .doit = nl80211_trigger_scan,
4225 .policy = nl80211_policy,
4226 .flags = GENL_ADMIN_PERM,
4227 },
4228 {
4229 .cmd = NL80211_CMD_GET_SCAN,
4230 .policy = nl80211_policy,
4231 .dumpit = nl80211_dump_scan,
4232 },
636a5d36
JM		 4233 {
4234 .cmd = NL80211_CMD_AUTHENTICATE,
4235 .doit = nl80211_authenticate,
4236 .policy = nl80211_policy,
4237 .flags = GENL_ADMIN_PERM,
4238 },
4239 {
4240 .cmd = NL80211_CMD_ASSOCIATE,
4241 .doit = nl80211_associate,
4242 .policy = nl80211_policy,
4243 .flags = GENL_ADMIN_PERM,
4244 },
4245 {
4246 .cmd = NL80211_CMD_DEAUTHENTICATE,
4247 .doit = nl80211_deauthenticate,
4248 .policy = nl80211_policy,
4249 .flags = GENL_ADMIN_PERM,
4250 },
4251 {
4252 .cmd = NL80211_CMD_DISASSOCIATE,
4253 .doit = nl80211_disassociate,
4254 .policy = nl80211_policy,
4255 .flags = GENL_ADMIN_PERM,
4256 },
04a773ad
JB		 4257 {
4258 .cmd = NL80211_CMD_JOIN_IBSS,
4259 .doit = nl80211_join_ibss,
4260 .policy = nl80211_policy,
4261 .flags = GENL_ADMIN_PERM,
4262 },
4263 {
4264 .cmd = NL80211_CMD_LEAVE_IBSS,
4265 .doit = nl80211_leave_ibss,
4266 .policy = nl80211_policy,
4267 .flags = GENL_ADMIN_PERM,
4268 },
aff89a9b
JB		 4269#ifdef CONFIG_NL80211_TESTMODE
4270 {
4271 .cmd = NL80211_CMD_TESTMODE,
4272 .doit = nl80211_testmode_do,
4273 .policy = nl80211_policy,
4274 .flags = GENL_ADMIN_PERM,
4275 },
4276#endif
b23aa676
SO		 4277 {
4278 .cmd = NL80211_CMD_CONNECT,
4279 .doit = nl80211_connect,
4280 .policy = nl80211_policy,
4281 .flags = GENL_ADMIN_PERM,
4282 },
4283 {
4284 .cmd = NL80211_CMD_DISCONNECT,
4285 .doit = nl80211_disconnect,
4286 .policy = nl80211_policy,
4287 .flags = GENL_ADMIN_PERM,
4288 },
463d0183
JB		 4289 {
4290 .cmd = NL80211_CMD_SET_WIPHY_NETNS,
4291 .doit = nl80211_wiphy_netns,
4292 .policy = nl80211_policy,
4293 .flags = GENL_ADMIN_PERM,
4294 },
55682965 4295};
6039f6d2
JM		 4296static struct genl_multicast_group nl80211_mlme_mcgrp = {
4297 .name = "mlme",
4298};
55682965
JB		 4299
4300/* multicast groups */
4301static struct genl_multicast_group nl80211_config_mcgrp = {
4302 .name = "config",
4303};
2a519311
JB		 4304static struct genl_multicast_group nl80211_scan_mcgrp = {
4305 .name = "scan",
4306};
73d54c9e
LR		 4307static struct genl_multicast_group nl80211_regulatory_mcgrp = {
4308 .name = "regulatory",
4309};
55682965
JB		 4310
4311/* notification functions */
4312
4313void nl80211_notify_dev_rename(struct cfg80211_registered_device *rdev)
4314{
4315 struct sk_buff *msg;
4316
fd2120ca 4317 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
55682965
JB		 4318 if (!msg)
4319 return;
4320
4321 if (nl80211_send_wiphy(msg, 0, 0, 0, rdev) < 0) {
4322 nlmsg_free(msg);
4323 return;
4324 }
4325
463d0183
JB		 4326 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4327 nl80211_config_mcgrp.id, GFP_KERNEL);
55682965
JB		 4328}
4329
362a415d
JB		 4330static int nl80211_add_scan_req(struct sk_buff *msg,
4331 struct cfg80211_registered_device *rdev)
4332{
4333 struct cfg80211_scan_request *req = rdev->scan_req;
4334 struct nlattr *nest;
4335 int i;
4336
667503dd
JB		 4337 ASSERT_RDEV_LOCK(rdev);
4338
362a415d
JB		 4339 if (WARN_ON(!req))
4340 return 0;
4341
4342 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_SSIDS);
4343 if (!nest)
4344 goto nla_put_failure;
4345 for (i = 0; i < req->n_ssids; i++)
4346 NLA_PUT(msg, i, req->ssids[i].ssid_len, req->ssids[i].ssid);
4347 nla_nest_end(msg, nest);
4348
4349 nest = nla_nest_start(msg, NL80211_ATTR_SCAN_FREQUENCIES);
4350 if (!nest)
4351 goto nla_put_failure;
4352 for (i = 0; i < req->n_channels; i++)
4353 NLA_PUT_U32(msg, i, req->channels[i]->center_freq);
4354 nla_nest_end(msg, nest);
4355
4356 if (req->ie)
4357 NLA_PUT(msg, NL80211_ATTR_IE, req->ie_len, req->ie);
4358
4359 return 0;
4360 nla_put_failure:
4361 return -ENOBUFS;
4362}
4363
a538e2d5
JB		 4364static int nl80211_send_scan_msg(struct sk_buff *msg,
4365 struct cfg80211_registered_device *rdev,
4366 struct net_device *netdev,
4367 u32 pid, u32 seq, int flags,
4368 u32 cmd)
2a519311
JB		 4369{
4370 void *hdr;
4371
4372 hdr = nl80211hdr_put(msg, pid, seq, flags, cmd);
4373 if (!hdr)
4374 return -1;
4375
b5850a7a 4376 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
2a519311
JB		 4377 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4378
362a415d
JB		 4379 /* ignore errors and send incomplete event anyway */
4380 nl80211_add_scan_req(msg, rdev);
2a519311
JB		 4381
4382 return genlmsg_end(msg, hdr);
4383
4384 nla_put_failure:
4385 genlmsg_cancel(msg, hdr);
4386 return -EMSGSIZE;
4387}
4388
a538e2d5
JB		 4389void nl80211_send_scan_start(struct cfg80211_registered_device *rdev,
4390 struct net_device *netdev)
4391{
4392 struct sk_buff *msg;
4393
4394 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
4395 if (!msg)
4396 return;
4397
4398 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4399 NL80211_CMD_TRIGGER_SCAN) < 0) {
4400 nlmsg_free(msg);
4401 return;
4402 }
4403
463d0183
JB		 4404 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4405 nl80211_scan_mcgrp.id, GFP_KERNEL);
a538e2d5
JB		 4406}
4407
2a519311
JB		 4408void nl80211_send_scan_done(struct cfg80211_registered_device *rdev,
4409 struct net_device *netdev)
4410{
4411 struct sk_buff *msg;
4412
fd2120ca 4413 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311
JB		 4414 if (!msg)
4415 return;
4416
a538e2d5
JB		 4417 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4418 NL80211_CMD_NEW_SCAN_RESULTS) < 0) {
2a519311
JB		 4419 nlmsg_free(msg);
4420 return;
4421 }
4422
463d0183
JB		 4423 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4424 nl80211_scan_mcgrp.id, GFP_KERNEL);
2a519311
JB		 4425}
4426
4427void nl80211_send_scan_aborted(struct cfg80211_registered_device *rdev,
4428 struct net_device *netdev)
4429{
4430 struct sk_buff *msg;
4431
fd2120ca 4432 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
2a519311
JB		 4433 if (!msg)
4434 return;
4435
a538e2d5
JB		 4436 if (nl80211_send_scan_msg(msg, rdev, netdev, 0, 0, 0,
4437 NL80211_CMD_SCAN_ABORTED) < 0) {
2a519311
JB		 4438 nlmsg_free(msg);
4439 return;
4440 }
4441
463d0183
JB		 4442 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4443 nl80211_scan_mcgrp.id, GFP_KERNEL);
2a519311
JB		 4444}
4445
73d54c9e
LR		 4446/*
4447 * This can happen on global regulatory changes or device specific settings
4448 * based on custom world regulatory domains.
4449 */
4450void nl80211_send_reg_change_event(struct regulatory_request *request)
4451{
4452 struct sk_buff *msg;
4453 void *hdr;
4454
fd2120ca 4455 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL);
73d54c9e
LR		 4456 if (!msg)
4457 return;
4458
4459 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_CHANGE);
4460 if (!hdr) {
4461 nlmsg_free(msg);
4462 return;
4463 }
4464
4465 /* Userspace can always count this one always being set */
4466 NLA_PUT_U8(msg, NL80211_ATTR_REG_INITIATOR, request->initiator);
4467
4468 if (request->alpha2[0] == '0' && request->alpha2[1] == '0')
4469 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4470 NL80211_REGDOM_TYPE_WORLD);
4471 else if (request->alpha2[0] == '9' && request->alpha2[1] == '9')
4472 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4473 NL80211_REGDOM_TYPE_CUSTOM_WORLD);
4474 else if ((request->alpha2[0] == '9' && request->alpha2[1] == '8') ||
4475 request->intersect)
4476 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4477 NL80211_REGDOM_TYPE_INTERSECTION);
4478 else {
4479 NLA_PUT_U8(msg, NL80211_ATTR_REG_TYPE,
4480 NL80211_REGDOM_TYPE_COUNTRY);
4481 NLA_PUT_STRING(msg, NL80211_ATTR_REG_ALPHA2, request->alpha2);
4482 }
4483
4484 if (wiphy_idx_valid(request->wiphy_idx))
4485 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, request->wiphy_idx);
4486
4487 if (genlmsg_end(msg, hdr) < 0) {
4488 nlmsg_free(msg);
4489 return;
4490 }
4491
bc43b28c 4492 rcu_read_lock();
463d0183 4493 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
bc43b28c
JB		 4494 GFP_ATOMIC);
4495 rcu_read_unlock();
73d54c9e
LR		 4496
4497 return;
4498
4499nla_put_failure:
4500 genlmsg_cancel(msg, hdr);
4501 nlmsg_free(msg);
4502}
4503
6039f6d2
JM		 4504static void nl80211_send_mlme_event(struct cfg80211_registered_device *rdev,
4505 struct net_device *netdev,
4506 const u8 *buf, size_t len,
e6d6e342 4507 enum nl80211_commands cmd, gfp_t gfp)
6039f6d2
JM		 4508{
4509 struct sk_buff *msg;
4510 void *hdr;
4511
e6d6e342 4512 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
6039f6d2
JM		 4513 if (!msg)
4514 return;
4515
4516 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
4517 if (!hdr) {
4518 nlmsg_free(msg);
4519 return;
4520 }
4521
4522 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4523 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4524 NLA_PUT(msg, NL80211_ATTR_FRAME, len, buf);
4525
4526 if (genlmsg_end(msg, hdr) < 0) {
4527 nlmsg_free(msg);
4528 return;
4529 }
4530
463d0183
JB		 4531 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4532 nl80211_mlme_mcgrp.id, gfp);
6039f6d2
JM		 4533 return;
4534
4535 nla_put_failure:
4536 genlmsg_cancel(msg, hdr);
4537 nlmsg_free(msg);
4538}
4539
4540void nl80211_send_rx_auth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 4541 struct net_device *netdev, const u8 *buf,
4542 size_t len, gfp_t gfp)
6039f6d2
JM		 4543{
4544 nl80211_send_mlme_event(rdev, netdev, buf, len,
e6d6e342 4545 NL80211_CMD_AUTHENTICATE, gfp);
6039f6d2
JM		 4546}
4547
4548void nl80211_send_rx_assoc(struct cfg80211_registered_device *rdev,
4549 struct net_device *netdev, const u8 *buf,
e6d6e342 4550 size_t len, gfp_t gfp)
6039f6d2 4551{
e6d6e342
JB		 4552 nl80211_send_mlme_event(rdev, netdev, buf, len,
4553 NL80211_CMD_ASSOCIATE, gfp);
6039f6d2
JM		 4554}
4555
53b46b84 4556void nl80211_send_deauth(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 4557 struct net_device *netdev, const u8 *buf,
4558 size_t len, gfp_t gfp)
6039f6d2
JM		 4559{
4560 nl80211_send_mlme_event(rdev, netdev, buf, len,
e6d6e342 4561 NL80211_CMD_DEAUTHENTICATE, gfp);
6039f6d2
JM		 4562}
4563
53b46b84
JM		 4564void nl80211_send_disassoc(struct cfg80211_registered_device *rdev,
4565 struct net_device *netdev, const u8 *buf,
e6d6e342 4566 size_t len, gfp_t gfp)
6039f6d2
JM		 4567{
4568 nl80211_send_mlme_event(rdev, netdev, buf, len,
e6d6e342 4569 NL80211_CMD_DISASSOCIATE, gfp);
6039f6d2
JM		 4570}
4571
1b06bb40
LR		 4572static void nl80211_send_mlme_timeout(struct cfg80211_registered_device *rdev,
4573 struct net_device *netdev, int cmd,
e6d6e342 4574 const u8 *addr, gfp_t gfp)
1965c853
JM		 4575{
4576 struct sk_buff *msg;
4577 void *hdr;
4578
e6d6e342 4579 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
1965c853
JM		 4580 if (!msg)
4581 return;
4582
4583 hdr = nl80211hdr_put(msg, 0, 0, 0, cmd);
4584 if (!hdr) {
4585 nlmsg_free(msg);
4586 return;
4587 }
4588
4589 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4590 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4591 NLA_PUT_FLAG(msg, NL80211_ATTR_TIMED_OUT);
4592 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
4593
4594 if (genlmsg_end(msg, hdr) < 0) {
4595 nlmsg_free(msg);
4596 return;
4597 }
4598
463d0183
JB		 4599 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4600 nl80211_mlme_mcgrp.id, gfp);
1965c853
JM		 4601 return;
4602
4603 nla_put_failure:
4604 genlmsg_cancel(msg, hdr);
4605 nlmsg_free(msg);
4606}
4607
4608void nl80211_send_auth_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 4609 struct net_device *netdev, const u8 *addr,
4610 gfp_t gfp)
1965c853
JM		 4611{
4612 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_AUTHENTICATE,
e6d6e342 4613 addr, gfp);
1965c853
JM		 4614}
4615
4616void nl80211_send_assoc_timeout(struct cfg80211_registered_device *rdev,
e6d6e342
JB		 4617 struct net_device *netdev, const u8 *addr,
4618 gfp_t gfp)
1965c853 4619{
e6d6e342
JB		 4620 nl80211_send_mlme_timeout(rdev, netdev, NL80211_CMD_ASSOCIATE,
4621 addr, gfp);
1965c853
JM		 4622}
4623
b23aa676
SO		 4624void nl80211_send_connect_result(struct cfg80211_registered_device *rdev,
4625 struct net_device *netdev, const u8 *bssid,
4626 const u8 *req_ie, size_t req_ie_len,
4627 const u8 *resp_ie, size_t resp_ie_len,
4628 u16 status, gfp_t gfp)
4629{
4630 struct sk_buff *msg;
4631 void *hdr;
4632
4633 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
4634 if (!msg)
4635 return;
4636
4637 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_CONNECT);
4638 if (!hdr) {
4639 nlmsg_free(msg);
4640 return;
4641 }
4642
4643 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4644 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4645 if (bssid)
4646 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4647 NLA_PUT_U16(msg, NL80211_ATTR_STATUS_CODE, status);
4648 if (req_ie)
4649 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
4650 if (resp_ie)
4651 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
4652
4653 if (genlmsg_end(msg, hdr) < 0) {
4654 nlmsg_free(msg);
4655 return;
4656 }
4657
463d0183
JB		 4658 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4659 nl80211_mlme_mcgrp.id, gfp);
b23aa676
SO		 4660 return;
4661
4662 nla_put_failure:
4663 genlmsg_cancel(msg, hdr);
4664 nlmsg_free(msg);
4665
4666}
4667
4668void nl80211_send_roamed(struct cfg80211_registered_device *rdev,
4669 struct net_device *netdev, const u8 *bssid,
4670 const u8 *req_ie, size_t req_ie_len,
4671 const u8 *resp_ie, size_t resp_ie_len, gfp_t gfp)
4672{
4673 struct sk_buff *msg;
4674 void *hdr;
4675
4676 msg = nlmsg_new(NLMSG_GOODSIZE, gfp);
4677 if (!msg)
4678 return;
4679
4680 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_ROAM);
4681 if (!hdr) {
4682 nlmsg_free(msg);
4683 return;
4684 }
4685
4686 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4687 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4688 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4689 if (req_ie)
4690 NLA_PUT(msg, NL80211_ATTR_REQ_IE, req_ie_len, req_ie);
4691 if (resp_ie)
4692 NLA_PUT(msg, NL80211_ATTR_RESP_IE, resp_ie_len, resp_ie);
4693
4694 if (genlmsg_end(msg, hdr) < 0) {
4695 nlmsg_free(msg);
4696 return;
4697 }
4698
463d0183
JB		 4699 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4700 nl80211_mlme_mcgrp.id, gfp);
b23aa676
SO		 4701 return;
4702
4703 nla_put_failure:
4704 genlmsg_cancel(msg, hdr);
4705 nlmsg_free(msg);
4706
4707}
4708
4709void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
4710 struct net_device *netdev, u16 reason,
667503dd 4711 const u8 *ie, size_t ie_len, bool from_ap)
b23aa676
SO		 4712{
4713 struct sk_buff *msg;
4714 void *hdr;
4715
667503dd 4716 msg = nlmsg_new(NLMSG_GOODSIZE, GFP_KERNEL);
b23aa676
SO		 4717 if (!msg)
4718 return;
4719
4720 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_DISCONNECT);
4721 if (!hdr) {
4722 nlmsg_free(msg);
4723 return;
4724 }
4725
4726 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4727 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4728 if (from_ap && reason)
4729 NLA_PUT_U16(msg, NL80211_ATTR_REASON_CODE, reason);
4730 if (from_ap)
4731 NLA_PUT_FLAG(msg, NL80211_ATTR_DISCONNECTED_BY_AP);
4732 if (ie)
4733 NLA_PUT(msg, NL80211_ATTR_IE, ie_len, ie);
4734
4735 if (genlmsg_end(msg, hdr) < 0) {
4736 nlmsg_free(msg);
4737 return;
4738 }
4739
463d0183
JB		 4740 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4741 nl80211_mlme_mcgrp.id, GFP_KERNEL);
b23aa676
SO		 4742 return;
4743
4744 nla_put_failure:
4745 genlmsg_cancel(msg, hdr);
4746 nlmsg_free(msg);
4747
4748}
4749
04a773ad
JB		 4750void nl80211_send_ibss_bssid(struct cfg80211_registered_device *rdev,
4751 struct net_device *netdev, const u8 *bssid,
4752 gfp_t gfp)
4753{
4754 struct sk_buff *msg;
4755 void *hdr;
4756
fd2120ca 4757 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
04a773ad
JB		 4758 if (!msg)
4759 return;
4760
4761 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_JOIN_IBSS);
4762 if (!hdr) {
4763 nlmsg_free(msg);
4764 return;
4765 }
4766
4767 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4768 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4769 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid);
4770
4771 if (genlmsg_end(msg, hdr) < 0) {
4772 nlmsg_free(msg);
4773 return;
4774 }
4775
463d0183
JB		 4776 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4777 nl80211_mlme_mcgrp.id, gfp);
04a773ad
JB		 4778 return;
4779
4780 nla_put_failure:
4781 genlmsg_cancel(msg, hdr);
4782 nlmsg_free(msg);
4783}
4784
a3b8b056
JM		 4785void nl80211_michael_mic_failure(struct cfg80211_registered_device *rdev,
4786 struct net_device *netdev, const u8 *addr,
4787 enum nl80211_key_type key_type, int key_id,
e6d6e342 4788 const u8 *tsc, gfp_t gfp)
a3b8b056
JM		 4789{
4790 struct sk_buff *msg;
4791 void *hdr;
4792
e6d6e342 4793 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, gfp);
a3b8b056
JM		 4794 if (!msg)
4795 return;
4796
4797 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_MICHAEL_MIC_FAILURE);
4798 if (!hdr) {
4799 nlmsg_free(msg);
4800 return;
4801 }
4802
4803 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, rdev->wiphy_idx);
4804 NLA_PUT_U32(msg, NL80211_ATTR_IFINDEX, netdev->ifindex);
4805 if (addr)
4806 NLA_PUT(msg, NL80211_ATTR_MAC, ETH_ALEN, addr);
4807 NLA_PUT_U32(msg, NL80211_ATTR_KEY_TYPE, key_type);
4808 NLA_PUT_U8(msg, NL80211_ATTR_KEY_IDX, key_id);
4809 if (tsc)
4810 NLA_PUT(msg, NL80211_ATTR_KEY_SEQ, 6, tsc);
4811
4812 if (genlmsg_end(msg, hdr) < 0) {
4813 nlmsg_free(msg);
4814 return;
4815 }
4816
463d0183
JB		 4817 genlmsg_multicast_netns(wiphy_net(&rdev->wiphy), msg, 0,
4818 nl80211_mlme_mcgrp.id, gfp);
a3b8b056
JM		 4819 return;
4820
4821 nla_put_failure:
4822 genlmsg_cancel(msg, hdr);
4823 nlmsg_free(msg);
4824}
4825
6bad8766
LR		 4826void nl80211_send_beacon_hint_event(struct wiphy *wiphy,
4827 struct ieee80211_channel *channel_before,
4828 struct ieee80211_channel *channel_after)
4829{
4830 struct sk_buff *msg;
4831 void *hdr;
4832 struct nlattr *nl_freq;
4833
fd2120ca 4834 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_ATOMIC);
6bad8766
LR		 4835 if (!msg)
4836 return;
4837
4838 hdr = nl80211hdr_put(msg, 0, 0, 0, NL80211_CMD_REG_BEACON_HINT);
4839 if (!hdr) {
4840 nlmsg_free(msg);
4841 return;
4842 }
4843
4844 /*
4845 * Since we are applying the beacon hint to a wiphy we know its
4846 * wiphy_idx is valid
4847 */
4848 NLA_PUT_U32(msg, NL80211_ATTR_WIPHY, get_wiphy_idx(wiphy));
4849
4850 /* Before */
4851 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_BEFORE);
4852 if (!nl_freq)
4853 goto nla_put_failure;
4854 if (nl80211_msg_put_channel(msg, channel_before))
4855 goto nla_put_failure;
4856 nla_nest_end(msg, nl_freq);
4857
4858 /* After */
4859 nl_freq = nla_nest_start(msg, NL80211_ATTR_FREQ_AFTER);
4860 if (!nl_freq)
4861 goto nla_put_failure;
4862 if (nl80211_msg_put_channel(msg, channel_after))
4863 goto nla_put_failure;
4864 nla_nest_end(msg, nl_freq);
4865
4866 if (genlmsg_end(msg, hdr) < 0) {
4867 nlmsg_free(msg);
4868 return;
4869 }
4870
463d0183
JB		 4871 rcu_read_lock();
4872 genlmsg_multicast_allns(msg, 0, nl80211_regulatory_mcgrp.id,
4873 GFP_ATOMIC);
4874 rcu_read_unlock();
6bad8766
LR		 4875
4876 return;
4877
4878nla_put_failure:
4879 genlmsg_cancel(msg, hdr);
4880 nlmsg_free(msg);
4881}
4882
55682965
JB		 4883/* initialisation/exit functions */
4884
4885int nl80211_init(void)
4886{
0d63cbb5 4887 int err;
55682965 4888
0d63cbb5
MM		 4889 err = genl_register_family_with_ops(&nl80211_fam,
4890 nl80211_ops, ARRAY_SIZE(nl80211_ops));
55682965
JB		 4891 if (err)
4892 return err;
4893
55682965
JB		 4894 err = genl_register_mc_group(&nl80211_fam, &nl80211_config_mcgrp);
4895 if (err)
4896 goto err_out;
4897
2a519311
JB		 4898 err = genl_register_mc_group(&nl80211_fam, &nl80211_scan_mcgrp);
4899 if (err)
4900 goto err_out;
4901
73d54c9e
LR		 4902 err = genl_register_mc_group(&nl80211_fam, &nl80211_regulatory_mcgrp);
4903 if (err)
4904 goto err_out;
4905
6039f6d2
JM		 4906 err = genl_register_mc_group(&nl80211_fam, &nl80211_mlme_mcgrp);
4907 if (err)
4908 goto err_out;
4909
aff89a9b
JB		 4910#ifdef CONFIG_NL80211_TESTMODE
4911 err = genl_register_mc_group(&nl80211_fam, &nl80211_testmode_mcgrp);
4912 if (err)
4913 goto err_out;
4914#endif
4915
55682965
JB		 4916 return 0;
4917 err_out:
4918 genl_unregister_family(&nl80211_fam);
4919 return err;
4920}
4921
4922void nl80211_exit(void)
4923{
4924 genl_unregister_family(&nl80211_fam);
4925}
kernel source for telekom puls (alcatel/mediatek)