diff options
author | Jerry Chuang <wlanfae@realtek.com> | 2009-05-22 01:16:02 -0400 |
---|---|---|
committer | Greg Kroah-Hartman <gregkh@suse.de> | 2009-06-19 14:00:53 -0400 |
commit | 5f53d8ca3d5d6afa55011e1e858a4bf255a3abf4 (patch) | |
tree | 5dfc036b97b9e68336298a61384e86f619d361e8 /drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c | |
parent | d01c3c8e13f7be29fae5b55bbd4a01d6f84d3d5e (diff) |
Staging: add rtl8192SU wireless usb driver
Driver from Realtek for the Realtek RTL8192 USB wifi device
Based on the r8187 driver from Andrea Merello <andreamrl@tiscali.it> and
others.
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>
Diffstat (limited to 'drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c')
-rw-r--r-- | drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c | 1032 |
1 files changed, 1032 insertions, 0 deletions
diff --git a/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c b/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c new file mode 100644 index 00000000000..118dfe1c977 --- /dev/null +++ b/drivers/staging/rtl8192su/ieee80211/ieee80211_wx.c | |||
@@ -0,0 +1,1032 @@ | |||
1 | /****************************************************************************** | ||
2 | |||
3 | Copyright(c) 2004 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 | #include <linux/wireless.h> | ||
33 | #include <linux/version.h> | ||
34 | #include <linux/kmod.h> | ||
35 | #include <linux/module.h> | ||
36 | |||
37 | #include "ieee80211.h" | ||
38 | #if 0 | ||
39 | static const char *ieee80211_modes[] = { | ||
40 | "?", "a", "b", "ab", "g", "ag", "bg", "abg" | ||
41 | }; | ||
42 | #endif | ||
43 | struct modes_unit { | ||
44 | char *mode_string; | ||
45 | int mode_size; | ||
46 | }; | ||
47 | struct modes_unit ieee80211_modes[] = { | ||
48 | {"a",1}, | ||
49 | {"b",1}, | ||
50 | {"g",1}, | ||
51 | {"?",1}, | ||
52 | {"N-24G",5}, | ||
53 | {"N-5G",4}, | ||
54 | }; | ||
55 | |||
56 | #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,4,20)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,5,0)) | ||
57 | static inline char * | ||
58 | iwe_stream_add_event_rsl(char * stream, /* Stream of events */ | ||
59 | char * ends, /* End of stream */ | ||
60 | struct iw_event *iwe, /* Payload */ | ||
61 | int event_len) /* Real size of payload */ | ||
62 | { | ||
63 | /* Check if it's possible */ | ||
64 | if((stream + event_len) < ends) { | ||
65 | iwe->len = event_len; | ||
66 | ndelay(1); //new | ||
67 | memcpy(stream, (char *) iwe, event_len); | ||
68 | stream += event_len; | ||
69 | } | ||
70 | return stream; | ||
71 | } | ||
72 | #else | ||
73 | #define iwe_stream_add_event_rsl iwe_stream_add_event | ||
74 | #endif | ||
75 | |||
76 | #define MAX_CUSTOM_LEN 64 | ||
77 | static inline char *rtl819x_translate_scan(struct ieee80211_device *ieee, | ||
78 | char *start, char *stop, | ||
79 | struct ieee80211_network *network, | ||
80 | struct iw_request_info *info) | ||
81 | { | ||
82 | char custom[MAX_CUSTOM_LEN]; | ||
83 | char proto_name[IFNAMSIZ]; | ||
84 | char *pname = proto_name; | ||
85 | char *p; | ||
86 | struct iw_event iwe; | ||
87 | int i, j; | ||
88 | u16 max_rate, rate; | ||
89 | static u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33}; | ||
90 | |||
91 | /* First entry *MUST* be the AP MAC address */ | ||
92 | iwe.cmd = SIOCGIWAP; | ||
93 | iwe.u.ap_addr.sa_family = ARPHRD_ETHER; | ||
94 | memcpy(iwe.u.ap_addr.sa_data, network->bssid, ETH_ALEN); | ||
95 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
96 | start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_ADDR_LEN); | ||
97 | #else | ||
98 | start = iwe_stream_add_event_rsl(start, stop, &iwe, IW_EV_ADDR_LEN); | ||
99 | #endif | ||
100 | /* Remaining entries will be displayed in the order we provide them */ | ||
101 | |||
102 | /* Add the ESSID */ | ||
103 | iwe.cmd = SIOCGIWESSID; | ||
104 | iwe.u.data.flags = 1; | ||
105 | // if (network->flags & NETWORK_EMPTY_ESSID) { | ||
106 | if (network->ssid_len == 0) { | ||
107 | iwe.u.data.length = sizeof("<hidden>"); | ||
108 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
109 | start = iwe_stream_add_point(info, start, stop, &iwe, "<hidden>"); | ||
110 | #else | ||
111 | start = iwe_stream_add_point(start, stop, &iwe, "<hidden>"); | ||
112 | #endif | ||
113 | } else { | ||
114 | iwe.u.data.length = min(network->ssid_len, (u8)32); | ||
115 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
116 | start = iwe_stream_add_point(info, start, stop, &iwe, network->ssid); | ||
117 | #else | ||
118 | start = iwe_stream_add_point(start, stop, &iwe, network->ssid); | ||
119 | #endif | ||
120 | } | ||
121 | /* Add the protocol name */ | ||
122 | iwe.cmd = SIOCGIWNAME; | ||
123 | for(i=0; i<(sizeof(ieee80211_modes)/sizeof(ieee80211_modes[0])); i++) { | ||
124 | if(network->mode&(1<<i)) { | ||
125 | sprintf(pname,ieee80211_modes[i].mode_string,ieee80211_modes[i].mode_size); | ||
126 | pname +=ieee80211_modes[i].mode_size; | ||
127 | } | ||
128 | } | ||
129 | *pname = '\0'; | ||
130 | snprintf(iwe.u.name, IFNAMSIZ, "IEEE802.11%s", proto_name); | ||
131 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
132 | start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_CHAR_LEN); | ||
133 | #else | ||
134 | start = iwe_stream_add_event_rsl(start, stop, &iwe, IW_EV_CHAR_LEN); | ||
135 | #endif | ||
136 | /* Add mode */ | ||
137 | iwe.cmd = SIOCGIWMODE; | ||
138 | if (network->capability & | ||
139 | (WLAN_CAPABILITY_BSS | WLAN_CAPABILITY_IBSS)) { | ||
140 | if (network->capability & WLAN_CAPABILITY_BSS) | ||
141 | iwe.u.mode = IW_MODE_MASTER; | ||
142 | else | ||
143 | iwe.u.mode = IW_MODE_ADHOC; | ||
144 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
145 | start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_UINT_LEN); | ||
146 | #else | ||
147 | start = iwe_stream_add_event_rsl(start, stop, &iwe, IW_EV_UINT_LEN); | ||
148 | #endif | ||
149 | } | ||
150 | |||
151 | /* Add frequency/channel */ | ||
152 | iwe.cmd = SIOCGIWFREQ; | ||
153 | /* iwe.u.freq.m = ieee80211_frequency(network->channel, network->mode); | ||
154 | iwe.u.freq.e = 3; */ | ||
155 | iwe.u.freq.m = network->channel; | ||
156 | iwe.u.freq.e = 0; | ||
157 | iwe.u.freq.i = 0; | ||
158 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
159 | start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_FREQ_LEN); | ||
160 | #else | ||
161 | start = iwe_stream_add_event_rsl(start, stop, &iwe, IW_EV_FREQ_LEN); | ||
162 | #endif | ||
163 | /* Add encryption capability */ | ||
164 | iwe.cmd = SIOCGIWENCODE; | ||
165 | if (network->capability & WLAN_CAPABILITY_PRIVACY) | ||
166 | iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY; | ||
167 | else | ||
168 | iwe.u.data.flags = IW_ENCODE_DISABLED; | ||
169 | iwe.u.data.length = 0; | ||
170 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
171 | start = iwe_stream_add_point(info, start, stop, &iwe, network->ssid); | ||
172 | #else | ||
173 | start = iwe_stream_add_point(start, stop, &iwe, network->ssid); | ||
174 | #endif | ||
175 | /* Add basic and extended rates */ | ||
176 | max_rate = 0; | ||
177 | p = custom; | ||
178 | p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): "); | ||
179 | for (i = 0, j = 0; i < network->rates_len; ) { | ||
180 | if (j < network->rates_ex_len && | ||
181 | ((network->rates_ex[j] & 0x7F) < | ||
182 | (network->rates[i] & 0x7F))) | ||
183 | rate = network->rates_ex[j++] & 0x7F; | ||
184 | else | ||
185 | rate = network->rates[i++] & 0x7F; | ||
186 | if (rate > max_rate) | ||
187 | max_rate = rate; | ||
188 | p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), | ||
189 | "%d%s ", rate >> 1, (rate & 1) ? ".5" : ""); | ||
190 | } | ||
191 | for (; j < network->rates_ex_len; j++) { | ||
192 | rate = network->rates_ex[j] & 0x7F; | ||
193 | p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), | ||
194 | "%d%s ", rate >> 1, (rate & 1) ? ".5" : ""); | ||
195 | if (rate > max_rate) | ||
196 | max_rate = rate; | ||
197 | } | ||
198 | |||
199 | if (network->mode >= IEEE_N_24G)//add N rate here; | ||
200 | { | ||
201 | PHT_CAPABILITY_ELE ht_cap = NULL; | ||
202 | bool is40M = false, isShortGI = false; | ||
203 | u8 max_mcs = 0; | ||
204 | if (!memcmp(network->bssht.bdHTCapBuf, EWC11NHTCap, 4)) | ||
205 | ht_cap = (PHT_CAPABILITY_ELE)&network->bssht.bdHTCapBuf[4]; | ||
206 | else | ||
207 | ht_cap = (PHT_CAPABILITY_ELE)&network->bssht.bdHTCapBuf[0]; | ||
208 | is40M = (ht_cap->ChlWidth)?1:0; | ||
209 | isShortGI = (ht_cap->ChlWidth)? | ||
210 | ((ht_cap->ShortGI40Mhz)?1:0): | ||
211 | ((ht_cap->ShortGI20Mhz)?1:0); | ||
212 | |||
213 | max_mcs = HTGetHighestMCSRate(ieee, ht_cap->MCS, MCS_FILTER_ALL); | ||
214 | rate = MCS_DATA_RATE[is40M][isShortGI][max_mcs&0x7f]; | ||
215 | if (rate > max_rate) | ||
216 | max_rate = rate; | ||
217 | } | ||
218 | #if 0 | ||
219 | printk("max rate:%d ===basic rate:\n", max_rate); | ||
220 | for (i=0;i<network->rates_len;i++) | ||
221 | printk(" %x", network->rates[i]); | ||
222 | printk("\n=======extend rate\n"); | ||
223 | for (i=0; i<network->rates_ex_len; i++) | ||
224 | printk(" %x", network->rates_ex[i]); | ||
225 | printk("\n"); | ||
226 | #endif | ||
227 | iwe.cmd = SIOCGIWRATE; | ||
228 | iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0; | ||
229 | iwe.u.bitrate.value = max_rate * 500000; | ||
230 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
231 | start = iwe_stream_add_event_rsl(info, start, stop, &iwe, | ||
232 | IW_EV_PARAM_LEN); | ||
233 | #else | ||
234 | start = iwe_stream_add_event_rsl(start, stop, &iwe, | ||
235 | IW_EV_PARAM_LEN); | ||
236 | #endif | ||
237 | iwe.cmd = IWEVCUSTOM; | ||
238 | iwe.u.data.length = p - custom; | ||
239 | if (iwe.u.data.length) | ||
240 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
241 | start = iwe_stream_add_point(info, start, stop, &iwe, custom); | ||
242 | #else | ||
243 | start = iwe_stream_add_point(start, stop, &iwe, custom); | ||
244 | #endif | ||
245 | /* Add quality statistics */ | ||
246 | /* TODO: Fix these values... */ | ||
247 | iwe.cmd = IWEVQUAL; | ||
248 | iwe.u.qual.qual = network->stats.signal; | ||
249 | iwe.u.qual.level = network->stats.rssi; | ||
250 | iwe.u.qual.noise = network->stats.noise; | ||
251 | iwe.u.qual.updated = network->stats.mask & IEEE80211_STATMASK_WEMASK; | ||
252 | if (!(network->stats.mask & IEEE80211_STATMASK_RSSI)) | ||
253 | iwe.u.qual.updated |= IW_QUAL_LEVEL_INVALID; | ||
254 | if (!(network->stats.mask & IEEE80211_STATMASK_NOISE)) | ||
255 | iwe.u.qual.updated |= IW_QUAL_NOISE_INVALID; | ||
256 | if (!(network->stats.mask & IEEE80211_STATMASK_SIGNAL)) | ||
257 | iwe.u.qual.updated |= IW_QUAL_QUAL_INVALID; | ||
258 | iwe.u.qual.updated = 7; | ||
259 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
260 | start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_QUAL_LEN); | ||
261 | #else | ||
262 | start = iwe_stream_add_event_rsl(start, stop, &iwe, IW_EV_QUAL_LEN); | ||
263 | #endif | ||
264 | iwe.cmd = IWEVCUSTOM; | ||
265 | p = custom; | ||
266 | |||
267 | iwe.u.data.length = p - custom; | ||
268 | if (iwe.u.data.length) | ||
269 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
270 | start = iwe_stream_add_point(info, start, stop, &iwe, custom); | ||
271 | #else | ||
272 | start = iwe_stream_add_point(start, stop, &iwe, custom); | ||
273 | #endif | ||
274 | #if (WIRELESS_EXT < 18) | ||
275 | if (ieee->wpa_enabled && network->wpa_ie_len){ | ||
276 | char buf[MAX_WPA_IE_LEN * 2 + 30]; | ||
277 | // printk("WPA IE\n"); | ||
278 | u8 *p = buf; | ||
279 | p += sprintf(p, "wpa_ie="); | ||
280 | for (i = 0; i < network->wpa_ie_len; i++) { | ||
281 | p += sprintf(p, "%02x", network->wpa_ie[i]); | ||
282 | } | ||
283 | |||
284 | memset(&iwe, 0, sizeof(iwe)); | ||
285 | iwe.cmd = IWEVCUSTOM; | ||
286 | iwe.u.data.length = strlen(buf); | ||
287 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
288 | start = iwe_stream_add_point(info, start, stop, &iwe, buf); | ||
289 | #else | ||
290 | start = iwe_stream_add_point(start, stop, &iwe, buf); | ||
291 | #endif | ||
292 | } | ||
293 | |||
294 | if (ieee->wpa_enabled && network->rsn_ie_len){ | ||
295 | char buf[MAX_WPA_IE_LEN * 2 + 30]; | ||
296 | |||
297 | u8 *p = buf; | ||
298 | p += sprintf(p, "rsn_ie="); | ||
299 | for (i = 0; i < network->rsn_ie_len; i++) { | ||
300 | p += sprintf(p, "%02x", network->rsn_ie[i]); | ||
301 | } | ||
302 | |||
303 | memset(&iwe, 0, sizeof(iwe)); | ||
304 | iwe.cmd = IWEVCUSTOM; | ||
305 | iwe.u.data.length = strlen(buf); | ||
306 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
307 | start = iwe_stream_add_point(info, start, stop, &iwe, buf); | ||
308 | #else | ||
309 | start = iwe_stream_add_point(start, stop, &iwe, buf); | ||
310 | #endif | ||
311 | } | ||
312 | #else | ||
313 | memset(&iwe, 0, sizeof(iwe)); | ||
314 | if (network->wpa_ie_len) | ||
315 | { | ||
316 | char buf[MAX_WPA_IE_LEN]; | ||
317 | memcpy(buf, network->wpa_ie, network->wpa_ie_len); | ||
318 | iwe.cmd = IWEVGENIE; | ||
319 | iwe.u.data.length = network->wpa_ie_len; | ||
320 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
321 | start = iwe_stream_add_point(info, start, stop, &iwe, buf); | ||
322 | #else | ||
323 | start = iwe_stream_add_point(start, stop, &iwe, buf); | ||
324 | #endif | ||
325 | } | ||
326 | memset(&iwe, 0, sizeof(iwe)); | ||
327 | if (network->rsn_ie_len) | ||
328 | { | ||
329 | char buf[MAX_WPA_IE_LEN]; | ||
330 | memcpy(buf, network->rsn_ie, network->rsn_ie_len); | ||
331 | iwe.cmd = IWEVGENIE; | ||
332 | iwe.u.data.length = network->rsn_ie_len; | ||
333 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
334 | start = iwe_stream_add_point(info, start, stop, &iwe, buf); | ||
335 | #else | ||
336 | start = iwe_stream_add_point(start, stop, &iwe, buf); | ||
337 | #endif | ||
338 | } | ||
339 | #endif | ||
340 | |||
341 | |||
342 | /* Add EXTRA: Age to display seconds since last beacon/probe response | ||
343 | * for given network. */ | ||
344 | iwe.cmd = IWEVCUSTOM; | ||
345 | p = custom; | ||
346 | p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), | ||
347 | " Last beacon: %lums ago", (jiffies - network->last_scanned) / (HZ / 100)); | ||
348 | iwe.u.data.length = p - custom; | ||
349 | if (iwe.u.data.length) | ||
350 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,27) | ||
351 | start = iwe_stream_add_point(info, start, stop, &iwe, custom); | ||
352 | #else | ||
353 | start = iwe_stream_add_point(start, stop, &iwe, custom); | ||
354 | #endif | ||
355 | |||
356 | return start; | ||
357 | } | ||
358 | |||
359 | int ieee80211_wx_get_scan(struct ieee80211_device *ieee, | ||
360 | struct iw_request_info *info, | ||
361 | union iwreq_data *wrqu, char *extra) | ||
362 | { | ||
363 | struct ieee80211_network *network; | ||
364 | unsigned long flags; | ||
365 | |||
366 | char *ev = extra; | ||
367 | // char *stop = ev + IW_SCAN_MAX_DATA; | ||
368 | char *stop = ev + wrqu->data.length;//IW_SCAN_MAX_DATA; | ||
369 | //char *stop = ev + IW_SCAN_MAX_DATA; | ||
370 | int i = 0; | ||
371 | int err = 0; | ||
372 | IEEE80211_DEBUG_WX("Getting scan\n"); | ||
373 | down(&ieee->wx_sem); | ||
374 | spin_lock_irqsave(&ieee->lock, flags); | ||
375 | |||
376 | list_for_each_entry(network, &ieee->network_list, list) { | ||
377 | i++; | ||
378 | if((stop-ev)<200) | ||
379 | { | ||
380 | err = -E2BIG; | ||
381 | break; | ||
382 | } | ||
383 | if (ieee->scan_age == 0 || | ||
384 | time_after(network->last_scanned + ieee->scan_age, jiffies)) | ||
385 | ev = rtl819x_translate_scan(ieee, ev, stop, network, info); | ||
386 | else | ||
387 | IEEE80211_DEBUG_SCAN( | ||
388 | "Not showing network '%s (" | ||
389 | MAC_FMT ")' due to age (%lums).\n", | ||
390 | escape_essid(network->ssid, | ||
391 | network->ssid_len), | ||
392 | MAC_ARG(network->bssid), | ||
393 | (jiffies - network->last_scanned) / (HZ / 100)); | ||
394 | } | ||
395 | |||
396 | spin_unlock_irqrestore(&ieee->lock, flags); | ||
397 | up(&ieee->wx_sem); | ||
398 | wrqu->data.length = ev - extra; | ||
399 | wrqu->data.flags = 0; | ||
400 | |||
401 | IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i); | ||
402 | |||
403 | return err; | ||
404 | } | ||
405 | |||
406 | int ieee80211_wx_set_encode(struct ieee80211_device *ieee, | ||
407 | struct iw_request_info *info, | ||
408 | union iwreq_data *wrqu, char *keybuf) | ||
409 | { | ||
410 | struct iw_point *erq = &(wrqu->encoding); | ||
411 | struct net_device *dev = ieee->dev; | ||
412 | struct ieee80211_security sec = { | ||
413 | .flags = 0 | ||
414 | }; | ||
415 | int i, key, key_provided, len; | ||
416 | struct ieee80211_crypt_data **crypt; | ||
417 | |||
418 | IEEE80211_DEBUG_WX("SET_ENCODE\n"); | ||
419 | |||
420 | key = erq->flags & IW_ENCODE_INDEX; | ||
421 | if (key) { | ||
422 | if (key > WEP_KEYS) | ||
423 | return -EINVAL; | ||
424 | key--; | ||
425 | key_provided = 1; | ||
426 | } else { | ||
427 | key_provided = 0; | ||
428 | key = ieee->tx_keyidx; | ||
429 | } | ||
430 | |||
431 | IEEE80211_DEBUG_WX("Key: %d [%s]\n", key, key_provided ? | ||
432 | "provided" : "default"); | ||
433 | crypt = &ieee->crypt[key]; | ||
434 | |||
435 | if (erq->flags & IW_ENCODE_DISABLED) { | ||
436 | if (key_provided && *crypt) { | ||
437 | IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n", | ||
438 | key); | ||
439 | ieee80211_crypt_delayed_deinit(ieee, crypt); | ||
440 | } else | ||
441 | IEEE80211_DEBUG_WX("Disabling encryption.\n"); | ||
442 | |||
443 | /* Check all the keys to see if any are still configured, | ||
444 | * and if no key index was provided, de-init them all */ | ||
445 | for (i = 0; i < WEP_KEYS; i++) { | ||
446 | if (ieee->crypt[i] != NULL) { | ||
447 | if (key_provided) | ||
448 | break; | ||
449 | ieee80211_crypt_delayed_deinit( | ||
450 | ieee, &ieee->crypt[i]); | ||
451 | } | ||
452 | } | ||
453 | |||
454 | if (i == WEP_KEYS) { | ||
455 | sec.enabled = 0; | ||
456 | sec.level = SEC_LEVEL_0; | ||
457 | sec.flags |= SEC_ENABLED | SEC_LEVEL; | ||
458 | } | ||
459 | |||
460 | goto done; | ||
461 | } | ||
462 | |||
463 | |||
464 | |||
465 | sec.enabled = 1; | ||
466 | sec.flags |= SEC_ENABLED; | ||
467 | |||
468 | if (*crypt != NULL && (*crypt)->ops != NULL && | ||
469 | strcmp((*crypt)->ops->name, "WEP") != 0) { | ||
470 | /* changing to use WEP; deinit previously used algorithm | ||
471 | * on this key */ | ||
472 | ieee80211_crypt_delayed_deinit(ieee, crypt); | ||
473 | } | ||
474 | |||
475 | if (*crypt == NULL) { | ||
476 | struct ieee80211_crypt_data *new_crypt; | ||
477 | |||
478 | /* take WEP into use */ | ||
479 | new_crypt = kmalloc(sizeof(struct ieee80211_crypt_data), | ||
480 | GFP_KERNEL); | ||
481 | if (new_crypt == NULL) | ||
482 | return -ENOMEM; | ||
483 | memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data)); | ||
484 | new_crypt->ops = ieee80211_get_crypto_ops("WEP"); | ||
485 | if (!new_crypt->ops) { | ||
486 | request_module("ieee80211_crypt_wep"); | ||
487 | new_crypt->ops = ieee80211_get_crypto_ops("WEP"); | ||
488 | } | ||
489 | #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,5,0) | ||
490 | if (new_crypt->ops && try_module_get(new_crypt->ops->owner)) | ||
491 | #else | ||
492 | if (new_crypt->ops && try_inc_mod_count(new_crypt->ops->owner)) | ||
493 | #endif | ||
494 | new_crypt->priv = new_crypt->ops->init(key); | ||
495 | |||
496 | if (!new_crypt->ops || !new_crypt->priv) { | ||
497 | kfree(new_crypt); | ||
498 | new_crypt = NULL; | ||
499 | |||
500 | printk(KERN_WARNING "%s: could not initialize WEP: " | ||
501 | "load module ieee80211_crypt_wep\n", | ||
502 | dev->name); | ||
503 | return -EOPNOTSUPP; | ||
504 | } | ||
505 | *crypt = new_crypt; | ||
506 | } | ||
507 | |||
508 | /* If a new key was provided, set it up */ | ||
509 | if (erq->length > 0) { | ||
510 | len = erq->length <= 5 ? 5 : 13; | ||
511 | memcpy(sec.keys[key], keybuf, erq->length); | ||
512 | if (len > erq->length) | ||
513 | memset(sec.keys[key] + erq->length, 0, | ||
514 | len - erq->length); | ||
515 | IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n", | ||
516 | key, escape_essid(sec.keys[key], len), | ||
517 | erq->length, len); | ||
518 | sec.key_sizes[key] = len; | ||
519 | (*crypt)->ops->set_key(sec.keys[key], len, NULL, | ||
520 | (*crypt)->priv); | ||
521 | sec.flags |= (1 << key); | ||
522 | /* This ensures a key will be activated if no key is | ||
523 | * explicitely set */ | ||
524 | if (key == sec.active_key) | ||
525 | sec.flags |= SEC_ACTIVE_KEY; | ||
526 | ieee->tx_keyidx = key; | ||
527 | |||
528 | } else { | ||
529 | len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN, | ||
530 | NULL, (*crypt)->priv); | ||
531 | if (len == 0) { | ||
532 | /* Set a default key of all 0 */ | ||
533 | printk("Setting key %d to all zero.\n", | ||
534 | key); | ||
535 | |||
536 | IEEE80211_DEBUG_WX("Setting key %d to all zero.\n", | ||
537 | key); | ||
538 | memset(sec.keys[key], 0, 13); | ||
539 | (*crypt)->ops->set_key(sec.keys[key], 13, NULL, | ||
540 | (*crypt)->priv); | ||
541 | sec.key_sizes[key] = 13; | ||
542 | sec.flags |= (1 << key); | ||
543 | } | ||
544 | |||
545 | /* No key data - just set the default TX key index */ | ||
546 | if (key_provided) { | ||
547 | IEEE80211_DEBUG_WX( | ||
548 | "Setting key %d to default Tx key.\n", key); | ||
549 | ieee->tx_keyidx = key; | ||
550 | sec.active_key = key; | ||
551 | sec.flags |= SEC_ACTIVE_KEY; | ||
552 | } | ||
553 | } | ||
554 | |||
555 | done: | ||
556 | ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED); | ||
557 | ieee->auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY; | ||
558 | sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY; | ||
559 | sec.flags |= SEC_AUTH_MODE; | ||
560 | IEEE80211_DEBUG_WX("Auth: %s\n", sec.auth_mode == WLAN_AUTH_OPEN ? | ||
561 | "OPEN" : "SHARED KEY"); | ||
562 | |||
563 | /* For now we just support WEP, so only set that security level... | ||
564 | * TODO: When WPA is added this is one place that needs to change */ | ||
565 | sec.flags |= SEC_LEVEL; | ||
566 | sec.level = SEC_LEVEL_1; /* 40 and 104 bit WEP */ | ||
567 | |||
568 | if (ieee->set_security) | ||
569 | ieee->set_security(dev, &sec); | ||
570 | |||
571 | /* Do not reset port if card is in Managed mode since resetting will | ||
572 | * generate new IEEE 802.11 authentication which may end up in looping | ||
573 | * with IEEE 802.1X. If your hardware requires a reset after WEP | ||
574 | * configuration (for example... Prism2), implement the reset_port in | ||
575 | * the callbacks structures used to initialize the 802.11 stack. */ | ||
576 | if (ieee->reset_on_keychange && | ||
577 | ieee->iw_mode != IW_MODE_INFRA && | ||
578 | ieee->reset_port && ieee->reset_port(dev)) { | ||
579 | printk(KERN_DEBUG "%s: reset_port failed\n", dev->name); | ||
580 | return -EINVAL; | ||
581 | } | ||
582 | return 0; | ||
583 | } | ||
584 | |||
585 | int ieee80211_wx_get_encode(struct ieee80211_device *ieee, | ||
586 | struct iw_request_info *info, | ||
587 | union iwreq_data *wrqu, char *keybuf) | ||
588 | { | ||
589 | struct iw_point *erq = &(wrqu->encoding); | ||
590 | int len, key; | ||
591 | struct ieee80211_crypt_data *crypt; | ||
592 | |||
593 | IEEE80211_DEBUG_WX("GET_ENCODE\n"); | ||
594 | |||
595 | if(ieee->iw_mode == IW_MODE_MONITOR) | ||
596 | return -1; | ||
597 | |||
598 | key = erq->flags & IW_ENCODE_INDEX; | ||
599 | if (key) { | ||
600 | if (key > WEP_KEYS) | ||
601 | return -EINVAL; | ||
602 | key--; | ||
603 | } else | ||
604 | key = ieee->tx_keyidx; | ||
605 | |||
606 | crypt = ieee->crypt[key]; | ||
607 | erq->flags = key + 1; | ||
608 | |||
609 | if (crypt == NULL || crypt->ops == NULL) { | ||
610 | erq->length = 0; | ||
611 | erq->flags |= IW_ENCODE_DISABLED; | ||
612 | return 0; | ||
613 | } | ||
614 | #if 0 | ||
615 | if (strcmp(crypt->ops->name, "WEP") != 0) { | ||
616 | /* only WEP is supported with wireless extensions, so just | ||
617 | * report that encryption is used */ | ||
618 | erq->length = 0; | ||
619 | erq->flags |= IW_ENCODE_ENABLED; | ||
620 | return 0; | ||
621 | } | ||
622 | #endif | ||
623 | len = crypt->ops->get_key(keybuf, SCM_KEY_LEN, NULL, crypt->priv); | ||
624 | erq->length = (len >= 0 ? len : 0); | ||
625 | |||
626 | erq->flags |= IW_ENCODE_ENABLED; | ||
627 | |||
628 | if (ieee->open_wep) | ||
629 | erq->flags |= IW_ENCODE_OPEN; | ||
630 | else | ||
631 | erq->flags |= IW_ENCODE_RESTRICTED; | ||
632 | |||
633 | return 0; | ||
634 | } | ||
635 | #if (WIRELESS_EXT >= 18) | ||
636 | int ieee80211_wx_set_encode_ext(struct ieee80211_device *ieee, | ||
637 | struct iw_request_info *info, | ||
638 | union iwreq_data *wrqu, char *extra) | ||
639 | { | ||
640 | int ret = 0; | ||
641 | #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0) | ||
642 | struct net_device *dev = ieee->dev; | ||
643 | struct iw_point *encoding = &wrqu->encoding; | ||
644 | struct iw_encode_ext *ext = (struct iw_encode_ext *)extra; | ||
645 | int i, idx; | ||
646 | int group_key = 0; | ||
647 | const char *alg, *module; | ||
648 | struct ieee80211_crypto_ops *ops; | ||
649 | struct ieee80211_crypt_data **crypt; | ||
650 | |||
651 | struct ieee80211_security sec = { | ||
652 | .flags = 0, | ||
653 | }; | ||
654 | //printk("======>encoding flag:%x,ext flag:%x, ext alg:%d\n", encoding->flags,ext->ext_flags, ext->alg); | ||
655 | idx = encoding->flags & IW_ENCODE_INDEX; | ||
656 | if (idx) { | ||
657 | if (idx < 1 || idx > WEP_KEYS) | ||
658 | return -EINVAL; | ||
659 | idx--; | ||
660 | } else | ||
661 | idx = ieee->tx_keyidx; | ||
662 | |||
663 | if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) { | ||
664 | |||
665 | crypt = &ieee->crypt[idx]; | ||
666 | |||
667 | group_key = 1; | ||
668 | } else { | ||
669 | /* some Cisco APs use idx>0 for unicast in dynamic WEP */ | ||
670 | //printk("not group key, flags:%x, ext->alg:%d\n", ext->ext_flags, ext->alg); | ||
671 | if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP) | ||
672 | return -EINVAL; | ||
673 | if (ieee->iw_mode == IW_MODE_INFRA) | ||
674 | |||
675 | crypt = &ieee->crypt[idx]; | ||
676 | |||
677 | else | ||
678 | return -EINVAL; | ||
679 | } | ||
680 | |||
681 | sec.flags |= SEC_ENABLED;// | SEC_ENCRYPT; | ||
682 | if ((encoding->flags & IW_ENCODE_DISABLED) || | ||
683 | ext->alg == IW_ENCODE_ALG_NONE) { | ||
684 | if (*crypt) | ||
685 | ieee80211_crypt_delayed_deinit(ieee, crypt); | ||
686 | |||
687 | for (i = 0; i < WEP_KEYS; i++) | ||
688 | |||
689 | if (ieee->crypt[i] != NULL) | ||
690 | |||
691 | break; | ||
692 | |||
693 | if (i == WEP_KEYS) { | ||
694 | sec.enabled = 0; | ||
695 | // sec.encrypt = 0; | ||
696 | sec.level = SEC_LEVEL_0; | ||
697 | sec.flags |= SEC_LEVEL; | ||
698 | } | ||
699 | //printk("disabled: flag:%x\n", encoding->flags); | ||
700 | goto done; | ||
701 | } | ||
702 | |||
703 | sec.enabled = 1; | ||
704 | // sec.encrypt = 1; | ||
705 | #if 0 | ||
706 | if (group_key ? !ieee->host_mc_decrypt : | ||
707 | !(ieee->host_encrypt || ieee->host_decrypt || | ||
708 | ieee->host_encrypt_msdu)) | ||
709 | goto skip_host_crypt; | ||
710 | #endif | ||
711 | switch (ext->alg) { | ||
712 | case IW_ENCODE_ALG_WEP: | ||
713 | alg = "WEP"; | ||
714 | module = "ieee80211_crypt_wep"; | ||
715 | break; | ||
716 | case IW_ENCODE_ALG_TKIP: | ||
717 | alg = "TKIP"; | ||
718 | module = "ieee80211_crypt_tkip"; | ||
719 | break; | ||
720 | case IW_ENCODE_ALG_CCMP: | ||
721 | alg = "CCMP"; | ||
722 | module = "ieee80211_crypt_ccmp"; | ||
723 | break; | ||
724 | default: | ||
725 | IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n", | ||
726 | dev->name, ext->alg); | ||
727 | ret = -EINVAL; | ||
728 | goto done; | ||
729 | } | ||
730 | printk("alg name:%s\n",alg); | ||
731 | |||
732 | ops = ieee80211_get_crypto_ops(alg); | ||
733 | if (ops == NULL) { | ||
734 | request_module(module); | ||
735 | ops = ieee80211_get_crypto_ops(alg); | ||
736 | } | ||
737 | if (ops == NULL) { | ||
738 | IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n", | ||
739 | dev->name, ext->alg); | ||
740 | printk("========>unknown crypto alg %d\n", ext->alg); | ||
741 | ret = -EINVAL; | ||
742 | goto done; | ||
743 | } | ||
744 | |||
745 | if (*crypt == NULL || (*crypt)->ops != ops) { | ||
746 | struct ieee80211_crypt_data *new_crypt; | ||
747 | |||
748 | ieee80211_crypt_delayed_deinit(ieee, crypt); | ||
749 | |||
750 | #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,13)) | ||
751 | new_crypt = kzalloc(sizeof(*new_crypt), GFP_KERNEL); | ||
752 | #else | ||
753 | new_crypt = kmalloc(sizeof(*new_crypt), GFP_KERNEL); | ||
754 | memset(new_crypt,0,sizeof(*new_crypt)); | ||
755 | #endif | ||
756 | if (new_crypt == NULL) { | ||
757 | ret = -ENOMEM; | ||
758 | goto done; | ||
759 | } | ||
760 | new_crypt->ops = ops; | ||
761 | if (new_crypt->ops && try_module_get(new_crypt->ops->owner)) | ||
762 | new_crypt->priv = new_crypt->ops->init(idx); | ||
763 | if (new_crypt->priv == NULL) { | ||
764 | kfree(new_crypt); | ||
765 | ret = -EINVAL; | ||
766 | goto done; | ||
767 | } | ||
768 | *crypt = new_crypt; | ||
769 | |||
770 | } | ||
771 | |||
772 | if (ext->key_len > 0 && (*crypt)->ops->set_key && | ||
773 | (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq, | ||
774 | (*crypt)->priv) < 0) { | ||
775 | IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name); | ||
776 | printk("key setting failed\n"); | ||
777 | ret = -EINVAL; | ||
778 | goto done; | ||
779 | } | ||
780 | #if 1 | ||
781 | //skip_host_crypt: | ||
782 | //printk("skip_host_crypt:ext_flags:%x\n", ext->ext_flags); | ||
783 | if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) { | ||
784 | ieee->tx_keyidx = idx; | ||
785 | sec.active_key = idx; | ||
786 | sec.flags |= SEC_ACTIVE_KEY; | ||
787 | } | ||
788 | |||
789 | if (ext->alg != IW_ENCODE_ALG_NONE) { | ||
790 | //memcpy(sec.keys[idx], ext->key, ext->key_len); | ||
791 | sec.key_sizes[idx] = ext->key_len; | ||
792 | sec.flags |= (1 << idx); | ||
793 | if (ext->alg == IW_ENCODE_ALG_WEP) { | ||
794 | // sec.encode_alg[idx] = SEC_ALG_WEP; | ||
795 | sec.flags |= SEC_LEVEL; | ||
796 | sec.level = SEC_LEVEL_1; | ||
797 | } else if (ext->alg == IW_ENCODE_ALG_TKIP) { | ||
798 | // sec.encode_alg[idx] = SEC_ALG_TKIP; | ||
799 | sec.flags |= SEC_LEVEL; | ||
800 | sec.level = SEC_LEVEL_2; | ||
801 | } else if (ext->alg == IW_ENCODE_ALG_CCMP) { | ||
802 | // sec.encode_alg[idx] = SEC_ALG_CCMP; | ||
803 | sec.flags |= SEC_LEVEL; | ||
804 | sec.level = SEC_LEVEL_3; | ||
805 | } | ||
806 | /* Don't set sec level for group keys. */ | ||
807 | if (group_key) | ||
808 | sec.flags &= ~SEC_LEVEL; | ||
809 | } | ||
810 | #endif | ||
811 | done: | ||
812 | if (ieee->set_security) | ||
813 | ieee->set_security(ieee->dev, &sec); | ||
814 | |||
815 | if (ieee->reset_on_keychange && | ||
816 | ieee->iw_mode != IW_MODE_INFRA && | ||
817 | ieee->reset_port && ieee->reset_port(dev)) { | ||
818 | IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name); | ||
819 | return -EINVAL; | ||
820 | } | ||
821 | #endif | ||
822 | return ret; | ||
823 | } | ||
824 | |||
825 | int ieee80211_wx_get_encode_ext(struct ieee80211_device *ieee, | ||
826 | struct iw_request_info *info, | ||
827 | union iwreq_data *wrqu, char *extra) | ||
828 | { | ||
829 | struct iw_point *encoding = &wrqu->encoding; | ||
830 | struct iw_encode_ext *ext = (struct iw_encode_ext *)extra; | ||
831 | struct ieee80211_crypt_data *crypt; | ||
832 | int idx, max_key_len; | ||
833 | |||
834 | max_key_len = encoding->length - sizeof(*ext); | ||
835 | if (max_key_len < 0) | ||
836 | return -EINVAL; | ||
837 | |||
838 | idx = encoding->flags & IW_ENCODE_INDEX; | ||
839 | if (idx) { | ||
840 | if (idx < 1 || idx > WEP_KEYS) | ||
841 | return -EINVAL; | ||
842 | idx--; | ||
843 | } else | ||
844 | idx = ieee->tx_keyidx; | ||
845 | |||
846 | if (!ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY && | ||
847 | ext->alg != IW_ENCODE_ALG_WEP) | ||
848 | if (idx != 0 || ieee->iw_mode != IW_MODE_INFRA) | ||
849 | return -EINVAL; | ||
850 | |||
851 | crypt = ieee->crypt[idx]; | ||
852 | encoding->flags = idx + 1; | ||
853 | memset(ext, 0, sizeof(*ext)); | ||
854 | |||
855 | if (crypt == NULL || crypt->ops == NULL ) { | ||
856 | ext->alg = IW_ENCODE_ALG_NONE; | ||
857 | ext->key_len = 0; | ||
858 | encoding->flags |= IW_ENCODE_DISABLED; | ||
859 | } else { | ||
860 | if (strcmp(crypt->ops->name, "WEP") == 0 ) | ||
861 | ext->alg = IW_ENCODE_ALG_WEP; | ||
862 | else if (strcmp(crypt->ops->name, "TKIP")) | ||
863 | ext->alg = IW_ENCODE_ALG_TKIP; | ||
864 | else if (strcmp(crypt->ops->name, "CCMP")) | ||
865 | ext->alg = IW_ENCODE_ALG_CCMP; | ||
866 | else | ||
867 | return -EINVAL; | ||
868 | ext->key_len = crypt->ops->get_key(ext->key, SCM_KEY_LEN, NULL, crypt->priv); | ||
869 | encoding->flags |= IW_ENCODE_ENABLED; | ||
870 | if (ext->key_len && | ||
871 | (ext->alg == IW_ENCODE_ALG_TKIP || | ||
872 | ext->alg == IW_ENCODE_ALG_CCMP)) | ||
873 | ext->ext_flags |= IW_ENCODE_EXT_TX_SEQ_VALID; | ||
874 | |||
875 | } | ||
876 | |||
877 | return 0; | ||
878 | } | ||
879 | |||
880 | int ieee80211_wx_set_mlme(struct ieee80211_device *ieee, | ||
881 | struct iw_request_info *info, | ||
882 | union iwreq_data *wrqu, char *extra) | ||
883 | { | ||
884 | #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0) | ||
885 | struct iw_mlme *mlme = (struct iw_mlme *) extra; | ||
886 | switch (mlme->cmd) { | ||
887 | case IW_MLME_DEAUTH: | ||
888 | case IW_MLME_DISASSOC: | ||
889 | ieee80211_disassociate(ieee); | ||
890 | break; | ||
891 | default: | ||
892 | return -EOPNOTSUPP; | ||
893 | } | ||
894 | #endif | ||
895 | return 0; | ||
896 | } | ||
897 | |||
898 | int ieee80211_wx_set_auth(struct ieee80211_device *ieee, | ||
899 | struct iw_request_info *info, | ||
900 | struct iw_param *data, char *extra) | ||
901 | { | ||
902 | #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0) | ||
903 | switch (data->flags & IW_AUTH_INDEX) { | ||
904 | case IW_AUTH_WPA_VERSION: | ||
905 | /*need to support wpa2 here*/ | ||
906 | //printk("wpa version:%x\n", data->value); | ||
907 | break; | ||
908 | case IW_AUTH_CIPHER_PAIRWISE: | ||
909 | case IW_AUTH_CIPHER_GROUP: | ||
910 | case IW_AUTH_KEY_MGMT: | ||
911 | /* | ||
912 | * * Host AP driver does not use these parameters and allows | ||
913 | * * wpa_supplicant to control them internally. | ||
914 | * */ | ||
915 | break; | ||
916 | case IW_AUTH_TKIP_COUNTERMEASURES: | ||
917 | ieee->tkip_countermeasures = data->value; | ||
918 | break; | ||
919 | case IW_AUTH_DROP_UNENCRYPTED: | ||
920 | ieee->drop_unencrypted = data->value; | ||
921 | break; | ||
922 | |||
923 | case IW_AUTH_80211_AUTH_ALG: | ||
924 | //printk("======>%s():data->value is %d\n",__FUNCTION__,data->value); | ||
925 | // ieee->open_wep = (data->value&IW_AUTH_ALG_OPEN_SYSTEM)?1:0; | ||
926 | if(data->value & IW_AUTH_ALG_SHARED_KEY){ | ||
927 | ieee->open_wep = 0; | ||
928 | ieee->auth_mode = 1; | ||
929 | } | ||
930 | else if(data->value & IW_AUTH_ALG_OPEN_SYSTEM){ | ||
931 | ieee->open_wep = 1; | ||
932 | ieee->auth_mode = 0; | ||
933 | } | ||
934 | else if(data->value & IW_AUTH_ALG_LEAP){ | ||
935 | ieee->open_wep = 1; | ||
936 | ieee->auth_mode = 2; | ||
937 | //printk("hahahaa:LEAP\n"); | ||
938 | } | ||
939 | else | ||
940 | return -EINVAL; | ||
941 | //printk("open_wep:%d\n", ieee->open_wep); | ||
942 | break; | ||
943 | |||
944 | #if 1 | ||
945 | case IW_AUTH_WPA_ENABLED: | ||
946 | ieee->wpa_enabled = (data->value)?1:0; | ||
947 | //printk("enalbe wpa:%d\n", ieee->wpa_enabled); | ||
948 | break; | ||
949 | |||
950 | #endif | ||
951 | case IW_AUTH_RX_UNENCRYPTED_EAPOL: | ||
952 | ieee->ieee802_1x = data->value; | ||
953 | break; | ||
954 | case IW_AUTH_PRIVACY_INVOKED: | ||
955 | ieee->privacy_invoked = data->value; | ||
956 | break; | ||
957 | default: | ||
958 | return -EOPNOTSUPP; | ||
959 | } | ||
960 | #endif | ||
961 | return 0; | ||
962 | } | ||
963 | #endif | ||
964 | #if 1 | ||
965 | int ieee80211_wx_set_gen_ie(struct ieee80211_device *ieee, u8 *ie, size_t len) | ||
966 | { | ||
967 | #if LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0) | ||
968 | #if 0 | ||
969 | printk("====>%s()\n", __FUNCTION__); | ||
970 | { | ||
971 | int i; | ||
972 | for (i=0; i<len; i++) | ||
973 | printk("%2x ", ie[i]&0xff); | ||
974 | printk("\n"); | ||
975 | } | ||
976 | #endif | ||
977 | u8 *buf; | ||
978 | |||
979 | if (len>MAX_WPA_IE_LEN || (len && ie == NULL)) | ||
980 | { | ||
981 | // printk("return error out, len:%d\n", len); | ||
982 | return -EINVAL; | ||
983 | } | ||
984 | |||
985 | |||
986 | if (len) | ||
987 | { | ||
988 | if (len != ie[1]+2) | ||
989 | { | ||
990 | printk("len:%d, ie:%d\n", len, ie[1]); | ||
991 | return -EINVAL; | ||
992 | } | ||
993 | buf = kmalloc(len, GFP_KERNEL); | ||
994 | if (buf == NULL) | ||
995 | return -ENOMEM; | ||
996 | memcpy(buf, ie, len); | ||
997 | kfree(ieee->wpa_ie); | ||
998 | ieee->wpa_ie = buf; | ||
999 | ieee->wpa_ie_len = len; | ||
1000 | } | ||
1001 | else{ | ||
1002 | if (ieee->wpa_ie) | ||
1003 | kfree(ieee->wpa_ie); | ||
1004 | ieee->wpa_ie = NULL; | ||
1005 | ieee->wpa_ie_len = 0; | ||
1006 | } | ||
1007 | #endif | ||
1008 | return 0; | ||
1009 | |||
1010 | } | ||
1011 | #endif | ||
1012 | |||
1013 | #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,5,0)) | ||
1014 | EXPORT_SYMBOL(ieee80211_wx_set_gen_ie); | ||
1015 | #if (WIRELESS_EXT >= 18) | ||
1016 | EXPORT_SYMBOL(ieee80211_wx_set_mlme); | ||
1017 | EXPORT_SYMBOL(ieee80211_wx_set_auth); | ||
1018 | EXPORT_SYMBOL(ieee80211_wx_set_encode_ext); | ||
1019 | EXPORT_SYMBOL(ieee80211_wx_get_encode_ext); | ||
1020 | #endif | ||
1021 | EXPORT_SYMBOL(ieee80211_wx_get_scan); | ||
1022 | EXPORT_SYMBOL(ieee80211_wx_set_encode); | ||
1023 | EXPORT_SYMBOL(ieee80211_wx_get_encode); | ||
1024 | #else | ||
1025 | EXPORT_SYMBOL_NOVERS(ieee80211_wx_set_gen_ie); | ||
1026 | //EXPORT_SYMBOL_NOVERS(ieee80211_wx_set_mlme); | ||
1027 | //EXPORT_SYMBOL_NOVERS(ieee80211_wx_set_auth); | ||
1028 | //EXPORT_SYMBOL_NOVERS(ieee80211_wx_set_encode_ext); | ||
1029 | EXPORT_SYMBOL_NOVERS(ieee80211_wx_get_scan); | ||
1030 | EXPORT_SYMBOL_NOVERS(ieee80211_wx_set_encode); | ||
1031 | EXPORT_SYMBOL_NOVERS(ieee80211_wx_get_encode); | ||
1032 | #endif | ||