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