1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
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
39struct modes_unit {
40 char *mode_string;
41 int mode_size;
42};
43struct modes_unit ieee80211_modes[] = {
44 {"a",1},
45 {"b",1},
46 {"g",1},
47 {"?",1},
48 {"N-24G",5},
49 {"N-5G",4},
50};
51
52#define iwe_stream_add_event_rsl iwe_stream_add_event
53
54#define MAX_CUSTOM_LEN 64
55static inline char *rtl819x_translate_scan(struct ieee80211_device *ieee,
56 char *start, char *stop,
57 struct ieee80211_network *network,
58 struct iw_request_info *info)
59{
60 char custom[MAX_CUSTOM_LEN];
61 char proto_name[IFNAMSIZ];
62 char *pname = proto_name;
63 char *p;
64 struct iw_event iwe;
65 int i, j;
66 u16 max_rate, rate;
67 static u8 EWC11NHTCap[] = {0x00, 0x90, 0x4c, 0x33};
68
69
70 iwe.cmd = SIOCGIWAP;
71 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
72 memcpy(iwe.u.ap_addr.sa_data, network->bssid, ETH_ALEN);
73 start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_ADDR_LEN);
74
75
76
77
78 iwe.cmd = SIOCGIWESSID;
79 iwe.u.data.flags = 1;
80
81 if (network->ssid_len == 0) {
82 iwe.u.data.length = sizeof("<hidden>");
83 start = iwe_stream_add_point(info, start, stop, &iwe, "<hidden>");
84 } else {
85 iwe.u.data.length = min(network->ssid_len, (u8)32);
86 start = iwe_stream_add_point(info, start, stop, &iwe, network->ssid);
87 }
88
89 iwe.cmd = SIOCGIWNAME;
90 for(i=0; i<ARRAY_SIZE(ieee80211_modes); i++) {
91 if(network->mode&(1<<i)) {
92 sprintf(pname,ieee80211_modes[i].mode_string,ieee80211_modes[i].mode_size);
93 pname +=ieee80211_modes[i].mode_size;
94 }
95 }
96 *pname = '\0';
97 snprintf(iwe.u.name, IFNAMSIZ, "IEEE802.11%s", proto_name);
98 start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_CHAR_LEN);
99
100 iwe.cmd = SIOCGIWMODE;
101 if (network->capability &
102 (WLAN_CAPABILITY_BSS | WLAN_CAPABILITY_IBSS)) {
103 if (network->capability & WLAN_CAPABILITY_BSS)
104 iwe.u.mode = IW_MODE_MASTER;
105 else
106 iwe.u.mode = IW_MODE_ADHOC;
107 start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_UINT_LEN);
108 }
109
110
111 iwe.cmd = SIOCGIWFREQ;
112
113
114 iwe.u.freq.m = network->channel;
115 iwe.u.freq.e = 0;
116 iwe.u.freq.i = 0;
117 start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_FREQ_LEN);
118
119 iwe.cmd = SIOCGIWENCODE;
120 if (network->capability & WLAN_CAPABILITY_PRIVACY)
121 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
122 else
123 iwe.u.data.flags = IW_ENCODE_DISABLED;
124 iwe.u.data.length = 0;
125 start = iwe_stream_add_point(info, start, stop, &iwe, network->ssid);
126
127 max_rate = 0;
128 p = custom;
129 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom), " Rates (Mb/s): ");
130 for (i = 0, j = 0; i < network->rates_len; ) {
131 if (j < network->rates_ex_len &&
132 ((network->rates_ex[j] & 0x7F) <
133 (network->rates[i] & 0x7F)))
134 rate = network->rates_ex[j++] & 0x7F;
135 else
136 rate = network->rates[i++] & 0x7F;
137 if (rate > max_rate)
138 max_rate = rate;
139 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
140 "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
141 }
142 for (; j < network->rates_ex_len; j++) {
143 rate = network->rates_ex[j] & 0x7F;
144 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
145 "%d%s ", rate >> 1, (rate & 1) ? ".5" : "");
146 if (rate > max_rate)
147 max_rate = rate;
148 }
149
150 if (network->mode >= IEEE_N_24G)
151 {
152 PHT_CAPABILITY_ELE ht_cap = NULL;
153 bool is40M = false, isShortGI = false;
154 u8 max_mcs = 0;
155 if (!memcmp(network->bssht.bdHTCapBuf, EWC11NHTCap, 4))
156 ht_cap = (PHT_CAPABILITY_ELE)&network->bssht.bdHTCapBuf[4];
157 else
158 ht_cap = (PHT_CAPABILITY_ELE)&network->bssht.bdHTCapBuf[0];
159 is40M = (ht_cap->ChlWidth)?1:0;
160 isShortGI = (ht_cap->ChlWidth)?
161 ((ht_cap->ShortGI40Mhz)?1:0):
162 ((ht_cap->ShortGI20Mhz)?1:0);
163
164 max_mcs = HTGetHighestMCSRate(ieee, ht_cap->MCS, MCS_FILTER_ALL);
165 rate = MCS_DATA_RATE[is40M][isShortGI][max_mcs&0x7f];
166 if (rate > max_rate)
167 max_rate = rate;
168 }
169
170 iwe.cmd = SIOCGIWRATE;
171 iwe.u.bitrate.fixed = iwe.u.bitrate.disabled = 0;
172 iwe.u.bitrate.value = max_rate * 500000;
173 start = iwe_stream_add_event_rsl(info, start, stop, &iwe,
174 IW_EV_PARAM_LEN);
175
176 iwe.cmd = IWEVCUSTOM;
177 iwe.u.data.length = p - custom;
178 if (iwe.u.data.length)
179 start = iwe_stream_add_point(info, start, stop, &iwe, custom);
180
181
182
183 iwe.cmd = IWEVQUAL;
184 iwe.u.qual.qual = network->stats.signal;
185 iwe.u.qual.level = network->stats.rssi;
186 iwe.u.qual.noise = network->stats.noise;
187 iwe.u.qual.updated = network->stats.mask & IEEE80211_STATMASK_WEMASK;
188 if (!(network->stats.mask & IEEE80211_STATMASK_RSSI))
189 iwe.u.qual.updated |= IW_QUAL_LEVEL_INVALID;
190 if (!(network->stats.mask & IEEE80211_STATMASK_NOISE))
191 iwe.u.qual.updated |= IW_QUAL_NOISE_INVALID;
192 if (!(network->stats.mask & IEEE80211_STATMASK_SIGNAL))
193 iwe.u.qual.updated |= IW_QUAL_QUAL_INVALID;
194 iwe.u.qual.updated = 7;
195 start = iwe_stream_add_event_rsl(info, start, stop, &iwe, IW_EV_QUAL_LEN);
196 iwe.cmd = IWEVCUSTOM;
197 p = custom;
198
199 iwe.u.data.length = p - custom;
200 if (iwe.u.data.length)
201 start = iwe_stream_add_point(info, start, stop, &iwe, custom);
202
203 memset(&iwe, 0, sizeof(iwe));
204 if (network->wpa_ie_len)
205 {
206 char buf[MAX_WPA_IE_LEN];
207 memcpy(buf, network->wpa_ie, network->wpa_ie_len);
208 iwe.cmd = IWEVGENIE;
209 iwe.u.data.length = network->wpa_ie_len;
210 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
211 }
212 memset(&iwe, 0, sizeof(iwe));
213 if (network->rsn_ie_len)
214 {
215 char buf[MAX_WPA_IE_LEN];
216 memcpy(buf, network->rsn_ie, network->rsn_ie_len);
217 iwe.cmd = IWEVGENIE;
218 iwe.u.data.length = network->rsn_ie_len;
219 start = iwe_stream_add_point(info, start, stop, &iwe, buf);
220 }
221
222
223
224 iwe.cmd = IWEVCUSTOM;
225 p = custom;
226 p += snprintf(p, MAX_CUSTOM_LEN - (p - custom),
227 " Last beacon: %lums ago", (jiffies - network->last_scanned) / (HZ / 100));
228 iwe.u.data.length = p - custom;
229 if (iwe.u.data.length)
230 start = iwe_stream_add_point(info, start, stop, &iwe, custom);
231
232 return start;
233}
234
235int ieee80211_wx_get_scan(struct ieee80211_device *ieee,
236 struct iw_request_info *info,
237 union iwreq_data *wrqu, char *extra)
238{
239 struct ieee80211_network *network;
240 unsigned long flags;
241
242 char *ev = extra;
243
244 char *stop = ev + wrqu->data.length;
245
246 int i = 0;
247 int err = 0;
248 IEEE80211_DEBUG_WX("Getting scan\n");
249 down(&ieee->wx_sem);
250 spin_lock_irqsave(&ieee->lock, flags);
251
252 list_for_each_entry(network, &ieee->network_list, list) {
253 i++;
254 if((stop-ev)<200)
255 {
256 err = -E2BIG;
257 break;
258 }
259 if (ieee->scan_age == 0 ||
260 time_after(network->last_scanned + ieee->scan_age, jiffies))
261 ev = rtl819x_translate_scan(ieee, ev, stop, network, info);
262 else
263 IEEE80211_DEBUG_SCAN(
264 "Not showing network '%s ("
265 MAC_FMT ")' due to age (%lums).\n",
266 escape_essid(network->ssid,
267 network->ssid_len),
268 MAC_ARG(network->bssid),
269 (jiffies - network->last_scanned) / (HZ / 100));
270 }
271
272 spin_unlock_irqrestore(&ieee->lock, flags);
273 up(&ieee->wx_sem);
274 wrqu->data.length = ev - extra;
275 wrqu->data.flags = 0;
276
277 IEEE80211_DEBUG_WX("exit: %d networks returned.\n", i);
278
279 return err;
280}
281
282int ieee80211_wx_set_encode(struct ieee80211_device *ieee,
283 struct iw_request_info *info,
284 union iwreq_data *wrqu, char *keybuf)
285{
286 struct iw_point *erq = &(wrqu->encoding);
287 struct net_device *dev = ieee->dev;
288 struct ieee80211_security sec = {
289 .flags = 0
290 };
291 int i, key, key_provided, len;
292 struct ieee80211_crypt_data **crypt;
293
294 IEEE80211_DEBUG_WX("SET_ENCODE\n");
295
296 key = erq->flags & IW_ENCODE_INDEX;
297 if (key) {
298 if (key > WEP_KEYS)
299 return -EINVAL;
300 key--;
301 key_provided = 1;
302 } else {
303 key_provided = 0;
304 key = ieee->tx_keyidx;
305 }
306
307 IEEE80211_DEBUG_WX("Key: %d [%s]\n", key, key_provided ?
308 "provided" : "default");
309 crypt = &ieee->crypt[key];
310
311 if (erq->flags & IW_ENCODE_DISABLED) {
312 if (key_provided && *crypt) {
313 IEEE80211_DEBUG_WX("Disabling encryption on key %d.\n",
314 key);
315 ieee80211_crypt_delayed_deinit(ieee, crypt);
316 } else
317 IEEE80211_DEBUG_WX("Disabling encryption.\n");
318
319
320
321 for (i = 0; i < WEP_KEYS; i++) {
322 if (ieee->crypt[i] != NULL) {
323 if (key_provided)
324 break;
325 ieee80211_crypt_delayed_deinit(
326 ieee, &ieee->crypt[i]);
327 }
328 }
329
330 if (i == WEP_KEYS) {
331 sec.enabled = 0;
332 sec.level = SEC_LEVEL_0;
333 sec.flags |= SEC_ENABLED | SEC_LEVEL;
334 }
335
336 goto done;
337 }
338
339
340
341 sec.enabled = 1;
342 sec.flags |= SEC_ENABLED;
343
344 if (*crypt != NULL && (*crypt)->ops != NULL &&
345 strcmp((*crypt)->ops->name, "WEP") != 0) {
346
347
348 ieee80211_crypt_delayed_deinit(ieee, crypt);
349 }
350
351 if (*crypt == NULL) {
352 struct ieee80211_crypt_data *new_crypt;
353
354
355 new_crypt = kmalloc(sizeof(struct ieee80211_crypt_data),
356 GFP_KERNEL);
357 if (new_crypt == NULL)
358 return -ENOMEM;
359 memset(new_crypt, 0, sizeof(struct ieee80211_crypt_data));
360 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
361 if (!new_crypt->ops)
362 new_crypt->ops = ieee80211_get_crypto_ops("WEP");
363 if (new_crypt->ops)
364 new_crypt->priv = new_crypt->ops->init(key);
365
366 if (!new_crypt->ops || !new_crypt->priv) {
367 kfree(new_crypt);
368 new_crypt = NULL;
369
370 printk(KERN_WARNING "%s: could not initialize WEP: "
371 "load module ieee80211_crypt_wep\n",
372 dev->name);
373 return -EOPNOTSUPP;
374 }
375 *crypt = new_crypt;
376 }
377
378
379 if (erq->length > 0) {
380 len = erq->length <= 5 ? 5 : 13;
381 memcpy(sec.keys[key], keybuf, erq->length);
382 if (len > erq->length)
383 memset(sec.keys[key] + erq->length, 0,
384 len - erq->length);
385 IEEE80211_DEBUG_WX("Setting key %d to '%s' (%d:%d bytes)\n",
386 key, escape_essid(sec.keys[key], len),
387 erq->length, len);
388 sec.key_sizes[key] = len;
389 (*crypt)->ops->set_key(sec.keys[key], len, NULL,
390 (*crypt)->priv);
391 sec.flags |= (1 << key);
392
393
394 if (key == sec.active_key)
395 sec.flags |= SEC_ACTIVE_KEY;
396 ieee->tx_keyidx = key;
397
398 } else {
399 len = (*crypt)->ops->get_key(sec.keys[key], WEP_KEY_LEN,
400 NULL, (*crypt)->priv);
401 if (len == 0) {
402
403 printk("Setting key %d to all zero.\n",
404 key);
405
406 IEEE80211_DEBUG_WX("Setting key %d to all zero.\n",
407 key);
408 memset(sec.keys[key], 0, 13);
409 (*crypt)->ops->set_key(sec.keys[key], 13, NULL,
410 (*crypt)->priv);
411 sec.key_sizes[key] = 13;
412 sec.flags |= (1 << key);
413 }
414
415
416 if (key_provided) {
417 IEEE80211_DEBUG_WX(
418 "Setting key %d to default Tx key.\n", key);
419 ieee->tx_keyidx = key;
420 sec.active_key = key;
421 sec.flags |= SEC_ACTIVE_KEY;
422 }
423 }
424
425 done:
426 ieee->open_wep = !(erq->flags & IW_ENCODE_RESTRICTED);
427 ieee->auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY;
428 sec.auth_mode = ieee->open_wep ? WLAN_AUTH_OPEN : WLAN_AUTH_SHARED_KEY;
429 sec.flags |= SEC_AUTH_MODE;
430 IEEE80211_DEBUG_WX("Auth: %s\n", sec.auth_mode == WLAN_AUTH_OPEN ?
431 "OPEN" : "SHARED KEY");
432
433
434
435 sec.flags |= SEC_LEVEL;
436 sec.level = SEC_LEVEL_1;
437
438 if (ieee->set_security)
439 ieee->set_security(dev, &sec);
440
441
442
443
444
445
446 if (ieee->reset_on_keychange &&
447 ieee->iw_mode != IW_MODE_INFRA &&
448 ieee->reset_port && ieee->reset_port(dev)) {
449 printk(KERN_DEBUG "%s: reset_port failed\n", dev->name);
450 return -EINVAL;
451 }
452 return 0;
453}
454
455int ieee80211_wx_get_encode(struct ieee80211_device *ieee,
456 struct iw_request_info *info,
457 union iwreq_data *wrqu, char *keybuf)
458{
459 struct iw_point *erq = &(wrqu->encoding);
460 int len, key;
461 struct ieee80211_crypt_data *crypt;
462
463 IEEE80211_DEBUG_WX("GET_ENCODE\n");
464
465 if(ieee->iw_mode == IW_MODE_MONITOR)
466 return -1;
467
468 key = erq->flags & IW_ENCODE_INDEX;
469 if (key) {
470 if (key > WEP_KEYS)
471 return -EINVAL;
472 key--;
473 } else
474 key = ieee->tx_keyidx;
475
476 crypt = ieee->crypt[key];
477 erq->flags = key + 1;
478
479 if (crypt == NULL || crypt->ops == NULL) {
480 erq->length = 0;
481 erq->flags |= IW_ENCODE_DISABLED;
482 return 0;
483 }
484
485 len = crypt->ops->get_key(keybuf, SCM_KEY_LEN, NULL, crypt->priv);
486 erq->length = (len >= 0 ? len : 0);
487
488 erq->flags |= IW_ENCODE_ENABLED;
489
490 if (ieee->open_wep)
491 erq->flags |= IW_ENCODE_OPEN;
492 else
493 erq->flags |= IW_ENCODE_RESTRICTED;
494
495 return 0;
496}
497
498int ieee80211_wx_set_encode_ext(struct ieee80211_device *ieee,
499 struct iw_request_info *info,
500 union iwreq_data *wrqu, char *extra)
501{
502 int ret = 0;
503 struct net_device *dev = ieee->dev;
504 struct iw_point *encoding = &wrqu->encoding;
505 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
506 int i, idx;
507 int group_key = 0;
508 const char *alg;
509 struct ieee80211_crypto_ops *ops;
510 struct ieee80211_crypt_data **crypt;
511
512 struct ieee80211_security sec = {
513 .flags = 0,
514 };
515
516 idx = encoding->flags & IW_ENCODE_INDEX;
517 if (idx) {
518 if (idx < 1 || idx > WEP_KEYS)
519 return -EINVAL;
520 idx--;
521 } else
522 idx = ieee->tx_keyidx;
523
524 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
525
526 crypt = &ieee->crypt[idx];
527
528 group_key = 1;
529 } else {
530
531
532 if (idx != 0 && ext->alg != IW_ENCODE_ALG_WEP)
533 return -EINVAL;
534 if (ieee->iw_mode == IW_MODE_INFRA)
535
536 crypt = &ieee->crypt[idx];
537
538 else
539 return -EINVAL;
540 }
541
542 sec.flags |= SEC_ENABLED;
543
544 if ((encoding->flags & IW_ENCODE_DISABLED) ||
545 ext->alg == IW_ENCODE_ALG_NONE) {
546 if (*crypt)
547 ieee80211_crypt_delayed_deinit(ieee, crypt);
548
549 for (i = 0; i < WEP_KEYS; i++)
550
551 if (ieee->crypt[i] != NULL)
552
553 break;
554
555 if (i == WEP_KEYS) {
556 sec.enabled = 0;
557
558 sec.level = SEC_LEVEL_0;
559 sec.flags |= SEC_LEVEL;
560 }
561
562 goto done;
563 }
564
565 sec.enabled = 1;
566
567
568 switch (ext->alg) {
569 case IW_ENCODE_ALG_WEP:
570 alg = "WEP";
571 break;
572 case IW_ENCODE_ALG_TKIP:
573 alg = "TKIP";
574 break;
575 case IW_ENCODE_ALG_CCMP:
576 alg = "CCMP";
577 break;
578 default:
579 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
580 dev->name, ext->alg);
581 ret = -EINVAL;
582 goto done;
583 }
584 printk("alg name:%s\n",alg);
585
586 ops = ieee80211_get_crypto_ops(alg);
587 if (ops == NULL)
588 ops = ieee80211_get_crypto_ops(alg);
589 if (ops == NULL) {
590 IEEE80211_DEBUG_WX("%s: unknown crypto alg %d\n",
591 dev->name, ext->alg);
592 printk("========>unknown crypto alg %d\n", ext->alg);
593 ret = -EINVAL;
594 goto done;
595 }
596
597 if (*crypt == NULL || (*crypt)->ops != ops) {
598 struct ieee80211_crypt_data *new_crypt;
599
600 ieee80211_crypt_delayed_deinit(ieee, crypt);
601
602 new_crypt = kzalloc(sizeof(*new_crypt), GFP_KERNEL);
603 if (new_crypt == NULL) {
604 ret = -ENOMEM;
605 goto done;
606 }
607 new_crypt->ops = ops;
608 if (new_crypt->ops)
609 new_crypt->priv = new_crypt->ops->init(idx);
610 if (new_crypt->priv == NULL) {
611 kfree(new_crypt);
612 ret = -EINVAL;
613 goto done;
614 }
615 *crypt = new_crypt;
616
617 }
618
619 if (ext->key_len > 0 && (*crypt)->ops->set_key &&
620 (*crypt)->ops->set_key(ext->key, ext->key_len, ext->rx_seq,
621 (*crypt)->priv) < 0) {
622 IEEE80211_DEBUG_WX("%s: key setting failed\n", dev->name);
623 printk("key setting failed\n");
624 ret = -EINVAL;
625 goto done;
626 }
627#if 1
628
629
630 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
631 ieee->tx_keyidx = idx;
632 sec.active_key = idx;
633 sec.flags |= SEC_ACTIVE_KEY;
634 }
635
636 if (ext->alg != IW_ENCODE_ALG_NONE) {
637
638 sec.key_sizes[idx] = ext->key_len;
639 sec.flags |= (1 << idx);
640 if (ext->alg == IW_ENCODE_ALG_WEP) {
641 sec.flags |= SEC_LEVEL;
642 sec.level = SEC_LEVEL_1;
643 } else if (ext->alg == IW_ENCODE_ALG_TKIP) {
644 sec.flags |= SEC_LEVEL;
645 sec.level = SEC_LEVEL_2;
646 } else if (ext->alg == IW_ENCODE_ALG_CCMP) {
647 sec.flags |= SEC_LEVEL;
648 sec.level = SEC_LEVEL_3;
649 }
650
651 if (group_key)
652 sec.flags &= ~SEC_LEVEL;
653 }
654#endif
655done:
656 if (ieee->set_security)
657 ieee->set_security(ieee->dev, &sec);
658
659 if (ieee->reset_on_keychange &&
660 ieee->iw_mode != IW_MODE_INFRA &&
661 ieee->reset_port && ieee->reset_port(dev)) {
662 IEEE80211_DEBUG_WX("%s: reset_port failed\n", dev->name);
663 return -EINVAL;
664 }
665
666 return ret;
667}
668
669int ieee80211_wx_set_mlme(struct ieee80211_device *ieee,
670 struct iw_request_info *info,
671 union iwreq_data *wrqu, char *extra)
672{
673 struct iw_mlme *mlme = (struct iw_mlme *) extra;
674
675 switch (mlme->cmd) {
676 case IW_MLME_DEAUTH:
677 case IW_MLME_DISASSOC:
678 ieee80211_disassociate(ieee);
679 break;
680 default:
681 return -EOPNOTSUPP;
682 }
683
684 return 0;
685}
686
687int ieee80211_wx_set_auth(struct ieee80211_device *ieee,
688 struct iw_request_info *info,
689 struct iw_param *data, char *extra)
690{
691 switch (data->flags & IW_AUTH_INDEX) {
692 case IW_AUTH_WPA_VERSION:
693
694
695 break;
696 case IW_AUTH_CIPHER_PAIRWISE:
697 case IW_AUTH_CIPHER_GROUP:
698 case IW_AUTH_KEY_MGMT:
699
700
701
702
703 break;
704 case IW_AUTH_TKIP_COUNTERMEASURES:
705 ieee->tkip_countermeasures = data->value;
706 break;
707 case IW_AUTH_DROP_UNENCRYPTED:
708 ieee->drop_unencrypted = data->value;
709 break;
710
711 case IW_AUTH_80211_AUTH_ALG:
712
713
714 if(data->value & IW_AUTH_ALG_SHARED_KEY){
715 ieee->open_wep = 0;
716 ieee->auth_mode = 1;
717 }
718 else if(data->value & IW_AUTH_ALG_OPEN_SYSTEM){
719 ieee->open_wep = 1;
720 ieee->auth_mode = 0;
721 }
722 else if(data->value & IW_AUTH_ALG_LEAP){
723 ieee->open_wep = 1;
724 ieee->auth_mode = 2;
725
726 }
727 else
728 return -EINVAL;
729
730 break;
731
732#if 1
733 case IW_AUTH_WPA_ENABLED:
734 ieee->wpa_enabled = (data->value)?1:0;
735
736 break;
737
738#endif
739 case IW_AUTH_RX_UNENCRYPTED_EAPOL:
740 ieee->ieee802_1x = data->value;
741 break;
742 case IW_AUTH_PRIVACY_INVOKED:
743 ieee->privacy_invoked = data->value;
744 break;
745 default:
746 return -EOPNOTSUPP;
747 }
748
749 return 0;
750}
751
752#if 1
753int ieee80211_wx_set_gen_ie(struct ieee80211_device *ieee, u8 *ie, size_t len)
754{
755 u8 *buf;
756
757 if (len>MAX_WPA_IE_LEN || (len && ie == NULL))
758 {
759
760 return -EINVAL;
761 }
762
763
764 if (len)
765 {
766 if (len != ie[1]+2)
767 {
768 printk("len: %Zd, ie:%d\n", len, ie[1]);
769 return -EINVAL;
770 }
771 buf = kmalloc(len, GFP_KERNEL);
772 if (buf == NULL)
773 return -ENOMEM;
774 memcpy(buf, ie, len);
775 kfree(ieee->wpa_ie);
776 ieee->wpa_ie = buf;
777 ieee->wpa_ie_len = len;
778 }
779 else{
780 if (ieee->wpa_ie)
781 kfree(ieee->wpa_ie);
782 ieee->wpa_ie = NULL;
783 ieee->wpa_ie_len = 0;
784 }
785
786 return 0;
787
788}
789#endif
790
