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 (c) 2004, 2010, Oracle and/or its affiliates. All rights reserved. 23 */ 24 /* 25 * Copyright 2011 Nexenta Systems, Inc. All rights reserved. 26 */ 27 28 29 /* 30 * XML document manipulation routines 31 * 32 * These routines provide translation to and from the internal representation to 33 * XML. Directionally-oriented verbs are with respect to the external source, 34 * so lxml_get_service() fetches a service from the XML file into the 35 * internal representation. 36 */ 37 38 #include <libxml/parser.h> 39 #include <libxml/xinclude.h> 40 41 #include <assert.h> 42 #include <ctype.h> 43 #include <errno.h> 44 #include <libintl.h> 45 #include <libscf.h> 46 #include <libscf_priv.h> 47 #include <libuutil.h> 48 #include <sasl/saslutil.h> 49 #include <stdlib.h> 50 #include <string.h> 51 #include <limits.h> 52 53 #include <sys/types.h> 54 #include <sys/stat.h> 55 #include <unistd.h> 56 57 #include <sys/param.h> 58 #include "manifest_hash.h" 59 60 #include "svccfg.h" 61 #include "notify_params.h" 62 63 /* 64 * snprintf(3C) format strings for constructing property names that include 65 * the locale designation. Use %s to indicate where the locale should go. 66 * 67 * The VALUE_* symbols are an exception. The firs %s will be replaced with 68 * "value_". The second %s will be replaced by the name of the value and 69 * %%s will be replaced by the locale designation. These formats are 70 * processed twice by snprintf(3C). The first time captures the value name 71 * and the second time captures the locale. 72 */ 73 #define LOCALE_ONLY_FMT ("%s") 74 #define COMMON_NAME_FMT ("common_name_%s") 75 #define DESCRIPTION_FMT ("description_%s") 76 #define UNITS_FMT ("units_%s") 77 #define VALUE_COMMON_NAME_FMT ("%s%s_common_name_%%s") 78 #define VALUE_DESCRIPTION_FMT ("%s%s_description_%%s") 79 80 /* Attribute names */ 81 const char * const delete_attr = "delete"; 82 const char * const enabled_attr = "enabled"; 83 const char * const lang_attr = "lang"; 84 const char * const manpath_attr = "manpath"; 85 const char * const max_attr = "max"; 86 const char * const min_attr = "min"; 87 const char * const name_attr = "name"; 88 const char * const override_attr = "override"; 89 const char * const required_attr = "required"; 90 const char * const section_attr = "section"; 91 const char * const set_attr = "set"; 92 const char * const target_attr = "target"; 93 const char * const timeout_seconds_attr = "timeout_seconds"; 94 const char * const title_attr = "title"; 95 const char * const type_attr = "type"; 96 const char * const uri_attr = "uri"; 97 const char * const value_attr = "value"; 98 const char * const version_attr = "version"; 99 const char * const xml_lang_attr = "xml:lang"; 100 const char * const active_attr = "active"; 101 102 /* Attribute values */ 103 const char * const all_value = "all"; 104 105 const char * const true = "true"; 106 const char * const false = "false"; 107 108 /* 109 * The following list must be kept in the same order as that of 110 * element_t array 111 */ 112 static const char *lxml_elements[] = { 113 "astring_list", /* SC_ASTRING */ 114 "boolean_list", /* SC_BOOLEAN */ 115 "cardinality", /* SC_CARDINALITY */ 116 "choices", /* SC_CHOICES */ 117 "common_name", /* SC_COMMON_NAME */ 118 "constraints", /* SC_CONSTRAINTS */ 119 "count_list", /* SC_COUNT */ 120 "create_default_instance", /* SC_INSTANCE_CREATE_DEFAULT */ 121 "dependency", /* SC_DEPENDENCY */ 122 "dependent", /* SC_DEPENDENT */ 123 "description", /* SC_DESCRIPTION */ 124 "doc_link", /* SC_DOC_LINK */ 125 "documentation", /* SC_DOCUMENTATION */ 126 "enabled", /* SC_ENABLED */ 127 "event", /* SC_EVENT */ 128 "exec_method", /* SC_EXEC_METHOD */ 129 "fmri_list", /* SC_FMRI */ 130 "host_list", /* SC_HOST */ 131 "hostname_list", /* SC_HOSTNAME */ 132 "include_values", /* SC_INCLUDE_VALUES */ 133 "instance", /* SC_INSTANCE */ 134 "integer_list", /* SC_INTEGER */ 135 "internal_separators", /* SC_INTERNAL_SEPARATORS */ 136 "loctext", /* SC_LOCTEXT */ 137 "manpage", /* SC_MANPAGE */ 138 "method_context", /* SC_METHOD_CONTEXT */ 139 "method_credential", /* SC_METHOD_CREDENTIAL */ 140 "method_profile", /* SC_METHOD_PROFILE */ 141 "method_environment", /* SC_METHOD_ENVIRONMENT */ 142 "envvar", /* SC_METHOD_ENVVAR */ 143 "net_address_list", /* SC_NET_ADDR */ 144 "net_address_v4_list", /* SC_NET_ADDR_V4 */ 145 "net_address_v6_list", /* SC_NET_ADDR_V6 */ 146 "notification_parameters", /* SC_NOTIFICATION_PARAMETERS */ 147 "opaque_list", /* SC_OPAQUE */ 148 "parameter", /* SC_PARAMETER */ 149 "paramval", /* SC_PARAMVAL */ 150 "pg_pattern", /* SC_PG_PATTERN */ 151 "prop_pattern", /* SC_PROP_PATTERN */ 152 "property", /* SC_PROPERTY */ 153 "property_group", /* SC_PROPERTY_GROUP */ 154 "propval", /* SC_PROPVAL */ 155 "range", /* SC_RANGE */ 156 "restarter", /* SC_RESTARTER */ 157 "service", /* SC_SERVICE */ 158 "service_bundle", /* SC_SERVICE_BUNDLE */ 159 "service_fmri", /* SC_SERVICE_FMRI */ 160 "single_instance", /* SC_INSTANCE_SINGLE */ 161 "stability", /* SC_STABILITY */ 162 "template", /* SC_TEMPLATE */ 163 "time_list", /* SC_TIME */ 164 "type", /* SC_TYPE */ 165 "units", /* SC_UNITS */ 166 "uri_list", /* SC_URI */ 167 "ustring_list", /* SC_USTRING */ 168 "value", /* SC_VALUE */ 169 "value_node", /* SC_VALUE_NODE */ 170 "values", /* SC_VALUES */ 171 "visibility", /* SC_VISIBILITY */ 172 "xi:fallback", /* SC_XI_FALLBACK */ 173 "xi:include" /* SC_XI_INCLUDE */ 174 }; 175 176 /* 177 * The following list must be kept in the same order as that of 178 * element_t array 179 */ 180 static const char *lxml_prop_types[] = { 181 "astring", /* SC_ASTRING */ 182 "boolean", /* SC_BOOLEAN */ 183 "", /* SC_CARDINALITY */ 184 "", /* SC_CHOICES */ 185 "", /* SC_COMMON_NAME */ 186 "", /* SC_CONSTRAINTS */ 187 "count", /* SC_COUNT */ 188 "", /* SC_INSTANCE_CREATE_DEFAULT */ 189 "", /* SC_DEPENDENCY */ 190 "", /* SC_DEPENDENT */ 191 "", /* SC_DESCRIPTION */ 192 "", /* SC_DOC_LINK */ 193 "", /* SC_DOCUMENTATION */ 194 "", /* SC_ENABLED */ 195 "", /* SC_EVENT */ 196 "", /* SC_EXEC_METHOD */ 197 "fmri", /* SC_FMRI */ 198 "host", /* SC_HOST */ 199 "hostname", /* SC_HOSTNAME */ 200 "", /* SC_INCLUDE_VALUES */ 201 "", /* SC_INSTANCE */ 202 "integer", /* SC_INTEGER */ 203 "", /* SC_INTERNAL_SEPARATORS */ 204 "", /* SC_LOCTEXT */ 205 "", /* SC_MANPAGE */ 206 "", /* SC_METHOD_CONTEXT */ 207 "", /* SC_METHOD_CREDENTIAL */ 208 "", /* SC_METHOD_PROFILE */ 209 "", /* SC_METHOD_ENVIRONMENT */ 210 "", /* SC_METHOD_ENVVAR */ 211 "net_address", /* SC_NET_ADDR */ 212 "net_address_v4", /* SC_NET_ADDR_V4 */ 213 "net_address_v6", /* SC_NET_ADDR_V6 */ 214 "", /* SC_NOTIFICATION_PARAMETERS */ 215 "opaque", /* SC_OPAQUE */ 216 "", /* SC_PARAMETER */ 217 "", /* SC_PARAMVAL */ 218 "", /* SC_PG_PATTERN */ 219 "", /* SC_PROP_PATTERN */ 220 "", /* SC_PROPERTY */ 221 "", /* SC_PROPERTY_GROUP */ 222 "", /* SC_PROPVAL */ 223 "", /* SC_RANGE */ 224 "", /* SC_RESTARTER */ 225 "", /* SC_SERVICE */ 226 "", /* SC_SERVICE_BUNDLE */ 227 "", /* SC_SERVICE_FMRI */ 228 "", /* SC_INSTANCE_SINGLE */ 229 "", /* SC_STABILITY */ 230 "", /* SC_TEMPLATE */ 231 "time", /* SC_TIME */ 232 "", /* SC_TYPE */ 233 "", /* SC_UNITS */ 234 "uri", /* SC_URI */ 235 "ustring", /* SC_USTRING */ 236 "", /* SC_VALUE */ 237 "", /* SC_VALUE_NODE */ 238 "", /* SC_VALUES */ 239 "", /* SC_VISIBILITY */ 240 "", /* SC_XI_FALLBACK */ 241 "" /* SC_XI_INCLUDE */ 242 }; 243 244 int 245 lxml_init() 246 { 247 if (getenv("SVCCFG_NOVALIDATE") == NULL) { 248 /* 249 * DTD validation, with line numbers. 250 */ 251 (void) xmlLineNumbersDefault(1); 252 xmlLoadExtDtdDefaultValue |= XML_DETECT_IDS; 253 xmlLoadExtDtdDefaultValue |= XML_COMPLETE_ATTRS; 254 } 255 256 return (0); 257 } 258 259 static bundle_type_t 260 lxml_xlate_bundle_type(xmlChar *type) 261 { 262 if (xmlStrcmp(type, (const xmlChar *)"manifest") == 0) 263 return (SVCCFG_MANIFEST); 264 265 if (xmlStrcmp(type, (const xmlChar *)"profile") == 0) 266 return (SVCCFG_PROFILE); 267 268 if (xmlStrcmp(type, (const xmlChar *)"archive") == 0) 269 return (SVCCFG_ARCHIVE); 270 271 return (SVCCFG_UNKNOWN_BUNDLE); 272 } 273 274 static service_type_t 275 lxml_xlate_service_type(xmlChar *type) 276 { 277 if (xmlStrcmp(type, (const xmlChar *)"service") == 0) 278 return (SVCCFG_SERVICE); 279 280 if (xmlStrcmp(type, (const xmlChar *)"restarter") == 0) 281 return (SVCCFG_RESTARTER); 282 283 if (xmlStrcmp(type, (const xmlChar *)"milestone") == 0) 284 return (SVCCFG_MILESTONE); 285 286 return (SVCCFG_UNKNOWN_SERVICE); 287 } 288 289 static element_t 290 lxml_xlate_element(const xmlChar *tag) 291 { 292 int i; 293 294 for (i = 0; i < sizeof (lxml_elements) / sizeof (char *); i++) 295 if (xmlStrcmp(tag, (const xmlChar *)lxml_elements[i]) == 0) 296 return ((element_t)i); 297 298 return ((element_t)-1); 299 } 300 301 static uint_t 302 lxml_xlate_boolean(const xmlChar *value) 303 { 304 if (xmlStrcmp(value, (const xmlChar *)true) == 0) 305 return (1); 306 307 if (xmlStrcmp(value, (const xmlChar *)false) == 0) 308 return (0); 309 310 uu_die(gettext("illegal boolean value \"%s\"\n"), value); 311 312 /*NOTREACHED*/ 313 } 314 315 static scf_type_t 316 lxml_element_to_type(element_t type) 317 { 318 switch (type) { 319 case SC_ASTRING: return (SCF_TYPE_ASTRING); 320 case SC_BOOLEAN: return (SCF_TYPE_BOOLEAN); 321 case SC_COUNT: return (SCF_TYPE_COUNT); 322 case SC_FMRI: return (SCF_TYPE_FMRI); 323 case SC_HOST: return (SCF_TYPE_HOST); 324 case SC_HOSTNAME: return (SCF_TYPE_HOSTNAME); 325 case SC_INTEGER: return (SCF_TYPE_INTEGER); 326 case SC_NET_ADDR: return (SCF_TYPE_NET_ADDR); 327 case SC_NET_ADDR_V4: return (SCF_TYPE_NET_ADDR_V4); 328 case SC_NET_ADDR_V6: return (SCF_TYPE_NET_ADDR_V6); 329 case SC_OPAQUE: return (SCF_TYPE_OPAQUE); 330 case SC_TIME: return (SCF_TYPE_TIME); 331 case SC_URI: return (SCF_TYPE_URI); 332 case SC_USTRING: return (SCF_TYPE_USTRING); 333 334 default: 335 uu_die(gettext("unknown value type (%d)\n"), type); 336 } 337 338 /* NOTREACHED */ 339 } 340 341 static element_t 342 lxml_type_to_element(scf_type_t type) 343 { 344 switch (type) { 345 case SCF_TYPE_ASTRING: return (SC_ASTRING); 346 case SCF_TYPE_BOOLEAN: return (SC_BOOLEAN); 347 case SCF_TYPE_COUNT: return (SC_COUNT); 348 case SCF_TYPE_FMRI: return (SC_FMRI); 349 case SCF_TYPE_HOST: return (SC_HOST); 350 case SCF_TYPE_HOSTNAME: return (SC_HOSTNAME); 351 case SCF_TYPE_INTEGER: return (SC_INTEGER); 352 case SCF_TYPE_NET_ADDR: return (SC_NET_ADDR); 353 case SCF_TYPE_NET_ADDR_V4: return (SC_NET_ADDR_V4); 354 case SCF_TYPE_NET_ADDR_V6: return (SC_NET_ADDR_V6); 355 case SCF_TYPE_OPAQUE: return (SC_OPAQUE); 356 case SCF_TYPE_TIME: return (SC_TIME); 357 case SCF_TYPE_URI: return (SC_URI); 358 case SCF_TYPE_USTRING: return (SC_USTRING); 359 360 default: 361 uu_die(gettext("unknown value type (%d)\n"), type); 362 } 363 364 /* NOTREACHED */ 365 } 366 367 /* 368 * Create a SCF_TYPE_BOOLEAN property name pname and attach it to the 369 * property group at pgrp. The value of the property will be set from the 370 * attribute named attr. attr must have a value of 0, 1, true or false. 371 * 372 * Zero is returned on success. An error is indicated by -1. It indicates 373 * that either the attribute had an invalid value or that we could not 374 * attach the property to pgrp. The attribute should not have an invalid 375 * value if the DTD is correctly written. 376 */ 377 static int 378 new_bool_prop_from_attr(pgroup_t *pgrp, const char *pname, xmlNodePtr n, 379 const char *attr) 380 { 381 uint64_t bool; 382 xmlChar *val; 383 property_t *p; 384 int r; 385 386 val = xmlGetProp(n, (xmlChar *)attr); 387 if (val == NULL) 388 return (0); 389 390 if ((xmlStrcmp(val, (xmlChar *)"0") == 0) || 391 (xmlStrcmp(val, (xmlChar *)"false") == 0)) { 392 bool = 0; 393 } else if ((xmlStrcmp(val, (xmlChar *)"1") == 0) || 394 (xmlStrcmp(val, (xmlChar *)"true") == 0)) { 395 bool = 1; 396 } else { 397 xmlFree(val); 398 return (-1); 399 } 400 xmlFree(val); 401 p = internal_property_create(pname, SCF_TYPE_BOOLEAN, 1, bool); 402 r = internal_attach_property(pgrp, p); 403 404 if (r != 0) 405 internal_property_free(p); 406 407 return (r); 408 } 409 410 static int 411 new_str_prop_from_attr(pgroup_t *pgrp, const char *pname, scf_type_t ty, 412 xmlNodePtr n, const char *attr) 413 { 414 xmlChar *val; 415 property_t *p; 416 int r; 417 418 val = xmlGetProp(n, (xmlChar *)attr); 419 420 p = internal_property_create(pname, ty, 1, val); 421 r = internal_attach_property(pgrp, p); 422 423 if (r != 0) 424 internal_property_free(p); 425 426 return (r); 427 } 428 429 static int 430 new_opt_str_prop_from_attr(pgroup_t *pgrp, const char *pname, scf_type_t ty, 431 xmlNodePtr n, const char *attr, const char *dflt) 432 { 433 xmlChar *val; 434 property_t *p; 435 int r; 436 437 val = xmlGetProp(n, (xmlChar *)attr); 438 if (val == NULL) { 439 if (dflt == NULL) { 440 /* 441 * A missing attribute is considered to be a 442 * success in this function, because many of the 443 * attributes are optional. Missing non-optional 444 * attributes will be detected later when template 445 * validation is done. 446 */ 447 return (0); 448 } else { 449 val = (xmlChar *)dflt; 450 } 451 } 452 453 p = internal_property_create(pname, ty, 1, val); 454 r = internal_attach_property(pgrp, p); 455 456 if (r != 0) 457 internal_property_free(p); 458 459 return (r); 460 } 461 462 static int 463 lxml_ignorable_block(xmlNodePtr n) 464 { 465 return ((xmlStrcmp(n->name, (xmlChar *)"text") == 0 || 466 xmlStrcmp(n->name, (xmlChar *)"comment") == 0) ? 1 : 0); 467 } 468 469 static void 470 lxml_validate_element(xmlNodePtr n) 471 { 472 xmlValidCtxtPtr vcp; 473 474 if (n->doc == NULL) 475 uu_die(gettext("Could not validate element\n")); 476 477 if (n->doc->extSubset == NULL) { 478 xmlDtdPtr dtd; 479 dtd = xmlParseDTD(NULL, n->doc->intSubset->SystemID); 480 481 if (dtd == NULL) { 482 uu_die(gettext("Could not parse DTD \"%s\".\n"), 483 n->doc->intSubset->SystemID); 484 } 485 486 n->doc->extSubset = dtd; 487 } 488 489 vcp = xmlNewValidCtxt(); 490 if (vcp == NULL) 491 uu_die(gettext("could not allocate memory")); 492 493 vcp->warning = xmlParserValidityWarning; 494 vcp->error = xmlParserValidityError; 495 496 if (xmlValidateElement(vcp, n->doc, n) == 0) 497 uu_die(gettext("Document is not valid.\n")); 498 499 xmlFreeValidCtxt(vcp); 500 } 501 502 static int 503 lxml_validate_string_value(scf_type_t type, const char *v) 504 { 505 static scf_value_t *scf_value = NULL; 506 static scf_handle_t *scf_hndl = NULL; 507 508 if (scf_hndl == NULL && (scf_hndl = scf_handle_create(SCF_VERSION)) == 509 NULL) 510 return (-1); 511 512 if (scf_value == NULL && (scf_value = scf_value_create(scf_hndl)) == 513 NULL) 514 return (-1); 515 516 return (scf_value_set_from_string(scf_value, type, v)); 517 } 518 519 static void 520 lxml_free_str(value_t *val) 521 { 522 free(val->sc_u.sc_string); 523 } 524 525 /* 526 * Take a value_t structure and a type and value. Based on the type 527 * ensure that the value is of that type. If so store the value in 528 * the correct location of the value_t structure. 529 * 530 * If the value is NULL, the value_t structure will have been created 531 * and the value would have ultimately been stored as a string value 532 * but at the time the type was unknown. Now the type should be known 533 * so take the type and value from value_t and validate and store 534 * the value correctly if the value is of the stated type. 535 */ 536 void 537 lxml_store_value(value_t *v, element_t type, const xmlChar *value) 538 { 539 char *endptr; 540 int fov = 0; 541 scf_type_t scf_type = SCF_TYPE_INVALID; 542 543 if (value == NULL) { 544 type = lxml_type_to_element(v->sc_type); 545 value = (const xmlChar *)v->sc_u.sc_string; 546 fov = 1; 547 } 548 549 switch (type) { 550 case SC_COUNT: 551 /* 552 * Although an SC_COUNT represents a uint64_t the use 553 * of a negative value is acceptable due to the usage 554 * established by inetd(1M). 555 */ 556 errno = 0; 557 v->sc_u.sc_count = strtoull((char *)value, &endptr, 10); 558 if (errno != 0 || endptr == (char *)value || *endptr) 559 uu_die(gettext("illegal value \"%s\" for " 560 "%s (%s)\n"), (char *)value, 561 lxml_prop_types[type], 562 (errno) ? strerror(errno) : 563 gettext("Illegal character")); 564 break; 565 case SC_INTEGER: 566 errno = 0; 567 v->sc_u.sc_integer = strtoll((char *)value, &endptr, 10); 568 if (errno != 0 || *endptr) 569 uu_die(gettext("illegal value \"%s\" for " 570 "%s (%s)\n"), (char *)value, 571 lxml_prop_types[type], 572 (errno) ? strerror(errno) : "Illegal character"); 573 break; 574 case SC_OPAQUE: 575 case SC_HOST: 576 case SC_HOSTNAME: 577 case SC_NET_ADDR: 578 case SC_NET_ADDR_V4: 579 case SC_NET_ADDR_V6: 580 case SC_FMRI: 581 case SC_URI: 582 case SC_TIME: 583 case SC_ASTRING: 584 case SC_USTRING: 585 scf_type = lxml_element_to_type(type); 586 587 v->sc_u.sc_string = safe_strdup((const char *)value); 588 if (lxml_validate_string_value(scf_type, 589 v->sc_u.sc_string) != 0) 590 uu_die(gettext("illegal value \"%s\" for " 591 "%s (%s)\n"), (char *)value, 592 lxml_prop_types[type], 593 (scf_error()) ? scf_strerror(scf_error()) : 594 gettext("Illegal format")); 595 v->sc_free = lxml_free_str; 596 break; 597 case SC_BOOLEAN: 598 v->sc_u.sc_count = lxml_xlate_boolean(value); 599 break; 600 default: 601 uu_die(gettext("unknown value type (%d)\n"), type); 602 break; 603 } 604 605 /* Free the old value */ 606 if (fov && v->sc_free != NULL) 607 free((char *)value); 608 } 609 610 static value_t * 611 lxml_make_value(element_t type, const xmlChar *value) 612 { 613 value_t *v; 614 615 v = internal_value_new(); 616 617 v->sc_type = lxml_element_to_type(type); 618 619 lxml_store_value(v, type, value); 620 621 return (v); 622 } 623 624 static int 625 lxml_get_value(property_t *prop, element_t vtype, xmlNodePtr value) 626 { 627 xmlNodePtr cursor; 628 629 for (cursor = value->xmlChildrenNode; cursor != NULL; 630 cursor = cursor->next) { 631 xmlChar *assigned_value; 632 value_t *v; 633 634 if (lxml_ignorable_block(cursor)) 635 continue; 636 637 switch (lxml_xlate_element(cursor->name)) { 638 case SC_VALUE_NODE: 639 if ((assigned_value = xmlGetProp(cursor, 640 (xmlChar *)value_attr)) == NULL) 641 uu_die(gettext("no value on value node?\n")); 642 break; 643 default: 644 uu_die(gettext("value list contains illegal element " 645 "\'%s\'\n"), cursor->name); 646 break; 647 } 648 649 v = lxml_make_value(vtype, assigned_value); 650 651 xmlFree(assigned_value); 652 653 internal_attach_value(prop, v); 654 } 655 656 return (0); 657 } 658 659 static int 660 lxml_get_propval(pgroup_t *pgrp, xmlNodePtr propval) 661 { 662 property_t *p; 663 element_t r; 664 value_t *v; 665 xmlChar *type, *val, *override; 666 int op = pgrp->sc_parent->sc_op; 667 668 p = internal_property_new(); 669 670 p->sc_property_name = (char *)xmlGetProp(propval, (xmlChar *)name_attr); 671 if ((p->sc_property_name == NULL) || (*p->sc_property_name == 0)) 672 uu_die(gettext("property name missing in group '%s'\n"), 673 pgrp->sc_pgroup_name); 674 675 type = xmlGetProp(propval, (xmlChar *)type_attr); 676 if ((type != NULL) && (*type != 0)) { 677 for (r = 0; 678 r < sizeof (lxml_prop_types) / sizeof (char *); ++r) { 679 if (xmlStrcmp(type, 680 (const xmlChar *)lxml_prop_types[r]) == 0) 681 break; 682 } 683 684 if (r >= sizeof (lxml_prop_types) / sizeof (char *)) 685 uu_die(gettext("property type invalid for " 686 "property '%s/%s'\n"), pgrp->sc_pgroup_name, 687 p->sc_property_name); 688 689 p->sc_value_type = lxml_element_to_type(r); 690 } else if (op == SVCCFG_OP_APPLY) { 691 /* 692 * Store the property type as invalid, and the value 693 * as an ASTRING and let the bundle apply code validate 694 * the type/value once the type is found. 695 */ 696 est->sc_miss_type = B_TRUE; 697 p->sc_value_type = SCF_TYPE_INVALID; 698 r = SC_ASTRING; 699 } else { 700 uu_die(gettext("property type missing for property '%s/%s'\n"), 701 pgrp->sc_pgroup_name, p->sc_property_name); 702 } 703 704 val = xmlGetProp(propval, (xmlChar *)value_attr); 705 if (val == NULL) 706 uu_die(gettext("property value missing for property '%s/%s'\n"), 707 pgrp->sc_pgroup_name, p->sc_property_name); 708 709 v = lxml_make_value(r, val); 710 xmlFree(val); 711 internal_attach_value(p, v); 712 713 xmlFree(type); 714 715 override = xmlGetProp(propval, (xmlChar *)override_attr); 716 p->sc_property_override = (xmlStrcmp(override, (xmlChar *)true) == 0); 717 xmlFree(override); 718 719 return (internal_attach_property(pgrp, p)); 720 } 721 722 static int 723 lxml_get_property(pgroup_t *pgrp, xmlNodePtr property) 724 { 725 property_t *p; 726 xmlNodePtr cursor; 727 element_t r; 728 xmlChar *type, *override; 729 int op = pgrp->sc_parent->sc_op; 730 731 p = internal_property_new(); 732 733 if (((p->sc_property_name = (char *)xmlGetProp(property, 734 (xmlChar *)name_attr)) == NULL) || (*p->sc_property_name == 0)) 735 uu_die(gettext("property name missing in group \'%s\'\n"), 736 pgrp->sc_pgroup_name); 737 738 type = xmlGetProp(property, (xmlChar *)type_attr); 739 if ((type != NULL) && (*type != 0)) { 740 for (r = 0; 741 r < sizeof (lxml_prop_types) / sizeof (char *); r++) { 742 if (xmlStrcmp(type, 743 (const xmlChar *)lxml_prop_types[r]) == 0) 744 break; 745 } 746 747 if (r >= sizeof (lxml_prop_types) / sizeof (char *)) 748 uu_die(gettext("property type invalid for " 749 "property '%s/%s'\n"), pgrp->sc_pgroup_name, 750 p->sc_property_name); 751 752 p->sc_value_type = lxml_element_to_type(r); 753 } else if (op == SVCCFG_OP_APPLY) { 754 /* 755 * Store the property type as invalid, and let the bundle apply 756 * code validate the type/value once the type is found. 757 */ 758 p->sc_value_type = SCF_TYPE_INVALID; 759 est->sc_miss_type = B_TRUE; 760 } else { 761 uu_die(gettext("property type missing for " 762 "property \'%s/%s\'\n"), pgrp->sc_pgroup_name, 763 p->sc_property_name); 764 } 765 766 for (cursor = property->xmlChildrenNode; cursor != NULL; 767 cursor = cursor->next) { 768 if (lxml_ignorable_block(cursor)) 769 continue; 770 771 switch (r = lxml_xlate_element(cursor->name)) { 772 case SC_ASTRING: 773 case SC_BOOLEAN: 774 case SC_COUNT: 775 case SC_FMRI: 776 case SC_HOST: 777 case SC_HOSTNAME: 778 case SC_INTEGER: 779 case SC_NET_ADDR: 780 case SC_NET_ADDR_V4: 781 case SC_NET_ADDR_V6: 782 case SC_OPAQUE: 783 case SC_TIME: 784 case SC_URI: 785 case SC_USTRING: 786 /* 787 * If the type is invalid then this is an apply 788 * operation and the type can be taken from the 789 * value list. 790 */ 791 if (p->sc_value_type == SCF_TYPE_INVALID) { 792 p->sc_value_type = lxml_element_to_type(r); 793 type = xmlStrdup((const 794 xmlChar *)lxml_prop_types[r]); 795 796 } else if (strcmp(lxml_prop_types[r], 797 (const char *)type) != 0) { 798 uu_die(gettext("property \'%s\' " 799 "type-to-list mismatch\n"), 800 p->sc_property_name); 801 } 802 803 (void) lxml_get_value(p, r, cursor); 804 break; 805 default: 806 uu_die(gettext("unknown value list type: %s\n"), 807 cursor->name); 808 break; 809 } 810 } 811 812 xmlFree(type); 813 814 override = xmlGetProp(property, (xmlChar *)override_attr); 815 p->sc_property_override = (xmlStrcmp(override, (xmlChar *)true) == 0); 816 xmlFree(override); 817 818 return (internal_attach_property(pgrp, p)); 819 } 820 821 static int 822 lxml_get_pgroup_stability(pgroup_t *pgrp, xmlNodePtr stab) 823 { 824 if (pgrp->sc_parent->sc_op == SVCCFG_OP_APPLY) 825 lxml_validate_element(stab); 826 827 return (new_str_prop_from_attr(pgrp, SCF_PROPERTY_STABILITY, 828 SCF_TYPE_ASTRING, stab, value_attr)); 829 } 830 831 /* 832 * Property groups can go on any of a service, an instance, or a template. 833 */ 834 static int 835 lxml_get_pgroup(entity_t *entity, xmlNodePtr pgroup) 836 { 837 pgroup_t *pg; 838 xmlNodePtr cursor; 839 xmlChar *name, *type, *delete; 840 841 /* 842 * property group attributes: 843 * name: string 844 * type: string | framework | application 845 */ 846 name = xmlGetProp(pgroup, (xmlChar *)name_attr); 847 type = xmlGetProp(pgroup, (xmlChar *)type_attr); 848 pg = internal_pgroup_find_or_create(entity, (char *)name, (char *)type); 849 xmlFree(name); 850 xmlFree(type); 851 852 /* 853 * Walk the children of this lxml_elements, which are a stability 854 * element, property elements, or propval elements. 855 */ 856 for (cursor = pgroup->xmlChildrenNode; cursor != NULL; 857 cursor = cursor->next) { 858 if (lxml_ignorable_block(cursor)) 859 continue; 860 861 switch (lxml_xlate_element(cursor->name)) { 862 case SC_STABILITY: 863 (void) lxml_get_pgroup_stability(pg, cursor); 864 break; 865 case SC_PROPERTY: 866 (void) lxml_get_property(pg, cursor); 867 break; 868 case SC_PROPVAL: 869 (void) lxml_get_propval(pg, cursor); 870 break; 871 default: 872 abort(); 873 break; 874 } 875 } 876 877 delete = xmlGetProp(pgroup, (xmlChar *)delete_attr); 878 pg->sc_pgroup_delete = (xmlStrcmp(delete, (xmlChar *)true) == 0); 879 xmlFree(delete); 880 881 return (0); 882 } 883 884 885 /* 886 * Dependency groups, execution methods can go on either a service or an 887 * instance. 888 */ 889 890 static int 891 lxml_get_method_profile(pgroup_t *pg, xmlNodePtr profile) 892 { 893 property_t *p; 894 895 p = internal_property_create(SCF_PROPERTY_USE_PROFILE, SCF_TYPE_BOOLEAN, 896 1, (uint64_t)1); 897 if (internal_attach_property(pg, p) != 0) 898 return (-1); 899 900 return (new_str_prop_from_attr(pg, SCF_PROPERTY_PROFILE, 901 SCF_TYPE_ASTRING, profile, name_attr)); 902 } 903 904 static int 905 lxml_get_method_credential(pgroup_t *pg, xmlNodePtr cred) 906 { 907 property_t *p; 908 909 p = internal_property_create(SCF_PROPERTY_USE_PROFILE, SCF_TYPE_BOOLEAN, 910 1, (uint64_t)0); 911 if (internal_attach_property(pg, p) != 0) 912 return (-1); 913 914 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_USER, SCF_TYPE_ASTRING, 915 cred, "user", NULL) != 0) 916 return (-1); 917 918 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_GROUP, SCF_TYPE_ASTRING, 919 cred, "group", NULL) != 0) 920 return (-1); 921 922 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_SUPP_GROUPS, 923 SCF_TYPE_ASTRING, cred, "supp_groups", NULL) != 0) 924 return (-1); 925 926 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_PRIVILEGES, 927 SCF_TYPE_ASTRING, cred, "privileges", NULL) != 0) 928 return (-1); 929 930 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_LIMIT_PRIVILEGES, 931 SCF_TYPE_ASTRING, cred, "limit_privileges", NULL) != 0) 932 return (-1); 933 934 return (0); 935 } 936 937 static char * 938 lxml_get_envvar(xmlNodePtr envvar) 939 { 940 char *name; 941 char *value; 942 char *ret; 943 944 name = (char *)xmlGetProp(envvar, (xmlChar *)name_attr); 945 value = (char *)xmlGetProp(envvar, (xmlChar *)value_attr); 946 947 if (strlen(name) == 0 || strchr(name, '=') != NULL) 948 uu_die(gettext("Invalid environment variable " 949 "\"%s\".\n"), name); 950 if (strstr(name, "SMF_") == name) 951 uu_die(gettext("Invalid environment variable " 952 "\"%s\"; \"SMF_\" prefix is reserved.\n"), name); 953 954 ret = uu_msprintf("%s=%s", name, value); 955 xmlFree(name); 956 xmlFree(value); 957 return (ret); 958 } 959 960 static int 961 lxml_get_method_environment(pgroup_t *pg, xmlNodePtr environment) 962 { 963 property_t *p; 964 xmlNodePtr cursor; 965 value_t *val; 966 967 p = internal_property_create(SCF_PROPERTY_ENVIRONMENT, 968 SCF_TYPE_ASTRING, 0); 969 970 for (cursor = environment->xmlChildrenNode; cursor != NULL; 971 cursor = cursor->next) { 972 char *tmp; 973 974 if (lxml_ignorable_block(cursor)) 975 continue; 976 977 if (lxml_xlate_element(cursor->name) != SC_METHOD_ENVVAR) 978 uu_die(gettext("illegal element \"%s\" on " 979 "method environment for \"%s\"\n"), 980 cursor->name, pg->sc_pgroup_name); 981 982 if ((tmp = lxml_get_envvar(cursor)) == NULL) 983 uu_die(gettext("Out of memory\n")); 984 985 val = internal_value_new(); 986 val->sc_u.sc_string = tmp; 987 val->sc_type = SCF_TYPE_ASTRING; 988 val->sc_free = lxml_free_str; 989 internal_attach_value(p, val); 990 } 991 992 if (internal_attach_property(pg, p) != 0) { 993 internal_property_free(p); 994 return (-1); 995 } 996 997 return (0); 998 } 999 1000 static int 1001 lxml_get_method_context(pgroup_t *pg, xmlNodePtr ctx) 1002 { 1003 xmlNodePtr cursor; 1004 1005 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_WORKING_DIRECTORY, 1006 SCF_TYPE_ASTRING, ctx, "working_directory", NULL) != 0) 1007 return (-1); 1008 1009 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_PROJECT, 1010 SCF_TYPE_ASTRING, ctx, "project", NULL) != 0) 1011 return (-1); 1012 1013 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_RESOURCE_POOL, 1014 SCF_TYPE_ASTRING, ctx, "resource_pool", NULL) != 0) 1015 return (-1); 1016 1017 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_SECFLAGS, 1018 SCF_TYPE_ASTRING, ctx, "security_flags", NULL) != 0) 1019 return (-1); 1020 1021 for (cursor = ctx->xmlChildrenNode; cursor != NULL; 1022 cursor = cursor->next) { 1023 if (lxml_ignorable_block(cursor)) 1024 continue; 1025 1026 switch (lxml_xlate_element(cursor->name)) { 1027 case SC_METHOD_CREDENTIAL: 1028 (void) lxml_get_method_credential(pg, cursor); 1029 break; 1030 case SC_METHOD_PROFILE: 1031 (void) lxml_get_method_profile(pg, cursor); 1032 break; 1033 case SC_METHOD_ENVIRONMENT: 1034 (void) lxml_get_method_environment(pg, cursor); 1035 break; 1036 default: 1037 semerr(gettext("illegal element \'%s\' in method " 1038 "context\n"), (char *)cursor); 1039 break; 1040 } 1041 } 1042 1043 return (0); 1044 } 1045 1046 static int 1047 lxml_get_entity_method_context(entity_t *entity, xmlNodePtr ctx) 1048 { 1049 pgroup_t *pg; 1050 1051 pg = internal_pgroup_find_or_create(entity, SCF_PG_METHOD_CONTEXT, 1052 (char *)scf_group_framework); 1053 1054 return (lxml_get_method_context(pg, ctx)); 1055 } 1056 1057 static int 1058 lxml_get_exec_method(entity_t *entity, xmlNodePtr emeth) 1059 { 1060 pgroup_t *pg; 1061 property_t *p; 1062 xmlChar *name, *timeout, *delete; 1063 xmlNodePtr cursor; 1064 int r = 0; 1065 1066 if (entity->sc_op == SVCCFG_OP_APPLY) 1067 lxml_validate_element(emeth); 1068 1069 name = xmlGetProp(emeth, (xmlChar *)name_attr); 1070 pg = internal_pgroup_find_or_create(entity, (char *)name, 1071 (char *)SCF_GROUP_METHOD); 1072 xmlFree(name); 1073 1074 if (new_str_prop_from_attr(pg, SCF_PROPERTY_TYPE, SCF_TYPE_ASTRING, 1075 emeth, type_attr) != 0 || 1076 new_str_prop_from_attr(pg, SCF_PROPERTY_EXEC, SCF_TYPE_ASTRING, 1077 emeth, "exec") != 0) 1078 return (-1); 1079 1080 timeout = xmlGetProp(emeth, (xmlChar *)timeout_seconds_attr); 1081 if (timeout != NULL) { 1082 uint64_t u_timeout; 1083 char *endptr; 1084 /* 1085 * Although an SC_COUNT represents a uint64_t the use 1086 * of a negative value is acceptable due to the usage 1087 * established by inetd(1M). 1088 */ 1089 errno = 0; 1090 u_timeout = strtoull((char *)timeout, &endptr, 10); 1091 if (errno != 0 || endptr == (char *)timeout || *endptr) 1092 uu_die(gettext("illegal value \"%s\" for " 1093 "timeout_seconds (%s)\n"), 1094 (char *)timeout, (errno) ? strerror(errno): 1095 gettext("Illegal character")); 1096 p = internal_property_create(SCF_PROPERTY_TIMEOUT, 1097 SCF_TYPE_COUNT, 1, u_timeout); 1098 r = internal_attach_property(pg, p); 1099 xmlFree(timeout); 1100 } 1101 if (r != 0) 1102 return (-1); 1103 1104 /* 1105 * There is a possibility that a method context also exists, in which 1106 * case the following attributes are defined: project, resource_pool, 1107 * working_directory, profile, user, group, privileges, 1108 * limit_privileges, security_flags 1109 */ 1110 for (cursor = emeth->xmlChildrenNode; cursor != NULL; 1111 cursor = cursor->next) { 1112 if (lxml_ignorable_block(cursor)) 1113 continue; 1114 1115 switch (lxml_xlate_element(cursor->name)) { 1116 case SC_STABILITY: 1117 if (lxml_get_pgroup_stability(pg, cursor) != 0) 1118 return (-1); 1119 break; 1120 1121 case SC_METHOD_CONTEXT: 1122 (void) lxml_get_method_context(pg, cursor); 1123 break; 1124 1125 case SC_PROPVAL: 1126 (void) lxml_get_propval(pg, cursor); 1127 break; 1128 1129 case SC_PROPERTY: 1130 (void) lxml_get_property(pg, cursor); 1131 break; 1132 1133 default: 1134 uu_die(gettext("illegal element \"%s\" on " 1135 "execution method \"%s\"\n"), cursor->name, 1136 pg->sc_pgroup_name); 1137 break; 1138 } 1139 } 1140 1141 delete = xmlGetProp(emeth, (xmlChar *)delete_attr); 1142 pg->sc_pgroup_delete = (xmlStrcmp(delete, (xmlChar *)true) == 0); 1143 xmlFree(delete); 1144 1145 return (0); 1146 } 1147 1148 static int 1149 lxml_get_dependency(entity_t *entity, xmlNodePtr dependency) 1150 { 1151 pgroup_t *pg; 1152 property_t *p; 1153 xmlNodePtr cursor; 1154 xmlChar *name; 1155 xmlChar *delete; 1156 1157 /* 1158 * dependency attributes: 1159 * name: string 1160 * grouping: require_all | require_any | exclude_all | optional_all 1161 * reset_on: string (error | restart | refresh | none) 1162 * type: service / path /host 1163 */ 1164 1165 if (entity->sc_op == SVCCFG_OP_APPLY) 1166 lxml_validate_element(dependency); 1167 1168 name = xmlGetProp(dependency, (xmlChar *)name_attr); 1169 pg = internal_pgroup_find_or_create(entity, (char *)name, 1170 (char *)SCF_GROUP_DEPENDENCY); 1171 xmlFree(name); 1172 1173 if (new_str_prop_from_attr(pg, SCF_PROPERTY_TYPE, SCF_TYPE_ASTRING, 1174 dependency, type_attr) != 0) 1175 return (-1); 1176 1177 if (new_str_prop_from_attr(pg, SCF_PROPERTY_RESTART_ON, 1178 SCF_TYPE_ASTRING, dependency, "restart_on") != 0) 1179 return (-1); 1180 1181 if (new_str_prop_from_attr(pg, SCF_PROPERTY_GROUPING, SCF_TYPE_ASTRING, 1182 dependency, "grouping") != 0) 1183 return (-1); 1184 1185 p = internal_property_create(SCF_PROPERTY_ENTITIES, SCF_TYPE_FMRI, 0); 1186 if (internal_attach_property(pg, p) != 0) 1187 return (-1); 1188 1189 for (cursor = dependency->xmlChildrenNode; cursor != NULL; 1190 cursor = cursor->next) { 1191 xmlChar *value; 1192 value_t *v; 1193 1194 if (lxml_ignorable_block(cursor)) 1195 continue; 1196 1197 switch (lxml_xlate_element(cursor->name)) { 1198 case SC_STABILITY: 1199 if (lxml_get_pgroup_stability(pg, cursor) != 0) 1200 return (-1); 1201 break; 1202 1203 case SC_SERVICE_FMRI: 1204 value = xmlGetProp(cursor, (xmlChar *)value_attr); 1205 if (value != NULL) { 1206 if (lxml_validate_string_value(SCF_TYPE_FMRI, 1207 (char *)value) != 0) 1208 uu_die(gettext("illegal value \"%s\" " 1209 "for %s (%s)\n"), (char *)value, 1210 lxml_prop_types[SC_FMRI], 1211 (scf_error()) ? 1212 scf_strerror(scf_error()) : 1213 gettext("Illegal format")); 1214 v = internal_value_new(); 1215 v->sc_type = SCF_TYPE_FMRI; 1216 v->sc_u.sc_string = (char *)value; 1217 internal_attach_value(p, v); 1218 } 1219 1220 break; 1221 1222 case SC_PROPVAL: 1223 (void) lxml_get_propval(pg, cursor); 1224 break; 1225 1226 case SC_PROPERTY: 1227 (void) lxml_get_property(pg, cursor); 1228 break; 1229 1230 default: 1231 uu_die(gettext("illegal element \"%s\" on " 1232 "dependency group \"%s\"\n"), cursor->name, name); 1233 break; 1234 } 1235 } 1236 1237 delete = xmlGetProp(dependency, (xmlChar *)delete_attr); 1238 pg->sc_pgroup_delete = (xmlStrcmp(delete, (xmlChar *)true) == 0); 1239 xmlFree(delete); 1240 1241 return (0); 1242 } 1243 1244 /* 1245 * Dependents are hairy. They should cause a dependency pg to be created in 1246 * another service, but we can't do that here; we'll have to wait until the 1247 * import routines. So for now we'll add the dependency group that should go 1248 * in the other service to the entity's dependent list. 1249 */ 1250 static int 1251 lxml_get_dependent(entity_t *entity, xmlNodePtr dependent) 1252 { 1253 xmlChar *name, *or; 1254 xmlNodePtr sf; 1255 xmlChar *fmri, *delete; 1256 pgroup_t *pg; 1257 property_t *p; 1258 xmlNodePtr n; 1259 char *myfmri; 1260 1261 if (entity->sc_op == SVCCFG_OP_APPLY) 1262 lxml_validate_element(dependent); 1263 1264 name = xmlGetProp(dependent, (xmlChar *)name_attr); 1265 1266 if (internal_pgroup_find(entity, (char *)name, NULL) != NULL) { 1267 semerr(gettext("Property group and dependent of entity %s " 1268 "have same name \"%s\".\n"), entity->sc_name, name); 1269 xmlFree(name); 1270 return (-1); 1271 } 1272 1273 or = xmlGetProp(dependent, (xmlChar *)override_attr); 1274 1275 pg = internal_pgroup_new(); 1276 pg->sc_pgroup_name = (char *)name; 1277 pg->sc_pgroup_type = (char *)SCF_GROUP_DEPENDENCY; 1278 pg->sc_pgroup_override = (xmlStrcmp(or, (xmlChar *)true) == 0); 1279 xmlFree(or); 1280 if (internal_attach_dependent(entity, pg) != 0) { 1281 xmlFree(name); 1282 internal_pgroup_free(pg); 1283 return (-1); 1284 } 1285 1286 for (sf = dependent->children; sf != NULL; sf = sf->next) 1287 if (xmlStrcmp(sf->name, (xmlChar *)"service_fmri") == 0) 1288 break; 1289 assert(sf != NULL); 1290 fmri = xmlGetProp(sf, (xmlChar *)value_attr); 1291 pg->sc_pgroup_fmri = (char *)fmri; 1292 1293 if (new_str_prop_from_attr(pg, SCF_PROPERTY_RESTART_ON, 1294 SCF_TYPE_ASTRING, dependent, "restart_on") != 0) 1295 return (-1); 1296 1297 if (new_str_prop_from_attr(pg, SCF_PROPERTY_GROUPING, SCF_TYPE_ASTRING, 1298 dependent, "grouping") != 0) 1299 return (-1); 1300 1301 myfmri = safe_malloc(max_scf_fmri_len + 1); 1302 if (entity->sc_etype == SVCCFG_SERVICE_OBJECT) { 1303 if (snprintf(myfmri, max_scf_fmri_len + 1, "svc:/%s", 1304 entity->sc_name) < 0) 1305 bad_error("snprintf", errno); 1306 } else { 1307 assert(entity->sc_etype == SVCCFG_INSTANCE_OBJECT); 1308 if (snprintf(myfmri, max_scf_fmri_len + 1, "svc:/%s:%s", 1309 entity->sc_parent->sc_name, entity->sc_name) < 0) 1310 bad_error("snprintf", errno); 1311 } 1312 1313 p = internal_property_create(SCF_PROPERTY_ENTITIES, SCF_TYPE_FMRI, 1, 1314 myfmri); 1315 if (internal_attach_property(pg, p) != 0) 1316 return (-1); 1317 1318 /* Create a property to serve as a do-not-export flag. */ 1319 p = internal_property_create("external", SCF_TYPE_BOOLEAN, 1, 1320 (uint64_t)1); 1321 if (internal_attach_property(pg, p) != 0) 1322 return (-1); 1323 1324 for (n = sf->next; n != NULL; n = n->next) { 1325 if (lxml_ignorable_block(n)) 1326 continue; 1327 1328 switch (lxml_xlate_element(n->name)) { 1329 case SC_STABILITY: 1330 if (new_str_prop_from_attr(pg, 1331 SCF_PROPERTY_ENTITY_STABILITY, SCF_TYPE_ASTRING, n, 1332 value_attr) != 0) 1333 return (-1); 1334 break; 1335 1336 case SC_PROPVAL: 1337 (void) lxml_get_propval(pg, n); 1338 break; 1339 1340 case SC_PROPERTY: 1341 (void) lxml_get_property(pg, n); 1342 break; 1343 1344 default: 1345 uu_die(gettext("unexpected element %s.\n"), n->name); 1346 } 1347 } 1348 1349 /* Go back and fill in defaults. */ 1350 if (internal_property_find(pg, SCF_PROPERTY_TYPE) == NULL) { 1351 p = internal_property_create(SCF_PROPERTY_TYPE, 1352 SCF_TYPE_ASTRING, 1, "service"); 1353 if (internal_attach_property(pg, p) != 0) 1354 return (-1); 1355 } 1356 1357 delete = xmlGetProp(dependent, (xmlChar *)delete_attr); 1358 pg->sc_pgroup_delete = (xmlStrcmp(delete, (xmlChar *)true) == 0); 1359 xmlFree(delete); 1360 1361 pg = internal_pgroup_find_or_create(entity, "dependents", 1362 (char *)scf_group_framework); 1363 p = internal_property_create((char *)name, SCF_TYPE_FMRI, 1, fmri); 1364 if (internal_attach_property(pg, p) != 0) 1365 return (-1); 1366 1367 return (0); 1368 } 1369 1370 static int 1371 lxml_get_entity_stability(entity_t *entity, xmlNodePtr rstr) 1372 { 1373 pgroup_t *pg; 1374 property_t *p; 1375 xmlChar *stabval; 1376 1377 if (((stabval = xmlGetProp(rstr, (xmlChar *)value_attr)) == NULL) || 1378 (*stabval == 0)) { 1379 uu_warn(gettext("no stability value found\n")); 1380 stabval = (xmlChar *)safe_strdup("External"); 1381 } 1382 1383 pg = internal_pgroup_find_or_create(entity, (char *)scf_pg_general, 1384 (char *)scf_group_framework); 1385 1386 p = internal_property_create(SCF_PROPERTY_ENTITY_STABILITY, 1387 SCF_TYPE_ASTRING, 1, stabval); 1388 1389 return (internal_attach_property(pg, p)); 1390 } 1391 1392 static int 1393 lxml_get_restarter(entity_t *entity, xmlNodePtr rstr) 1394 { 1395 pgroup_t *pg; 1396 property_t *p; 1397 xmlChar *restarter; 1398 xmlNode *cursor; 1399 int r; 1400 1401 /* 1402 * Go find child. Child is a service_fmri element. value attribute 1403 * contains restarter FMRI. 1404 */ 1405 1406 pg = internal_pgroup_find_or_create(entity, (char *)scf_pg_general, 1407 (char *)scf_group_framework); 1408 1409 /* 1410 * Walk its child elements, as appropriate. 1411 */ 1412 for (cursor = rstr->xmlChildrenNode; cursor != NULL; 1413 cursor = cursor->next) { 1414 if (lxml_ignorable_block(cursor)) 1415 continue; 1416 1417 switch (lxml_xlate_element(cursor->name)) { 1418 case SC_SERVICE_FMRI: 1419 restarter = xmlGetProp(cursor, (xmlChar *)value_attr); 1420 break; 1421 default: 1422 uu_die(gettext("illegal element \"%s\" on restarter " 1423 "element for \"%s\"\n"), cursor->name, 1424 entity->sc_name); 1425 break; 1426 } 1427 } 1428 1429 p = internal_property_create(SCF_PROPERTY_RESTARTER, SCF_TYPE_FMRI, 1, 1430 restarter); 1431 1432 r = internal_attach_property(pg, p); 1433 if (r != 0) { 1434 internal_property_free(p); 1435 return (-1); 1436 } 1437 1438 return (0); 1439 } 1440 1441 static void 1442 lxml_get_paramval(pgroup_t *pgrp, const char *propname, xmlNodePtr pval) 1443 { 1444 property_t *p; 1445 char *value; 1446 char *prop; 1447 1448 prop = safe_strdup(propname); 1449 1450 value = (char *)xmlGetProp(pval, (xmlChar *)value_attr); 1451 if (value == NULL || *value == '\0') 1452 uu_die(gettext("property value missing for property '%s/%s'\n"), 1453 pgrp->sc_pgroup_name, propname); 1454 p = internal_property_create(prop, SCF_TYPE_ASTRING, 1, value); 1455 1456 (void) internal_attach_property(pgrp, p); 1457 } 1458 1459 static void 1460 lxml_get_parameter(pgroup_t *pgrp, const char *propname, xmlNodePtr param) 1461 { 1462 property_t *p = internal_property_new(); 1463 1464 p->sc_property_name = safe_strdup(propname); 1465 p->sc_value_type = SCF_TYPE_ASTRING; 1466 1467 (void) lxml_get_value(p, SC_ASTRING, param); 1468 1469 (void) internal_attach_property(pgrp, p); 1470 } 1471 1472 static void 1473 lxml_get_type(pgroup_t *pgrp, xmlNodePtr type) 1474 { 1475 property_t *p; 1476 xmlChar *name; 1477 xmlChar *active; 1478 xmlNodePtr cursor; 1479 uint64_t active_val; 1480 size_t sz = max_scf_name_len + 1; 1481 char *propname = safe_malloc(sz); 1482 1483 if (pgrp->sc_parent->sc_op == SVCCFG_OP_APPLY) 1484 lxml_validate_element(type); 1485 1486 name = xmlGetProp(type, (xmlChar *)name_attr); 1487 if (name == NULL || *name == '\0') 1488 uu_die(gettext("attribute name missing in element 'type'\n")); 1489 1490 for (cursor = type->xmlChildrenNode; cursor != NULL; 1491 cursor = cursor->next) { 1492 xmlChar *pname; 1493 1494 if (lxml_ignorable_block(cursor)) 1495 continue; 1496 1497 pname = xmlGetProp(cursor, (xmlChar *)name_attr); 1498 if (pname == NULL || *pname == '\0') 1499 uu_die(gettext( 1500 "attribute name missing in sub-element of type\n")); 1501 1502 if (snprintf(propname, sz, "%s,%s", (char *)name, 1503 (char *)pname) >= sz) 1504 uu_die(gettext("name '%s,%s' is too long\n"), 1505 (char *)name, (char *)pname); 1506 xmlFree(pname); 1507 1508 switch (lxml_xlate_element(cursor->name)) { 1509 case SC_PARAMETER: 1510 lxml_get_parameter(pgrp, propname, cursor); 1511 break; 1512 1513 case SC_PARAMVAL: 1514 lxml_get_paramval(pgrp, propname, cursor); 1515 break; 1516 1517 default: 1518 uu_die(gettext("unknown element %s\n"), cursor->name); 1519 } 1520 } 1521 1522 active = xmlGetProp(type, (xmlChar *)active_attr); 1523 if (active == NULL || strcmp(true, (const char *)active) == 0) 1524 active_val = 1; 1525 else 1526 active_val = 0; 1527 xmlFree(active); 1528 1529 if (snprintf(propname, sz, "%s,%s", (char *)name, 1530 SCF_PROPERTY_ACTIVE_POSTFIX) >= sz) 1531 uu_die(gettext("name '%s,%s' is too long\n"), 1532 (char *)name, SCF_PROPERTY_ACTIVE_POSTFIX); 1533 1534 p = internal_property_create(propname, SCF_TYPE_BOOLEAN, 1, active_val); 1535 1536 (void) internal_attach_property(pgrp, p); 1537 1538 xmlFree(name); 1539 } 1540 1541 static void 1542 lxml_get_event(entity_t *entity, const char *pgname, xmlNodePtr np) 1543 { 1544 xmlNodePtr cursor; 1545 pgroup_t *pgrp; 1546 1547 pgrp = internal_pgroup_find_or_create(entity, pgname, 1548 SCF_NOTIFY_PARAMS_PG_TYPE); 1549 for (cursor = np->xmlChildrenNode; cursor != NULL; 1550 cursor = cursor->next) { 1551 if (lxml_ignorable_block(cursor)) 1552 continue; 1553 1554 switch (lxml_xlate_element(cursor->name)) { 1555 case SC_EVENT: 1556 continue; 1557 1558 case SC_TYPE: 1559 lxml_get_type(pgrp, cursor); 1560 break; 1561 1562 default: 1563 uu_warn(gettext("illegal element '%s' on " 1564 "notification parameters\n"), cursor->name); 1565 } 1566 } 1567 } 1568 1569 static int 1570 lxml_get_notification_parameters(entity_t *entity, xmlNodePtr np) 1571 { 1572 char *event = NULL; 1573 char **pgs = NULL; 1574 char **p; 1575 char *pgname = NULL; 1576 xmlNodePtr cursor; 1577 int32_t tset, t; 1578 size_t sz = max_scf_name_len + 1; 1579 int count; 1580 int r = -1; 1581 1582 for (count = 0, cursor = np->xmlChildrenNode; cursor != NULL; 1583 cursor = cursor->next) { 1584 if (lxml_ignorable_block(cursor)) 1585 continue; 1586 1587 if (lxml_xlate_element(cursor->name) == SC_EVENT) { 1588 xmlChar *s; 1589 1590 count++; 1591 if (count > 1) 1592 uu_die(gettext("Can't have more than 1 element " 1593 "event in a notification parameter\n")); 1594 s = xmlGetProp(cursor, (xmlChar *)value_attr); 1595 if (s == NULL || (event = strdup((char *)s)) == NULL) 1596 uu_die(gettext("couldn't allocate memory")); 1597 xmlFree(s); 1598 } 1599 } 1600 1601 pgs = tokenize(event, ","); 1602 1603 switch (tset = check_tokens(pgs)) { 1604 case INVALID_TOKENS: 1605 uu_die(gettext("Invalid input.\n")); 1606 /*NOTREACHED*/ 1607 case MIXED_TOKENS: 1608 semerr(gettext("Can't mix SMF and FMA event definitions\n")); 1609 goto out; 1610 case FMA_TOKENS: 1611 /* make sure this is SCF_NOTIFY_PARAMS_INST */ 1612 if (entity->sc_etype != SVCCFG_INSTANCE_OBJECT || 1613 strcmp(entity->sc_fmri, SCF_NOTIFY_PARAMS_INST) != 0) { 1614 semerr(gettext( 1615 "Non-SMF transition events must go to %s\n"), 1616 SCF_NOTIFY_PARAMS_INST); 1617 goto out; 1618 } 1619 pgname = safe_malloc(sz); 1620 for (p = pgs; *p; ++p) { 1621 if (snprintf(pgname, sz, "%s,%s", de_tag(*p), 1622 SCF_NOTIFY_PG_POSTFIX) >= sz) 1623 uu_die(gettext("event name too long: %s\n"), 1624 *p); 1625 1626 lxml_get_event(entity, pgname, np); 1627 } 1628 break; 1629 1630 default: /* smf state transition tokens */ 1631 if (entity->sc_etype == SVCCFG_SERVICE_OBJECT && 1632 strcmp(entity->sc_fmri, SCF_SERVICE_GLOBAL) == 0) { 1633 semerr(gettext( 1634 "Can't set events for global service\n")); 1635 goto out; 1636 } 1637 for (t = 0x1; t < SCF_STATE_ALL; t <<= 1) { 1638 if (t & tset) { 1639 lxml_get_event(entity, tset_to_string(t), np); 1640 } 1641 if ((t << 16) & tset) { 1642 lxml_get_event(entity, tset_to_string(t << 16), 1643 np); 1644 } 1645 } 1646 } 1647 1648 r = 0; 1649 out: 1650 free(pgname); 1651 free(pgs); 1652 free(event); 1653 1654 return (r); 1655 } 1656 1657 /* 1658 * Add a property containing the localized text from the manifest. The 1659 * property is added to the property group at pg. The name of the created 1660 * property is based on the format at pn_format. This is an snprintf(3C) 1661 * format containing a single %s conversion specification. At conversion 1662 * time, the %s is replaced by the locale designation. 1663 * 1664 * source is the source element and it is only used for error messages. 1665 */ 1666 static int 1667 lxml_get_loctext(entity_t *service, pgroup_t *pg, xmlNodePtr loctext, 1668 const char *pn_format, const char *source) 1669 { 1670 int extra; 1671 xmlNodePtr cursor; 1672 xmlChar *val; 1673 char *stripped, *cp; 1674 property_t *p; 1675 char *prop_name; 1676 int r; 1677 1678 if (((val = xmlGetProp(loctext, (xmlChar *)xml_lang_attr)) == NULL) || 1679 (*val == 0)) { 1680 if (((val = xmlGetProp(loctext, 1681 (xmlChar *)lang_attr)) == NULL) || (*val == 0)) { 1682 val = (xmlChar *)"unknown"; 1683 } 1684 } 1685 1686 _scf_sanitize_locale((char *)val); 1687 prop_name = safe_malloc(max_scf_name_len + 1); 1688 if ((extra = snprintf(prop_name, max_scf_name_len + 1, pn_format, 1689 val)) >= max_scf_name_len + 1) { 1690 extra -= max_scf_name_len; 1691 uu_die(gettext("%s attribute is %d characters too long for " 1692 "%s in %s\n"), 1693 xml_lang_attr, extra, source, service->sc_name); 1694 } 1695 xmlFree(val); 1696 1697 for (cursor = loctext->xmlChildrenNode; cursor != NULL; 1698 cursor = cursor->next) { 1699 if (strcmp("text", (const char *)cursor->name) == 0) { 1700 break; 1701 } else if (strcmp("comment", (const char *)cursor->name) != 0) { 1702 uu_die(gettext("illegal element \"%s\" on loctext " 1703 "element for \"%s\"\n"), cursor->name, 1704 service->sc_name); 1705 } 1706 } 1707 1708 if (cursor == NULL) { 1709 uu_die(gettext("loctext element has no content for \"%s\"\n"), 1710 service->sc_name); 1711 } 1712 1713 /* 1714 * Remove leading and trailing whitespace. 1715 */ 1716 stripped = safe_strdup((const char *)cursor->content); 1717 1718 for (; isspace(*stripped); stripped++) 1719 ; 1720 for (cp = stripped + strlen(stripped) - 1; isspace(*cp); cp--) 1721 ; 1722 *(cp + 1) = '\0'; 1723 1724 p = internal_property_create(prop_name, SCF_TYPE_USTRING, 1, 1725 stripped); 1726 1727 r = internal_attach_property(pg, p); 1728 if (r != 0) { 1729 internal_property_free(p); 1730 free(prop_name); 1731 } 1732 1733 return (r); 1734 } 1735 1736 /* 1737 * This function processes all loctext elements in the current XML element 1738 * designated by container. A property is created for each loctext element 1739 * and added to the property group at pg. The name of the property is 1740 * derived from the loctext language designation using the format at 1741 * pn_format. pn_format should be an snprintf format string containing one 1742 * %s which is replaced by the language designation. 1743 * 1744 * The function returns 0 on success and -1 if it is unable to attach the 1745 * newly created property to pg. 1746 */ 1747 static int 1748 lxml_get_all_loctext(entity_t *service, pgroup_t *pg, xmlNodePtr container, 1749 const char *pn_format, const char *source) 1750 { 1751 xmlNodePtr cursor; 1752 1753 /* 1754 * Iterate through one or more loctext elements. The locale is 1755 * used to generate the property name; the contents are the ustring 1756 * value for the property. 1757 */ 1758 for (cursor = container->xmlChildrenNode; cursor != NULL; 1759 cursor = cursor->next) { 1760 if (lxml_ignorable_block(cursor)) 1761 continue; 1762 1763 switch (lxml_xlate_element(cursor->name)) { 1764 case SC_LOCTEXT: 1765 if (lxml_get_loctext(service, pg, cursor, pn_format, 1766 source)) 1767 return (-1); 1768 break; 1769 default: 1770 uu_die(gettext("illegal element \"%s\" on %s element " 1771 "for \"%s\"\n"), cursor->name, container->name, 1772 service->sc_name); 1773 break; 1774 } 1775 } 1776 1777 return (0); 1778 } 1779 1780 /* 1781 * Obtain the specified cardinality attribute and place it in a property 1782 * named prop_name. The converted attribute is placed at *value, and the 1783 * newly created property is returned to propp. NULL is returned to propp 1784 * if the attribute is not provided in the manifest. 1785 * 1786 * 0 is returned upon success, and -1 indicates that the manifest contained 1787 * an invalid cardinality value. 1788 */ 1789 static int 1790 lxml_get_cardinality_attribute(entity_t *service, xmlNodePtr cursor, 1791 const char *attr_name, const char *prop_name, uint64_t *value, 1792 property_t **propp) 1793 { 1794 char *c; 1795 property_t *p; 1796 xmlChar *val; 1797 uint64_t count; 1798 char *endptr; 1799 1800 *propp = NULL; 1801 val = xmlGetProp(cursor, (xmlChar *)attr_name); 1802 if (val == NULL) 1803 return (0); 1804 if (*val == 0) { 1805 xmlFree(val); 1806 return (0); 1807 } 1808 1809 /* 1810 * Make sure that the string at val doesn't have a leading minus 1811 * sign. The strtoull() call below does not catch this problem. 1812 */ 1813 for (c = (char *)val; *c != 0; c++) { 1814 if (isspace(*c)) 1815 continue; 1816 if (isdigit(*c)) 1817 break; 1818 semerr(gettext("\"%c\" is not a legal character in the %s " 1819 "attribute of the %s element in %s.\n"), *c, 1820 attr_name, prop_name, service->sc_name); 1821 xmlFree(val); 1822 return (-1); 1823 } 1824 errno = 0; 1825 count = strtoull((char *)val, &endptr, 10); 1826 if (errno != 0 || endptr == (char *)val || *endptr) { 1827 semerr(gettext("\"%s\" is not a legal number for the %s " 1828 "attribute of the %s element in %s.\n"), (char *)val, 1829 attr_name, prop_name, service->sc_name); 1830 xmlFree(val); 1831 return (-1); 1832 } 1833 1834 xmlFree(val); 1835 1836 /* Value is valid. Create the property. */ 1837 p = internal_property_create(prop_name, SCF_TYPE_COUNT, 1, count); 1838 *value = count; 1839 *propp = p; 1840 return (0); 1841 } 1842 1843 /* 1844 * The cardinality is specified by two attributes max and min at cursor. 1845 * Both are optional, but if present they must be unsigned integers. 1846 */ 1847 static int 1848 lxml_get_tm_cardinality(entity_t *service, pgroup_t *pg, xmlNodePtr cursor) 1849 { 1850 int min_attached = 0; 1851 int compare = 1; 1852 property_t *min_prop; 1853 property_t *max_prop; 1854 uint64_t max; 1855 uint64_t min; 1856 int r; 1857 1858 r = lxml_get_cardinality_attribute(service, cursor, min_attr, 1859 SCF_PROPERTY_TM_CARDINALITY_MIN, &min, &min_prop); 1860 if (r != 0) 1861 return (r); 1862 if (min_prop == NULL) 1863 compare = 0; 1864 r = lxml_get_cardinality_attribute(service, cursor, max_attr, 1865 SCF_PROPERTY_TM_CARDINALITY_MAX, &max, &max_prop); 1866 if (r != 0) 1867 goto errout; 1868 if ((max_prop != NULL) && (compare == 1)) { 1869 if (max < min) { 1870 semerr(gettext("Cardinality max is less than min for " 1871 "the %s element in %s.\n"), pg->sc_pgroup_name, 1872 service->sc_fmri); 1873 goto errout; 1874 } 1875 } 1876 1877 /* Attach the properties to the property group. */ 1878 if (min_prop) { 1879 if (internal_attach_property(pg, min_prop) == 0) { 1880 min_attached = 1; 1881 } else { 1882 goto errout; 1883 } 1884 } 1885 if (max_prop) { 1886 if (internal_attach_property(pg, max_prop) != 0) { 1887 if (min_attached) 1888 internal_detach_property(pg, min_prop); 1889 goto errout; 1890 } 1891 } 1892 return (0); 1893 1894 errout: 1895 if (min_prop) 1896 internal_property_free(min_prop); 1897 if (max_prop) 1898 internal_property_free(max_prop); 1899 return (-1); 1900 } 1901 1902 /* 1903 * Get the common_name which is present as localized text at common_name in 1904 * the manifest. The common_name is stored as the value of a property in 1905 * the property group whose name is SCF_PG_TM_COMMON_NAME and type is 1906 * SCF_GROUP_TEMPLATE. This property group will be created in service if 1907 * it is not already there. 1908 */ 1909 static int 1910 lxml_get_tm_common_name(entity_t *service, xmlNodePtr common_name) 1911 { 1912 pgroup_t *pg; 1913 1914 /* 1915 * Create the property group, if absent. 1916 */ 1917 pg = internal_pgroup_find_or_create(service, SCF_PG_TM_COMMON_NAME, 1918 SCF_GROUP_TEMPLATE); 1919 1920 return (lxml_get_all_loctext(service, pg, common_name, LOCALE_ONLY_FMT, 1921 "common_name")); 1922 } 1923 1924 /* 1925 * Get the description which is present as localized text at description in 1926 * the manifest. The description is stored as the value of a property in 1927 * the property group whose name is SCF_PG_TM_DESCRIPTION and type is 1928 * SCF_GROUP_TEMPLATE. This property group will be created in service if 1929 * it is not already there. 1930 */ 1931 static int 1932 lxml_get_tm_description(entity_t *service, xmlNodePtr description) 1933 { 1934 pgroup_t *pg; 1935 1936 /* 1937 * Create the property group, if absent. 1938 */ 1939 pg = internal_pgroup_find_or_create(service, SCF_PG_TM_DESCRIPTION, 1940 SCF_GROUP_TEMPLATE); 1941 1942 return (lxml_get_all_loctext(service, pg, description, 1943 LOCALE_ONLY_FMT, "description")); 1944 } 1945 1946 static char * 1947 lxml_label_to_groupname(const char *prefix, const char *in) 1948 { 1949 char *out, *cp; 1950 size_t len, piece_len; 1951 1952 out = uu_zalloc(2 * max_scf_name_len + 1); 1953 if (out == NULL) 1954 return (NULL); 1955 1956 (void) strlcpy(out, prefix, 2 * max_scf_name_len + 1); 1957 1958 len = strlcat(out, in, 2 * max_scf_name_len + 1); 1959 if (len > max_scf_name_len) { 1960 /* Use the first half and the second half. */ 1961 piece_len = (max_scf_name_len - 2) / 2; 1962 1963 (void) strncpy(out + piece_len, "..", 2); 1964 1965 (void) strcpy(out + piece_len + 2, out + (len - piece_len)); 1966 } 1967 1968 /* 1969 * Translate non-property characters to '_'. 1970 */ 1971 for (cp = out; *cp != '\0'; ++cp) { 1972 if (!(isalnum(*cp) || *cp == '_' || *cp == '-')) 1973 *cp = '_'; 1974 } 1975 1976 return (out); 1977 } 1978 1979 /* 1980 * If *p is NULL, astring_prop_value() first creates a property with the 1981 * name specified in prop_name. The address of the newly created property 1982 * is placed in *p. 1983 * 1984 * In either case, newly created property or existing property, a new 1985 * SCF_TYPE_ASTRING value will created and attached to the property at *p. 1986 * The value of the newly created property is prop_value. 1987 * 1988 * free_flag is used to indicate whether or not the memory at prop_value 1989 * should be freed when the property is freed by a call to 1990 * internal_property_free(). 1991 */ 1992 static void 1993 astring_prop_value(property_t **p, const char *prop_name, char *prop_value, 1994 boolean_t free_flag) 1995 { 1996 value_t *v; 1997 1998 if (*p == NULL) { 1999 /* Create the property */ 2000 *p = internal_property_new(); 2001 (*p)->sc_property_name = (char *)prop_name; 2002 (*p)->sc_value_type = SCF_TYPE_ASTRING; 2003 } 2004 2005 /* Add the property value to the property's list of values. */ 2006 v = internal_value_new(); 2007 v->sc_type = SCF_TYPE_ASTRING; 2008 if (free_flag == B_TRUE) 2009 v->sc_free = lxml_free_str; 2010 v->sc_u.sc_string = prop_value; 2011 internal_attach_value(*p, v); 2012 } 2013 2014 /* 2015 * If p points to a null pointer, create an internal_separators property 2016 * saving the address at p. For each character at seps create a property 2017 * value and attach it to the property at p. 2018 */ 2019 static void 2020 seps_to_prop_values(property_t **p, xmlChar *seps) 2021 { 2022 value_t *v; 2023 char val_str[2]; 2024 2025 if (*p == NULL) { 2026 *p = internal_property_new(); 2027 (*p)->sc_property_name = 2028 (char *)SCF_PROPERTY_INTERNAL_SEPARATORS; 2029 (*p)->sc_value_type = SCF_TYPE_ASTRING; 2030 } 2031 2032 /* Add the values to the property's list. */ 2033 val_str[1] = 0; /* Terminate the string. */ 2034 for (; *seps != 0; seps++) { 2035 v = internal_value_new(); 2036 v->sc_type = (*p)->sc_value_type; 2037 v->sc_free = lxml_free_str; 2038 val_str[0] = *seps; 2039 v->sc_u.sc_string = safe_strdup(val_str); 2040 internal_attach_value(*p, v); 2041 } 2042 } 2043 2044 /* 2045 * Create an internal_separators property and attach it to the property 2046 * group at pg. The separator characters are provided in the text nodes 2047 * that are the children of seps. Each separator character is stored as a 2048 * property value in the internal_separators property. 2049 */ 2050 static int 2051 lxml_get_tm_internal_seps(entity_t *service, pgroup_t *pg, xmlNodePtr seps) 2052 { 2053 xmlNodePtr cursor; 2054 property_t *prop = NULL; 2055 int r; 2056 2057 for (cursor = seps->xmlChildrenNode; cursor != NULL; 2058 cursor = cursor->next) { 2059 if (strcmp("text", (const char *)cursor->name) == 0) { 2060 seps_to_prop_values(&prop, cursor->content); 2061 } else if (strcmp("comment", (const char *)cursor->name) != 0) { 2062 uu_die(gettext("illegal element \"%s\" on %s element " 2063 "for \"%s\"\n"), cursor->name, seps->name, 2064 service->sc_name); 2065 } 2066 } 2067 if (prop == NULL) { 2068 semerr(gettext("The %s element in %s had an empty list of " 2069 "separators.\n"), (const char *)seps->name, 2070 service->sc_name); 2071 return (-1); 2072 } 2073 r = internal_attach_property(pg, prop); 2074 if (r != 0) 2075 internal_property_free(prop); 2076 return (r); 2077 } 2078 2079 static int 2080 lxml_get_tm_manpage(entity_t *service, xmlNodePtr manpage) 2081 { 2082 pgroup_t *pg; 2083 char *pgname; 2084 char *name; 2085 xmlChar *title; 2086 xmlChar *section; 2087 2088 /* 2089 * Fetch title and section attributes, convert to something sanitized, 2090 * and create property group. 2091 */ 2092 title = xmlGetProp(manpage, (xmlChar *)title_attr); 2093 if (title == NULL) 2094 return (-1); 2095 section = xmlGetProp(manpage, (xmlChar *)section_attr); 2096 if (section == NULL) { 2097 xmlFree(title); 2098 return (-1); 2099 } 2100 2101 name = safe_malloc(max_scf_name_len + 1); 2102 2103 /* Find existing property group with underscore separators */ 2104 (void) snprintf(name, max_scf_name_len + 1, "%s_%s", title, section); 2105 pgname = lxml_label_to_groupname(SCF_PG_TM_MAN_PREFIX, name); 2106 pg = internal_pgroup_find(service, pgname, SCF_GROUP_TEMPLATE); 2107 2108 uu_free(pgname); 2109 (void) snprintf(name, max_scf_name_len + 1, "%s%s", title, section); 2110 pgname = lxml_label_to_groupname(SCF_PG_TM_MAN_PREFIX, name); 2111 2112 if (pg == NULL) { 2113 pg = internal_pgroup_find_or_create(service, pgname, 2114 SCF_GROUP_TEMPLATE); 2115 } else { 2116 /* Rename property group */ 2117 free((char *)pg->sc_pgroup_name); 2118 pg->sc_pgroup_name = safe_strdup(pgname); 2119 } 2120 2121 uu_free(pgname); 2122 free(name); 2123 xmlFree(section); 2124 xmlFree(title); 2125 2126 2127 /* 2128 * Each attribute is an astring property within the group. 2129 */ 2130 if (new_str_prop_from_attr(pg, SCF_PROPERTY_TM_TITLE, 2131 SCF_TYPE_ASTRING, manpage, title_attr) != 0 || 2132 new_str_prop_from_attr(pg, SCF_PROPERTY_TM_SECTION, 2133 SCF_TYPE_ASTRING, manpage, section_attr) != 0 || 2134 new_str_prop_from_attr(pg, SCF_PROPERTY_TM_MANPATH, 2135 SCF_TYPE_ASTRING, manpage, manpath_attr) != 0) 2136 return (-1); 2137 2138 return (0); 2139 } 2140 2141 static int 2142 lxml_get_tm_doclink(entity_t *service, xmlNodePtr doc_link) 2143 { 2144 pgroup_t *pg; 2145 char *pgname; 2146 xmlChar *name; 2147 2148 /* 2149 * Fetch name attribute, convert name to something sanitized, and create 2150 * property group. 2151 */ 2152 name = xmlGetProp(doc_link, (xmlChar *)name_attr); 2153 if (name == NULL) 2154 return (-1); 2155 2156 pgname = (char *)lxml_label_to_groupname(SCF_PG_TM_DOC_PREFIX, 2157 (const char *)name); 2158 2159 pg = internal_pgroup_find_or_create(service, pgname, 2160 (char *)SCF_GROUP_TEMPLATE); 2161 2162 uu_free(pgname); 2163 xmlFree(name); 2164 2165 /* 2166 * Each attribute is an astring property within the group. 2167 */ 2168 if (new_str_prop_from_attr(pg, SCF_PROPERTY_TM_NAME, SCF_TYPE_ASTRING, 2169 doc_link, name_attr) != 0 || 2170 new_str_prop_from_attr(pg, SCF_PROPERTY_TM_URI, SCF_TYPE_ASTRING, 2171 doc_link, uri_attr) != 0) 2172 return (-1); 2173 2174 return (0); 2175 } 2176 2177 static int 2178 lxml_get_tm_documentation(entity_t *service, xmlNodePtr documentation) 2179 { 2180 xmlNodePtr cursor; 2181 2182 for (cursor = documentation->xmlChildrenNode; cursor != NULL; 2183 cursor = cursor->next) { 2184 if (lxml_ignorable_block(cursor)) 2185 continue; 2186 2187 switch (lxml_xlate_element(cursor->name)) { 2188 case SC_MANPAGE: 2189 (void) lxml_get_tm_manpage(service, cursor); 2190 break; 2191 case SC_DOC_LINK: 2192 (void) lxml_get_tm_doclink(service, cursor); 2193 break; 2194 default: 2195 uu_die(gettext("illegal element \"%s\" on template " 2196 "for service \"%s\"\n"), 2197 cursor->name, service->sc_name); 2198 } 2199 } 2200 2201 return (0); 2202 } 2203 2204 static int 2205 lxml_get_prop_pattern_attributes(pgroup_t *pg, xmlNodePtr cursor) 2206 { 2207 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_TM_NAME, 2208 SCF_TYPE_ASTRING, cursor, name_attr, NULL) != 0) { 2209 return (-1); 2210 } 2211 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_TM_TYPE, 2212 SCF_TYPE_ASTRING, cursor, type_attr, "") != 0) { 2213 return (-1); 2214 } 2215 if (new_bool_prop_from_attr(pg, SCF_PROPERTY_TM_REQUIRED, cursor, 2216 required_attr) != 0) 2217 return (-1); 2218 return (0); 2219 } 2220 2221 static int 2222 lxml_get_tm_include_values(entity_t *service, pgroup_t *pg, 2223 xmlNodePtr include_values, const char *prop_name) 2224 { 2225 boolean_t attach_to_pg = B_FALSE; 2226 property_t *p; 2227 int r = 0; 2228 char *type; 2229 2230 /* Get the type attribute of the include_values element. */ 2231 type = (char *)xmlGetProp(include_values, (const xmlChar *)type_attr); 2232 if ((type == NULL) || (*type == 0)) { 2233 uu_die(gettext("%s element requires a %s attribute in the %s " 2234 "service.\n"), include_values->name, type_attr, 2235 service->sc_name); 2236 } 2237 2238 /* Add the type to the values of the prop_name property. */ 2239 p = internal_property_find(pg, prop_name); 2240 if (p == NULL) 2241 attach_to_pg = B_TRUE; 2242 astring_prop_value(&p, prop_name, type, B_FALSE); 2243 if (attach_to_pg == B_TRUE) { 2244 r = internal_attach_property(pg, p); 2245 if (r != 0) 2246 internal_property_free(p); 2247 } 2248 return (r); 2249 } 2250 2251 #define RC_MIN 0 2252 #define RC_MAX 1 2253 #define RC_COUNT 2 2254 2255 /* 2256 * Verify that the strings at min and max are valid numeric strings. Also 2257 * verify that max is numerically >= min. 2258 * 2259 * 0 is returned if the range is valid, and -1 is returned if it is not. 2260 */ 2261 static int 2262 verify_range(entity_t *service, xmlNodePtr range, char *min, char *max) 2263 { 2264 char *c; 2265 int i; 2266 int is_signed = 0; 2267 int inverted = 0; 2268 const char *limit[RC_COUNT]; 2269 char *strings[RC_COUNT]; 2270 uint64_t urange[RC_COUNT]; /* unsigned range. */ 2271 int64_t srange[RC_COUNT]; /* signed range. */ 2272 2273 strings[RC_MIN] = min; 2274 strings[RC_MAX] = max; 2275 limit[RC_MIN] = min_attr; 2276 limit[RC_MAX] = max_attr; 2277 2278 /* See if the range is signed. */ 2279 for (i = 0; (i < RC_COUNT) && (is_signed == 0); i++) { 2280 c = strings[i]; 2281 while (isspace(*c)) { 2282 c++; 2283 } 2284 if (*c == '-') 2285 is_signed = 1; 2286 } 2287 2288 /* Attempt to convert the strings. */ 2289 for (i = 0; i < RC_COUNT; i++) { 2290 errno = 0; 2291 if (is_signed) { 2292 srange[i] = strtoll(strings[i], &c, 0); 2293 } else { 2294 urange[i] = strtoull(strings[i], &c, 0); 2295 } 2296 if ((errno != 0) || (c == strings[i]) || (*c != 0)) { 2297 /* Conversion failed. */ 2298 uu_die(gettext("Unable to convert %s for the %s " 2299 "element in service %s.\n"), limit[i], 2300 (char *)range->name, service->sc_name); 2301 } 2302 } 2303 2304 /* Make sure that min is <= max */ 2305 if (is_signed) { 2306 if (srange[RC_MAX] < srange[RC_MIN]) 2307 inverted = 1; 2308 } else { 2309 if (urange[RC_MAX] < urange[RC_MIN]) 2310 inverted = 1; 2311 } 2312 if (inverted != 0) { 2313 semerr(gettext("Maximum less than minimum for the %s element " 2314 "in service %s.\n"), (char *)range->name, 2315 service->sc_name); 2316 return (-1); 2317 } 2318 2319 return (0); 2320 } 2321 2322 /* 2323 * This, function creates a property named prop_name. The range element 2324 * should have two attributes -- min and max. The property value then 2325 * becomes the concatenation of their value separated by a comma. The 2326 * property is then attached to the property group at pg. 2327 * 2328 * If pg already contains a property with a name of prop_name, it is only 2329 * necessary to create a new value and attach it to the existing property. 2330 */ 2331 static int 2332 lxml_get_tm_range(entity_t *service, pgroup_t *pg, xmlNodePtr range, 2333 const char *prop_name) 2334 { 2335 boolean_t attach_to_pg = B_FALSE; 2336 char *max; 2337 char *min; 2338 property_t *p; 2339 char *prop_value; 2340 int r = 0; 2341 2342 /* Get max and min from the XML description. */ 2343 max = (char *)xmlGetProp(range, (xmlChar *)max_attr); 2344 if ((max == NULL) || (*max == 0)) { 2345 uu_die(gettext("%s element is missing the %s attribute in " 2346 "service %s.\n"), (char *)range->name, max_attr, 2347 service->sc_name); 2348 } 2349 min = (char *)xmlGetProp(range, (xmlChar *)min_attr); 2350 if ((min == NULL) || (*min == 0)) { 2351 uu_die(gettext("%s element is missing the %s attribute in " 2352 "service %s.\n"), (char *)range->name, min_attr, 2353 service->sc_name); 2354 } 2355 if (verify_range(service, range, min, max) != 0) { 2356 xmlFree(min); 2357 xmlFree(max); 2358 return (-1); 2359 } 2360 2361 /* Property value is concatenation of min and max. */ 2362 prop_value = safe_malloc(max_scf_value_len + 1); 2363 if (snprintf(prop_value, max_scf_value_len + 1, "%s,%s", min, max) >= 2364 max_scf_value_len + 1) { 2365 uu_die(gettext("min and max are too long for the %s element " 2366 "of %s.\n"), (char *)range->name, service->sc_name); 2367 } 2368 xmlFree(min); 2369 xmlFree(max); 2370 2371 /* 2372 * If necessary create the property and attach it to the property 2373 * group. 2374 */ 2375 p = internal_property_find(pg, prop_name); 2376 if (p == NULL) 2377 attach_to_pg = B_TRUE; 2378 astring_prop_value(&p, prop_name, prop_value, B_TRUE); 2379 if (attach_to_pg == B_TRUE) { 2380 r = internal_attach_property(pg, p); 2381 if (r != 0) { 2382 internal_property_free(p); 2383 } 2384 } 2385 return (r); 2386 } 2387 2388 /* 2389 * Determine how many plain characters are represented by count Base32 2390 * encoded characters. 5 plain text characters are converted to 8 Base32 2391 * characters. 2392 */ 2393 static size_t 2394 encoded_count_to_plain(size_t count) 2395 { 2396 return (5 * ((count + 7) / 8)); 2397 } 2398 2399 /* 2400 * The value element contains 0 or 1 common_name element followed by 0 or 1 2401 * description element. It also has a required attribute called "name". 2402 * The common_name and description are stored as property values in pg. 2403 * The property names are: 2404 * value_<name>_common_name_<lang> 2405 * value_<name>_description_<lang> 2406 * 2407 * The <name> portion of the preceeding proper names requires more 2408 * explanation. Ideally it would just the name attribute of this value 2409 * element. Unfortunately, the name attribute can contain characters that 2410 * are not legal in a property name. Thus, we base 32 encode the name 2411 * attribute and use that for <name>. 2412 * 2413 * There are cases where the caller needs to know the name, so it is 2414 * returned through the name_value pointer if it is not NULL. 2415 * 2416 * Parameters: 2417 * service - Information about the service that is being 2418 * processed. This function only uses this parameter 2419 * for producing error messages. 2420 * 2421 * pg - The property group to receive the newly created 2422 * properties. 2423 * 2424 * value - Pointer to the value element in the XML tree. 2425 * 2426 * name_value - Address to receive the value of the name attribute. 2427 * The caller must free the memory. 2428 */ 2429 static int 2430 lxml_get_tm_value_element(entity_t *service, pgroup_t *pg, xmlNodePtr value, 2431 char **name_value) 2432 { 2433 char *common_name_fmt; 2434 xmlNodePtr cursor; 2435 char *description_fmt; 2436 char *encoded_value = NULL; 2437 size_t extra; 2438 char *value_name; 2439 int r = 0; 2440 2441 common_name_fmt = safe_malloc(max_scf_name_len + 1); 2442 description_fmt = safe_malloc(max_scf_name_len + 1); 2443 2444 /* 2445 * Get the value of our name attribute, so that we can use it to 2446 * construct property names. 2447 */ 2448 value_name = (char *)xmlGetProp(value, (xmlChar *)name_attr); 2449 /* The value name must be present, but it can be empty. */ 2450 if (value_name == NULL) { 2451 uu_die(gettext("%s element requires a %s attribute in the %s " 2452 "service.\n"), (char *)value->name, name_attr, 2453 service->sc_name); 2454 } 2455 2456 /* 2457 * The value_name may contain characters that are not valid in in a 2458 * property name. So we will encode value_name and then use the 2459 * encoded value in the property name. 2460 */ 2461 encoded_value = safe_malloc(max_scf_name_len + 1); 2462 if (scf_encode32(value_name, strlen(value_name), encoded_value, 2463 max_scf_name_len + 1, &extra, SCF_ENCODE32_PAD) != 0) { 2464 extra = encoded_count_to_plain(extra - max_scf_name_len); 2465 uu_die(gettext("Constructed property name is %u characters " 2466 "too long for value \"%s\" in the %s service.\n"), 2467 extra, value_name, service->sc_name); 2468 } 2469 if ((extra = snprintf(common_name_fmt, max_scf_name_len + 1, 2470 VALUE_COMMON_NAME_FMT, SCF_PROPERTY_TM_VALUE_PREFIX, 2471 encoded_value)) >= max_scf_name_len + 1) { 2472 extra = encoded_count_to_plain(extra - max_scf_name_len); 2473 uu_die(gettext("Name attribute is " 2474 "%u characters too long for %s in service %s\n"), 2475 extra, (char *)value->name, service->sc_name); 2476 } 2477 if ((extra = snprintf(description_fmt, max_scf_name_len + 1, 2478 VALUE_DESCRIPTION_FMT, SCF_PROPERTY_TM_VALUE_PREFIX, 2479 encoded_value)) >= max_scf_name_len + 1) { 2480 extra = encoded_count_to_plain(extra - max_scf_name_len); 2481 uu_die(gettext("Name attribute is " 2482 "%u characters too long for %s in service %s\n"), 2483 extra, (char *)value->name, service->sc_name); 2484 } 2485 2486 for (cursor = value->xmlChildrenNode; 2487 cursor != NULL; 2488 cursor = cursor->next) { 2489 if (lxml_ignorable_block(cursor)) 2490 continue; 2491 switch (lxml_xlate_element(cursor->name)) { 2492 case SC_COMMON_NAME: 2493 r = lxml_get_all_loctext(service, pg, cursor, 2494 common_name_fmt, (const char *)cursor->name); 2495 break; 2496 case SC_DESCRIPTION: 2497 r = lxml_get_all_loctext(service, pg, cursor, 2498 description_fmt, (const char *)cursor->name); 2499 break; 2500 default: 2501 uu_die(gettext("\"%s\" is an illegal element in %s " 2502 "of service %s\n"), (char *)cursor->name, 2503 (char *)value->name, service->sc_name); 2504 } 2505 if (r != 0) 2506 break; 2507 } 2508 2509 free(description_fmt); 2510 free(common_name_fmt); 2511 if (r == 0) { 2512 *name_value = safe_strdup(value_name); 2513 } 2514 xmlFree(value_name); 2515 free(encoded_value); 2516 return (r); 2517 } 2518 2519 static int 2520 lxml_get_tm_choices(entity_t *service, pgroup_t *pg, xmlNodePtr choices) 2521 { 2522 xmlNodePtr cursor; 2523 char *name_value; 2524 property_t *name_prop = NULL; 2525 int r = 0; 2526 2527 for (cursor = choices->xmlChildrenNode; 2528 (cursor != NULL) && (r == 0); 2529 cursor = cursor->next) { 2530 if (lxml_ignorable_block(cursor)) 2531 continue; 2532 switch (lxml_xlate_element(cursor->name)) { 2533 case SC_INCLUDE_VALUES: 2534 (void) lxml_get_tm_include_values(service, pg, cursor, 2535 SCF_PROPERTY_TM_CHOICES_INCLUDE_VALUES); 2536 break; 2537 case SC_RANGE: 2538 r = lxml_get_tm_range(service, pg, cursor, 2539 SCF_PROPERTY_TM_CHOICES_RANGE); 2540 if (r != 0) 2541 goto out; 2542 break; 2543 case SC_VALUE: 2544 r = lxml_get_tm_value_element(service, pg, cursor, 2545 &name_value); 2546 if (r == 0) { 2547 /* 2548 * There is no need to free the memory 2549 * associated with name_value, because the 2550 * property value will end up pointing to 2551 * the memory. 2552 */ 2553 astring_prop_value(&name_prop, 2554 SCF_PROPERTY_TM_CHOICES_NAME, name_value, 2555 B_TRUE); 2556 } else { 2557 goto out; 2558 } 2559 break; 2560 default: 2561 uu_die(gettext("%s is an invalid element of " 2562 "choices for service %s.\n"), cursor->name, 2563 service->sc_name); 2564 } 2565 } 2566 2567 out: 2568 /* Attach the name property if we created one. */ 2569 if ((r == 0) && (name_prop != NULL)) { 2570 r = internal_attach_property(pg, name_prop); 2571 } 2572 if ((r != 0) && (name_prop != NULL)) { 2573 internal_property_free(name_prop); 2574 } 2575 2576 return (r); 2577 } 2578 2579 static int 2580 lxml_get_tm_constraints(entity_t *service, pgroup_t *pg, xmlNodePtr constraints) 2581 { 2582 xmlNodePtr cursor; 2583 char *name_value; 2584 property_t *name_prop = NULL; 2585 int r = 0; 2586 2587 for (cursor = constraints->xmlChildrenNode; 2588 (cursor != NULL) && (r == 0); 2589 cursor = cursor->next) { 2590 if (lxml_ignorable_block(cursor)) 2591 continue; 2592 switch (lxml_xlate_element(cursor->name)) { 2593 case SC_RANGE: 2594 r = lxml_get_tm_range(service, pg, cursor, 2595 SCF_PROPERTY_TM_CONSTRAINT_RANGE); 2596 if (r != 0) 2597 goto out; 2598 break; 2599 case SC_VALUE: 2600 r = lxml_get_tm_value_element(service, pg, cursor, 2601 &name_value); 2602 if (r == 0) { 2603 /* 2604 * There is no need to free the memory 2605 * associated with name_value, because the 2606 * property value will end up pointing to 2607 * the memory. 2608 */ 2609 astring_prop_value(&name_prop, 2610 SCF_PROPERTY_TM_CONSTRAINT_NAME, name_value, 2611 B_TRUE); 2612 } else { 2613 goto out; 2614 } 2615 break; 2616 default: 2617 uu_die(gettext("%s is an invalid element of " 2618 "constraints for service %s.\n"), cursor->name, 2619 service->sc_name); 2620 } 2621 } 2622 2623 out: 2624 /* Attach the name property if we created one. */ 2625 if ((r == 0) && (name_prop != NULL)) { 2626 r = internal_attach_property(pg, name_prop); 2627 } 2628 if ((r != 0) && (name_prop != NULL)) { 2629 internal_property_free(name_prop); 2630 } 2631 2632 return (r); 2633 } 2634 2635 /* 2636 * The values element contains one or more value elements. 2637 */ 2638 static int 2639 lxml_get_tm_values(entity_t *service, pgroup_t *pg, xmlNodePtr values) 2640 { 2641 xmlNodePtr cursor; 2642 char *name_value; 2643 property_t *name_prop = NULL; 2644 int r = 0; 2645 2646 for (cursor = values->xmlChildrenNode; 2647 (cursor != NULL) && (r == 0); 2648 cursor = cursor->next) { 2649 if (lxml_ignorable_block(cursor)) 2650 continue; 2651 if (lxml_xlate_element(cursor->name) != SC_VALUE) { 2652 uu_die(gettext("\"%s\" is an illegal element in the " 2653 "%s element of %s\n"), (char *)cursor->name, 2654 (char *)values->name, service->sc_name); 2655 } 2656 r = lxml_get_tm_value_element(service, pg, cursor, &name_value); 2657 if (r == 0) { 2658 /* 2659 * There is no need to free the memory 2660 * associated with name_value, because the 2661 * property value will end up pointing to 2662 * the memory. 2663 */ 2664 astring_prop_value(&name_prop, 2665 SCF_PROPERTY_TM_VALUES_NAME, name_value, 2666 B_TRUE); 2667 } 2668 } 2669 2670 /* Attach the name property if we created one. */ 2671 if ((r == 0) && (name_prop != NULL)) { 2672 r = internal_attach_property(pg, name_prop); 2673 } 2674 if ((r != 0) && (name_prop != NULL)) { 2675 internal_property_free(name_prop); 2676 } 2677 2678 return (r); 2679 } 2680 2681 /* 2682 * This function processes a prop_pattern element within a pg_pattern XML 2683 * element. First it creates a property group to hold the prop_pattern 2684 * information. The name of this property group is the concatenation of: 2685 * - SCF_PG_TM_PROP_PATTERN_PREFIX 2686 * - The unique part of the property group name of the enclosing 2687 * pg_pattern. The property group name of the enclosing pg_pattern 2688 * is passed to us in pgpat_name. The unique part, is the part 2689 * following SCF_PG_TM_PG_PATTERN_PREFIX. 2690 * - The name of this prop_pattern element. 2691 * 2692 * After creating the property group, the prop_pattern attributes are saved 2693 * as properties in the PG. Finally, the prop_pattern elements are 2694 * processed and added to the PG. 2695 */ 2696 static int 2697 lxml_get_tm_prop_pattern(entity_t *service, xmlNodePtr prop_pattern, 2698 const char *pgpat_name) 2699 { 2700 xmlNodePtr cursor; 2701 int extra; 2702 pgroup_t *pg; 2703 property_t *p; 2704 char *pg_name; 2705 size_t prefix_len; 2706 xmlChar *prop_pattern_name; 2707 int r; 2708 const char *unique; 2709 value_t *v; 2710 2711 /* Find the unique part of the pg_pattern property group name. */ 2712 prefix_len = strlen(SCF_PG_TM_PG_PAT_BASE); 2713 assert(strncmp(pgpat_name, SCF_PG_TM_PG_PAT_BASE, prefix_len) == 0); 2714 unique = pgpat_name + prefix_len; 2715 2716 /* 2717 * We need to get the value of the name attribute first. The 2718 * prop_pattern name as well as the name of the enclosing 2719 * pg_pattern both constitute part of the name of the property 2720 * group that we will create. 2721 */ 2722 prop_pattern_name = xmlGetProp(prop_pattern, (xmlChar *)name_attr); 2723 if ((prop_pattern_name == NULL) || (*prop_pattern_name == 0)) { 2724 semerr(gettext("prop_pattern name is missing for %s\n"), 2725 service->sc_name); 2726 return (-1); 2727 } 2728 if (uu_check_name((const char *)prop_pattern_name, 2729 UU_NAME_DOMAIN) != 0) { 2730 semerr(gettext("prop_pattern name, \"%s\", for %s is not " 2731 "valid.\n"), prop_pattern_name, service->sc_name); 2732 xmlFree(prop_pattern_name); 2733 return (-1); 2734 } 2735 pg_name = safe_malloc(max_scf_name_len + 1); 2736 if ((extra = snprintf(pg_name, max_scf_name_len + 1, "%s%s_%s", 2737 SCF_PG_TM_PROP_PATTERN_PREFIX, unique, 2738 (char *)prop_pattern_name)) >= max_scf_name_len + 1) { 2739 uu_die(gettext("prop_pattern name, \"%s\", for %s is %d " 2740 "characters too long\n"), (char *)prop_pattern_name, 2741 service->sc_name, extra - max_scf_name_len); 2742 } 2743 2744 /* 2745 * Create the property group, the property referencing the pg_pattern 2746 * name, and add the prop_pattern attributes to the property group. 2747 */ 2748 pg = internal_pgroup_create_strict(service, pg_name, 2749 SCF_GROUP_TEMPLATE_PROP_PATTERN); 2750 if (pg == NULL) { 2751 uu_die(gettext("Property group for prop_pattern, \"%s\", " 2752 "already exists in %s\n"), prop_pattern_name, 2753 service->sc_name); 2754 } 2755 2756 p = internal_property_create(SCF_PROPERTY_TM_PG_PATTERN, 2757 SCF_TYPE_ASTRING, 1, safe_strdup(pgpat_name)); 2758 /* 2759 * Unfortunately, internal_property_create() does not set the free 2760 * function for the value, so we'll set it now. 2761 */ 2762 v = uu_list_first(p->sc_property_values); 2763 v->sc_free = lxml_free_str; 2764 if (internal_attach_property(pg, p) != 0) 2765 internal_property_free(p); 2766 2767 2768 r = lxml_get_prop_pattern_attributes(pg, prop_pattern); 2769 if (r != 0) 2770 goto out; 2771 2772 /* 2773 * Now process the elements of prop_pattern 2774 */ 2775 for (cursor = prop_pattern->xmlChildrenNode; 2776 cursor != NULL; 2777 cursor = cursor->next) { 2778 if (lxml_ignorable_block(cursor)) 2779 continue; 2780 2781 switch (lxml_xlate_element(cursor->name)) { 2782 case SC_CARDINALITY: 2783 r = lxml_get_tm_cardinality(service, pg, cursor); 2784 if (r != 0) 2785 goto out; 2786 break; 2787 case SC_CHOICES: 2788 r = lxml_get_tm_choices(service, pg, cursor); 2789 if (r != 0) 2790 goto out; 2791 break; 2792 case SC_COMMON_NAME: 2793 (void) lxml_get_all_loctext(service, pg, cursor, 2794 COMMON_NAME_FMT, (const char *)cursor->name); 2795 break; 2796 case SC_CONSTRAINTS: 2797 r = lxml_get_tm_constraints(service, pg, cursor); 2798 if (r != 0) 2799 goto out; 2800 break; 2801 case SC_DESCRIPTION: 2802 (void) lxml_get_all_loctext(service, pg, cursor, 2803 DESCRIPTION_FMT, (const char *)cursor->name); 2804 break; 2805 case SC_INTERNAL_SEPARATORS: 2806 r = lxml_get_tm_internal_seps(service, pg, cursor); 2807 if (r != 0) 2808 goto out; 2809 break; 2810 case SC_UNITS: 2811 (void) lxml_get_all_loctext(service, pg, cursor, 2812 UNITS_FMT, "units"); 2813 break; 2814 case SC_VALUES: 2815 (void) lxml_get_tm_values(service, pg, cursor); 2816 break; 2817 case SC_VISIBILITY: 2818 /* 2819 * The visibility element is empty, so we only need 2820 * to proccess the value attribute. 2821 */ 2822 (void) new_str_prop_from_attr(pg, 2823 SCF_PROPERTY_TM_VISIBILITY, SCF_TYPE_ASTRING, 2824 cursor, value_attr); 2825 break; 2826 default: 2827 uu_die(gettext("illegal element \"%s\" in prop_pattern " 2828 "for service \"%s\"\n"), cursor->name, 2829 service->sc_name); 2830 } 2831 } 2832 2833 out: 2834 xmlFree(prop_pattern_name); 2835 free(pg_name); 2836 return (r); 2837 } 2838 2839 /* 2840 * Get the pg_pattern attributes and save them as properties in the 2841 * property group at pg. The pg_pattern element accepts four attributes -- 2842 * name, type, required and target. 2843 */ 2844 static int 2845 lxml_get_pg_pattern_attributes(pgroup_t *pg, xmlNodePtr cursor) 2846 { 2847 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_TM_NAME, 2848 SCF_TYPE_ASTRING, cursor, name_attr, NULL) != 0) { 2849 return (-1); 2850 } 2851 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_TM_TYPE, 2852 SCF_TYPE_ASTRING, cursor, type_attr, NULL) != 0) { 2853 return (-1); 2854 } 2855 if (new_opt_str_prop_from_attr(pg, SCF_PROPERTY_TM_TARGET, 2856 SCF_TYPE_ASTRING, cursor, target_attr, NULL) != 0) { 2857 return (-1); 2858 } 2859 if (new_bool_prop_from_attr(pg, SCF_PROPERTY_TM_REQUIRED, cursor, 2860 required_attr) != 0) 2861 return (-1); 2862 return (0); 2863 } 2864 2865 /* 2866 * There are several restrictions on the pg_pattern attributes that cannot 2867 * be specifed in the service bundle DTD. This function verifies that 2868 * those restrictions have been satisfied. The restrictions are: 2869 * 2870 * - The target attribute may have a value of "instance" only when the 2871 * template block is in a service declaration. 2872 * 2873 * - The target attribute may have a value of "delegate" only when the 2874 * template block applies to a restarter. 2875 * 2876 * - The target attribute may have a value of "all" only when the 2877 * template block applies to the master restarter. 2878 * 2879 * The function returns 0 on success and -1 on failure. 2880 */ 2881 static int 2882 verify_pg_pattern_attributes(entity_t *s, pgroup_t *pg) 2883 { 2884 int is_restarter; 2885 property_t *target; 2886 value_t *v; 2887 2888 /* Find the value of the target property. */ 2889 target = internal_property_find(pg, SCF_PROPERTY_TM_TARGET); 2890 if (target == NULL) { 2891 uu_die(gettext("pg_pattern is missing the %s attribute " 2892 "in %s\n"), target_attr, s->sc_name); 2893 return (-1); 2894 } 2895 v = uu_list_first(target->sc_property_values); 2896 assert(v != NULL); 2897 assert(v->sc_type == SCF_TYPE_ASTRING); 2898 2899 /* 2900 * If target has a value of instance, the template must be in a 2901 * service object. 2902 */ 2903 if (strcmp(v->sc_u.sc_string, "instance") == 0) { 2904 if (s->sc_etype != SVCCFG_SERVICE_OBJECT) { 2905 uu_warn(gettext("pg_pattern %s attribute may only " 2906 "have a value of \"instance\" when it is in a " 2907 "service declaration.\n"), target_attr); 2908 return (-1); 2909 } 2910 } 2911 2912 /* 2913 * If target has a value of "delegate", the template must be in a 2914 * restarter. 2915 */ 2916 if (strcmp(v->sc_u.sc_string, "delegate") == 0) { 2917 is_restarter = 0; 2918 if ((s->sc_etype == SVCCFG_SERVICE_OBJECT) && 2919 (s->sc_u.sc_service.sc_service_type == SVCCFG_RESTARTER)) { 2920 is_restarter = 1; 2921 } 2922 if ((s->sc_etype == SVCCFG_INSTANCE_OBJECT) && 2923 (s->sc_parent->sc_u.sc_service.sc_service_type == 2924 SVCCFG_RESTARTER)) { 2925 is_restarter = 1; 2926 } 2927 if (is_restarter == 0) { 2928 uu_warn(gettext("pg_pattern %s attribute has a " 2929 "value of \"delegate\" but is not in a " 2930 "restarter service\n"), target_attr); 2931 return (-1); 2932 } 2933 } 2934 2935 /* 2936 * If target has a value of "all", the template must be in the 2937 * global (SCF_SERVICE_GLOBAL) service. 2938 */ 2939 if (strcmp(v->sc_u.sc_string, all_value) == 0) { 2940 if (s->sc_etype != SVCCFG_SERVICE_OBJECT) { 2941 uu_warn(gettext("pg_pattern %s attribute has a " 2942 "value of \"%s\" but is not in a " 2943 "service entity.\n"), target_attr, all_value); 2944 return (-1); 2945 } 2946 if (strcmp(s->sc_fmri, SCF_SERVICE_GLOBAL) != 0) { 2947 uu_warn(gettext("pg_pattern %s attribute has a " 2948 "value of \"%s\" but is in the \"%s\" service. " 2949 "pg_patterns with target \"%s\" are only allowed " 2950 "in the global service.\n"), 2951 target_attr, all_value, s->sc_fmri, all_value); 2952 return (-1); 2953 } 2954 } 2955 2956 return (0); 2957 } 2958 2959 static int 2960 lxml_get_tm_pg_pattern(entity_t *service, xmlNodePtr pg_pattern) 2961 { 2962 xmlNodePtr cursor; 2963 int out_len; 2964 xmlChar *name; 2965 pgroup_t *pg = NULL; 2966 char *pg_name; 2967 int r = -1; 2968 xmlChar *type; 2969 2970 pg_name = safe_malloc(max_scf_name_len + 1); 2971 2972 /* 2973 * Get the name and type attributes. Their presence or absence 2974 * determines whcih prefix we will use for the property group name. 2975 * There are four cases -- neither attribute is present, both are 2976 * present, only name is present or only type is present. 2977 */ 2978 name = xmlGetProp(pg_pattern, (xmlChar *)name_attr); 2979 type = xmlGetProp(pg_pattern, (xmlChar *)type_attr); 2980 if ((name == NULL) || (*name == 0)) { 2981 if ((type == NULL) || (*type == 0)) { 2982 /* PG name contains only the prefix in this case */ 2983 if (strlcpy(pg_name, SCF_PG_TM_PG_PATTERN_PREFIX, 2984 max_scf_name_len + 1) >= max_scf_name_len + 1) { 2985 uu_die(gettext("Unable to create pg_pattern " 2986 "property for %s\n"), service->sc_name); 2987 } 2988 } else { 2989 /* 2990 * If we have a type and no name, the type becomes 2991 * part of the pg_pattern property group name. 2992 */ 2993 if ((out_len = snprintf(pg_name, max_scf_name_len + 1, 2994 "%s%s", SCF_PG_TM_PG_PATTERN_T_PREFIX, type)) >= 2995 max_scf_name_len + 1) { 2996 uu_die(gettext("pg_pattern type is for %s is " 2997 "%d bytes too long\n"), service->sc_name, 2998 out_len - max_scf_name_len); 2999 } 3000 } 3001 } else { 3002 const char *prefix; 3003 3004 /* Make sure that the name is valid. */ 3005 if (uu_check_name((const char *)name, UU_NAME_DOMAIN) != 0) { 3006 semerr(gettext("pg_pattern name attribute, \"%s\", " 3007 "for %s is invalid\n"), name, service->sc_name); 3008 goto out; 3009 } 3010 3011 /* 3012 * As long as the pg_pattern has a name, it becomes part of 3013 * the name of the pg_pattern property group name. We 3014 * merely need to pick the appropriate prefix. 3015 */ 3016 if ((type == NULL) || (*type == 0)) { 3017 prefix = SCF_PG_TM_PG_PATTERN_N_PREFIX; 3018 } else { 3019 prefix = SCF_PG_TM_PG_PATTERN_NT_PREFIX; 3020 } 3021 if ((out_len = snprintf(pg_name, max_scf_name_len + 1, "%s%s", 3022 prefix, name)) >= max_scf_name_len + 1) { 3023 uu_die(gettext("pg_pattern property group name " 3024 "for %s is %d bytes too long\n"), service->sc_name, 3025 out_len - max_scf_name_len); 3026 } 3027 } 3028 3029 /* 3030 * Create the property group for holding this pg_pattern 3031 * information, and capture the pg_pattern attributes. 3032 */ 3033 pg = internal_pgroup_create_strict(service, pg_name, 3034 SCF_GROUP_TEMPLATE_PG_PATTERN); 3035 if (pg == NULL) { 3036 if ((name == NULL) || (*name == 0)) { 3037 if ((type == NULL) ||(*type == 0)) { 3038 semerr(gettext("pg_pattern with empty name and " 3039 "type is not unique in %s\n"), 3040 service->sc_name); 3041 } else { 3042 semerr(gettext("pg_pattern with empty name and " 3043 "type \"%s\" is not unique in %s\n"), 3044 type, service->sc_name); 3045 } 3046 } else { 3047 if ((type == NULL) || (*type == 0)) { 3048 semerr(gettext("pg_pattern with name \"%s\" " 3049 "and empty type is not unique in %s\n"), 3050 name, service->sc_name); 3051 } else { 3052 semerr(gettext("pg_pattern with name \"%s\" " 3053 "and type \"%s\" is not unique in %s\n"), 3054 name, type, service->sc_name); 3055 } 3056 } 3057 goto out; 3058 } 3059 3060 /* 3061 * Get the pg_pattern attributes from the manifest and verify 3062 * that they satisfy our restrictions. 3063 */ 3064 r = lxml_get_pg_pattern_attributes(pg, pg_pattern); 3065 if (r != 0) 3066 goto out; 3067 if (verify_pg_pattern_attributes(service, pg) != 0) { 3068 semerr(gettext("Invalid pg_pattern attributes in %s\n"), 3069 service->sc_name); 3070 r = -1; 3071 goto out; 3072 } 3073 3074 /* 3075 * Now process all of the elements of pg_pattern. 3076 */ 3077 for (cursor = pg_pattern->xmlChildrenNode; 3078 cursor != NULL; 3079 cursor = cursor->next) { 3080 if (lxml_ignorable_block(cursor)) 3081 continue; 3082 3083 switch (lxml_xlate_element(cursor->name)) { 3084 case SC_COMMON_NAME: 3085 (void) lxml_get_all_loctext(service, pg, cursor, 3086 COMMON_NAME_FMT, (const char *)cursor->name); 3087 break; 3088 case SC_DESCRIPTION: 3089 (void) lxml_get_all_loctext(service, pg, cursor, 3090 DESCRIPTION_FMT, (const char *)cursor->name); 3091 break; 3092 case SC_PROP_PATTERN: 3093 r = lxml_get_tm_prop_pattern(service, cursor, 3094 pg_name); 3095 if (r != 0) 3096 goto out; 3097 break; 3098 default: 3099 uu_die(gettext("illegal element \"%s\" in pg_pattern " 3100 "for service \"%s\"\n"), cursor->name, 3101 service->sc_name); 3102 } 3103 } 3104 3105 out: 3106 if ((r != 0) && (pg != NULL)) { 3107 internal_detach_pgroup(service, pg); 3108 internal_pgroup_free(pg); 3109 } 3110 free(pg_name); 3111 xmlFree(name); 3112 xmlFree(type); 3113 3114 return (r); 3115 } 3116 3117 static int 3118 lxml_get_template(entity_t *service, xmlNodePtr templ) 3119 { 3120 xmlNodePtr cursor; 3121 3122 for (cursor = templ->xmlChildrenNode; cursor != NULL; 3123 cursor = cursor->next) { 3124 if (lxml_ignorable_block(cursor)) 3125 continue; 3126 3127 switch (lxml_xlate_element(cursor->name)) { 3128 case SC_COMMON_NAME: 3129 (void) lxml_get_tm_common_name(service, cursor); 3130 break; 3131 case SC_DESCRIPTION: 3132 (void) lxml_get_tm_description(service, cursor); 3133 break; 3134 case SC_DOCUMENTATION: 3135 (void) lxml_get_tm_documentation(service, cursor); 3136 break; 3137 case SC_PG_PATTERN: 3138 if (lxml_get_tm_pg_pattern(service, cursor) != 0) 3139 return (-1); 3140 break; 3141 default: 3142 uu_die(gettext("illegal element \"%s\" on template " 3143 "for service \"%s\"\n"), 3144 cursor->name, service->sc_name); 3145 } 3146 } 3147 3148 return (0); 3149 } 3150 3151 static int 3152 lxml_get_default_instance(entity_t *service, xmlNodePtr definst) 3153 { 3154 entity_t *i; 3155 xmlChar *enabled; 3156 pgroup_t *pg; 3157 property_t *p; 3158 char *package; 3159 uint64_t enabled_val = 0; 3160 3161 i = internal_instance_new("default"); 3162 3163 if ((enabled = xmlGetProp(definst, (xmlChar *)enabled_attr)) != NULL) { 3164 enabled_val = (strcmp(true, (const char *)enabled) == 0) ? 3165 1 : 0; 3166 xmlFree(enabled); 3167 } 3168 3169 /* 3170 * New general property group with enabled boolean property set. 3171 */ 3172 3173 i->sc_op = service->sc_op; 3174 pg = internal_pgroup_new(); 3175 (void) internal_attach_pgroup(i, pg); 3176 3177 pg->sc_pgroup_name = (char *)scf_pg_general; 3178 pg->sc_pgroup_type = (char *)scf_group_framework; 3179 pg->sc_pgroup_flags = 0; 3180 3181 p = internal_property_create(SCF_PROPERTY_ENABLED, SCF_TYPE_BOOLEAN, 1, 3182 enabled_val); 3183 3184 (void) internal_attach_property(pg, p); 3185 3186 /* 3187 * Add general/package property if PKGINST is set. 3188 */ 3189 if ((package = getenv("PKGINST")) != NULL) { 3190 p = internal_property_create(SCF_PROPERTY_PACKAGE, 3191 SCF_TYPE_ASTRING, 1, package); 3192 3193 (void) internal_attach_property(pg, p); 3194 } 3195 3196 return (internal_attach_entity(service, i)); 3197 } 3198 3199 /* 3200 * Translate an instance element into an internal property tree, added to 3201 * service. If op is SVCCFG_OP_APPLY (i.e., apply a profile), set the 3202 * enabled property to override. 3203 * 3204 * If op is SVCCFG_OP_APPLY (i.e., apply a profile), do not allow for 3205 * modification of template data. 3206 */ 3207 static int 3208 lxml_get_instance(entity_t *service, xmlNodePtr inst, bundle_type_t bt, 3209 svccfg_op_t op) 3210 { 3211 entity_t *i; 3212 pgroup_t *pg; 3213 property_t *p; 3214 xmlNodePtr cursor; 3215 xmlChar *enabled; 3216 int r, e_val; 3217 3218 /* 3219 * Fetch its attributes, as appropriate. 3220 */ 3221 i = internal_instance_new((char *)xmlGetProp(inst, 3222 (xmlChar *)name_attr)); 3223 3224 /* 3225 * Note that this must be done before walking the children so that 3226 * sc_fmri is set in case we enter lxml_get_dependent(). 3227 */ 3228 r = internal_attach_entity(service, i); 3229 if (r != 0) 3230 return (r); 3231 3232 i->sc_op = op; 3233 enabled = xmlGetProp(inst, (xmlChar *)enabled_attr); 3234 3235 if (enabled == NULL) { 3236 if (bt == SVCCFG_MANIFEST) { 3237 semerr(gettext("Instance \"%s\" missing attribute " 3238 "\"%s\".\n"), i->sc_name, enabled_attr); 3239 return (-1); 3240 } 3241 } else { /* enabled != NULL */ 3242 if (strcmp(true, (const char *)enabled) != 0 && 3243 strcmp(false, (const char *)enabled) != 0) { 3244 xmlFree(enabled); 3245 semerr(gettext("Invalid enabled value\n")); 3246 return (-1); 3247 } 3248 pg = internal_pgroup_new(); 3249 (void) internal_attach_pgroup(i, pg); 3250 3251 pg->sc_pgroup_name = (char *)scf_pg_general; 3252 pg->sc_pgroup_type = (char *)scf_group_framework; 3253 pg->sc_pgroup_flags = 0; 3254 3255 e_val = (strcmp(true, (const char *)enabled) == 0); 3256 p = internal_property_create(SCF_PROPERTY_ENABLED, 3257 SCF_TYPE_BOOLEAN, 1, (uint64_t)e_val); 3258 3259 p->sc_property_override = (op == SVCCFG_OP_APPLY); 3260 3261 (void) internal_attach_property(pg, p); 3262 3263 xmlFree(enabled); 3264 } 3265 3266 /* 3267 * Walk its child elements, as appropriate. 3268 */ 3269 for (cursor = inst->xmlChildrenNode; cursor != NULL; 3270 cursor = cursor->next) { 3271 if (lxml_ignorable_block(cursor)) 3272 continue; 3273 3274 switch (lxml_xlate_element(cursor->name)) { 3275 case SC_RESTARTER: 3276 (void) lxml_get_restarter(i, cursor); 3277 break; 3278 case SC_DEPENDENCY: 3279 (void) lxml_get_dependency(i, cursor); 3280 break; 3281 case SC_DEPENDENT: 3282 (void) lxml_get_dependent(i, cursor); 3283 break; 3284 case SC_METHOD_CONTEXT: 3285 (void) lxml_get_entity_method_context(i, cursor); 3286 break; 3287 case SC_EXEC_METHOD: 3288 (void) lxml_get_exec_method(i, cursor); 3289 break; 3290 case SC_PROPERTY_GROUP: 3291 (void) lxml_get_pgroup(i, cursor); 3292 break; 3293 case SC_TEMPLATE: 3294 if (op == SVCCFG_OP_APPLY) { 3295 semerr(gettext("Template data for \"%s\" may " 3296 "not be modified in a profile.\n"), 3297 i->sc_name); 3298 3299 return (-1); 3300 } 3301 3302 if (lxml_get_template(i, cursor) != 0) 3303 return (-1); 3304 break; 3305 case SC_NOTIFICATION_PARAMETERS: 3306 if (lxml_get_notification_parameters(i, cursor) != 0) 3307 return (-1); 3308 break; 3309 default: 3310 uu_die(gettext( 3311 "illegal element \"%s\" on instance \"%s\"\n"), 3312 cursor->name, i->sc_name); 3313 break; 3314 } 3315 } 3316 3317 return (0); 3318 } 3319 3320 /* ARGSUSED1 */ 3321 static int 3322 lxml_get_single_instance(entity_t *entity, xmlNodePtr si) 3323 { 3324 pgroup_t *pg; 3325 property_t *p; 3326 int r; 3327 3328 pg = internal_pgroup_find_or_create(entity, (char *)scf_pg_general, 3329 (char *)scf_group_framework); 3330 3331 p = internal_property_create(SCF_PROPERTY_SINGLE_INSTANCE, 3332 SCF_TYPE_BOOLEAN, 1, (uint64_t)1); 3333 3334 r = internal_attach_property(pg, p); 3335 if (r != 0) { 3336 internal_property_free(p); 3337 return (-1); 3338 } 3339 3340 return (0); 3341 } 3342 3343 /* 3344 * Check to see if the service should allow the upgrade 3345 * process to handle adding of the manifestfiles linkage. 3346 * 3347 * If the service exists and does not have a manifestfiles 3348 * property group then the upgrade process should handle 3349 * the service. 3350 * 3351 * If the service doesn't exist or the service exists 3352 * and has a manifestfiles property group then the import 3353 * process can handle the manifestfiles property group 3354 * work. 3355 * 3356 * This prevents potential cleanup of unaccounted for instances 3357 * in early manifest import due to upgrade process needing 3358 * information that has not yet been supplied by manifests 3359 * that are still located in the /var/svc manifests directory. 3360 */ 3361 static int 3362 lxml_check_upgrade(const char *service) 3363 { 3364 scf_handle_t *h = NULL; 3365 scf_scope_t *sc = NULL; 3366 scf_service_t *svc = NULL; 3367 scf_propertygroup_t *pg = NULL; 3368 int rc = SCF_FAILED; 3369 3370 if ((h = scf_handle_create(SCF_VERSION)) == NULL || 3371 (sc = scf_scope_create(h)) == NULL || 3372 (svc = scf_service_create(h)) == NULL || 3373 (pg = scf_pg_create(h)) == NULL) 3374 goto out; 3375 3376 if (scf_handle_bind(h) != 0) 3377 goto out; 3378 3379 if (scf_handle_get_scope(h, SCF_FMRI_LOCAL_SCOPE, sc) == -1) 3380 goto out; 3381 3382 if (scf_scope_get_service(sc, service, svc) != SCF_SUCCESS) { 3383 if (scf_error() == SCF_ERROR_NOT_FOUND) 3384 rc = SCF_SUCCESS; 3385 3386 goto out; 3387 } 3388 3389 if (scf_service_get_pg(svc, SCF_PG_MANIFESTFILES, pg) != SCF_SUCCESS) 3390 goto out; 3391 3392 rc = SCF_SUCCESS; 3393 out: 3394 scf_pg_destroy(pg); 3395 scf_service_destroy(svc); 3396 scf_scope_destroy(sc); 3397 scf_handle_destroy(h); 3398 3399 return (rc); 3400 } 3401 3402 /* 3403 * Translate a service element into an internal instance/property tree, added 3404 * to bundle. 3405 * 3406 * If op is SVCCFG_OP_APPLY (i.e., apply a profile), do not allow for 3407 * modification of template data. 3408 */ 3409 static int 3410 lxml_get_service(bundle_t *bundle, xmlNodePtr svc, svccfg_op_t op) 3411 { 3412 pgroup_t *pg; 3413 property_t *p; 3414 entity_t *s; 3415 xmlNodePtr cursor; 3416 xmlChar *type; 3417 xmlChar *version; 3418 int e; 3419 3420 /* 3421 * Fetch attributes, as appropriate. 3422 */ 3423 s = internal_service_new((char *)xmlGetProp(svc, 3424 (xmlChar *)name_attr)); 3425 3426 version = xmlGetProp(svc, (xmlChar *)version_attr); 3427 s->sc_u.sc_service.sc_service_version = atol((const char *)version); 3428 xmlFree(version); 3429 3430 type = xmlGetProp(svc, (xmlChar *)type_attr); 3431 s->sc_u.sc_service.sc_service_type = lxml_xlate_service_type(type); 3432 xmlFree(type); 3433 3434 /* 3435 * Set the global missing type to false before processing the service 3436 */ 3437 est->sc_miss_type = B_FALSE; 3438 s->sc_op = op; 3439 3440 /* 3441 * Now that the service is created create the manifest 3442 * property group and add the property value of the service. 3443 */ 3444 if (lxml_check_upgrade(s->sc_name) == SCF_SUCCESS && 3445 svc->doc->name != NULL && 3446 bundle->sc_bundle_type == SVCCFG_MANIFEST) { 3447 char *buf, *base, *fname, *bname; 3448 size_t base_sz = 0; 3449 3450 /* 3451 * Must remove the PKG_INSTALL_ROOT, point to the correct 3452 * directory after install 3453 */ 3454 bname = uu_zalloc(PATH_MAX + 1); 3455 if (realpath(svc->doc->name, bname) == NULL) { 3456 uu_die(gettext("Unable to create the real path of the " 3457 "manifest file \"%s\" : %d\n"), svc->doc->name, 3458 errno); 3459 } 3460 3461 base = getenv("PKG_INSTALL_ROOT"); 3462 if (base != NULL && strncmp(bname, base, strlen(base)) == 0) { 3463 base_sz = strlen(base); 3464 } 3465 fname = safe_strdup(bname + base_sz); 3466 3467 uu_free(bname); 3468 buf = mhash_filename_to_propname(svc->doc->name, B_FALSE); 3469 3470 pg = internal_pgroup_create_strict(s, SCF_PG_MANIFESTFILES, 3471 SCF_GROUP_FRAMEWORK); 3472 3473 if (pg == NULL) { 3474 uu_die(gettext("Property group for prop_pattern, " 3475 "\"%s\", already exists in %s\n"), 3476 SCF_PG_MANIFESTFILES, s->sc_name); 3477 } 3478 3479 p = internal_property_create(buf, SCF_TYPE_ASTRING, 1, fname); 3480 3481 (void) internal_attach_property(pg, p); 3482 } 3483 3484 /* 3485 * Walk its child elements, as appropriate. 3486 */ 3487 for (cursor = svc->xmlChildrenNode; cursor != NULL; 3488 cursor = cursor->next) { 3489 if (lxml_ignorable_block(cursor)) 3490 continue; 3491 3492 e = lxml_xlate_element(cursor->name); 3493 3494 switch (e) { 3495 case SC_INSTANCE: 3496 if (lxml_get_instance(s, cursor, 3497 bundle->sc_bundle_type, op) != 0) 3498 return (-1); 3499 break; 3500 case SC_TEMPLATE: 3501 if (op == SVCCFG_OP_APPLY) { 3502 semerr(gettext("Template data for \"%s\" may " 3503 "not be modified in a profile.\n"), 3504 s->sc_name); 3505 3506 return (-1); 3507 } 3508 3509 if (lxml_get_template(s, cursor) != 0) 3510 return (-1); 3511 break; 3512 case SC_NOTIFICATION_PARAMETERS: 3513 if (lxml_get_notification_parameters(s, cursor) != 0) 3514 return (-1); 3515 break; 3516 case SC_STABILITY: 3517 (void) lxml_get_entity_stability(s, cursor); 3518 break; 3519 case SC_DEPENDENCY: 3520 (void) lxml_get_dependency(s, cursor); 3521 break; 3522 case SC_DEPENDENT: 3523 (void) lxml_get_dependent(s, cursor); 3524 break; 3525 case SC_RESTARTER: 3526 (void) lxml_get_restarter(s, cursor); 3527 break; 3528 case SC_EXEC_METHOD: 3529 (void) lxml_get_exec_method(s, cursor); 3530 break; 3531 case SC_METHOD_CONTEXT: 3532 (void) lxml_get_entity_method_context(s, cursor); 3533 break; 3534 case SC_PROPERTY_GROUP: 3535 (void) lxml_get_pgroup(s, cursor); 3536 break; 3537 case SC_INSTANCE_CREATE_DEFAULT: 3538 (void) lxml_get_default_instance(s, cursor); 3539 break; 3540 case SC_INSTANCE_SINGLE: 3541 (void) lxml_get_single_instance(s, cursor); 3542 break; 3543 default: 3544 uu_die(gettext( 3545 "illegal element \"%s\" on service \"%s\"\n"), 3546 cursor->name, s->sc_name); 3547 break; 3548 } 3549 } 3550 3551 /* 3552 * Now that the service has been processed set the missing type 3553 * for the service. So that only the services with missing 3554 * types are processed. 3555 */ 3556 s->sc_miss_type = est->sc_miss_type; 3557 if (est->sc_miss_type) 3558 est->sc_miss_type = B_FALSE; 3559 3560 return (internal_attach_service(bundle, s)); 3561 } 3562 3563 #ifdef DEBUG 3564 void 3565 lxml_dump(int g, xmlNodePtr p) 3566 { 3567 if (p && p->name) { 3568 (void) printf("%d %s\n", g, p->name); 3569 3570 for (p = p->xmlChildrenNode; p != NULL; p = p->next) 3571 lxml_dump(g + 1, p); 3572 } 3573 } 3574 #endif /* DEBUG */ 3575 3576 static int 3577 lxml_is_known_dtd(const xmlChar *dtdname) 3578 { 3579 if (dtdname == NULL || 3580 strcmp(MANIFEST_DTD_PATH, (const char *)dtdname) != 0) 3581 return (0); 3582 3583 return (1); 3584 } 3585 3586 static int 3587 lxml_get_bundle(bundle_t *bundle, bundle_type_t bundle_type, 3588 xmlNodePtr subbundle, svccfg_op_t op) 3589 { 3590 xmlNodePtr cursor; 3591 xmlChar *type; 3592 int e; 3593 3594 /* 3595 * 1. Get bundle attributes. 3596 */ 3597 type = xmlGetProp(subbundle, (xmlChar *)type_attr); 3598 bundle->sc_bundle_type = lxml_xlate_bundle_type(type); 3599 if (bundle->sc_bundle_type != bundle_type && 3600 bundle_type != SVCCFG_UNKNOWN_BUNDLE) { 3601 semerr(gettext("included bundle of different type.\n")); 3602 return (-1); 3603 } 3604 3605 xmlFree(type); 3606 3607 switch (op) { 3608 case SVCCFG_OP_IMPORT: 3609 if (bundle->sc_bundle_type != SVCCFG_MANIFEST) { 3610 semerr(gettext("document is not a manifest.\n")); 3611 return (-1); 3612 } 3613 break; 3614 case SVCCFG_OP_APPLY: 3615 if (bundle->sc_bundle_type != SVCCFG_PROFILE) { 3616 semerr(gettext("document is not a profile.\n")); 3617 return (-1); 3618 } 3619 break; 3620 case SVCCFG_OP_RESTORE: 3621 if (bundle->sc_bundle_type != SVCCFG_ARCHIVE) { 3622 semerr(gettext("document is not an archive.\n")); 3623 return (-1); 3624 } 3625 break; 3626 } 3627 3628 if (((bundle->sc_bundle_name = xmlGetProp(subbundle, 3629 (xmlChar *)name_attr)) == NULL) || (*bundle->sc_bundle_name == 0)) { 3630 semerr(gettext("service bundle lacks name attribute\n")); 3631 return (-1); 3632 } 3633 3634 /* 3635 * 2. Get services, descend into each one and build state. 3636 */ 3637 for (cursor = subbundle->xmlChildrenNode; cursor != NULL; 3638 cursor = cursor->next) { 3639 if (lxml_ignorable_block(cursor)) 3640 continue; 3641 3642 e = lxml_xlate_element(cursor->name); 3643 3644 switch (e) { 3645 case SC_XI_INCLUDE: 3646 continue; 3647 3648 case SC_SERVICE_BUNDLE: 3649 if (lxml_get_bundle(bundle, bundle_type, cursor, op)) 3650 return (-1); 3651 break; 3652 case SC_SERVICE: 3653 if (lxml_get_service(bundle, cursor, op) != 0) 3654 return (-1); 3655 break; 3656 } 3657 } 3658 3659 return (0); 3660 } 3661 3662 /* 3663 * Load an XML tree from filename and translate it into an internal service 3664 * tree bundle. Require that the bundle be of appropriate type for the 3665 * operation: archive for RESTORE, manifest for IMPORT, profile for APPLY. 3666 */ 3667 int 3668 lxml_get_bundle_file(bundle_t *bundle, const char *filename, svccfg_op_t op) 3669 { 3670 xmlDocPtr document; 3671 xmlNodePtr cursor; 3672 xmlDtdPtr dtd = NULL; 3673 xmlValidCtxtPtr vcp; 3674 boolean_t do_validate; 3675 char *dtdpath = NULL; 3676 int r; 3677 3678 /* 3679 * Verify we can read the file before we try to parse it. 3680 */ 3681 if (access(filename, R_OK | F_OK) == -1) { 3682 semerr(gettext("unable to open file: %s\n"), strerror(errno)); 3683 return (-1); 3684 } 3685 3686 /* 3687 * Until libxml2 addresses DTD-based validation with XInclude, we don't 3688 * validate service profiles (i.e. the apply path). 3689 */ 3690 do_validate = (op != SVCCFG_OP_APPLY) && 3691 (getenv("SVCCFG_NOVALIDATE") == NULL); 3692 if (do_validate) 3693 dtdpath = getenv("SVCCFG_DTD"); 3694 3695 if (dtdpath != NULL) 3696 xmlLoadExtDtdDefaultValue = 0; 3697 3698 if ((document = xmlReadFile(filename, NULL, 0)) == NULL) { 3699 semerr(gettext("couldn't parse document\n")); 3700 return (-1); 3701 } 3702 3703 document->name = safe_strdup(filename); 3704 3705 /* 3706 * Verify that this is a document type we understand. 3707 */ 3708 if ((dtd = xmlGetIntSubset(document)) == NULL) { 3709 semerr(gettext("document has no DTD\n")); 3710 return (-1); 3711 } else if (dtdpath == NULL && !do_validate) { 3712 /* 3713 * If apply then setup so that some validation 3714 * for specific elements can be done. 3715 */ 3716 dtdpath = (char *)document->intSubset->SystemID; 3717 } 3718 3719 if (!lxml_is_known_dtd(dtd->SystemID)) { 3720 semerr(gettext("document DTD unknown; not service bundle?\n")); 3721 return (-1); 3722 } 3723 3724 if ((cursor = xmlDocGetRootElement(document)) == NULL) { 3725 semerr(gettext("document is empty\n")); 3726 xmlFreeDoc(document); 3727 return (-1); 3728 } 3729 3730 if (xmlStrcmp(cursor->name, (const xmlChar *)"service_bundle") != 0) { 3731 semerr(gettext("document is not a service bundle\n")); 3732 xmlFreeDoc(document); 3733 return (-1); 3734 } 3735 3736 3737 if (dtdpath != NULL) { 3738 dtd = xmlParseDTD(NULL, (xmlChar *)dtdpath); 3739 if (dtd == NULL) { 3740 semerr(gettext("Could not parse DTD \"%s\".\n"), 3741 dtdpath); 3742 return (-1); 3743 } 3744 3745 if (document->extSubset != NULL) 3746 xmlFreeDtd(document->extSubset); 3747 3748 document->extSubset = dtd; 3749 } 3750 3751 if (xmlXIncludeProcessFlags(document, XML_PARSE_XINCLUDE) == -1) { 3752 semerr(gettext("couldn't handle XInclude statements " 3753 "in document\n")); 3754 return (-1); 3755 } 3756 3757 if (do_validate) { 3758 vcp = xmlNewValidCtxt(); 3759 if (vcp == NULL) 3760 uu_die(gettext("could not allocate memory")); 3761 vcp->warning = xmlParserValidityWarning; 3762 vcp->error = xmlParserValidityError; 3763 3764 r = xmlValidateDocument(vcp, document); 3765 3766 xmlFreeValidCtxt(vcp); 3767 3768 if (r == 0) { 3769 semerr(gettext("Document is not valid.\n")); 3770 xmlFreeDoc(document); 3771 return (-1); 3772 } 3773 } 3774 3775 #ifdef DEBUG 3776 lxml_dump(0, cursor); 3777 #endif /* DEBUG */ 3778 3779 r = lxml_get_bundle(bundle, SVCCFG_UNKNOWN_BUNDLE, cursor, op); 3780 3781 xmlFreeDoc(document); 3782 3783 return (r); 3784 } 3785 3786 int 3787 lxml_inventory(const char *filename) 3788 { 3789 bundle_t *b; 3790 uu_list_walk_t *svcs, *insts; 3791 entity_t *svc, *inst; 3792 3793 b = internal_bundle_new(); 3794 3795 if (lxml_get_bundle_file(b, filename, SVCCFG_OP_IMPORT) != 0) { 3796 internal_bundle_free(b); 3797 return (-1); 3798 } 3799 3800 svcs = uu_list_walk_start(b->sc_bundle_services, 0); 3801 if (svcs == NULL) 3802 uu_die(gettext("Couldn't walk services")); 3803 3804 while ((svc = uu_list_walk_next(svcs)) != NULL) { 3805 uu_list_t *inst_list; 3806 3807 inst_list = svc->sc_u.sc_service.sc_service_instances; 3808 insts = uu_list_walk_start(inst_list, 0); 3809 if (insts == NULL) 3810 uu_die(gettext("Couldn't walk instances")); 3811 3812 while ((inst = uu_list_walk_next(insts)) != NULL) 3813 (void) printf("svc:/%s:%s\n", svc->sc_name, 3814 inst->sc_name); 3815 3816 uu_list_walk_end(insts); 3817 } 3818 3819 uu_list_walk_end(svcs); 3820 3821 svcs = uu_list_walk_start(b->sc_bundle_services, 0); 3822 while ((svc = uu_list_walk_next(svcs)) != NULL) { 3823 (void) fputs("svc:/", stdout); 3824 (void) puts(svc->sc_name); 3825 } 3826 uu_list_walk_end(svcs); 3827 3828 internal_bundle_free(b); 3829 3830 return (0); 3831 } 3832