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 (c) 2010, Oracle and/or its affiliates. All rights reserved. 24 */ 25 26 #include <arpa/inet.h> 27 #include <errno.h> 28 #include <inet/ip.h> 29 #include <libdladm.h> 30 #include <libdllink.h> 31 #include <libdlwlan.h> 32 #include <libscf.h> 33 #include <limits.h> 34 #include <netdb.h> 35 #include <netinet/in.h> 36 #include <stdio.h> 37 #include <stdlib.h> 38 #include <string.h> 39 #include <sys/socket.h> 40 #include <sys/types.h> 41 42 #include <libnwam.h> 43 #include "conditions.h" 44 #include "events.h" 45 #include "objects.h" 46 #include "util.h" 47 48 /* 49 * loc.c - contains routines which handle location abstraction. 50 */ 51 52 pthread_mutex_t active_loc_mutex = PTHREAD_MUTEX_INITIALIZER; 53 char active_loc[NWAM_MAX_NAME_LEN]; 54 55 static int 56 loc_create_init_fini_event(nwam_loc_handle_t loch, void *data) 57 { 58 boolean_t *init = data; 59 char *name; 60 nwamd_event_t event; 61 62 if (nwam_loc_get_name(loch, &name) != NWAM_SUCCESS) { 63 nlog(LOG_ERR, "loc_init_fini: could not get loc name"); 64 return (0); 65 } 66 67 event = nwamd_event_init(*init ? 68 NWAM_EVENT_TYPE_OBJECT_INIT : NWAM_EVENT_TYPE_OBJECT_FINI, 69 NWAM_OBJECT_TYPE_LOC, 0, name); 70 if (event != NULL) 71 nwamd_event_enqueue(event); 72 free(name); 73 74 return (0); 75 } 76 77 /* 78 * Walk all locs, creating init events for each. 79 */ 80 void 81 nwamd_init_locs(void) 82 { 83 boolean_t init = B_TRUE; 84 85 /* Unset active location */ 86 (void) pthread_mutex_lock(&active_loc_mutex); 87 active_loc[0] = '\0'; 88 (void) pthread_mutex_unlock(&active_loc_mutex); 89 (void) nwam_walk_locs(loc_create_init_fini_event, &init, 0, NULL); 90 } 91 92 /* 93 * Walk all locs, creating fini events for each. 94 */ 95 void 96 nwamd_fini_locs(void) 97 { 98 boolean_t init = B_FALSE; 99 100 (void) nwam_walk_locs(loc_create_init_fini_event, &init, 0, NULL); 101 } 102 103 static boolean_t 104 loc_is_enabled(nwam_loc_handle_t loch) 105 { 106 nwam_value_t enabledval; 107 boolean_t enabled = B_FALSE; 108 109 if (nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ENABLED, 110 &enabledval) != NWAM_SUCCESS) { 111 nlog(LOG_ERR, "loc_is_enabled: could not retrieve " 112 "enabled value"); 113 return (B_FALSE); 114 } 115 if (nwam_value_get_boolean(enabledval, &enabled) 116 != NWAM_SUCCESS) { 117 nlog(LOG_ERR, "loc_is_enabled: could not retrieve " 118 "enabled value"); 119 nwam_value_free(enabledval); 120 return (B_FALSE); 121 } 122 nwam_value_free(enabledval); 123 return (enabled); 124 } 125 126 static int64_t 127 loc_get_activation_mode(nwam_loc_handle_t loch) 128 { 129 nwam_error_t err; 130 uint64_t activation; 131 nwam_value_t activationval; 132 133 if (nwam_loc_get_prop_value(loch, NWAM_LOC_PROP_ACTIVATION_MODE, 134 &activationval) != NWAM_SUCCESS) { 135 nlog(LOG_ERR, "loc_get_activation_mode: could not retrieve " 136 "activation mode value"); 137 return (-1); 138 } 139 err = nwam_value_get_uint64(activationval, &activation); 140 nwam_value_free(activationval); 141 if (err != NWAM_SUCCESS) { 142 nlog(LOG_ERR, "loc_get_activation_mode: could not retrieve " 143 "activation mode value"); 144 return (-1); 145 } 146 147 return ((int64_t)activation); 148 } 149 150 /* Enables the location. */ 151 static void 152 nwamd_loc_activate(const char *object_name) 153 { 154 char *enabled; 155 156 nlog(LOG_DEBUG, "nwamd_loc_activate: activating loc %s", 157 object_name); 158 159 /* 160 * Find currently enabled location and change its state to disabled 161 * if it is a manual location, or offline (if it is not). 162 * Only manual locations reach disabled, since conditional and 163 * system locations which are manually disabled simply revert to 164 * their conditions for activation. 165 */ 166 if ((enabled = malloc(NWAM_MAX_NAME_LEN)) != NULL && 167 nwamd_lookup_string_property(NET_LOC_FMRI, NET_LOC_PG, 168 NET_LOC_SELECTED_PROP, enabled, NWAM_MAX_NAME_LEN) == 0) { 169 /* Only change state if current != new */ 170 if (strcmp(enabled, object_name) != 0) { 171 boolean_t do_disable = B_FALSE; 172 nwamd_object_t eobj = nwamd_object_find 173 (NWAM_OBJECT_TYPE_LOC, enabled); 174 if (eobj == NULL) { 175 nlog(LOG_INFO, "nwamd_loc_activate: could not " 176 "find old location %s", enabled); 177 goto skip_disable; 178 } 179 /* 180 * Disable if the old location was manual, since the 181 * only way a manual location can deactivate is if 182 * it is disabled. 183 */ 184 do_disable = 185 (loc_get_activation_mode(eobj->nwamd_object_handle) 186 == (int64_t)NWAM_ACTIVATION_MODE_MANUAL); 187 nwamd_object_release(eobj); 188 189 if (do_disable) { 190 nlog(LOG_DEBUG, "nwamd_loc_activate: " 191 "disable needed for old location %s", 192 enabled); 193 nwamd_object_set_state 194 (NWAM_OBJECT_TYPE_LOC, enabled, 195 NWAM_STATE_DISABLED, 196 NWAM_AUX_STATE_MANUAL_DISABLE); 197 } else { 198 nlog(LOG_DEBUG, "nwamd_loc_activate: " 199 "offline needed for old location %s", 200 enabled); 201 nwamd_object_set_state 202 (NWAM_OBJECT_TYPE_LOC, enabled, 203 NWAM_STATE_OFFLINE, 204 NWAM_AUX_STATE_CONDITIONS_NOT_MET); 205 } 206 } 207 } 208 skip_disable: 209 free(enabled); 210 211 if (nwamd_set_string_property(NET_LOC_FMRI, NET_LOC_PG, 212 NET_LOC_SELECTED_PROP, object_name) == 0) { 213 char *state = smf_get_state(NET_LOC_FMRI); 214 nlog(LOG_INFO, "nwamd_loc_activate: set %s/%s to %s; " 215 "service is in %s state", NET_LOC_PG, NET_LOC_SELECTED_PROP, 216 object_name, state == NULL ? "unknown" : state); 217 free(state); 218 (void) smf_restore_instance(NET_LOC_FMRI); 219 if (smf_refresh_instance(NET_LOC_FMRI) == 0) { 220 (void) pthread_mutex_lock(&active_loc_mutex); 221 (void) strlcpy(active_loc, object_name, 222 sizeof (active_loc)); 223 (void) pthread_mutex_unlock(&active_loc_mutex); 224 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, 225 object_name, 226 NWAM_STATE_ONLINE, NWAM_AUX_STATE_ACTIVE); 227 } else { 228 nlog(LOG_ERR, "nwamd_loc_activate: " 229 "%s could not be refreshed", NET_LOC_FMRI); 230 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, 231 object_name, 232 NWAM_STATE_MAINTENANCE, 233 NWAM_AUX_STATE_METHOD_FAILED); 234 } 235 } 236 } 237 238 struct nwamd_loc_check_walk_arg { 239 nwamd_object_t winning_object; 240 uint64_t winning_rating; 241 }; 242 243 /* 244 * Determine which location should be activated. 245 */ 246 static int 247 nwamd_loc_check(nwamd_object_t object, void *data) 248 { 249 struct nwamd_loc_check_walk_arg *wa = data; 250 nwam_loc_handle_t loch = object->nwamd_object_handle; 251 nwam_value_t conditionval; 252 int64_t lactivation; 253 uint64_t rating, activation; 254 boolean_t satisfied; 255 char **conditions; 256 uint_t nelem; 257 258 lactivation = loc_get_activation_mode(object->nwamd_object_handle); 259 260 if (lactivation == -1) 261 return (0); 262 263 activation = (uint64_t)lactivation; 264 switch (activation) { 265 case NWAM_ACTIVATION_MODE_MANUAL: 266 if (loc_is_enabled(loch)) { 267 /* Manually enabled locations should always win out. */ 268 nlog(LOG_DEBUG, "nwamd_loc_check: %s is enabled", 269 object->nwamd_object_name); 270 wa->winning_object = object; 271 wa->winning_rating = UINT64_MAX; 272 } else { 273 nlog(LOG_DEBUG, "nwamd_loc_check: %s is disabled", 274 object->nwamd_object_name); 275 if (object->nwamd_object_state != NWAM_STATE_DISABLED) { 276 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, 277 object->nwamd_object_name, 278 NWAM_STATE_DISABLED, 279 NWAM_AUX_STATE_MANUAL_DISABLE); 280 } 281 } 282 283 return (0); 284 285 case NWAM_ACTIVATION_MODE_CONDITIONAL_ANY: 286 case NWAM_ACTIVATION_MODE_CONDITIONAL_ALL: 287 if (loc_is_enabled(loch)) { 288 /* Manually enabled locations should always win out. */ 289 nlog(LOG_DEBUG, "nwamd_loc_check: %s is enabled", 290 object->nwamd_object_name); 291 wa->winning_object = object; 292 wa->winning_rating = UINT64_MAX; 293 } 294 295 if (nwam_loc_get_prop_value(loch, 296 NWAM_LOC_PROP_CONDITIONS, &conditionval) != NWAM_SUCCESS) { 297 nlog(LOG_ERR, "nwamd_loc_check: could not retrieve " 298 "condition value"); 299 return (0); 300 } 301 if (nwam_value_get_string_array(conditionval, 302 &conditions, &nelem) != NWAM_SUCCESS) { 303 nlog(LOG_ERR, "nwamd_loc_check: could not retrieve " 304 "condition value"); 305 nwam_value_free(conditionval); 306 return (0); 307 } 308 satisfied = nwamd_check_conditions(activation, conditions, 309 nelem); 310 311 if (satisfied) { 312 rating = nwamd_rate_conditions(activation, 313 conditions, nelem); 314 if (rating > wa->winning_rating) { 315 wa->winning_object = object; 316 wa->winning_rating = rating; 317 } 318 } 319 nwam_value_free(conditionval); 320 return (0); 321 322 case NWAM_ACTIVATION_MODE_SYSTEM: 323 if (loc_is_enabled(loch)) { 324 /* Manually enabled locations should always win out. */ 325 nlog(LOG_DEBUG, "nwamd_loc_check: %s is enabled", 326 object->nwamd_object_name); 327 wa->winning_object = object; 328 wa->winning_rating = UINT64_MAX; 329 } 330 331 /* Either NoNet, Automatic or Legacy location, so skip. */ 332 333 return (0); 334 default: 335 return (0); 336 } 337 /*NOTREACHED*/ 338 return (0); 339 } 340 341 static int 342 nwamd_ncu_online_check(nwamd_object_t object, void *data) 343 { 344 boolean_t *online = data; 345 nwamd_ncu_t *ncu_data = object->nwamd_object_data; 346 347 if (ncu_data->ncu_type != NWAM_NCU_TYPE_INTERFACE) 348 return (0); 349 350 if (object->nwamd_object_state == NWAM_STATE_ONLINE) { 351 /* An online IP NCU found, stop walk */ 352 *online = B_TRUE; 353 return (1); 354 } 355 return (0); 356 } 357 358 void 359 nwamd_loc_check_conditions(void) 360 { 361 struct nwamd_loc_check_walk_arg wa = { NULL, 0 }; 362 const char *winning_loc; 363 boolean_t ncu_online = B_FALSE; 364 boolean_t is_active; 365 366 /* 367 * Walk the NCUs to find out if at least one IP NCU is online. If so, 368 * check the activation-mode and conditions. If not, enable the NoNet 369 * location. 370 */ 371 (void) nwamd_walk_objects(NWAM_OBJECT_TYPE_NCU, nwamd_ncu_online_check, 372 &ncu_online); 373 374 if (!ncu_online) { 375 winning_loc = NWAM_LOC_NAME_NO_NET; 376 } else { 377 (void) nwamd_walk_objects(NWAM_OBJECT_TYPE_LOC, nwamd_loc_check, 378 &wa); 379 if (wa.winning_object != NULL) 380 winning_loc = wa.winning_object->nwamd_object_name; 381 else 382 winning_loc = NWAM_LOC_NAME_AUTOMATIC; 383 } 384 nlog(LOG_INFO, "nwamd_loc_check_conditions: winning loc is %s", 385 winning_loc); 386 387 /* If the winning location is already active, do nothing */ 388 (void) pthread_mutex_lock(&active_loc_mutex); 389 is_active = (strcmp(active_loc, winning_loc) == 0); 390 (void) pthread_mutex_unlock(&active_loc_mutex); 391 if (is_active) 392 return; 393 394 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, winning_loc, 395 NWAM_STATE_OFFLINE_TO_ONLINE, NWAM_AUX_STATE_METHOD_RUNNING); 396 } 397 398 int 399 nwamd_loc_action(const char *loc, nwam_action_t action) 400 { 401 nwamd_event_t event = nwamd_event_init_object_action 402 (NWAM_OBJECT_TYPE_LOC, loc, NULL, action); 403 if (event == NULL) 404 return (1); 405 nwamd_event_enqueue(event); 406 return (0); 407 } 408 409 /* 410 * Event handling functions. 411 */ 412 413 /* Handle loc initialization/refresh event */ 414 void 415 nwamd_loc_handle_init_event(nwamd_event_t event) 416 { 417 nwamd_object_t object; 418 nwam_loc_handle_t loch; 419 nwam_error_t err; 420 boolean_t new_enabled, old_enabled = B_FALSE; 421 nwam_state_t state; 422 423 if ((err = nwam_loc_read(event->event_object, 0, &loch)) 424 != NWAM_SUCCESS) { 425 nlog(LOG_ERR, "nwamd_loc_handle_init_event: could not " 426 "read object '%s': %s", event->event_object, 427 nwam_strerror(err)); 428 nwamd_event_do_not_send(event); 429 return; 430 } 431 if ((object = nwamd_object_find(NWAM_OBJECT_TYPE_LOC, 432 event->event_object)) != NULL) { 433 old_enabled = loc_is_enabled(object->nwamd_object_handle); 434 nwam_loc_free(object->nwamd_object_handle); 435 object->nwamd_object_handle = loch; 436 } else { 437 object = nwamd_object_init(NWAM_OBJECT_TYPE_LOC, 438 event->event_object, loch, NULL); 439 object->nwamd_object_state = NWAM_STATE_OFFLINE; 440 object->nwamd_object_aux_state = 441 NWAM_AUX_STATE_CONDITIONS_NOT_MET; 442 } 443 new_enabled = loc_is_enabled(loch); 444 state = object->nwamd_object_state; 445 nwamd_object_release(object); 446 447 /* 448 * If this location is ONLINE and the value of the "enabled" property 449 * has not changed, then this location is getting refreshed because it 450 * was committed with changes. Change states to re-activate itself. 451 * If the "enabled" property has changed, then this location is 452 * getting refreshed as part of a enable/disable action and there is 453 * no need to change states here. 454 */ 455 if (state == NWAM_STATE_ONLINE && old_enabled == new_enabled) { 456 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, 457 event->event_object, NWAM_STATE_OFFLINE_TO_ONLINE, 458 NWAM_AUX_STATE_METHOD_RUNNING); 459 } 460 } 461 462 /* Handle loc finish event */ 463 void 464 nwamd_loc_handle_fini_event(nwamd_event_t event) 465 { 466 nwamd_object_t object; 467 468 nlog(LOG_DEBUG, "nwamd_loc_handle_fini_event(%s)", 469 event->event_object); 470 471 /* Don't disable the location, as this can enable the Automatic loc */ 472 if ((object = nwamd_object_find(NWAM_OBJECT_TYPE_LOC, 473 event->event_object)) == NULL) { 474 nlog(LOG_ERR, "nwamd_loc_handle_fini_event: " 475 "loc %s not found", event->event_object); 476 nwamd_event_do_not_send(event); 477 return; 478 } 479 nwamd_object_release_and_destroy(object); 480 } 481 482 void 483 nwamd_loc_handle_action_event(nwamd_event_t event) 484 { 485 nwamd_object_t object; 486 487 switch (event->event_msg->nwe_data.nwe_object_action.nwe_action) { 488 case NWAM_ACTION_ENABLE: 489 object = nwamd_object_find(NWAM_OBJECT_TYPE_LOC, 490 event->event_object); 491 if (object == NULL) { 492 nlog(LOG_ERR, "nwamd_loc_handle_action_event: " 493 "could not find location %s", event->event_object); 494 nwamd_event_do_not_send(event); 495 return; 496 } 497 if (object->nwamd_object_state == NWAM_STATE_ONLINE) { 498 nlog(LOG_DEBUG, "nwamd_loc_handle_action_event: " 499 "location %s already online, nothing to do", 500 event->event_object); 501 nwamd_object_release(object); 502 return; 503 } 504 nwamd_object_release(object); 505 506 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, 507 event->event_object, NWAM_STATE_OFFLINE_TO_ONLINE, 508 NWAM_AUX_STATE_METHOD_RUNNING); 509 break; 510 case NWAM_ACTION_DISABLE: 511 object = nwamd_object_find(NWAM_OBJECT_TYPE_LOC, 512 event->event_object); 513 if (object == NULL) { 514 nlog(LOG_ERR, "nwamd_loc_handle_action_event: " 515 "could not find location %s", event->event_object); 516 nwamd_event_do_not_send(event); 517 return; 518 } 519 if (object->nwamd_object_state == NWAM_STATE_DISABLED) { 520 nlog(LOG_DEBUG, "nwamd_loc_handle_action_event: " 521 "location %s already disabled, nothing to do", 522 event->event_object); 523 nwamd_object_release(object); 524 return; 525 } 526 nwamd_object_release(object); 527 528 nwamd_object_set_state(NWAM_OBJECT_TYPE_LOC, 529 event->event_object, NWAM_STATE_ONLINE_TO_OFFLINE, 530 NWAM_AUX_STATE_MANUAL_DISABLE); 531 break; 532 case NWAM_ACTION_ADD: 533 case NWAM_ACTION_REFRESH: 534 nwamd_loc_handle_init_event(event); 535 break; 536 case NWAM_ACTION_DESTROY: 537 nwamd_loc_handle_fini_event(event); 538 break; 539 default: 540 nlog(LOG_INFO, "nwam_loc_handle_action_event: " 541 "unexpected action"); 542 break; 543 } 544 } 545 546 void 547 nwamd_loc_handle_state_event(nwamd_event_t event) 548 { 549 nwamd_object_t object; 550 nwam_state_t new_state; 551 nwam_aux_state_t new_aux_state; 552 553 if ((object = nwamd_object_find(NWAM_OBJECT_TYPE_LOC, 554 event->event_object)) == NULL) { 555 nlog(LOG_ERR, "nwamd_loc_handle_state_event: " 556 "state event for nonexistent loc %s", event->event_object); 557 nwamd_event_do_not_send(event); 558 return; 559 } 560 new_state = event->event_msg->nwe_data.nwe_object_state.nwe_state; 561 new_aux_state = 562 event->event_msg->nwe_data.nwe_object_state.nwe_aux_state; 563 564 if (new_state == object->nwamd_object_state && 565 new_aux_state == object->nwamd_object_aux_state) { 566 nlog(LOG_DEBUG, "nwamd_loc_handle_state_event: " 567 "loc %s already in state (%s , %s)", 568 object->nwamd_object_name, 569 nwam_state_to_string(new_state), 570 nwam_aux_state_to_string(new_aux_state)); 571 nwamd_object_release(object); 572 return; 573 } 574 575 object->nwamd_object_state = new_state; 576 object->nwamd_object_aux_state = new_aux_state; 577 578 nlog(LOG_DEBUG, "nwamd_loc_handle_state_event: changing state for loc " 579 "%s to (%s , %s)", object->nwamd_object_name, 580 nwam_state_to_string(object->nwamd_object_state), 581 nwam_aux_state_to_string(object->nwamd_object_aux_state)); 582 583 nwamd_object_release(object); 584 585 /* 586 * State machine for location. 587 */ 588 switch (new_state) { 589 case NWAM_STATE_OFFLINE_TO_ONLINE: 590 nwamd_loc_activate(event->event_object); 591 break; 592 case NWAM_STATE_ONLINE_TO_OFFLINE: 593 /* 594 * Don't need to deactivate current location - condition check 595 * will activate another. If the currently active location is 596 * being deactivated, then it is being manually deactivated; 597 * so also clear active_loc so condition checking is not 598 * confused. 599 */ 600 (void) pthread_mutex_lock(&active_loc_mutex); 601 if (strcmp(event->event_object, active_loc) == 0) 602 active_loc[0] = '\0'; 603 (void) pthread_mutex_unlock(&active_loc_mutex); 604 nwamd_loc_check_conditions(); 605 break; 606 case NWAM_STATE_DISABLED: 607 case NWAM_STATE_OFFLINE: 608 case NWAM_STATE_UNINITIALIZED: 609 case NWAM_STATE_MAINTENANCE: 610 case NWAM_STATE_DEGRADED: 611 default: 612 /* do nothing */ 613 break; 614 } 615 } 616