?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
e1000: Add device IDs of blade version of the 82571 quad port
[pv_ops_mirror.git] / net / ieee80211 / ieee80211_wx.c
blob465b73d505321e0fefecbb499d963f90ac58f4ea
1 /******************************************************************************
2
3 Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
4
5 Portions of this file are based on the WEP enablement code provided by the
6 Host AP project hostap-drivers v0.1.3
7 Copyright (c) 2001-2002, SSH Communications Security Corp and Jouni Malinen
8 <j@w1.fi>
9 Copyright (c) 2002-2003, Jouni Malinen <j@w1.fi>
10
11 This program is free software; you can redistribute it and/or modify it
12 under the terms of version 2 of the GNU General Public License as
13 published by the Free Software Foundation.
14
15 This program is distributed in the hope that it will be useful, but WITHOUT
16 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
17 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
18 more details.
19
20 You should have received a copy of the GNU General Public License along with
21 this program; if not, write to the Free Software Foundation, Inc., 59
22 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
23
24 The full GNU General Public License is included in this distribution in the
25 file called LICENSE.
26
27 Contact Information:
28 James P. Ketrenos <ipw2100-admin@linux.intel.com>
29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30
31 ******************************************************************************/
32
33 #include <linux/kmod.h>
34 #include <linux/module.h>
35 #include <linux/jiffies.h>
36
37 #include <net/ieee80211.h>
38 #include <linux/wireless.h>
39
40 static const char *ieee80211_modes[] = {
41 "?", "a", "b", "ab", "g", "ag", "bg", "abg"
42 };
43
44 #define MAX_CUSTOM_LEN 64
45 static char *ieee80211_translate_scan(struct ieee80211_device *ieee,
46 char *start, char *stop,
47 struct ieee80211_network *network)
48 {
49 char custom[MAX_CUSTOM_LEN];
50 char *p;
51 struct iw_event iwe;
52 int i, j;
53 char *current_val; /* For rates */
54 u8 rate;
55
56 /* First entry *MUST* be the AP MAC address */
57 iwe.cmd = SIOCGIWAP;
58 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
59 memcpy(iwe.u.ap_addr.sa_data, network->bssid, ETH_ALEN);
60 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_ADDR_LEN);
61
62 /* Remaining entries will be displayed in the order we provide them */
63
64 /* Add the ESSID */
65 iwe.cmd = SIOCGIWESSID;
66 iwe.u.data.flags = 1;
67 if (network->flags & NETWORK_EMPTY_ESSID) {
68 iwe.u.data.length = sizeof("<hidden>");
69 start = iwe_stream_add_point(start, stop, &iwe, "<hidden>");
70 } else {
71 iwe.u.data.length = min(network->ssid_len, (u8) 32);
72 start = iwe_stream_add_point(start, stop, &iwe, network->ssid);
73 }
74
75 /* Add the protocol name */
76 iwe.cmd = SIOCGIWNAME;
77 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11%s",
78 ieee80211_modes[network->mode]);
79 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_CHAR_LEN);
80
81 /* Add mode */
82 iwe.cmd = SIOCGIWMODE;
83 if (network->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
84 if (network->capability & WLAN_CAPABILITY_ESS)
85 iwe.u.mode = IW_MODE_MASTER;
86 else
87 iwe.u.mode = IW_MODE_ADHOC;
88
89 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_UINT_LEN);
90 }
91
92 /* Add channel and frequency */
93 /* Note : userspace automatically computes channel using iwrange */
94 iwe.cmd = SIOCGIWFREQ;
95 iwe.u.freq.m = ieee80211_channel_to_freq(ieee, network->channel);
96 iwe.u.freq.e = 6;
97 iwe.u.freq.i = 0;
98 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_FREQ_LEN);
99
100 /* Add encryption capability */
101 iwe.cmd = SIOCGIWENCODE;
102 if (network->capability & WLAN_CAPABILITY_PRIVACY)
103 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
104 else
105 iwe.u.data.flags = IW_ENCODE_DISABLED;
106 iwe.u.data.length = 0;
107 start = iwe_stream_add_point(start, stop, &iwe, network->ssid);
108
109 /* Add basic and extended rates */
110 /* Rate : stuffing multiple values in a single event require a bit
111 * more of magic - Jean II */
112 current_val = start + IW_EV_LCP_LEN;
113 iwe.cmd = SIOCGIWRATE;
114 /* Those two flags are ignored... */
115 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
116
117 for (i = 0, j = 0; i < network->rates_len;) {
118 if (j < network->rates_ex_len &&
119 ((network->rates_ex[j] & 0x7F) <
120 (network->rates[i] & 0x7F)))
121 rate = network->rates_ex[j++] & 0x7F;
122 else
123 rate = network->rates[i++] & 0x7F;
124 /* Bit rate given in 500 kb/s units (+ 0x80) */
125 iwe.u.bitrate.value = ((rate & 0x7f) * 500000);
126 /* Add new value to event */
127 current_val = iwe_stream_add_value(start, current_val, stop, &iwe, IW_EV_PARAM_LEN);
128 }
129 for (; j < network->rates_ex_len; j++) {
130 rate = network->rates_ex[j] & 0x7F;
131 /* Bit rate given in 500 kb/s units (+ 0x80) */
132 iwe.u.bitrate.value = ((rate & 0x7f) * 500000);
133 /* Add new value to event */
134 current_val = iwe_stream_add_value(start, current_val, stop, &iwe, IW_EV_PARAM_LEN);
135 }
136 /* Check if we added any rate */
137 if((current_val - start) > IW_EV_LCP_LEN)
138 start = current_val;
139
140 /* Add quality statistics */
141 iwe.cmd = IWEVQUAL;
142 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
143 IW_QUAL_NOISE_UPDATED;
144
145 if (!(network->stats.mask & IEEE80211_STATMASK_RSSI)) {
146 iwe.u.qual.updated |= IW_QUAL_QUAL_INVALID |
147 IW_QUAL_LEVEL_INVALID;
148 iwe.u.qual.qual = 0;
149 } else {
150 if (ieee->perfect_rssi == ieee->worst_rssi)
151 iwe.u.qual.qual = 100;
152 else
153 iwe.u.qual.qual =
154 (100 *
155 (ieee->perfect_rssi - ieee->worst_rssi) *
156 (ieee->perfect_rssi - ieee->worst_rssi) -
157 (ieee->perfect_rssi - network->stats.rssi) *
158 (15 * (ieee->perfect_rssi - ieee->worst_rssi) +
159 62 * (ieee->perfect_rssi -
160 network->stats.rssi))) /
161 ((ieee->perfect_rssi -
162 ieee->worst_rssi) * (ieee->perfect_rssi -
163 ieee->worst_rssi));
164 if (iwe.u.qual.qual > 100)
165 iwe.u.qual.qual = 100;
166 else if (iwe.u.qual.qual < 1)
167 iwe.u.qual.qual = 0;
168 }
169
170 if (!(network->stats.mask & IEEE80211_STATMASK_NOISE)) {
171 iwe.u.qual.updated |= IW_QUAL_NOISE_INVALID;
172 iwe.u.qual.noise = 0;
173 } else {
174 iwe.u.qual.noise = network->stats.noise;
175 }
176
177 if (!(network->stats.mask & IEEE80211_STATMASK_SIGNAL)) {
178 iwe.u.qual.updated |= IW_QUAL_LEVEL_INVALID;
179 iwe.u.qual.level = 0;
180 } else {
181 iwe.u.qual.level = network->stats.signal;
182 }
183
184 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
185
186 iwe.cmd = IWEVCUSTOM;
187 p = custom;
188
189 iwe.u.data.length = p - custom;
190 if (iwe.u.data.length)
191 start = iwe_stream_add_point(start, stop, &iwe, custom);
192
193 memset(&iwe, 0, sizeof(iwe));
194 if (network->wpa_ie_len) {
195 char buf[MAX_WPA_IE_LEN];
196 memcpy(buf, network->wpa_ie, network->wpa_ie_len);
197 iwe.cmd = IWEVGENIE;
198 iwe.u.data.length = network->wpa_ie_len;
199 start = iwe_stream_add_point(start, stop, &iwe, buf);
200 }
201
202 memset(&iwe, 0, sizeof(iwe));
203 if (network->rsn_ie_len) {
204 char buf[MAX_WPA_IE_LEN];
205 memcpy(buf, network->rsn_ie, network->rsn_ie_len);
206 iwe.cmd = IWEVGENIE;
207 iwe.u.data.length = network->rsn_ie_len;
208 start = iwe_stream_add_point(start, stop, &iwe, buf);
209 }
210
211 /* Add EXTRA: Age to display seconds since last beacon/probe response
212 * for given network. */
213 iwe.cmd = IWEVCUSTOM;
214 p = custom;
215 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
216 " Last beacon: %dms ago",
217 jiffies_to_msecs(jiffies - network->last_scanned));
218 iwe.u.data.length = p - custom;
219 if (iwe.u.data.length)
220 start = iwe_stream_add_point(start, stop, &iwe, custom);
221
222 /* Add spectrum management information */
223 iwe.cmd = -1;
224 p = custom;
225 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Channel flags: ");
226
227 if (ieee80211_get_channel_flags(ieee, network->channel) &
228 IEEE80211_CH_INVALID) {
229 iwe.cmd = IWEVCUSTOM;
230 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), "INVALID ");
231 }
232
233 if (ieee80211_get_channel_flags(ieee, network->channel) &
234 IEEE80211_CH_RADAR_DETECT) {
235 iwe.cmd = IWEVCUSTOM;
236 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), "DFS ");
237 }
238
239 if (iwe.cmd == IWEVCUSTOM) {
240 iwe.u.data.length = p - custom;
241 start = iwe_stream_add_point(start, stop, &iwe, custom);
242 }
243
244 return start;
245 }
246
247 #define SCAN_ITEM_SIZE 128
248
249 int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
250 struct iw_request_info *info,
251 union iwreq_data *wrqu, char *extra)
252 {
253 struct ieee80211_network *network;
254 unsigned long flags;
255 int err = 0;
256
257 char *ev = extra;
258 char *stop = ev + wrqu->data.length;
259 int i = 0;
260
261 IEEE80211_DEBUG_WX("Getting scan\n");
262
263 spin_lock_irqsave(&ieee->lock, flags);
264
265 list_for_each_entry(network, &ieee->network_list, list) {
266 i++;
267 if (stop - ev < SCAN_ITEM_SIZE) {
268 err = -E2BIG;
269 break;
270 }
271
272 if (ieee->scan_age == 0 ||
273 time_after(network->last_scanned + ieee->scan_age, jiffies))
274 ev = ieee80211_translate_scan(ieee, ev, stop, network);
275 else
276 IEEE80211_DEBUG_SCAN("Not showing network '%s ("
277 MAC_FMT ")' due to age (%dms).\n",
278 escape_essid(network->ssid,
279 network->ssid_len),
280 MAC_ARG(network->bssid),
281 jiffies_to_msecs(jiffies -
282 network->
283 last_scanned));
284 }
285
286 spin_unlock_irqrestore(&ieee->lock, flags);
287
288 wrqu->data.length = ev - extra;
289 wrqu->data.flags = 0;
290
291 IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i);
292
293 return err;
294 }
295
296 int ieee80211_wx_set_encode(struct ieee80211_device *ieee,
297 struct iw_request_info *info,
298 union iwreq_data *wrqu, char *keybuf)
299 {
300 struct iw_point *erq = &(wrqu->encoding);
301 struct net_device *dev = ieee->dev;
302 struct ieee80211_security sec = {
303 .flags = 0
304 };
305 int i, key, key_provided, len;
306 struct ieee80211_crypt_data **crypt;
307 int host_crypto = ieee->host_encrypt || ieee->host_decrypt || ieee->host_build_iv;
308
309 IEEE80211_DEBUG_WX("SET_ENCODE\n");
310
311 key = erq->flags & IW_ENCODE_INDEX;
312 if (key) {
313 if (key > WEP_KEYS)
314 return -EINVAL;
315 key--;
316 key_provided = 1;
317 } else {
318 key_provided = 0;
319 key = ieee->tx_keyidx;
320 }
321
322 IEEE80211_DEBUG_WX("Key: %d [%s]\n", key, key_provided ?
323 "provided" : "default");
324
325 crypt = &ieee->crypt[key];
326
327 if (erq->flags & IW_ENCODE_DISABLED) {
328 if (key_provided && *crypt) {
329 IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n",
330 key);
331 ieee80211_crypt_delayed_deinit(ieee, crypt);
332 } else
333 IEEE80211_DEBUG_WX("Disabling encryption.\n");
334
335 /* Check all the keys to see if any are still configured,
336 * and if no key index was provided, de-init them all */
337 for (i = 0; i < WEP_KEYS; i++) {
338 if (ieee->crypt[i] != NULL) {
339 if (key_provided)
340 break;
341 ieee80211_crypt_delayed_deinit(ieee,
342 &ieee->crypt[i]);
343 }
344 }
345
346 if (i == WEP_KEYS) {
347 sec.enabled = 0;
348 sec.encrypt = 0;
349 sec.level = SEC_LEVEL_0;
350 sec.flags |= SEC_ENABLED | SEC_LEVEL | SEC_ENCRYPT;
351 }
352
353 goto done;
354 }
355
356 sec.enabled = 1;
357 sec.encrypt = 1;
358 sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
359
360 if (*crypt != NULL && (*crypt)->ops != NULL &&
361 strcmp((*crypt)->ops->name, "WEP") != 0) {
362 /* changing to use WEP; deinit previously used algorithm
363 * on this key */
364 ieee80211_crypt_delayed_deinit(ieee, crypt);
365 }
366
367 if (*crypt == NULL && host_crypto) {
368 struct ieee80211_crypt_data *new_crypt;
369
370 /* take WEP into use */
371 new_crypt = kzalloc(sizeof(struct ieee80211_crypt_data),
372 GFP_KERNEL);
373 if (new_crypt == NULL)
374 return -ENOMEM;
375 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
376 if (!new_crypt->ops) {
377 request_module("ieee80211_crypt_wep");
378 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
379 }
380
381 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
382 new_crypt->priv = new_crypt->ops->init(key);
383
384 if (!new_crypt->ops || !new_crypt->priv) {
385 kfree(new_crypt);
386 new_crypt = NULL;
387
388 printk(KERN_WARNING "%s: could not initialize WEP: "
389 "load module ieee80211_crypt_wep\n", dev->name);
390 return -EOPNOTSUPP;
391 }
392 *crypt = new_crypt;
393 }
394
395 /* If a new key was provided, set it up */
396 if (erq->length > 0) {
397 len = erq->length <= 5 ? 5 : 13;
398 memcpy(sec.keys[key], keybuf, erq->length);
399 if (len > erq->length)
400 memset(sec.keys[key] + erq->length, 0,
401 len - erq->length);
402 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
403 key, escape_essid(sec.keys[key], len),
404 erq->length, len);
405 sec.key_sizes[key] = len;
406 if (*crypt)
407 (*crypt)->ops->set_key(sec.keys[key], len, NULL,
408 (*crypt)->priv);
409 sec.flags |= (1 << key);
410 /* This ensures a key will be activated if no key is
411 * explicitely set */
412 if (key == sec.active_key)
413 sec.flags |= SEC_ACTIVE_KEY;
414
415 } else {
416 if (host_crypto) {
417 len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
418 NULL, (*crypt)->priv);
419 if (len == 0) {
420 /* Set a default key of all 0 */
421 IEEE80211_DEBUG_WX("Setting key %d to all "
422 "zero.\n", key);
423 memset(sec.keys[key], 0, 13);
424 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
425 (*crypt)->priv);
426 sec.key_sizes[key] = 13;
427 sec.flags |= (1 << key);
428 }
429 }
430 /* No key data - just set the default TX key index */
431 if (key_provided) {
432 IEEE80211_DEBUG_WX("Setting key %d to default Tx "
433 "key.\n", key);
434 ieee->tx_keyidx = key;
435 sec.active_key = key;
436 sec.flags |= SEC_ACTIVE_KEY;
437 }
438 }
439 if (erq->flags & (IW_ENCODE_OPEN | IW_ENCODE_RESTRICTED)) {
440 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
441 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN :
442 WLAN_AUTH_SHARED_KEY;
443 sec.flags |= SEC_AUTH_MODE;
444 IEEE80211_DEBUG_WX("Auth: %s\n",
445 sec.auth_mode == WLAN_AUTH_OPEN ?
446 "OPEN" : "SHARED KEY");
447 }
448
449 /* For now we just support WEP, so only set that security level...
450 * TODO: When WPA is added this is one place that needs to change */
451 sec.flags |= SEC_LEVEL;
452 sec.level = SEC_LEVEL_1; /* 40 and 104 bit WEP */
453 sec.encode_alg[key] = SEC_ALG_WEP;
454
455 done:
456 if (ieee->set_security)
457 ieee->set_security(dev, &sec);
458
459 /* Do not reset port if card is in Managed mode since resetting will
460 * generate new IEEE 802.11 authentication which may end up in looping
461 * with IEEE 802.1X. If your hardware requires a reset after WEP
462 * configuration (for example... Prism2), implement the reset_port in
463 * the callbacks structures used to initialize the 802.11 stack. */
464 if (ieee->reset_on_keychange &&
465 ieee->iw_mode != IW_MODE_INFRA &&
466 ieee->reset_port && ieee->reset_port(dev)) {
467 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
468 return -EINVAL;
469 }
470 return 0;
471 }
472
473 int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
474 struct iw_request_info *info,
475 union iwreq_data *wrqu, char *keybuf)
476 {
477 struct iw_point *erq = &(wrqu->encoding);
478 int len, key;
479 struct ieee80211_crypt_data *crypt;
480 struct ieee80211_security *sec = &ieee->sec;
481
482 IEEE80211_DEBUG_WX("GET_ENCODE\n");
483
484 key = erq->flags & IW_ENCODE_INDEX;
485 if (key) {
486 if (key > WEP_KEYS)
487 return -EINVAL;
488 key--;
489 } else
490 key = ieee->tx_keyidx;
491
492 crypt = ieee->crypt[key];
493 erq->flags = key + 1;
494
495 if (!sec->enabled) {
496 erq->length = 0;
497 erq->flags |= IW_ENCODE_DISABLED;
498 return 0;
499 }
500
501 len = sec->key_sizes[key];
502 memcpy(keybuf, sec->keys[key], len);
503
504 erq->length = len;
505 erq->flags |= IW_ENCODE_ENABLED;
506
507 if (ieee->open_wep)
508 erq->flags |= IW_ENCODE_OPEN;
509 else
510 erq->flags |= IW_ENCODE_RESTRICTED;
511
512 return 0;
513 }
514
515 int ieee80211_wx_set_encodeext(struct ieee80211_device *ieee,
516 struct iw_request_info *info,
517 union iwreq_data *wrqu, char *extra)
518 {
519 struct net_device *dev = ieee->dev;
520 struct iw_point *encoding = &wrqu->encoding;
521 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
522 int i, idx, ret = 0;
523 int group_key = 0;
524 const char *alg, *module;
525 struct ieee80211_crypto_ops *ops;
526 struct ieee80211_crypt_data **crypt;
527
528 struct ieee80211_security sec = {
529 .flags = 0,
530 };
531
532 idx = encoding->flags & IW_ENCODE_INDEX;
533 if (idx) {
534 if (idx < 1 || idx > WEP_KEYS)
535 return -EINVAL;
536 idx--;
537 } else
538 idx = ieee->tx_keyidx;
539
540 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
541 crypt = &ieee->crypt[idx];
542 group_key = 1;
543 } else {
544 /* some Cisco APs use idx>0 for unicast in dynamic WEP */
545 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
546 return -EINVAL;
547 if (ieee->iw_mode == IW_MODE_INFRA)
548 crypt = &ieee->crypt[idx];
549 else
550 return -EINVAL;
551 }
552
553 sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
554 if ((encoding->flags & IW_ENCODE_DISABLED) ||
555 ext->alg == IW_ENCODE_ALG_NONE) {
556 if (*crypt)
557 ieee80211_crypt_delayed_deinit(ieee, crypt);
558
559 for (i = 0; i < WEP_KEYS; i++)
560 if (ieee->crypt[i] != NULL)
561 break;
562
563 if (i == WEP_KEYS) {
564 sec.enabled = 0;
565 sec.encrypt = 0;
566 sec.level = SEC_LEVEL_0;
567 sec.flags |= SEC_LEVEL;
568 }
569 goto done;
570 }
571
572 sec.enabled = 1;
573 sec.encrypt = 1;
574
575 if (group_key ? !ieee->host_mc_decrypt :
576 !(ieee->host_encrypt || ieee->host_decrypt ||
577 ieee->host_encrypt_msdu))
578 goto skip_host_crypt;
579
580 switch (ext->alg) {
581 case IW_ENCODE_ALG_WEP:
582 alg = "WEP";
583 module = "ieee80211_crypt_wep";
584 break;
585 case IW_ENCODE_ALG_TKIP:
586 alg = "TKIP";
587 module = "ieee80211_crypt_tkip";
588 break;
589 case IW_ENCODE_ALG_CCMP:
590 alg = "CCMP";
591 module = "ieee80211_crypt_ccmp";
592 break;
593 default:
594 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
595 dev->name, ext->alg);
596 ret = -EINVAL;
597 goto done;
598 }
599
600 ops = ieee80211_get_crypto_ops(alg);
601 if (ops == NULL) {
602 request_module(module);
603 ops = ieee80211_get_crypto_ops(alg);
604 }
605 if (ops == NULL) {
606 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
607 dev->name, ext->alg);
608 ret = -EINVAL;
609 goto done;
610 }
611
612 if (*crypt == NULL || (*crypt)->ops != ops) {
613 struct ieee80211_crypt_data *new_crypt;
614
615 ieee80211_crypt_delayed_deinit(ieee, crypt);
616
617 new_crypt = kzalloc(sizeof(*new_crypt), GFP_KERNEL);
618 if (new_crypt == NULL) {
619 ret = -ENOMEM;
620 goto done;
621 }
622 new_crypt->ops = ops;
623 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
624 new_crypt->priv = new_crypt->ops->init(idx);
625 if (new_crypt->priv == NULL) {
626 kfree(new_crypt);
627 ret = -EINVAL;
628 goto done;
629 }
630 *crypt = new_crypt;
631 }
632
633 if (ext->key_len > 0 && (*crypt)->ops->set_key &&
634 (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
635 (*crypt)->priv) < 0) {
636 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name);
637 ret = -EINVAL;
638 goto done;
639 }
640
641 skip_host_crypt:
642 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
643 ieee->tx_keyidx = idx;
644 sec.active_key = idx;
645 sec.flags |= SEC_ACTIVE_KEY;
646 }
647
648 if (ext->alg != IW_ENCODE_ALG_NONE) {
649 memcpy(sec.keys[idx], ext->key, ext->key_len);
650 sec.key_sizes[idx] = ext->key_len;
651 sec.flags |= (1 << idx);
652 if (ext->alg == IW_ENCODE_ALG_WEP) {
653 sec.encode_alg[idx] = SEC_ALG_WEP;
654 sec.flags |= SEC_LEVEL;
655 sec.level = SEC_LEVEL_1;
656 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
657 sec.encode_alg[idx] = SEC_ALG_TKIP;
658 sec.flags |= SEC_LEVEL;
659 sec.level = SEC_LEVEL_2;
660 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
661 sec.encode_alg[idx] = SEC_ALG_CCMP;
662 sec.flags |= SEC_LEVEL;
663 sec.level = SEC_LEVEL_3;
664 }
665 /* Don't set sec level for group keys. */
666 if (group_key)
667 sec.flags &= ~SEC_LEVEL;
668 }
669 done:
670 if (ieee->set_security)
671 ieee->set_security(ieee->dev, &sec);
672
673 /*
674 * Do not reset port if card is in Managed mode since resetting will
675 * generate new IEEE 802.11 authentication which may end up in looping
676 * with IEEE 802.1X. If your hardware requires a reset after WEP
677 * configuration (for example... Prism2), implement the reset_port in
678 * the callbacks structures used to initialize the 802.11 stack.
679 */
680 if (ieee->reset_on_keychange &&
681 ieee->iw_mode != IW_MODE_INFRA &&
682 ieee->reset_port && ieee->reset_port(dev)) {
683 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name);
684 return -EINVAL;
685 }
686
687 return ret;
688 }
689
690 int ieee80211_wx_get_encodeext(struct ieee80211_device *ieee,
691 struct iw_request_info *info,
692 union iwreq_data *wrqu, char *extra)
693 {
694 struct iw_point *encoding = &wrqu->encoding;
695 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
696 struct ieee80211_security *sec = &ieee->sec;
697 int idx, max_key_len;
698
699 max_key_len = encoding->length - sizeof(*ext);
700 if (max_key_len < 0)
701 return -EINVAL;
702
703 idx = encoding->flags & IW_ENCODE_INDEX;
704 if (idx) {
705 if (idx < 1 || idx > WEP_KEYS)
706 return -EINVAL;
707 idx--;
708 } else
709 idx = ieee->tx_keyidx;
710
711 if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
712 ext->alg != IW_ENCODE_ALG_WEP)
713 if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA)
714 return -EINVAL;
715
716 encoding->flags = idx + 1;
717 memset(ext, 0, sizeof(*ext));
718
719 if (!sec->enabled) {
720 ext->alg = IW_ENCODE_ALG_NONE;
721 ext->key_len = 0;
722 encoding->flags |= IW_ENCODE_DISABLED;
723 } else {
724 if (sec->encode_alg[idx] == SEC_ALG_WEP)
725 ext->alg = IW_ENCODE_ALG_WEP;
726 else if (sec->encode_alg[idx] == SEC_ALG_TKIP)
727 ext->alg = IW_ENCODE_ALG_TKIP;
728 else if (sec->encode_alg[idx] == SEC_ALG_CCMP)
729 ext->alg = IW_ENCODE_ALG_CCMP;
730 else
731 return -EINVAL;
732
733 ext->key_len = sec->key_sizes[idx];
734 memcpy(ext->key, sec->keys[idx], ext->key_len);
735 encoding->flags |= IW_ENCODE_ENABLED;
736 if (ext->key_len &&
737 (ext->alg == IW_ENCODE_ALG_TKIP ||
738 ext->alg == IW_ENCODE_ALG_CCMP))
739 ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
740
741 }
742
743 return 0;
744 }
745
746 int ieee80211_wx_set_auth(struct net_device *dev,
747 struct iw_request_info *info,
748 union iwreq_data *wrqu,
749 char *extra)
750 {
751 struct ieee80211_device *ieee = netdev_priv(dev);
752 unsigned long flags;
753 int err = 0;
754
755 spin_lock_irqsave(&ieee->lock, flags);
756
757 switch (wrqu->param.flags & IW_AUTH_INDEX) {
758 case IW_AUTH_WPA_VERSION:
759 case IW_AUTH_CIPHER_PAIRWISE:
760 case IW_AUTH_CIPHER_GROUP:
761 case IW_AUTH_KEY_MGMT:
762 /*
763 * Host AP driver does not use these parameters and allows
764 * wpa_supplicant to control them internally.
765 */
766 break;
767 case IW_AUTH_TKIP_COUNTERMEASURES:
768 break; /* FIXME */
769 case IW_AUTH_DROP_UNENCRYPTED:
770 ieee->drop_unencrypted = !!wrqu->param.value;
771 break;
772 case IW_AUTH_80211_AUTH_ALG:
773 break; /* FIXME */
774 case IW_AUTH_WPA_ENABLED:
775 ieee->privacy_invoked = ieee->wpa_enabled = !!wrqu->param.value;
776 break;
777 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
778 ieee->ieee802_1x = !!wrqu->param.value;
779 break;
780 case IW_AUTH_PRIVACY_INVOKED:
781 ieee->privacy_invoked = !!wrqu->param.value;
782 break;
783 default:
784 err = -EOPNOTSUPP;
785 break;
786 }
787 spin_unlock_irqrestore(&ieee->lock, flags);
788 return err;
789 }
790
791 int ieee80211_wx_get_auth(struct net_device *dev,
792 struct iw_request_info *info,
793 union iwreq_data *wrqu,
794 char *extra)
795 {
796 struct ieee80211_device *ieee = netdev_priv(dev);
797 unsigned long flags;
798 int err = 0;
799
800 spin_lock_irqsave(&ieee->lock, flags);
801
802 switch (wrqu->param.flags & IW_AUTH_INDEX) {
803 case IW_AUTH_WPA_VERSION:
804 case IW_AUTH_CIPHER_PAIRWISE:
805 case IW_AUTH_CIPHER_GROUP:
806 case IW_AUTH_KEY_MGMT:
807 case IW_AUTH_TKIP_COUNTERMEASURES: /* FIXME */
808 case IW_AUTH_80211_AUTH_ALG: /* FIXME */
809 /*
810 * Host AP driver does not use these parameters and allows
811 * wpa_supplicant to control them internally.
812 */
813 err = -EOPNOTSUPP;
814 break;
815 case IW_AUTH_DROP_UNENCRYPTED:
816 wrqu->param.value = ieee->drop_unencrypted;
817 break;
818 case IW_AUTH_WPA_ENABLED:
819 wrqu->param.value = ieee->wpa_enabled;
820 break;
821 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
822 wrqu->param.value = ieee->ieee802_1x;
823 break;
824 default:
825 err = -EOPNOTSUPP;
826 break;
827 }
828 spin_unlock_irqrestore(&ieee->lock, flags);
829 return err;
830 }
831
832 EXPORT_SYMBOL(ieee80211_wx_set_encodeext);
833 EXPORT_SYMBOL(ieee80211_wx_get_encodeext);
834
835 EXPORT_SYMBOL(ieee80211_wx_get_scan);
836 EXPORT_SYMBOL(ieee80211_wx_set_encode);
837 EXPORT_SYMBOL(ieee80211_wx_get_encode);
838
839 EXPORT_SYMBOL_GPL(ieee80211_wx_set_auth);
840 EXPORT_SYMBOL_GPL(ieee80211_wx_get_auth);
Mirror for ia64_pv_ops.git