7127  remove -Wno-missing-braces from Makefile.uts

   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 }
--- EOF ---