?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] ieee80211: Fix iwlist scan can only show about 20 APs
[linux-2.6/linux-loongson.git] / net / ieee80211 / ieee80211_wx.c
blobf87c6b89f8450e513fd6c434864e7ae65b267ad0
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 <jkmaline@cc.hut.fi>
9 Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.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 *ipw2100_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 u8 max_rate, rate;
54
55 /* First entry *MUST* be the AP MAC address */
56 iwe.cmd = SIOCGIWAP;
57 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
58 memcpy(iwe.u.ap_addr.sa_data, network->bssid, ETH_ALEN);
59 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_ADDR_LEN);
60
61 /* Remaining entries will be displayed in the order we provide them */
62
63 /* Add the ESSID */
64 iwe.cmd = SIOCGIWESSID;
65 iwe.u.data.flags = 1;
66 if (network->flags & NETWORK_EMPTY_ESSID) {
67 iwe.u.data.length = sizeof("<hidden>");
68 start = iwe_stream_add_point(start, stop, &iwe, "<hidden>");
69 } else {
70 iwe.u.data.length = min(network->ssid_len, (u8) 32);
71 start = iwe_stream_add_point(start, stop, &iwe, network->ssid);
72 }
73
74 /* Add the protocol name */
75 iwe.cmd = SIOCGIWNAME;
76 snprintf(iwe.u.name, IFNAMSIZ, "IEEE 802.11%s",
77 ieee80211_modes[network->mode]);
78 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_CHAR_LEN);
79
80 /* Add mode */
81 iwe.cmd = SIOCGIWMODE;
82 if (network->capability & (WLAN_CAPABILITY_ESS | WLAN_CAPABILITY_IBSS)) {
83 if (network->capability & WLAN_CAPABILITY_ESS)
84 iwe.u.mode = IW_MODE_MASTER;
85 else
86 iwe.u.mode = IW_MODE_ADHOC;
87
88 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_UINT_LEN);
89 }
90
91 /* Add frequency/channel */
92 iwe.cmd = SIOCGIWFREQ;
93 /* iwe.u.freq.m = ieee80211_frequency(network->channel, network->mode);
94 iwe.u.freq.e = 3; */
95 iwe.u.freq.m = network->channel;
96 iwe.u.freq.e = 0;
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 max_rate = 0;
111 p = custom;
112 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
113 for (i = 0, j = 0; i < network->rates_len;) {
114 if (j < network->rates_ex_len &&
115 ((network->rates_ex[j] & 0x7F) <
116 (network->rates[i] & 0x7F)))
117 rate = network->rates_ex[j++] & 0x7F;
118 else
119 rate = network->rates[i++] & 0x7F;
120 if (rate > max_rate)
121 max_rate = rate;
122 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
123 "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
124 }
125 for (; j < network->rates_ex_len; j++) {
126 rate = network->rates_ex[j] & 0x7F;
127 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
128 "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
129 if (rate > max_rate)
130 max_rate = rate;
131 }
132
133 iwe.cmd = SIOCGIWRATE;
134 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
135 iwe.u.bitrate.value = max_rate * 500000;
136 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_PARAM_LEN);
137
138 iwe.cmd = IWEVCUSTOM;
139 iwe.u.data.length = p - custom;
140 if (iwe.u.data.length)
141 start = iwe_stream_add_point(start, stop, &iwe, custom);
142
143 /* Add quality statistics */
144 iwe.cmd = IWEVQUAL;
145 iwe.u.qual.updated = IW_QUAL_QUAL_UPDATED | IW_QUAL_LEVEL_UPDATED |
146 IW_QUAL_NOISE_UPDATED;
147
148 if (!(network->stats.mask & IEEE80211_STATMASK_RSSI)) {
149 iwe.u.qual.updated |= IW_QUAL_QUAL_INVALID |
150 IW_QUAL_LEVEL_INVALID;
151 iwe.u.qual.qual = 0;
152 iwe.u.qual.level = 0;
153 } else {
154 iwe.u.qual.level = network->stats.rssi;
155 if (ieee->perfect_rssi == ieee->worst_rssi)
156 iwe.u.qual.qual = 100;
157 else
158 iwe.u.qual.qual =
159 (100 *
160 (ieee->perfect_rssi - ieee->worst_rssi) *
161 (ieee->perfect_rssi - ieee->worst_rssi) -
162 (ieee->perfect_rssi - network->stats.rssi) *
163 (15 * (ieee->perfect_rssi - ieee->worst_rssi) +
164 62 * (ieee->perfect_rssi -
165 network->stats.rssi))) /
166 ((ieee->perfect_rssi -
167 ieee->worst_rssi) * (ieee->perfect_rssi -
168 ieee->worst_rssi));
169 if (iwe.u.qual.qual > 100)
170 iwe.u.qual.qual = 100;
171 else if (iwe.u.qual.qual < 1)
172 iwe.u.qual.qual = 0;
173 }
174
175 if (!(network->stats.mask & IEEE80211_STATMASK_NOISE)) {
176 iwe.u.qual.updated |= IW_QUAL_NOISE_INVALID;
177 iwe.u.qual.noise = 0;
178 } else {
179 iwe.u.qual.noise = network->stats.noise;
180 }
181
182 start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
183
184 iwe.cmd = IWEVCUSTOM;
185 p = custom;
186
187 iwe.u.data.length = p - custom;
188 if (iwe.u.data.length)
189 start = iwe_stream_add_point(start, stop, &iwe, custom);
190
191 if (network->wpa_ie_len) {
192 char buf[MAX_WPA_IE_LEN * 2 + 30];
193
194 u8 *p = buf;
195 p += sprintf(p, "wpa_ie=");
196 for (i = 0; i < network->wpa_ie_len; i++) {
197 p += sprintf(p, "%02x", network->wpa_ie[i]);
198 }
199
200 memset(&iwe, 0, sizeof(iwe));
201 iwe.cmd = IWEVCUSTOM;
202 iwe.u.data.length = strlen(buf);
203 start = iwe_stream_add_point(start, stop, &iwe, buf);
204 }
205
206 if (network->rsn_ie_len) {
207 char buf[MAX_WPA_IE_LEN * 2 + 30];
208
209 u8 *p = buf;
210 p += sprintf(p, "rsn_ie=");
211 for (i = 0; i < network->rsn_ie_len; i++) {
212 p += sprintf(p, "%02x", network->rsn_ie[i]);
213 }
214
215 memset(&iwe, 0, sizeof(iwe));
216 iwe.cmd = IWEVCUSTOM;
217 iwe.u.data.length = strlen(buf);
218 start = iwe_stream_add_point(start, stop, &iwe, buf);
219 }
220
221 /* Add EXTRA: Age to display seconds since last beacon/probe response
222 * for given network. */
223 iwe.cmd = IWEVCUSTOM;
224 p = custom;
225 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
226 " Last beacon: %dms ago",
227 jiffies_to_msecs(jiffies - network->last_scanned));
228 iwe.u.data.length = p - custom;
229 if (iwe.u.data.length)
230 start = iwe_stream_add_point(start, stop, &iwe, custom);
231
232 return start;
233 }
234
235 #define SCAN_ITEM_SIZE 128
236
237 int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
238 struct iw_request_info *info,
239 union iwreq_data *wrqu, char *extra)
240 {
241 struct ieee80211_network *network;
242 unsigned long flags;
243 int err = 0;
244
245 char *ev = extra;
246 char *stop = ev + wrqu->data.length;
247 int i = 0;
248
249 IEEE80211_DEBUG_WX("Getting scan\n");
250
251 spin_lock_irqsave(&ieee->lock, flags);
252
253 list_for_each_entry(network, &ieee->network_list, list) {
254 i++;
255 if (stop - ev < SCAN_ITEM_SIZE) {
256 err = -E2BIG;
257 break;
258 }
259
260 if (ieee->scan_age == 0 ||
261 time_after(network->last_scanned + ieee->scan_age, jiffies))
262 ev = ipw2100_translate_scan(ieee, ev, stop, network);
263 else
264 IEEE80211_DEBUG_SCAN("Not showing network '%s ("
265 MAC_FMT ")' due to age (%dms).\n",
266 escape_essid(network->ssid,
267 network->ssid_len),
268 MAC_ARG(network->bssid),
269 jiffies_to_msecs(jiffies -
270 network->
271 last_scanned));
272 }
273
274 spin_unlock_irqrestore(&ieee->lock, flags);
275
276 wrqu->data.length = ev - extra;
277 wrqu->data.flags = 0;
278
279 IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i);
280
281 return err;
282 }
283
284 int ieee80211_wx_set_encode(struct ieee80211_device *ieee,
285 struct iw_request_info *info,
286 union iwreq_data *wrqu, char *keybuf)
287 {
288 struct iw_point *erq = &(wrqu->encoding);
289 struct net_device *dev = ieee->dev;
290 struct ieee80211_security sec = {
291 .flags = 0
292 };
293 int i, key, key_provided, len;
294 struct ieee80211_crypt_data **crypt;
295 int host_crypto = ieee->host_encrypt || ieee->host_decrypt || ieee->host_build_iv;
296
297 IEEE80211_DEBUG_WX("SET_ENCODE\n");
298
299 key = erq->flags & IW_ENCODE_INDEX;
300 if (key) {
301 if (key > WEP_KEYS)
302 return -EINVAL;
303 key--;
304 key_provided = 1;
305 } else {
306 key_provided = 0;
307 key = ieee->tx_keyidx;
308 }
309
310 IEEE80211_DEBUG_WX("Key: %d [%s]\n", key, key_provided ?
311 "provided" : "default");
312
313 crypt = &ieee->crypt[key];
314
315 if (erq->flags & IW_ENCODE_DISABLED) {
316 if (key_provided && *crypt) {
317 IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n",
318 key);
319 ieee80211_crypt_delayed_deinit(ieee, crypt);
320 } else
321 IEEE80211_DEBUG_WX("Disabling encryption.\n");
322
323 /* Check all the keys to see if any are still configured,
324 * and if no key index was provided, de-init them all */
325 for (i = 0; i < WEP_KEYS; i++) {
326 if (ieee->crypt[i] != NULL) {
327 if (key_provided)
328 break;
329 ieee80211_crypt_delayed_deinit(ieee,
330 &ieee->crypt[i]);
331 }
332 }
333
334 if (i == WEP_KEYS) {
335 sec.enabled = 0;
336 sec.encrypt = 0;
337 sec.level = SEC_LEVEL_0;
338 sec.flags |= SEC_ENABLED | SEC_LEVEL | SEC_ENCRYPT;
339 }
340
341 goto done;
342 }
343
344 sec.enabled = 1;
345 sec.encrypt = 1;
346 sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
347
348 if (*crypt != NULL && (*crypt)->ops != NULL &&
349 strcmp((*crypt)->ops->name, "WEP") != 0) {
350 /* changing to use WEP; deinit previously used algorithm
351 * on this key */
352 ieee80211_crypt_delayed_deinit(ieee, crypt);
353 }
354
355 if (*crypt == NULL && host_crypto) {
356 struct ieee80211_crypt_data *new_crypt;
357
358 /* take WEP into use */
359 new_crypt = kmalloc(sizeof(struct ieee80211_crypt_data),
360 GFP_KERNEL);
361 if (new_crypt == NULL)
362 return -ENOMEM;
363 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
364 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
365 if (!new_crypt->ops) {
366 request_module("ieee80211_crypt_wep");
367 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
368 }
369
370 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
371 new_crypt->priv = new_crypt->ops->init(key);
372
373 if (!new_crypt->ops || !new_crypt->priv) {
374 kfree(new_crypt);
375 new_crypt = NULL;
376
377 printk(KERN_WARNING "%s: could not initialize WEP: "
378 "load module ieee80211_crypt_wep\n", dev->name);
379 return -EOPNOTSUPP;
380 }
381 *crypt = new_crypt;
382 }
383
384 /* If a new key was provided, set it up */
385 if (erq->length > 0) {
386 len = erq->length <= 5 ? 5 : 13;
387 memcpy(sec.keys[key], keybuf, erq->length);
388 if (len > erq->length)
389 memset(sec.keys[key] + erq->length, 0,
390 len - erq->length);
391 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
392 key, escape_essid(sec.keys[key], len),
393 erq->length, len);
394 sec.key_sizes[key] = len;
395 if (*crypt)
396 (*crypt)->ops->set_key(sec.keys[key], len, NULL,
397 (*crypt)->priv);
398 sec.flags |= (1 << key);
399 /* This ensures a key will be activated if no key is
400 * explicitely set */
401 if (key == sec.active_key)
402 sec.flags |= SEC_ACTIVE_KEY;
403
404 } else {
405 if (host_crypto) {
406 len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
407 NULL, (*crypt)->priv);
408 if (len == 0) {
409 /* Set a default key of all 0 */
410 IEEE80211_DEBUG_WX("Setting key %d to all "
411 "zero.\n", key);
412 memset(sec.keys[key], 0, 13);
413 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
414 (*crypt)->priv);
415 sec.key_sizes[key] = 13;
416 sec.flags |= (1 << key);
417 }
418 }
419 /* No key data - just set the default TX key index */
420 if (key_provided) {
421 IEEE80211_DEBUG_WX("Setting key %d to default Tx "
422 "key.\n", key);
423 ieee->tx_keyidx = key;
424 sec.active_key = key;
425 sec.flags |= SEC_ACTIVE_KEY;
426 }
427 }
428 if (erq->flags & (IW_ENCODE_OPEN | IW_ENCODE_RESTRICTED)) {
429 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
430 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN :
431 WLAN_AUTH_SHARED_KEY;
432 sec.flags |= SEC_AUTH_MODE;
433 IEEE80211_DEBUG_WX("Auth: %s\n",
434 sec.auth_mode == WLAN_AUTH_OPEN ?
435 "OPEN" : "SHARED KEY");
436 }
437
438 /* For now we just support WEP, so only set that security level...
439 * TODO: When WPA is added this is one place that needs to change */
440 sec.flags |= SEC_LEVEL;
441 sec.level = SEC_LEVEL_1; /* 40 and 104 bit WEP */
442 sec.encode_alg[key] = SEC_ALG_WEP;
443
444 done:
445 if (ieee->set_security)
446 ieee->set_security(dev, &sec);
447
448 /* Do not reset port if card is in Managed mode since resetting will
449 * generate new IEEE 802.11 authentication which may end up in looping
450 * with IEEE 802.1X. If your hardware requires a reset after WEP
451 * configuration (for example... Prism2), implement the reset_port in
452 * the callbacks structures used to initialize the 802.11 stack. */
453 if (ieee->reset_on_keychange &&
454 ieee->iw_mode != IW_MODE_INFRA &&
455 ieee->reset_port && ieee->reset_port(dev)) {
456 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
457 return -EINVAL;
458 }
459 return 0;
460 }
461
462 int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
463 struct iw_request_info *info,
464 union iwreq_data *wrqu, char *keybuf)
465 {
466 struct iw_point *erq = &(wrqu->encoding);
467 int len, key;
468 struct ieee80211_crypt_data *crypt;
469 struct ieee80211_security *sec = &ieee->sec;
470
471 IEEE80211_DEBUG_WX("GET_ENCODE\n");
472
473 key = erq->flags & IW_ENCODE_INDEX;
474 if (key) {
475 if (key > WEP_KEYS)
476 return -EINVAL;
477 key--;
478 } else
479 key = ieee->tx_keyidx;
480
481 crypt = ieee->crypt[key];
482 erq->flags = key + 1;
483
484 if (!sec->enabled) {
485 erq->length = 0;
486 erq->flags |= IW_ENCODE_DISABLED;
487 return 0;
488 }
489
490 len = sec->key_sizes[key];
491 memcpy(keybuf, sec->keys[key], len);
492
493 erq->length = (len >= 0 ? len : 0);
494 erq->flags |= IW_ENCODE_ENABLED;
495
496 if (ieee->open_wep)
497 erq->flags |= IW_ENCODE_OPEN;
498 else
499 erq->flags |= IW_ENCODE_RESTRICTED;
500
501 return 0;
502 }
503
504 int ieee80211_wx_set_encodeext(struct ieee80211_device *ieee,
505 struct iw_request_info *info,
506 union iwreq_data *wrqu, char *extra)
507 {
508 struct net_device *dev = ieee->dev;
509 struct iw_point *encoding = &wrqu->encoding;
510 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
511 int i, idx, ret = 0;
512 int group_key = 0;
513 const char *alg, *module;
514 struct ieee80211_crypto_ops *ops;
515 struct ieee80211_crypt_data **crypt;
516
517 struct ieee80211_security sec = {
518 .flags = 0,
519 };
520
521 idx = encoding->flags & IW_ENCODE_INDEX;
522 if (idx) {
523 if (idx < 1 || idx > WEP_KEYS)
524 return -EINVAL;
525 idx--;
526 } else
527 idx = ieee->tx_keyidx;
528
529 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
530 crypt = &ieee->crypt[idx];
531 group_key = 1;
532 } else {
533 /* some Cisco APs use idx>0 for unicast in dynamic WEP */
534 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
535 return -EINVAL;
536 if (ieee->iw_mode == IW_MODE_INFRA)
537 crypt = &ieee->crypt[idx];
538 else
539 return -EINVAL;
540 }
541
542 sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
543 if ((encoding->flags & IW_ENCODE_DISABLED) ||
544 ext->alg == IW_ENCODE_ALG_NONE) {
545 if (*crypt)
546 ieee80211_crypt_delayed_deinit(ieee, crypt);
547
548 for (i = 0; i < WEP_KEYS; i++)
549 if (ieee->crypt[i] != NULL)
550 break;
551
552 if (i == WEP_KEYS) {
553 sec.enabled = 0;
554 sec.encrypt = 0;
555 sec.level = SEC_LEVEL_0;
556 sec.flags |= SEC_LEVEL;
557 }
558 goto done;
559 }
560
561 sec.enabled = 1;
562 sec.encrypt = 1;
563
564 if (group_key ? !ieee->host_mc_decrypt :
565 !(ieee->host_encrypt || ieee->host_decrypt ||
566 ieee->host_encrypt_msdu))
567 goto skip_host_crypt;
568
569 switch (ext->alg) {
570 case IW_ENCODE_ALG_WEP:
571 alg = "WEP";
572 module = "ieee80211_crypt_wep";
573 break;
574 case IW_ENCODE_ALG_TKIP:
575 alg = "TKIP";
576 module = "ieee80211_crypt_tkip";
577 break;
578 case IW_ENCODE_ALG_CCMP:
579 alg = "CCMP";
580 module = "ieee80211_crypt_ccmp";
581 break;
582 default:
583 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
584 dev->name, ext->alg);
585 ret = -EINVAL;
586 goto done;
587 }
588
589 ops = ieee80211_get_crypto_ops(alg);
590 if (ops == NULL) {
591 request_module(module);
592 ops = ieee80211_get_crypto_ops(alg);
593 }
594 if (ops == NULL) {
595 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
596 dev->name, ext->alg);
597 ret = -EINVAL;
598 goto done;
599 }
600
601 if (*crypt == NULL || (*crypt)->ops != ops) {
602 struct ieee80211_crypt_data *new_crypt;
603
604 ieee80211_crypt_delayed_deinit(ieee, crypt);
605
606 new_crypt = (struct ieee80211_crypt_data *)
607 kmalloc(sizeof(*new_crypt), GFP_KERNEL);
608 if (new_crypt == NULL) {
609 ret = -ENOMEM;
610 goto done;
611 }
612 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
613 new_crypt->ops = ops;
614 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
615 new_crypt->priv = new_crypt->ops->init(idx);
616 if (new_crypt->priv == NULL) {
617 kfree(new_crypt);
618 ret = -EINVAL;
619 goto done;
620 }
621 *crypt = new_crypt;
622 }
623
624 if (ext->key_len > 0 && (*crypt)->ops->set_key &&
625 (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
626 (*crypt)->priv) < 0) {
627 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name);
628 ret = -EINVAL;
629 goto done;
630 }
631
632 skip_host_crypt:
633 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
634 ieee->tx_keyidx = idx;
635 sec.active_key = idx;
636 sec.flags |= SEC_ACTIVE_KEY;
637 }
638
639 if (ext->alg != IW_ENCODE_ALG_NONE) {
640 memcpy(sec.keys[idx], ext->key, ext->key_len);
641 sec.key_sizes[idx] = ext->key_len;
642 sec.flags |= (1 << idx);
643 if (ext->alg == IW_ENCODE_ALG_WEP) {
644 sec.encode_alg[idx] = SEC_ALG_WEP;
645 sec.flags |= SEC_LEVEL;
646 sec.level = SEC_LEVEL_1;
647 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
648 sec.encode_alg[idx] = SEC_ALG_TKIP;
649 sec.flags |= SEC_LEVEL;
650 sec.level = SEC_LEVEL_2;
651 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
652 sec.encode_alg[idx] = SEC_ALG_CCMP;
653 sec.flags |= SEC_LEVEL;
654 sec.level = SEC_LEVEL_3;
655 }
656 /* Don't set sec level for group keys. */
657 if (group_key)
658 sec.flags &= ~SEC_LEVEL;
659 }
660 done:
661 if (ieee->set_security)
662 ieee->set_security(ieee->dev, &sec);
663
664 /*
665 * Do not reset port if card is in Managed mode since resetting will
666 * generate new IEEE 802.11 authentication which may end up in looping
667 * with IEEE 802.1X. If your hardware requires a reset after WEP
668 * configuration (for example... Prism2), implement the reset_port in
669 * the callbacks structures used to initialize the 802.11 stack.
670 */
671 if (ieee->reset_on_keychange &&
672 ieee->iw_mode != IW_MODE_INFRA &&
673 ieee->reset_port && ieee->reset_port(dev)) {
674 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name);
675 return -EINVAL;
676 }
677
678 return ret;
679 }
680
681 int ieee80211_wx_get_encodeext(struct ieee80211_device *ieee,
682 struct iw_request_info *info,
683 union iwreq_data *wrqu, char *extra)
684 {
685 struct iw_point *encoding = &wrqu->encoding;
686 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
687 struct ieee80211_security *sec = &ieee->sec;
688 int idx, max_key_len;
689
690 max_key_len = encoding->length - sizeof(*ext);
691 if (max_key_len < 0)
692 return -EINVAL;
693
694 idx = encoding->flags & IW_ENCODE_INDEX;
695 if (idx) {
696 if (idx < 1 || idx > WEP_KEYS)
697 return -EINVAL;
698 idx--;
699 } else
700 idx = ieee->tx_keyidx;
701
702 if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
703 ext->alg != IW_ENCODE_ALG_WEP)
704 if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA)
705 return -EINVAL;
706
707 encoding->flags = idx + 1;
708 memset(ext, 0, sizeof(*ext));
709
710 if (!sec->enabled) {
711 ext->alg = IW_ENCODE_ALG_NONE;
712 ext->key_len = 0;
713 encoding->flags |= IW_ENCODE_DISABLED;
714 } else {
715 if (sec->encode_alg[idx] == SEC_ALG_WEP)
716 ext->alg = IW_ENCODE_ALG_WEP;
717 else if (sec->encode_alg[idx] == SEC_ALG_TKIP)
718 ext->alg = IW_ENCODE_ALG_TKIP;
719 else if (sec->encode_alg[idx] == SEC_ALG_CCMP)
720 ext->alg = IW_ENCODE_ALG_CCMP;
721 else
722 return -EINVAL;
723
724 ext->key_len = sec->key_sizes[idx];
725 memcpy(ext->key, sec->keys[idx], ext->key_len);
726 encoding->flags |= IW_ENCODE_ENABLED;
727 if (ext->key_len &&
728 (ext->alg == IW_ENCODE_ALG_TKIP ||
729 ext->alg == IW_ENCODE_ALG_CCMP))
730 ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
731
732 }
733
734 return 0;
735 }
736
737 EXPORT_SYMBOL(ieee80211_wx_set_encodeext);
738 EXPORT_SYMBOL(ieee80211_wx_get_encodeext);
739
740 EXPORT_SYMBOL(ieee80211_wx_get_scan);
741 EXPORT_SYMBOL(ieee80211_wx_set_encode);
742 EXPORT_SYMBOL(ieee80211_wx_get_encode);
linux kernel for loongson