?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
loader: Minor cosmetic changes.
[unleashed.git] / kernel / net / net80211 / net80211_ioctl.c
blob25ef1e4fde99c5190fb74735aa2584a59f717363
1 /*
2 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
3 * Use is subject to license terms.
4 */
5
6 /*
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * Alternatively, this software may be distributed under the terms of the
19 * GNU General Public License ("GPL") version 2 as published by the Free
20 * Software Foundation.
21 *
22 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32 */
33
34
35 #include <sys/param.h>
36 #include <sys/types.h>
37 #include <sys/errno.h>
38 #include <sys/strsun.h>
39 #include <sys/policy.h>
40 #include <inet/common.h>
41 #include <inet/nd.h>
42 #include <inet/mi.h>
43 #include <sys/note.h>
44 #include <sys/mac_provider.h>
45 #include <inet/wifi_ioctl.h>
46 #include "net80211_impl.h"
47
48 static int wl_set_essid(struct ieee80211com *, const void *);
49 static void wl_get_essid(struct ieee80211com *, void *);
50 static int wl_set_bssid(struct ieee80211com *, const void *);
51 static void wl_get_bssid(struct ieee80211com *, void *);
52 static int wl_set_bsstype(struct ieee80211com *, const void *);
53 static void wl_get_bsstype(struct ieee80211com *, void *);
54 static void wl_get_linkstatus(struct ieee80211com *, void *);
55 static int wl_set_desrates(struct ieee80211com *, const void *);
56 static void wl_get_desrates(struct ieee80211com *, void *);
57 static int wl_set_authmode(struct ieee80211com *, const void *);
58 static void wl_get_authmode(struct ieee80211com *, void *);
59 static int wl_set_encrypt(struct ieee80211com *, const void *);
60 static void wl_get_encrypt(struct ieee80211com *, void *);
61 static void wl_get_rssi(struct ieee80211com *, void *);
62 static int wl_set_phy(struct ieee80211com *, const void *);
63 static int wl_get_phy(struct ieee80211com *, void *);
64 static void wl_get_capability(struct ieee80211com *, void *);
65 static int wl_set_wpa(struct ieee80211com *, const void *);
66 static void wl_get_wpa(struct ieee80211com *, void *);
67 static void wl_get_scanresults(struct ieee80211com *, void *);
68 static void wl_get_esslist(struct ieee80211com *, void *);
69 static int wl_set_wepkey(struct ieee80211com *, const void *);
70 static int wl_set_optie(struct ieee80211com *, const void *);
71 static int wl_set_delkey(struct ieee80211com *, const void *);
72 static int wl_set_mlme(struct ieee80211com *, const void *);
73 static int wl_set_wpakey(struct ieee80211com *, const void *);
74 static void wl_get_suprates(struct ieee80211com *, void *);
75 static int wl_set_createibss(struct ieee80211com *, const void *);
76 static void wl_get_createibss(struct ieee80211com *, void *);
77
78 static size_t
79 wifi_strnlen(const char *s, size_t n)
80 {
81 size_t i;
82
83 for (i = 0; i < n && s[i] != '\0'; i++)
84 /* noop */;
85 return (i);
86 }
87
88 /*
89 * Initialize an output message block by copying from an
90 * input message block. The message is of type wldp_t.
91 * mp input message block
92 * buflen length of wldp_buf
93 */
94 static void
95 wifi_setupoutmsg(mblk_t *mp, int buflen)
96 {
97 wldp_t *wp;
98
99 wp = (wldp_t *)mp->b_rptr;
100 wp->wldp_length = WIFI_BUF_OFFSET + buflen;
101 wp->wldp_result = WL_SUCCESS;
102 mp->b_wptr = mp->b_rptr + wp->wldp_length;
103 }
104
105 /*
106 * Allocate and initialize an output message.
107 */
108 static mblk_t *
109 wifi_getoutmsg(mblk_t *mp, uint32_t cmd, int buflen)
110 {
111 mblk_t *mp1;
112 int size;
113
114 size = WIFI_BUF_OFFSET;
115 if (cmd == WLAN_GET_PARAM)
116 size += buflen; /* to hold output parameters */
117 mp1 = allocb(size, BPRI_HI);
118 if (mp1 == NULL) {
119 ieee80211_err("wifi_getoutbuf: allocb %d bytes failed!\n",
120 size);
121 return (NULL);
122 }
123
124 bzero(mp1->b_rptr, size);
125 bcopy(mp->b_rptr, mp1->b_rptr, WIFI_BUF_OFFSET);
126 wifi_setupoutmsg(mp1, size - WIFI_BUF_OFFSET);
127
128 return (mp1);
129 }
130
131 static int
132 wifi_cfg_essid(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
133 {
134 mblk_t *omp;
135 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
136 wldp_t *outp;
137 wl_essid_t *iw_essid = (wl_essid_t *)inp->wldp_buf;
138 wl_essid_t *ow_essid;
139 int err = 0;
140
141 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_essid_t))) == NULL)
142 return (ENOMEM);
143 outp = (wldp_t *)omp->b_rptr;
144 ow_essid = (wl_essid_t *)outp->wldp_buf;
145
146 switch (cmd) {
147 case WLAN_GET_PARAM:
148 wl_get_essid(ic, ow_essid);
149 break;
150 case WLAN_SET_PARAM:
151 err = wl_set_essid(ic, iw_essid);
152 break;
153 default:
154 ieee80211_err("wifi_cfg_essid: unknown command %x\n", cmd);
155 outp->wldp_result = WL_NOTSUPPORTED;
156 err = EINVAL;
157 break;
158 }
159
160 freemsg(*mp);
161 *mp = omp;
162 return (err);
163 }
164
165 static int
166 wifi_cfg_bssid(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
167 {
168 mblk_t *omp;
169 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
170 wldp_t *outp;
171 int err = 0;
172
173 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_bssid_t))) == NULL)
174 return (ENOMEM);
175 outp = (wldp_t *)omp->b_rptr;
176
177 switch (cmd) {
178 case WLAN_GET_PARAM:
179 wl_get_bssid(ic, outp->wldp_buf);
180 break;
181 case WLAN_SET_PARAM:
182 err = wl_set_bssid(ic, inp->wldp_buf);
183 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wifi_cfg_bssid: "
184 "set bssid=%s\n",
185 ieee80211_macaddr_sprintf(inp->wldp_buf));
186 break;
187 default:
188 ieee80211_err("wifi_cfg_bssid: unknown command %x\n", cmd);
189 outp->wldp_result = WL_NOTSUPPORTED;
190 err = EINVAL;
191 break;
192 }
193
194 freemsg(*mp);
195 *mp = omp;
196 return (err);
197 }
198
199 static int
200 wifi_cfg_nodename(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
201 {
202 mblk_t *omp;
203 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
204 wldp_t *outp;
205 wl_nodename_t *iw_name = (wl_nodename_t *)inp->wldp_buf;
206 wl_nodename_t *ow_name;
207 char *nodename;
208 int len, err;
209
210 err = 0;
211 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_nodename_t))) == NULL)
212 return (ENOMEM);
213 outp = (wldp_t *)omp->b_rptr;
214 ow_name = (wl_nodename_t *)outp->wldp_buf;
215
216 switch (cmd) {
217 case WLAN_GET_PARAM:
218 len = wifi_strnlen((const char *)ic->ic_nickname,
219 IEEE80211_NWID_LEN);
220 ow_name->wl_nodename_length = len;
221 bcopy(ic->ic_nickname, ow_name->wl_nodename_name, len);
222 break;
223 case WLAN_SET_PARAM:
224 if (iw_name->wl_nodename_length > IEEE80211_NWID_LEN) {
225 ieee80211_err("wifi_cfg_nodename: "
226 "node name too long, %u\n",
227 iw_name->wl_nodename_length);
228 outp->wldp_result = WL_NOTSUPPORTED;
229 err = EINVAL;
230 break;
231 }
232 nodename = iw_name->wl_nodename_name;
233 nodename[IEEE80211_NWID_LEN] = 0;
234 ieee80211_dbg(IEEE80211_MSG_CONFIG,
235 "wifi_cfg_nodename: set nodename %s, len=%d\n",
236 nodename, iw_name->wl_nodename_length);
237
238 len = iw_name->wl_nodename_length;
239 if (len > 0)
240 bcopy(nodename, ic->ic_nickname, len);
241 if (len < IEEE80211_NWID_LEN)
242 ic->ic_nickname[len] = 0;
243 break;
244 default:
245 ieee80211_err("wifi_cfg_nodename: unknown command %x\n", cmd);
246 outp->wldp_result = WL_NOTSUPPORTED;
247 err = EINVAL;
248 break;
249 }
250
251 freemsg(*mp);
252 *mp = omp;
253 return (err);
254 }
255
256 static int
257 wifi_cfg_phy(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
258 {
259 mblk_t *omp;
260 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
261 wldp_t *outp;
262 wl_phy_conf_t *iw_phy = (wl_phy_conf_t *)inp->wldp_buf;
263 wl_phy_conf_t *ow_phy;
264 int err = 0;
265
266 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_phy_conf_t))) == NULL)
267 return (ENOMEM);
268 outp = (wldp_t *)omp->b_rptr;
269 ow_phy = (wl_phy_conf_t *)outp->wldp_buf;
270
271 switch (cmd) {
272 case WLAN_GET_PARAM:
273 err = wl_get_phy(ic, ow_phy);
274 break;
275
276 case WLAN_SET_PARAM:
277 err = wl_set_phy(ic, iw_phy);
278 break;
279
280 default:
281 ieee80211_err("wifi_cfg_phy: unknown command %x\n", cmd);
282 outp->wldp_result = WL_NOTSUPPORTED;
283 err = EINVAL;
284 break;
285 } /* switch (cmd) */
286
287 freemsg(*mp);
288 *mp = omp;
289 return (err);
290 }
291
292 static int
293 wifi_cfg_wepkey(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
294 {
295 mblk_t *omp;
296 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
297 wldp_t *outp;
298 wl_wep_key_t *iw_wepkey = (wl_wep_key_t *)inp->wldp_buf;
299 int err = 0;
300
301 if ((omp = wifi_getoutmsg(*mp, cmd, 0)) == NULL)
302 return (ENOMEM);
303 outp = (wldp_t *)omp->b_rptr;
304
305 switch (cmd) {
306 case WLAN_GET_PARAM:
307 outp->wldp_result = WL_WRITEONLY;
308 err = EINVAL;
309 break;
310 case WLAN_SET_PARAM:
311 if (inp->wldp_length < sizeof (wl_wep_key_tab_t)) {
312 ieee80211_err("wifi_cfg_wepkey: "
313 "parameter too short, %d, expected %d\n",
314 inp->wldp_length, sizeof (wl_wep_key_tab_t));
315 outp->wldp_result = WL_NOTSUPPORTED;
316 err = EINVAL;
317 break;
318 }
319
320 err = wl_set_wepkey(ic, iw_wepkey);
321 break;
322 default:
323 ieee80211_err("wifi_cfg_wepkey: unknown command %x\n", cmd);
324 outp->wldp_result = WL_NOTSUPPORTED;
325 err = EINVAL;
326 break;
327 }
328
329 freemsg(*mp);
330 *mp = omp;
331 return (err);
332 }
333
334 static int
335 wifi_cfg_keyid(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
336 {
337 mblk_t *omp;
338 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
339 wldp_t *outp;
340 wl_wep_key_id_t *iw_kid = (wl_wep_key_id_t *)inp->wldp_buf;
341 wl_wep_key_id_t *ow_kid;
342 int err = 0;
343
344 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_wep_key_id_t))) == NULL)
345 return (ENOMEM);
346 outp = (wldp_t *)omp->b_rptr;
347 ow_kid = (wl_wep_key_id_t *)outp->wldp_buf;
348
349 switch (cmd) {
350 case WLAN_GET_PARAM:
351 *ow_kid = (ic->ic_def_txkey == IEEE80211_KEYIX_NONE) ?
352 0 : ic->ic_def_txkey;
353 break;
354 case WLAN_SET_PARAM:
355 if (*iw_kid >= MAX_NWEPKEYS) {
356 ieee80211_err("wifi_cfg_keyid: "
357 "keyid too large, %u\n", *iw_kid);
358 outp->wldp_result = WL_NOTSUPPORTED;
359 err = EINVAL;
360 } else {
361 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wifi_cfg_keyid: "
362 "set keyid=%u\n", *iw_kid);
363 ic->ic_def_txkey = *iw_kid;
364 err = ENETRESET;
365 }
366 break;
367 default:
368 ieee80211_err("wifi_cfg_keyid: unknown command %x\n", cmd);
369 outp->wldp_result = WL_NOTSUPPORTED;
370 err = EINVAL;
371 break;
372 }
373
374 freemsg(*mp);
375 *mp = omp;
376 return (err);
377 }
378
379 static int
380 wifi_cfg_authmode(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
381 {
382 mblk_t *omp;
383 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
384 wldp_t *outp;
385 wl_authmode_t *iw_auth = (wl_authmode_t *)inp->wldp_buf;
386 wl_authmode_t *ow_auth;
387 int err = 0;
388
389 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_authmode_t))) == NULL)
390 return (ENOMEM);
391 outp = (wldp_t *)omp->b_rptr;
392 ow_auth = (wl_authmode_t *)outp->wldp_buf;
393
394 switch (cmd) {
395 case WLAN_GET_PARAM:
396 wl_get_authmode(ic, ow_auth);
397 break;
398 case WLAN_SET_PARAM:
399 err = wl_set_authmode(ic, iw_auth);
400 break;
401 default:
402 ieee80211_err("wifi_cfg_authmode: unknown command %x\n", cmd);
403 outp->wldp_result = WL_NOTSUPPORTED;
404 err = EINVAL;
405 break;
406 }
407
408 freemsg(*mp);
409 *mp = omp;
410 return (err);
411 }
412
413 static int
414 wifi_cfg_encrypt(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
415 {
416 mblk_t *omp;
417 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
418 wldp_t *outp;
419 wl_encryption_t *iw_encryp = (wl_encryption_t *)inp->wldp_buf;
420 wl_encryption_t *ow_encryp;
421 int err = 0;
422
423 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_encryption_t))) == NULL)
424 return (ENOMEM);
425 outp = (wldp_t *)omp->b_rptr;
426 ow_encryp = (wl_encryption_t *)outp->wldp_buf;
427
428 switch (cmd) {
429 case WLAN_GET_PARAM:
430 wl_get_encrypt(ic, ow_encryp);
431 break;
432 case WLAN_SET_PARAM:
433 err = wl_set_encrypt(ic, iw_encryp);
434 break;
435 default:
436 ieee80211_err("wifi_cfg_encrypt: unknown command %x\n", cmd);
437 outp->wldp_result = WL_NOTSUPPORTED;
438 err = EINVAL;
439 break;
440 }
441
442 freemsg(*mp);
443 *mp = omp;
444 return (err);
445 }
446
447 static int
448 wifi_cfg_bsstype(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
449 {
450 mblk_t *omp;
451 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
452 wldp_t *outp;
453 wl_bss_type_t *iw_opmode = (wl_bss_type_t *)inp->wldp_buf;
454 wl_bss_type_t *ow_opmode;
455 int err = 0;
456
457 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_bss_type_t))) == NULL)
458 return (ENOMEM);
459 outp = (wldp_t *)omp->b_rptr;
460 ow_opmode = (wl_bss_type_t *)outp->wldp_buf;
461
462 switch (cmd) {
463 case WLAN_GET_PARAM:
464 wl_get_bsstype(ic, ow_opmode);
465 break;
466 case WLAN_SET_PARAM:
467 if (*iw_opmode == ic->ic_opmode)
468 break;
469
470 err = wl_set_bsstype(ic, iw_opmode);
471 break;
472 default:
473 ieee80211_err("wifi_cfg_bsstype: unknown command %x\n", cmd);
474 outp->wldp_result = WL_NOTSUPPORTED;
475 err = EINVAL;
476 break;
477 }
478
479 freemsg(*mp);
480 *mp = omp;
481 return (err);
482 }
483
484 static int
485 wifi_cfg_createibss(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
486 {
487 mblk_t *omp;
488 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
489 wldp_t *outp;
490 wl_create_ibss_t *iw_ibss = (wl_create_ibss_t *)inp->wldp_buf;
491 wl_create_ibss_t *ow_ibss;
492 int err = 0;
493
494 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_create_ibss_t))) == NULL)
495 return (ENOMEM);
496 outp = (wldp_t *)omp->b_rptr;
497 ow_ibss = (wl_create_ibss_t *)outp->wldp_buf;
498
499 switch (cmd) {
500 case WLAN_GET_PARAM:
501 wl_get_createibss(ic, ow_ibss);
502 break;
503 case WLAN_SET_PARAM:
504 err = wl_set_createibss(ic, iw_ibss);
505 break;
506 default:
507 ieee80211_err("wifi_cfg_bsstype: unknown command %x\n", cmd);
508 outp->wldp_result = WL_NOTSUPPORTED;
509 err = EINVAL;
510 break;
511 }
512
513 freemsg(*mp);
514 *mp = omp;
515 return (err);
516 }
517
518 static int
519 wifi_cfg_linkstatus(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
520 {
521 mblk_t *omp;
522 wldp_t *outp;
523 wl_linkstatus_t *ow_linkstat;
524 int err = 0;
525
526 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_linkstatus_t))) == NULL)
527 return (ENOMEM);
528 outp = (wldp_t *)omp->b_rptr;
529 ow_linkstat = (wl_linkstatus_t *)outp->wldp_buf;
530
531 switch (cmd) {
532 case WLAN_GET_PARAM:
533 wl_get_linkstatus(ic, ow_linkstat);
534 break;
535 case WLAN_SET_PARAM:
536 outp->wldp_result = WL_READONLY;
537 err = EINVAL;
538 break;
539 default:
540 ieee80211_err("wifi_cfg_linkstatus: unknown command %x\n", cmd);
541 outp->wldp_result = WL_NOTSUPPORTED;
542 err = EINVAL;
543 break;
544 }
545
546 freemsg(*mp);
547 *mp = omp;
548 return (err);
549 }
550
551 static int
552 wifi_cfg_suprates(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
553 {
554 mblk_t *omp;
555 wldp_t *outp;
556 wl_rates_t *ow_rates;
557 int err, buflen;
558
559 err = 0;
560 /* rate value (wl_rates_rates) is of type char */
561 buflen = offsetof(wl_rates_t, wl_rates_rates) +
562 sizeof (char) * IEEE80211_MODE_MAX * IEEE80211_RATE_MAXSIZE;
563 if ((omp = wifi_getoutmsg(*mp, cmd, buflen)) == NULL)
564 return (ENOMEM);
565 outp = (wldp_t *)omp->b_rptr;
566 ow_rates = (wl_rates_t *)outp->wldp_buf;
567
568 switch (cmd) {
569 case WLAN_GET_PARAM:
570 (void) wl_get_suprates(ic, ow_rates);
571 break;
572 case WLAN_SET_PARAM:
573 outp->wldp_result = WL_READONLY;
574 err = EINVAL;
575 break;
576 default:
577 ieee80211_err("wifi_cfg_suprates: unknown command %x\n", cmd);
578 outp->wldp_result = WL_NOTSUPPORTED;
579 err = EINVAL;
580 break;
581 }
582
583 freemsg(*mp);
584 *mp = omp;
585 return (err);
586 }
587
588 static int
589 wifi_cfg_desrates(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
590 {
591 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
592 wl_rates_t *iw_rates = (wl_rates_t *)inp->wldp_buf;
593 mblk_t *omp;
594 wldp_t *outp;
595 wl_rates_t *ow_rates;
596 int err;
597
598 err = 0;
599 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_rates_t))) == NULL)
600 return (ENOMEM);
601 outp = (wldp_t *)omp->b_rptr;
602 ow_rates = (wl_rates_t *)outp->wldp_buf;
603
604 switch (cmd) {
605 case WLAN_GET_PARAM:
606 wl_get_desrates(ic, ow_rates);
607 break;
608 case WLAN_SET_PARAM:
609 err = wl_set_desrates(ic, iw_rates);
610 break;
611 default:
612 ieee80211_err("wifi_cfg_desrates: unknown command %x\n", cmd);
613 outp->wldp_result = WL_NOTSUPPORTED;
614 err = EINVAL;
615 break;
616 }
617
618 freemsg(*mp);
619 *mp = omp;
620 return (err);
621 }
622
623 /*
624 * Rescale device's RSSI value to (0, 15) as required by WiFi
625 * driver IOCTLs (PSARC/2003/722)
626 */
627 static wl_rssi_t
628 wifi_getrssi(struct ieee80211_node *in)
629 {
630 struct ieee80211com *ic = in->in_ic;
631 wl_rssi_t rssi, max_rssi;
632
633 rssi = ic->ic_node_getrssi(in);
634 max_rssi = (ic->ic_maxrssi == 0) ? IEEE80211_MAXRSSI : ic->ic_maxrssi;
635 if (rssi == 0)
636 rssi = 0;
637 else if (rssi >= max_rssi)
638 rssi = MAX_RSSI;
639 else
640 rssi = rssi * MAX_RSSI / max_rssi + 1;
641
642 return (rssi);
643 }
644
645 static int
646 wifi_cfg_rssi(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
647 {
648 mblk_t *omp;
649 wldp_t *outp;
650 wl_rssi_t *ow_rssi;
651 int err = 0;
652
653 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_rssi_t))) == NULL)
654 return (ENOMEM);
655 outp = (wldp_t *)omp->b_rptr;
656 ow_rssi = (wl_rssi_t *)outp->wldp_buf;
657
658 switch (cmd) {
659 case WLAN_GET_PARAM:
660 *ow_rssi = wifi_getrssi(ic->ic_bss);
661 break;
662 case WLAN_SET_PARAM:
663 outp->wldp_result = WL_READONLY;
664 err = EINVAL;
665 break;
666 default:
667 ieee80211_err("wifi_cfg_rssi: unknown command %x\n", cmd);
668 outp->wldp_result = WL_NOTSUPPORTED;
669 return (EINVAL);
670 }
671
672 freemsg(*mp);
673 *mp = omp;
674 return (err);
675 }
676
677 /*
678 * maximum scan wait time in second.
679 * Time spent on scaning one channel is usually 100~200ms. The maximum
680 * number of channels defined in wifi_ioctl.h is 99 (MAX_CHANNEL_NUM).
681 * As a result the maximum total scan time is defined as below in ms.
682 */
683 #define WAIT_SCAN_MAX (200 * MAX_CHANNEL_NUM)
684
685 static void
686 wifi_wait_scan(struct ieee80211com *ic)
687 {
688 ieee80211_impl_t *im = ic->ic_private;
689 clock_t delta = drv_usectohz(WAIT_SCAN_MAX * 1000);
690
691 while ((ic->ic_flags & (IEEE80211_F_SCAN | IEEE80211_F_ASCAN)) != 0) {
692 if (cv_reltimedwait_sig(&im->im_scan_cv, &ic->ic_genlock,
693 delta, TR_CLOCK_TICK) != 0) {
694 break;
695 }
696 }
697 }
698
699 #define WIFI_HAVE_CAP(in, flag) (((in)->in_capinfo & (flag)) ? 1 : 0)
700 #define WIFI_HAVE_HTCAP(in) (((in)->in_htcap != 0) ? 1 : 0)
701
702 /*
703 * Callback function used by ieee80211_iterate_nodes() in
704 * wifi_cfg_esslist() to get info of each node in a node table
705 * arg output buffer, pointer to wl_ess_list_t
706 * in each node in the node table
707 */
708 static void
709 wifi_read_ap(void *arg, struct ieee80211_node *in)
710 {
711 wl_ess_list_t *aps = arg;
712 ieee80211com_t *ic = in->in_ic;
713 struct ieee80211_channel *chan = in->in_chan;
714 struct ieee80211_rateset *rates = &(in->in_rates);
715 wl_ess_conf_t *conf;
716 uint8_t *end;
717 uint_t i, nrates;
718
719 end = (uint8_t *)aps - WIFI_BUF_OFFSET + MAX_BUF_LEN -
720 sizeof (wl_ess_list_t);
721 conf = &aps->wl_ess_list_ess[aps->wl_ess_list_num];
722 if ((uint8_t *)conf > end)
723 return;
724
725 conf->wl_ess_conf_length = sizeof (struct wl_ess_conf);
726
727 /* skip newly allocated NULL bss node */
728 if (IEEE80211_ADDR_EQ(in->in_macaddr, ic->ic_macaddr))
729 return;
730
731 conf->wl_ess_conf_essid.wl_essid_length = in->in_esslen;
732 bcopy(in->in_essid, conf->wl_ess_conf_essid.wl_essid_essid,
733 in->in_esslen);
734 bcopy(in->in_bssid, conf->wl_ess_conf_bssid, IEEE80211_ADDR_LEN);
735 conf->wl_ess_conf_wepenabled =
736 (in->in_capinfo & IEEE80211_CAPINFO_PRIVACY ?
737 WL_ENC_WEP : WL_NOENCRYPTION);
738 conf->wl_ess_conf_bsstype =
739 (in->in_capinfo & IEEE80211_CAPINFO_ESS ?
740 WL_BSS_BSS : WL_BSS_IBSS);
741 conf->wl_ess_conf_sl = wifi_getrssi(in);
742 conf->wl_ess_conf_reserved[0] = (in->in_wpa_ie == NULL? 0 : 1);
743
744 /* physical (FH, DS, ERP) parameters */
745 if (IEEE80211_IS_CHAN_A(chan) || IEEE80211_IS_CHAN_T(chan)) {
746 wl_ofdm_t *ofdm =
747 (wl_ofdm_t *)&((conf->wl_phy_conf).wl_phy_ofdm_conf);
748 ofdm->wl_ofdm_subtype = WL_OFDM;
749 ofdm->wl_ofdm_frequency = chan->ich_freq;
750 ofdm->wl_ofdm_ht_enabled = WIFI_HAVE_HTCAP(in);
751 } else {
752 switch (in->in_phytype) {
753 case IEEE80211_T_FH: {
754 wl_fhss_t *fhss = (wl_fhss_t *)
755 &((conf->wl_phy_conf).wl_phy_fhss_conf);
756
757 fhss->wl_fhss_subtype = WL_FHSS;
758 fhss->wl_fhss_channel = ieee80211_chan2ieee(ic, chan);
759 fhss->wl_fhss_dwelltime = in->in_fhdwell;
760 break;
761 }
762 case IEEE80211_T_DS: {
763 wl_dsss_t *dsss = (wl_dsss_t *)
764 &((conf->wl_phy_conf).wl_phy_dsss_conf);
765
766 dsss->wl_dsss_subtype = WL_DSSS;
767 dsss->wl_dsss_channel = ieee80211_chan2ieee(ic, chan);
768 dsss->wl_dsss_have_short_preamble = WIFI_HAVE_CAP(in,
769 IEEE80211_CAPINFO_SHORT_PREAMBLE);
770 dsss->wl_dsss_agility_enabled = WIFI_HAVE_CAP(in,
771 IEEE80211_CAPINFO_CHNL_AGILITY);
772 dsss->wl_dsss_have_pbcc = dsss->wl_dsss_pbcc_enable =
773 WIFI_HAVE_CAP(in, IEEE80211_CAPINFO_PBCC);
774 break;
775 }
776 case IEEE80211_T_OFDM: {
777 wl_erp_t *erp = (wl_erp_t *)
778 &((conf->wl_phy_conf).wl_phy_erp_conf);
779
780 erp->wl_erp_subtype = WL_ERP;
781 erp->wl_erp_channel = ieee80211_chan2ieee(ic, chan);
782 erp->wl_erp_have_short_preamble = WIFI_HAVE_CAP(in,
783 IEEE80211_CAPINFO_SHORT_PREAMBLE);
784 erp->wl_erp_have_agility = erp->wl_erp_agility_enabled =
785 WIFI_HAVE_CAP(in, IEEE80211_CAPINFO_CHNL_AGILITY);
786 erp->wl_erp_have_pbcc = erp->wl_erp_pbcc_enabled =
787 WIFI_HAVE_CAP(in, IEEE80211_CAPINFO_PBCC);
788 erp->wl_erp_dsss_ofdm_enabled =
789 WIFI_HAVE_CAP(in, IEEE80211_CAPINFO_DSSSOFDM);
790 erp->wl_erp_sst_enabled = WIFI_HAVE_CAP(in,
791 IEEE80211_CAPINFO_SHORT_SLOTTIME);
792 erp->wl_erp_ht_enabled = WIFI_HAVE_HTCAP(in);
793 break;
794 } /* case IEEE80211_T_OFDM */
795 } /* switch in->in_phytype */
796 }
797
798 /* supported rates */
799 nrates = MIN(rates->ir_nrates, MAX_SCAN_SUPPORT_RATES);
800 /*
801 * The number of supported rates might exceed
802 * MAX_SCAN_SUPPORT_RATES. Fill in highest rates
803 * first so userland command could properly show
804 * maximum speed of AP
805 */
806 for (i = 0; i < nrates; i++) {
807 conf->wl_supported_rates[i] =
808 rates->ir_rates[rates->ir_nrates - i - 1];
809 }
810
811 aps->wl_ess_list_num++;
812 }
813
814 static int
815 wifi_cfg_esslist(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
816 {
817 mblk_t *omp;
818 wldp_t *outp;
819 wl_ess_list_t *ow_aps;
820 int err = 0;
821
822 if ((omp = wifi_getoutmsg(*mp, cmd, MAX_BUF_LEN - WIFI_BUF_OFFSET)) ==
823 NULL) {
824 return (ENOMEM);
825 }
826 outp = (wldp_t *)omp->b_rptr;
827 ow_aps = (wl_ess_list_t *)outp->wldp_buf;
828
829 switch (cmd) {
830 case WLAN_GET_PARAM:
831 ow_aps->wl_ess_list_num = 0;
832 ieee80211_iterate_nodes(&ic->ic_scan, wifi_read_ap, ow_aps);
833 outp->wldp_length = WIFI_BUF_OFFSET +
834 offsetof(wl_ess_list_t, wl_ess_list_ess) +
835 ow_aps->wl_ess_list_num * sizeof (wl_ess_conf_t);
836 omp->b_wptr = omp->b_rptr + outp->wldp_length;
837 break;
838 case WLAN_SET_PARAM:
839 outp->wldp_result = WL_READONLY;
840 err = EINVAL;
841 break;
842 default:
843 ieee80211_err("wifi_cfg_esslist: unknown command %x\n", cmd);
844 outp->wldp_result = WL_NOTSUPPORTED;
845 err = EINVAL;
846 break;
847 }
848
849 freemsg(*mp);
850 *mp = omp;
851 return (err);
852 }
853
854 /*
855 * Scan the network for all available ESSs.
856 * IEEE80211_F_SCANONLY is set when current state is INIT. And
857 * with this flag, after scan the state will be changed back to
858 * INIT. The reason is at the end of SCAN stage, the STA will
859 * consequently connect to an AP. Then it looks unreasonable that
860 * for a disconnected device, A SCAN command causes it connected.
861 * So the state is changed back to INIT.
862 */
863 static int
864 wifi_cmd_scan(struct ieee80211com *ic, mblk_t *mp)
865 {
866 int ostate = ic->ic_state;
867
868 /*
869 * Do not scan when current state is RUN. The reason is
870 * when connected, STA is on the same channel as AP. But
871 * to do scan, STA have to switch to each available channel,
872 * send probe request and wait certian time for probe
873 * response/beacon. Then when the STA switches to a channel
874 * different than AP's, as a result it cannot send/receive
875 * data packets to/from the connected WLAN. This eventually
876 * will cause data loss.
877 */
878 if (ostate == IEEE80211_S_RUN)
879 return (0);
880
881 IEEE80211_UNLOCK(ic);
882
883 ieee80211_new_state(ic, IEEE80211_S_SCAN, -1);
884 IEEE80211_LOCK(ic);
885 if (ostate == IEEE80211_S_INIT)
886 ic->ic_flags |= IEEE80211_F_SCANONLY;
887
888 /* Don't wait on WPA mode */
889 if ((ic->ic_flags & IEEE80211_F_WPA) == 0) {
890 /* wait scan complete */
891 wifi_wait_scan(ic);
892 }
893
894 wifi_setupoutmsg(mp, 0);
895 return (0);
896 }
897
898 static void
899 wifi_loaddefdata(struct ieee80211com *ic)
900 {
901 struct ieee80211_node *in = ic->ic_bss;
902 int i;
903
904 ic->ic_des_esslen = 0;
905 bzero(ic->ic_des_essid, IEEE80211_NWID_LEN);
906 ic->ic_flags &= ~IEEE80211_F_DESBSSID;
907 bzero(ic->ic_des_bssid, IEEE80211_ADDR_LEN);
908 bzero(ic->ic_bss->in_bssid, IEEE80211_ADDR_LEN);
909 ic->ic_des_chan = IEEE80211_CHAN_ANYC;
910 ic->ic_fixed_rate = IEEE80211_FIXED_RATE_NONE;
911 bzero(ic->ic_nickname, IEEE80211_NWID_LEN);
912 in->in_authmode = IEEE80211_AUTH_OPEN;
913 ic->ic_flags &= ~IEEE80211_F_PRIVACY;
914 ic->ic_flags &= ~IEEE80211_F_WPA; /* mask WPA mode */
915 ic->ic_evq_head = ic->ic_evq_tail = 0; /* reset Queue */
916 ic->ic_def_txkey = 0;
917 for (i = 0; i < MAX_NWEPKEYS; i++) {
918 ic->ic_nw_keys[i].wk_keylen = 0;
919 bzero(ic->ic_nw_keys[i].wk_key, IEEE80211_KEYBUF_SIZE);
920 }
921 ic->ic_curmode = IEEE80211_MODE_AUTO;
922 ic->ic_flags &= ~IEEE80211_F_IBSSON;
923 ic->ic_opmode = IEEE80211_M_STA;
924 }
925
926 static int
927 wifi_cmd_loaddefaults(struct ieee80211com *ic, mblk_t *mp)
928 {
929 wifi_loaddefdata(ic);
930 wifi_setupoutmsg(mp, 0);
931 return (ENETRESET);
932 }
933
934 static int
935 wifi_cmd_disassoc(struct ieee80211com *ic, mblk_t *mp)
936 {
937 if (ic->ic_state != IEEE80211_S_INIT) {
938 IEEE80211_UNLOCK(ic);
939 (void) ieee80211_new_state(ic, IEEE80211_S_INIT, -1);
940 IEEE80211_LOCK(ic);
941 }
942 wifi_loaddefdata(ic);
943 wifi_setupoutmsg(mp, 0);
944 return (0);
945 }
946
947 /*
948 * Get the capabilities of drivers.
949 */
950 static int
951 wifi_cfg_caps(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
952 {
953 mblk_t *omp;
954 wldp_t *outp;
955 wl_capability_t *o_caps;
956 int err = 0;
957
958 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_capability_t))) == NULL)
959 return (ENOMEM);
960 outp = (wldp_t *)omp->b_rptr;
961 o_caps = (wl_capability_t *)outp->wldp_buf;
962
963 switch (cmd) {
964 case WLAN_GET_PARAM:
965 wl_get_capability(ic, o_caps);
966 break;
967 case WLAN_SET_PARAM:
968 outp->wldp_result = WL_READONLY;
969 err = EINVAL;
970 break;
971 default:
972 ieee80211_err("wifi_cfg_caps: unknown command %x\n", cmd);
973 outp->wldp_result = WL_NOTSUPPORTED;
974 err = EINVAL;
975 break;
976 }
977
978 freemsg(*mp);
979 *mp = omp;
980 return (err);
981 }
982
983 /*
984 * Operating on WPA mode.
985 */
986 static int
987 wifi_cfg_wpa(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
988 {
989 mblk_t *omp;
990 wldp_t *outp;
991 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
992 wl_wpa_t *wpa = (wl_wpa_t *)inp->wldp_buf;
993 wl_wpa_t *o_wpa;
994 int err = 0;
995
996 if ((omp = wifi_getoutmsg(*mp, cmd, sizeof (wl_wpa_t))) == NULL)
997 return (ENOMEM);
998 outp = (wldp_t *)omp->b_rptr;
999 o_wpa = (wl_wpa_t *)outp->wldp_buf;
1000
1001 switch (cmd) {
1002 case WLAN_GET_PARAM:
1003 wl_get_wpa(ic, o_wpa);
1004 break;
1005 case WLAN_SET_PARAM:
1006 err = wl_set_wpa(ic, wpa);
1007 break;
1008 default:
1009 ieee80211_err("wifi_cfg_wpa: unknown command %x\n", cmd);
1010 outp->wldp_result = WL_NOTSUPPORTED;
1011 err = EINVAL;
1012 break;
1013 }
1014
1015 freemsg(*mp);
1016 *mp = omp;
1017 return (err);
1018 }
1019
1020 /*
1021 * WPA daemon set the WPA keys.
1022 * The WPA keys are negotiated with APs through wpa service.
1023 */
1024 static int
1025 wifi_cfg_wpakey(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
1026 {
1027 mblk_t *omp;
1028 wldp_t *outp;
1029 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
1030 wl_key_t *ik = (wl_key_t *)(inp->wldp_buf);
1031 int err = 0;
1032
1033 if ((omp = wifi_getoutmsg(*mp, cmd, 0)) == NULL)
1034 return (ENOMEM);
1035 outp = (wldp_t *)omp->b_rptr;
1036
1037 switch (cmd) {
1038 case WLAN_GET_PARAM:
1039 outp->wldp_result = WL_WRITEONLY;
1040 err = EINVAL;
1041 break;
1042 case WLAN_SET_PARAM:
1043 err = wl_set_wpakey(ic, ik);
1044 break;
1045 default:
1046 ieee80211_err("wifi_cfg_wpakey: unknown command %x\n", cmd);
1047 outp->wldp_result = WL_NOTSUPPORTED;
1048 err = EINVAL;
1049 break;
1050 }
1051
1052 freemsg(*mp);
1053 *mp = omp;
1054 return (err);
1055 }
1056
1057 /*
1058 * Delete obsolete keys - keys are dynamically exchanged between APs
1059 * and wpa daemon.
1060 */
1061 static int
1062 wifi_cfg_delkey(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
1063 {
1064 mblk_t *omp;
1065 wldp_t *outp;
1066 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
1067 wl_del_key_t *dk = (wl_del_key_t *)inp->wldp_buf;
1068 int err = 0;
1069
1070 if ((omp = wifi_getoutmsg(*mp, cmd, 0)) == NULL)
1071 return (ENOMEM);
1072 outp = (wldp_t *)omp->b_rptr;
1073
1074 switch (cmd) {
1075 case WLAN_GET_PARAM:
1076 outp->wldp_result = WL_WRITEONLY;
1077 err = EINVAL;
1078 break;
1079 case WLAN_SET_PARAM:
1080 err = wl_set_delkey(ic, dk);
1081 break;
1082 default:
1083 ieee80211_err("wifi_cfg_delkey: unknown command %x\n", cmd);
1084 outp->wldp_result = WL_NOTSUPPORTED;
1085 err = EINVAL;
1086 break;
1087 }
1088
1089 freemsg(*mp);
1090 *mp = omp;
1091 return (err);
1092 }
1093
1094 /*
1095 * The OPTIE will be used in the association request.
1096 */
1097 static int
1098 wifi_cfg_setoptie(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
1099 {
1100 mblk_t *omp;
1101 wldp_t *outp;
1102 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
1103 wl_wpa_ie_t *ie_in = (wl_wpa_ie_t *)inp->wldp_buf;
1104 int err = 0;
1105
1106 if ((omp = wifi_getoutmsg(*mp, cmd, 0)) == NULL)
1107 return (ENOMEM);
1108 outp = (wldp_t *)omp->b_rptr;
1109
1110 switch (cmd) {
1111 case WLAN_GET_PARAM:
1112 outp->wldp_result = WL_WRITEONLY;
1113 err = EINVAL;
1114 break;
1115 case WLAN_SET_PARAM:
1116 if ((err = wl_set_optie(ic, ie_in)) == EINVAL)
1117 outp->wldp_result = WL_NOTSUPPORTED;
1118 break;
1119 default:
1120 ieee80211_err("wifi_cfg_setoptie: unknown command %x\n", cmd);
1121 outp->wldp_result = WL_NOTSUPPORTED;
1122 err = EINVAL;
1123 break;
1124 }
1125
1126 freemsg(*mp);
1127 *mp = omp;
1128 return (err);
1129 }
1130
1131 /*
1132 * To be compatible with drivers/tools of OpenSolaris.org,
1133 * we use a different ID to filter out those APs of WPA mode.
1134 */
1135 static int
1136 wifi_cfg_scanresults(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
1137 {
1138 mblk_t *omp;
1139 wldp_t *outp;
1140 wl_wpa_ess_t *sr;
1141 ieee80211_node_t *in;
1142 ieee80211_node_table_t *nt;
1143 int len, ap_num = 0;
1144 int err = 0;
1145
1146 if ((omp = wifi_getoutmsg(*mp, cmd, MAX_BUF_LEN - WIFI_BUF_OFFSET)) ==
1147 NULL) {
1148 return (ENOMEM);
1149 }
1150 outp = (wldp_t *)omp->b_rptr;
1151 sr = (wl_wpa_ess_t *)outp->wldp_buf;
1152 sr->count = 0;
1153
1154 switch (cmd) {
1155 case WLAN_GET_PARAM:
1156 ieee80211_dbg(IEEE80211_MSG_WPA, "wifi_cfg_scanresults\n");
1157 nt = &ic->ic_scan;
1158 IEEE80211_NODE_LOCK(nt);
1159 in = list_head(&nt->nt_node);
1160 while (in != NULL) {
1161 /* filter out non-WPA APs */
1162 if (in->in_wpa_ie == NULL) {
1163 in = list_next(&nt->nt_node, in);
1164 continue;
1165 }
1166 bcopy(in->in_bssid, sr->ess[ap_num].bssid,
1167 IEEE80211_ADDR_LEN);
1168 sr->ess[ap_num].ssid_len = in->in_esslen;
1169 bcopy(in->in_essid, sr->ess[ap_num].ssid,
1170 in->in_esslen);
1171 sr->ess[ap_num].freq = in->in_chan->ich_freq;
1172
1173 len = in->in_wpa_ie[1] + 2;
1174 bcopy(in->in_wpa_ie, sr->ess[ap_num].wpa_ie, len);
1175 sr->ess[ap_num].wpa_ie_len = len;
1176
1177 ap_num ++;
1178 in = list_next(&nt->nt_node, in);
1179 }
1180 IEEE80211_NODE_UNLOCK(nt);
1181 sr->count = ap_num;
1182 outp->wldp_length = WIFI_BUF_OFFSET +
1183 offsetof(wl_wpa_ess_t, ess) +
1184 sr->count * sizeof (struct wpa_ess);
1185 omp->b_wptr = omp->b_rptr + outp->wldp_length;
1186 break;
1187 case WLAN_SET_PARAM:
1188 outp->wldp_result = WL_READONLY;
1189 err = EINVAL;
1190 break;
1191 default:
1192 ieee80211_err("wifi_cfg_scanresults: unknown cmmand %x\n", cmd);
1193 outp->wldp_result = WL_NOTSUPPORTED;
1194 err = EINVAL;
1195 break;
1196 }
1197
1198 freemsg(*mp);
1199 *mp = omp;
1200 return (err);
1201 }
1202
1203 /*
1204 * Manually control the state of AUTH | DEAUTH | DEASSOC | ASSOC
1205 */
1206 static int
1207 wifi_cfg_setmlme(struct ieee80211com *ic, uint32_t cmd, mblk_t **mp)
1208 {
1209 mblk_t *omp;
1210 wldp_t *outp;
1211 wldp_t *inp = (wldp_t *)(*mp)->b_rptr;
1212 wl_mlme_t *mlme = (wl_mlme_t *)inp->wldp_buf;
1213 int err = 0;
1214
1215 if ((omp = wifi_getoutmsg(*mp, cmd, 0)) == NULL)
1216 return (ENOMEM);
1217 outp = (wldp_t *)omp->b_rptr;
1218
1219 switch (cmd) {
1220 case WLAN_GET_PARAM:
1221 outp->wldp_result = WL_WRITEONLY;
1222 err = EINVAL;
1223 break;
1224 case WLAN_SET_PARAM:
1225 err = wl_set_mlme(ic, mlme);
1226 break;
1227 default:
1228 ieee80211_err("wifi_cfg_delkey: unknown command %x\n", cmd);
1229 outp->wldp_result = WL_NOTSUPPORTED;
1230 err = EINVAL;
1231 break;
1232 }
1233
1234 freemsg(*mp);
1235 *mp = omp;
1236 return (err);
1237 }
1238
1239 static int
1240 wifi_cfg_getset(struct ieee80211com *ic, mblk_t **mp, uint32_t cmd)
1241 {
1242 mblk_t *mp1 = *mp;
1243 wldp_t *wp = (wldp_t *)mp1->b_rptr;
1244 int err = 0;
1245
1246 ASSERT(ic != NULL && mp1 != NULL);
1247 IEEE80211_LOCK_ASSERT(ic);
1248 if (MBLKL(mp1) < WIFI_BUF_OFFSET) {
1249 ieee80211_err("wifi_cfg_getset: "
1250 "invalid input buffer, size=%d\n", MBLKL(mp1));
1251 return (EINVAL);
1252 }
1253
1254 switch (wp->wldp_id) {
1255 /* Commands */
1256 case WL_SCAN:
1257 err = wifi_cmd_scan(ic, mp1);
1258 break;
1259 case WL_LOAD_DEFAULTS:
1260 err = wifi_cmd_loaddefaults(ic, mp1);
1261 break;
1262 case WL_DISASSOCIATE:
1263 err = wifi_cmd_disassoc(ic, mp1);
1264 break;
1265 /* Parameters */
1266 case WL_ESSID:
1267 err = wifi_cfg_essid(ic, cmd, mp);
1268 break;
1269 case WL_BSSID:
1270 err = wifi_cfg_bssid(ic, cmd, mp);
1271 break;
1272 case WL_NODE_NAME:
1273 err = wifi_cfg_nodename(ic, cmd, mp);
1274 break;
1275 case WL_PHY_CONFIG:
1276 err = wifi_cfg_phy(ic, cmd, mp);
1277 break;
1278 case WL_WEP_KEY_TAB:
1279 err = wifi_cfg_wepkey(ic, cmd, mp);
1280 break;
1281 case WL_WEP_KEY_ID:
1282 err = wifi_cfg_keyid(ic, cmd, mp);
1283 break;
1284 case WL_AUTH_MODE:
1285 err = wifi_cfg_authmode(ic, cmd, mp);
1286 break;
1287 case WL_ENCRYPTION:
1288 err = wifi_cfg_encrypt(ic, cmd, mp);
1289 break;
1290 case WL_BSS_TYPE:
1291 err = wifi_cfg_bsstype(ic, cmd, mp);
1292 break;
1293 case WL_CREATE_IBSS:
1294 err = wifi_cfg_createibss(ic, cmd, mp);
1295 break;
1296 case WL_DESIRED_RATES:
1297 err = wifi_cfg_desrates(ic, cmd, mp);
1298 break;
1299 case WL_LINKSTATUS:
1300 err = wifi_cfg_linkstatus(ic, cmd, mp);
1301 break;
1302 case WL_ESS_LIST:
1303 err = wifi_cfg_esslist(ic, cmd, mp);
1304 break;
1305 case WL_SUPPORTED_RATES:
1306 err = wifi_cfg_suprates(ic, cmd, mp);
1307 break;
1308 case WL_RSSI:
1309 err = wifi_cfg_rssi(ic, cmd, mp);
1310 break;
1311 /*
1312 * WPA IOCTLs
1313 */
1314 case WL_CAPABILITY:
1315 err = wifi_cfg_caps(ic, cmd, mp);
1316 break;
1317 case WL_WPA:
1318 err = wifi_cfg_wpa(ic, cmd, mp);
1319 break;
1320 case WL_KEY:
1321 err = wifi_cfg_wpakey(ic, cmd, mp);
1322 break;
1323 case WL_DELKEY:
1324 err = wifi_cfg_delkey(ic, cmd, mp);
1325 break;
1326 case WL_SETOPTIE:
1327 err = wifi_cfg_setoptie(ic, cmd, mp);
1328 break;
1329 case WL_SCANRESULTS:
1330 err = wifi_cfg_scanresults(ic, cmd, mp);
1331 break;
1332 case WL_MLME:
1333 err = wifi_cfg_setmlme(ic, cmd, mp);
1334 break;
1335 default:
1336 wifi_setupoutmsg(mp1, 0);
1337 wp->wldp_result = WL_LACK_FEATURE;
1338 err = ENOTSUP;
1339 break;
1340 }
1341
1342 return (err);
1343 }
1344
1345 /*
1346 * Typically invoked by drivers in response to requests for
1347 * information or to change settings from the userland.
1348 *
1349 * Return value should be checked by WiFi drivers. Return 0
1350 * on success. Otherwise, return non-zero value to indicate
1351 * the error. Driver should operate as below when the return
1352 * error is:
1353 * ENETRESET Reset wireless network and re-start to join a
1354 * WLAN. ENETRESET is returned when a configuration
1355 * parameter has been changed.
1356 * When acknowledge a M_IOCTL message, thie error
1357 * is ignored.
1358 */
1359 int
1360 ieee80211_ioctl(struct ieee80211com *ic, queue_t *wq, mblk_t *mp)
1361 {
1362 struct iocblk *iocp;
1363 int32_t cmd, err, len;
1364 boolean_t need_privilege;
1365 mblk_t *mp1;
1366
1367 if (MBLKL(mp) < sizeof (struct iocblk)) {
1368 ieee80211_err("ieee80211_ioctl: ioctl buffer too short, %u\n",
1369 MBLKL(mp));
1370 miocnak(wq, mp, 0, EINVAL);
1371 return (EINVAL);
1372 }
1373
1374 /*
1375 * Validate the command
1376 */
1377 iocp = (struct iocblk *)mp->b_rptr;
1378 iocp->ioc_error = 0;
1379 cmd = iocp->ioc_cmd;
1380 need_privilege = B_TRUE;
1381 switch (cmd) {
1382 case WLAN_SET_PARAM:
1383 case WLAN_COMMAND:
1384 break;
1385 case WLAN_GET_PARAM:
1386 need_privilege = B_FALSE;
1387 break;
1388 default:
1389 ieee80211_dbg(IEEE80211_MSG_ANY, "ieee80211_ioctl(): "
1390 "unknown cmd 0x%x\n", cmd);
1391 miocnak(wq, mp, 0, EINVAL);
1392 return (EINVAL);
1393 }
1394
1395 if (need_privilege && (err = secpolicy_dl_config(iocp->ioc_cr)) != 0) {
1396 miocnak(wq, mp, 0, err);
1397 return (err);
1398 }
1399
1400 IEEE80211_LOCK(ic);
1401
1402 /* sanity check */
1403 mp1 = mp->b_cont;
1404 if (iocp->ioc_count == 0 || iocp->ioc_count < sizeof (wldp_t) ||
1405 mp1 == NULL) {
1406 miocnak(wq, mp, 0, EINVAL);
1407 IEEE80211_UNLOCK(ic);
1408 return (EINVAL);
1409 }
1410
1411 /* assuming single data block */
1412 if (mp1->b_cont != NULL) {
1413 freemsg(mp1->b_cont);
1414 mp1->b_cont = NULL;
1415 }
1416
1417 err = wifi_cfg_getset(ic, &mp1, cmd);
1418 mp->b_cont = mp1;
1419 IEEE80211_UNLOCK(ic);
1420
1421 len = msgdsize(mp1);
1422 /* ignore ENETRESET when acknowledge the M_IOCTL message */
1423 if (err == 0 || err == ENETRESET)
1424 miocack(wq, mp, len, 0);
1425 else
1426 miocack(wq, mp, len, err);
1427
1428 return (err);
1429 }
1430
1431 /*
1432 * The following routines are for brussels support
1433 */
1434
1435 /*
1436 * MAC_PROP_WL_ESSID
1437 */
1438 static int
1439 wl_set_essid(struct ieee80211com *ic, const void *wldp_buf)
1440 {
1441 int err = 0;
1442 char *essid;
1443 wl_essid_t *iw_essid = (wl_essid_t *)wldp_buf;
1444
1445 if (iw_essid->wl_essid_length > IEEE80211_NWID_LEN) {
1446 ieee80211_err("wl_set_essid: "
1447 "essid too long, %u, max %u\n",
1448 iw_essid->wl_essid_length, IEEE80211_NWID_LEN);
1449
1450 err = EINVAL;
1451 return (err);
1452 }
1453
1454 essid = iw_essid->wl_essid_essid;
1455 essid[IEEE80211_NWID_LEN] = 0;
1456
1457 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_essid: "
1458 "set essid=%s length=%d\n",
1459 essid, iw_essid->wl_essid_length);
1460
1461 ic->ic_des_esslen = iw_essid->wl_essid_length;
1462 if (ic->ic_des_esslen != 0)
1463 bcopy(essid, ic->ic_des_essid, ic->ic_des_esslen);
1464 if (ic->ic_des_esslen < IEEE80211_NWID_LEN)
1465 ic->ic_des_essid[ic->ic_des_esslen] = 0;
1466
1467 err = ENETRESET;
1468
1469 return (err);
1470 }
1471
1472 static void
1473 wl_get_essid(struct ieee80211com *ic, void *wldp_buf)
1474 {
1475 char *essid;
1476 wl_essid_t ow_essid;
1477
1478 essid = (char *)ic->ic_des_essid;
1479 if (essid[0] == '\0')
1480 essid = (char *)ic->ic_bss->in_essid;
1481
1482 bzero(&ow_essid, sizeof (wl_essid_t));
1483 ow_essid.wl_essid_length = wifi_strnlen((const char *)essid,
1484 IEEE80211_NWID_LEN);
1485 bcopy(essid, ow_essid.wl_essid_essid,
1486 ow_essid.wl_essid_length);
1487 bcopy(&ow_essid, wldp_buf, sizeof (wl_essid_t));
1488
1489 }
1490
1491 /*
1492 * MAC_PROP_WL_BSSID
1493 */
1494 static int
1495 wl_set_bssid(struct ieee80211com *ic, const void* wldp_buf)
1496 {
1497
1498 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_bssid: "
1499 "set bssid=%s\n",
1500 ieee80211_macaddr_sprintf(wldp_buf));
1501
1502 bcopy(wldp_buf, ic->ic_des_bssid, sizeof (wl_bssid_t));
1503 ic->ic_flags |= IEEE80211_F_DESBSSID;
1504
1505 return (ENETRESET);
1506 }
1507
1508 static void
1509 wl_get_bssid(struct ieee80211com *ic, void *wldp_buf)
1510 {
1511 uint8_t *bssid;
1512
1513 if (ic->ic_flags & IEEE80211_F_DESBSSID)
1514 bssid = ic->ic_des_bssid;
1515 else
1516 bssid = ic->ic_bss->in_bssid;
1517 bcopy(bssid, wldp_buf, sizeof (wl_bssid_t));
1518
1519 }
1520
1521 /*
1522 * MAC_PROP_WL_BSSTYP
1523 */
1524 static int
1525 wl_set_bsstype(struct ieee80211com *ic, const void *wldp_buf)
1526 {
1527 int err = 0;
1528 wl_bss_type_t *iw_opmode = (wl_bss_type_t *)wldp_buf;
1529
1530 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_bsstype: "
1531 "set bsstype=%u\n", *iw_opmode);
1532
1533 switch (*iw_opmode) {
1534 case WL_BSS_BSS:
1535 ic->ic_flags &= ~IEEE80211_F_IBSSON;
1536 ic->ic_opmode = IEEE80211_M_STA;
1537 err = ENETRESET;
1538 break;
1539 case WL_BSS_IBSS:
1540 if ((ic->ic_caps & IEEE80211_C_IBSS) == 0) {
1541 err = ENOTSUP;
1542 break;
1543 }
1544
1545 ic->ic_opmode = IEEE80211_M_IBSS;
1546 err = ENETRESET;
1547 break;
1548 default:
1549 ieee80211_err("wl_set_bsstype: "
1550 "unknown opmode\n");
1551 err = EINVAL;
1552 break;
1553 }
1554 return (err);
1555 }
1556
1557 static void
1558 wl_get_bsstype(struct ieee80211com *ic, void *wldp_buf)
1559 {
1560 wl_bss_type_t ow_opmode;
1561
1562 switch (ic->ic_opmode) {
1563 case IEEE80211_M_STA:
1564 ow_opmode = WL_BSS_BSS;
1565 break;
1566 case IEEE80211_M_IBSS:
1567 ow_opmode = WL_BSS_IBSS;
1568 break;
1569 default:
1570 ow_opmode = WL_BSS_ANY;
1571 break;
1572 }
1573
1574 bcopy(&ow_opmode, wldp_buf, sizeof (wl_bss_type_t));
1575 }
1576
1577 /*
1578 * MAC_PROP_WL_LINKSTATUS
1579 */
1580 static void
1581 wl_get_linkstatus(struct ieee80211com *ic, void *wldp_buf)
1582 {
1583 wl_linkstatus_t ow_linkstat;
1584
1585 ow_linkstat = (ic->ic_state == IEEE80211_S_RUN) ?
1586 WL_CONNECTED : WL_NOTCONNECTED;
1587 if ((ic->ic_flags & IEEE80211_F_WPA) &&
1588 (ieee80211_crypto_getciphertype(ic) != WIFI_SEC_WPA)) {
1589 ow_linkstat = WL_NOTCONNECTED;
1590 }
1591
1592 bcopy(&ow_linkstat, wldp_buf, sizeof (wl_linkstatus_t));
1593 }
1594
1595 /*
1596 * MAC_PROP_WL_DESIRED_RATESa
1597 */
1598 static int
1599 wl_set_desrates(struct ieee80211com *ic, const void *wldp_buf)
1600 {
1601 int err = 0;
1602 int i, j;
1603 uint8_t drate;
1604 boolean_t isfound;
1605 wl_rates_t *iw_rates = (wl_rates_t *)wldp_buf;
1606 struct ieee80211_node *in = ic->ic_bss;
1607 struct ieee80211_rateset *rs = &in->in_rates;
1608
1609 drate = iw_rates->wl_rates_rates[0];
1610 if (ic->ic_fixed_rate == drate)
1611 return (err);
1612
1613 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_desrates: "
1614 "set desired rate=%u\n", drate);
1615
1616 if (drate == 0) {
1617 ic->ic_fixed_rate = IEEE80211_FIXED_RATE_NONE;
1618 if (ic->ic_state == IEEE80211_S_RUN) {
1619 IEEE80211_UNLOCK(ic);
1620 ieee80211_new_state(ic, IEEE80211_S_ASSOC, 0);
1621 IEEE80211_LOCK(ic);
1622 }
1623 return (err);
1624 }
1625
1626 /*
1627 * Set desired rate. The desired rate is for data transfer
1628 * and usally is checked and used when driver changes to
1629 * RUN state.
1630 * If the driver is in AUTH | ASSOC | RUN state, desired
1631 * rate is checked anainst rates supported by current ESS.
1632 * If it's supported and current state is AUTH|ASSOC, nothing
1633 * needs to be done by driver since the desired rate will
1634 * be enabled when the device changes to RUN state. And
1635 * when current state is RUN, Re-associate with the ESS to
1636 * enable the desired rate.
1637 */
1638
1639 if (ic->ic_state != IEEE80211_S_INIT &&
1640 ic->ic_state != IEEE80211_S_SCAN) {
1641 for (i = 0; i < rs->ir_nrates; i++) {
1642 if (drate == IEEE80211_RV(rs->ir_rates[i]))
1643 break;
1644 }
1645 /* supported */
1646 if (i < rs->ir_nrates) {
1647 ic->ic_fixed_rate = drate;
1648 if (ic->ic_state == IEEE80211_S_RUN) {
1649 IEEE80211_UNLOCK(ic);
1650 ieee80211_new_state(ic,
1651 IEEE80211_S_ASSOC, 0);
1652 IEEE80211_LOCK(ic);
1653 }
1654 return (err);
1655 }
1656 }
1657
1658 /*
1659 * In INIT or SCAN state
1660 * check if the desired rate is supported by device
1661 */
1662 isfound = B_FALSE;
1663 for (i = 0; i < IEEE80211_MODE_MAX; i++) {
1664 rs = &ic->ic_sup_rates[i];
1665 for (j = 0; j < rs->ir_nrates; j++) {
1666 if (drate == IEEE80211_RV(rs->ir_rates[j])) {
1667 isfound = B_TRUE;
1668 break;
1669 }
1670 }
1671 if (isfound)
1672 break;
1673 }
1674 if (!isfound) {
1675 ieee80211_err("wl_set_desrates: "
1676 "invald rate %d\n", drate);
1677 err = EINVAL;
1678 return (err);
1679 }
1680 ic->ic_fixed_rate = drate;
1681 if (ic->ic_state != IEEE80211_S_SCAN)
1682 err = ENETRESET;
1683
1684 return (err);
1685 }
1686
1687 static void
1688 wl_get_desrates(struct ieee80211com *ic, void *wldp_buf)
1689 {
1690 uint8_t srate;
1691 wl_rates_t ow_rates;
1692 struct ieee80211_node *in = ic->ic_bss;
1693 struct ieee80211_rateset *rs = &in->in_rates;
1694
1695 srate = rs->ir_rates[in->in_txrate] & IEEE80211_RATE_VAL;
1696 ow_rates.wl_rates_num = 1;
1697 ow_rates.wl_rates_rates[0] =
1698 (ic->ic_fixed_rate == IEEE80211_FIXED_RATE_NONE) ?
1699 srate : ic->ic_fixed_rate;
1700 bcopy(&ow_rates, wldp_buf, sizeof (wl_rates_t));
1701
1702 }
1703
1704 /*
1705 * MAC_PROP_AUTH_MODE
1706 */
1707 static int
1708 wl_set_authmode(struct ieee80211com *ic, const void *wldp_buf)
1709 {
1710 int err = 0;
1711 wl_authmode_t *iw_auth = (wl_authmode_t *)wldp_buf;
1712
1713 if (*iw_auth == ic->ic_bss->in_authmode)
1714 return (err);
1715
1716 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_authmode: "
1717 "set authmode=%u\n", *iw_auth);
1718
1719 switch (*iw_auth) {
1720 case WL_OPENSYSTEM:
1721 case WL_SHAREDKEY:
1722 ic->ic_bss->in_authmode = *iw_auth;
1723 err = ENETRESET;
1724 break;
1725 default:
1726 ieee80211_err("wl_set_authmode: "
1727 "unknown authmode %u\n", *iw_auth);
1728 err = EINVAL;
1729 break;
1730 }
1731
1732 return (err);
1733 }
1734
1735 static void
1736 wl_get_authmode(struct ieee80211com *ic, void *wldp_buf)
1737 {
1738 wl_authmode_t ow_auth;
1739
1740 ow_auth = ic->ic_bss->in_authmode;
1741 bcopy(&ow_auth, wldp_buf, sizeof (wl_authmode_t));
1742
1743 }
1744
1745 /*
1746 * MAC_PROP_WL_ENCRYPTION
1747 */
1748 static int
1749 wl_set_encrypt(struct ieee80211com *ic, const void *wldp_buf)
1750 {
1751 int err = 0;
1752 uint32_t flags;
1753 wl_encryption_t *iw_encryp = (wl_encryption_t *)wldp_buf;
1754
1755 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_encrypt: "
1756 "set encryption=%u\n", *iw_encryp);
1757
1758 flags = ic->ic_flags;
1759 if (*iw_encryp == WL_NOENCRYPTION)
1760 flags &= ~IEEE80211_F_PRIVACY;
1761 else
1762 flags |= IEEE80211_F_PRIVACY;
1763
1764 if (ic->ic_flags != flags) {
1765 ic->ic_flags = flags;
1766 err = ENETRESET;
1767 }
1768
1769 return (err);
1770 }
1771
1772 static void
1773 wl_get_encrypt(struct ieee80211com *ic, void *wldp_buf)
1774 {
1775 wl_encryption_t *ow_encryp;
1776
1777 ow_encryp = (wl_encryption_t *)wldp_buf;
1778 *ow_encryp = (ic->ic_flags & IEEE80211_F_PRIVACY) ? 1 : 0;
1779 if (ic->ic_flags & IEEE80211_F_WPA)
1780 *ow_encryp = WL_ENC_WPA;
1781
1782 }
1783
1784 /*
1785 * MAC_PROP_WL_RSSI
1786 */
1787 static void
1788 wl_get_rssi(struct ieee80211com *ic, void *wldp_buf)
1789 {
1790 wl_rssi_t *ow_rssi;
1791
1792 ow_rssi = (wl_rssi_t *)wldp_buf;
1793 *ow_rssi = wifi_getrssi(ic->ic_bss);
1794
1795 }
1796
1797 /*
1798 * MAC_PROP_WL_PHY_CONFIG
1799 */
1800
1801 static int
1802 wl_set_phy(struct ieee80211com *ic, const void* wldp_buf)
1803 {
1804 int err = 0;
1805 int16_t ch;
1806 wl_dsss_t *dsss;
1807 wl_phy_conf_t *iw_phy = (wl_phy_conf_t *)wldp_buf;
1808
1809 dsss = (wl_dsss_t *)iw_phy;
1810 ch = dsss->wl_dsss_channel;
1811
1812 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_phy: "
1813 "set channel=%d\n", ch);
1814
1815 if (ch == 0 || ch == (int16_t)IEEE80211_CHAN_ANY) {
1816 ic->ic_des_chan = IEEE80211_CHAN_ANYC;
1817 } else if ((uint_t)ch > IEEE80211_CHAN_MAX ||
1818 ieee80211_isclr(ic->ic_chan_active, ch)) {
1819 err = EINVAL;
1820 return (err);
1821 } else {
1822 ic->ic_des_chan = ic->ic_ibss_chan =
1823 &ic->ic_sup_channels[ch];
1824 }
1825
1826 switch (ic->ic_state) {
1827 case IEEE80211_S_INIT:
1828 case IEEE80211_S_SCAN:
1829 err = ENETRESET;
1830 break;
1831 default:
1832 /*
1833 * If hte desired channel has changed (to something
1834 * other than any) and we're not already scanning,
1835 * then kick the state machine.
1836 */
1837 if (ic->ic_des_chan != IEEE80211_CHAN_ANYC &&
1838 ic->ic_bss->in_chan != ic->ic_des_chan &&
1839 (ic->ic_flags & IEEE80211_F_SCAN) == 0)
1840 err = ENETRESET;
1841 break;
1842 }
1843
1844 return (err);
1845 }
1846
1847 #define WIFI_HT_MODE(in) (((in)->in_flags & IEEE80211_NODE_HT) ? 1 : 0)
1848
1849 static int
1850 wl_get_phy(struct ieee80211com *ic, void *wldp_buf)
1851 {
1852 int err = 0;
1853 wl_phy_conf_t *ow_phy;
1854 struct ieee80211_channel *ch = ic->ic_curchan;
1855 struct ieee80211_node *in = ic->ic_bss;
1856
1857 ow_phy = (wl_phy_conf_t *)wldp_buf;
1858 bzero(wldp_buf, sizeof (wl_phy_conf_t));
1859
1860 /* get current phy parameters: FH|DS|ERP */
1861 if (IEEE80211_IS_CHAN_A(ch) || IEEE80211_IS_CHAN_T(ch)) {
1862 wl_ofdm_t *ofdm = (wl_ofdm_t *)ow_phy;
1863 ofdm->wl_ofdm_subtype = WL_OFDM;
1864 ofdm->wl_ofdm_frequency = ch->ich_freq;
1865 ofdm->wl_ofdm_ht_enabled = WIFI_HT_MODE(in);
1866 } else {
1867 switch (ic->ic_phytype) {
1868 case IEEE80211_T_FH: {
1869 wl_fhss_t *fhss = (wl_fhss_t *)ow_phy;
1870 fhss->wl_fhss_subtype = WL_FHSS;
1871 fhss->wl_fhss_channel =
1872 ieee80211_chan2ieee(ic, ch);
1873 break;
1874 }
1875 case IEEE80211_T_DS: {
1876 wl_dsss_t *dsss = (wl_dsss_t *)ow_phy;
1877 dsss->wl_dsss_subtype = WL_DSSS;
1878 dsss->wl_dsss_channel =
1879 ieee80211_chan2ieee(ic, ch);
1880 break;
1881 }
1882 case IEEE80211_T_OFDM: {
1883 wl_erp_t *erp = (wl_erp_t *)ow_phy;
1884 erp->wl_erp_subtype = WL_ERP;
1885 erp->wl_erp_channel =
1886 ieee80211_chan2ieee(ic, ch);
1887 erp->wl_erp_ht_enabled = WIFI_HT_MODE(in);
1888 break;
1889 }
1890 default:
1891 ieee80211_err("wl_get_phy: "
1892 "unknown phy type, %x\n", ic->ic_phytype);
1893 err = EIO;
1894 break;
1895 }
1896 }
1897
1898 return (err);
1899 }
1900
1901 /*
1902 * MAC_PROP_WL_CAPABILITY
1903 */
1904 static void
1905 wl_get_capability(struct ieee80211com *ic, void *wldp_buf)
1906 {
1907 wl_capability_t ow_caps;
1908
1909 ow_caps.caps = ic->ic_caps;
1910 bcopy(&ow_caps, wldp_buf, sizeof (wl_capability_t));
1911
1912 }
1913
1914 /*
1915 * MAC_PROP_WL_WPA
1916 */
1917 static int
1918 wl_set_wpa(struct ieee80211com *ic, const void *wldp_buf)
1919 {
1920 int err = 0;
1921 wl_wpa_t *wpa = (wl_wpa_t *)wldp_buf;
1922
1923 ieee80211_dbg(IEEE80211_MSG_BRUSSELS, "wl_set_wpa: "
1924 "set wpa=%u\n", wpa->wpa_flag);
1925
1926 if (wpa->wpa_flag > 0) {
1927 /* enable wpa mode */
1928 ic->ic_flags |= IEEE80211_F_PRIVACY;
1929 ic->ic_flags |= IEEE80211_F_WPA;
1930 } else {
1931 ic->ic_flags &= ~IEEE80211_F_PRIVACY;
1932 ic->ic_flags &= ~IEEE80211_F_WPA;
1933 }
1934
1935 return (err);
1936 }
1937
1938 static void
1939 wl_get_wpa(struct ieee80211com *ic, void *wldp_buf)
1940 {
1941 wl_wpa_t *wpa;
1942
1943 wpa = (wl_wpa_t *)wldp_buf;
1944 wpa->wpa_flag = ((ic->ic_flags & IEEE80211_F_WPA) ? 1 : 0);
1945
1946 ieee80211_dbg(IEEE80211_MSG_BRUSSELS, "wl_get_wpa: "
1947 "get wpa=%u\n", wpa->wpa_flag);
1948
1949 }
1950
1951 /*
1952 * MAC_PROP_WL_SCANRESULTS
1953 */
1954
1955 static void
1956 wl_get_scanresults(struct ieee80211com *ic, void *wldp_buf)
1957 {
1958 wl_wpa_ess_t *sr;
1959 ieee80211_node_t *in;
1960 ieee80211_node_table_t *nt;
1961 int ap_num;
1962 int len;
1963
1964 sr = (wl_wpa_ess_t *)wldp_buf;
1965 sr->count = 0;
1966 ap_num = 0;
1967
1968 ieee80211_dbg(IEEE80211_MSG_WPA, "wl_get_scanrelults\n");
1969
1970 nt = &ic->ic_scan;
1971 IEEE80211_NODE_LOCK(nt);
1972 in = list_head(&nt->nt_node);
1973
1974 while (in != NULL) {
1975 /* filter out non-wpa APs */
1976 if (in->in_wpa_ie == NULL) {
1977 in = list_next(&nt->nt_node, in);
1978 continue;
1979 }
1980 bcopy(in->in_bssid, sr->ess[ap_num].bssid,
1981 IEEE80211_ADDR_LEN);
1982 sr->ess[ap_num].ssid_len = in->in_esslen;
1983 bcopy(in->in_essid, sr->ess[ap_num].ssid,
1984 in->in_esslen);
1985 sr->ess[ap_num].freq = in->in_chan->ich_freq;
1986
1987 len = in->in_wpa_ie[1] + 2;
1988 bcopy(in->in_wpa_ie, sr->ess[ap_num].wpa_ie, len);
1989 sr->ess[ap_num].wpa_ie_len = len;
1990
1991 ap_num++;
1992 in = list_next(&nt->nt_node, in);
1993 }
1994 IEEE80211_NODE_UNLOCK(nt);
1995 sr->count = ap_num;
1996
1997 }
1998
1999 /*
2000 * MAC_PROP_WL_ESS_LIST
2001 */
2002 static void
2003 wl_get_esslist(struct ieee80211com *ic, void *wldp_buf)
2004 {
2005 wl_ess_list_t *ess_list;
2006
2007 ess_list = (wl_ess_list_t *)wldp_buf;
2008
2009 ess_list->wl_ess_list_num = 0;
2010 ieee80211_iterate_nodes(&ic->ic_scan, wifi_read_ap, ess_list);
2011
2012 }
2013
2014 /*
2015 * MAC_PROP_WL_WEP_KEY
2016 */
2017 static int
2018 wl_set_wepkey(struct ieee80211com *ic, const void *wldp_buf)
2019 {
2020 int err = 0;
2021 uint16_t i;
2022 uint32_t klen;
2023 struct ieee80211_key *key;
2024 wl_wep_key_t *wepkey = (wl_wep_key_t *)wldp_buf;
2025
2026 /* set all valid keys */
2027 for (i = 0; i < MAX_NWEPKEYS; i++) {
2028 if (wepkey[i].wl_wep_operation != WL_ADD)
2029 continue;
2030 klen = wepkey[i].wl_wep_length;
2031 if (klen > IEEE80211_KEYBUF_SIZE) {
2032 ieee80211_err("wl_set_wepkey: "
2033 "invalid wepkey length, %u\n", klen);
2034 err = EINVAL;
2035 continue; /* continue to set other keys */
2036 }
2037 if (klen == 0)
2038 continue;
2039
2040 /*
2041 * Set key contents. Only WEP is supported
2042 */
2043 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_wepkey: "
2044 "set key %u, len=%u\n", i, klen);
2045 key = &ic->ic_nw_keys[i];
2046 if (ieee80211_crypto_newkey(ic, IEEE80211_CIPHER_WEP,
2047 IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV, key) == 0) {
2048 ieee80211_err("wl_set_wepkey: "
2049 "abort, create key failed. id=%u\n", i);
2050 err = EIO;
2051 continue;
2052 }
2053
2054 key->wk_keyix = i;
2055 key->wk_keylen = (uint8_t)klen;
2056 key->wk_flags |= IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV;
2057 bzero(key->wk_key, IEEE80211_KEYBUF_SIZE);
2058 bcopy(wepkey[i].wl_wep_key, key->wk_key, klen);
2059 if (ieee80211_crypto_setkey(ic, key, ic->ic_macaddr)
2060 == 0) {
2061 ieee80211_err("wl_set_wepkey: "
2062 "set key failed len=%u\n", klen);
2063 err = EIO;
2064 }
2065 }
2066 if (err == 0)
2067 err = ENETRESET;
2068
2069 return (err);
2070 }
2071
2072 /*
2073 * MAC_PROP_WL_SETOPTIE
2074 */
2075 static int
2076 wl_set_optie(struct ieee80211com *ic, const void *wldp_buf)
2077 {
2078 int err = 0;
2079 char *ie;
2080 wl_wpa_ie_t *ie_in = (wl_wpa_ie_t *)wldp_buf;
2081
2082 if (ic->ic_opmode != IEEE80211_M_STA) {
2083 ieee80211_err("wl_set_optie: opmode err\n");
2084 err = EINVAL;
2085 return (err);
2086 }
2087 if (ie_in->wpa_ie_len > IEEE80211_MAX_OPT_IE) {
2088
2089 ieee80211_err("wl_set_optie: optie is too long\n");
2090
2091 err = EINVAL;
2092 return (err);
2093 }
2094
2095 ie = ieee80211_malloc(ie_in->wpa_ie_len);
2096 (void) memcpy(ie, ie_in->wpa_ie, ie_in->wpa_ie_len);
2097 if (ic->ic_opt_ie != NULL) {
2098 ieee80211_dbg(IEEE80211_MSG_BRUSSELS,
2099 "wl_set_optie:ic_opt_ie!=NULL\n");
2100 ieee80211_free(ic->ic_opt_ie);
2101 }
2102 ic->ic_opt_ie = ie;
2103 ic->ic_opt_ie_len = ie_in->wpa_ie_len;
2104
2105 return (err);
2106 }
2107
2108 /*
2109 * MAC_PROP_WL_DELKEY
2110 */
2111 static int
2112 wl_set_delkey(struct ieee80211com *ic, const void *wldp_buf)
2113 {
2114 int err = 0;
2115 int kid;
2116 wl_del_key_t *dk = (wl_del_key_t *)wldp_buf;
2117
2118 ieee80211_dbg(IEEE80211_MSG_BRUSSELS, "wl_set_delkey(): "
2119 "keyix=%d\n", dk->idk_keyix);
2120
2121 kid = dk->idk_keyix;
2122
2123 if (kid == IEEE80211_KEYIX_NONE ||
2124 kid >= IEEE80211_WEP_NKID) {
2125 ieee80211_err("wl_set_delkey: incorrect keyix\n");
2126 err = EINVAL;
2127 return (err);
2128 } else {
2129 (void) ieee80211_crypto_delkey(ic,
2130 &ic->ic_nw_keys[kid]);
2131 ieee80211_mac_update(ic);
2132 }
2133
2134 return (err);
2135 }
2136
2137 /*
2138 * MAC_PROP_WL_MLME
2139 */
2140
2141 static int
2142 wl_set_mlme(struct ieee80211com *ic, const void *wldp_buf)
2143 {
2144 int err = 0;
2145 uint32_t flags;
2146 ieee80211_node_t *in;
2147 wl_mlme_t *mlme = (wl_mlme_t *)wldp_buf;
2148
2149 ieee80211_dbg(IEEE80211_MSG_WPA, "wl_set_mlme: "
2150 "op=%d\n", mlme->im_op);
2151
2152 switch (mlme->im_op) {
2153 case IEEE80211_MLME_DISASSOC:
2154 case IEEE80211_MLME_DEAUTH:
2155 if (ic->ic_opmode == IEEE80211_M_STA) {
2156 /*
2157 * Mask ic_flags of IEEE80211_F_WPA to disable
2158 * ieee80211_notify temporarily.
2159 */
2160 flags = ic->ic_flags;
2161 ic->ic_flags &= ~IEEE80211_F_WPA;
2162
2163 IEEE80211_UNLOCK(ic);
2164 ieee80211_new_state(ic, IEEE80211_S_INIT,
2165 mlme->im_reason);
2166 IEEE80211_LOCK(ic);
2167
2168 ic->ic_flags = flags;
2169 }
2170 break;
2171 case IEEE80211_MLME_ASSOC:
2172 if (ic->ic_opmode != IEEE80211_M_STA) {
2173 ieee80211_err("wifi_cfg_setmlme: opmode err\n");
2174 err = EINVAL;
2175 break;
2176 }
2177 if (ic->ic_des_esslen != 0) {
2178 /*
2179 * Desired ssid specified; must match both bssid and
2180 * ssid to distinguish ap advertising multiple ssid's.
2181 */
2182 in = ieee80211_find_node_with_ssid(&ic->ic_scan,
2183 mlme->im_macaddr,
2184 ic->ic_des_esslen,
2185 ic->ic_des_essid);
2186 } else {
2187 /*
2188 * Normal case; just match bssid.
2189 */
2190 in = ieee80211_find_node(&ic->ic_scan,
2191 mlme->im_macaddr);
2192 }
2193 if (in == NULL) {
2194 ieee80211_err("wifi_cfg_setmlme: "
2195 "no matched node\n");
2196 err = EINVAL;
2197 break;
2198 }
2199 IEEE80211_UNLOCK(ic);
2200 ieee80211_sta_join(ic, in);
2201 IEEE80211_LOCK(ic);
2202 break;
2203 default:
2204 err = EINVAL;
2205 break;
2206 }
2207
2208 return (err);
2209 }
2210
2211 /*
2212 * MAC_PROP_WL_WPA_KEY
2213 */
2214 static int
2215 wl_set_wpakey(struct ieee80211com *ic, const void *wldp_buf)
2216 {
2217 int err = 0;
2218 uint16_t kid;
2219 struct ieee80211_node *in;
2220 struct ieee80211_key *wk;
2221 wl_key_t ik;
2222
2223 bcopy(wldp_buf, &ik, sizeof (wl_key_t));
2224
2225 ieee80211_dbg(IEEE80211_MSG_BRUSSELS, "wl_set_wpakey: "
2226 "idx=%d\n", ik.ik_keyix);
2227
2228 /*
2229 * cipher support is verified by ieee80211_crypt_newkey
2230 * this also checks ik.ik_keylen > sizeof(wk->wk_key)
2231 */
2232 if (ik.ik_keylen > sizeof (ik.ik_keydata)) {
2233 ieee80211_err("wl_set_wpakey: key is too long\n");
2234 err = EINVAL;
2235 return (err);
2236 }
2237 kid = ik.ik_keyix;
2238 if (kid == IEEE80211_KEYIX_NONE || kid >= IEEE80211_WEP_NKID) {
2239 ieee80211_err("wl_set_wpakey: incorrect keyix\n");
2240 err = EINVAL;
2241 return (err);
2242 } else {
2243 wk = &ic->ic_nw_keys[kid];
2244 /*
2245 * Globle slots start off w/o any assigned key index.
2246 * Force one here for consistency with WEPKEY.
2247 */
2248 if (wk->wk_keyix == IEEE80211_KEYIX_NONE)
2249 wk->wk_keyix = kid;
2250 in = NULL;
2251 }
2252
2253 KEY_UPDATE_BEGIN(ic);
2254 if (ieee80211_crypto_newkey(ic, ik.ik_type,
2255 ik.ik_flags, wk)) {
2256 wk->wk_keylen = ik.ik_keylen;
2257 /* MIC presence is implied by cipher type */
2258 if (wk->wk_keylen > IEEE80211_KEYBUF_SIZE)
2259 wk->wk_keylen = IEEE80211_KEYBUF_SIZE;
2260 wk->wk_keyrsc = ik.ik_keyrsc;
2261 wk->wk_keytsc = 0;
2262 wk->wk_flags |= ik.ik_flags &
2263 (IEEE80211_KEY_XMIT | IEEE80211_KEY_RECV);
2264 (void) memset(wk->wk_key, 0, sizeof (wk->wk_key));
2265 (void) memcpy(wk->wk_key, ik.ik_keydata,
2266 ik.ik_keylen);
2267 if (!ieee80211_crypto_setkey(ic, wk,
2268 in != NULL ? in->in_macaddr : ik.ik_macaddr)) {
2269 err = EIO;
2270 } else if ((ik.ik_flags & IEEE80211_KEY_DEFAULT)) {
2271 ic->ic_def_txkey = kid;
2272 ieee80211_mac_update(ic);
2273 }
2274 } else {
2275 err = EIO;
2276 }
2277 KEY_UPDATE_END(ic);
2278
2279 return (err);
2280 }
2281
2282 /*
2283 * MAC_PROP_WL_SUP_RATE
2284 */
2285 static void
2286 wl_get_suprates(struct ieee80211com *ic, void *wldp_buf)
2287 {
2288 int i, j, k, l;
2289 uint8_t srates;
2290 uint8_t *drates;
2291 wl_rates_t *wl_rates;
2292 const struct ieee80211_rateset *srs;
2293
2294 wl_rates = (wl_rates_t *)wldp_buf;
2295
2296 wl_rates->wl_rates_num = 0;
2297 drates = (uint8_t *)wl_rates->wl_rates_rates;
2298 for (i = 0; i < IEEE80211_MODE_MAX; i++) {
2299 srs = &ic->ic_sup_rates[i];
2300 if (srs->ir_nrates == 0)
2301 continue;
2302 for (j = 0; j < srs->ir_nrates; j++) {
2303 srates = IEEE80211_RV(srs->ir_rates[j]);
2304 /* sort & skip duplicated rates */
2305 for (k = 0; k < wl_rates->wl_rates_num; k++) {
2306 if (srates <= drates[k])
2307 break;
2308 }
2309 if (srates == drates[k])
2310 /* skip duplicated rates */
2311 continue;
2312 /* sort */
2313 for (l = wl_rates->wl_rates_num; l > k; l--)
2314 drates[l] = drates[l-1];
2315 drates[k] = srates;
2316 wl_rates->wl_rates_num++;
2317 }
2318 }
2319
2320 }
2321
2322 /*
2323 * MAC_PROP_WL_CREATE_IBSS
2324 */
2325 static int
2326 wl_set_createibss(struct ieee80211com *ic, const void *wldp_buf)
2327 {
2328 wl_create_ibss_t *iw_ibss = (wl_create_ibss_t *)wldp_buf;
2329 int err = 0;
2330
2331 ieee80211_dbg(IEEE80211_MSG_CONFIG, "wl_set_ibss: "
2332 "set createibss=%u\n", *iw_ibss);
2333
2334 if ((ic->ic_caps & IEEE80211_C_IBSS) == 0) {
2335 err = ENOTSUP;
2336 return (err);
2337 }
2338 if (*iw_ibss) {
2339 if ((ic->ic_flags & IEEE80211_F_IBSSON) == 0) {
2340 ic->ic_flags |= IEEE80211_F_IBSSON;
2341 ic->ic_opmode = IEEE80211_M_IBSS;
2342 /*
2343 * Yech, slot time may change depending on the
2344 * operating mode so reset it to be sure
2345 * everything is setup appropriately.
2346 */
2347 ieee80211_reset_erp(ic);
2348 err = ENETRESET;
2349 }
2350 } else {
2351 if (ic->ic_flags & IEEE80211_F_IBSSON) {
2352 ic->ic_flags &= ~IEEE80211_F_IBSSON;
2353 err = ENETRESET;
2354 }
2355 }
2356
2357 return (err);
2358 }
2359
2360 static void
2361 wl_get_createibss(struct ieee80211com *ic, void *wldp_buf)
2362 {
2363 wl_create_ibss_t *ow_ibss = (wl_create_ibss_t *)wldp_buf;
2364
2365 *ow_ibss = (ic->ic_flags & IEEE80211_F_IBSSON)? 1 : 0;
2366 }
2367
2368 /*
2369 * Typically invoked by drivers in response to request for
2370 * information or to change settings from the userland.
2371 *
2372 * Return value should be checked by WiFI drivers. Return 0
2373 * on success. Otherwise, return non-zero value to indicate
2374 * the error. Driver should operate as below when the return
2375 * error is:
2376 * ENETRESET Reset wireless network and re-start to join a
2377 * WLAN, ENETRESET is returned when a configuration
2378 * parameter has been changed.
2379 * When acknowledge a M_IOCTL message, this error
2380 * is ignored
2381 */
2382 /* ARGSUSED */
2383 int
2384 ieee80211_setprop(void *ic_arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
2385 uint_t wldp_length, const void *wldp_buf)
2386 {
2387 int err = 0;
2388 struct ieee80211com *ic = ic_arg;
2389
2390 ASSERT(ic != NULL);
2391 IEEE80211_LOCK(ic);
2392
2393 switch (wldp_pr_num) {
2394 /* mac_prop_id */
2395 case MAC_PROP_WL_ESSID:
2396 err = wl_set_essid(ic, wldp_buf);
2397 break;
2398 case MAC_PROP_WL_BSSID:
2399 err = wl_set_bssid(ic, wldp_buf);
2400 break;
2401 case MAC_PROP_WL_PHY_CONFIG:
2402 err = wl_set_phy(ic, wldp_buf);
2403 break;
2404 case MAC_PROP_WL_KEY_TAB:
2405 err = wl_set_wepkey(ic, wldp_buf);
2406 break;
2407 case MAC_PROP_WL_AUTH_MODE:
2408 err = wl_set_authmode(ic, wldp_buf);
2409 break;
2410 case MAC_PROP_WL_ENCRYPTION:
2411 err = wl_set_encrypt(ic, wldp_buf);
2412 break;
2413 case MAC_PROP_WL_BSSTYPE:
2414 err = wl_set_bsstype(ic, wldp_buf);
2415 break;
2416 case MAC_PROP_WL_DESIRED_RATES:
2417 err = wl_set_desrates(ic, wldp_buf);
2418 break;
2419 case MAC_PROP_WL_WPA:
2420 err = wl_set_wpa(ic, wldp_buf);
2421 break;
2422 case MAC_PROP_WL_KEY:
2423 err = wl_set_wpakey(ic, wldp_buf);
2424 break;
2425 case MAC_PROP_WL_DELKEY:
2426 err = wl_set_delkey(ic, wldp_buf);
2427 break;
2428 case MAC_PROP_WL_SETOPTIE:
2429 err = wl_set_optie(ic, wldp_buf);
2430 break;
2431 case MAC_PROP_WL_MLME:
2432 err = wl_set_mlme(ic, wldp_buf);
2433 break;
2434 case MAC_PROP_WL_CREATE_IBSS:
2435 err = wl_set_createibss(ic, wldp_buf);
2436 break;
2437 case MAC_PROP_WL_LINKSTATUS:
2438 case MAC_PROP_WL_ESS_LIST:
2439 case MAC_PROP_WL_SUPPORTED_RATES:
2440 case MAC_PROP_WL_RSSI:
2441 case MAC_PROP_WL_CAPABILITY:
2442 case MAC_PROP_WL_SCANRESULTS:
2443 ieee80211_err("ieee80211_setprop: opmode err\n");
2444 err = EINVAL;
2445 break;
2446 default:
2447 ieee80211_err("ieee80211_setprop: opmode not support\n");
2448 err = ENOTSUP;
2449 break;
2450 }
2451
2452 IEEE80211_UNLOCK(ic);
2453
2454 return (err);
2455 }
2456
2457 /* ARGSUSED */
2458 int
2459 ieee80211_getprop(void *ic_arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
2460 uint_t wldp_length, void *wldp_buf)
2461 {
2462 int err = 0;
2463 struct ieee80211com *ic = ic_arg;
2464
2465 ASSERT(ic != NULL);
2466 IEEE80211_LOCK(ic);
2467
2468 switch (wldp_pr_num) {
2469 /* mac_prop_id */
2470 case MAC_PROP_WL_ESSID:
2471 wl_get_essid(ic, wldp_buf);
2472 break;
2473 case MAC_PROP_WL_BSSID:
2474 wl_get_bssid(ic, wldp_buf);
2475 break;
2476 case MAC_PROP_WL_PHY_CONFIG:
2477 err = wl_get_phy(ic, wldp_buf);
2478 break;
2479 case MAC_PROP_WL_AUTH_MODE:
2480 wl_get_authmode(ic, wldp_buf);
2481 break;
2482 case MAC_PROP_WL_ENCRYPTION:
2483 wl_get_encrypt(ic, wldp_buf);
2484 break;
2485 case MAC_PROP_WL_BSSTYPE:
2486 wl_get_bsstype(ic, wldp_buf);
2487 break;
2488 case MAC_PROP_WL_DESIRED_RATES:
2489 wl_get_desrates(ic, wldp_buf);
2490 break;
2491 case MAC_PROP_WL_LINKSTATUS:
2492 wl_get_linkstatus(ic, wldp_buf);
2493 break;
2494 case MAC_PROP_WL_ESS_LIST:
2495 wl_get_esslist(ic, wldp_buf);
2496 break;
2497 case MAC_PROP_WL_SUPPORTED_RATES:
2498 wl_get_suprates(ic, wldp_buf);
2499 break;
2500 case MAC_PROP_WL_RSSI:
2501 wl_get_rssi(ic, wldp_buf);
2502 break;
2503 case MAC_PROP_WL_CAPABILITY:
2504 wl_get_capability(ic, wldp_buf);
2505 break;
2506 case MAC_PROP_WL_WPA:
2507 wl_get_wpa(ic, wldp_buf);
2508 break;
2509 case MAC_PROP_WL_SCANRESULTS:
2510 wl_get_scanresults(ic, wldp_buf);
2511 break;
2512 case MAC_PROP_WL_CREATE_IBSS:
2513 wl_get_createibss(ic, wldp_buf);
2514 break;
2515 case MAC_PROP_WL_KEY_TAB:
2516 case MAC_PROP_WL_KEY:
2517 case MAC_PROP_WL_DELKEY:
2518 case MAC_PROP_WL_SETOPTIE:
2519 case MAC_PROP_WL_MLME:
2520 ieee80211_err("ieee80211_setprop: opmode err\n");
2521 err = EINVAL;
2522 break;
2523 default:
2524 ieee80211_err("ieee80211_setprop: opmode not support\n");
2525 err = ENOTSUP;
2526 break;
2527 }
2528
2529 IEEE80211_UNLOCK(ic);
2530
2531 return (err);
2532 }
2533
2534 void ieee80211_propinfo(void *ic_arg, const char *pr_name,
2535 mac_prop_id_t wldp_pr_num, mac_prop_info_handle_t prh)
2536 {
2537 _NOTE(ARGUNUSED(pr_name, ic_arg));
2538
2539 /*
2540 * By default permissions are read/write unless specified
2541 * otherwise by the driver.
2542 */
2543
2544 switch (wldp_pr_num) {
2545 case MAC_PROP_WL_LINKSTATUS:
2546 case MAC_PROP_WL_ESS_LIST:
2547 case MAC_PROP_WL_SUPPORTED_RATES:
2548 case MAC_PROP_WL_RSSI:
2549 case MAC_PROP_WL_CAPABILITY:
2550 case MAC_PROP_WL_SCANRESULTS:
2551 case MAC_PROP_WL_CREATE_IBSS:
2552 mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
2553 }
2554 }
Unleashed OS