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