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