?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'origin/master'
[unleashed/lotheac.git] / usr / src / uts / common / io / simnet / simnet.c
blob727fbbad8e2d9140e0b34a144c55b84ea9e35996
1 /*
2 * CDDL HEADER START
3 *
4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
7 *
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or http://www.opensolaris.org/os/licensing.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
12 *
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
18 *
19 * CDDL HEADER END
20 */
21 /*
22 * Copyright 2010 Sun Microsystems, Inc. All rights reserved.
23 * Use is subject to license terms.
24 */
25
26 /*
27 * Simulated network device (simnet) driver: simulates a pseudo GLDv3 network
28 * device. Can simulate an Ethernet or WiFi network device. In addition, another
29 * simnet instance can be attached as a peer to create a point-to-point link on
30 * the same system.
31 */
32
33 #include <sys/policy.h>
34 #include <sys/conf.h>
35 #include <sys/modctl.h>
36 #include <sys/priv_names.h>
37 #include <sys/dlpi.h>
38 #include <net/simnet.h>
39 #include <sys/ethernet.h>
40 #include <sys/mac.h>
41 #include <sys/dls.h>
42 #include <sys/mac_ether.h>
43 #include <sys/mac_provider.h>
44 #include <sys/mac_client_priv.h>
45 #include <sys/vlan.h>
46 #include <sys/random.h>
47 #include <sys/sysmacros.h>
48 #include <sys/list.h>
49 #include <sys/strsubr.h>
50 #include <sys/strsun.h>
51 #include <sys/atomic.h>
52 #include <sys/mac_wifi.h>
53 #include <sys/mac_impl.h>
54 #include <inet/wifi_ioctl.h>
55 #include <sys/thread.h>
56 #include <sys/synch.h>
57 #include <sys/sunddi.h>
58
59 #include "simnet_impl.h"
60
61 #define SIMNETINFO "Simulated Network Driver"
62
63 static dev_info_t *simnet_dip;
64 static ddi_taskq_t *simnet_rxq;
65
66 static int simnet_getinfo(dev_info_t *, ddi_info_cmd_t, void *, void **);
67 static int simnet_attach(dev_info_t *, ddi_attach_cmd_t);
68 static int simnet_detach(dev_info_t *, ddi_detach_cmd_t);
69 static int simnet_ioc_create(void *, intptr_t, int, cred_t *, int *);
70 static int simnet_ioc_delete(void *, intptr_t, int, cred_t *, int *);
71 static int simnet_ioc_info(void *, intptr_t, int, cred_t *, int *);
72 static int simnet_ioc_modify(void *, intptr_t, int, cred_t *, int *);
73 static uint8_t *mcastaddr_lookup(simnet_dev_t *, const uint8_t *);
74
75 static dld_ioc_info_t simnet_ioc_list[] = {
76 {SIMNET_IOC_CREATE, DLDCOPYINOUT, sizeof (simnet_ioc_create_t),
77 simnet_ioc_create, secpolicy_dl_config},
78 {SIMNET_IOC_DELETE, DLDCOPYIN, sizeof (simnet_ioc_delete_t),
79 simnet_ioc_delete, secpolicy_dl_config},
80 {SIMNET_IOC_INFO, DLDCOPYINOUT, sizeof (simnet_ioc_info_t),
81 simnet_ioc_info, NULL},
82 {SIMNET_IOC_MODIFY, DLDCOPYIN, sizeof (simnet_ioc_modify_t),
83 simnet_ioc_modify, secpolicy_dl_config}
84 };
85
86 DDI_DEFINE_STREAM_OPS(simnet_dev_ops, nulldev, nulldev, simnet_attach,
87 simnet_detach, nodev, simnet_getinfo, D_MP, NULL,
88 ddi_quiesce_not_supported);
89
90 static struct modldrv simnet_modldrv = {
91 &mod_driverops, /* Type of module. This one is a driver */
92 SIMNETINFO, /* short description */
93 &simnet_dev_ops /* driver specific ops */
94 };
95
96 static struct modlinkage modlinkage = {
97 MODREV_1, &simnet_modldrv, NULL
98 };
99
100 /* MAC callback function declarations */
101 static int simnet_m_start(void *);
102 static void simnet_m_stop(void *);
103 static int simnet_m_promisc(void *, boolean_t);
104 static int simnet_m_multicst(void *, boolean_t, const uint8_t *);
105 static int simnet_m_unicst(void *, const uint8_t *);
106 static int simnet_m_stat(void *, uint_t, uint64_t *);
107 static void simnet_m_ioctl(void *, queue_t *, mblk_t *);
108 static mblk_t *simnet_m_tx(void *, mblk_t *);
109 static int simnet_m_setprop(void *, const char *, mac_prop_id_t,
110 uint_t, const void *);
111 static int simnet_m_getprop(void *, const char *, mac_prop_id_t,
112 uint_t, void *);
113 static void simnet_m_propinfo(void *, const char *, mac_prop_id_t,
114 mac_prop_info_handle_t);
115
116 static mac_callbacks_t simnet_m_callbacks = {
117 (MC_IOCTL | MC_SETPROP | MC_GETPROP | MC_PROPINFO),
118 simnet_m_stat,
119 simnet_m_start,
120 simnet_m_stop,
121 simnet_m_promisc,
122 simnet_m_multicst,
123 simnet_m_unicst,
124 simnet_m_tx,
125 NULL,
126 simnet_m_ioctl,
127 NULL,
128 NULL,
129 NULL,
130 simnet_m_setprop,
131 simnet_m_getprop,
132 simnet_m_propinfo
133 };
134
135 /*
136 * simnet_dev_lock protects the simnet device list.
137 * sd_instlock in each simnet_dev_t protects access to
138 * a single simnet_dev_t.
139 */
140 static krwlock_t simnet_dev_lock;
141 static list_t simnet_dev_list;
142 static int simnet_count; /* Num of simnet instances */
143
144 int
145 _init(void)
146 {
147 int status;
148
149 mac_init_ops(&simnet_dev_ops, "simnet");
150 status = mod_install(&modlinkage);
151 if (status != DDI_SUCCESS)
152 mac_fini_ops(&simnet_dev_ops);
153
154 return (status);
155 }
156
157 int
158 _fini(void)
159 {
160 int status;
161
162 status = mod_remove(&modlinkage);
163 if (status == DDI_SUCCESS)
164 mac_fini_ops(&simnet_dev_ops);
165
166 return (status);
167 }
168
169 int
170 _info(struct modinfo *modinfop)
171 {
172 return (mod_info(&modlinkage, modinfop));
173 }
174
175 static boolean_t
176 simnet_init(void)
177 {
178 if ((simnet_rxq = ddi_taskq_create(simnet_dip, "simnet", 1,
179 TASKQ_DEFAULTPRI, 0)) == NULL)
180 return (B_FALSE);
181 rw_init(&simnet_dev_lock, NULL, RW_DEFAULT, NULL);
182 list_create(&simnet_dev_list, sizeof (simnet_dev_t),
183 offsetof(simnet_dev_t, sd_listnode));
184 return (B_TRUE);
185 }
186
187 static void
188 simnet_fini(void)
189 {
190 ASSERT(simnet_count == 0);
191 rw_destroy(&simnet_dev_lock);
192 list_destroy(&simnet_dev_list);
193 ddi_taskq_destroy(simnet_rxq);
194 }
195
196 /*ARGSUSED*/
197 static int
198 simnet_getinfo(dev_info_t *dip, ddi_info_cmd_t infocmd, void *arg,
199 void **result)
200 {
201 switch (infocmd) {
202 case DDI_INFO_DEVT2DEVINFO:
203 *result = simnet_dip;
204 return (DDI_SUCCESS);
205 case DDI_INFO_DEVT2INSTANCE:
206 *result = NULL;
207 return (DDI_SUCCESS);
208 }
209 return (DDI_FAILURE);
210 }
211
212 static int
213 simnet_attach(dev_info_t *dip, ddi_attach_cmd_t cmd)
214 {
215 switch (cmd) {
216 case DDI_ATTACH:
217 if (ddi_get_instance(dip) != 0) {
218 /* we only allow instance 0 to attach */
219 return (DDI_FAILURE);
220 }
221
222 if (dld_ioc_register(SIMNET_IOC, simnet_ioc_list,
223 DLDIOCCNT(simnet_ioc_list)) != 0)
224 return (DDI_FAILURE);
225
226 simnet_dip = dip;
227 if (!simnet_init())
228 return (DDI_FAILURE);
229 return (DDI_SUCCESS);
230
231 case DDI_RESUME:
232 return (DDI_SUCCESS);
233
234 default:
235 return (DDI_FAILURE);
236 }
237 }
238
239 /*ARGSUSED*/
240 static int
241 simnet_detach(dev_info_t *dip, ddi_detach_cmd_t cmd)
242 {
243 switch (cmd) {
244 case DDI_DETACH:
245 /*
246 * Allow the simnet instance to be detached only if there
247 * are no simnets configured.
248 */
249 if (simnet_count > 0)
250 return (DDI_FAILURE);
251
252 dld_ioc_unregister(SIMNET_IOC);
253 simnet_fini();
254 simnet_dip = NULL;
255 return (DDI_SUCCESS);
256
257 case DDI_SUSPEND:
258 return (DDI_SUCCESS);
259
260 default:
261 return (DDI_FAILURE);
262 }
263 }
264
265 /* Caller must hold simnet_dev_lock */
266 static simnet_dev_t *
267 simnet_dev_lookup(datalink_id_t link_id)
268 {
269 simnet_dev_t *sdev;
270
271 ASSERT(RW_LOCK_HELD(&simnet_dev_lock));
272 for (sdev = list_head(&simnet_dev_list); sdev != NULL;
273 sdev = list_next(&simnet_dev_list, sdev)) {
274 if (!(sdev->sd_flags & SDF_SHUTDOWN) &&
275 (sdev->sd_link_id == link_id)) {
276 atomic_inc_32(&sdev->sd_refcount);
277 return (sdev);
278 }
279 }
280
281 return (NULL);
282 }
283
284 static void
285 simnet_wifidev_free(simnet_dev_t *sdev)
286 {
287 simnet_wifidev_t *wdev = sdev->sd_wifidev;
288 int i;
289
290 for (i = 0; i < wdev->swd_esslist_num; i++) {
291 kmem_free(wdev->swd_esslist[i],
292 sizeof (wl_ess_conf_t));
293 }
294 kmem_free(wdev, sizeof (simnet_wifidev_t));
295 }
296
297 static void
298 simnet_dev_unref(simnet_dev_t *sdev)
299 {
300
301 ASSERT(sdev->sd_refcount > 0);
302 if (atomic_dec_32_nv(&sdev->sd_refcount) != 0)
303 return;
304
305 if (sdev->sd_mh != NULL)
306 (void) mac_unregister(sdev->sd_mh);
307
308 if (sdev->sd_wifidev != NULL) {
309 ASSERT(sdev->sd_type == DL_WIFI);
310 simnet_wifidev_free(sdev);
311 }
312
313 mutex_destroy(&sdev->sd_instlock);
314 cv_destroy(&sdev->sd_threadwait);
315 kmem_free(sdev->sd_mcastaddrs, ETHERADDRL * sdev->sd_mcastaddr_count);
316 kmem_free(sdev, sizeof (*sdev));
317 simnet_count--;
318 }
319
320 static int
321 simnet_init_wifi(simnet_dev_t *sdev, mac_register_t *mac)
322 {
323 wifi_data_t wd = { 0 };
324 int err;
325
326 sdev->sd_wifidev = kmem_zalloc(sizeof (simnet_wifidev_t), KM_NOSLEEP);
327 if (sdev->sd_wifidev == NULL)
328 return (ENOMEM);
329
330 sdev->sd_wifidev->swd_sdev = sdev;
331 sdev->sd_wifidev->swd_linkstatus = WL_NOTCONNECTED;
332 wd.wd_secalloc = WIFI_SEC_NONE;
333 wd.wd_opmode = IEEE80211_M_STA;
334 mac->m_type_ident = MAC_PLUGIN_IDENT_WIFI;
335 mac->m_max_sdu = IEEE80211_MTU;
336 mac->m_pdata = &wd;
337 mac->m_pdata_size = sizeof (wd);
338 err = mac_register(mac, &sdev->sd_mh);
339 return (err);
340 }
341
342 static int
343 simnet_init_ether(simnet_dev_t *sdev, mac_register_t *mac)
344 {
345 int err;
346
347 mac->m_type_ident = MAC_PLUGIN_IDENT_ETHER;
348 mac->m_max_sdu = SIMNET_MAX_MTU;
349 mac->m_margin = VLAN_TAGSZ;
350 err = mac_register(mac, &sdev->sd_mh);
351 return (err);
352 }
353
354 static int
355 simnet_init_mac(simnet_dev_t *sdev)
356 {
357 mac_register_t *mac;
358 int err;
359
360 if ((mac = mac_alloc(MAC_VERSION)) == NULL)
361 return (ENOMEM);
362
363 mac->m_driver = sdev;
364 mac->m_dip = simnet_dip;
365 mac->m_instance = (uint_t)-1;
366 mac->m_src_addr = sdev->sd_mac_addr;
367 mac->m_callbacks = &simnet_m_callbacks;
368 mac->m_min_sdu = 0;
369
370 if (sdev->sd_type == DL_ETHER)
371 err = simnet_init_ether(sdev, mac);
372 else if (sdev->sd_type == DL_WIFI)
373 err = simnet_init_wifi(sdev, mac);
374 else
375 err = EINVAL;
376
377 mac_free(mac);
378 return (err);
379 }
380
381 /* ARGSUSED */
382 static int
383 simnet_ioc_create(void *karg, intptr_t arg, int mode, cred_t *cred, int *rvalp)
384 {
385 simnet_ioc_create_t *create_arg = karg;
386 simnet_dev_t *sdev;
387 simnet_dev_t *sdev_tmp;
388 int err = 0;
389
390 sdev = kmem_zalloc(sizeof (*sdev), KM_NOSLEEP);
391 if (sdev == NULL)
392 return (ENOMEM);
393
394 rw_enter(&simnet_dev_lock, RW_WRITER);
395 if ((sdev_tmp = simnet_dev_lookup(create_arg->sic_link_id)) != NULL) {
396 simnet_dev_unref(sdev_tmp);
397 rw_exit(&simnet_dev_lock);
398 kmem_free(sdev, sizeof (*sdev));
399 return (EEXIST);
400 }
401
402 sdev->sd_type = create_arg->sic_type;
403 sdev->sd_link_id = create_arg->sic_link_id;
404 sdev->sd_zoneid = crgetzoneid(cred);
405 sdev->sd_refcount++;
406 mutex_init(&sdev->sd_instlock, NULL, MUTEX_DRIVER, NULL);
407 cv_init(&sdev->sd_threadwait, NULL, CV_DRIVER, NULL);
408 simnet_count++;
409
410 /* Simnets created from configuration on boot pass saved MAC address */
411 if (create_arg->sic_mac_len == 0) {
412 /* Generate random MAC address */
413 (void) random_get_pseudo_bytes(sdev->sd_mac_addr, ETHERADDRL);
414 /* Ensure MAC address is not multicast and is local */
415 sdev->sd_mac_addr[0] = (sdev->sd_mac_addr[0] & ~1) | 2;
416 sdev->sd_mac_len = ETHERADDRL;
417 } else {
418 (void) memcpy(sdev->sd_mac_addr, create_arg->sic_mac_addr,
419 create_arg->sic_mac_len);
420 sdev->sd_mac_len = create_arg->sic_mac_len;
421 }
422
423 if ((err = simnet_init_mac(sdev)) != 0) {
424 simnet_dev_unref(sdev);
425 goto exit;
426 }
427
428 if ((err = dls_devnet_create(sdev->sd_mh, sdev->sd_link_id,
429 crgetzoneid(cred))) != 0) {
430 simnet_dev_unref(sdev);
431 goto exit;
432 }
433
434 mac_link_update(sdev->sd_mh, LINK_STATE_UP);
435 mac_tx_update(sdev->sd_mh);
436 list_insert_tail(&simnet_dev_list, sdev);
437
438 /* Always return MAC address back to caller */
439 (void) memcpy(create_arg->sic_mac_addr, sdev->sd_mac_addr,
440 sdev->sd_mac_len);
441 create_arg->sic_mac_len = sdev->sd_mac_len;
442 exit:
443 rw_exit(&simnet_dev_lock);
444 return (err);
445 }
446
447 /* Caller must hold writer simnet_dev_lock */
448 static datalink_id_t
449 simnet_remove_peer(simnet_dev_t *sdev)
450 {
451 simnet_dev_t *sdev_peer;
452 datalink_id_t peer_link_id = DATALINK_INVALID_LINKID;
453
454 ASSERT(RW_WRITE_HELD(&simnet_dev_lock));
455 if ((sdev_peer = sdev->sd_peer_dev) != NULL) {
456 ASSERT(sdev == sdev_peer->sd_peer_dev);
457 sdev_peer->sd_peer_dev = NULL;
458 sdev->sd_peer_dev = NULL;
459 peer_link_id = sdev_peer->sd_link_id;
460 /* Release previous references held on both simnets */
461 simnet_dev_unref(sdev_peer);
462 simnet_dev_unref(sdev);
463 }
464
465 return (peer_link_id);
466 }
467
468 /* ARGSUSED */
469 static int
470 simnet_ioc_modify(void *karg, intptr_t arg, int mode, cred_t *cred, int *rvalp)
471 {
472 simnet_ioc_modify_t *modify_arg = karg;
473 simnet_dev_t *sdev;
474 simnet_dev_t *sdev_peer = NULL;
475
476 rw_enter(&simnet_dev_lock, RW_WRITER);
477 if ((sdev = simnet_dev_lookup(modify_arg->sim_link_id)) == NULL) {
478 rw_exit(&simnet_dev_lock);
479 return (ENOENT);
480 }
481
482 if (sdev->sd_zoneid != crgetzoneid(cred)) {
483 rw_exit(&simnet_dev_lock);
484 simnet_dev_unref(sdev);
485 return (ENOENT);
486 }
487
488 if (sdev->sd_link_id == modify_arg->sim_peer_link_id) {
489 /* Cannot peer with self */
490 rw_exit(&simnet_dev_lock);
491 simnet_dev_unref(sdev);
492 return (EINVAL);
493 }
494
495 if (sdev->sd_peer_dev != NULL && sdev->sd_peer_dev->sd_link_id ==
496 modify_arg->sim_peer_link_id) {
497 /* Nothing to modify */
498 rw_exit(&simnet_dev_lock);
499 simnet_dev_unref(sdev);
500 return (0);
501 }
502
503 if (modify_arg->sim_peer_link_id != DATALINK_INVALID_LINKID) {
504 sdev_peer = simnet_dev_lookup(modify_arg->sim_peer_link_id);
505 if (sdev_peer == NULL) {
506 /* Peer simnet device not available */
507 rw_exit(&simnet_dev_lock);
508 simnet_dev_unref(sdev);
509 return (ENOENT);
510 }
511 if (sdev_peer->sd_zoneid != sdev->sd_zoneid) {
512 /* The two peers must be in the same zone (for now). */
513 rw_exit(&simnet_dev_lock);
514 simnet_dev_unref(sdev);
515 simnet_dev_unref(sdev_peer);
516 return (EACCES);
517 }
518 }
519
520 /* First remove any previous peer */
521 (void) simnet_remove_peer(sdev);
522
523 if (sdev_peer != NULL) {
524 /* Remove any previous peer of sdev_peer */
525 (void) simnet_remove_peer(sdev_peer);
526 /* Update both devices with the new peer */
527 sdev_peer->sd_peer_dev = sdev;
528 sdev->sd_peer_dev = sdev_peer;
529 /* Hold references on both devices */
530 } else {
531 /* Release sdev lookup reference */
532 simnet_dev_unref(sdev);
533 }
534
535 rw_exit(&simnet_dev_lock);
536 return (0);
537 }
538
539 /* ARGSUSED */
540 static int
541 simnet_ioc_delete(void *karg, intptr_t arg, int mode, cred_t *cred, int *rvalp)
542 {
543 int err;
544 simnet_dev_t *sdev;
545 simnet_dev_t *sdev_peer;
546 simnet_ioc_delete_t *delete_arg = karg;
547 datalink_id_t tmpid;
548 datalink_id_t peerid;
549
550 rw_enter(&simnet_dev_lock, RW_WRITER);
551 if ((sdev = simnet_dev_lookup(delete_arg->sid_link_id)) == NULL) {
552 rw_exit(&simnet_dev_lock);
553 return (ENOENT);
554 }
555
556 if (sdev->sd_zoneid != crgetzoneid(cred)) {
557 rw_exit(&simnet_dev_lock);
558 simnet_dev_unref(sdev);
559 return (ENOENT);
560 }
561
562 if ((err = dls_devnet_destroy(sdev->sd_mh, &tmpid, B_TRUE)) != 0) {
563 rw_exit(&simnet_dev_lock);
564 simnet_dev_unref(sdev);
565 return (err);
566 }
567
568 ASSERT(sdev->sd_link_id == tmpid);
569 /* Remove any attached peer link */
570 peerid = simnet_remove_peer(sdev);
571
572 /* Prevent new threads from using the instance */
573 mutex_enter(&sdev->sd_instlock);
574 sdev->sd_flags |= SDF_SHUTDOWN;
575 /* Wait until all active threads using the instance exit */
576 while (sdev->sd_threadcount > 0) {
577 if (cv_wait_sig(&sdev->sd_threadwait,
578 &sdev->sd_instlock) == 0) {
579 /* Signaled */
580 mutex_exit(&sdev->sd_instlock);
581 err = EINTR;
582 goto fail;
583 }
584 }
585 mutex_exit(&sdev->sd_instlock);
586
587 /* Try disabling the MAC */
588 if ((err = mac_disable(sdev->sd_mh)) != 0)
589 goto fail;
590
591 list_remove(&simnet_dev_list, sdev);
592 rw_exit(&simnet_dev_lock);
593 simnet_dev_unref(sdev); /* Release lookup ref */
594 /* Releasing the last ref performs sdev/mem free */
595 simnet_dev_unref(sdev);
596 return (err);
597 fail:
598 /* Re-create simnet instance and add any previous peer */
599 (void) dls_devnet_create(sdev->sd_mh, sdev->sd_link_id,
600 crgetzoneid(cred));
601 sdev->sd_flags &= ~SDF_SHUTDOWN;
602
603 ASSERT(sdev->sd_peer_dev == NULL);
604 if (peerid != DATALINK_INVALID_LINKID &&
605 ((sdev_peer = simnet_dev_lookup(peerid)) != NULL)) {
606 /* Attach peer device back */
607 ASSERT(sdev_peer->sd_peer_dev == NULL);
608 sdev_peer->sd_peer_dev = sdev;
609 sdev->sd_peer_dev = sdev_peer;
610 /* Hold reference on both devices */
611 } else {
612 /*
613 * No previous peer or previous peer no longer
614 * available so release lookup reference.
615 */
616 simnet_dev_unref(sdev);
617 }
618
619 rw_exit(&simnet_dev_lock);
620 return (err);
621 }
622
623 /* ARGSUSED */
624 static int
625 simnet_ioc_info(void *karg, intptr_t arg, int mode, cred_t *cred, int *rvalp)
626 {
627 simnet_ioc_info_t *info_arg = karg;
628 simnet_dev_t *sdev;
629
630 /* Make sure that the simnet link is visible from the caller's zone. */
631 if (!dls_devnet_islinkvisible(info_arg->sii_link_id, crgetzoneid(cred)))
632 return (ENOENT);
633
634 rw_enter(&simnet_dev_lock, RW_READER);
635 if ((sdev = simnet_dev_lookup(info_arg->sii_link_id)) == NULL) {
636 rw_exit(&simnet_dev_lock);
637 return (ENOENT);
638 }
639
640 (void) memcpy(info_arg->sii_mac_addr, sdev->sd_mac_addr,
641 sdev->sd_mac_len);
642 info_arg->sii_mac_len = sdev->sd_mac_len;
643 info_arg->sii_type = sdev->sd_type;
644 if (sdev->sd_peer_dev != NULL)
645 info_arg->sii_peer_link_id = sdev->sd_peer_dev->sd_link_id;
646 rw_exit(&simnet_dev_lock);
647 simnet_dev_unref(sdev);
648 return (0);
649 }
650
651 static boolean_t
652 simnet_thread_ref(simnet_dev_t *sdev)
653 {
654 mutex_enter(&sdev->sd_instlock);
655 if (sdev->sd_flags & SDF_SHUTDOWN ||
656 !(sdev->sd_flags & SDF_STARTED)) {
657 mutex_exit(&sdev->sd_instlock);
658 return (B_FALSE);
659 }
660 sdev->sd_threadcount++;
661 mutex_exit(&sdev->sd_instlock);
662 return (B_TRUE);
663 }
664
665 static void
666 simnet_thread_unref(simnet_dev_t *sdev)
667 {
668 mutex_enter(&sdev->sd_instlock);
669 if (--sdev->sd_threadcount == 0)
670 cv_broadcast(&sdev->sd_threadwait);
671 mutex_exit(&sdev->sd_instlock);
672 }
673
674 static void
675 simnet_rx(void *arg)
676 {
677 mblk_t *mp = arg;
678 mac_header_info_t hdr_info;
679 simnet_dev_t *sdev;
680
681 sdev = (simnet_dev_t *)mp->b_next;
682 mp->b_next = NULL;
683
684 /* Check for valid packet header */
685 if (mac_header_info(sdev->sd_mh, mp, &hdr_info) != 0) {
686 freemsg(mp);
687 sdev->sd_stats.recv_errors++;
688 goto rx_done;
689 }
690
691 /*
692 * When we are NOT in promiscuous mode we only receive
693 * unicast packets addressed to us and multicast packets that
694 * MAC clients have requested.
695 */
696 if (!sdev->sd_promisc &&
697 hdr_info.mhi_dsttype != MAC_ADDRTYPE_BROADCAST) {
698 if (hdr_info.mhi_dsttype == MAC_ADDRTYPE_UNICAST &&
699 bcmp(hdr_info.mhi_daddr, sdev->sd_mac_addr,
700 ETHERADDRL) != 0) {
701 freemsg(mp);
702 goto rx_done;
703 } else if (hdr_info.mhi_dsttype == MAC_ADDRTYPE_MULTICAST) {
704 mutex_enter(&sdev->sd_instlock);
705 if (mcastaddr_lookup(sdev, hdr_info.mhi_daddr) ==
706 NULL) {
707 mutex_exit(&sdev->sd_instlock);
708 freemsg(mp);
709 goto rx_done;
710 }
711 mutex_exit(&sdev->sd_instlock);
712 }
713 }
714
715 sdev->sd_stats.recv_count++;
716 sdev->sd_stats.rbytes += msgdsize(mp);
717 mac_rx(sdev->sd_mh, NULL, mp);
718 rx_done:
719 simnet_thread_unref(sdev);
720 }
721
722 static mblk_t *
723 simnet_m_tx(void *arg, mblk_t *mp_chain)
724 {
725 simnet_dev_t *sdev = arg;
726 simnet_dev_t *sdev_rx;
727 mblk_t *mpnext = mp_chain;
728 mblk_t *mp;
729
730 rw_enter(&simnet_dev_lock, RW_READER);
731 if ((sdev_rx = sdev->sd_peer_dev) == NULL) {
732 /* Discard packets when no peer exists */
733 rw_exit(&simnet_dev_lock);
734 freemsgchain(mp_chain);
735 return (NULL);
736 }
737
738 /*
739 * Discard packets when either device is shutting down or not ready.
740 * Though MAC layer ensures a reference is held on the MAC while we
741 * process the packet chain, there is no guarantee the peer MAC will
742 * remain enabled. So we increment per-instance threadcount to ensure
743 * either MAC instance is not disabled while we handle the chain of
744 * packets. It is okay if the peer device is disconnected while we are
745 * here since we lookup the peer device while holding simnet_dev_lock
746 * (reader lock) and increment the threadcount of the peer, the peer
747 * MAC cannot be disabled in simnet_ioc_delete.
748 */
749 if (!simnet_thread_ref(sdev_rx)) {
750 rw_exit(&simnet_dev_lock);
751 freemsgchain(mp_chain);
752 return (NULL);
753 }
754 rw_exit(&simnet_dev_lock);
755
756 if (!simnet_thread_ref(sdev)) {
757 simnet_thread_unref(sdev_rx);
758 freemsgchain(mp_chain);
759 return (NULL);
760 }
761
762 while ((mp = mpnext) != NULL) {
763 int len;
764 int size;
765 mblk_t *mp_new;
766 mblk_t *mp_tmp;
767
768 mpnext = mp->b_next;
769 mp->b_next = NULL;
770 len = msgdsize(mp);
771
772 /* Pad packet to minimum Ethernet frame size */
773 if (len < ETHERMIN) {
774 size = ETHERMIN - len;
775 mp_new = allocb(size, BPRI_HI);
776 if (mp_new == NULL) {
777 sdev->sd_stats.xmit_errors++;
778 freemsg(mp);
779 continue;
780 }
781 bzero(mp_new->b_wptr, size);
782 mp_new->b_wptr += size;
783
784 mp_tmp = mp;
785 while (mp_tmp->b_cont != NULL)
786 mp_tmp = mp_tmp->b_cont;
787 mp_tmp->b_cont = mp_new;
788 len += size;
789 }
790
791 /* Pullup packet into a single mblk */
792 if (!pullupmsg(mp, -1)) {
793 sdev->sd_stats.xmit_errors++;
794 freemsg(mp);
795 continue;
796 }
797
798 /* Fix mblk checksum as the pkt dest is local */
799 if ((mp = mac_fix_cksum(mp)) == NULL) {
800 sdev->sd_stats.xmit_errors++;
801 continue;
802 }
803
804 /* Hold reference for taskq receive processing per-pkt */
805 if (!simnet_thread_ref(sdev_rx)) {
806 freemsg(mp);
807 freemsgchain(mpnext);
808 break;
809 }
810
811 /* Use taskq for pkt receive to avoid kernel stack explosion */
812 mp->b_next = (mblk_t *)sdev_rx;
813 if (ddi_taskq_dispatch(simnet_rxq, simnet_rx, mp,
814 DDI_NOSLEEP) == DDI_SUCCESS) {
815 sdev->sd_stats.xmit_count++;
816 sdev->sd_stats.obytes += len;
817 } else {
818 simnet_thread_unref(sdev_rx);
819 mp->b_next = NULL;
820 freemsg(mp);
821 sdev_rx->sd_stats.recv_errors++;
822 }
823 }
824
825 simnet_thread_unref(sdev);
826 simnet_thread_unref(sdev_rx);
827 return (NULL);
828 }
829
830 static int
831 simnet_wifi_ioctl(simnet_dev_t *sdev, mblk_t *mp)
832 {
833 int rc = WL_SUCCESS;
834 simnet_wifidev_t *wdev = sdev->sd_wifidev;
835
836 /* LINTED E_BAD_PTR_CAST_ALIGN */
837 switch (((wldp_t *)mp->b_rptr)->wldp_id) {
838 case WL_DISASSOCIATE:
839 wdev->swd_linkstatus = WL_NOTCONNECTED;
840 break;
841 default:
842 break;
843 }
844 return (rc);
845 }
846
847 static void
848 simnet_m_ioctl(void *arg, queue_t *q, mblk_t *mp)
849 {
850 simnet_dev_t *sdev = arg;
851 struct iocblk *iocp;
852 mblk_t *mp1;
853 uint32_t cmd;
854 int rc;
855
856 if (sdev->sd_type != DL_WIFI) {
857 miocnak(q, mp, 0, ENOTSUP);
858 return;
859 }
860
861 /* LINTED E_BAD_PTR_CAST_ALIGN */
862 iocp = (struct iocblk *)mp->b_rptr;
863 if (iocp->ioc_count == 0) {
864 miocnak(q, mp, 0, EINVAL);
865 return;
866 }
867
868 /* We only claim support for WiFi operation commands */
869 cmd = iocp->ioc_cmd;
870 switch (cmd) {
871 default:
872 miocnak(q, mp, 0, EINVAL);
873 return;
874 case WLAN_GET_PARAM:
875 case WLAN_SET_PARAM:
876 case WLAN_COMMAND:
877 break;
878 }
879
880 mp1 = mp->b_cont;
881 freemsg(mp1->b_cont);
882 mp1->b_cont = NULL;
883 /* overwrite everything */
884 mp1->b_wptr = mp1->b_rptr;
885 rc = simnet_wifi_ioctl(sdev, mp1);
886 miocack(q, mp, msgdsize(mp1), rc);
887 }
888
889 static int
890 simnet_m_stat(void *arg, uint_t stat, uint64_t *val)
891 {
892 int rval = 0;
893 simnet_dev_t *sdev = arg;
894
895 ASSERT(sdev->sd_mh != NULL);
896
897 switch (stat) {
898 case MAC_STAT_IFSPEED:
899 *val = 100 * 1000000ull; /* 100 Mbps */
900 break;
901 case MAC_STAT_LINK_STATE:
902 *val = LINK_DUPLEX_FULL;
903 break;
904 case MAC_STAT_LINK_UP:
905 if (sdev->sd_flags & SDF_STARTED)
906 *val = LINK_STATE_UP;
907 else
908 *val = LINK_STATE_DOWN;
909 break;
910 case MAC_STAT_PROMISC:
911 case MAC_STAT_MULTIRCV:
912 case MAC_STAT_MULTIXMT:
913 case MAC_STAT_BRDCSTRCV:
914 case MAC_STAT_BRDCSTXMT:
915 rval = ENOTSUP;
916 break;
917 case MAC_STAT_OPACKETS:
918 *val = sdev->sd_stats.xmit_count;
919 break;
920 case MAC_STAT_OBYTES:
921 *val = sdev->sd_stats.obytes;
922 break;
923 case MAC_STAT_IERRORS:
924 *val = sdev->sd_stats.recv_errors;
925 break;
926 case MAC_STAT_OERRORS:
927 *val = sdev->sd_stats.xmit_errors;
928 break;
929 case MAC_STAT_RBYTES:
930 *val = sdev->sd_stats.rbytes;
931 break;
932 case MAC_STAT_IPACKETS:
933 *val = sdev->sd_stats.recv_count;
934 break;
935 case WIFI_STAT_FCS_ERRORS:
936 case WIFI_STAT_WEP_ERRORS:
937 case WIFI_STAT_TX_FRAGS:
938 case WIFI_STAT_MCAST_TX:
939 case WIFI_STAT_RTS_SUCCESS:
940 case WIFI_STAT_RTS_FAILURE:
941 case WIFI_STAT_ACK_FAILURE:
942 case WIFI_STAT_RX_FRAGS:
943 case WIFI_STAT_MCAST_RX:
944 case WIFI_STAT_RX_DUPS:
945 rval = ENOTSUP;
946 break;
947 default:
948 rval = ENOTSUP;
949 break;
950 }
951
952 return (rval);
953 }
954
955 static int
956 simnet_m_start(void *arg)
957 {
958 simnet_dev_t *sdev = arg;
959
960 sdev->sd_flags |= SDF_STARTED;
961 return (0);
962 }
963
964 static void
965 simnet_m_stop(void *arg)
966 {
967 simnet_dev_t *sdev = arg;
968
969 sdev->sd_flags &= ~SDF_STARTED;
970 }
971
972 static int
973 simnet_m_promisc(void *arg, boolean_t on)
974 {
975 simnet_dev_t *sdev = arg;
976
977 sdev->sd_promisc = on;
978 return (0);
979 }
980
981 /*
982 * Returns matching multicast address enabled on the simnet instance.
983 * Assumes simnet instance mutex lock is held.
984 */
985 static uint8_t *
986 mcastaddr_lookup(simnet_dev_t *sdev, const uint8_t *addrp)
987 {
988 int idx;
989 uint8_t *maddrptr;
990
991 ASSERT(MUTEX_HELD(&sdev->sd_instlock));
992 maddrptr = sdev->sd_mcastaddrs;
993 for (idx = 0; idx < sdev->sd_mcastaddr_count; idx++) {
994 if (bcmp(maddrptr, addrp, ETHERADDRL) == 0)
995 return (maddrptr);
996 maddrptr += ETHERADDRL;
997 }
998
999 return (NULL);
1000 }
1001
1002 /* Add or remove Multicast addresses on simnet instance */
1003 static int
1004 simnet_m_multicst(void *arg, boolean_t add, const uint8_t *addrp)
1005 {
1006 simnet_dev_t *sdev = arg;
1007 uint8_t *maddrptr;
1008 uint8_t *newbuf;
1009 size_t prevsize;
1010 size_t newsize;
1011 ptrdiff_t len;
1012 ptrdiff_t len2;
1013
1014 alloc_retry:
1015 prevsize = sdev->sd_mcastaddr_count * ETHERADDRL;
1016 newsize = prevsize + (add ? ETHERADDRL:-ETHERADDRL);
1017 newbuf = kmem_alloc(newsize, KM_SLEEP);
1018
1019 mutex_enter(&sdev->sd_instlock);
1020 if (prevsize != (sdev->sd_mcastaddr_count * ETHERADDRL)) {
1021 mutex_exit(&sdev->sd_instlock);
1022 kmem_free(newbuf, newsize);
1023 goto alloc_retry;
1024 }
1025
1026 maddrptr = mcastaddr_lookup(sdev, addrp);
1027 if (!add && maddrptr != NULL) {
1028 /* Removing a Multicast address */
1029 if (newbuf != NULL) {
1030 /* LINTED: E_PTRDIFF_OVERFLOW */
1031 len = maddrptr - sdev->sd_mcastaddrs;
1032 (void) memcpy(newbuf, sdev->sd_mcastaddrs, len);
1033 len2 = prevsize - len - ETHERADDRL;
1034 (void) memcpy(newbuf + len,
1035 maddrptr + ETHERADDRL, len2);
1036 }
1037 sdev->sd_mcastaddr_count--;
1038 } else if (add && maddrptr == NULL) {
1039 /* Adding a new Multicast address */
1040 (void) memcpy(newbuf, sdev->sd_mcastaddrs, prevsize);
1041 (void) memcpy(newbuf + prevsize, addrp, ETHERADDRL);
1042 sdev->sd_mcastaddr_count++;
1043 } else {
1044 /* Error: removing a non-existing Multicast address */
1045 mutex_exit(&sdev->sd_instlock);
1046 kmem_free(newbuf, newsize);
1047 cmn_err(CE_WARN, "simnet: MAC call to remove a "
1048 "Multicast address failed");
1049 return (EINVAL);
1050 }
1051
1052 kmem_free(sdev->sd_mcastaddrs, prevsize);
1053 sdev->sd_mcastaddrs = newbuf;
1054 mutex_exit(&sdev->sd_instlock);
1055 return (0);
1056 }
1057
1058 static int
1059 simnet_m_unicst(void *arg, const uint8_t *macaddr)
1060 {
1061 simnet_dev_t *sdev = arg;
1062
1063 (void) memcpy(sdev->sd_mac_addr, macaddr, ETHERADDRL);
1064 return (0);
1065 }
1066
1067 /* Parse WiFi scan list entry arguments and return the arg count */
1068 static int
1069 parse_esslist_args(const void *pr_val, uint_t pr_valsize,
1070 char args[][MAX_ESSLIST_ARGLEN])
1071 {
1072 char *sep;
1073 ptrdiff_t len = pr_valsize;
1074 const char *piece = pr_val;
1075 const char *end = (const char *)pr_val + pr_valsize - 1;
1076 int arg = 0;
1077
1078 while (piece < end && (arg < MAX_ESSLIST_ARGS)) {
1079 sep = strchr(piece, ',');
1080 if (sep == NULL)
1081 sep = (char *)end;
1082 /* LINTED E_PTRDIFF_OVERFLOW */
1083 len = sep - piece;
1084 /* If first arg is zero then return none to delete all */
1085 if (arg == 0 && strnlen(piece, len) == 1 && piece[0] == '0')
1086 return (0);
1087 if (len > MAX_ESSLIST_ARGLEN)
1088 len = MAX_ESSLIST_ARGLEN - 1;
1089 (void) memcpy(&args[arg][0], piece, len);
1090 args[arg][len] = '\0';
1091 piece = sep + 1;
1092 arg++;
1093 }
1094
1095 return (arg);
1096 }
1097
1098 /* Set WiFi scan list entry from private property _wl_esslist */
1099 static int
1100 set_wl_esslist_priv_prop(simnet_wifidev_t *wdev, uint_t pr_valsize,
1101 const void *pr_val)
1102 {
1103 char essargs[MAX_ESSLIST_ARGS][MAX_ESSLIST_ARGLEN];
1104 wl_ess_conf_t *wls;
1105 long result;
1106 int i;
1107
1108 bzero(essargs, sizeof (essargs));
1109 if (parse_esslist_args(pr_val, pr_valsize, essargs) == 0) {
1110 for (i = 0; i < wdev->swd_esslist_num; i++) {
1111 kmem_free(wdev->swd_esslist[i], sizeof (wl_ess_conf_t));
1112 wdev->swd_esslist[i] = NULL;
1113 }
1114 wdev->swd_esslist_num = 0;
1115 return (0);
1116 }
1117
1118 for (i = 0; i < wdev->swd_esslist_num; i++) {
1119 wls = wdev->swd_esslist[i];
1120 if (strcasecmp(wls->wl_ess_conf_essid.wl_essid_essid,
1121 essargs[0]) == 0)
1122 return (EEXIST);
1123 }
1124
1125 if (wdev->swd_esslist_num >= MAX_SIMNET_ESSCONF)
1126 return (EINVAL);
1127
1128 wls = kmem_zalloc(sizeof (wl_ess_conf_t), KM_SLEEP);
1129 (void) strlcpy(wls->wl_ess_conf_essid.wl_essid_essid,
1130 essargs[0], sizeof (wls->wl_ess_conf_essid.wl_essid_essid));
1131 wls->wl_ess_conf_essid.wl_essid_length =
1132 strlen(wls->wl_ess_conf_essid.wl_essid_essid);
1133 (void) random_get_pseudo_bytes((uint8_t *)
1134 &wls->wl_ess_conf_bssid, sizeof (wl_bssid_t));
1135 (void) ddi_strtol(essargs[1], (char **)NULL, 0, &result);
1136 wls->wl_ess_conf_sl = (wl_rssi_t)
1137 ((result > MAX_RSSI || result < 0) ? 0:result);
1138 wdev->swd_esslist[wdev->swd_esslist_num] = wls;
1139 wdev->swd_esslist_num++;
1140
1141 return (0);
1142 }
1143
1144 static int
1145 simnet_set_priv_prop(simnet_dev_t *sdev, const char *pr_name,
1146 uint_t pr_valsize, const void *pr_val)
1147 {
1148 simnet_wifidev_t *wdev = sdev->sd_wifidev;
1149 long result;
1150
1151 if (strcmp(pr_name, "_wl_esslist") == 0) {
1152 if (pr_val == NULL)
1153 return (EINVAL);
1154 return (set_wl_esslist_priv_prop(wdev, pr_valsize, pr_val));
1155 } else if (strcmp(pr_name, "_wl_connected") == 0) {
1156 if (pr_val == NULL)
1157 return (EINVAL);
1158 (void) ddi_strtol(pr_val, (char **)NULL, 0, &result);
1159 wdev->swd_linkstatus = ((result == 1) ?
1160 WL_CONNECTED:WL_NOTCONNECTED);
1161 return (0);
1162 }
1163
1164 return (EINVAL);
1165 }
1166
1167 static int
1168 simnet_m_setprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
1169 uint_t wldp_length, const void *wldp_buf)
1170 {
1171 simnet_dev_t *sdev = arg;
1172 simnet_wifidev_t *wdev = sdev->sd_wifidev;
1173 int err = 0;
1174 uint32_t mtu;
1175
1176 switch (wldp_pr_num) {
1177 case MAC_PROP_MTU:
1178 (void) memcpy(&mtu, wldp_buf, sizeof (mtu));
1179 if (mtu > ETHERMIN && mtu < SIMNET_MAX_MTU)
1180 return (mac_maxsdu_update(sdev->sd_mh, mtu));
1181 else
1182 return (EINVAL);
1183 default:
1184 break;
1185 }
1186
1187 if (sdev->sd_type == DL_ETHER)
1188 return (ENOTSUP);
1189
1190 /* mac_prop_id */
1191 switch (wldp_pr_num) {
1192 case MAC_PROP_WL_ESSID: {
1193 int i;
1194 wl_ess_conf_t *wls;
1195
1196 (void) memcpy(&wdev->swd_essid, wldp_buf,
1197 sizeof (wl_essid_t));
1198 wdev->swd_linkstatus = WL_CONNECTED;
1199
1200 /* Lookup the signal strength of the connected ESSID */
1201 for (i = 0; i < wdev->swd_esslist_num; i++) {
1202 wls = wdev->swd_esslist[i];
1203 if (strcasecmp(wls->wl_ess_conf_essid.wl_essid_essid,
1204 wdev->swd_essid.wl_essid_essid) == 0) {
1205 wdev->swd_rssi = wls->wl_ess_conf_sl;
1206 break;
1207 }
1208 }
1209 break;
1210 }
1211 case MAC_PROP_WL_BSSID: {
1212 (void) memcpy(&wdev->swd_bssid, wldp_buf,
1213 sizeof (wl_bssid_t));
1214 break;
1215 }
1216 case MAC_PROP_WL_PHY_CONFIG:
1217 case MAC_PROP_WL_KEY_TAB:
1218 case MAC_PROP_WL_AUTH_MODE:
1219 case MAC_PROP_WL_ENCRYPTION:
1220 case MAC_PROP_WL_BSSTYPE:
1221 case MAC_PROP_WL_DESIRED_RATES:
1222 break;
1223 case MAC_PROP_PRIVATE:
1224 err = simnet_set_priv_prop(sdev, pr_name,
1225 wldp_length, wldp_buf);
1226 break;
1227 default:
1228 break;
1229 }
1230
1231 return (err);
1232 }
1233
1234 static int
1235 simnet_get_priv_prop(simnet_dev_t *sdev, const char *pr_name,
1236 uint_t pr_valsize, void *pr_val)
1237 {
1238 simnet_wifidev_t *wdev = sdev->sd_wifidev;
1239 int err = 0;
1240 int value;
1241
1242 if (strcmp(pr_name, "_wl_esslist") == 0) {
1243 /* Returns num of _wl_ess_conf_t that have been set */
1244 value = wdev->swd_esslist_num;
1245 } else if (strcmp(pr_name, "_wl_connected") == 0) {
1246 value = ((wdev->swd_linkstatus == WL_CONNECTED) ? 1:0);
1247 } else {
1248 err = ENOTSUP;
1249 }
1250
1251 if (err == 0)
1252 (void) snprintf(pr_val, pr_valsize, "%d", value);
1253 return (err);
1254 }
1255
1256 static int
1257 simnet_m_getprop(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
1258 uint_t wldp_length, void *wldp_buf)
1259 {
1260 simnet_dev_t *sdev = arg;
1261 simnet_wifidev_t *wdev = sdev->sd_wifidev;
1262 int err = 0;
1263 int i;
1264
1265 if (sdev->sd_type == DL_ETHER)
1266 return (ENOTSUP);
1267
1268 /* mac_prop_id */
1269 switch (wldp_pr_num) {
1270 case MAC_PROP_WL_ESSID:
1271 (void) memcpy(wldp_buf, &wdev->swd_essid,
1272 sizeof (wl_essid_t));
1273 break;
1274 case MAC_PROP_WL_BSSID:
1275 (void) memcpy(wldp_buf, &wdev->swd_bssid,
1276 sizeof (wl_bssid_t));
1277 break;
1278 case MAC_PROP_WL_PHY_CONFIG:
1279 case MAC_PROP_WL_AUTH_MODE:
1280 case MAC_PROP_WL_ENCRYPTION:
1281 break;
1282 case MAC_PROP_WL_LINKSTATUS:
1283 (void) memcpy(wldp_buf, &wdev->swd_linkstatus,
1284 sizeof (wdev->swd_linkstatus));
1285 break;
1286 case MAC_PROP_WL_ESS_LIST: {
1287 wl_ess_conf_t *w_ess_conf;
1288
1289 ((wl_ess_list_t *)wldp_buf)->wl_ess_list_num =
1290 wdev->swd_esslist_num;
1291 /* LINTED E_BAD_PTR_CAST_ALIGN */
1292 w_ess_conf = (wl_ess_conf_t *)((char *)wldp_buf +
1293 offsetof(wl_ess_list_t, wl_ess_list_ess));
1294 for (i = 0; i < wdev->swd_esslist_num; i++) {
1295 (void) memcpy(w_ess_conf, wdev->swd_esslist[i],
1296 sizeof (wl_ess_conf_t));
1297 w_ess_conf++;
1298 }
1299 break;
1300 }
1301 case MAC_PROP_WL_RSSI:
1302 *(wl_rssi_t *)wldp_buf = wdev->swd_rssi;
1303 break;
1304 case MAC_PROP_WL_RADIO:
1305 *(wl_radio_t *)wldp_buf = B_TRUE;
1306 break;
1307 case MAC_PROP_WL_POWER_MODE:
1308 break;
1309 case MAC_PROP_WL_DESIRED_RATES:
1310 break;
1311 case MAC_PROP_PRIVATE:
1312 err = simnet_get_priv_prop(sdev, pr_name, wldp_length,
1313 wldp_buf);
1314 break;
1315 default:
1316 err = ENOTSUP;
1317 break;
1318 }
1319
1320 return (err);
1321 }
1322
1323 static void
1324 simnet_priv_propinfo(const char *pr_name, mac_prop_info_handle_t prh)
1325 {
1326 char valstr[MAXNAMELEN];
1327
1328 bzero(valstr, sizeof (valstr));
1329
1330 if (strcmp(pr_name, "_wl_esslist") == 0) {
1331 (void) snprintf(valstr, sizeof (valstr), "%d", 0);
1332 }
1333
1334 if (strlen(valstr) > 0)
1335 mac_prop_info_set_default_str(prh, valstr);
1336 }
1337
1338 static void
1339 simnet_m_propinfo(void *arg, const char *pr_name, mac_prop_id_t wldp_pr_num,
1340 mac_prop_info_handle_t prh)
1341 {
1342 simnet_dev_t *sdev = arg;
1343
1344 if (sdev->sd_type == DL_ETHER)
1345 return;
1346
1347 switch (wldp_pr_num) {
1348 case MAC_PROP_WL_BSSTYPE:
1349 case MAC_PROP_WL_ESS_LIST:
1350 case MAC_PROP_WL_SUPPORTED_RATES:
1351 case MAC_PROP_WL_RSSI:
1352 mac_prop_info_set_perm(prh, MAC_PROP_PERM_READ);
1353 break;
1354 case MAC_PROP_PRIVATE:
1355 simnet_priv_propinfo(pr_name, prh);
1356 break;
1357 }
1358 }