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