Merge master.kernel.org:/pub/scm/linux/kernel/git/davej/cpufreq
[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 = kzalloc(sizeof(struct ieee80211_crypt_data),
373                                     GFP_KERNEL);
374                 if (new_crypt == NULL)
375                         return -ENOMEM;
376                 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
377                 if (!new_crypt->ops) {
378                         request_module("ieee80211_crypt_wep");
379                         new_crypt->ops = ieee80211_get_crypto_ops("WEP");
380                 }
381
382                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
383                         new_crypt->priv = new_crypt->ops->init(key);
384
385                 if (!new_crypt->ops || !new_crypt->priv) {
386                         kfree(new_crypt);
387                         new_crypt = NULL;
388
389                         printk(KERN_WARNING "%s: could not initialize WEP: "
390                                "load module ieee80211_crypt_wep\n", dev->name);
391                         return -EOPNOTSUPP;
392                 }
393                 *crypt = new_crypt;
394         }
395
396         /* If a new key was provided, set it up */
397         if (erq->length > 0) {
398                 len = erq->length <= 5 ? 5 : 13;
399                 memcpy(sec.keys[key], keybuf, erq->length);
400                 if (len > erq->length)
401                         memset(sec.keys[key] + erq->length, 0,
402                                len - erq->length);
403                 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
404                                    key, escape_essid(sec.keys[key], len),
405                                    erq->length, len);
406                 sec.key_sizes[key] = len;
407                 if (*crypt)
408                         (*crypt)->ops->set_key(sec.keys[key], len, NULL,
409                                                (*crypt)->priv);
410                 sec.flags |= (1 << key);
411                 /* This ensures a key will be activated if no key is
412                  * explicitely set */
413                 if (key == sec.active_key)
414                         sec.flags |= SEC_ACTIVE_KEY;
415
416         } else {
417                 if (host_crypto) {
418                         len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
419                                                      NULL, (*crypt)->priv);
420                         if (len == 0) {
421                                 /* Set a default key of all 0 */
422                                 IEEE80211_DEBUG_WX("Setting key %d to all "
423                                                    "zero.\n", key);
424                                 memset(sec.keys[key], 0, 13);
425                                 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
426                                                        (*crypt)->priv);
427                                 sec.key_sizes[key] = 13;
428                                 sec.flags |= (1 << key);
429                         }
430                 }
431                 /* No key data - just set the default TX key index */
432                 if (key_provided) {
433                         IEEE80211_DEBUG_WX("Setting key %d to default Tx "
434                                            "key.\n", key);
435                         ieee->tx_keyidx = key;
436                         sec.active_key = key;
437                         sec.flags |= SEC_ACTIVE_KEY;
438                 }
439         }
440         if (erq->flags & (IW_ENCODE_OPEN | IW_ENCODE_RESTRICTED)) {
441                 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
442                 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN :
443                     WLAN_AUTH_SHARED_KEY;
444                 sec.flags |= SEC_AUTH_MODE;
445                 IEEE80211_DEBUG_WX("Auth: %s\n",
446                                    sec.auth_mode == WLAN_AUTH_OPEN ?
447                                    "OPEN" : "SHARED KEY");
448         }
449
450         /* For now we just support WEP, so only set that security level...
451          * TODO: When WPA is added this is one place that needs to change */
452         sec.flags |= SEC_LEVEL;
453         sec.level = SEC_LEVEL_1;        /* 40 and 104 bit WEP */
454         sec.encode_alg[key] = SEC_ALG_WEP;
455
456       done:
457         if (ieee->set_security)
458                 ieee->set_security(dev, &sec);
459
460         /* Do not reset port if card is in Managed mode since resetting will
461          * generate new IEEE 802.11 authentication which may end up in looping
462          * with IEEE 802.1X.  If your hardware requires a reset after WEP
463          * configuration (for example... Prism2), implement the reset_port in
464          * the callbacks structures used to initialize the 802.11 stack. */
465         if (ieee->reset_on_keychange &&
466             ieee->iw_mode != IW_MODE_INFRA &&
467             ieee->reset_port && ieee->reset_port(dev)) {
468                 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
469                 return -EINVAL;
470         }
471         return 0;
472 }
473
474 int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
475                             struct iw_request_info *info,
476                             union iwreq_data *wrqu, char *keybuf)
477 {
478         struct iw_point *erq = &(wrqu->encoding);
479         int len, key;
480         struct ieee80211_crypt_data *crypt;
481         struct ieee80211_security *sec = &ieee->sec;
482
483         IEEE80211_DEBUG_WX("GET_ENCODE\n");
484
485         key = erq->flags & IW_ENCODE_INDEX;
486         if (key) {
487                 if (key > WEP_KEYS)
488                         return -EINVAL;
489                 key--;
490         } else
491                 key = ieee->tx_keyidx;
492
493         crypt = ieee->crypt[key];
494         erq->flags = key + 1;
495
496         if (!sec->enabled) {
497                 erq->length = 0;
498                 erq->flags |= IW_ENCODE_DISABLED;
499                 return 0;
500         }
501
502         len = sec->key_sizes[key];
503         memcpy(keybuf, sec->keys[key], len);
504
505         erq->length = len;
506         erq->flags |= IW_ENCODE_ENABLED;
507
508         if (ieee->open_wep)
509                 erq->flags |= IW_ENCODE_OPEN;
510         else
511                 erq->flags |= IW_ENCODE_RESTRICTED;
512
513         return 0;
514 }
515
516 int ieee80211_wx_set_encodeext(struct ieee80211_device *ieee,
517                                struct iw_request_info *info,
518                                union iwreq_data *wrqu, char *extra)
519 {
520         struct net_device *dev = ieee->dev;
521         struct iw_point *encoding = &wrqu->encoding;
522         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
523         int i, idx, ret = 0;
524         int group_key = 0;
525         const char *alg, *module;
526         struct ieee80211_crypto_ops *ops;
527         struct ieee80211_crypt_data **crypt;
528
529         struct ieee80211_security sec = {
530                 .flags = 0,
531         };
532
533         idx = encoding->flags & IW_ENCODE_INDEX;
534         if (idx) {
535                 if (idx < 1 || idx > WEP_KEYS)
536                         return -EINVAL;
537                 idx--;
538         } else
539                 idx = ieee->tx_keyidx;
540
541         if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
542                 crypt = &ieee->crypt[idx];
543                 group_key = 1;
544         } else {
545                 /* some Cisco APs use idx>0 for unicast in dynamic WEP */
546                 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
547                         return -EINVAL;
548                 if (ieee->iw_mode == IW_MODE_INFRA)
549                         crypt = &ieee->crypt[idx];
550                 else
551                         return -EINVAL;
552         }
553
554         sec.flags |= SEC_ENABLED | SEC_ENCRYPT;
555         if ((encoding->flags & IW_ENCODE_DISABLED) ||
556             ext->alg == IW_ENCODE_ALG_NONE) {
557                 if (*crypt)
558                         ieee80211_crypt_delayed_deinit(ieee, crypt);
559
560                 for (i = 0; i < WEP_KEYS; i++)
561                         if (ieee->crypt[i] != NULL)
562                                 break;
563
564                 if (i == WEP_KEYS) {
565                         sec.enabled = 0;
566                         sec.encrypt = 0;
567                         sec.level = SEC_LEVEL_0;
568                         sec.flags |= SEC_LEVEL;
569                 }
570                 goto done;
571         }
572
573         sec.enabled = 1;
574         sec.encrypt = 1;
575
576         if (group_key ? !ieee->host_mc_decrypt :
577             !(ieee->host_encrypt || ieee->host_decrypt ||
578               ieee->host_encrypt_msdu))
579                 goto skip_host_crypt;
580
581         switch (ext->alg) {
582         case IW_ENCODE_ALG_WEP:
583                 alg = "WEP";
584                 module = "ieee80211_crypt_wep";
585                 break;
586         case IW_ENCODE_ALG_TKIP:
587                 alg = "TKIP";
588                 module = "ieee80211_crypt_tkip";
589                 break;
590         case IW_ENCODE_ALG_CCMP:
591                 alg = "CCMP";
592                 module = "ieee80211_crypt_ccmp";
593                 break;
594         default:
595                 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
596                                    dev->name, ext->alg);
597                 ret = -EINVAL;
598                 goto done;
599         }
600
601         ops = ieee80211_get_crypto_ops(alg);
602         if (ops == NULL) {
603                 request_module(module);
604                 ops = ieee80211_get_crypto_ops(alg);
605         }
606         if (ops == NULL) {
607                 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
608                                    dev->name, ext->alg);
609                 ret = -EINVAL;
610                 goto done;
611         }
612
613         if (*crypt == NULL || (*crypt)->ops != ops) {
614                 struct ieee80211_crypt_data *new_crypt;
615
616                 ieee80211_crypt_delayed_deinit(ieee, crypt);
617
618                 new_crypt = kzalloc(sizeof(*new_crypt), GFP_KERNEL);
619                 if (new_crypt == NULL) {
620                         ret = -ENOMEM;
621                         goto done;
622                 }
623                 new_crypt->ops = ops;
624                 if (new_crypt->ops && try_module_get(new_crypt->ops->owner))
625                         new_crypt->priv = new_crypt->ops->init(idx);
626                 if (new_crypt->priv == NULL) {
627                         kfree(new_crypt);
628                         ret = -EINVAL;
629                         goto done;
630                 }
631                 *crypt = new_crypt;
632         }
633
634         if (ext->key_len > 0 && (*crypt)->ops->set_key &&
635             (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
636                                    (*crypt)->priv) < 0) {
637                 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name);
638                 ret = -EINVAL;
639                 goto done;
640         }
641
642       skip_host_crypt:
643         if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
644                 ieee->tx_keyidx = idx;
645                 sec.active_key = idx;
646                 sec.flags |= SEC_ACTIVE_KEY;
647         }
648
649         if (ext->alg != IW_ENCODE_ALG_NONE) {
650                 memcpy(sec.keys[idx], ext->key, ext->key_len);
651                 sec.key_sizes[idx] = ext->key_len;
652                 sec.flags |= (1 << idx);
653                 if (ext->alg == IW_ENCODE_ALG_WEP) {
654                         sec.encode_alg[idx] = SEC_ALG_WEP;
655                         sec.flags |= SEC_LEVEL;
656                         sec.level = SEC_LEVEL_1;
657                 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
658                         sec.encode_alg[idx] = SEC_ALG_TKIP;
659                         sec.flags |= SEC_LEVEL;
660                         sec.level = SEC_LEVEL_2;
661                 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
662                         sec.encode_alg[idx] = SEC_ALG_CCMP;
663                         sec.flags |= SEC_LEVEL;
664                         sec.level = SEC_LEVEL_3;
665                 }
666                 /* Don't set sec level for group keys. */
667                 if (group_key)
668                         sec.flags &= ~SEC_LEVEL;
669         }
670       done:
671         if (ieee->set_security)
672                 ieee->set_security(ieee->dev, &sec);
673
674         /*
675          * Do not reset port if card is in Managed mode since resetting will
676          * generate new IEEE 802.11 authentication which may end up in looping
677          * with IEEE 802.1X. If your hardware requires a reset after WEP
678          * configuration (for example... Prism2), implement the reset_port in
679          * the callbacks structures used to initialize the 802.11 stack.
680          */
681         if (ieee->reset_on_keychange &&
682             ieee->iw_mode != IW_MODE_INFRA &&
683             ieee->reset_port && ieee->reset_port(dev)) {
684                 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name);
685                 return -EINVAL;
686         }
687
688         return ret;
689 }
690
691 int ieee80211_wx_get_encodeext(struct ieee80211_device *ieee,
692                                struct iw_request_info *info,
693                                union iwreq_data *wrqu, char *extra)
694 {
695         struct iw_point *encoding = &wrqu->encoding;
696         struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
697         struct ieee80211_security *sec = &ieee->sec;
698         int idx, max_key_len;
699
700         max_key_len = encoding->length - sizeof(*ext);
701         if (max_key_len < 0)
702                 return -EINVAL;
703
704         idx = encoding->flags & IW_ENCODE_INDEX;
705         if (idx) {
706                 if (idx < 1 || idx > WEP_KEYS)
707                         return -EINVAL;
708                 idx--;
709         } else
710                 idx = ieee->tx_keyidx;
711
712         if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY &&
713             ext->alg != IW_ENCODE_ALG_WEP)
714                 if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA)
715                         return -EINVAL;
716
717         encoding->flags = idx + 1;
718         memset(ext, 0, sizeof(*ext));
719
720         if (!sec->enabled) {
721                 ext->alg = IW_ENCODE_ALG_NONE;
722                 ext->key_len = 0;
723                 encoding->flags |= IW_ENCODE_DISABLED;
724         } else {
725                 if (sec->encode_alg[idx] == SEC_ALG_WEP)
726                         ext->alg = IW_ENCODE_ALG_WEP;
727                 else if (sec->encode_alg[idx] == SEC_ALG_TKIP)
728                         ext->alg = IW_ENCODE_ALG_TKIP;
729                 else if (sec->encode_alg[idx] == SEC_ALG_CCMP)
730                         ext->alg = IW_ENCODE_ALG_CCMP;
731                 else
732                         return -EINVAL;
733
734                 ext->key_len = sec->key_sizes[idx];
735                 memcpy(ext->key, sec->keys[idx], ext->key_len);
736                 encoding->flags |= IW_ENCODE_ENABLED;
737                 if (ext->key_len &&
738                     (ext->alg == IW_ENCODE_ALG_TKIP ||
739                      ext->alg == IW_ENCODE_ALG_CCMP))
740                         ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID;
741
742         }
743
744         return 0;
745 }
746
747 int ieee80211_wx_set_auth(struct net_device *dev,
748                           struct iw_request_info *info,
749                           union iwreq_data *wrqu,
750                           char *extra)
751 {
752         struct ieee80211_device *ieee = netdev_priv(dev);
753         unsigned long flags;
754         int err = 0;
755
756         spin_lock_irqsave(&ieee->lock, flags);
757
758         switch (wrqu->param.flags & IW_AUTH_INDEX) {
759         case IW_AUTH_WPA_VERSION:
760         case IW_AUTH_CIPHER_PAIRWISE:
761         case IW_AUTH_CIPHER_GROUP:
762         case IW_AUTH_KEY_MGMT:
763                 /*
764                  * Host AP driver does not use these parameters and allows
765                  * wpa_supplicant to control them internally.
766                  */
767                 break;
768         case IW_AUTH_TKIP_COUNTERMEASURES:
769                 break;          /* FIXME */
770         case IW_AUTH_DROP_UNENCRYPTED:
771                 ieee->drop_unencrypted = !!wrqu->param.value;
772                 break;
773         case IW_AUTH_80211_AUTH_ALG:
774                 break;          /* FIXME */
775         case IW_AUTH_WPA_ENABLED:
776                 ieee->privacy_invoked = ieee->wpa_enabled = !!wrqu->param.value;
777                 break;
778         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
779                 ieee->ieee802_1x = !!wrqu->param.value;
780                 break;
781         case IW_AUTH_PRIVACY_INVOKED:
782                 ieee->privacy_invoked = !!wrqu->param.value;
783                 break;
784         default:
785                 err = -EOPNOTSUPP;
786                 break;
787         }
788         spin_unlock_irqrestore(&ieee->lock, flags);
789         return err;
790 }
791
792 int ieee80211_wx_get_auth(struct net_device *dev,
793                           struct iw_request_info *info,
794                           union iwreq_data *wrqu,
795                           char *extra)
796 {
797         struct ieee80211_device *ieee = netdev_priv(dev);
798         unsigned long flags;
799         int err = 0;
800
801         spin_lock_irqsave(&ieee->lock, flags);
802
803         switch (wrqu->param.flags & IW_AUTH_INDEX) {
804         case IW_AUTH_WPA_VERSION:
805         case IW_AUTH_CIPHER_PAIRWISE:
806         case IW_AUTH_CIPHER_GROUP:
807         case IW_AUTH_KEY_MGMT:
808         case IW_AUTH_TKIP_COUNTERMEASURES:              /* FIXME */
809         case IW_AUTH_80211_AUTH_ALG:                    /* FIXME */
810                 /*
811                  * Host AP driver does not use these parameters and allows
812                  * wpa_supplicant to control them internally.
813                  */
814                 err = -EOPNOTSUPP;
815                 break;
816         case IW_AUTH_DROP_UNENCRYPTED:
817                 wrqu->param.value = ieee->drop_unencrypted;
818                 break;
819         case IW_AUTH_WPA_ENABLED:
820                 wrqu->param.value = ieee->wpa_enabled;
821                 break;
822         case IW_AUTH_RX_UNENCRYPTED_EAPOL:
823                 wrqu->param.value = ieee->ieee802_1x;
824                 break;
825         default:
826                 err = -EOPNOTSUPP;
827                 break;
828         }
829         spin_unlock_irqrestore(&ieee->lock, flags);
830         return err;
831 }
832
833 EXPORT_SYMBOL(ieee80211_wx_set_encodeext);
834 EXPORT_SYMBOL(ieee80211_wx_get_encodeext);
835
836 EXPORT_SYMBOL(ieee80211_wx_get_scan);
837 EXPORT_SYMBOL(ieee80211_wx_set_encode);
838 EXPORT_SYMBOL(ieee80211_wx_get_encode);
839
840 EXPORT_SYMBOL_GPL(ieee80211_wx_set_auth);
841 EXPORT_SYMBOL_GPL(ieee80211_wx_get_auth);