1 /******************************************************************************
3 Copyright(c) 2004-2005 Intel Corporation. All rights reserved.
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
9 Copyright (c) 2002-2003, Jouni Malinen <jkmaline@cc.hut.fi>
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.
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
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.
24 The full GNU General Public License is included in this distribution in the
28 James P. Ketrenos <ipw2100-admin@linux.intel.com>
29 Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 ******************************************************************************/
33 #include <linux/kmod.h>
34 #include <linux/module.h>
35 #include <linux/jiffies.h>
37 #include <net/ieee80211.h>
38 #include <linux/wireless.h>
40 static const char *ieee80211_modes
[] = {
41 "?", "a", "b", "ab", "g", "ag", "bg", "abg"
44 #define MAX_CUSTOM_LEN 64
45 static inline char *ipw2100_translate_scan(struct ieee80211_device
*ieee
,
46 char *start
, char *stop
,
47 struct ieee80211_network
*network
)
49 char custom
[MAX_CUSTOM_LEN
];
55 /* First entry *MUST* be the AP MAC address */
57 iwe
.u
.ap_addr
.sa_family
= ARPHRD_ETHER
;
58 memcpy(iwe
.u
.ap_addr
.sa_data
, network
->bssid
, ETH_ALEN
);
59 start
= iwe_stream_add_event(start
, stop
, &iwe
, IW_EV_ADDR_LEN
);
61 /* Remaining entries will be displayed in the order we provide them */
64 iwe
.cmd
= SIOCGIWESSID
;
66 if (network
->flags
& NETWORK_EMPTY_ESSID
) {
67 iwe
.u
.data
.length
= sizeof("<hidden>");
68 start
= iwe_stream_add_point(start
, stop
, &iwe
, "<hidden>");
70 iwe
.u
.data
.length
= min(network
->ssid_len
, (u8
) 32);
71 start
= iwe_stream_add_point(start
, stop
, &iwe
, network
->ssid
);
74 /* Add the protocol name */
75 iwe
.cmd
= SIOCGIWNAME
;
76 snprintf(iwe
.u
.name
, IFNAMSIZ
, "IEEE 802.11%s",
77 ieee80211_modes
[network
->mode
]);
78 start
= iwe_stream_add_event(start
, stop
, &iwe
, IW_EV_CHAR_LEN
);
81 iwe
.cmd
= SIOCGIWMODE
;
82 if (network
->capability
& (WLAN_CAPABILITY_ESS
| WLAN_CAPABILITY_IBSS
)) {
83 if (network
->capability
& WLAN_CAPABILITY_ESS
)
84 iwe
.u
.mode
= IW_MODE_MASTER
;
86 iwe
.u
.mode
= IW_MODE_ADHOC
;
88 start
= iwe_stream_add_event(start
, stop
, &iwe
, IW_EV_UINT_LEN
);
91 /* Add frequency/channel */
92 iwe
.cmd
= SIOCGIWFREQ
;
93 /* iwe.u.freq.m = ieee80211_frequency(network->channel, network->mode);
95 iwe
.u
.freq
.m
= network
->channel
;
98 start
= iwe_stream_add_event(start
, stop
, &iwe
, IW_EV_FREQ_LEN
);
100 /* Add encryption capability */
101 iwe
.cmd
= SIOCGIWENCODE
;
102 if (network
->capability
& WLAN_CAPABILITY_PRIVACY
)
103 iwe
.u
.data
.flags
= IW_ENCODE_ENABLED
| IW_ENCODE_NOKEY
;
105 iwe
.u
.data
.flags
= IW_ENCODE_DISABLED
;
106 iwe
.u
.data
.length
= 0;
107 start
= iwe_stream_add_point(start
, stop
, &iwe
, network
->ssid
);
109 /* Add basic and extended rates */
112 p
+= snprintf(p
, MAX_CUSTOM_LEN
- (p
- custom
), " Rates (Mb/s): ");
113 for (i
= 0, j
= 0; i
< network
->rates_len
;) {
114 if (j
< network
->rates_ex_len
&&
115 ((network
->rates_ex
[j
] & 0x7F) <
116 (network
->rates
[i
] & 0x7F)))
117 rate
= network
->rates_ex
[j
++] & 0x7F;
119 rate
= network
->rates
[i
++] & 0x7F;
122 p
+= snprintf(p
, MAX_CUSTOM_LEN
- (p
- custom
),
123 "%d%s ", rate
>> 1, (rate
& 1) ? ".5" : "");
125 for (; j
< network
->rates_ex_len
; j
++) {
126 rate
= network
->rates_ex
[j
] & 0x7F;
127 p
+= snprintf(p
, MAX_CUSTOM_LEN
- (p
- custom
),
128 "%d%s ", rate
>> 1, (rate
& 1) ? ".5" : "");
133 iwe
.cmd
= SIOCGIWRATE
;
134 iwe
.u
.bitrate
.fixed
= iwe
.u
.bitrate
.disabled
= 0;
135 iwe
.u
.bitrate
.value
= max_rate
* 500000;
136 start
= iwe_stream_add_event(start
, stop
, &iwe
, IW_EV_PARAM_LEN
);
138 iwe
.cmd
= IWEVCUSTOM
;
139 iwe
.u
.data
.length
= p
- custom
;
140 if (iwe
.u
.data
.length
)
141 start
= iwe_stream_add_point(start
, stop
, &iwe
, custom
);
143 /* Add quality statistics */
145 iwe
.u
.qual
.updated
= IW_QUAL_QUAL_UPDATED
| IW_QUAL_LEVEL_UPDATED
|
146 IW_QUAL_NOISE_UPDATED
;
148 if (!(network
->stats
.mask
& IEEE80211_STATMASK_RSSI
)) {
149 iwe
.u
.qual
.updated
|= IW_QUAL_QUAL_INVALID
|
150 IW_QUAL_LEVEL_INVALID
;
152 iwe
.u
.qual
.level
= 0;
154 iwe
.u
.qual
.level
= network
->stats
.rssi
;
157 (ieee
->perfect_rssi
- ieee
->worst_rssi
) *
158 (ieee
->perfect_rssi
- ieee
->worst_rssi
) -
159 (ieee
->perfect_rssi
- network
->stats
.rssi
) *
160 (15 * (ieee
->perfect_rssi
- ieee
->worst_rssi
) +
161 62 * (ieee
->perfect_rssi
- network
->stats
.rssi
))) /
162 ((ieee
->perfect_rssi
- ieee
->worst_rssi
) *
163 (ieee
->perfect_rssi
- ieee
->worst_rssi
));
164 if (iwe
.u
.qual
.qual
> 100)
165 iwe
.u
.qual
.qual
= 100;
166 else if (iwe
.u
.qual
.qual
< 1)
170 if (!(network
->stats
.mask
& IEEE80211_STATMASK_NOISE
)) {
171 iwe
.u
.qual
.updated
|= IW_QUAL_NOISE_INVALID
;
172 iwe
.u
.qual
.noise
= 0;
174 iwe
.u
.qual
.noise
= network
->stats
.noise
;
177 start
= iwe_stream_add_event(start
, stop
, &iwe
, IW_EV_QUAL_LEN
);
179 iwe
.cmd
= IWEVCUSTOM
;
182 iwe
.u
.data
.length
= p
- custom
;
183 if (iwe
.u
.data
.length
)
184 start
= iwe_stream_add_point(start
, stop
, &iwe
, custom
);
186 if (network
->wpa_ie_len
) {
187 char buf
[MAX_WPA_IE_LEN
* 2 + 30];
190 p
+= sprintf(p
, "wpa_ie=");
191 for (i
= 0; i
< network
->wpa_ie_len
; i
++) {
192 p
+= sprintf(p
, "%02x", network
->wpa_ie
[i
]);
195 memset(&iwe
, 0, sizeof(iwe
));
196 iwe
.cmd
= IWEVCUSTOM
;
197 iwe
.u
.data
.length
= strlen(buf
);
198 start
= iwe_stream_add_point(start
, stop
, &iwe
, buf
);
201 if (network
->rsn_ie_len
) {
202 char buf
[MAX_WPA_IE_LEN
* 2 + 30];
205 p
+= sprintf(p
, "rsn_ie=");
206 for (i
= 0; i
< network
->rsn_ie_len
; i
++) {
207 p
+= sprintf(p
, "%02x", network
->rsn_ie
[i
]);
210 memset(&iwe
, 0, sizeof(iwe
));
211 iwe
.cmd
= IWEVCUSTOM
;
212 iwe
.u
.data
.length
= strlen(buf
);
213 start
= iwe_stream_add_point(start
, stop
, &iwe
, buf
);
216 /* Add EXTRA: Age to display seconds since last beacon/probe response
217 * for given network. */
218 iwe
.cmd
= IWEVCUSTOM
;
220 p
+= snprintf(p
, MAX_CUSTOM_LEN
- (p
- custom
),
221 " Last beacon: %dms ago",
222 jiffies_to_msecs(jiffies
- network
->last_scanned
));
223 iwe
.u
.data
.length
= p
- custom
;
224 if (iwe
.u
.data
.length
)
225 start
= iwe_stream_add_point(start
, stop
, &iwe
, custom
);
230 int ieee80211_wx_get_scan(struct ieee80211_device
*ieee
,
231 struct iw_request_info
*info
,
232 union iwreq_data
*wrqu
, char *extra
)
234 struct ieee80211_network
*network
;
238 char *stop
= ev
+ IW_SCAN_MAX_DATA
;
241 IEEE80211_DEBUG_WX("Getting scan\n");
243 spin_lock_irqsave(&ieee
->lock
, flags
);
245 list_for_each_entry(network
, &ieee
->network_list
, list
) {
247 if (ieee
->scan_age
== 0 ||
248 time_after(network
->last_scanned
+ ieee
->scan_age
, jiffies
))
249 ev
= ipw2100_translate_scan(ieee
, ev
, stop
, network
);
251 IEEE80211_DEBUG_SCAN("Not showing network '%s ("
252 MAC_FMT
")' due to age (%dms).\n",
253 escape_essid(network
->ssid
,
255 MAC_ARG(network
->bssid
),
256 jiffies_to_msecs(jiffies
-
261 spin_unlock_irqrestore(&ieee
->lock
, flags
);
263 wrqu
->data
.length
= ev
- extra
;
264 wrqu
->data
.flags
= 0;
266 IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i
);
271 int ieee80211_wx_set_encode(struct ieee80211_device
*ieee
,
272 struct iw_request_info
*info
,
273 union iwreq_data
*wrqu
, char *keybuf
)
275 struct iw_point
*erq
= &(wrqu
->encoding
);
276 struct net_device
*dev
= ieee
->dev
;
277 struct ieee80211_security sec
= {
280 int i
, key
, key_provided
, len
;
281 struct ieee80211_crypt_data
**crypt
;
282 int host_crypto
= ieee
->host_encrypt
|| ieee
->host_decrypt
;
284 IEEE80211_DEBUG_WX("SET_ENCODE\n");
286 key
= erq
->flags
& IW_ENCODE_INDEX
;
294 key
= ieee
->tx_keyidx
;
297 IEEE80211_DEBUG_WX("Key: %d [%s]\n", key
, key_provided
?
298 "provided" : "default");
300 crypt
= &ieee
->crypt
[key
];
302 if (erq
->flags
& IW_ENCODE_DISABLED
) {
303 if (key_provided
&& *crypt
) {
304 IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n",
306 ieee80211_crypt_delayed_deinit(ieee
, crypt
);
308 IEEE80211_DEBUG_WX("Disabling encryption.\n");
310 /* Check all the keys to see if any are still configured,
311 * and if no key index was provided, de-init them all */
312 for (i
= 0; i
< WEP_KEYS
; i
++) {
313 if (ieee
->crypt
[i
] != NULL
) {
316 ieee80211_crypt_delayed_deinit(ieee
,
324 sec
.level
= SEC_LEVEL_0
;
325 sec
.flags
|= SEC_ENABLED
| SEC_LEVEL
| SEC_ENCRYPT
;
333 sec
.flags
|= SEC_ENABLED
| SEC_ENCRYPT
;
335 if (*crypt
!= NULL
&& (*crypt
)->ops
!= NULL
&&
336 strcmp((*crypt
)->ops
->name
, "WEP") != 0) {
337 /* changing to use WEP; deinit previously used algorithm
339 ieee80211_crypt_delayed_deinit(ieee
, crypt
);
342 if (*crypt
== NULL
&& host_crypto
) {
343 struct ieee80211_crypt_data
*new_crypt
;
345 /* take WEP into use */
346 new_crypt
= kmalloc(sizeof(struct ieee80211_crypt_data
),
348 if (new_crypt
== NULL
)
350 memset(new_crypt
, 0, sizeof(struct ieee80211_crypt_data
));
351 new_crypt
->ops
= ieee80211_get_crypto_ops("WEP");
352 if (!new_crypt
->ops
) {
353 request_module("ieee80211_crypt_wep");
354 new_crypt
->ops
= ieee80211_get_crypto_ops("WEP");
357 if (new_crypt
->ops
&& try_module_get(new_crypt
->ops
->owner
))
358 new_crypt
->priv
= new_crypt
->ops
->init(key
);
360 if (!new_crypt
->ops
|| !new_crypt
->priv
) {
364 printk(KERN_WARNING
"%s: could not initialize WEP: "
365 "load module ieee80211_crypt_wep\n", dev
->name
);
371 /* If a new key was provided, set it up */
372 if (erq
->length
> 0) {
373 len
= erq
->length
<= 5 ? 5 : 13;
374 memcpy(sec
.keys
[key
], keybuf
, erq
->length
);
375 if (len
> erq
->length
)
376 memset(sec
.keys
[key
] + erq
->length
, 0,
378 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
379 key
, escape_essid(sec
.keys
[key
], len
),
381 sec
.key_sizes
[key
] = len
;
383 (*crypt
)->ops
->set_key(sec
.keys
[key
], len
, NULL
,
385 sec
.flags
|= (1 << key
);
386 /* This ensures a key will be activated if no key is
388 if (key
== sec
.active_key
)
389 sec
.flags
|= SEC_ACTIVE_KEY
;
393 len
= (*crypt
)->ops
->get_key(sec
.keys
[key
], WEP_KEY_LEN
,
394 NULL
, (*crypt
)->priv
);
396 /* Set a default key of all 0 */
397 IEEE80211_DEBUG_WX("Setting key %d to all "
399 memset(sec
.keys
[key
], 0, 13);
400 (*crypt
)->ops
->set_key(sec
.keys
[key
], 13, NULL
,
402 sec
.key_sizes
[key
] = 13;
403 sec
.flags
|= (1 << key
);
406 /* No key data - just set the default TX key index */
408 IEEE80211_DEBUG_WX("Setting key %d to default Tx "
410 ieee
->tx_keyidx
= key
;
411 sec
.active_key
= key
;
412 sec
.flags
|= SEC_ACTIVE_KEY
;
415 if (erq
->flags
& (IW_ENCODE_OPEN
| IW_ENCODE_RESTRICTED
)) {
416 ieee
->open_wep
= !(erq
->flags
& IW_ENCODE_RESTRICTED
);
417 sec
.auth_mode
= ieee
->open_wep
? WLAN_AUTH_OPEN
:
418 WLAN_AUTH_SHARED_KEY
;
419 sec
.flags
|= SEC_AUTH_MODE
;
420 IEEE80211_DEBUG_WX("Auth: %s\n",
421 sec
.auth_mode
== WLAN_AUTH_OPEN
?
422 "OPEN" : "SHARED KEY");
425 /* For now we just support WEP, so only set that security level...
426 * TODO: When WPA is added this is one place that needs to change */
427 sec
.flags
|= SEC_LEVEL
;
428 sec
.level
= SEC_LEVEL_1
; /* 40 and 104 bit WEP */
429 sec
.encode_alg
[key
] = SEC_ALG_WEP
;
432 if (ieee
->set_security
)
433 ieee
->set_security(dev
, &sec
);
435 /* Do not reset port if card is in Managed mode since resetting will
436 * generate new IEEE 802.11 authentication which may end up in looping
437 * with IEEE 802.1X. If your hardware requires a reset after WEP
438 * configuration (for example... Prism2), implement the reset_port in
439 * the callbacks structures used to initialize the 802.11 stack. */
440 if (ieee
->reset_on_keychange
&&
441 ieee
->iw_mode
!= IW_MODE_INFRA
&&
442 ieee
->reset_port
&& ieee
->reset_port(dev
)) {
443 printk(KERN_DEBUG
"%s: reset_port failed\n", dev
->name
);
449 int ieee80211_wx_get_encode(struct ieee80211_device
*ieee
,
450 struct iw_request_info
*info
,
451 union iwreq_data
*wrqu
, char *keybuf
)
453 struct iw_point
*erq
= &(wrqu
->encoding
);
455 struct ieee80211_crypt_data
*crypt
;
456 struct ieee80211_security
*sec
= &ieee
->sec
;
458 IEEE80211_DEBUG_WX("GET_ENCODE\n");
460 key
= erq
->flags
& IW_ENCODE_INDEX
;
466 key
= ieee
->tx_keyidx
;
468 crypt
= ieee
->crypt
[key
];
469 erq
->flags
= key
+ 1;
473 erq
->flags
|= IW_ENCODE_DISABLED
;
477 len
= sec
->key_sizes
[key
];
478 memcpy(keybuf
, sec
->keys
[key
], len
);
480 erq
->length
= (len
>= 0 ? len
: 0);
481 erq
->flags
|= IW_ENCODE_ENABLED
;
484 erq
->flags
|= IW_ENCODE_OPEN
;
486 erq
->flags
|= IW_ENCODE_RESTRICTED
;
491 int ieee80211_wx_set_encodeext(struct ieee80211_device
*ieee
,
492 struct iw_request_info
*info
,
493 union iwreq_data
*wrqu
, char *extra
)
495 struct net_device
*dev
= ieee
->dev
;
496 struct iw_point
*encoding
= &wrqu
->encoding
;
497 struct iw_encode_ext
*ext
= (struct iw_encode_ext
*)extra
;
500 const char *alg
, *module
;
501 struct ieee80211_crypto_ops
*ops
;
502 struct ieee80211_crypt_data
**crypt
;
504 struct ieee80211_security sec
= {
508 idx
= encoding
->flags
& IW_ENCODE_INDEX
;
510 if (idx
< 1 || idx
> WEP_KEYS
)
514 idx
= ieee
->tx_keyidx
;
516 if (ext
->ext_flags
& IW_ENCODE_EXT_GROUP_KEY
) {
517 crypt
= &ieee
->crypt
[idx
];
522 if (ieee
->iw_mode
== IW_MODE_INFRA
)
523 crypt
= &ieee
->crypt
[idx
];
528 sec
.flags
|= SEC_ENABLED
| SEC_ENCRYPT
;
529 if ((encoding
->flags
& IW_ENCODE_DISABLED
) ||
530 ext
->alg
== IW_ENCODE_ALG_NONE
) {
532 ieee80211_crypt_delayed_deinit(ieee
, crypt
);
534 for (i
= 0; i
< WEP_KEYS
; i
++)
535 if (ieee
->crypt
[i
] != NULL
)
541 sec
.level
= SEC_LEVEL_0
;
542 sec
.flags
|= SEC_LEVEL
;
550 if (group_key
? !ieee
->host_mc_decrypt
:
551 !(ieee
->host_encrypt
|| ieee
->host_decrypt
||
552 ieee
->host_encrypt_msdu
))
553 goto skip_host_crypt
;
556 case IW_ENCODE_ALG_WEP
:
558 module
= "ieee80211_crypt_wep";
560 case IW_ENCODE_ALG_TKIP
:
562 module
= "ieee80211_crypt_tkip";
564 case IW_ENCODE_ALG_CCMP
:
566 module
= "ieee80211_crypt_ccmp";
569 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
570 dev
->name
, ext
->alg
);
575 ops
= ieee80211_get_crypto_ops(alg
);
577 request_module(module
);
578 ops
= ieee80211_get_crypto_ops(alg
);
581 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
582 dev
->name
, ext
->alg
);
587 if (*crypt
== NULL
|| (*crypt
)->ops
!= ops
) {
588 struct ieee80211_crypt_data
*new_crypt
;
590 ieee80211_crypt_delayed_deinit(ieee
, crypt
);
592 new_crypt
= (struct ieee80211_crypt_data
*)
593 kmalloc(sizeof(*new_crypt
), GFP_KERNEL
);
594 if (new_crypt
== NULL
) {
598 memset(new_crypt
, 0, sizeof(struct ieee80211_crypt_data
));
599 new_crypt
->ops
= ops
;
600 if (new_crypt
->ops
&& try_module_get(new_crypt
->ops
->owner
))
601 new_crypt
->priv
= new_crypt
->ops
->init(idx
);
602 if (new_crypt
->priv
== NULL
) {
610 if (ext
->key_len
> 0 && (*crypt
)->ops
->set_key
&&
611 (*crypt
)->ops
->set_key(ext
->key
, ext
->key_len
, ext
->rx_seq
,
612 (*crypt
)->priv
) < 0) {
613 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev
->name
);
619 if (ext
->ext_flags
& IW_ENCODE_EXT_SET_TX_KEY
) {
620 ieee
->tx_keyidx
= idx
;
621 sec
.active_key
= idx
;
622 sec
.flags
|= SEC_ACTIVE_KEY
;
625 if (ext
->alg
!= IW_ENCODE_ALG_NONE
) {
626 memcpy(sec
.keys
[idx
], ext
->key
, ext
->key_len
);
627 sec
.key_sizes
[idx
] = ext
->key_len
;
628 sec
.flags
|= (1 << idx
);
629 if (ext
->alg
== IW_ENCODE_ALG_WEP
) {
630 sec
.encode_alg
[idx
] = SEC_ALG_WEP
;
631 sec
.flags
|= SEC_LEVEL
;
632 sec
.level
= SEC_LEVEL_1
;
633 } else if (ext
->alg
== IW_ENCODE_ALG_TKIP
) {
634 sec
.encode_alg
[idx
] = SEC_ALG_TKIP
;
635 sec
.flags
|= SEC_LEVEL
;
636 sec
.level
= SEC_LEVEL_2
;
637 } else if (ext
->alg
== IW_ENCODE_ALG_CCMP
) {
638 sec
.encode_alg
[idx
] = SEC_ALG_CCMP
;
639 sec
.flags
|= SEC_LEVEL
;
640 sec
.level
= SEC_LEVEL_3
;
642 /* Don't set sec level for group keys. */
644 sec
.flags
&= ~SEC_LEVEL
;
647 if (ieee
->set_security
)
648 ieee
->set_security(ieee
->dev
, &sec
);
651 * Do not reset port if card is in Managed mode since resetting will
652 * generate new IEEE 802.11 authentication which may end up in looping
653 * with IEEE 802.1X. If your hardware requires a reset after WEP
654 * configuration (for example... Prism2), implement the reset_port in
655 * the callbacks structures used to initialize the 802.11 stack.
657 if (ieee
->reset_on_keychange
&&
658 ieee
->iw_mode
!= IW_MODE_INFRA
&&
659 ieee
->reset_port
&& ieee
->reset_port(dev
)) {
660 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev
->name
);
667 int ieee80211_wx_get_encodeext(struct ieee80211_device
*ieee
,
668 struct iw_request_info
*info
,
669 union iwreq_data
*wrqu
, char *extra
)
671 struct iw_point
*encoding
= &wrqu
->encoding
;
672 struct iw_encode_ext
*ext
= (struct iw_encode_ext
*)extra
;
673 struct ieee80211_security
*sec
= &ieee
->sec
;
674 int idx
, max_key_len
;
676 max_key_len
= encoding
->length
- sizeof(*ext
);
680 idx
= encoding
->flags
& IW_ENCODE_INDEX
;
682 if (idx
< 1 || idx
> WEP_KEYS
)
686 idx
= ieee
->tx_keyidx
;
688 if (!ext
->ext_flags
& IW_ENCODE_EXT_GROUP_KEY
)
689 if (idx
!= 0 || ieee
->iw_mode
!= IW_MODE_INFRA
)
692 encoding
->flags
= idx
+ 1;
693 memset(ext
, 0, sizeof(*ext
));
696 ext
->alg
= IW_ENCODE_ALG_NONE
;
698 encoding
->flags
|= IW_ENCODE_DISABLED
;
700 if (sec
->encode_alg
[idx
] == SEC_ALG_WEP
)
701 ext
->alg
= IW_ENCODE_ALG_WEP
;
702 else if (sec
->encode_alg
[idx
] == SEC_ALG_TKIP
)
703 ext
->alg
= IW_ENCODE_ALG_TKIP
;
704 else if (sec
->encode_alg
[idx
] == SEC_ALG_CCMP
)
705 ext
->alg
= IW_ENCODE_ALG_CCMP
;
709 ext
->key_len
= sec
->key_sizes
[idx
];
710 memcpy(ext
->key
, sec
->keys
[idx
], ext
->key_len
);
711 encoding
->flags
|= IW_ENCODE_ENABLED
;
713 (ext
->alg
== IW_ENCODE_ALG_TKIP
||
714 ext
->alg
== IW_ENCODE_ALG_CCMP
))
715 ext
->ext_flags
|= IW_ENCODE_EXT_TX_SEQ_VALID
;
722 EXPORT_SYMBOL(ieee80211_wx_set_encodeext
);
723 EXPORT_SYMBOL(ieee80211_wx_get_encodeext
);
725 EXPORT_SYMBOL(ieee80211_wx_get_scan
);
726 EXPORT_SYMBOL(ieee80211_wx_set_encode
);
727 EXPORT_SYMBOL(ieee80211_wx_get_encode
);