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