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 /* 23 * Copyright 2010 Sun Microsystems, Inc. All rights reserved. 24 * Use is subject to license terms. 25 */ 26 27 #include <assert.h> 28 #include <ctype.h> 29 #include <sys/param.h> 30 #include <sys/types.h> 31 #include <sys/stat.h> 32 #include <stdio.h> 33 #include <stdlib.h> 34 #include <strings.h> 35 #include <unistd.h> 36 #include <libscf.h> 37 #include "libnwam_impl.h" 38 #include <libnwam_priv.h> 39 #include <libnwam.h> 40 41 /* 42 * Functions to support creating, modifying, destroying, querying the 43 * state of and changing the state of ENM (External Network Modifier) 44 * objects. ENMs represent services or scripts that can be enabled 45 * either manually or conditionally for a combination of the set of 46 * available conditions (an IP address is present, a location is active etc). 47 */ 48 49 typedef nwam_error_t (*nwam_enm_prop_validate_func_t)(nwam_value_t); 50 51 static nwam_error_t valid_enm_activation_mode(nwam_value_t); 52 53 struct nwam_prop_table_entry enm_prop_table_entries[] = { 54 {NWAM_ENM_PROP_ACTIVATION_MODE, NWAM_VALUE_TYPE_UINT64, B_FALSE, 1, 1, 55 valid_enm_activation_mode, 56 "specifies the ENM activation mode - valid values are:\n" 57 "\'manual\', \'conditional-any\' and \'conditional-all\'", 58 NWAM_TYPE_ANY, NWAM_CLASS_ANY}, 59 {NWAM_ENM_PROP_CONDITIONS, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 60 NWAM_MAX_NUM_VALUES, nwam_valid_condition, 61 "specifies the activation condition. Conditions are of the form:\n" 62 "ncp|ncu|enm|loc name is|is-not active\n" 63 "ip-address is|is-not|is-in-range|is-not-in-range| 1.2.3.4[/24]\n" 64 "advertised-domain is|is-not|contains|does-not-contain string\n" 65 "system-domain is|is-not|contains|does-not-contain string\n" 66 "essid is|is-not|contains|does-not-contain string\n" 67 "bssid is|is-not string", 68 NWAM_TYPE_ANY, NWAM_CLASS_ANY}, 69 {NWAM_ENM_PROP_ENABLED, NWAM_VALUE_TYPE_BOOLEAN, B_TRUE, 0, 1, 70 nwam_valid_boolean, 71 "specifies if manual ENM is to be enabled", 72 NWAM_TYPE_ANY, NWAM_CLASS_ANY}, 73 {NWAM_ENM_PROP_FMRI, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1, 74 nwam_valid_fmri, 75 "specifies SMF FMRI of service to be enabled on ENM activation", 76 NWAM_TYPE_ANY, NWAM_CLASS_ANY}, 77 {NWAM_ENM_PROP_START, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1, 78 nwam_valid_file, 79 "specifies absolute path to start script to be run on ENM " 80 "activation", 81 NWAM_TYPE_ANY, NWAM_CLASS_ANY}, 82 {NWAM_ENM_PROP_STOP, NWAM_VALUE_TYPE_STRING, B_FALSE, 0, 1, 83 nwam_valid_file, 84 "specifies absolute path to stop script to be run on ENM " 85 "deactivation", 86 NWAM_TYPE_ANY, NWAM_CLASS_ANY} 87 }; 88 89 #define NWAM_NUM_ENM_PROPS (sizeof (enm_prop_table_entries) / \ 90 sizeof (*enm_prop_table_entries)) 91 92 struct nwam_prop_table enm_prop_table = 93 { NWAM_NUM_ENM_PROPS, enm_prop_table_entries }; 94 95 static uint64_t 96 nwam_enm_activation_to_flag(nwam_activation_mode_t activation) 97 { 98 switch (activation) { 99 case NWAM_ACTIVATION_MODE_MANUAL: 100 return (NWAM_FLAG_ACTIVATION_MODE_MANUAL); 101 case NWAM_ACTIVATION_MODE_CONDITIONAL_ANY: 102 return (NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ANY); 103 case NWAM_ACTIVATION_MODE_CONDITIONAL_ALL: 104 return (NWAM_FLAG_ACTIVATION_MODE_CONDITIONAL_ALL); 105 default: 106 return (0); 107 } 108 } 109 110 nwam_error_t 111 nwam_enm_read(const char *name, uint64_t flags, nwam_enm_handle_t *enmhp) 112 { 113 return (nwam_read(NWAM_OBJECT_TYPE_ENM, NWAM_ENM_CONF_FILE, name, 114 flags, enmhp)); 115 } 116 117 nwam_error_t 118 nwam_enm_create(const char *name, const char *fmri, nwam_enm_handle_t *enmhp) 119 { 120 nwam_error_t err; 121 nwam_value_t actval = NULL, falseval = NULL, fmrival = NULL; 122 123 assert(enmhp != NULL && name != NULL); 124 125 if ((err = nwam_create(NWAM_OBJECT_TYPE_ENM, NWAM_ENM_CONF_FILE, name, 126 enmhp)) != NWAM_SUCCESS) 127 return (err); 128 129 /* 130 * Create new object list for ENM. The initial activation mode is set, 131 * and the FMRI property is set, if specified. 132 */ 133 if ((err = nwam_alloc_object_list(&((*enmhp)->nwh_data))) 134 != NWAM_SUCCESS) 135 goto finish; 136 137 if ((err = nwam_value_create_uint64(NWAM_ACTIVATION_MODE_MANUAL, 138 &actval)) != NWAM_SUCCESS || 139 ((fmri != NULL) && 140 (err = nwam_value_create_string((char *)fmri, &fmrival)) 141 != NWAM_SUCCESS) || 142 (err = nwam_value_create_boolean(B_FALSE, &falseval)) 143 != NWAM_SUCCESS) { 144 goto finish; 145 } 146 if ((err = nwam_set_prop_value((*enmhp)->nwh_data, 147 NWAM_ENM_PROP_ACTIVATION_MODE, actval)) == NWAM_SUCCESS && 148 (err = nwam_set_prop_value((*enmhp)->nwh_data, 149 NWAM_ENM_PROP_ENABLED, falseval)) == NWAM_SUCCESS) { 150 if (fmri != NULL) { 151 err = nwam_set_prop_value((*enmhp)->nwh_data, 152 NWAM_ENM_PROP_FMRI, fmrival); 153 } 154 } 155 156 finish: 157 nwam_value_free(actval); 158 nwam_value_free(falseval); 159 if (fmrival != NULL) 160 nwam_value_free(fmrival); 161 162 if (err != NWAM_SUCCESS) { 163 nwam_enm_free(*enmhp); 164 *enmhp = NULL; 165 } 166 167 return (err); 168 } 169 170 nwam_error_t 171 nwam_enm_get_name(nwam_enm_handle_t enmh, char **namep) 172 { 173 return (nwam_get_name(enmh, namep)); 174 } 175 176 nwam_error_t 177 nwam_enm_set_name(nwam_enm_handle_t enmh, const char *name) 178 { 179 return (nwam_set_name(enmh, name)); 180 } 181 182 boolean_t 183 nwam_enm_can_set_name(nwam_enm_handle_t enmh) 184 { 185 return (!enmh->nwh_committed); 186 } 187 188 /* ARGSUSED2 */ 189 static int 190 enm_selectcb(struct nwam_handle *hp, uint64_t flags, void *data) 191 { 192 nwam_enm_handle_t enmh = hp; 193 uint64_t activation, actflag, walkfilter; 194 nwam_value_t actval; 195 196 /* 197 * Get a bitmapped flag value corresponding to this enm's 198 * activation value - if the activation value is not recognized, 199 * actflag will be set to 0, and will thus fail to match 200 * any bit flag passed in by the caller. 201 */ 202 if (nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_ACTIVATION_MODE, 203 &actval) != NWAM_SUCCESS) { 204 return (NWAM_INVALID_ARG); 205 } 206 if (nwam_value_get_uint64(actval, &activation) != NWAM_SUCCESS) { 207 nwam_value_free(actval); 208 return (NWAM_INVALID_ARG); 209 } 210 211 actflag = nwam_enm_activation_to_flag(activation); 212 nwam_value_free(actval); 213 if ((walkfilter = flags & NWAM_WALK_FILTER_MASK) == 0) 214 walkfilter = NWAM_FLAG_ACTIVATION_MODE_ALL; 215 if (actflag & walkfilter) 216 return (NWAM_SUCCESS); 217 return (NWAM_INVALID_ARG); 218 } 219 220 nwam_error_t 221 nwam_walk_enms(int(*cb)(nwam_enm_handle_t, void *), void *data, uint64_t flags, 222 int *retp) 223 { 224 nwam_error_t err = nwam_valid_flags(flags, 225 NWAM_FLAG_ACTIVATION_MODE_ALL | NWAM_FLAG_BLOCKING); 226 227 if (err != NWAM_SUCCESS) 228 return (err); 229 230 return (nwam_walk(NWAM_OBJECT_TYPE_ENM, NWAM_ENM_CONF_FILE, 231 cb, data, flags, retp, enm_selectcb)); 232 } 233 234 void 235 nwam_enm_free(nwam_enm_handle_t enmh) 236 { 237 nwam_free(enmh); 238 } 239 240 nwam_error_t 241 nwam_enm_copy(nwam_enm_handle_t oldenmh, const char *newname, 242 nwam_enm_handle_t *newenmhp) 243 { 244 return (nwam_copy(NWAM_ENM_CONF_FILE, oldenmh, newname, newenmhp)); 245 } 246 247 nwam_error_t 248 nwam_enm_delete_prop(nwam_enm_handle_t enmh, const char *propname) 249 { 250 nwam_error_t err; 251 boolean_t ro; 252 void *olddata; 253 boolean_t manual; 254 255 assert(enmh != NULL && propname != NULL); 256 257 if ((err = nwam_enm_prop_read_only(propname, &ro)) != NWAM_SUCCESS) 258 return (err); 259 if (ro) { 260 /* 261 * If the activation-mode is not manual, allow the enabled 262 * property to be deleted. 263 */ 264 if (strcmp(propname, NWAM_ENM_PROP_ENABLED) != 0) 265 return (NWAM_ENTITY_READ_ONLY); 266 267 if ((err = nwam_enm_is_manual(enmh, &manual)) != NWAM_SUCCESS) 268 return (err); 269 if (manual) 270 return (NWAM_ENTITY_READ_ONLY); 271 } 272 273 /* 274 * Duplicate data, remove property and validate. If validation 275 * fails, revert to data duplicated prior to remove. 276 */ 277 if ((err = nwam_dup_object_list(enmh->nwh_data, &olddata)) 278 != NWAM_SUCCESS) 279 return (err); 280 if ((err = nwam_delete_prop(enmh->nwh_data, propname)) 281 != NWAM_SUCCESS) { 282 nwam_free_object_list(enmh->nwh_data); 283 enmh->nwh_data = olddata; 284 return (err); 285 } 286 if ((err = nwam_enm_validate(enmh, NULL)) != NWAM_SUCCESS) { 287 nwam_free_object_list(enmh->nwh_data); 288 enmh->nwh_data = olddata; 289 return (err); 290 } 291 nwam_free_object_list(olddata); 292 293 return (NWAM_SUCCESS); 294 } 295 296 nwam_error_t 297 nwam_enm_set_prop_value(nwam_enm_handle_t enmh, const char *propname, 298 nwam_value_t value) 299 { 300 nwam_error_t err; 301 boolean_t ro; 302 303 assert(enmh != NULL && propname != NULL && value != NULL); 304 305 if ((err = nwam_enm_validate_prop(enmh, propname, value)) 306 != NWAM_SUCCESS || 307 (err = nwam_enm_prop_read_only(propname, &ro)) != NWAM_SUCCESS) 308 return (err); 309 if (ro) 310 return (NWAM_ENTITY_READ_ONLY); 311 312 return (nwam_set_prop_value(enmh->nwh_data, propname, value)); 313 } 314 315 nwam_error_t 316 nwam_enm_get_prop_value(nwam_enm_handle_t enmh, const char *propname, 317 nwam_value_t *valuep) 318 { 319 return (nwam_get_prop_value(enmh->nwh_data, propname, valuep)); 320 } 321 322 nwam_error_t 323 nwam_enm_walk_props(nwam_enm_handle_t enmh, 324 int (*cb)(const char *, nwam_value_t, void *), 325 void *data, uint64_t flags, int *retp) 326 { 327 return (nwam_walk_props(enmh, cb, data, flags, retp)); 328 } 329 330 nwam_error_t 331 nwam_enm_commit(nwam_enm_handle_t enmh, uint64_t flags) 332 { 333 nwam_error_t err; 334 335 assert(enmh != NULL && enmh->nwh_data != NULL); 336 337 if ((err = nwam_enm_validate(enmh, NULL)) != NWAM_SUCCESS) 338 return (err); 339 340 return (nwam_commit(NWAM_ENM_CONF_FILE, enmh, flags)); 341 } 342 343 nwam_error_t 344 nwam_enm_destroy(nwam_enm_handle_t enmh, uint64_t flags) 345 { 346 return (nwam_destroy(NWAM_ENM_CONF_FILE, enmh, flags)); 347 } 348 349 nwam_error_t 350 nwam_enm_get_prop_description(const char *propname, const char **descriptionp) 351 { 352 return (nwam_get_prop_description(enm_prop_table, propname, 353 descriptionp)); 354 } 355 356 nwam_error_t 357 nwam_enm_prop_read_only(const char *propname, boolean_t *readp) 358 { 359 return (nwam_prop_read_only(enm_prop_table, propname, readp)); 360 } 361 362 /* Property-specific value validation functions follow */ 363 364 static nwam_error_t 365 valid_enm_activation_mode(nwam_value_t value) 366 { 367 uint64_t activation_mode; 368 369 if (nwam_value_get_uint64(value, &activation_mode) != NWAM_SUCCESS) 370 return (NWAM_ENTITY_INVALID_VALUE); 371 372 switch (activation_mode) { 373 case NWAM_ACTIVATION_MODE_MANUAL: 374 case NWAM_ACTIVATION_MODE_CONDITIONAL_ANY: 375 case NWAM_ACTIVATION_MODE_CONDITIONAL_ALL: 376 return (NWAM_SUCCESS); 377 } 378 return (NWAM_ENTITY_INVALID_VALUE); 379 } 380 381 nwam_error_t 382 nwam_enm_validate(nwam_enm_handle_t enmh, const char **errpropp) 383 { 384 uint64_t activation; 385 nwam_value_t activationval, enabledval, fmrival = NULL, startval = NULL; 386 nwam_value_t conditionval = NULL; 387 char **conditions, *name; 388 uint_t i, numvalues; 389 nwam_condition_object_type_t object_type; 390 nwam_condition_t condition; 391 392 assert(enmh != NULL); 393 394 /* 395 * Make sure enm is internally consistent: must have either 396 * an fmri or a start string; and if activation type is conditional, 397 * the condition string must be specified. 398 */ 399 if ((nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_FMRI, &fmrival) 400 != NWAM_SUCCESS) && 401 (nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_START, &startval) 402 != NWAM_SUCCESS)) { 403 if (fmrival != NULL) { 404 if (errpropp != NULL) 405 *errpropp = NWAM_ENM_PROP_START; 406 nwam_value_free(fmrival); 407 } else { 408 if (errpropp != NULL) 409 *errpropp = NWAM_ENM_PROP_FMRI; 410 } 411 return (NWAM_ENTITY_MISSING_MEMBER); 412 } 413 if (fmrival != NULL) 414 nwam_value_free(fmrival); 415 if (startval != NULL) 416 nwam_value_free(startval); 417 418 if (nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_ACTIVATION_MODE, 419 &activationval) != NWAM_SUCCESS) { 420 if (errpropp != NULL) 421 *errpropp = NWAM_ENM_PROP_ACTIVATION_MODE; 422 return (NWAM_ENTITY_MISSING_MEMBER); 423 } 424 if (nwam_value_get_uint64(activationval, &activation) 425 != NWAM_SUCCESS) { 426 if (errpropp != NULL) 427 *errpropp = NWAM_ENM_PROP_ACTIVATION_MODE; 428 return (NWAM_ENTITY_INVALID_VALUE); 429 } 430 nwam_value_free(activationval); 431 432 if (activation == NWAM_ACTIVATION_MODE_CONDITIONAL_ANY || 433 activation == NWAM_ACTIVATION_MODE_CONDITIONAL_ALL) { 434 if (nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_CONDITIONS, 435 &conditionval) != NWAM_SUCCESS) { 436 if (errpropp != NULL) 437 *errpropp = NWAM_ENM_PROP_CONDITIONS; 438 return (NWAM_ENTITY_MISSING_MEMBER); 439 } 440 /* 441 * Are conditions self-referential? In other words, do any 442 * of the activation conditions refer to this ENM? 443 */ 444 if (nwam_value_get_string_array(conditionval, &conditions, 445 &numvalues) != NWAM_SUCCESS) { 446 nwam_value_free(conditionval); 447 if (errpropp != NULL) 448 *errpropp = NWAM_ENM_PROP_CONDITIONS; 449 return (NWAM_ENTITY_INVALID_VALUE); 450 } 451 if (nwam_enm_get_name(enmh, &name) != NWAM_SUCCESS) { 452 nwam_value_free(conditionval); 453 return (NWAM_INVALID_ARG); 454 } 455 for (i = 0; i < numvalues; i++) { 456 char *object_name = NULL; 457 458 if (nwam_condition_string_to_condition(conditions[i], 459 &object_type, &condition, &object_name) 460 != NWAM_SUCCESS) { 461 if (errpropp != NULL) 462 *errpropp = NWAM_ENM_PROP_CONDITIONS; 463 free(name); 464 nwam_value_free(conditionval); 465 return (NWAM_ENTITY_INVALID_VALUE); 466 } 467 if (object_name != NULL && 468 object_type == NWAM_CONDITION_OBJECT_TYPE_ENM && 469 strcmp(object_name, name) == 0) { 470 if (errpropp != NULL) 471 *errpropp = NWAM_ENM_PROP_CONDITIONS; 472 free(name); 473 free(object_name); 474 nwam_value_free(conditionval); 475 return (NWAM_ENTITY_INVALID_VALUE); 476 } 477 free(object_name); 478 } 479 free(name); 480 nwam_value_free(conditionval); 481 } 482 483 if (activation == NWAM_ACTIVATION_MODE_MANUAL) { 484 if (nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_ENABLED, 485 &enabledval) != NWAM_SUCCESS) { 486 if (errpropp != NULL) 487 *errpropp = NWAM_ENM_PROP_ENABLED; 488 return (NWAM_ENTITY_MISSING_MEMBER); 489 } 490 nwam_value_free(enabledval); 491 } 492 493 return (nwam_validate(enm_prop_table, enmh, errpropp)); 494 } 495 496 nwam_error_t 497 nwam_enm_validate_prop(nwam_enm_handle_t enmh, const char *propname, 498 nwam_value_t value) 499 { 500 assert(enmh != NULL); 501 502 return (nwam_validate_prop(enm_prop_table, enmh, propname, value)); 503 } 504 505 /* 506 * Given a property, return expected property data type 507 */ 508 nwam_error_t 509 nwam_enm_get_prop_type(const char *propname, nwam_value_type_t *typep) 510 { 511 return (nwam_get_prop_type(enm_prop_table, propname, typep)); 512 } 513 514 nwam_error_t 515 nwam_enm_prop_multivalued(const char *propname, boolean_t *multip) 516 { 517 return (nwam_prop_multivalued(enm_prop_table, propname, multip)); 518 } 519 520 /* 521 * Determine if the ENM has manual activation-mode or not. 522 */ 523 nwam_error_t 524 nwam_enm_is_manual(nwam_enm_handle_t enmh, boolean_t *manualp) 525 { 526 nwam_error_t err; 527 nwam_value_t actval; 528 uint64_t activation; 529 530 assert(enmh != NULL); 531 532 if ((err = nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_ACTIVATION_MODE, 533 &actval)) != NWAM_SUCCESS) 534 return (err); 535 err = nwam_value_get_uint64(actval, &activation); 536 nwam_value_free(actval); 537 if (err != NWAM_SUCCESS) 538 return (err); 539 540 if (activation == NWAM_ACTIVATION_MODE_MANUAL) 541 *manualp = B_TRUE; 542 else 543 *manualp = B_FALSE; 544 return (NWAM_SUCCESS); 545 } 546 547 /* Determine if ENM is enabled or not */ 548 static nwam_error_t 549 nwam_enm_is_enabled(nwam_enm_handle_t enmh, boolean_t *enabledp) 550 { 551 nwam_error_t err; 552 nwam_value_t enabledval; 553 554 assert(enmh != NULL); 555 556 if ((err = nwam_enm_get_prop_value(enmh, NWAM_ENM_PROP_ENABLED, 557 &enabledval)) != NWAM_SUCCESS) 558 return (err); 559 err = nwam_value_get_boolean(enabledval, enabledp); 560 nwam_value_free(enabledval); 561 return (err); 562 } 563 564 /* Update the enabled property */ 565 static nwam_error_t 566 nwam_enm_update_enabled(nwam_enm_handle_t enmh, boolean_t enabled) 567 { 568 nwam_error_t err; 569 nwam_value_t enabledval; 570 571 if ((err = nwam_value_create_boolean(enabled, &enabledval)) 572 != NWAM_SUCCESS) 573 return (err); 574 err = nwam_set_prop_value(enmh->nwh_data, NWAM_ENM_PROP_ENABLED, 575 enabledval); 576 nwam_value_free(enabledval); 577 if (err != NWAM_SUCCESS) 578 return (err); 579 return (nwam_enm_commit(enmh, NWAM_FLAG_ENTITY_ENABLE)); 580 } 581 582 nwam_error_t 583 nwam_enm_enable(nwam_enm_handle_t enmh) 584 { 585 nwam_error_t err; 586 boolean_t manual, enabled; 587 588 assert(enmh != NULL); 589 590 /* Only enms with manual activation-mode can be enabled */ 591 if ((err = nwam_enm_is_manual(enmh, &manual)) != NWAM_SUCCESS) 592 return (err); 593 if (!manual) 594 return (NWAM_ENTITY_NOT_MANUAL); 595 596 /* Make sure ENM is not enabled */ 597 if ((err = nwam_enm_is_enabled(enmh, &enabled)) != NWAM_SUCCESS) 598 return (err); 599 if (enabled) 600 return (NWAM_SUCCESS); 601 602 if ((err = nwam_enm_update_enabled(enmh, B_TRUE)) != NWAM_SUCCESS) 603 return (err); 604 605 err = nwam_enable(NULL, enmh); 606 607 /* nwamd may not be running, that's okay. */ 608 if (err == NWAM_ERROR_BIND) 609 return (NWAM_SUCCESS); 610 else 611 return (err); 612 } 613 614 nwam_error_t 615 nwam_enm_disable(nwam_enm_handle_t enmh) 616 { 617 nwam_error_t err; 618 boolean_t manual, enabled; 619 620 assert(enmh != NULL); 621 622 /* Only enms with manual activation-mode can be disabled */ 623 if ((err = nwam_enm_is_manual(enmh, &manual)) != NWAM_SUCCESS) 624 return (err); 625 if (!manual) 626 return (NWAM_ENTITY_NOT_MANUAL); 627 628 /* Make sure ENM is enabled */ 629 if ((err = nwam_enm_is_enabled(enmh, &enabled)) != NWAM_SUCCESS) 630 return (err); 631 if (!enabled) 632 return (NWAM_SUCCESS); 633 634 if ((err = nwam_enm_update_enabled(enmh, B_FALSE)) != NWAM_SUCCESS) 635 return (err); 636 637 err = nwam_disable(NULL, enmh); 638 639 /* nwamd may not be running, that's okay. */ 640 if (err == NWAM_ERROR_BIND) 641 return (NWAM_SUCCESS); 642 else 643 return (err); 644 } 645 646 nwam_error_t 647 nwam_enm_get_default_proplist(const char ***prop_list, uint_t *numvaluesp) 648 { 649 return (nwam_get_default_proplist(enm_prop_table, 650 NWAM_TYPE_ANY, NWAM_CLASS_ANY, prop_list, numvaluesp)); 651 } 652 653 nwam_error_t 654 nwam_enm_get_state(nwam_enm_handle_t enmh, nwam_state_t *statep, 655 nwam_aux_state_t *auxp) 656 { 657 return (nwam_get_state(NULL, enmh, statep, auxp)); 658 } 659