?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drm: ioremap return value checks
[usb.git] / net / mac80211 / ieee80211_ioctl.c
blobd0e1ab5589dbbbc0b33c4efcadb47a6c8c6043fb
1 /*
2 * Copyright 2002-2005, Instant802 Networks, Inc.
3 * Copyright 2005-2006, Devicescape Software, Inc.
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
8 */
9
10 #include <linux/module.h>
11 #include <linux/init.h>
12 #include <linux/netdevice.h>
13 #include <linux/types.h>
14 #include <linux/slab.h>
15 #include <linux/skbuff.h>
16 #include <linux/etherdevice.h>
17 #include <linux/if_arp.h>
18 #include <linux/wireless.h>
19 #include <net/iw_handler.h>
20 #include <asm/uaccess.h>
21
22 #include <net/mac80211.h>
23 #include "ieee80211_i.h"
24 #include "hostapd_ioctl.h"
25 #include "ieee80211_rate.h"
26 #include "wpa.h"
27 #include "aes_ccm.h"
28 #include "debugfs_key.h"
29
30 static void ieee80211_set_hw_encryption(struct net_device *dev,
31 struct sta_info *sta, u8 addr[ETH_ALEN],
32 struct ieee80211_key *key)
33 {
34 struct ieee80211_key_conf *keyconf = NULL;
35 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
36
37 /* default to sw encryption; this will be cleared by low-level
38 * driver if the hw supports requested encryption */
39 if (key)
40 key->force_sw_encrypt = 1;
41
42 if (key && local->ops->set_key &&
43 (keyconf = ieee80211_key_data2conf(local, key))) {
44 if (local->ops->set_key(local_to_hw(local), SET_KEY, addr,
45 keyconf, sta ? sta->aid : 0)) {
46 key->force_sw_encrypt = 1;
47 key->hw_key_idx = HW_KEY_IDX_INVALID;
48 } else {
49 key->force_sw_encrypt =
50 !!(keyconf->flags & IEEE80211_KEY_FORCE_SW_ENCRYPT);
51 key->hw_key_idx =
52 keyconf->hw_key_idx;
53
54 }
55 }
56 kfree(keyconf);
57 }
58
59
60 static int ieee80211_set_encryption(struct net_device *dev, u8 *sta_addr,
61 int idx, int alg, int set_tx_key,
62 const u8 *_key, size_t key_len)
63 {
64 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
65 int ret = 0;
66 struct sta_info *sta;
67 struct ieee80211_key *key, *old_key;
68 int try_hwaccel = 1;
69 struct ieee80211_key_conf *keyconf;
70 struct ieee80211_sub_if_data *sdata;
71
72 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
73
74 if (is_broadcast_ether_addr(sta_addr)) {
75 sta = NULL;
76 if (idx >= NUM_DEFAULT_KEYS) {
77 printk(KERN_DEBUG "%s: set_encrypt - invalid idx=%d\n",
78 dev->name, idx);
79 return -EINVAL;
80 }
81 key = sdata->keys[idx];
82
83 /* TODO: consider adding hwaccel support for these; at least
84 * Atheros key cache should be able to handle this since AP is
85 * only transmitting frames with default keys. */
86 /* FIX: hw key cache can be used when only one virtual
87 * STA is associated with each AP. If more than one STA
88 * is associated to the same AP, software encryption
89 * must be used. This should be done automatically
90 * based on configured station devices. For the time
91 * being, this can be only set at compile time. */
92 } else {
93 set_tx_key = 0;
94 if (idx != 0) {
95 printk(KERN_DEBUG "%s: set_encrypt - non-zero idx for "
96 "individual key\n", dev->name);
97 return -EINVAL;
98 }
99
100 sta = sta_info_get(local, sta_addr);
101 if (!sta) {
102 #ifdef CONFIG_MAC80211_VERBOSE_DEBUG
103 printk(KERN_DEBUG "%s: set_encrypt - unknown addr "
104 MAC_FMT "\n",
105 dev->name, MAC_ARG(sta_addr));
106 #endif /* CONFIG_MAC80211_VERBOSE_DEBUG */
107
108 return -ENOENT;
109 }
110
111 key = sta->key;
112 }
113
114 /* FIX:
115 * Cannot configure default hwaccel keys with WEP algorithm, if
116 * any of the virtual interfaces is using static WEP
117 * configuration because hwaccel would otherwise try to decrypt
118 * these frames.
119 *
120 * For now, just disable WEP hwaccel for broadcast when there is
121 * possibility of conflict with default keys. This can maybe later be
122 * optimized by using non-default keys (at least with Atheros ar521x).
123 */
124 if (!sta && alg == ALG_WEP && !local->default_wep_only &&
125 sdata->type != IEEE80211_IF_TYPE_IBSS &&
126 sdata->type != IEEE80211_IF_TYPE_AP) {
127 try_hwaccel = 0;
128 }
129
130 if (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP) {
131 /* Software encryption cannot be used with devices that hide
132 * encryption from the host system, so always try to use
133 * hardware acceleration with such devices. */
134 try_hwaccel = 1;
135 }
136
137 if ((local->hw.flags & IEEE80211_HW_NO_TKIP_WMM_HWACCEL) &&
138 alg == ALG_TKIP) {
139 if (sta && (sta->flags & WLAN_STA_WME)) {
140 /* Hardware does not support hwaccel with TKIP when using WMM.
141 */
142 try_hwaccel = 0;
143 }
144 else if (sdata->type == IEEE80211_IF_TYPE_STA) {
145 sta = sta_info_get(local, sdata->u.sta.bssid);
146 if (sta) {
147 if (sta->flags & WLAN_STA_WME) {
148 try_hwaccel = 0;
149 }
150 sta_info_put(sta);
151 sta = NULL;
152 }
153 }
154 }
155
156 if (alg == ALG_NONE) {
157 keyconf = NULL;
158 if (try_hwaccel && key &&
159 key->hw_key_idx != HW_KEY_IDX_INVALID &&
160 local->ops->set_key &&
161 (keyconf = ieee80211_key_data2conf(local, key)) != NULL &&
162 local->ops->set_key(local_to_hw(local), DISABLE_KEY,
163 sta_addr, keyconf, sta ? sta->aid : 0)) {
164 printk(KERN_DEBUG "%s: set_encrypt - low-level disable"
165 " failed\n", dev->name);
166 ret = -EINVAL;
167 }
168 kfree(keyconf);
169
170 if (set_tx_key || sdata->default_key == key) {
171 ieee80211_debugfs_key_remove_default(sdata);
172 sdata->default_key = NULL;
173 }
174 ieee80211_debugfs_key_remove(key);
175 if (sta)
176 sta->key = NULL;
177 else
178 sdata->keys[idx] = NULL;
179 ieee80211_key_free(key);
180 key = NULL;
181 } else {
182 old_key = key;
183 key = ieee80211_key_alloc(sta ? NULL : sdata, idx, key_len,
184 GFP_KERNEL);
185 if (!key) {
186 ret = -ENOMEM;
187 goto err_out;
188 }
189
190 /* default to sw encryption; low-level driver sets these if the
191 * requested encryption is supported */
192 key->hw_key_idx = HW_KEY_IDX_INVALID;
193 key->force_sw_encrypt = 1;
194
195 key->alg = alg;
196 key->keyidx = idx;
197 key->keylen = key_len;
198 memcpy(key->key, _key, key_len);
199 if (set_tx_key)
200 key->default_tx_key = 1;
201
202 if (alg == ALG_CCMP) {
203 /* Initialize AES key state here as an optimization
204 * so that it does not need to be initialized for every
205 * packet. */
206 key->u.ccmp.tfm = ieee80211_aes_key_setup_encrypt(
207 key->key);
208 if (!key->u.ccmp.tfm) {
209 ret = -ENOMEM;
210 goto err_free;
211 }
212 }
213
214 if (set_tx_key || sdata->default_key == old_key) {
215 ieee80211_debugfs_key_remove_default(sdata);
216 sdata->default_key = NULL;
217 }
218 ieee80211_debugfs_key_remove(old_key);
219 if (sta)
220 sta->key = key;
221 else
222 sdata->keys[idx] = key;
223 ieee80211_key_free(old_key);
224 ieee80211_debugfs_key_add(local, key);
225 if (sta)
226 ieee80211_debugfs_key_sta_link(key, sta);
227
228 if (try_hwaccel &&
229 (alg == ALG_WEP || alg == ALG_TKIP || alg == ALG_CCMP))
230 ieee80211_set_hw_encryption(dev, sta, sta_addr, key);
231 }
232
233 if (set_tx_key || (!sta && !sdata->default_key && key)) {
234 sdata->default_key = key;
235 if (key)
236 ieee80211_debugfs_key_add_default(sdata);
237
238 if (local->ops->set_key_idx &&
239 local->ops->set_key_idx(local_to_hw(local), idx))
240 printk(KERN_DEBUG "%s: failed to set TX key idx for "
241 "low-level driver\n", dev->name);
242 }
243
244 if (sta)
245 sta_info_put(sta);
246
247 return 0;
248
249 err_free:
250 ieee80211_key_free(key);
251 err_out:
252 if (sta)
253 sta_info_put(sta);
254 return ret;
255 }
256
257 static int ieee80211_ioctl_siwgenie(struct net_device *dev,
258 struct iw_request_info *info,
259 struct iw_point *data, char *extra)
260 {
261 struct ieee80211_sub_if_data *sdata;
262 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
263
264 if (local->user_space_mlme)
265 return -EOPNOTSUPP;
266
267 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
268 if (sdata->type == IEEE80211_IF_TYPE_STA ||
269 sdata->type == IEEE80211_IF_TYPE_IBSS) {
270 int ret = ieee80211_sta_set_extra_ie(dev, extra, data->length);
271 if (ret)
272 return ret;
273 sdata->u.sta.auto_bssid_sel = 0;
274 ieee80211_sta_req_auth(dev, &sdata->u.sta);
275 return 0;
276 }
277
278 if (sdata->type == IEEE80211_IF_TYPE_AP) {
279 kfree(sdata->u.ap.generic_elem);
280 sdata->u.ap.generic_elem = kmalloc(data->length, GFP_KERNEL);
281 if (!sdata->u.ap.generic_elem)
282 return -ENOMEM;
283 memcpy(sdata->u.ap.generic_elem, extra, data->length);
284 sdata->u.ap.generic_elem_len = data->length;
285 return ieee80211_if_config(dev);
286 }
287 return -EOPNOTSUPP;
288 }
289
290 static int ieee80211_ioctl_set_radio_enabled(struct net_device *dev,
291 int val)
292 {
293 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
294 struct ieee80211_conf *conf = &local->hw.conf;
295
296 conf->radio_enabled = val;
297 return ieee80211_hw_config(wdev_priv(dev->ieee80211_ptr));
298 }
299
300 static int ieee80211_ioctl_giwname(struct net_device *dev,
301 struct iw_request_info *info,
302 char *name, char *extra)
303 {
304 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
305
306 switch (local->hw.conf.phymode) {
307 case MODE_IEEE80211A:
308 strcpy(name, "IEEE 802.11a");
309 break;
310 case MODE_IEEE80211B:
311 strcpy(name, "IEEE 802.11b");
312 break;
313 case MODE_IEEE80211G:
314 strcpy(name, "IEEE 802.11g");
315 break;
316 case MODE_ATHEROS_TURBO:
317 strcpy(name, "5GHz Turbo");
318 break;
319 default:
320 strcpy(name, "IEEE 802.11");
321 break;
322 }
323
324 return 0;
325 }
326
327
328 static int ieee80211_ioctl_giwrange(struct net_device *dev,
329 struct iw_request_info *info,
330 struct iw_point *data, char *extra)
331 {
332 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
333 struct iw_range *range = (struct iw_range *) extra;
334 struct ieee80211_hw_mode *mode = NULL;
335 int c = 0;
336
337 data->length = sizeof(struct iw_range);
338 memset(range, 0, sizeof(struct iw_range));
339
340 range->we_version_compiled = WIRELESS_EXT;
341 range->we_version_source = 21;
342 range->retry_capa = IW_RETRY_LIMIT;
343 range->retry_flags = IW_RETRY_LIMIT;
344 range->min_retry = 0;
345 range->max_retry = 255;
346 range->min_rts = 0;
347 range->max_rts = 2347;
348 range->min_frag = 256;
349 range->max_frag = 2346;
350
351 range->encoding_size[0] = 5;
352 range->encoding_size[1] = 13;
353 range->num_encoding_sizes = 2;
354 range->max_encoding_tokens = NUM_DEFAULT_KEYS;
355
356 range->max_qual.qual = local->hw.max_signal;
357 range->max_qual.level = local->hw.max_rssi;
358 range->max_qual.noise = local->hw.max_noise;
359 range->max_qual.updated = local->wstats_flags;
360
361 range->avg_qual.qual = local->hw.max_signal/2;
362 range->avg_qual.level = 0;
363 range->avg_qual.noise = 0;
364 range->avg_qual.updated = local->wstats_flags;
365
366 range->enc_capa = IW_ENC_CAPA_WPA | IW_ENC_CAPA_WPA2 |
367 IW_ENC_CAPA_CIPHER_TKIP | IW_ENC_CAPA_CIPHER_CCMP;
368
369 list_for_each_entry(mode, &local->modes_list, list) {
370 int i = 0;
371
372 if (!(local->enabled_modes & (1 << mode->mode)) ||
373 (local->hw_modes & local->enabled_modes &
374 (1 << MODE_IEEE80211G) && mode->mode == MODE_IEEE80211B))
375 continue;
376
377 while (i < mode->num_channels && c < IW_MAX_FREQUENCIES) {
378 struct ieee80211_channel *chan = &mode->channels[i];
379
380 if (chan->flag & IEEE80211_CHAN_W_SCAN) {
381 range->freq[c].i = chan->chan;
382 range->freq[c].m = chan->freq * 100000;
383 range->freq[c].e = 1;
384 c++;
385 }
386 i++;
387 }
388 }
389 range->num_channels = c;
390 range->num_frequency = c;
391
392 IW_EVENT_CAPA_SET_KERNEL(range->event_capa);
393 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWTHRSPY);
394 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWAP);
395 IW_EVENT_CAPA_SET(range->event_capa, SIOCGIWSCAN);
396
397 return 0;
398 }
399
400
401 static int ieee80211_ioctl_siwmode(struct net_device *dev,
402 struct iw_request_info *info,
403 __u32 *mode, char *extra)
404 {
405 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
406 int type;
407
408 if (sdata->type == IEEE80211_IF_TYPE_VLAN)
409 return -EOPNOTSUPP;
410
411 switch (*mode) {
412 case IW_MODE_INFRA:
413 type = IEEE80211_IF_TYPE_STA;
414 break;
415 case IW_MODE_ADHOC:
416 type = IEEE80211_IF_TYPE_IBSS;
417 break;
418 case IW_MODE_MONITOR:
419 type = IEEE80211_IF_TYPE_MNTR;
420 break;
421 default:
422 return -EINVAL;
423 }
424
425 if (type == sdata->type)
426 return 0;
427 if (netif_running(dev))
428 return -EBUSY;
429
430 ieee80211_if_reinit(dev);
431 ieee80211_if_set_type(dev, type);
432
433 return 0;
434 }
435
436
437 static int ieee80211_ioctl_giwmode(struct net_device *dev,
438 struct iw_request_info *info,
439 __u32 *mode, char *extra)
440 {
441 struct ieee80211_sub_if_data *sdata;
442
443 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
444 switch (sdata->type) {
445 case IEEE80211_IF_TYPE_AP:
446 *mode = IW_MODE_MASTER;
447 break;
448 case IEEE80211_IF_TYPE_STA:
449 *mode = IW_MODE_INFRA;
450 break;
451 case IEEE80211_IF_TYPE_IBSS:
452 *mode = IW_MODE_ADHOC;
453 break;
454 case IEEE80211_IF_TYPE_MNTR:
455 *mode = IW_MODE_MONITOR;
456 break;
457 case IEEE80211_IF_TYPE_WDS:
458 *mode = IW_MODE_REPEAT;
459 break;
460 case IEEE80211_IF_TYPE_VLAN:
461 *mode = IW_MODE_SECOND; /* FIXME */
462 break;
463 default:
464 *mode = IW_MODE_AUTO;
465 break;
466 }
467 return 0;
468 }
469
470 int ieee80211_set_channel(struct ieee80211_local *local, int channel, int freq)
471 {
472 struct ieee80211_hw_mode *mode;
473 int c, set = 0;
474 int ret = -EINVAL;
475
476 list_for_each_entry(mode, &local->modes_list, list) {
477 if (!(local->enabled_modes & (1 << mode->mode)))
478 continue;
479 for (c = 0; c < mode->num_channels; c++) {
480 struct ieee80211_channel *chan = &mode->channels[c];
481 if (chan->flag & IEEE80211_CHAN_W_SCAN &&
482 ((chan->chan == channel) || (chan->freq == freq))) {
483 /* Use next_mode as the mode preference to
484 * resolve non-unique channel numbers. */
485 if (set && mode->mode != local->next_mode)
486 continue;
487
488 local->oper_channel = chan;
489 local->oper_hw_mode = mode;
490 set++;
491 }
492 }
493 }
494
495 if (set) {
496 if (local->sta_scanning)
497 ret = 0;
498 else
499 ret = ieee80211_hw_config(local);
500
501 rate_control_clear(local);
502 }
503
504 return ret;
505 }
506
507 static int ieee80211_ioctl_siwfreq(struct net_device *dev,
508 struct iw_request_info *info,
509 struct iw_freq *freq, char *extra)
510 {
511 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
512 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
513
514 if (sdata->type == IEEE80211_IF_TYPE_STA)
515 sdata->u.sta.auto_channel_sel = 0;
516
517 /* freq->e == 0: freq->m = channel; otherwise freq = m * 10^e */
518 if (freq->e == 0) {
519 if (freq->m < 0) {
520 if (sdata->type == IEEE80211_IF_TYPE_STA)
521 sdata->u.sta.auto_channel_sel = 1;
522 return 0;
523 } else
524 return ieee80211_set_channel(local, freq->m, -1);
525 } else {
526 int i, div = 1000000;
527 for (i = 0; i < freq->e; i++)
528 div /= 10;
529 if (div > 0)
530 return ieee80211_set_channel(local, -1, freq->m / div);
531 else
532 return -EINVAL;
533 }
534 }
535
536
537 static int ieee80211_ioctl_giwfreq(struct net_device *dev,
538 struct iw_request_info *info,
539 struct iw_freq *freq, char *extra)
540 {
541 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
542
543 /* TODO: in station mode (Managed/Ad-hoc) might need to poll low-level
544 * driver for the current channel with firmware-based management */
545
546 freq->m = local->hw.conf.freq;
547 freq->e = 6;
548
549 return 0;
550 }
551
552
553 static int ieee80211_ioctl_siwessid(struct net_device *dev,
554 struct iw_request_info *info,
555 struct iw_point *data, char *ssid)
556 {
557 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
558 struct ieee80211_sub_if_data *sdata;
559 size_t len = data->length;
560
561 /* iwconfig uses nul termination in SSID.. */
562 if (len > 0 && ssid[len - 1] == '\0')
563 len--;
564
565 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
566 if (sdata->type == IEEE80211_IF_TYPE_STA ||
567 sdata->type == IEEE80211_IF_TYPE_IBSS) {
568 int ret;
569 if (local->user_space_mlme) {
570 if (len > IEEE80211_MAX_SSID_LEN)
571 return -EINVAL;
572 memcpy(sdata->u.sta.ssid, ssid, len);
573 sdata->u.sta.ssid_len = len;
574 return 0;
575 }
576 sdata->u.sta.auto_ssid_sel = !data->flags;
577 ret = ieee80211_sta_set_ssid(dev, ssid, len);
578 if (ret)
579 return ret;
580 ieee80211_sta_req_auth(dev, &sdata->u.sta);
581 return 0;
582 }
583
584 if (sdata->type == IEEE80211_IF_TYPE_AP) {
585 memcpy(sdata->u.ap.ssid, ssid, len);
586 memset(sdata->u.ap.ssid + len, 0,
587 IEEE80211_MAX_SSID_LEN - len);
588 sdata->u.ap.ssid_len = len;
589 return ieee80211_if_config(dev);
590 }
591 return -EOPNOTSUPP;
592 }
593
594
595 static int ieee80211_ioctl_giwessid(struct net_device *dev,
596 struct iw_request_info *info,
597 struct iw_point *data, char *ssid)
598 {
599 size_t len;
600
601 struct ieee80211_sub_if_data *sdata;
602 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
603 if (sdata->type == IEEE80211_IF_TYPE_STA ||
604 sdata->type == IEEE80211_IF_TYPE_IBSS) {
605 int res = ieee80211_sta_get_ssid(dev, ssid, &len);
606 if (res == 0) {
607 data->length = len;
608 data->flags = 1;
609 } else
610 data->flags = 0;
611 return res;
612 }
613
614 if (sdata->type == IEEE80211_IF_TYPE_AP) {
615 len = sdata->u.ap.ssid_len;
616 if (len > IW_ESSID_MAX_SIZE)
617 len = IW_ESSID_MAX_SIZE;
618 memcpy(ssid, sdata->u.ap.ssid, len);
619 data->length = len;
620 data->flags = 1;
621 return 0;
622 }
623 return -EOPNOTSUPP;
624 }
625
626
627 static int ieee80211_ioctl_siwap(struct net_device *dev,
628 struct iw_request_info *info,
629 struct sockaddr *ap_addr, char *extra)
630 {
631 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
632 struct ieee80211_sub_if_data *sdata;
633
634 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
635 if (sdata->type == IEEE80211_IF_TYPE_STA ||
636 sdata->type == IEEE80211_IF_TYPE_IBSS) {
637 int ret;
638 if (local->user_space_mlme) {
639 memcpy(sdata->u.sta.bssid, (u8 *) &ap_addr->sa_data,
640 ETH_ALEN);
641 return 0;
642 }
643 if (is_zero_ether_addr((u8 *) &ap_addr->sa_data)) {
644 sdata->u.sta.auto_bssid_sel = 1;
645 sdata->u.sta.auto_channel_sel = 1;
646 } else if (is_broadcast_ether_addr((u8 *) &ap_addr->sa_data))
647 sdata->u.sta.auto_bssid_sel = 1;
648 else
649 sdata->u.sta.auto_bssid_sel = 0;
650 ret = ieee80211_sta_set_bssid(dev, (u8 *) &ap_addr->sa_data);
651 if (ret)
652 return ret;
653 ieee80211_sta_req_auth(dev, &sdata->u.sta);
654 return 0;
655 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
656 if (memcmp(sdata->u.wds.remote_addr, (u8 *) &ap_addr->sa_data,
657 ETH_ALEN) == 0)
658 return 0;
659 return ieee80211_if_update_wds(dev, (u8 *) &ap_addr->sa_data);
660 }
661
662 return -EOPNOTSUPP;
663 }
664
665
666 static int ieee80211_ioctl_giwap(struct net_device *dev,
667 struct iw_request_info *info,
668 struct sockaddr *ap_addr, char *extra)
669 {
670 struct ieee80211_sub_if_data *sdata;
671
672 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
673 if (sdata->type == IEEE80211_IF_TYPE_STA ||
674 sdata->type == IEEE80211_IF_TYPE_IBSS) {
675 ap_addr->sa_family = ARPHRD_ETHER;
676 memcpy(&ap_addr->sa_data, sdata->u.sta.bssid, ETH_ALEN);
677 return 0;
678 } else if (sdata->type == IEEE80211_IF_TYPE_WDS) {
679 ap_addr->sa_family = ARPHRD_ETHER;
680 memcpy(&ap_addr->sa_data, sdata->u.wds.remote_addr, ETH_ALEN);
681 return 0;
682 }
683
684 return -EOPNOTSUPP;
685 }
686
687
688 static int ieee80211_ioctl_siwscan(struct net_device *dev,
689 struct iw_request_info *info,
690 struct iw_point *data, char *extra)
691 {
692 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
693 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
694 u8 *ssid = NULL;
695 size_t ssid_len = 0;
696
697 if (!netif_running(dev))
698 return -ENETDOWN;
699
700 if (local->scan_flags & IEEE80211_SCAN_MATCH_SSID) {
701 if (sdata->type == IEEE80211_IF_TYPE_STA ||
702 sdata->type == IEEE80211_IF_TYPE_IBSS) {
703 ssid = sdata->u.sta.ssid;
704 ssid_len = sdata->u.sta.ssid_len;
705 } else if (sdata->type == IEEE80211_IF_TYPE_AP) {
706 ssid = sdata->u.ap.ssid;
707 ssid_len = sdata->u.ap.ssid_len;
708 } else
709 return -EINVAL;
710 }
711 return ieee80211_sta_req_scan(dev, ssid, ssid_len);
712 }
713
714
715 static int ieee80211_ioctl_giwscan(struct net_device *dev,
716 struct iw_request_info *info,
717 struct iw_point *data, char *extra)
718 {
719 int res;
720 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
721 if (local->sta_scanning)
722 return -EAGAIN;
723 res = ieee80211_sta_scan_results(dev, extra, data->length);
724 if (res >= 0) {
725 data->length = res;
726 return 0;
727 }
728 data->length = 0;
729 return res;
730 }
731
732
733 static int ieee80211_ioctl_siwrate(struct net_device *dev,
734 struct iw_request_info *info,
735 struct iw_param *rate, char *extra)
736 {
737 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
738 struct ieee80211_hw_mode *mode;
739 int i;
740 u32 target_rate = rate->value / 100000;
741 struct ieee80211_sub_if_data *sdata;
742
743 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
744 if (!sdata->bss)
745 return -ENODEV;
746 mode = local->oper_hw_mode;
747 /* target_rate = -1, rate->fixed = 0 means auto only, so use all rates
748 * target_rate = X, rate->fixed = 1 means only rate X
749 * target_rate = X, rate->fixed = 0 means all rates <= X */
750 sdata->bss->max_ratectrl_rateidx = -1;
751 sdata->bss->force_unicast_rateidx = -1;
752 if (rate->value < 0)
753 return 0;
754 for (i=0; i< mode->num_rates; i++) {
755 struct ieee80211_rate *rates = &mode->rates[i];
756 int this_rate = rates->rate;
757
758 if (mode->mode == MODE_ATHEROS_TURBO ||
759 mode->mode == MODE_ATHEROS_TURBOG)
760 this_rate *= 2;
761 if (target_rate == this_rate) {
762 sdata->bss->max_ratectrl_rateidx = i;
763 if (rate->fixed)
764 sdata->bss->force_unicast_rateidx = i;
765 break;
766 }
767 }
768 return 0;
769 }
770
771 static int ieee80211_ioctl_giwrate(struct net_device *dev,
772 struct iw_request_info *info,
773 struct iw_param *rate, char *extra)
774 {
775 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
776 struct sta_info *sta;
777 struct ieee80211_sub_if_data *sdata;
778
779 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
780 if (sdata->type == IEEE80211_IF_TYPE_STA)
781 sta = sta_info_get(local, sdata->u.sta.bssid);
782 else
783 return -EOPNOTSUPP;
784 if (!sta)
785 return -ENODEV;
786 if (sta->txrate < local->oper_hw_mode->num_rates)
787 rate->value = local->oper_hw_mode->rates[sta->txrate].rate * 100000;
788 else
789 rate->value = 0;
790 sta_info_put(sta);
791 return 0;
792 }
793
794 static int ieee80211_ioctl_siwrts(struct net_device *dev,
795 struct iw_request_info *info,
796 struct iw_param *rts, char *extra)
797 {
798 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
799
800 if (rts->disabled)
801 local->rts_threshold = IEEE80211_MAX_RTS_THRESHOLD;
802 else if (rts->value < 0 || rts->value > IEEE80211_MAX_RTS_THRESHOLD)
803 return -EINVAL;
804 else
805 local->rts_threshold = rts->value;
806
807 /* If the wlan card performs RTS/CTS in hardware/firmware,
808 * configure it here */
809
810 if (local->ops->set_rts_threshold)
811 local->ops->set_rts_threshold(local_to_hw(local),
812 local->rts_threshold);
813
814 return 0;
815 }
816
817 static int ieee80211_ioctl_giwrts(struct net_device *dev,
818 struct iw_request_info *info,
819 struct iw_param *rts, char *extra)
820 {
821 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
822
823 rts->value = local->rts_threshold;
824 rts->disabled = (rts->value >= IEEE80211_MAX_RTS_THRESHOLD);
825 rts->fixed = 1;
826
827 return 0;
828 }
829
830
831 static int ieee80211_ioctl_siwfrag(struct net_device *dev,
832 struct iw_request_info *info,
833 struct iw_param *frag, char *extra)
834 {
835 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
836
837 if (frag->disabled)
838 local->fragmentation_threshold = IEEE80211_MAX_FRAG_THRESHOLD;
839 else if (frag->value < 256 ||
840 frag->value > IEEE80211_MAX_FRAG_THRESHOLD)
841 return -EINVAL;
842 else {
843 /* Fragment length must be even, so strip LSB. */
844 local->fragmentation_threshold = frag->value & ~0x1;
845 }
846
847 /* If the wlan card performs fragmentation in hardware/firmware,
848 * configure it here */
849
850 if (local->ops->set_frag_threshold)
851 local->ops->set_frag_threshold(
852 local_to_hw(local),
853 local->fragmentation_threshold);
854
855 return 0;
856 }
857
858 static int ieee80211_ioctl_giwfrag(struct net_device *dev,
859 struct iw_request_info *info,
860 struct iw_param *frag, char *extra)
861 {
862 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
863
864 frag->value = local->fragmentation_threshold;
865 frag->disabled = (frag->value >= IEEE80211_MAX_RTS_THRESHOLD);
866 frag->fixed = 1;
867
868 return 0;
869 }
870
871
872 static int ieee80211_ioctl_siwretry(struct net_device *dev,
873 struct iw_request_info *info,
874 struct iw_param *retry, char *extra)
875 {
876 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
877
878 if (retry->disabled ||
879 (retry->flags & IW_RETRY_TYPE) != IW_RETRY_LIMIT)
880 return -EINVAL;
881
882 if (retry->flags & IW_RETRY_MAX)
883 local->long_retry_limit = retry->value;
884 else if (retry->flags & IW_RETRY_MIN)
885 local->short_retry_limit = retry->value;
886 else {
887 local->long_retry_limit = retry->value;
888 local->short_retry_limit = retry->value;
889 }
890
891 if (local->ops->set_retry_limit) {
892 return local->ops->set_retry_limit(
893 local_to_hw(local),
894 local->short_retry_limit,
895 local->long_retry_limit);
896 }
897
898 return 0;
899 }
900
901
902 static int ieee80211_ioctl_giwretry(struct net_device *dev,
903 struct iw_request_info *info,
904 struct iw_param *retry, char *extra)
905 {
906 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
907
908 retry->disabled = 0;
909 if (retry->flags == 0 || retry->flags & IW_RETRY_MIN) {
910 /* first return min value, iwconfig will ask max value
911 * later if needed */
912 retry->flags |= IW_RETRY_LIMIT;
913 retry->value = local->short_retry_limit;
914 if (local->long_retry_limit != local->short_retry_limit)
915 retry->flags |= IW_RETRY_MIN;
916 return 0;
917 }
918 if (retry->flags & IW_RETRY_MAX) {
919 retry->flags = IW_RETRY_LIMIT | IW_RETRY_MAX;
920 retry->value = local->long_retry_limit;
921 }
922
923 return 0;
924 }
925
926 static void ieee80211_key_enable_hwaccel(struct ieee80211_local *local,
927 struct ieee80211_key *key)
928 {
929 struct ieee80211_key_conf *keyconf;
930 u8 addr[ETH_ALEN];
931
932 if (!key || key->alg != ALG_WEP || !key->force_sw_encrypt ||
933 (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP))
934 return;
935
936 memset(addr, 0xff, ETH_ALEN);
937 keyconf = ieee80211_key_data2conf(local, key);
938 if (keyconf && local->ops->set_key &&
939 local->ops->set_key(local_to_hw(local),
940 SET_KEY, addr, keyconf, 0) == 0) {
941 key->force_sw_encrypt =
942 !!(keyconf->flags & IEEE80211_KEY_FORCE_SW_ENCRYPT);
943 key->hw_key_idx = keyconf->hw_key_idx;
944 }
945 kfree(keyconf);
946 }
947
948
949 static void ieee80211_key_disable_hwaccel(struct ieee80211_local *local,
950 struct ieee80211_key *key)
951 {
952 struct ieee80211_key_conf *keyconf;
953 u8 addr[ETH_ALEN];
954
955 if (!key || key->alg != ALG_WEP || key->force_sw_encrypt ||
956 (local->hw.flags & IEEE80211_HW_DEVICE_HIDES_WEP))
957 return;
958
959 memset(addr, 0xff, ETH_ALEN);
960 keyconf = ieee80211_key_data2conf(local, key);
961 if (keyconf && local->ops->set_key)
962 local->ops->set_key(local_to_hw(local), DISABLE_KEY,
963 addr, keyconf, 0);
964 kfree(keyconf);
965 key->force_sw_encrypt = 1;
966 }
967
968
969 static int ieee80211_ioctl_default_wep_only(struct ieee80211_local *local,
970 int value)
971 {
972 int i;
973 struct ieee80211_sub_if_data *sdata;
974
975 local->default_wep_only = value;
976 read_lock(&local->sub_if_lock);
977 list_for_each_entry(sdata, &local->sub_if_list, list)
978 for (i = 0; i < NUM_DEFAULT_KEYS; i++)
979 if (value)
980 ieee80211_key_enable_hwaccel(local,
981 sdata->keys[i]);
982 else
983 ieee80211_key_disable_hwaccel(local,
984 sdata->keys[i]);
985 read_unlock(&local->sub_if_lock);
986
987 return 0;
988 }
989
990
991 void ieee80211_update_default_wep_only(struct ieee80211_local *local)
992 {
993 int i = 0;
994 struct ieee80211_sub_if_data *sdata;
995
996 read_lock(&local->sub_if_lock);
997 list_for_each_entry(sdata, &local->sub_if_list, list) {
998
999 if (sdata->dev == local->mdev)
1000 continue;
1001
1002 /* If there is an AP interface then depend on userspace to
1003 set default_wep_only correctly. */
1004 if (sdata->type == IEEE80211_IF_TYPE_AP) {
1005 read_unlock(&local->sub_if_lock);
1006 return;
1007 }
1008
1009 i++;
1010 }
1011
1012 read_unlock(&local->sub_if_lock);
1013
1014 if (i <= 1)
1015 ieee80211_ioctl_default_wep_only(local, 1);
1016 else
1017 ieee80211_ioctl_default_wep_only(local, 0);
1018 }
1019
1020
1021 static int ieee80211_ioctl_prism2_param(struct net_device *dev,
1022 struct iw_request_info *info,
1023 void *wrqu, char *extra)
1024 {
1025 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1026 struct ieee80211_sub_if_data *sdata;
1027 int *i = (int *) extra;
1028 int param = *i;
1029 int value = *(i + 1);
1030 int ret = 0;
1031
1032 if (!capable(CAP_NET_ADMIN))
1033 return -EPERM;
1034
1035 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1036
1037 switch (param) {
1038 case PRISM2_PARAM_IEEE_802_1X:
1039 if (local->ops->set_ieee8021x)
1040 ret = local->ops->set_ieee8021x(local_to_hw(local),
1041 value);
1042 if (ret)
1043 printk(KERN_DEBUG "%s: failed to set IEEE 802.1X (%d) "
1044 "for low-level driver\n", dev->name, value);
1045 else
1046 sdata->ieee802_1x = value;
1047 break;
1048
1049 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
1050 if (sdata->type != IEEE80211_IF_TYPE_AP)
1051 ret = -ENOENT;
1052 else
1053 sdata->use_protection = value;
1054 break;
1055
1056 case PRISM2_PARAM_PREAMBLE:
1057 local->short_preamble = value;
1058 break;
1059
1060 case PRISM2_PARAM_STAT_TIME:
1061 if (!local->stat_time && value) {
1062 local->stat_timer.expires = jiffies + HZ * value / 100;
1063 add_timer(&local->stat_timer);
1064 } else if (local->stat_time && !value) {
1065 del_timer_sync(&local->stat_timer);
1066 }
1067 local->stat_time = value;
1068 break;
1069 case PRISM2_PARAM_SHORT_SLOT_TIME:
1070 if (value)
1071 local->hw.conf.flags |= IEEE80211_CONF_SHORT_SLOT_TIME;
1072 else
1073 local->hw.conf.flags &= ~IEEE80211_CONF_SHORT_SLOT_TIME;
1074 if (ieee80211_hw_config(local))
1075 ret = -EINVAL;
1076 break;
1077
1078 case PRISM2_PARAM_NEXT_MODE:
1079 local->next_mode = value;
1080 break;
1081
1082 case PRISM2_PARAM_RADIO_ENABLED:
1083 ret = ieee80211_ioctl_set_radio_enabled(dev, value);
1084 break;
1085
1086 case PRISM2_PARAM_ANTENNA_MODE:
1087 local->hw.conf.antenna_mode = value;
1088 if (ieee80211_hw_config(local))
1089 ret = -EINVAL;
1090 break;
1091
1092 case PRISM2_PARAM_STA_ANTENNA_SEL:
1093 local->sta_antenna_sel = value;
1094 break;
1095
1096 case PRISM2_PARAM_TX_POWER_REDUCTION:
1097 if (value < 0)
1098 ret = -EINVAL;
1099 else
1100 local->hw.conf.tx_power_reduction = value;
1101 break;
1102
1103 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
1104 local->key_tx_rx_threshold = value;
1105 break;
1106
1107 case PRISM2_PARAM_DEFAULT_WEP_ONLY:
1108 ret = ieee80211_ioctl_default_wep_only(local, value);
1109 break;
1110
1111 case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
1112 local->wifi_wme_noack_test = value;
1113 break;
1114
1115 case PRISM2_PARAM_SCAN_FLAGS:
1116 local->scan_flags = value;
1117 break;
1118
1119 case PRISM2_PARAM_MIXED_CELL:
1120 if (sdata->type != IEEE80211_IF_TYPE_STA &&
1121 sdata->type != IEEE80211_IF_TYPE_IBSS)
1122 ret = -EINVAL;
1123 else
1124 sdata->u.sta.mixed_cell = !!value;
1125 break;
1126
1127 case PRISM2_PARAM_HW_MODES:
1128 local->enabled_modes = value;
1129 break;
1130
1131 case PRISM2_PARAM_CREATE_IBSS:
1132 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
1133 ret = -EINVAL;
1134 else
1135 sdata->u.sta.create_ibss = !!value;
1136 break;
1137 case PRISM2_PARAM_WMM_ENABLED:
1138 if (sdata->type != IEEE80211_IF_TYPE_STA &&
1139 sdata->type != IEEE80211_IF_TYPE_IBSS)
1140 ret = -EINVAL;
1141 else
1142 sdata->u.sta.wmm_enabled = !!value;
1143 break;
1144 case PRISM2_PARAM_RADAR_DETECT:
1145 local->hw.conf.radar_detect = value;
1146 break;
1147 case PRISM2_PARAM_SPECTRUM_MGMT:
1148 local->hw.conf.spect_mgmt = value;
1149 break;
1150 default:
1151 ret = -EOPNOTSUPP;
1152 break;
1153 }
1154
1155 return ret;
1156 }
1157
1158
1159 static int ieee80211_ioctl_get_prism2_param(struct net_device *dev,
1160 struct iw_request_info *info,
1161 void *wrqu, char *extra)
1162 {
1163 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1164 struct ieee80211_sub_if_data *sdata;
1165 int *param = (int *) extra;
1166 int ret = 0;
1167
1168 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1169
1170 switch (*param) {
1171 case PRISM2_PARAM_IEEE_802_1X:
1172 *param = sdata->ieee802_1x;
1173 break;
1174
1175 case PRISM2_PARAM_CTS_PROTECT_ERP_FRAMES:
1176 *param = sdata->use_protection;
1177 break;
1178
1179 case PRISM2_PARAM_PREAMBLE:
1180 *param = local->short_preamble;
1181 break;
1182
1183 case PRISM2_PARAM_STAT_TIME:
1184 *param = local->stat_time;
1185 break;
1186 case PRISM2_PARAM_SHORT_SLOT_TIME:
1187 *param = !!(local->hw.conf.flags & IEEE80211_CONF_SHORT_SLOT_TIME);
1188 break;
1189
1190 case PRISM2_PARAM_NEXT_MODE:
1191 *param = local->next_mode;
1192 break;
1193
1194 case PRISM2_PARAM_ANTENNA_MODE:
1195 *param = local->hw.conf.antenna_mode;
1196 break;
1197
1198 case PRISM2_PARAM_STA_ANTENNA_SEL:
1199 *param = local->sta_antenna_sel;
1200 break;
1201
1202 case PRISM2_PARAM_TX_POWER_REDUCTION:
1203 *param = local->hw.conf.tx_power_reduction;
1204 break;
1205
1206 case PRISM2_PARAM_KEY_TX_RX_THRESHOLD:
1207 *param = local->key_tx_rx_threshold;
1208 break;
1209
1210 case PRISM2_PARAM_DEFAULT_WEP_ONLY:
1211 *param = local->default_wep_only;
1212 break;
1213
1214 case PRISM2_PARAM_WIFI_WME_NOACK_TEST:
1215 *param = local->wifi_wme_noack_test;
1216 break;
1217
1218 case PRISM2_PARAM_SCAN_FLAGS:
1219 *param = local->scan_flags;
1220 break;
1221
1222 case PRISM2_PARAM_HW_MODES:
1223 *param = local->enabled_modes;
1224 break;
1225
1226 case PRISM2_PARAM_CREATE_IBSS:
1227 if (sdata->type != IEEE80211_IF_TYPE_IBSS)
1228 ret = -EINVAL;
1229 else
1230 *param = !!sdata->u.sta.create_ibss;
1231 break;
1232
1233 case PRISM2_PARAM_MIXED_CELL:
1234 if (sdata->type != IEEE80211_IF_TYPE_STA &&
1235 sdata->type != IEEE80211_IF_TYPE_IBSS)
1236 ret = -EINVAL;
1237 else
1238 *param = !!sdata->u.sta.mixed_cell;
1239 break;
1240 case PRISM2_PARAM_WMM_ENABLED:
1241 if (sdata->type != IEEE80211_IF_TYPE_STA &&
1242 sdata->type != IEEE80211_IF_TYPE_IBSS)
1243 ret = -EINVAL;
1244 else
1245 *param = !!sdata->u.sta.wmm_enabled;
1246 break;
1247 default:
1248 ret = -EOPNOTSUPP;
1249 break;
1250 }
1251
1252 return ret;
1253 }
1254
1255 static int ieee80211_ioctl_siwmlme(struct net_device *dev,
1256 struct iw_request_info *info,
1257 struct iw_point *data, char *extra)
1258 {
1259 struct ieee80211_sub_if_data *sdata;
1260 struct iw_mlme *mlme = (struct iw_mlme *) extra;
1261
1262 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1263 if (sdata->type != IEEE80211_IF_TYPE_STA &&
1264 sdata->type != IEEE80211_IF_TYPE_IBSS)
1265 return -EINVAL;
1266
1267 switch (mlme->cmd) {
1268 case IW_MLME_DEAUTH:
1269 /* TODO: mlme->addr.sa_data */
1270 return ieee80211_sta_deauthenticate(dev, mlme->reason_code);
1271 case IW_MLME_DISASSOC:
1272 /* TODO: mlme->addr.sa_data */
1273 return ieee80211_sta_disassociate(dev, mlme->reason_code);
1274 default:
1275 return -EOPNOTSUPP;
1276 }
1277 }
1278
1279
1280 static int ieee80211_ioctl_siwencode(struct net_device *dev,
1281 struct iw_request_info *info,
1282 struct iw_point *erq, char *keybuf)
1283 {
1284 struct ieee80211_sub_if_data *sdata;
1285 int idx, i, alg = ALG_WEP;
1286 u8 bcaddr[ETH_ALEN] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
1287
1288 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1289
1290 idx = erq->flags & IW_ENCODE_INDEX;
1291 if (idx == 0) {
1292 if (sdata->default_key)
1293 for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1294 if (sdata->default_key == sdata->keys[i]) {
1295 idx = i;
1296 break;
1297 }
1298 }
1299 } else if (idx < 1 || idx > 4)
1300 return -EINVAL;
1301 else
1302 idx--;
1303
1304 if (erq->flags & IW_ENCODE_DISABLED)
1305 alg = ALG_NONE;
1306 else if (erq->length == 0) {
1307 /* No key data - just set the default TX key index */
1308 if (sdata->default_key != sdata->keys[idx]) {
1309 ieee80211_debugfs_key_remove_default(sdata);
1310 sdata->default_key = sdata->keys[idx];
1311 if (sdata->default_key)
1312 ieee80211_debugfs_key_add_default(sdata);
1313 }
1314 return 0;
1315 }
1316
1317 return ieee80211_set_encryption(
1318 dev, bcaddr,
1319 idx, alg,
1320 !sdata->default_key,
1321 keybuf, erq->length);
1322 }
1323
1324
1325 static int ieee80211_ioctl_giwencode(struct net_device *dev,
1326 struct iw_request_info *info,
1327 struct iw_point *erq, char *key)
1328 {
1329 struct ieee80211_sub_if_data *sdata;
1330 int idx, i;
1331
1332 sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1333
1334 idx = erq->flags & IW_ENCODE_INDEX;
1335 if (idx < 1 || idx > 4) {
1336 idx = -1;
1337 if (!sdata->default_key)
1338 idx = 0;
1339 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1340 if (sdata->default_key == sdata->keys[i]) {
1341 idx = i;
1342 break;
1343 }
1344 }
1345 if (idx < 0)
1346 return -EINVAL;
1347 } else
1348 idx--;
1349
1350 erq->flags = idx + 1;
1351
1352 if (!sdata->keys[idx]) {
1353 erq->length = 0;
1354 erq->flags |= IW_ENCODE_DISABLED;
1355 return 0;
1356 }
1357
1358 memcpy(key, sdata->keys[idx]->key,
1359 min((int)erq->length, sdata->keys[idx]->keylen));
1360 erq->length = sdata->keys[idx]->keylen;
1361 erq->flags |= IW_ENCODE_ENABLED;
1362
1363 return 0;
1364 }
1365
1366 static int ieee80211_ioctl_siwauth(struct net_device *dev,
1367 struct iw_request_info *info,
1368 struct iw_param *data, char *extra)
1369 {
1370 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1371 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1372 int ret = 0;
1373
1374 switch (data->flags & IW_AUTH_INDEX) {
1375 case IW_AUTH_WPA_VERSION:
1376 case IW_AUTH_CIPHER_PAIRWISE:
1377 case IW_AUTH_CIPHER_GROUP:
1378 case IW_AUTH_WPA_ENABLED:
1379 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
1380 break;
1381 case IW_AUTH_KEY_MGMT:
1382 if (sdata->type != IEEE80211_IF_TYPE_STA)
1383 ret = -EINVAL;
1384 else {
1385 /*
1386 * TODO: sdata->u.sta.key_mgmt does not match with WE18
1387 * value completely; could consider modifying this to
1388 * be closer to WE18. For now, this value is not really
1389 * used for anything else than Privacy matching, so the
1390 * current code here should be more or less OK.
1391 */
1392 if (data->value & IW_AUTH_KEY_MGMT_802_1X) {
1393 sdata->u.sta.key_mgmt =
1394 IEEE80211_KEY_MGMT_WPA_EAP;
1395 } else if (data->value & IW_AUTH_KEY_MGMT_PSK) {
1396 sdata->u.sta.key_mgmt =
1397 IEEE80211_KEY_MGMT_WPA_PSK;
1398 } else {
1399 sdata->u.sta.key_mgmt =
1400 IEEE80211_KEY_MGMT_NONE;
1401 }
1402 }
1403 break;
1404 case IW_AUTH_80211_AUTH_ALG:
1405 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1406 sdata->type == IEEE80211_IF_TYPE_IBSS)
1407 sdata->u.sta.auth_algs = data->value;
1408 else
1409 ret = -EOPNOTSUPP;
1410 break;
1411 case IW_AUTH_PRIVACY_INVOKED:
1412 if (local->ops->set_privacy_invoked)
1413 ret = local->ops->set_privacy_invoked(
1414 local_to_hw(local), data->value);
1415 break;
1416 default:
1417 ret = -EOPNOTSUPP;
1418 break;
1419 }
1420 return ret;
1421 }
1422
1423 /* Get wireless statistics. Called by /proc/net/wireless and by SIOCGIWSTATS */
1424 static struct iw_statistics *ieee80211_get_wireless_stats(struct net_device *dev)
1425 {
1426 struct ieee80211_local *local = wdev_priv(dev->ieee80211_ptr);
1427 struct iw_statistics *wstats = &local->wstats;
1428 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1429 struct sta_info *sta = NULL;
1430
1431 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1432 sdata->type == IEEE80211_IF_TYPE_IBSS)
1433 sta = sta_info_get(local, sdata->u.sta.bssid);
1434 if (!sta) {
1435 wstats->discard.fragment = 0;
1436 wstats->discard.misc = 0;
1437 wstats->qual.qual = 0;
1438 wstats->qual.level = 0;
1439 wstats->qual.noise = 0;
1440 wstats->qual.updated = IW_QUAL_ALL_INVALID;
1441 } else {
1442 wstats->qual.level = sta->last_rssi;
1443 wstats->qual.qual = sta->last_signal;
1444 wstats->qual.noise = sta->last_noise;
1445 wstats->qual.updated = local->wstats_flags;
1446 sta_info_put(sta);
1447 }
1448 return wstats;
1449 }
1450
1451 static int ieee80211_ioctl_giwauth(struct net_device *dev,
1452 struct iw_request_info *info,
1453 struct iw_param *data, char *extra)
1454 {
1455 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1456 int ret = 0;
1457
1458 switch (data->flags & IW_AUTH_INDEX) {
1459 case IW_AUTH_80211_AUTH_ALG:
1460 if (sdata->type == IEEE80211_IF_TYPE_STA ||
1461 sdata->type == IEEE80211_IF_TYPE_IBSS)
1462 data->value = sdata->u.sta.auth_algs;
1463 else
1464 ret = -EOPNOTSUPP;
1465 break;
1466 default:
1467 ret = -EOPNOTSUPP;
1468 break;
1469 }
1470 return ret;
1471 }
1472
1473
1474 static int ieee80211_ioctl_siwencodeext(struct net_device *dev,
1475 struct iw_request_info *info,
1476 struct iw_point *erq, char *extra)
1477 {
1478 struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
1479 struct iw_encode_ext *ext = (struct iw_encode_ext *) extra;
1480 int alg, idx, i;
1481
1482 switch (ext->alg) {
1483 case IW_ENCODE_ALG_NONE:
1484 alg = ALG_NONE;
1485 break;
1486 case IW_ENCODE_ALG_WEP:
1487 alg = ALG_WEP;
1488 break;
1489 case IW_ENCODE_ALG_TKIP:
1490 alg = ALG_TKIP;
1491 break;
1492 case IW_ENCODE_ALG_CCMP:
1493 alg = ALG_CCMP;
1494 break;
1495 default:
1496 return -EOPNOTSUPP;
1497 }
1498
1499 if (erq->flags & IW_ENCODE_DISABLED)
1500 alg = ALG_NONE;
1501
1502 idx = erq->flags & IW_ENCODE_INDEX;
1503 if (idx < 1 || idx > 4) {
1504 idx = -1;
1505 if (!sdata->default_key)
1506 idx = 0;
1507 else for (i = 0; i < NUM_DEFAULT_KEYS; i++) {
1508 if (sdata->default_key == sdata->keys[i]) {
1509 idx = i;
1510 break;
1511 }
1512 }
1513 if (idx < 0)
1514 return -EINVAL;
1515 } else
1516 idx--;
1517
1518 return ieee80211_set_encryption(dev, ext->addr.sa_data, idx, alg,
1519 ext->ext_flags &
1520 IW_ENCODE_EXT_SET_TX_KEY,
1521 ext->key, ext->key_len);
1522 }
1523
1524
1525 static const struct iw_priv_args ieee80211_ioctl_priv[] = {
1526 { PRISM2_IOCTL_PRISM2_PARAM,
1527 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 2, 0, "param" },
1528 { PRISM2_IOCTL_GET_PRISM2_PARAM,
1529 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1,
1530 IW_PRIV_TYPE_INT | IW_PRIV_SIZE_FIXED | 1, "get_param" },
1531 };
1532
1533 /* Structures to export the Wireless Handlers */
1534
1535 static const iw_handler ieee80211_handler[] =
1536 {
1537 (iw_handler) NULL, /* SIOCSIWCOMMIT */
1538 (iw_handler) ieee80211_ioctl_giwname, /* SIOCGIWNAME */
1539 (iw_handler) NULL, /* SIOCSIWNWID */
1540 (iw_handler) NULL, /* SIOCGIWNWID */
1541 (iw_handler) ieee80211_ioctl_siwfreq, /* SIOCSIWFREQ */
1542 (iw_handler) ieee80211_ioctl_giwfreq, /* SIOCGIWFREQ */
1543 (iw_handler) ieee80211_ioctl_siwmode, /* SIOCSIWMODE */
1544 (iw_handler) ieee80211_ioctl_giwmode, /* SIOCGIWMODE */
1545 (iw_handler) NULL, /* SIOCSIWSENS */
1546 (iw_handler) NULL, /* SIOCGIWSENS */
1547 (iw_handler) NULL /* not used */, /* SIOCSIWRANGE */
1548 (iw_handler) ieee80211_ioctl_giwrange, /* SIOCGIWRANGE */
1549 (iw_handler) NULL /* not used */, /* SIOCSIWPRIV */
1550 (iw_handler) NULL /* kernel code */, /* SIOCGIWPRIV */
1551 (iw_handler) NULL /* not used */, /* SIOCSIWSTATS */
1552 (iw_handler) NULL /* kernel code */, /* SIOCGIWSTATS */
1553 iw_handler_set_spy, /* SIOCSIWSPY */
1554 iw_handler_get_spy, /* SIOCGIWSPY */
1555 iw_handler_set_thrspy, /* SIOCSIWTHRSPY */
1556 iw_handler_get_thrspy, /* SIOCGIWTHRSPY */
1557 (iw_handler) ieee80211_ioctl_siwap, /* SIOCSIWAP */
1558 (iw_handler) ieee80211_ioctl_giwap, /* SIOCGIWAP */
1559 (iw_handler) ieee80211_ioctl_siwmlme, /* SIOCSIWMLME */
1560 (iw_handler) NULL, /* SIOCGIWAPLIST */
1561 (iw_handler) ieee80211_ioctl_siwscan, /* SIOCSIWSCAN */
1562 (iw_handler) ieee80211_ioctl_giwscan, /* SIOCGIWSCAN */
1563 (iw_handler) ieee80211_ioctl_siwessid, /* SIOCSIWESSID */
1564 (iw_handler) ieee80211_ioctl_giwessid, /* SIOCGIWESSID */
1565 (iw_handler) NULL, /* SIOCSIWNICKN */
1566 (iw_handler) NULL, /* SIOCGIWNICKN */
1567 (iw_handler) NULL, /* -- hole -- */
1568 (iw_handler) NULL, /* -- hole -- */
1569 (iw_handler) ieee80211_ioctl_siwrate, /* SIOCSIWRATE */
1570 (iw_handler) ieee80211_ioctl_giwrate, /* SIOCGIWRATE */
1571 (iw_handler) ieee80211_ioctl_siwrts, /* SIOCSIWRTS */
1572 (iw_handler) ieee80211_ioctl_giwrts, /* SIOCGIWRTS */
1573 (iw_handler) ieee80211_ioctl_siwfrag, /* SIOCSIWFRAG */
1574 (iw_handler) ieee80211_ioctl_giwfrag, /* SIOCGIWFRAG */
1575 (iw_handler) NULL, /* SIOCSIWTXPOW */
1576 (iw_handler) NULL, /* SIOCGIWTXPOW */
1577 (iw_handler) ieee80211_ioctl_siwretry, /* SIOCSIWRETRY */
1578 (iw_handler) ieee80211_ioctl_giwretry, /* SIOCGIWRETRY */
1579 (iw_handler) ieee80211_ioctl_siwencode, /* SIOCSIWENCODE */
1580 (iw_handler) ieee80211_ioctl_giwencode, /* SIOCGIWENCODE */
1581 (iw_handler) NULL, /* SIOCSIWPOWER */
1582 (iw_handler) NULL, /* SIOCGIWPOWER */
1583 (iw_handler) NULL, /* -- hole -- */
1584 (iw_handler) NULL, /* -- hole -- */
1585 (iw_handler) ieee80211_ioctl_siwgenie, /* SIOCSIWGENIE */
1586 (iw_handler) NULL, /* SIOCGIWGENIE */
1587 (iw_handler) ieee80211_ioctl_siwauth, /* SIOCSIWAUTH */
1588 (iw_handler) ieee80211_ioctl_giwauth, /* SIOCGIWAUTH */
1589 (iw_handler) ieee80211_ioctl_siwencodeext, /* SIOCSIWENCODEEXT */
1590 (iw_handler) NULL, /* SIOCGIWENCODEEXT */
1591 (iw_handler) NULL, /* SIOCSIWPMKSA */
1592 (iw_handler) NULL, /* -- hole -- */
1593 };
1594
1595 static const iw_handler ieee80211_private_handler[] =
1596 { /* SIOCIWFIRSTPRIV + */
1597 (iw_handler) ieee80211_ioctl_prism2_param, /* 0 */
1598 (iw_handler) ieee80211_ioctl_get_prism2_param, /* 1 */
1599 };
1600
1601 const struct iw_handler_def ieee80211_iw_handler_def =
1602 {
1603 .num_standard = ARRAY_SIZE(ieee80211_handler),
1604 .num_private = ARRAY_SIZE(ieee80211_private_handler),
1605 .num_private_args = ARRAY_SIZE(ieee80211_ioctl_priv),
1606 .standard = (iw_handler *) ieee80211_handler,
1607 .private = (iw_handler *) ieee80211_private_handler,
1608 .private_args = (struct iw_priv_args *) ieee80211_ioctl_priv,
1609 .get_wireless_stats = ieee80211_get_wireless_stats,
1610 };
USB Experimental Work