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