?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
debugfs: Modified default dir of debugfs for debugging UHCI.
[linux/fpc-iii.git] / drivers / staging / wlan-ng / p80211wext.c
blob984e45d9f700b6de1c61475bd6fc9f3cf9a4c173
1 /* src/p80211/p80211wext.c
2 *
3 * Glue code to make linux-wlan-ng a happy wireless extension camper.
4 *
5 * original author: Reyk Floeter <reyk@synack.de>
6 * Completely re-written by Solomon Peachy <solomon@linux-wlan.com>
7 *
8 * Copyright (C) 2002 AbsoluteValue Systems, Inc. All Rights Reserved.
9 * --------------------------------------------------------------------
10 *
11 * linux-wlan
12 *
13 * The contents of this file are subject to the Mozilla Public
14 * License Version 1.1 (the "License"); you may not use this file
15 * except in compliance with the License. You may obtain a copy of
16 * the License at http://www.mozilla.org/MPL/
17 *
18 * Software distributed under the License is distributed on an "AS
19 * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
20 * implied. See the License for the specific language governing
21 * rights and limitations under the License.
22 *
23 * Alternatively, the contents of this file may be used under the
24 * terms of the GNU Public License version 2 (the "GPL"), in which
25 * case the provisions of the GPL are applicable instead of the
26 * above. If you wish to allow the use of your version of this file
27 * only under the terms of the GPL and not to allow others to use
28 * your version of this file under the MPL, indicate your decision
29 * by deleting the provisions above and replace them with the notice
30 * and other provisions required by the GPL. If you do not delete
31 * the provisions above, a recipient may use your version of this
32 * file under either the MPL or the GPL.
33 *
34 * --------------------------------------------------------------------
35 */
36
37 /*================================================================*/
38 /* System Includes */
39
40 #include <linux/kernel.h>
41 #include <linux/sched.h>
42 #include <linux/types.h>
43 #include <linux/slab.h>
44 #include <linux/netdevice.h>
45 #include <linux/etherdevice.h>
46 #include <linux/wireless.h>
47 #include <net/iw_handler.h>
48 #include <linux/if_arp.h>
49 #include <asm/bitops.h>
50 #include <asm/uaccess.h>
51 #include <asm/byteorder.h>
52 #include <linux/if_ether.h>
53 #include <linux/bitops.h>
54
55 /*================================================================*/
56 /* Project Includes */
57
58 #include "p80211types.h"
59 #include "p80211hdr.h"
60 #include "p80211conv.h"
61 #include "p80211mgmt.h"
62 #include "p80211msg.h"
63 #include "p80211metastruct.h"
64 #include "p80211metadef.h"
65 #include "p80211netdev.h"
66 #include "p80211ioctl.h"
67 #include "p80211req.h"
68
69 static int p80211wext_giwrate(netdevice_t * dev,
70 struct iw_request_info *info,
71 struct iw_param *rrq, char *extra);
72 static int p80211wext_giwessid(netdevice_t * dev,
73 struct iw_request_info *info,
74 struct iw_point *data, char *essid);
75
76 static u8 p80211_mhz_to_channel(u16 mhz)
77 {
78 if (mhz >= 5000)
79 return (mhz - 5000) / 5;
80
81 if (mhz == 2482)
82 return 14;
83
84 if (mhz >= 2407)
85 return (mhz - 2407) / 5;
86
87 return 0;
88 }
89
90 static u16 p80211_channel_to_mhz(u8 ch, int dot11a)
91 {
92
93 if (ch == 0)
94 return 0;
95 if (ch > 200)
96 return 0;
97
98 /* 5G */
99 if (dot11a)
100 return 5000 + (5 * ch);
101
102 /* 2.4G */
103 if (ch == 14)
104 return 2484;
105
106 if ((ch < 14) && (ch > 0))
107 return 2407 + (5 * ch);
108
109 return 0;
110 }
111
112 /* taken from orinoco.c ;-) */
113 static const long p80211wext_channel_freq[] = {
114 2412, 2417, 2422, 2427, 2432, 2437, 2442,
115 2447, 2452, 2457, 2462, 2467, 2472, 2484
116 };
117
118 #define NUM_CHANNELS ARRAY_SIZE(p80211wext_channel_freq)
119
120 /* steal a spare bit to store the shared/opensystems state.
121 should default to open if not set */
122 #define HOSTWEP_SHAREDKEY BIT(3)
123
124 static int qual_as_percent(int snr)
125 {
126 if (snr <= 0)
127 return 0;
128 if (snr <= 40)
129 return snr * 5 / 2;
130 return 100;
131 }
132
133 static int p80211wext_dorequest(wlandevice_t * wlandev, u32 did, u32 data)
134 {
135 p80211msg_dot11req_mibset_t msg;
136 p80211item_uint32_t mibitem;
137 int result;
138
139 msg.msgcode = DIDmsg_dot11req_mibset;
140 mibitem.did = did;
141 mibitem.data = data;
142 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
143 result = p80211req_dorequest(wlandev, (u8 *) & msg);
144
145 return result;
146 }
147
148 static int p80211wext_autojoin(wlandevice_t * wlandev)
149 {
150 p80211msg_lnxreq_autojoin_t msg;
151 struct iw_point data;
152 char ssid[IW_ESSID_MAX_SIZE];
153
154 int result;
155 int err = 0;
156
157 /* Get ESSID */
158 result = p80211wext_giwessid(wlandev->netdev, NULL, &data, ssid);
159
160 if (result) {
161 err = -EFAULT;
162 goto exit;
163 }
164
165 if (wlandev->hostwep & HOSTWEP_SHAREDKEY)
166 msg.authtype.data = P80211ENUM_authalg_sharedkey;
167 else
168 msg.authtype.data = P80211ENUM_authalg_opensystem;
169
170 msg.msgcode = DIDmsg_lnxreq_autojoin;
171
172 /* Trim the last '\0' to fit the SSID format */
173
174 if (data.length && ssid[data.length - 1] == '\0')
175 data.length = data.length - 1;
176
177 memcpy(msg.ssid.data.data, ssid, data.length);
178 msg.ssid.data.len = data.length;
179
180 result = p80211req_dorequest(wlandev, (u8 *) & msg);
181
182 if (result) {
183 err = -EFAULT;
184 goto exit;
185 }
186
187 exit:
188
189 return err;
190
191 }
192
193 /* called by /proc/net/wireless */
194 struct iw_statistics *p80211wext_get_wireless_stats(netdevice_t * dev)
195 {
196 p80211msg_lnxreq_commsquality_t quality;
197 wlandevice_t *wlandev = dev->ml_priv;
198 struct iw_statistics *wstats = &wlandev->wstats;
199 int retval;
200
201 /* Check */
202 if ((wlandev == NULL) || (wlandev->msdstate != WLAN_MSD_RUNNING))
203 return NULL;
204
205 /* XXX Only valid in station mode */
206 wstats->status = 0;
207
208 /* build request message */
209 quality.msgcode = DIDmsg_lnxreq_commsquality;
210 quality.dbm.data = P80211ENUM_truth_true;
211 quality.dbm.status = P80211ENUM_msgitem_status_data_ok;
212
213 /* send message to nsd */
214 if (wlandev->mlmerequest == NULL)
215 return NULL;
216
217 retval = wlandev->mlmerequest(wlandev, (p80211msg_t *) & quality);
218
219 wstats->qual.qual = qual_as_percent(quality.link.data); /* overall link quality */
220 wstats->qual.level = quality.level.data; /* instant signal level */
221 wstats->qual.noise = quality.noise.data; /* instant noise level */
222
223 wstats->qual.updated = IW_QUAL_ALL_UPDATED | IW_QUAL_DBM;
224 wstats->discard.code = wlandev->rx.decrypt_err;
225 wstats->discard.nwid = 0;
226 wstats->discard.misc = 0;
227
228 wstats->discard.fragment = 0; /* incomplete fragments */
229 wstats->discard.retries = 0; /* tx retries. */
230 wstats->miss.beacon = 0;
231
232 return wstats;
233 }
234
235 static int p80211wext_giwname(netdevice_t * dev,
236 struct iw_request_info *info,
237 char *name, char *extra)
238 {
239 struct iw_param rate;
240 int result;
241 int err = 0;
242
243 result = p80211wext_giwrate(dev, NULL, &rate, NULL);
244
245 if (result) {
246 err = -EFAULT;
247 goto exit;
248 }
249
250 switch (rate.value) {
251 case 1000000:
252 case 2000000:
253 strcpy(name, "IEEE 802.11-DS");
254 break;
255 case 5500000:
256 case 11000000:
257 strcpy(name, "IEEE 802.11-b");
258 break;
259 }
260 exit:
261 return err;
262 }
263
264 static int p80211wext_giwfreq(netdevice_t * dev,
265 struct iw_request_info *info,
266 struct iw_freq *freq, char *extra)
267 {
268 wlandevice_t *wlandev = dev->ml_priv;
269 p80211item_uint32_t mibitem;
270 p80211msg_dot11req_mibset_t msg;
271 int result;
272 int err = 0;
273
274 msg.msgcode = DIDmsg_dot11req_mibget;
275 mibitem.did = DIDmib_dot11phy_dot11PhyDSSSTable_dot11CurrentChannel;
276 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
277 result = p80211req_dorequest(wlandev, (u8 *) & msg);
278
279 if (result) {
280 err = -EFAULT;
281 goto exit;
282 }
283
284 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
285
286 if (mibitem.data > NUM_CHANNELS) {
287 err = -EFAULT;
288 goto exit;
289 }
290
291 /* convert into frequency instead of a channel */
292 freq->e = 1;
293 freq->m = p80211_channel_to_mhz(mibitem.data, 0) * 100000;
294
295 exit:
296 return err;
297 }
298
299 static int p80211wext_siwfreq(netdevice_t * dev,
300 struct iw_request_info *info,
301 struct iw_freq *freq, char *extra)
302 {
303 wlandevice_t *wlandev = dev->ml_priv;
304 p80211item_uint32_t mibitem;
305 p80211msg_dot11req_mibset_t msg;
306 int result;
307 int err = 0;
308
309 if (!wlan_wext_write) {
310 err = (-EOPNOTSUPP);
311 goto exit;
312 }
313
314 msg.msgcode = DIDmsg_dot11req_mibset;
315 mibitem.did = DIDmib_dot11phy_dot11PhyDSSSTable_dot11CurrentChannel;
316 mibitem.status = P80211ENUM_msgitem_status_data_ok;
317
318 if ((freq->e == 0) && (freq->m <= 1000))
319 mibitem.data = freq->m;
320 else
321 mibitem.data = p80211_mhz_to_channel(freq->m);
322
323 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
324 result = p80211req_dorequest(wlandev, (u8 *) & msg);
325
326 if (result) {
327 err = -EFAULT;
328 goto exit;
329 }
330
331 exit:
332 return err;
333 }
334
335 static int p80211wext_giwmode(netdevice_t * dev,
336 struct iw_request_info *info,
337 __u32 * mode, char *extra)
338 {
339 wlandevice_t *wlandev = dev->ml_priv;
340
341 switch (wlandev->macmode) {
342 case WLAN_MACMODE_IBSS_STA:
343 *mode = IW_MODE_ADHOC;
344 break;
345 case WLAN_MACMODE_ESS_STA:
346 *mode = IW_MODE_INFRA;
347 break;
348 case WLAN_MACMODE_ESS_AP:
349 *mode = IW_MODE_MASTER;
350 break;
351 default:
352 /* Not set yet. */
353 *mode = IW_MODE_AUTO;
354 }
355
356 return 0;
357 }
358
359 static int p80211wext_siwmode(netdevice_t * dev,
360 struct iw_request_info *info,
361 __u32 * mode, char *extra)
362 {
363 wlandevice_t *wlandev = dev->ml_priv;
364 p80211item_uint32_t mibitem;
365 p80211msg_dot11req_mibset_t msg;
366 int result;
367 int err = 0;
368
369 if (!wlan_wext_write) {
370 err = (-EOPNOTSUPP);
371 goto exit;
372 }
373
374 if (*mode != IW_MODE_ADHOC && *mode != IW_MODE_INFRA &&
375 *mode != IW_MODE_MASTER) {
376 err = (-EOPNOTSUPP);
377 goto exit;
378 }
379
380 /* Operation mode is the same with current mode */
381 if (*mode == wlandev->macmode)
382 goto exit;
383
384 switch (*mode) {
385 case IW_MODE_ADHOC:
386 wlandev->macmode = WLAN_MACMODE_IBSS_STA;
387 break;
388 case IW_MODE_INFRA:
389 wlandev->macmode = WLAN_MACMODE_ESS_STA;
390 break;
391 case IW_MODE_MASTER:
392 wlandev->macmode = WLAN_MACMODE_ESS_AP;
393 break;
394 default:
395 /* Not set yet. */
396 printk(KERN_INFO "Operation mode: %d not support\n", *mode);
397 return -EOPNOTSUPP;
398 }
399
400 /* Set Operation mode to the PORT TYPE RID */
401 msg.msgcode = DIDmsg_dot11req_mibset;
402 mibitem.did = DIDmib_p2_p2Static_p2CnfPortType;
403 mibitem.data = (*mode == IW_MODE_ADHOC) ? 0 : 1;
404 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
405 result = p80211req_dorequest(wlandev, (u8 *) & msg);
406
407 if (result)
408 err = -EFAULT;
409
410 exit:
411 return err;
412 }
413
414 static int p80211wext_giwrange(netdevice_t * dev,
415 struct iw_request_info *info,
416 struct iw_point *data, char *extra)
417 {
418 struct iw_range *range = (struct iw_range *)extra;
419 int i, val;
420
421 /* for backward compatability set size and zero everything we don't understand */
422 data->length = sizeof(*range);
423 memset(range, 0, sizeof(*range));
424
425 range->txpower_capa = IW_TXPOW_DBM;
426 /* XXX what about min/max_pmp, min/max_pmt, etc. */
427
428 range->we_version_compiled = WIRELESS_EXT;
429 range->we_version_source = 13;
430
431 range->retry_capa = IW_RETRY_LIMIT;
432 range->retry_flags = IW_RETRY_LIMIT;
433 range->min_retry = 0;
434 range->max_retry = 255;
435
436 range->event_capa[0] = (IW_EVENT_CAPA_K_0 | /* mode/freq/ssid */
437 IW_EVENT_CAPA_MASK(SIOCGIWAP) |
438 IW_EVENT_CAPA_MASK(SIOCGIWSCAN));
439 range->event_capa[1] = IW_EVENT_CAPA_K_1; /* encode */
440 range->event_capa[4] = (IW_EVENT_CAPA_MASK(IWEVQUAL) |
441 IW_EVENT_CAPA_MASK(IWEVCUSTOM));
442
443 range->num_channels = NUM_CHANNELS;
444
445 /* XXX need to filter against the regulatory domain &| active set */
446 val = 0;
447 for (i = 0; i < NUM_CHANNELS; i++) {
448 range->freq[val].i = i + 1;
449 range->freq[val].m = p80211wext_channel_freq[i] * 100000;
450 range->freq[val].e = 1;
451 val++;
452 }
453
454 range->num_frequency = val;
455
456 /* Max of /proc/net/wireless */
457 range->max_qual.qual = 100;
458 range->max_qual.level = 0;
459 range->max_qual.noise = 0;
460 range->sensitivity = 3;
461 /* XXX these need to be nsd-specific! */
462
463 range->min_rts = 0;
464 range->max_rts = 2347;
465 range->min_frag = 256;
466 range->max_frag = 2346;
467
468 range->max_encoding_tokens = NUM_WEPKEYS;
469 range->num_encoding_sizes = 2;
470 range->encoding_size[0] = 5;
471 range->encoding_size[1] = 13;
472
473 /* XXX what about num_bitrates/throughput? */
474 range->num_bitrates = 0;
475
476 /* estimated max throughput */
477 /* XXX need to cap it if we're running at ~2Mbps.. */
478 range->throughput = 5500000;
479
480 return 0;
481 }
482
483 static int p80211wext_giwap(netdevice_t * dev,
484 struct iw_request_info *info,
485 struct sockaddr *ap_addr, char *extra)
486 {
487
488 wlandevice_t *wlandev = dev->ml_priv;
489
490 memcpy(ap_addr->sa_data, wlandev->bssid, WLAN_BSSID_LEN);
491 ap_addr->sa_family = ARPHRD_ETHER;
492
493 return 0;
494 }
495
496 static int p80211wext_giwencode(netdevice_t * dev,
497 struct iw_request_info *info,
498 struct iw_point *erq, char *key)
499 {
500 wlandevice_t *wlandev = dev->ml_priv;
501 int err = 0;
502 int i;
503
504 i = (erq->flags & IW_ENCODE_INDEX) - 1;
505 erq->flags = 0;
506
507 if (wlandev->hostwep & HOSTWEP_PRIVACYINVOKED)
508 erq->flags |= IW_ENCODE_ENABLED;
509 else
510 erq->flags |= IW_ENCODE_DISABLED;
511
512 if (wlandev->hostwep & HOSTWEP_EXCLUDEUNENCRYPTED)
513 erq->flags |= IW_ENCODE_RESTRICTED;
514 else
515 erq->flags |= IW_ENCODE_OPEN;
516
517 i = (erq->flags & IW_ENCODE_INDEX) - 1;
518
519 if (i == -1)
520 i = wlandev->hostwep & HOSTWEP_DEFAULTKEY_MASK;
521
522 if ((i < 0) || (i >= NUM_WEPKEYS)) {
523 err = -EINVAL;
524 goto exit;
525 }
526
527 erq->flags |= i + 1;
528
529 /* copy the key from the driver cache as the keys are read-only MIBs */
530 erq->length = wlandev->wep_keylens[i];
531 memcpy(key, wlandev->wep_keys[i], erq->length);
532
533 exit:
534 return err;
535 }
536
537 static int p80211wext_siwencode(netdevice_t * dev,
538 struct iw_request_info *info,
539 struct iw_point *erq, char *key)
540 {
541 wlandevice_t *wlandev = dev->ml_priv;
542 p80211msg_dot11req_mibset_t msg;
543 p80211item_pstr32_t pstr;
544
545 int err = 0;
546 int result = 0;
547 int i;
548
549 if (!wlan_wext_write) {
550 err = (-EOPNOTSUPP);
551 goto exit;
552 }
553
554 /* Check the Key index first. */
555 if ((i = (erq->flags & IW_ENCODE_INDEX))) {
556
557 if ((i < 1) || (i > NUM_WEPKEYS)) {
558 err = -EINVAL;
559 goto exit;
560 } else
561 i--;
562
563 /* Set current key number only if no keys are given */
564 if (erq->flags & IW_ENCODE_NOKEY) {
565 result =
566 p80211wext_dorequest(wlandev,
567 DIDmib_dot11smt_dot11PrivacyTable_dot11WEPDefaultKeyID,
568 i);
569
570 if (result) {
571 err = -EFAULT;
572 goto exit;
573 }
574 }
575
576 } else {
577 /* Use defaultkey if no Key Index */
578 i = wlandev->hostwep & HOSTWEP_DEFAULTKEY_MASK;
579 }
580
581 /* Check if there is no key information in the iwconfig request */
582 if ((erq->flags & IW_ENCODE_NOKEY) == 0) {
583
584 /*------------------------------------------------------------
585 * If there is WEP Key for setting, check the Key Information
586 * and then set it to the firmware.
587 -------------------------------------------------------------*/
588
589 if (erq->length > 0) {
590
591 /* copy the key from the driver cache as the keys are read-only MIBs */
592 wlandev->wep_keylens[i] = erq->length;
593 memcpy(wlandev->wep_keys[i], key, erq->length);
594
595 /* Prepare data struture for p80211req_dorequest. */
596 memcpy(pstr.data.data, key, erq->length);
597 pstr.data.len = erq->length;
598
599 switch (i) {
600 case 0:
601 pstr.did =
602 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey0;
603 break;
604
605 case 1:
606 pstr.did =
607 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey1;
608 break;
609
610 case 2:
611 pstr.did =
612 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey2;
613 break;
614
615 case 3:
616 pstr.did =
617 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey3;
618 break;
619
620 default:
621 err = -EINVAL;
622 goto exit;
623 }
624
625 msg.msgcode = DIDmsg_dot11req_mibset;
626 memcpy(&msg.mibattribute.data, &pstr, sizeof(pstr));
627 result = p80211req_dorequest(wlandev, (u8 *) & msg);
628
629 if (result) {
630 err = -EFAULT;
631 goto exit;
632 }
633 }
634
635 }
636
637 /* Check the PrivacyInvoked flag */
638 if (erq->flags & IW_ENCODE_DISABLED) {
639 result =
640 p80211wext_dorequest(wlandev,
641 DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked,
642 P80211ENUM_truth_false);
643 } else {
644 result =
645 p80211wext_dorequest(wlandev,
646 DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked,
647 P80211ENUM_truth_true);
648 }
649
650 if (result) {
651 err = -EFAULT;
652 goto exit;
653 }
654
655 /* The security mode may be open or restricted, and its meaning
656 depends on the card used. With most cards, in open mode no
657 authentication is used and the card may also accept non-
658 encrypted sessions, whereas in restricted mode only encrypted
659 sessions are accepted and the card will use authentication if
660 available.
661 */
662 if (erq->flags & IW_ENCODE_RESTRICTED) {
663 result =
664 p80211wext_dorequest(wlandev,
665 DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted,
666 P80211ENUM_truth_true);
667 } else if (erq->flags & IW_ENCODE_OPEN) {
668 result =
669 p80211wext_dorequest(wlandev,
670 DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted,
671 P80211ENUM_truth_false);
672 }
673
674 if (result) {
675 err = -EFAULT;
676 goto exit;
677 }
678
679 exit:
680
681 return err;
682 }
683
684 static int p80211wext_giwessid(netdevice_t * dev,
685 struct iw_request_info *info,
686 struct iw_point *data, char *essid)
687 {
688 wlandevice_t *wlandev = dev->ml_priv;
689
690 if (wlandev->ssid.len) {
691 data->length = wlandev->ssid.len;
692 data->flags = 1;
693 memcpy(essid, wlandev->ssid.data, data->length);
694 essid[data->length] = 0;
695 #if (WIRELESS_EXT < 21)
696 data->length++;
697 #endif
698 } else {
699 memset(essid, 0, sizeof(wlandev->ssid.data));
700 data->length = 0;
701 data->flags = 0;
702 }
703
704 return 0;
705 }
706
707 static int p80211wext_siwessid(netdevice_t * dev,
708 struct iw_request_info *info,
709 struct iw_point *data, char *essid)
710 {
711 wlandevice_t *wlandev = dev->ml_priv;
712 p80211msg_lnxreq_autojoin_t msg;
713
714 int result;
715 int err = 0;
716 int length = data->length;
717
718 if (!wlan_wext_write) {
719 err = (-EOPNOTSUPP);
720 goto exit;
721 }
722
723 if (wlandev->hostwep & HOSTWEP_SHAREDKEY)
724 msg.authtype.data = P80211ENUM_authalg_sharedkey;
725 else
726 msg.authtype.data = P80211ENUM_authalg_opensystem;
727
728 msg.msgcode = DIDmsg_lnxreq_autojoin;
729
730 #if (WIRELESS_EXT < 21)
731 if (length)
732 length--;
733 #endif
734
735 /* Trim the last '\0' to fit the SSID format */
736 if (length && essid[length - 1] == '\0')
737 length--;
738
739 memcpy(msg.ssid.data.data, essid, length);
740 msg.ssid.data.len = length;
741
742 pr_debug("autojoin_ssid for %s \n", essid);
743 result = p80211req_dorequest(wlandev, (u8 *) & msg);
744 pr_debug("autojoin_ssid %d\n", result);
745
746 if (result) {
747 err = -EFAULT;
748 goto exit;
749 }
750
751 exit:
752 return err;
753 }
754
755 static int p80211wext_siwcommit(netdevice_t * dev,
756 struct iw_request_info *info,
757 struct iw_point *data, char *essid)
758 {
759 wlandevice_t *wlandev = dev->ml_priv;
760 int err = 0;
761
762 if (!wlan_wext_write) {
763 err = (-EOPNOTSUPP);
764 goto exit;
765 }
766
767 /* Auto Join */
768 err = p80211wext_autojoin(wlandev);
769
770 exit:
771 return err;
772 }
773
774 static int p80211wext_giwrate(netdevice_t * dev,
775 struct iw_request_info *info,
776 struct iw_param *rrq, char *extra)
777 {
778 wlandevice_t *wlandev = dev->ml_priv;
779 p80211item_uint32_t mibitem;
780 p80211msg_dot11req_mibset_t msg;
781 int result;
782 int err = 0;
783
784 msg.msgcode = DIDmsg_dot11req_mibget;
785 mibitem.did = DIDmib_p2_p2MAC_p2CurrentTxRate;
786 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
787 result = p80211req_dorequest(wlandev, (u8 *) & msg);
788
789 if (result) {
790 err = -EFAULT;
791 goto exit;
792 }
793
794 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
795
796 rrq->fixed = 0; /* can it change? */
797 rrq->disabled = 0;
798 rrq->value = 0;
799
800 #define HFA384x_RATEBIT_1 ((u16)1)
801 #define HFA384x_RATEBIT_2 ((u16)2)
802 #define HFA384x_RATEBIT_5dot5 ((u16)4)
803 #define HFA384x_RATEBIT_11 ((u16)8)
804
805 switch (mibitem.data) {
806 case HFA384x_RATEBIT_1:
807 rrq->value = 1000000;
808 break;
809 case HFA384x_RATEBIT_2:
810 rrq->value = 2000000;
811 break;
812 case HFA384x_RATEBIT_5dot5:
813 rrq->value = 5500000;
814 break;
815 case HFA384x_RATEBIT_11:
816 rrq->value = 11000000;
817 break;
818 default:
819 err = -EINVAL;
820 }
821 exit:
822 return err;
823 }
824
825 static int p80211wext_giwrts(netdevice_t * dev,
826 struct iw_request_info *info,
827 struct iw_param *rts, char *extra)
828 {
829 wlandevice_t *wlandev = dev->ml_priv;
830 p80211item_uint32_t mibitem;
831 p80211msg_dot11req_mibset_t msg;
832 int result;
833 int err = 0;
834
835 msg.msgcode = DIDmsg_dot11req_mibget;
836 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11RTSThreshold;
837 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
838 result = p80211req_dorequest(wlandev, (u8 *) & msg);
839
840 if (result) {
841 err = -EFAULT;
842 goto exit;
843 }
844
845 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
846
847 rts->value = mibitem.data;
848 rts->disabled = (rts->value == 2347);
849 rts->fixed = 1;
850
851 exit:
852 return err;
853 }
854
855 static int p80211wext_siwrts(netdevice_t * dev,
856 struct iw_request_info *info,
857 struct iw_param *rts, char *extra)
858 {
859 wlandevice_t *wlandev = dev->ml_priv;
860 p80211item_uint32_t mibitem;
861 p80211msg_dot11req_mibset_t msg;
862 int result;
863 int err = 0;
864
865 if (!wlan_wext_write) {
866 err = (-EOPNOTSUPP);
867 goto exit;
868 }
869
870 msg.msgcode = DIDmsg_dot11req_mibget;
871 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11RTSThreshold;
872 if (rts->disabled)
873 mibitem.data = 2347;
874 else
875 mibitem.data = rts->value;
876
877 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
878 result = p80211req_dorequest(wlandev, (u8 *) & msg);
879
880 if (result) {
881 err = -EFAULT;
882 goto exit;
883 }
884
885 exit:
886 return err;
887 }
888
889 static int p80211wext_giwfrag(netdevice_t * dev,
890 struct iw_request_info *info,
891 struct iw_param *frag, char *extra)
892 {
893 wlandevice_t *wlandev = dev->ml_priv;
894 p80211item_uint32_t mibitem;
895 p80211msg_dot11req_mibset_t msg;
896 int result;
897 int err = 0;
898
899 msg.msgcode = DIDmsg_dot11req_mibget;
900 mibitem.did =
901 DIDmib_dot11mac_dot11OperationTable_dot11FragmentationThreshold;
902 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
903 result = p80211req_dorequest(wlandev, (u8 *) & msg);
904
905 if (result) {
906 err = -EFAULT;
907 goto exit;
908 }
909
910 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
911
912 frag->value = mibitem.data;
913 frag->disabled = (frag->value == 2346);
914 frag->fixed = 1;
915
916 exit:
917 return err;
918 }
919
920 static int p80211wext_siwfrag(netdevice_t * dev,
921 struct iw_request_info *info,
922 struct iw_param *frag, char *extra)
923 {
924 wlandevice_t *wlandev = dev->ml_priv;
925 p80211item_uint32_t mibitem;
926 p80211msg_dot11req_mibset_t msg;
927 int result;
928 int err = 0;
929
930 if (!wlan_wext_write) {
931 err = (-EOPNOTSUPP);
932 goto exit;
933 }
934
935 msg.msgcode = DIDmsg_dot11req_mibset;
936 mibitem.did =
937 DIDmib_dot11mac_dot11OperationTable_dot11FragmentationThreshold;
938
939 if (frag->disabled)
940 mibitem.data = 2346;
941 else
942 mibitem.data = frag->value;
943
944 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
945 result = p80211req_dorequest(wlandev, (u8 *) & msg);
946
947 if (result) {
948 err = -EFAULT;
949 goto exit;
950 }
951
952 exit:
953 return err;
954 }
955
956 #ifndef IW_RETRY_LONG
957 #define IW_RETRY_LONG IW_RETRY_MAX
958 #endif
959
960 #ifndef IW_RETRY_SHORT
961 #define IW_RETRY_SHORT IW_RETRY_MIN
962 #endif
963
964 static int p80211wext_giwretry(netdevice_t * dev,
965 struct iw_request_info *info,
966 struct iw_param *rrq, char *extra)
967 {
968 wlandevice_t *wlandev = dev->ml_priv;
969 p80211item_uint32_t mibitem;
970 p80211msg_dot11req_mibset_t msg;
971 int result;
972 int err = 0;
973 u16 shortretry, longretry, lifetime;
974
975 msg.msgcode = DIDmsg_dot11req_mibget;
976 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11ShortRetryLimit;
977
978 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
979 result = p80211req_dorequest(wlandev, (u8 *) & msg);
980
981 if (result) {
982 err = -EFAULT;
983 goto exit;
984 }
985
986 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
987
988 shortretry = mibitem.data;
989
990 mibitem.did = DIDmib_dot11mac_dot11OperationTable_dot11LongRetryLimit;
991
992 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
993 result = p80211req_dorequest(wlandev, (u8 *) & msg);
994
995 if (result) {
996 err = -EFAULT;
997 goto exit;
998 }
999
1000 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1001
1002 longretry = mibitem.data;
1003
1004 mibitem.did =
1005 DIDmib_dot11mac_dot11OperationTable_dot11MaxTransmitMSDULifetime;
1006
1007 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1008 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1009
1010 if (result) {
1011 err = -EFAULT;
1012 goto exit;
1013 }
1014
1015 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1016
1017 lifetime = mibitem.data;
1018
1019 rrq->disabled = 0;
1020
1021 if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
1022 rrq->flags = IW_RETRY_LIFETIME;
1023 rrq->value = lifetime * 1024;
1024 } else {
1025 if (rrq->flags & IW_RETRY_LONG) {
1026 rrq->flags = IW_RETRY_LIMIT | IW_RETRY_LONG;
1027 rrq->value = longretry;
1028 } else {
1029 rrq->flags = IW_RETRY_LIMIT;
1030 rrq->value = shortretry;
1031 if (shortretry != longretry)
1032 rrq->flags |= IW_RETRY_SHORT;
1033 }
1034 }
1035
1036 exit:
1037 return err;
1038
1039 }
1040
1041 static int p80211wext_siwretry(netdevice_t * dev,
1042 struct iw_request_info *info,
1043 struct iw_param *rrq, char *extra)
1044 {
1045 wlandevice_t *wlandev = dev->ml_priv;
1046 p80211item_uint32_t mibitem;
1047 p80211msg_dot11req_mibset_t msg;
1048 int result;
1049 int err = 0;
1050
1051 if (!wlan_wext_write) {
1052 err = (-EOPNOTSUPP);
1053 goto exit;
1054 }
1055
1056 if (rrq->disabled) {
1057 err = -EINVAL;
1058 goto exit;
1059 }
1060
1061 msg.msgcode = DIDmsg_dot11req_mibset;
1062
1063 if ((rrq->flags & IW_RETRY_TYPE) == IW_RETRY_LIFETIME) {
1064 mibitem.did =
1065 DIDmib_dot11mac_dot11OperationTable_dot11MaxTransmitMSDULifetime;
1066 mibitem.data = rrq->value /= 1024;
1067
1068 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1069 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1070
1071 if (result) {
1072 err = -EFAULT;
1073 goto exit;
1074 }
1075 } else {
1076 if (rrq->flags & IW_RETRY_LONG) {
1077 mibitem.did =
1078 DIDmib_dot11mac_dot11OperationTable_dot11LongRetryLimit;
1079 mibitem.data = rrq->value;
1080
1081 memcpy(&msg.mibattribute.data, &mibitem,
1082 sizeof(mibitem));
1083 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1084
1085 if (result) {
1086 err = -EFAULT;
1087 goto exit;
1088 }
1089 }
1090
1091 if (rrq->flags & IW_RETRY_SHORT) {
1092 mibitem.did =
1093 DIDmib_dot11mac_dot11OperationTable_dot11ShortRetryLimit;
1094 mibitem.data = rrq->value;
1095
1096 memcpy(&msg.mibattribute.data, &mibitem,
1097 sizeof(mibitem));
1098 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1099
1100 if (result) {
1101 err = -EFAULT;
1102 goto exit;
1103 }
1104 }
1105 }
1106
1107 exit:
1108 return err;
1109
1110 }
1111
1112 static int p80211wext_siwtxpow(netdevice_t * dev,
1113 struct iw_request_info *info,
1114 struct iw_param *rrq, char *extra)
1115 {
1116 wlandevice_t *wlandev = dev->ml_priv;
1117 p80211item_uint32_t mibitem;
1118 p80211msg_dot11req_mibset_t msg;
1119 int result;
1120 int err = 0;
1121
1122 if (!wlan_wext_write) {
1123 err = (-EOPNOTSUPP);
1124 goto exit;
1125 }
1126
1127 msg.msgcode = DIDmsg_dot11req_mibset;
1128 mibitem.did =
1129 DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel;
1130 if (rrq->fixed == 0)
1131 mibitem.data = 30;
1132 else
1133 mibitem.data = rrq->value;
1134 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1135 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1136
1137 if (result) {
1138 err = -EFAULT;
1139 goto exit;
1140 }
1141
1142 exit:
1143 return err;
1144 }
1145
1146 static int p80211wext_giwtxpow(netdevice_t * dev,
1147 struct iw_request_info *info,
1148 struct iw_param *rrq, char *extra)
1149 {
1150 wlandevice_t *wlandev = dev->ml_priv;
1151 p80211item_uint32_t mibitem;
1152 p80211msg_dot11req_mibset_t msg;
1153 int result;
1154 int err = 0;
1155
1156 msg.msgcode = DIDmsg_dot11req_mibget;
1157 mibitem.did =
1158 DIDmib_dot11phy_dot11PhyTxPowerTable_dot11CurrentTxPowerLevel;
1159
1160 memcpy(&msg.mibattribute.data, &mibitem, sizeof(mibitem));
1161 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1162
1163 if (result) {
1164 err = -EFAULT;
1165 goto exit;
1166 }
1167
1168 memcpy(&mibitem, &msg.mibattribute.data, sizeof(mibitem));
1169
1170 /* XXX handle OFF by setting disabled = 1; */
1171
1172 rrq->flags = 0; /* IW_TXPOW_DBM; */
1173 rrq->disabled = 0;
1174 rrq->fixed = 0;
1175 rrq->value = mibitem.data;
1176
1177 exit:
1178 return err;
1179 }
1180
1181 static int p80211wext_siwspy(netdevice_t * dev,
1182 struct iw_request_info *info,
1183 struct iw_point *srq, char *extra)
1184 {
1185 wlandevice_t *wlandev = dev->ml_priv;
1186 struct sockaddr address[IW_MAX_SPY];
1187 int number = srq->length;
1188 int i;
1189
1190 /* Copy the data from the input buffer */
1191 memcpy(address, extra, sizeof(struct sockaddr) * number);
1192
1193 wlandev->spy_number = 0;
1194
1195 if (number > 0) {
1196
1197 /* extract the addresses */
1198 for (i = 0; i < number; i++) {
1199
1200 memcpy(wlandev->spy_address[i], address[i].sa_data,
1201 ETH_ALEN);
1202 }
1203
1204 /* reset stats */
1205 memset(wlandev->spy_stat, 0,
1206 sizeof(struct iw_quality) * IW_MAX_SPY);
1207
1208 /* set number of addresses */
1209 wlandev->spy_number = number;
1210 }
1211
1212 return 0;
1213 }
1214
1215 /* jkriegl: from orinoco, modified */
1216 static int p80211wext_giwspy(netdevice_t * dev,
1217 struct iw_request_info *info,
1218 struct iw_point *srq, char *extra)
1219 {
1220 wlandevice_t *wlandev = dev->ml_priv;
1221
1222 struct sockaddr address[IW_MAX_SPY];
1223 struct iw_quality spy_stat[IW_MAX_SPY];
1224 int number;
1225 int i;
1226
1227 number = wlandev->spy_number;
1228
1229 if (number > 0) {
1230
1231 /* populate address and spy struct's */
1232 for (i = 0; i < number; i++) {
1233 memcpy(address[i].sa_data, wlandev->spy_address[i],
1234 ETH_ALEN);
1235 address[i].sa_family = AF_UNIX;
1236 memcpy(&spy_stat[i], &wlandev->spy_stat[i],
1237 sizeof(struct iw_quality));
1238 }
1239
1240 /* reset update flag */
1241 for (i = 0; i < number; i++)
1242 wlandev->spy_stat[i].updated = 0;
1243 }
1244
1245 /* push stuff to user space */
1246 srq->length = number;
1247 memcpy(extra, address, sizeof(struct sockaddr) * number);
1248 memcpy(extra + sizeof(struct sockaddr) * number, spy_stat,
1249 sizeof(struct iw_quality) * number);
1250
1251 return 0;
1252 }
1253
1254 static int prism2_result2err(int prism2_result)
1255 {
1256 int err = 0;
1257
1258 switch (prism2_result) {
1259 case P80211ENUM_resultcode_invalid_parameters:
1260 err = -EINVAL;
1261 break;
1262 case P80211ENUM_resultcode_implementation_failure:
1263 err = -EIO;
1264 break;
1265 case P80211ENUM_resultcode_not_supported:
1266 err = -EOPNOTSUPP;
1267 break;
1268 default:
1269 err = 0;
1270 break;
1271 }
1272
1273 return err;
1274 }
1275
1276 static int p80211wext_siwscan(netdevice_t * dev,
1277 struct iw_request_info *info,
1278 struct iw_point *srq, char *extra)
1279 {
1280 wlandevice_t *wlandev = dev->ml_priv;
1281 p80211msg_dot11req_scan_t msg;
1282 int result;
1283 int err = 0;
1284 int i = 0;
1285
1286 if (wlandev->macmode == WLAN_MACMODE_ESS_AP) {
1287 printk(KERN_ERR "Can't scan in AP mode\n");
1288 err = (-EOPNOTSUPP);
1289 goto exit;
1290 }
1291
1292 memset(&msg, 0x00, sizeof(p80211msg_dot11req_scan_t));
1293 msg.msgcode = DIDmsg_dot11req_scan;
1294 msg.bsstype.data = P80211ENUM_bsstype_any;
1295
1296 memset(&(msg.bssid.data), 0xFF, sizeof(p80211item_pstr6_t));
1297 msg.bssid.data.len = 6;
1298
1299 msg.scantype.data = P80211ENUM_scantype_active;
1300 msg.probedelay.data = 0;
1301
1302 for (i = 1; i <= 14; i++)
1303 msg.channellist.data.data[i - 1] = i;
1304 msg.channellist.data.len = 14;
1305
1306 msg.maxchanneltime.data = 250;
1307 msg.minchanneltime.data = 200;
1308
1309 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1310 if (result)
1311 err = prism2_result2err(msg.resultcode.data);
1312
1313 exit:
1314 return err;
1315 }
1316
1317 /* Helper to translate scan into Wireless Extensions scan results.
1318 * Inspired by the prism54 code, which was in turn inspired by the
1319 * airo driver code.
1320 */
1321 static char *wext_translate_bss(struct iw_request_info *info, char *current_ev,
1322 char *end_buf,
1323 p80211msg_dot11req_scan_results_t * bss)
1324 {
1325 struct iw_event iwe; /* Temporary buffer */
1326
1327 /* The first entry must be the MAC address */
1328 memcpy(iwe.u.ap_addr.sa_data, bss->bssid.data.data, WLAN_BSSID_LEN);
1329 iwe.u.ap_addr.sa_family = ARPHRD_ETHER;
1330 iwe.cmd = SIOCGIWAP;
1331 current_ev =
1332 iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1333 IW_EV_ADDR_LEN);
1334
1335 /* The following entries will be displayed in the same order we give them */
1336
1337 /* The ESSID. */
1338 if (bss->ssid.data.len > 0) {
1339 char essid[IW_ESSID_MAX_SIZE + 1];
1340 int size;
1341
1342 size =
1343 min_t(unsigned short, IW_ESSID_MAX_SIZE,
1344 bss->ssid.data.len);
1345 memset(&essid, 0, sizeof(essid));
1346 memcpy(&essid, bss->ssid.data.data, size);
1347 pr_debug(" essid size = %d\n", size);
1348 iwe.u.data.length = size;
1349 iwe.u.data.flags = 1;
1350 iwe.cmd = SIOCGIWESSID;
1351 current_ev =
1352 iwe_stream_add_point(info, current_ev, end_buf, &iwe,
1353 &essid[0]);
1354 pr_debug(" essid size OK.\n");
1355 }
1356
1357 switch (bss->bsstype.data) {
1358 case P80211ENUM_bsstype_infrastructure:
1359 iwe.u.mode = IW_MODE_MASTER;
1360 break;
1361
1362 case P80211ENUM_bsstype_independent:
1363 iwe.u.mode = IW_MODE_ADHOC;
1364 break;
1365
1366 default:
1367 iwe.u.mode = 0;
1368 break;
1369 }
1370 iwe.cmd = SIOCGIWMODE;
1371 if (iwe.u.mode)
1372 current_ev =
1373 iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1374 IW_EV_UINT_LEN);
1375
1376 /* Encryption capability */
1377 if (bss->privacy.data == P80211ENUM_truth_true)
1378 iwe.u.data.flags = IW_ENCODE_ENABLED | IW_ENCODE_NOKEY;
1379 else
1380 iwe.u.data.flags = IW_ENCODE_DISABLED;
1381 iwe.u.data.length = 0;
1382 iwe.cmd = SIOCGIWENCODE;
1383 current_ev =
1384 iwe_stream_add_point(info, current_ev, end_buf, &iwe, NULL);
1385
1386 /* Add frequency. (short) bss->channel is the frequency in MHz */
1387 iwe.u.freq.m = bss->dschannel.data;
1388 iwe.u.freq.e = 0;
1389 iwe.cmd = SIOCGIWFREQ;
1390 current_ev =
1391 iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1392 IW_EV_FREQ_LEN);
1393
1394 /* Add quality statistics */
1395 iwe.u.qual.level = bss->signal.data;
1396 iwe.u.qual.noise = bss->noise.data;
1397 /* do a simple SNR for quality */
1398 iwe.u.qual.qual = qual_as_percent(bss->signal.data - bss->noise.data);
1399 iwe.cmd = IWEVQUAL;
1400 current_ev =
1401 iwe_stream_add_event(info, current_ev, end_buf, &iwe,
1402 IW_EV_QUAL_LEN);
1403
1404 return current_ev;
1405 }
1406
1407 static int p80211wext_giwscan(netdevice_t * dev,
1408 struct iw_request_info *info,
1409 struct iw_point *srq, char *extra)
1410 {
1411 wlandevice_t *wlandev = dev->ml_priv;
1412 p80211msg_dot11req_scan_results_t msg;
1413 int result = 0;
1414 int err = 0;
1415 int i = 0;
1416 int scan_good = 0;
1417 char *current_ev = extra;
1418
1419 /* Since wireless tools doesn't really have a way of passing how
1420 * many scan results results there were back here, keep grabbing them
1421 * until we fail.
1422 */
1423 do {
1424 memset(&msg, 0, sizeof(msg));
1425 msg.msgcode = DIDmsg_dot11req_scan_results;
1426 msg.bssindex.data = i;
1427
1428 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1429 if ((result != 0) ||
1430 (msg.resultcode.data != P80211ENUM_resultcode_success)) {
1431 break;
1432 }
1433
1434 current_ev =
1435 wext_translate_bss(info, current_ev,
1436 extra + IW_SCAN_MAX_DATA, &msg);
1437 scan_good = 1;
1438 i++;
1439 } while (i < IW_MAX_AP);
1440
1441 srq->length = (current_ev - extra);
1442 srq->flags = 0; /* todo */
1443
1444 if (result && !scan_good)
1445 err = prism2_result2err(msg.resultcode.data);
1446
1447 return err;
1448 }
1449
1450 /* extra wireless extensions stuff to support NetworkManager (I hope) */
1451
1452 /* SIOCSIWENCODEEXT */
1453 static int p80211wext_set_encodeext(struct net_device *dev,
1454 struct iw_request_info *info,
1455 union iwreq_data *wrqu, char *extra)
1456 {
1457 wlandevice_t *wlandev = dev->ml_priv;
1458 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1459 p80211msg_dot11req_mibset_t msg;
1460 p80211item_pstr32_t *pstr;
1461
1462 int result = 0;
1463 struct iw_point *encoding = &wrqu->encoding;
1464 int idx = encoding->flags & IW_ENCODE_INDEX;
1465
1466 pr_debug("set_encode_ext flags[%d] alg[%d] keylen[%d]\n",
1467 ext->ext_flags, (int)ext->alg, (int)ext->key_len);
1468
1469 if (ext->ext_flags & IW_ENCODE_EXT_GROUP_KEY) {
1470 /* set default key ? I'm not sure if this the the correct thing to do here */
1471
1472 if (idx) {
1473 if (idx < 1 || idx > NUM_WEPKEYS)
1474 return -EINVAL;
1475 else
1476 idx--;
1477 }
1478 pr_debug("setting default key (%d)\n", idx);
1479 result =
1480 p80211wext_dorequest(wlandev,
1481 DIDmib_dot11smt_dot11PrivacyTable_dot11WEPDefaultKeyID,
1482 idx);
1483 if (result)
1484 return -EFAULT;
1485 }
1486
1487 if (ext->ext_flags & IW_ENCODE_EXT_SET_TX_KEY) {
1488 if (ext->alg != IW_ENCODE_ALG_WEP) {
1489 pr_debug("asked to set a non wep key :(\n");
1490 return -EINVAL;
1491 }
1492 if (idx) {
1493 if (idx < 1 || idx > NUM_WEPKEYS)
1494 return -EINVAL;
1495 else
1496 idx--;
1497 }
1498 pr_debug("Set WEP key (%d)\n", idx);
1499 wlandev->wep_keylens[idx] = ext->key_len;
1500 memcpy(wlandev->wep_keys[idx], ext->key, ext->key_len);
1501
1502 memset(&msg, 0, sizeof(msg));
1503 pstr = (p80211item_pstr32_t *) & msg.mibattribute.data;
1504 memcpy(pstr->data.data, ext->key, ext->key_len);
1505 pstr->data.len = ext->key_len;
1506 switch (idx) {
1507 case 0:
1508 pstr->did =
1509 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey0;
1510 break;
1511 case 1:
1512 pstr->did =
1513 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey1;
1514 break;
1515 case 2:
1516 pstr->did =
1517 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey2;
1518 break;
1519 case 3:
1520 pstr->did =
1521 DIDmib_dot11smt_dot11WEPDefaultKeysTable_dot11WEPDefaultKey3;
1522 break;
1523 default:
1524 break;
1525 }
1526 msg.msgcode = DIDmsg_dot11req_mibset;
1527 result = p80211req_dorequest(wlandev, (u8 *) & msg);
1528 pr_debug("result (%d)\n", result);
1529 }
1530 return result;
1531 }
1532
1533 /* SIOCGIWENCODEEXT */
1534 static int p80211wext_get_encodeext(struct net_device *dev,
1535 struct iw_request_info *info,
1536 union iwreq_data *wrqu, char *extra)
1537 {
1538 wlandevice_t *wlandev = dev->ml_priv;
1539 struct iw_encode_ext *ext = (struct iw_encode_ext *)extra;
1540
1541 struct iw_point *encoding = &wrqu->encoding;
1542 int result = 0;
1543 int max_len;
1544 int idx;
1545
1546 pr_debug("get_encode_ext flags[%d] alg[%d] keylen[%d]\n",
1547 ext->ext_flags, (int)ext->alg, (int)ext->key_len);
1548
1549 max_len = encoding->length - sizeof(*ext);
1550 if (max_len <= 0) {
1551 pr_debug("get_encodeext max_len [%d] invalid\n", max_len);
1552 result = -EINVAL;
1553 goto exit;
1554 }
1555 idx = encoding->flags & IW_ENCODE_INDEX;
1556
1557 pr_debug("get_encode_ext index [%d]\n", idx);
1558
1559 if (idx) {
1560 if (idx < 1 || idx > NUM_WEPKEYS) {
1561 pr_debug("get_encode_ext invalid key index [%d]\n",
1562 idx);
1563 result = -EINVAL;
1564 goto exit;
1565 }
1566 idx--;
1567 } else {
1568 /* default key ? not sure what to do */
1569 /* will just use key[0] for now ! FIX ME */
1570 }
1571
1572 encoding->flags = idx + 1;
1573 memset(ext, 0, sizeof(*ext));
1574
1575 ext->alg = IW_ENCODE_ALG_WEP;
1576 ext->key_len = wlandev->wep_keylens[idx];
1577 memcpy(ext->key, wlandev->wep_keys[idx], ext->key_len);
1578
1579 encoding->flags |= IW_ENCODE_ENABLED;
1580 exit:
1581 return result;
1582 }
1583
1584 /* SIOCSIWAUTH */
1585 static int p80211_wext_set_iwauth(struct net_device *dev,
1586 struct iw_request_info *info,
1587 union iwreq_data *wrqu, char *extra)
1588 {
1589 wlandevice_t *wlandev = dev->ml_priv;
1590 struct iw_param *param = &wrqu->param;
1591 int result = 0;
1592
1593 pr_debug("set_iwauth flags[%d]\n", (int)param->flags & IW_AUTH_INDEX);
1594
1595 switch (param->flags & IW_AUTH_INDEX) {
1596 case IW_AUTH_DROP_UNENCRYPTED:
1597 pr_debug("drop_unencrypted %d\n", param->value);
1598 if (param->value)
1599 result =
1600 p80211wext_dorequest(wlandev,
1601 DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted,
1602 P80211ENUM_truth_true);
1603 else
1604 result =
1605 p80211wext_dorequest(wlandev,
1606 DIDmib_dot11smt_dot11PrivacyTable_dot11ExcludeUnencrypted,
1607 P80211ENUM_truth_false);
1608 break;
1609
1610 case IW_AUTH_PRIVACY_INVOKED:
1611 pr_debug("privacy invoked %d\n", param->value);
1612 if (param->value)
1613 result =
1614 p80211wext_dorequest(wlandev,
1615 DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked,
1616 P80211ENUM_truth_true);
1617 else
1618 result =
1619 p80211wext_dorequest(wlandev,
1620 DIDmib_dot11smt_dot11PrivacyTable_dot11PrivacyInvoked,
1621 P80211ENUM_truth_false);
1622
1623 break;
1624
1625 case IW_AUTH_80211_AUTH_ALG:
1626 if (param->value & IW_AUTH_ALG_OPEN_SYSTEM) {
1627 pr_debug("set open_system\n");
1628 wlandev->hostwep &= ~HOSTWEP_SHAREDKEY;
1629 } else if (param->value & IW_AUTH_ALG_SHARED_KEY) {
1630 pr_debug("set shared key\n");
1631 wlandev->hostwep |= HOSTWEP_SHAREDKEY;
1632 } else {
1633 /* don't know what to do know */
1634 pr_debug("unknown AUTH_ALG (%d)\n", param->value);
1635 result = -EINVAL;
1636 }
1637 break;
1638
1639 default:
1640 break;
1641 }
1642
1643 return result;
1644 }
1645
1646 /* SIOCSIWAUTH */
1647 static int p80211_wext_get_iwauth(struct net_device *dev,
1648 struct iw_request_info *info,
1649 union iwreq_data *wrqu, char *extra)
1650 {
1651 wlandevice_t *wlandev = dev->ml_priv;
1652 struct iw_param *param = &wrqu->param;
1653 int result = 0;
1654
1655 pr_debug("get_iwauth flags[%d]\n", (int)param->flags & IW_AUTH_INDEX);
1656
1657 switch (param->flags & IW_AUTH_INDEX) {
1658 case IW_AUTH_DROP_UNENCRYPTED:
1659 param->value =
1660 wlandev->hostwep & HOSTWEP_EXCLUDEUNENCRYPTED ? 1 : 0;
1661 break;
1662
1663 case IW_AUTH_PRIVACY_INVOKED:
1664 param->value =
1665 wlandev->hostwep & HOSTWEP_PRIVACYINVOKED ? 1 : 0;
1666 break;
1667
1668 case IW_AUTH_80211_AUTH_ALG:
1669 param->value =
1670 wlandev->hostwep & HOSTWEP_SHAREDKEY ?
1671 IW_AUTH_ALG_SHARED_KEY : IW_AUTH_ALG_OPEN_SYSTEM;
1672 break;
1673
1674 default:
1675 break;
1676 }
1677
1678 return result;
1679 }
1680
1681 static iw_handler p80211wext_handlers[] = {
1682 (iw_handler) p80211wext_siwcommit, /* SIOCSIWCOMMIT */
1683 (iw_handler) p80211wext_giwname, /* SIOCGIWNAME */
1684 (iw_handler) NULL, /* SIOCSIWNWID */
1685 (iw_handler) NULL, /* SIOCGIWNWID */
1686 (iw_handler) p80211wext_siwfreq, /* SIOCSIWFREQ */
1687 (iw_handler) p80211wext_giwfreq, /* SIOCGIWFREQ */
1688 (iw_handler) p80211wext_siwmode, /* SIOCSIWMODE */
1689 (iw_handler) p80211wext_giwmode, /* SIOCGIWMODE */
1690 (iw_handler) NULL, /* SIOCSIWSENS */
1691 (iw_handler) NULL, /* SIOCGIWSENS */
1692 (iw_handler) NULL, /* not used *//* SIOCSIWRANGE */
1693 (iw_handler) p80211wext_giwrange, /* SIOCGIWRANGE */
1694 (iw_handler) NULL, /* not used *//* SIOCSIWPRIV */
1695 (iw_handler) NULL, /* kernel code *//* SIOCGIWPRIV */
1696 (iw_handler) NULL, /* not used *//* SIOCSIWSTATS */
1697 (iw_handler) NULL, /* kernel code *//* SIOCGIWSTATS */
1698 (iw_handler) p80211wext_siwspy, /* SIOCSIWSPY */
1699 (iw_handler) p80211wext_giwspy, /* SIOCGIWSPY */
1700 (iw_handler) NULL, /* -- hole -- */
1701 (iw_handler) NULL, /* -- hole -- */
1702 (iw_handler) NULL, /* SIOCSIWAP */
1703 (iw_handler) p80211wext_giwap, /* SIOCGIWAP */
1704 (iw_handler) NULL, /* -- hole -- */
1705 (iw_handler) NULL, /* SIOCGIWAPLIST */
1706 (iw_handler) p80211wext_siwscan, /* SIOCSIWSCAN */
1707 (iw_handler) p80211wext_giwscan, /* SIOCGIWSCAN */
1708 (iw_handler) p80211wext_siwessid, /* SIOCSIWESSID */
1709 (iw_handler) p80211wext_giwessid, /* SIOCGIWESSID */
1710 (iw_handler) NULL, /* SIOCSIWNICKN */
1711 (iw_handler) p80211wext_giwessid, /* SIOCGIWNICKN */
1712 (iw_handler) NULL, /* -- hole -- */
1713 (iw_handler) NULL, /* -- hole -- */
1714 (iw_handler) NULL, /* SIOCSIWRATE */
1715 (iw_handler) p80211wext_giwrate, /* SIOCGIWRATE */
1716 (iw_handler) p80211wext_siwrts, /* SIOCSIWRTS */
1717 (iw_handler) p80211wext_giwrts, /* SIOCGIWRTS */
1718 (iw_handler) p80211wext_siwfrag, /* SIOCSIWFRAG */
1719 (iw_handler) p80211wext_giwfrag, /* SIOCGIWFRAG */
1720 (iw_handler) p80211wext_siwtxpow, /* SIOCSIWTXPOW */
1721 (iw_handler) p80211wext_giwtxpow, /* SIOCGIWTXPOW */
1722 (iw_handler) p80211wext_siwretry, /* SIOCSIWRETRY */
1723 (iw_handler) p80211wext_giwretry, /* SIOCGIWRETRY */
1724 (iw_handler) p80211wext_siwencode, /* SIOCSIWENCODE */
1725 (iw_handler) p80211wext_giwencode, /* SIOCGIWENCODE */
1726 (iw_handler) NULL, /* SIOCSIWPOWER */
1727 (iw_handler) NULL, /* SIOCGIWPOWER */
1728 /* WPA operations */
1729 (iw_handler) NULL, /* -- hole -- */
1730 (iw_handler) NULL, /* -- hole -- */
1731 (iw_handler) NULL, /* SIOCSIWGENIE set generic IE */
1732 (iw_handler) NULL, /* SIOCGIWGENIE get generic IE */
1733 (iw_handler) p80211_wext_set_iwauth, /* SIOCSIWAUTH set authentication mode params */
1734 (iw_handler) p80211_wext_get_iwauth, /* SIOCGIWAUTH get authentication mode params */
1735
1736 (iw_handler) p80211wext_set_encodeext, /* SIOCSIWENCODEEXT set encoding token & mode */
1737 (iw_handler) p80211wext_get_encodeext, /* SIOCGIWENCODEEXT get encoding token & mode */
1738 (iw_handler) NULL, /* SIOCSIWPMKSA PMKSA cache operation */
1739 };
1740
1741 struct iw_handler_def p80211wext_handler_def = {
1742 .num_standard = ARRAY_SIZE(p80211wext_handlers),
1743 .num_private = 0,
1744 .num_private_args = 0,
1745 .standard = p80211wext_handlers,
1746 .private = NULL,
1747 .private_args = NULL,
1748 .get_wireless_stats = p80211wext_get_wireless_stats
1749 };
1750
1751 int p80211wext_event_associated(wlandevice_t * wlandev, int assoc)
1752 {
1753 union iwreq_data data;
1754
1755 /* Send the association state first */
1756 data.ap_addr.sa_family = ARPHRD_ETHER;
1757 if (assoc)
1758 memcpy(data.ap_addr.sa_data, wlandev->bssid, ETH_ALEN);
1759 else
1760 memset(data.ap_addr.sa_data, 0, ETH_ALEN);
1761
1762 if (wlan_wext_write)
1763 wireless_send_event(wlandev->netdev, SIOCGIWAP, &data, NULL);
1764
1765 if (!assoc)
1766 goto done;
1767
1768 /* XXX send association data, like IEs, etc etc. */
1769
1770 done:
1771 return 0;
1772 }
Linux with added FPC-III support