Merge master.kernel.org:/pub/scm/linux/kernel/git/sridhar/lksctp-2.6
[linux-2.6] / net / ieee80211 / ieee80211_wx.c
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 inline 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 - network->stats.rssi))) /
165                             ((ieee->perfect_rssi - ieee->worst_rssi) *
166                              (ieee->perfect_rssi - 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         start = iwe_stream_add_event(start, stop, &iwe, IW_EV_QUAL_LEN);
181
182         iwe.cmd = IWEVCUSTOM;
183         p = custom;
184
185         iwe.u.data.length = p - custom;
186         if (iwe.u.data.length)
187                 start = iwe_stream_add_point(start, stop, &iwe, custom);
188
189         if (network->wpa_ie_len) {
190                 char buf[MAX_WPA_IE_LEN * 2 + 30];
191
192                 u8 *p = buf;
193                 p += sprintf(p, "wpa_ie=");
194                 for (i = 0; i < network->wpa_ie_len; i++) {
195                         p += sprintf(p, "%02x", network->wpa_ie[i]);
196                 }
197
198                 memset(&iwe, 0, sizeof(iwe));
199                 iwe.cmd = IWEVCUSTOM;
200                 iwe.u.data.length = strlen(buf);
201                 start = iwe_stream_add_point(start, stop, &iwe, buf);
202         }
203
204         if (network->rsn_ie_len) {
205                 char buf[MAX_WPA_IE_LEN * 2 + 30];
206
207                 u8 *p = buf;
208                 p += sprintf(p, "rsn_ie=");
209                 for (i = 0; i < network->rsn_ie_len; i++) {
210                         p += sprintf(p, "%02x", network->rsn_ie[i]);
211                 }
212
213                 memset(&iwe, 0, sizeof(iwe));
214                 iwe.cmd = IWEVCUSTOM;
215                 iwe.u.data.length = strlen(buf);
216                 start = iwe_stream_add_point(start, stop, &iwe, buf);
217         }
218
219         /* Add EXTRA: Age to display seconds since last beacon/probe response
220          * for given network. */
221         iwe.cmd = IWEVCUSTOM;
222         p = custom;
223         p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
224                       " Last beacon: %dms ago",
225                       jiffies_to_msecs(jiffies - network->last_scanned));
226         iwe.u.data.length = p - custom;
227         if (iwe.u.data.length)
228                 start = iwe_stream_add_point(start, stop, &iwe, custom);
229
230         return start;
231 }
232
233 int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
234                           struct iw_request_info *info,
235                           union iwreq_data *wrqu, char *extra)
236 {
237         struct ieee80211_network *network;
238         unsigned long flags;
239
240         char *ev = extra;
241         char *stop = ev + IW_SCAN_MAX_DATA;
242         int i = 0;
243
244         IEEE80211_DEBUG_WX("Getting scan\n");
245
246         spin_lock_irqsave(&ieee->lock, flags);
247
248         list_for_each_entry(network, &ieee->network_list, list) {
249                 i++;
250                 if (ieee->scan_age == 0 ||
251                     time_after(network->last_scanned + ieee->scan_age, jiffies))
252                         ev = ipw2100_translate_scan(ieee, ev, stop, network);
253                 else
254                         IEEE80211_DEBUG_SCAN("Not showing network '%s ("
255                                              MAC_FMT ")' due to age (%dms).\n",
256                                              escape_essid(network->ssid,
257                                                           network->ssid_len),
258                                              MAC_ARG(network->bssid),
259                                              jiffies_to_msecs(jiffies -
260                                                               network->
261                                                               last_scanned));
262         }
263
264         spin_unlock_irqrestore(&ieee->lock, flags);
265
266         wrqu->data.length = ev - extra;
267         wrqu->data.flags = 0;
268
269         IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i);
270
271         return 0;
272 }
273
274 int ieee80211_wx_set_encode(struct ieee80211_device *ieee,
275                             struct iw_request_info *info,
276                             union iwreq_data *wrqu, char *keybuf)
277 {
278         struct iw_point *erq = &(wrqu->encoding);
279         struct net_device *dev = ieee->dev;
280         struct ieee80211_security sec = {
281                 .flags = 0
282         };
283         int i, key, key_provided, len;
284         struct ieee80211_crypt_data **crypt;
285         int host_crypto = ieee->host_encrypt || ieee->host_decrypt;
286
287         IEEE80211_DEBUG_WX("SET_ENCODE\n");
288
289         key = erq->flags & IW_ENCODE_INDEX;
290         if (key) {
291                 if (key > WEP_KEYS)
292                         return -EINVAL;
293                 key--;
294                 key_provided = 1;
295         } else {
296                 key_provided = 0;
297                 key = ieee->tx_keyidx;
298         }
299
300         IEEE80211_DEBUG_WX("Key: %d [%s]\n", key, key_provided ?
301                            "provided" : "default");
302
303         crypt = &ieee->crypt[key];
304
305         if (erq->flags & IW_ENCODE_DISABLED) {
306                 if (key_provided && *crypt) {
307                         IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n",
308                                            key);
309                         ieee80211_crypt_delayed_deinit(ieee, crypt);
310                 } else
311                         IEEE80211_DEBUG_WX("Disabling encryption.\n");
312
313                 /* Check all the keys to see if any are still configured,
314                  * and if no key index was provided, de-init them all */
315                 for (i = 0; i < WEP_KEYS; i++) {
316                         if (ieee->crypt[i] != NULL) {
317                                 if (key_provided)
318                                         break;
319                                 ieee80211_crypt_delayed_deinit(ieee,
320                                                                &ieee->crypt[i]);
321                         }
322                 }
323
324                 if (i == WEP_KEYS) {
325                         sec.enabled = 0;
326                         sec.encrypt = 0;
327                         sec.level = SEC_LEVEL_0;
328                         sec.flags |= SEC_ENABLED | SEC_LEVEL | SEC_ENCRYPT;
329                 }
330
331                 goto done;
332         }
333
334         sec.enabled = 1;
335         sec.encrypt = 1;
336         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
337
338         if (*crypt != NULL && (*crypt)->ops != NULL &&
339             strcmp((*crypt)->ops->name, "WEP") != 0) {
340                 /* changing to use WEP; deinit previously used algorithm
341                  * on this key */
342                 ieee80211_crypt_delayed_deinit(ieee, crypt);
343         }
344
345         if (*crypt == NULL && host_crypto) {
346                 struct ieee80211_crypt_data *new_crypt;
347
348                 /* take WEP into use */
349                 new_crypt = kmalloc(sizeof(struct ieee80211_crypt_data),
350                                     GFP_KERNEL);
351                 if (new_crypt == NULL)
352                         return -ENOMEM;
353                 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
354                 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
355                 if (!new_crypt->ops) {
356                         request_module("ieee80211_crypt_wep");
357                         new_crypt->ops = ieee80211_get_crypto_ops("WEP");
358                 }
359
360                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
361                         new_crypt->priv = new_crypt->ops->init(key);
362
363                 if (!new_crypt->ops || !new_crypt->priv) {
364                         kfree(new_crypt);
365                         new_crypt = NULL;
366
367                         printk(KERN_WARNING "%s: could not initialize WEP: "
368                                "load module ieee80211_crypt_wep\n", dev->name);
369                         return -EOPNOTSUPP;
370                 }
371                 *crypt = new_crypt;
372         }
373
374         /* If a new key was provided, set it up */
375         if (erq->length > 0) {
376                 len = erq->length <= 5 ? 5 : 13;
377                 memcpy(sec.keys[key], keybuf, erq->length);
378                 if (len > erq->length)
379                         memset(sec.keys[key] + erq->length, 0,
380                                len - erq->length);
381                 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
382                                    key, escape_essid(sec.keys[key], len),
383                                    erq->length, len);
384                 sec.key_sizes[key] = len;
385                 if (*crypt)
386                         (*crypt)->ops->set_key(sec.keys[key], len, NULL,
387                                                (*crypt)->priv);
388                 sec.flags |= (1 << key);
389                 /* This ensures a key will be activated if no key is
390                  * explicitely set */
391                 if (key == sec.active_key)
392                         sec.flags |= SEC_ACTIVE_KEY;
393
394         } else {
395                 if (host_crypto) {
396                         len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
397                                                      NULL, (*crypt)->priv);
398                         if (len == 0) {
399                                 /* Set a default key of all 0 */
400                                 IEEE80211_DEBUG_WX("Setting key %d to all "
401                                                    "zero.\n", key);
402                                 memset(sec.keys[key], 0, 13);
403                                 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
404                                                        (*crypt)->priv);
405                                 sec.key_sizes[key] = 13;
406                                 sec.flags |= (1 << key);
407                         }
408                 }
409                 /* No key data - just set the default TX key index */
410                 if (key_provided) {
411                         IEEE80211_DEBUG_WX("Setting key %d to default Tx "
412                                            "key.\n", key);
413                         ieee->tx_keyidx = key;
414                         sec.active_key = key;
415                         sec.flags |= SEC_ACTIVE_KEY;
416                 }
417         }
418         if (erq->flags & (IW_ENCODE_OPEN | IW_ENCODE_RESTRICTED)) {
419                 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
420                 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN :
421                     WLAN_AUTH_SHARED_KEY;
422                 sec.flags |= SEC_AUTH_MODE;
423                 IEEE80211_DEBUG_WX("Auth: %s\n",
424                                    sec.auth_mode == WLAN_AUTH_OPEN ?
425                                    "OPEN" : "SHARED KEY");
426         }
427
428         /* For now we just support WEP, so only set that security level...
429          * TODO: When WPA is added this is one place that needs to change */
430         sec.flags |= SEC_LEVEL;
431         sec.level = SEC_LEVEL_1;        /* 40 and 104 bit WEP */
432         sec.encode_alg[key] = SEC_ALG_WEP;
433
434       done:
435         if (ieee->set_security)
436                 ieee->set_security(dev, &sec);
437
438         /* Do not reset port if card is in Managed mode since resetting will
439          * generate new IEEE 802.11 authentication which may end up in looping
440          * with IEEE 802.1X.  If your hardware requires a reset after WEP
441          * configuration (for example... Prism2), implement the reset_port in
442          * the callbacks structures used to initialize the 802.11 stack. */
443         if (ieee->reset_on_keychange &&
444             ieee->iw_mode != IW_MODE_INFRA &&
445             ieee->reset_port && ieee->reset_port(dev)) {
446                 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
447                 return -EINVAL;
448         }
449         return 0;
450 }
451
452 int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
453                             struct iw_request_info *info,
454                             union iwreq_data *wrqu, char *keybuf)
455 {
456         struct iw_point *erq = &(wrqu->encoding);
457         int len, key;
458         struct ieee80211_crypt_data *crypt;
459         struct ieee80211_security *sec = &ieee->sec;
460
461         IEEE80211_DEBUG_WX("GET_ENCODE\n");
462
463         key = erq->flags & IW_ENCODE_INDEX;
464         if (key) {
465                 if (key > WEP_KEYS)
466                         return -EINVAL;
467                 key--;
468         } else
469                 key = ieee->tx_keyidx;
470
471         crypt = ieee->crypt[key];
472         erq->flags = key + 1;
473
474         if (!sec->enabled) {
475                 erq->length = 0;
476                 erq->flags |= IW_ENCODE_DISABLED;
477                 return 0;
478         }
479
480         len = sec->key_sizes[key];
481         memcpy(keybuf, sec->keys[key], len);
482
483         erq->length = (len >= 0 ? len : 0);
484         erq->flags |= IW_ENCODE_ENABLED;
485
486         if (ieee->open_wep)
487                 erq->flags |= IW_ENCODE_OPEN;
488         else
489                 erq->flags |= IW_ENCODE_RESTRICTED;
490
491         return 0;
492 }
493
494 int ieee80211_wx_set_encodeext(struct ieee80211_device *ieee,
495                                struct iw_request_info *info,
496                                union iwreq_data *wrqu, char *extra)
497 {
498         struct net_device *dev = ieee->dev;
499         struct iw_point *encoding = &wrqu->encoding;
500         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
501         int i, idx, ret = 0;
502         int group_key = 0;
503         const char *alg, *module;
504         struct ieee80211_crypto_ops *ops;
505         struct ieee80211_crypt_data **crypt;
506
507         struct ieee80211_security sec = {
508                 .flags = 0,
509         };
510
511         idx = encoding->flags & IW_ENCODE_INDEX;
512         if (idx) {
513                 if (idx < 1 || idx > WEP_KEYS)
514                         return -EINVAL;
515                 idx--;
516         } else
517                 idx = ieee->tx_keyidx;
518
519         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
520                 crypt = &ieee->crypt[idx];
521                 group_key = 1;
522         } else {
523                 if (idx != 0)
524                         return -EINVAL;
525                 if (ieee->iw_mode == IW_MODE_INFRA)
526                         crypt = &ieee->crypt[idx];
527                 else
528                         return -EINVAL;
529         }
530
531         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
532         if ((encoding->flags & IW_ENCODE_DISABLED) ||
533             ext->alg == IW_ENCODE_ALG_NONE) {
534                 if (*crypt)
535                         ieee80211_crypt_delayed_deinit(ieee, crypt);
536
537                 for (i = 0; i < WEP_KEYS; i++)
538                         if (ieee->crypt[i] != NULL)
539                                 break;
540
541                 if (i == WEP_KEYS) {
542                         sec.enabled = 0;
543                         sec.encrypt = 0;
544                         sec.level = SEC_LEVEL_0;
545                         sec.flags |= SEC_LEVEL;
546                 }
547                 goto done;
548         }
549
550         sec.enabled = 1;
551         sec.encrypt = 1;
552
553         if (group_key ? !ieee->host_mc_decrypt :
554             !(ieee->host_encrypt || ieee->host_decrypt ||
555               ieee->host_encrypt_msdu))
556                 goto skip_host_crypt;
557
558         switch (ext->alg) {
559         case IW_ENCODE_ALG_WEP:
560                 alg = "WEP";
561                 module = "ieee80211_crypt_wep";
562                 break;
563         case IW_ENCODE_ALG_TKIP:
564                 alg = "TKIP";
565                 module = "ieee80211_crypt_tkip";
566                 break;
567         case IW_ENCODE_ALG_CCMP:
568                 alg = "CCMP";
569                 module = "ieee80211_crypt_ccmp";
570                 break;
571         default:
572                 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
573                                    dev->name, ext->alg);
574                 ret = -EINVAL;
575                 goto done;
576         }
577
578         ops = ieee80211_get_crypto_ops(alg);
579         if (ops == NULL) {
580                 request_module(module);
581                 ops = ieee80211_get_crypto_ops(alg);
582         }
583         if (ops == NULL) {
584                 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
585                                    dev->name, ext->alg);
586                 ret = -EINVAL;
587                 goto done;
588         }
589
590         if (*crypt == NULL || (*crypt)->ops != ops) {
591                 struct ieee80211_crypt_data *new_crypt;
592
593                 ieee80211_crypt_delayed_deinit(ieee, crypt);
594
595                 new_crypt = (struct ieee80211_crypt_data *)
596                     kmalloc(sizeof(*new_crypt), GFP_KERNEL);
597                 if (new_crypt == NULL) {
598                         ret = -ENOMEM;
599                         goto done;
600                 }
601                 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
602                 new_crypt->ops = ops;
603                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
604                         new_crypt->priv = new_crypt->ops->init(idx);
605                 if (new_crypt->priv == NULL) {
606                         kfree(new_crypt);
607                         ret = -EINVAL;
608                         goto done;
609                 }
610                 *crypt = new_crypt;
611         }
612
613         if (ext->key_len > 0 && (*crypt)->ops->set_key &&
614             (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
615                                    (*crypt)->priv) < 0) {
616                 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name);
617                 ret = -EINVAL;
618                 goto done;
619         }
620
621       skip_host_crypt:
622         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
623                 ieee->tx_keyidx = idx;
624                 sec.active_key = idx;
625                 sec.flags |= SEC_ACTIVE_KEY;
626         }
627
628         if (ext->alg != IW_ENCODE_ALG_NONE) {
629                 memcpy(sec.keys[idx], ext->key, ext->key_len);
630                 sec.key_sizes[idx] = ext->key_len;
631                 sec.flags |= (1 << idx);
632                 if (ext->alg == IW_ENCODE_ALG_WEP) {
633                         sec.encode_alg[idx] = SEC_ALG_WEP;
634                         sec.flags |= SEC_LEVEL;
635                         sec.level = SEC_LEVEL_1;
636                 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
637                         sec.encode_alg[idx] = SEC_ALG_TKIP;
638                         sec.flags |= SEC_LEVEL;
639                         sec.level = SEC_LEVEL_2;
640                 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
641                         sec.encode_alg[idx] = SEC_ALG_CCMP;
642                         sec.flags |= SEC_LEVEL;
643                         sec.level = SEC_LEVEL_3;
644                 }
645                 /* Don't set sec level for group keys. */
646                 if (group_key)
647                         sec.flags &= ~SEC_LEVEL;
648         }
649       done:
650         if (ieee->set_security)
651                 ieee->set_security(ieee->dev, &sec);
652
653         /*
654          * Do not reset port if card is in Managed mode since resetting will
655          * generate new IEEE 802.11 authentication which may end up in looping
656          * with IEEE 802.1X. If your hardware requires a reset after WEP
657          * configuration (for example... Prism2), implement the reset_port in
658          * the callbacks structures used to initialize the 802.11 stack.
659          */
660         if (ieee->reset_on_keychange &&
661             ieee->iw_mode != IW_MODE_INFRA &&
662             ieee->reset_port && ieee->reset_port(dev)) {
663                 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name);
664                 return -EINVAL;
665         }
666
667         return ret;
668 }
669
670 int ieee80211_wx_get_encodeext(struct ieee80211_device *ieee,
671                                struct iw_request_info *info,
672                                union iwreq_data *wrqu, char *extra)
673 {
674         struct iw_point *encoding = &wrqu->encoding;
675         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
676         struct ieee80211_security *sec = &ieee->sec;
677         int idx, max_key_len;
678
679         max_key_len = encoding->length - sizeof(*ext);
680         if (max_key_len < 0)
681                 return -EINVAL;
682
683         idx = encoding->flags & IW_ENCODE_INDEX;
684         if (idx) {
685                 if (idx < 1 || idx > WEP_KEYS)
686                         return -EINVAL;
687                 idx--;
688         } else
689                 idx = ieee->tx_keyidx;
690
691         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY)
692                 if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA)
693                         return -EINVAL;
694
695         encoding->flags = idx + 1;
696         memset(ext, 0, sizeof(*ext));
697
698         if (!sec->enabled) {
699                 ext->alg = IW_ENCODE_ALG_NONE;
700                 ext->key_len = 0;
701                 encoding->flags |= IW_ENCODE_DISABLED;
702         } else {
703                 if (sec->encode_alg[idx] == SEC_ALG_WEP)
704                         ext->alg = IW_ENCODE_ALG_WEP;
705                 else if (sec->encode_alg[idx] == SEC_ALG_TKIP)
706                         ext->alg = IW_ENCODE_ALG_TKIP;
707                 else if (sec->encode_alg[idx] == SEC_ALG_CCMP)
708                         ext->alg = IW_ENCODE_ALG_CCMP;
709                 else
710                         return -EINVAL;
711
712                 ext->key_len = sec->key_sizes[idx];
713                 memcpy(ext->key, sec->keys[idx], ext->key_len);
714                 encoding->flags |= IW_ENCODE_ENABLED;
715                 if (ext->key_len &&
716                     (ext->alg == IW_ENCODE_ALG_TKIP ||
717                      ext->alg == IW_ENCODE_ALG_CCMP))
718                         ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
719
720         }
721
722         return 0;
723 }
724
725 EXPORT_SYMBOL(ieee80211_wx_set_encodeext);
726 EXPORT_SYMBOL(ieee80211_wx_get_encodeext);
727
728 EXPORT_SYMBOL(ieee80211_wx_get_scan);
729 EXPORT_SYMBOL(ieee80211_wx_set_encode);
730 EXPORT_SYMBOL(ieee80211_wx_get_encode);