svccfg: remove -Wno-unitialized

[unleashed/lotheac.git] / usr / src / cmd / svc / svccfg / svccfg_tmpl.c

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

/*
 * This file provides the code that allows svccfg(8) to validate a
 * manifest against the template specifications.  svccfg uses the
 * validation facilities for the import and validate subcommands.
 *
 * There are three entry points -- tmpl_validate_bundle(),
 * tmpl_errors_print() and tmpl_errors_destroy().  svccfg calls
 * tmpl_validate_bundle() to validate a bundle.  tmpl_validate_bundle()
 * returns a pointer to a tmpl_errors_t.  This is a pointer to information
 * about any validation errors that were found.  If an error was detected,
 * svccfg calls tmpl_errors_print() to print the error information.  Once
 * the error information is printed, svccfg calls tmpl_errors_destroy() to
 * free the memory associated with the tmpl_errors_t.
 *
 * libscf's scf_tmpl.c performs similar checks to the ones described in
 * this paragraph.  Any changes to the algorithms in this file should also
 * be infcorporated into scf_tmpl.c.  The reason that there are two bodies
 * of code is that they work on different data structures.
 * tmpl_validate_bundle() validates each instance of each service in the
 * bundle.  The following checks are performed on each instance:
 *
 *      1.  Verify template consistency.
 *          A.  No conflicting definitions of "pg_pattern" are allowed
 *              within a single instance.
 *          B.  Templates at a narrow target (e.g. instance) which define
 *              property groups already templated at a broad target
 *              (e.g. delegate or all) are strongly discouraged.
 *          C.  Developers may not define a template which specifies a
 *              single prop_pattern name with differing types on the same
 *              target entity.
 *          D.  If a pg_pattern has a required attribute with a value of
 *              true, then its name and type attributes must be
 *              specified.
 *          E.  If a prop_pattern has a required attribute with a value
 *              of true, then its type attribute must be specified.
 *          F.  If a prop_pattern has an include_values element make sure
 *              that the appropriate constraints or values element has
 *              also been declared.
 *      2.  Validate that each property group in the instance is in
 *          conformance with the template specifications.
 *          A.  Verify that the types of the PG and the pg_pattern are
 *              compatible.
 *          B.  Verify properties of the PG against the prop_patterns in
 *              the template.
 *              o Verify property's type.
 *              o Verify cardinality.
 *              o Vefiy that property values satisfy the constraints
 *                imposed by the prop_pattern.
 *          C.  Verify that required properties are present.
 *      3.  Verify that all required property groups are present in the
 *          insance.
 *
 * tmpl_validate_bundle() is called after svccfg has processed the manifest
 * file.  The manifest is represented in memory by a set of entity_t,
 * pgroup_t, property_t and value_t structures.  These structures are
 * defined in svccfg.h.
 *
 * tmpl_validate_bundle() calls tmpl_validate_service() for each service in
 * the bundle, and tmpl_validate_service() then calls
 * tmpl_validate_instance() for each instance in the service.
 * tmpl_validate_instance() is the function that does the real work of
 * validation against the template specification.
 *
 * Subsystems:
 * ==========
 *
 * General Templates:
 * -----------------
 * In order to perform the validation specified by 1.B above, we need to
 * load the templates specifications for the global service and the
 * instance's restarter.  This information is loaded from the repository
 * and it is held in memory using the entity_t, pgroup_t, property_t and
 * value_t hierarchy of structures.  When a service is processed,
 * load_general_templates() is called to load the information for the
 * global service and restarter that is declared at the service level.  The
 * sc_service.sc_global and sc_service.sc_restarter members of the
 * service's entity_t point to the information for the global and restarter
 * services.
 *
 * The instance portion of a manifest can declare an instance specific
 * restarter.  If this is the case, load_instance_restarter() will load the
 * information for that restarter, and it is saved in the
 * sc_instance.sc_instance_restarter member of the entity_t that represents
 * the instance.
 *
 * Composed Properties:
 * -------------------
 * We need the ability to process the composed properties of an instance.
 * That is to say if an instance defines a property, it overrides any
 * definition in the service.  Otherwise, the service's definition is
 * inherited in the instance.
 *
 * In an entity_t, the sc_instance.sc_composed member points to a
 * uu_avl tree of composed property groups (composed_pg_t) for the
 * instance.  The composed_pg_t has two members, cpg_instance_pg and
 * cpg_service_pg, that point to the instance and service property group
 * definitions respectively.  Either of these may be NULL indicating that
 * only an instance or service definition exists in the manifest.
 *
 * In the case where both the instance and the service define a property
 * group, the properties must be composed.  This is done by
 * compose_props().  The compose_pg_t holds the composed properties in a
 * uu_avl_tree at cpf_compose_props.  This is a tree of property_t
 * structures.  If a property is defined in both the instance and service
 * property group, the tree will hold the instance definition.  If the
 * property is defined at only one level, the tree will hold the property_t
 * for that level.  Thus, the tree is truly a set of composed properties of
 * the property group.
 *
 * Property Group Iteration:
 * ------------------------
 * A number of functions must iterate through an instance's property groups
 * looking for the ones that define a pg_pattern or a prop_pattern.  To be
 * specific, the iteration starts with the composed view of the instance.
 * It then proceeds through the restarter information and finally moves on
 * to the global service.  The pg_iter_t structure holds the information
 * that is needed to implement this type of iteration.  pg_iter_create()
 * creates one of these iterators, and pg_iter_destroy() frees the memory
 * associated with the pg_iter_t.  next_pattern_pg(), is used to step
 * through the iteration.
 *
 * Error Reporting:
 * ---------------
 * While performing the templates validation checks, svccfg collects
 * information for all the errors that it finds.  Because of this you will
 * see many places in the code where a loop is not exited when an error is
 * encountered.  We note that fact that an error has occurred, but continue
 * in the loop to see if there are more validation errors.  The error code
 * of the last error that is encountered is returned.  This works, because
 * the callers of tmpl_validate_bundle() only look to see whether or not
 * the return code is TVS_SUCCESS.
 *
 * The information for reporting the errors is collected in a tmpl_errors_t
 * structure, and tmpl_validate_bundle() returns the address of this
 * structure.  The caller of tmpl_validate_bundle() can then call
 * tmpl_errors_print() to display the error information to the user.
 *
 * There are two categories of errors.  Some errors are seen when
 * processing the information in the manifest.  This type of error is only
 * seen by svccfg when it is importing or validating a manifest.  The other
 * type of error consists of template validation errors.  These errors can
 * be seen when processing a manifest or when performing a templates
 * validation of the information associated with an FMRI in the the
 * repository.  tmpl_errors_add_im() is used to capture error information
 * about the first type of error, and add_scf_error() is used to capture
 * error information about the second type of error.
 *
 * The distinction is important when printing the error information.  The
 * fuctions for printing the first type of error reside in this file, since
 * these errors will only be seen by the functions in this file.  The
 * functions for printing the template validation errors reside in libscf,
 * because these errors are of a more general nature.
 *
 * Thus, tmpl_errors_t has two lists -- one for each type of error.
 * te_list is a list of im_tmpl_error_t structures that represent the first
 * type of error.  te_scf is a list of tv_errors_t structures that hold
 * information about general template validation errors.
 * tmpl_errors_print() processes both lists to print information about all
 * errors.  In tmpl_errors_print() im_tmpl_error_print() is used to print
 * the errors that are specific to this file.  scf_tmpl_strerror() provides
 * the errors messages for general templates errors.
 *
 * As was mentioned in the previous paragraph, im_tmpl_error_print() is
 * responsible for printing the errors that are specific to this file.
 * Based on the error code, it dispatches to one of
 * im_perror_bad_conversion(), im_perror_bad_template(),
 * im_perror_invalid_type(), im_perror_missing_pg_type() or
 * im_perror_missing_type().  The rest of the im_perror_* functions provide
 * services to these error specific functions by printing common
 * information.
 *
 * im_perror_item() is the heart of this message printing subsystem.  It is
 * called directly or indirectly by all of the other im_perror_* functions.
 * im_perror_item() prints a single item of error information.  If svccfg
 * is running in interactive mode, im_perror_item() prints each item on a
 * single line, so that they are readable by a human.  In non-interactive
 * mode, all items are printed on a single line separated by semi-colons.
 */

#include <assert.h>
#include <errno.h>
#include <inttypes.h>
#include <libintl.h>
#include <limits.h>
#include <libscf.h>
#include <libscf_priv.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>
#include "svccfg.h"

/*
 * Clear error_info_t structure.
 */
#define CLEAR_ERROR_INFO(ei)    ((void) memset((ei), 0, sizeof (error_info_t)))

/*
 * Retrieve the property group pointer from the composed_pg structure.
 */
#define CPG2PG(cpg)     (cpg->cpg_instance_pg ? cpg->cpg_instance_pg : \
                            cpg->cpg_service_pg)

/*
 * Convert a pointer to an empty string into a NULL pointer.
 */
#define EMPTY_TO_NULL(p) (((p) && (*(p) == 0)) ? NULL : (p))

/* uu_avl and uu_list debugging bits. */
#ifdef  NDEBUG
#define TMPL_DEBUG_AVL_POOL     UU_DEFAULT
#define TMPL_DEBUG_LIST         UU_DEFAULT
#define TMPL_DEBUG_LIST_POOL    UU_DEFAULT
#define TMPL_DEBUG_TREE         UU_DEFAULT
#else
#define TMPL_DEBUG_AVL_POOL     UU_AVL_POOL_DEBUG
#define TMPL_DEBUG_LIST         UU_LIST_DEBUG
#define TMPL_DEBUG_LIST_POOL    UU_LIST_POOL_DEBUG
#define TMPL_DEBUG_TREE         UU_AVL_DEBUG
#endif  /* NDEBUG */

/*
 * Structures and enums that are used in producing error messages:
 *
 * error_info_t is used to pass information about an error to
 * tmpl_errors_add_im() and add_scf_error().  tmpl_errors_add_im() collects
 * the error information and stores it in an im_tmpl_error_t.  The
 * im_tmpl_error_t is linked into the tmpl_errors_t, so that the captured
 * information can be used later when error messages are printed.
 *
 * tv_errors_t is used to keep track of error information for general
 * template errors that are known by libscf.  add_scf_error() captures the
 * error information for use in this structure.
 */
/*
 * enum to designate the type of data that is held in a err_info structure.
 */
typedef enum err_info_type {
        EIT_NONE,               /* No values in the structure */
        EIT_BAD_TEMPLATE,       /* Reason that template is bad */
        EIT_CARDINALITY,        /* Ranges for property cardinality */
        EIT_INCLUDE_VALUES,     /* include_values type attribute */
        EIT_MISSING_PG,         /* Name of missing pg */
        EIT_MISSING_PROP,       /* Name of missing property */
        EIT_PATTERN_CONFLICT,   /* Conflicting pattern definition */
        EIT_PROP_TYPE,          /* Value with invalid type */
        EIT_RANGE               /* Value that is out of range */
} err_info_type_t;

/*
 * Structure to hold information that will be used in generating error
 * messages.
 */
typedef struct error_info {
        err_info_type_t ei_type;        /* Type of information stored here */
        union {
                /* EIT_BAD_TEMPLATE */
                struct {
                        const char      *ei_reason;
                } ei_bad_template;
                /* EIT_CARDINALITY */
                struct {
                        uint64_t        ei_min;
                        uint64_t        ei_max;
                        uint64_t        ei_count; /* Number of prop values */
                } ei_cardinality;
                /* EIT_INCLUDE_VALUES */
                struct {
                        const char      *ei_type;
                } ei_inc_values;
                /* EIT_MISSING_PG */
                struct {
                        const char      *ei_pg_name;    /* Name of missing pg */
                        const char      *ei_pg_type;    /* Type of missing pg */
                } ei_missing_pg;
                /* EIT_MISSING_PROP */
                struct {
                        const char      *ei_prop_name; /* Name of prop */
                } ei_missing_prop;
                /* EIT_PATTERN_CONFLICT */
                struct {
                        pgroup_t        *ei_pattern; /* Conficting pattern */
                } ei_pattern_conflict;
                /* EIT_PROP_TYPE */
                struct {
                        scf_type_t      ei_actual;
                        scf_type_t      ei_specified;
                } ei_prop_type;
                /* EIT_RANGE */
                struct {
                        scf_type_t      ei_rtype;
                        int64_t         ei_ivalue;
                        uint64_t        ei_uvalue;
                } ei_range;
        } ei_u;
} error_info_t;

/*
 * Structure with information about a template violation.  This structure
 * is for use with in memory representations of the manifest and template.
 * See scf_tmpl_error_t for use with repository representations.  Some of
 * the pointers may be NULL for some types of errors.
 */
typedef struct im_tmpl_error {
        tmpl_validate_status_t ite_type; /* Type of error */
        entity_t        *ite_entity;    /* Instance or service */
        pgroup_t        *ite_pg;        /* Non-conforming prop. group */
        pgroup_t        *ite_pg_pattern; /* Violated pg_pattern */
        property_t      *ite_prop;      /* Non-conforming property */
        pgroup_t        *ite_prop_pattern; /* Violated prop_pattern */
        value_t         *ite_value;     /* Non-conforming value */
        error_info_t    ite_einfo;      /* Extra error information */
        uu_list_node_t  ite_node;       /* Node to link us in a list. */
} im_tmpl_error_t;

/*
 * This structure holds the data that will be used by scf_tmpl_strerror()
 * for printing template validation errors.
 */
typedef struct tv_errors {
        scf_tmpl_errors_t *tve_errors;  /* Errors for scf_tmpl_strerror() */
        uu_list_node_t  tve_node;       /* Linkage in a list. */
} tv_errors_t;

/*
 * Structure to collect template validation errors.
 */
struct tmpl_errors {
        uu_list_t       *te_list;       /* List of im_tmpl_error_t */
        im_tmpl_error_t *te_next;       /* Next error to present */
        uu_list_t       *te_scf;        /* Errors for scf_tmpl_strerror() */
        tv_errors_t     *te_cur_scf;    /* Current member of te_scf */
};

/* End of structures used in error processing. */

/*
 * Property group types that are of interest to us.  See pgroup_type().
 */
typedef enum pg_type {
        NORMAL_PG,
        PG_PATTERN_PG,
        PROP_PATTERN_PG
} pg_type_t;

/*
 * Structure to keep track of a set of ASTRING property values for a
 * property.  The consumer may wish to have the ASTRING property values
 * converted to a numeric form which is the reason for the av_v union.
 * This structure is returned by av_get_values() and is accessed by
 * av_get_integer(), av_get_string() and av_get_unsigned().
 */
typedef struct avalues {
        uint_t          av_count;       /* Number of values */
        scf_type_t      av_type;        /* Type of value representation */
        union {
                uint64_t        *av_unsigned;   /* Count & boolean values */
                int64_t         *av_integer;    /* Integer values */
                const char      **av_string;    /* String values */
        } av_v;                         /* Container for the values */
} avalues_t;

/*
 * composed_pg_t contains the information that is needed to compose a
 * property group.  See the section on Composed Properties in the block
 * comment at the beginning of this file.  The composed_pg structures are
 * linked into a uu_avl tree.  The tree is at sc_instance.sc_composed in
 * the entity_t.
 */
struct composed_pg {
        /*
         * Property group is uniquely identified by its name and type.
         * These two elements point to the name and type in a pgroup_t
         * (either service or instance), so they do not need to be
         * allocated or freed.
         */
        const char      *cpg_name;
        const char      *cpg_type;

        /* References to the actual property group definitions. */
        pgroup_t        *cpg_instance_pg;
        pgroup_t        *cpg_service_pg;

        /* Composed properties of the property group. */
        uu_avl_t        *cpg_composed_props;

        uu_avl_node_t   cpg_node;       /* Linkage for AVL tree */
};

/*
 * Prefixes for standard property names.  Used in
 * include_values_support().
 */
typedef struct prop_prefix {
        const char      *pp_prefix;
        size_t          pp_size;
} prop_prefix_t;

/*
 * Store a legal range for a property allowing for either signed or
 * unsigned ranges.  It is used to store a range from a template
 * constraint element of a prop_pattern.  The structure is returned by
 * get_ranges() and is used by value_in_range() to validate the values of a
 * property.
 */
typedef struct range {
        union {
                struct {
                        uint64_t        rng_min;
                        uint64_t        rng_max;
                } rng_unsigned;
                struct {
                        int64_t         rng_min;
                        int64_t         rng_max;
                } rng_signed;
        } rng_u;
} range_t;

/*
 * This enum defines the levels where templates can be defined.  See the
 * pg_iter structure below.
 */
typedef enum tmpl_level {
        TL_NOLEVEL = 0,         /* No level yet specified. */
        TL_INSTANCE,            /* Instance templates. */
        TL_COMPOSED,            /* Composed instance. */
        TL_SERVICE,             /* Service wide templates. */
        TL_RESTARTER,           /* Templates from restarter manifest. */
        TL_GLOBAL               /* SMF wide templates. */
} tmpl_level_t;

/*
 * pg_iter is a structure that allows us to iterate through property groups
 * in an instance followed by the property groups of the instance's
 * service, the instance's restarter and finally the global service.  See
 * the Property Group Iteration section of the block comment at the
 * beginning of this file.
 */
typedef struct pg_iter {
        entity_t        *pgi_entity;    /* Entity being searched */
        const char      *pgi_restrict;  /* Only return PGs of this type */
        tmpl_level_t    pgi_level;      /* Current level */
        entity_t        *pgi_service;   /* Service being processed. */
        union {
                pgroup_t        *pgi_pg;
                composed_pg_t   *pgi_cpg;
        } pgi_current;                  /* Current property group. */
} pg_iter_t;

/*
 * enum to distinguish between pg_patterns and prop_patterns.  It is used
 * in the ptrn_info_t structure.  See below.
 */
typedef enum ptrn_type {
        PG_PATTERN,
        PROP_PATTERN
} ptrn_type_t;

/*
 * Structure of information about a pg_pattern or a prop_pattern.  It is
 * used for template consistency checks.  gather_pattern() is used to
 * gather information for all the pg_patterns or prop_patterns in an
 * instance.  It allocates a ptrn_info_t for each of these and adds them to
 * an avl tree that is held by tmpl_consistency().
 */
typedef struct ptrn_info {
        ptrn_type_t     pi_ptrn_type;
        pgroup_t        *pi_ptrnpg;     /* pgroup_t defining the pattern. */
        const char      *pi_name;       /* Name attribute. */
        const char      *pi_type;       /* Type attribute. */
        const char      *pi_target;     /* Target attribute - only PG_PATTERN */
        const char      *pi_pgp_name;   /* Name of the pg pattern.  Only */
                                        /* used for PROP_PATTERN. */
        pgroup_t        *pi_enc_pgp;    /* PG of the pg_pattern that holds */
                                        /* the prop_pattern defined by this */
                                        /* structure.  Only used for */
                                        /* PROP_PATTERN. */
        uu_avl_node_t   pi_link;        /* Linkage into AVL tree */
} ptrn_info_t;

static const char *emesg_nomem;

/*
 * Pool for trees of composed property groups.
 */
static uu_avl_pool_t *composed_pg_pool;

/*
 * Pool for trees of composed properties.
 */
static uu_avl_pool_t *composed_prop_pool;

/*
 * Pool for lists of errors in the internal representation.
 */
static uu_list_pool_t *inmem_errors_pool;

/*
 * Pool for trees of pg_pattern info structures (ptrn_info_t).
 */
static uu_avl_pool_t *ptrn_info_pool;

/*
 * Pool for lists of template errors in the libscf representation.
 */
static uu_list_pool_t *tv_errors_pool;

/*
 * Property name prefixes for constraints and values.
 */
static const char *constraint_prefixes[] = {
        SCF_PROPERTY_TM_CONSTRAINT_NAME,
        SCF_PROPERTY_TM_CONSTRAINT_RANGE,
        NULL
};
static const char *value_prefixes[] = {
        SCF_PROPERTY_TM_VALUE_PREFIX,
        NULL
};

/*
 * Function to compare two composed_pg structures.
 */
/* ARGSUSED2 */
static int
composed_pg_compare(const void *left, const void *right, void *unused)
{
        composed_pg_t *l = (composed_pg_t *)left;
        composed_pg_t *r = (composed_pg_t *)right;
        int rc;

        if ((rc = strcmp(l->cpg_name, r->cpg_name)) == 0) {
                rc = strcmp(l->cpg_type, r->cpg_type);
        }
        return (rc);
}

/* ARGSUSED2 */
static int
composed_prop_compare(const void *left, const void *right, void *unused)
{
        property_t *l = (property_t *)left;
        property_t *r = (property_t *)right;

        return (strcmp(l->sc_property_name, r->sc_property_name));
}

static composed_pg_t *
composed_pg_create()
{
        composed_pg_t *cpg;

        cpg = safe_malloc(sizeof (*cpg));
        uu_avl_node_init(cpg, &cpg->cpg_node, composed_pg_pool);
        return (cpg);
}

static void
composed_pg_destroy(composed_pg_t *cpg)
{
        void *marker = NULL;
        pgroup_t *pg;

        if (cpg == NULL)
                return;
        /* Tear down composed property tree if we have one. */
        if ((cpg->cpg_composed_props != NULL)) {
                while (uu_avl_teardown(cpg->cpg_composed_props, &marker) !=
                    NULL) {
                        /*
                         * Nothing to do other than getting the property
                         * out of the list.  This cleans up the property's
                         * uu_avl_node.
                         */
                }
                uu_avl_destroy(cpg->cpg_composed_props);
        }

        /* Clean up any pgroup_t references to us. */
        if ((pg = cpg->cpg_instance_pg) != NULL) {
                assert((pg->sc_pgroup_composed == NULL) ||
                    (pg->sc_pgroup_composed == cpg));
                pg->sc_pgroup_composed = NULL;
        }

        uu_avl_node_fini(cpg, &cpg->cpg_node, composed_pg_pool);
        free(cpg);
}

/*
 * Walk the property group at pg, and add its properties to the AVL tree at
 * tree.
 */
static void
grow_props_tree(pgroup_t *pg, uu_avl_t *tree)
{
        uu_avl_index_t marker;
        property_t *prop;

        for (prop = uu_list_first(pg->sc_pgroup_props);
            prop != NULL;
            prop = uu_list_next(pg->sc_pgroup_props, prop)) {
                if (uu_avl_find(tree, prop, NULL, &marker) == NULL) {
                        /*
                         * If there was no match, insert the property into
                         * the tree.  If we do get a match, there is
                         * nothing to do.  That is because we rely on our
                         * caller to process the instance properties first,
                         * and the instance properties override the service
                         * properties.
                         */
                        uu_avl_insert(tree, prop, marker);
                }
        }
}

/*
 * The composed properties are stored in a uu_avl_tree.  First we populate
 * the tree with properties from the instance level property group.  Then,
 * we'll add the properties from the service level property group.
 */
static void
compose_props(composed_pg_t *cpg)
{
        uu_avl_t *tree;

        tree = uu_avl_create(composed_prop_pool, cpg, TMPL_DEBUG_TREE);
        if (tree == NULL) {
                uu_die(gettext("composed_pool tree creation failed: %s\n"),
                    uu_strerror(uu_error()));
        }
        cpg->cpg_composed_props = tree;

        /*
         * compose_props() is only called when there is both an instance
         * and a service definition of the property group.  This implies
         * that neither cpg->cpg_instance_pg nor cpg->cpg_service_pg can be
         * NULL.
         */
        /*
         * First add instance properties to the tree.
         */
        assert(cpg->cpg_instance_pg != NULL);
        grow_props_tree(cpg->cpg_instance_pg, tree);

        /*
         * Add service properties to the tree.
         */
        assert(cpg->cpg_service_pg != NULL);
        grow_props_tree(cpg->cpg_service_pg, tree);
}

/*
 * This function is a utility for build_composed_instance().
 */
static void
build_composed_property_groups(entity_t *inst, uu_avl_t *tree)
{
        composed_pg_t *cpg;
        uu_avl_index_t marker;
        composed_pg_t *match;
        pgroup_t *pg;
        entity_t *svc;

        /* First capture the instance property groups. */
        for (pg = uu_list_first(inst->sc_pgroups);
            pg != NULL;
            pg = uu_list_next(inst->sc_pgroups, pg)) {
                cpg = composed_pg_create();
                cpg->cpg_name = pg->sc_pgroup_name;
                cpg->cpg_type = pg->sc_pgroup_type;
                cpg->cpg_instance_pg = pg;
                match = uu_avl_find(tree, cpg, NULL, &marker);
                /* Since we do the instance first, there should be no match. */
                assert(match == NULL);
                uu_avl_insert(tree, cpg, marker);
                pg->sc_pgroup_composed = cpg;
        }

        /* Now capture the service property groups. */
        svc = inst->sc_parent;
        cpg = NULL;
        for (pg = uu_list_first(svc->sc_pgroups);
            pg != NULL;
            pg = uu_list_next(svc->sc_pgroups, pg)) {
                if (cpg == NULL)
                        cpg = composed_pg_create();
                cpg->cpg_name = pg->sc_pgroup_name;
                cpg->cpg_type = pg->sc_pgroup_type;
                cpg->cpg_service_pg = pg;
                match = uu_avl_find(tree, cpg, NULL, &marker);
                if (match == NULL) {
                        uu_avl_insert(tree, cpg, marker);
                        /* Get new composed_pg_t next at top of loop. */
                        cpg = NULL;
                } else {
                        /*
                         * Already have a composed_pg from instance
                         * processing.  Just add the pointer to the service
                         * pg and compose the properties.
                         */
                        match->cpg_service_pg = pg;
                        compose_props(match);
                }
        }
        if (cpg != NULL)
                composed_pg_destroy(cpg);
}

static void
build_composed_instance(entity_t *inst)
{
        uu_avl_t *tree;

        assert(inst->sc_etype == SVCCFG_INSTANCE_OBJECT);

        if (inst->sc_u.sc_instance.sc_composed == NULL) {
                tree = uu_avl_create(composed_pg_pool, inst, TMPL_DEBUG_TREE);
                if (tree == NULL) {
                        uu_die(gettext("composed_instance tree creation "
                            "failed: %s\n"), uu_strerror(uu_error()));
                }
                inst->sc_u.sc_instance.sc_composed = tree;
        }
        build_composed_property_groups(inst,
            inst->sc_u.sc_instance.sc_composed);
}

static void
demolish_composed_instance(entity_t *inst)
{
        composed_pg_t *cpg;
        void *marker = NULL;
        uu_avl_t *tree;

        tree = inst->sc_u.sc_instance.sc_composed;
        if (tree == NULL)
                return;

        marker = NULL;
        while ((cpg = uu_avl_teardown(tree, &marker)) != NULL) {
                composed_pg_destroy(cpg);
        }
        uu_avl_destroy(tree);

        inst->sc_u.sc_instance.sc_composed = NULL;
}
/*
 * Return the number of values in prop.
 */
static size_t
count_prop_values(property_t *prop)
{
        return (uu_list_numnodes(prop->sc_property_values));
}

static int
is_numeric_type(scf_type_t type)
{
        if (type == SCF_TYPE_BOOLEAN)
                return (1);
        if (type == SCF_TYPE_COUNT)
                return (1);
        if (type == SCF_TYPE_INTEGER)
                return (1);
        return (0);
}

static pg_type_t
pgroup_type(pgroup_t *pg)
{
        if (strcmp(pg->sc_pgroup_type, SCF_GROUP_TEMPLATE_PG_PATTERN) == 0)
                return (PG_PATTERN_PG);
        if (strcmp(pg->sc_pgroup_type, SCF_GROUP_TEMPLATE_PROP_PATTERN) == 0)
                return (PROP_PATTERN_PG);
        return (NORMAL_PG);
}

/*
 * Search the property group at pg for a property named name.  If the
 * property group has a tree of composed properties, the tree will be
 * searched for the property.  Otherwise, the property group's linked list
 * will be searched.
 */
static property_t *
property_find(pgroup_t *pg, const char *name)
{
        composed_pg_t *cpg;
        property_t look;

        cpg = pg->sc_pgroup_composed;

        if ((cpg == NULL) || (cpg->cpg_composed_props == NULL)) {
                /* This is not a composed property group. */
                return (internal_property_find(pg, name));
        }

        /*
         * This is a composed property group, so look for the property in
         * the AVL tree.
         */
        look.sc_property_name = (char *)name;
        return (uu_avl_find(cpg->cpg_composed_props, &look, NULL, NULL));
}

/*
 * Functions for manipulating the avalues structure.
 */

/*
 * Free allocated memory referenced by the avalues structure.  Then, free
 * the structure itself.
 */
static void
av_destroy(avalues_t *av)
{
        if (av == NULL)
                return;
        switch (av->av_type) {
        case SCF_TYPE_BOOLEAN:
        case SCF_TYPE_COUNT:
                uu_free(av->av_v.av_unsigned);
                break;
        case SCF_TYPE_INTEGER:
                uu_free(av->av_v.av_integer);
                break;
        default:
                /*
                 * We don't need to free the strings that are referenced by
                 * av_string.  The strings are held in propery_t structures
                 * that will be freed at a later time.
                 */
                uu_free(av->av_v.av_string);
                break;
        }
        uu_free(av);
}
/*
 * Allocate and inialize an avalues structure.  count represents the
 * number of values the structure is expected to hold.  type specifies how
 * the consumer of the property values would like to see them represented.
 * See comments for the av_get_values() more details on how type is used.
 *
 * The returned structure must be freed by calling av_destroy().
 *
 * NULL is returned if memory allocation fails.
 */
static avalues_t *
av_create(size_t count, scf_type_t type)
{
        uint_t alloc_failed = 0;
        avalues_t *av;

        av = uu_zalloc(sizeof (*av));
        if (av == NULL)
                return (NULL);
        av->av_count = count;
        av->av_type = type;
        switch (type) {
        case SCF_TYPE_BOOLEAN:
        case SCF_TYPE_COUNT:
                av->av_v.av_unsigned = uu_zalloc(count * sizeof (uint64_t));
                if (av->av_v.av_unsigned == NULL)
                        alloc_failed = 1;
                break;
        case SCF_TYPE_INTEGER:
                av->av_v.av_integer = uu_zalloc(count * sizeof (int64_t));
                if (av->av_v.av_integer == NULL)
                        alloc_failed = 1;
                break;
        default:
                av->av_v.av_string = uu_zalloc(count * sizeof (char *));
                if (av->av_v.av_string == NULL)
                        alloc_failed = 1;
        }
        if (alloc_failed) {
                av_destroy(av);
                return (NULL);
        }
        return (av);
}

/*
 * Return the ith integer value in av.
 */
static int64_t
av_get_integer(avalues_t *av, uint_t i)
{
        assert(av->av_type == SCF_TYPE_INTEGER);
        assert(i < av->av_count);
        return (*(av->av_v.av_integer + i));
}

/*
 * Return the ith string value in av.
 */
static const char *
av_get_string(avalues_t *av, uint_t i)
{
        assert(is_numeric_type(av->av_type) == 0);
        assert(i < av->av_count);
        return (*(av->av_v.av_string + i));
}

/*
 * Return the ith unsigned value in av.
 */
static uint64_t
av_get_unsigned(avalues_t *av, uint_t i)
{
        assert((av->av_type == SCF_TYPE_BOOLEAN) ||
            (av->av_type == SCF_TYPE_COUNT));
        assert(i < av->av_count);
        return (*(av->av_v.av_unsigned + i));
}

/*
 * Store the value in the ith slot of the av structure.  If av is being
 * used to store numeric values, the string at value will be converted to
 * the appropriate numeric form.
 */
static tmpl_validate_status_t
av_set_value(avalues_t *av, uint_t i, const char *value)
{
        char *endptr;
        int64_t n;
        uint64_t un;

        if (is_numeric_type(av->av_type)) {
                switch (av->av_type) {
                case SCF_TYPE_BOOLEAN:
                case SCF_TYPE_COUNT:
                        un = strtoull(value, &endptr, 0);
                        if ((endptr == value) || (*endptr != 0)) {
                                return (TVS_BAD_CONVERSION);
                        }
                        *(av->av_v.av_unsigned + i) = un;
                        break;
                case SCF_TYPE_INTEGER:
                        n = strtoll(value, &endptr, 0);
                        if ((endptr == value) || (*endptr != 0)) {
                                return (TVS_BAD_CONVERSION);
                        }
                        *(av->av_v.av_integer + i) = n;
                }
        } else {
                *(av->av_v.av_string + i) = value;
        }

        return (TVS_SUCCESS);
}

/*
 * Find the property whose name is prop_name in the property group at pg.
 * Read all the values of this property and return them in an avalues
 * structure placing the address of the structure in *values.  The caller
 * must free the structure by calling av_destroy().
 *
 * The type parameter is used to indicate the type of information that the
 * caller would like to consume.  If it is one of the numeric types, the
 * property value will be converted to the appropriate numeric type before
 * placing it in the avalues struct.  Decoding will be done before the
 * conversion if necessary.
 */
static tmpl_validate_status_t
av_get_values(pgroup_t *pg, const char *prop_name, scf_type_t type,
    avalues_t **values)
{
        avalues_t *av;
        uint_t i;
        property_t *prop;
        tmpl_validate_status_t rc;
        value_t *v;

        prop = property_find(pg, prop_name);
        if (prop == NULL) {
                return (TVS_NOMATCH);
        }
        assert(prop->sc_value_type == SCF_TYPE_ASTRING);
        av = av_create(count_prop_values(prop), type);
        if (av == NULL)
                uu_die(emesg_nomem);

        /* Collect the values. */
        for ((v = uu_list_first(prop->sc_property_values)), i = 0;
            v != NULL;
            (v = uu_list_next(prop->sc_property_values, v)), i++) {
                assert(i < av->av_count);
                assert(v->sc_type == SCF_TYPE_ASTRING);
                rc = av_set_value(av, i, v->sc_u.sc_string);
                if (rc != TVS_SUCCESS) {
                        av_destroy(av);
                        return (rc);
                }
        }
        *values = av;
        return (TVS_SUCCESS);
}

/*
 * Find the property in pg whose name is prop_name.  Return a pointer to
 * the first astring value in that property.
 *
 * NULL is returned if there is no property named prop_name or if it does
 * not have an astring value.
 */
static const char *
find_astring_value_in_pg(pgroup_t *pg, const char *prop_name)
{
        property_t *prop;
        value_t *v;

        prop = property_find(pg, prop_name);
        if (prop == NULL)
                return (NULL);
        if (prop->sc_value_type != SCF_TYPE_ASTRING)
                return (NULL);
        v = uu_list_first(prop->sc_property_values);
        if (v == NULL)
                return (NULL);
        assert(v->sc_type == SCF_TYPE_ASTRING);
        return (v->sc_u.sc_string);
}
/*
 * Find the first property value of type SCF_TYPE_COUNT in the property at
 * prop.  Return the value to count.
 */
static tmpl_validate_status_t
find_count_value(property_t *prop, uint64_t *count)
{
        value_t *value;

        assert(prop->sc_value_type == SCF_TYPE_COUNT);
        value = uu_list_first(prop->sc_property_values);
        if (value == NULL)
                return (TVS_NOMATCH);
        *count = value->sc_u.sc_count;
        return (TVS_SUCCESS);
}

/*
 * pattern is a property group representing a pg_pattern or a
 * prop_pattern.  This function returns the name specification from the
 * pg_pattern or prop_pattern.
 */
static const char *
find_name_specification(pgroup_t *pattern)
{
        return (find_astring_value_in_pg(pattern, SCF_PROPERTY_TM_NAME));
}

/*
 * pattern is a property group representing a pg_pattern or a prop_pattern.
 * This function returns the type specification from the pg_pattern or
 * prop_pattern.
 */
static const char *
find_type_specification(pgroup_t *pattern)
{
        return (find_astring_value_in_pg(pattern, SCF_PROPERTY_TM_TYPE));
}

/*
 * Find the FMRI of the restarter for the entity, e.  The restarter is the
 * value of the "restarter" property in the "general" property group.
 */
static const char *
find_restarter(entity_t *e)
{
        pgroup_t *pg;
        property_t *prop;
        value_t *v;

        pg = internal_pgroup_find(e, scf_pg_general, scf_group_framework);
        if (pg != NULL) {
                prop = property_find(pg, SCF_PROPERTY_RESTARTER);
                if ((prop != NULL) && (prop->sc_value_type == SCF_TYPE_FMRI)) {
                        v = uu_list_first(prop->sc_property_values);
                        if (v != NULL)
                                return (v->sc_u.sc_string);
                }
        }

        /*
         * Didn't find the restarter.
         */
        return (NULL);
}

/*
 * prop_pattern points to a prop_pattern.  This function finds the
 * cardinality specification in the prop_pattern and returns the minimum
 * and maximum values of the cardinality.
 *
 * Returns TVS_NOMATCH if either the cardinality minimum or maximum are
 * missing.
 */
static tmpl_validate_status_t
get_cardinality(pgroup_t *prop_pattern, uint64_t *min, uint64_t *max)
{
        property_t *prop;
        tmpl_validate_status_t rc;

        assert(strcmp(prop_pattern->sc_pgroup_type,
            SCF_GROUP_TEMPLATE_PROP_PATTERN) == 0);

        prop = property_find(prop_pattern,
            SCF_PROPERTY_TM_CARDINALITY_MIN);
        if (prop == NULL)
                return (TVS_NOMATCH);
        rc = find_count_value(prop, min);
        if (rc != TVS_SUCCESS)
                return (rc);

        prop = property_find(prop_pattern,
            SCF_PROPERTY_TM_CARDINALITY_MAX);
        if (prop == NULL)
                return (TVS_NOMATCH);
        rc = find_count_value(prop, max);

        return (rc);
}

/*
 * Ranges are represented as ASTRING values in the property at range_prop.
 * The minimum and maximum of the range are separated by a comma.
 *
 * range_prop can contain multiple range values, so we return a pointer to
 * an allocated array of range_t in ranges.  This array must be freed by
 * the caller using free().  count receives the number of range_t
 * structures that are allocated.
 *
 * type tells us whether the range values should be treated as signed or
 * unsigned.  It must be SCF_TYPE_COUNT or SCF_TYPE_INTEGER.
 */
static tmpl_validate_status_t
get_ranges(property_t *range_prop, scf_type_t type, range_t **ranges,
    uint_t *count)
{
        char *endptr;
        char *endptr2;
        range_t *r;
        value_t *value;

        *count = uu_list_numnodes(range_prop->sc_property_values);
        assert(*count != 0);
        r = safe_malloc(*count * sizeof (*r));
        *ranges = r;
        for (value = uu_list_first(range_prop->sc_property_values);
            value != NULL;
            value = uu_list_next(range_prop->sc_property_values, value)) {
                assert(value->sc_type == SCF_TYPE_ASTRING);

                /* First get the minimum */
                errno = 0;
                if (type == SCF_TYPE_INTEGER) {
                        r->rng_u.rng_signed.rng_min =
                            strtoll(value->sc_u.sc_string, &endptr, 0);
                } else {
                        r->rng_u.rng_unsigned.rng_min =
                            strtoull(value->sc_u.sc_string, &endptr, 0);
                }
                if ((errno != 0) || (endptr == value->sc_u.sc_string))
                        goto badtemplate;
                if (*endptr != ',')
                        goto badtemplate;

                /* Now get the maximum */
                endptr++;
                if (type == SCF_TYPE_INTEGER) {
                        r->rng_u.rng_signed.rng_max =
                            strtoll(endptr, &endptr2, 0);
                } else {
                        r->rng_u.rng_unsigned.rng_max =
                            strtoull(endptr, &endptr2, 0);
                }
                if ((errno != 0) || (endptr2 == endptr) ||
                    (*endptr2 != 0))
                        goto badtemplate;
                r++;
        }

        return (TVS_SUCCESS);

badtemplate:
        free(*ranges);
        *ranges = NULL;
        return (TVS_BAD_TEMPLATE);
}

static tv_errors_t *
tv_errors_create(const char *fmri)
{
        tv_errors_t *ste;

        ste = safe_malloc(sizeof (*ste));
        uu_list_node_init(ste, &ste->tve_node, tv_errors_pool);
        ste->tve_errors = _scf_create_errors(fmri, 1);
        if (ste->tve_errors == NULL)
                uu_die(emesg_nomem);

        return (ste);
}

static void
destroy_scf_errors(tv_errors_t *ste)
{
        scf_tmpl_errors_destroy(ste->tve_errors);
        uu_list_node_fini(ste, &ste->tve_node, tv_errors_pool);
        free(ste);
}

/*
 * Given a property group and the name of a property within that property
 * group, generate the name of the property group that holds the
 * prop_pattern information for the property.  The address of the generated
 * name is returned to prop_pattern_pg_name.  The memory holding the
 * generated name must be freed using uu_free().
 */
static tmpl_validate_status_t
gen_prop_pattern_pg_name(pgroup_t *pg_pattern, const char *prop_name,
    char **prop_pattern_pg_name)
{
        ssize_t limit;
        char *name;
        size_t prefix_size;
        const char *unique;

        limit = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH) + 1;
        assert(limit > 0);

        /* Get the unique part of the pg_pattern's property group name. */
        prefix_size = strlen(SCF_PG_TM_PG_PAT_BASE);
        assert(strncmp(pg_pattern->sc_pgroup_name, SCF_PG_TM_PG_PAT_BASE,
            prefix_size) == 0);
        unique = pg_pattern->sc_pgroup_name + prefix_size;

        /* Construct the prop pattern property group name. */
        *prop_pattern_pg_name = NULL;
        name = uu_zalloc(limit);
        if (name == NULL)
                uu_die(emesg_nomem);
        if (snprintf(name, limit, "%s%s_%s", SCF_PG_TM_PROP_PATTERN_PREFIX,
            unique, prop_name) >= limit) {
                uu_free(name);
                return (TVS_BAD_TEMPLATE);
        }
        *prop_pattern_pg_name = name;
        return (TVS_SUCCESS);
}

/*
 * Error message printing functions:
 */

/*
 * Flags for use by im_perror_item.
 */
#define IPI_NOT_FIRST   0x1     /* Not first item to be displayed. */

/*
 * Print a single item of information about a validation failure.  This
 * function takes care of printing the appropriate decoration before the
 * first item and between subsequent items.
 *
 * Parameters:
 *      out             Stream to receive the output.
 *      desc            Text describing the items
 *      item            Address of the item to be displayed
 *      type            Type of the item
 *      flags           Used by im_perror_item to keep track of where it
 *                      is.  Caller should set flags to 0 before calling
 *                      this function with the first item.
 */
static void
im_perror_item(FILE *out, const char *desc, void *item, scf_type_t type,
    int *flags)
{
        const char *cp;
        const char *first_sep;
        int64_t ival;
        const char *subsequent_sep;
        uint64_t uval;

        /* Nothing to print if item is NULL. */
        if (item == NULL)
                return;

        assert(type != SCF_TYPE_INVALID);

        /* Establish separators for environment. */
        if (est->sc_cmd_flags & SC_CMD_IACTIVE) {
                /* Interactive mode - make messages readable */
                first_sep = ":\n\t";
                subsequent_sep = "\n\t";
        } else {
                /* Non-interactive - one line messages. */
                first_sep = ": ";
                subsequent_sep = "; ";
        }

        /* Print separator and description */
        if (*flags & IPI_NOT_FIRST) {
                (void) fprintf(out, subsequent_sep);
        } else {
                (void) fprintf(out, first_sep);
                *flags |= IPI_NOT_FIRST;
        }
        (void) fprintf(out, "%s=", desc);

        switch (type) {
        case SCF_TYPE_BOOLEAN:
                uval = *((uint64_t *)item);
                if (uval) {
                        (void) fprintf(out, "\"%s\"", gettext("true"));
                } else {
                        (void) fprintf(out, "\"%s\"", gettext("false"));
                }
                break;
        case SCF_TYPE_COUNT:
                uval = *((uint64_t *)item);
                (void) fprintf(out, "%" PRIu64, uval);
                break;
        case SCF_TYPE_INTEGER:
                ival = *((int64_t *)item);
                (void) fprintf(out, "%" PRIi64, ival);
                break;
        default:
                /*
                 * Treat everything else as a string, but escape any
                 * internal quotes.
                 */
                (void) fputc('\"', out);
                cp = (const char *)item;
                while (*cp != 0) {
                        if (*cp == '\"') {
                                (void) fprintf(out, "\\\"");
                        } else {
                                (void) fputc(*cp, out);
                        }
                        cp++;
                }
                (void) fputc('\"', out);
                break;
        }
}

/*
 * Print erroneous FMRI.
 */
static void
im_perror_fmri(FILE *out, im_tmpl_error_t *i, int *flags)
{
        if (i->ite_entity != NULL) {
                im_perror_item(out, "FMRI", (void *)i->ite_entity->sc_fmri,
                    SCF_TYPE_FMRI, flags);
        }
}

/*
 * Print erroneous property group name.
 */
static void
im_perror_pg_name(FILE *out, im_tmpl_error_t *i, int *flags)
{
        if (i->ite_pg != NULL) {
                im_perror_item(out, gettext("Property group"),
                    (void *)i->ite_pg->sc_pgroup_name, SCF_TYPE_ASTRING,
                    flags);
        }
}

/*
 * If srcflag is 1, print the template source of the pg_pattern or
 * prop_pattern at pattern.  Always print the name and type of the pattern.
 */
static void
im_perror_pattern_info(FILE *out, pgroup_t *pattern, int *flags, int srcflag)
{
        void *c;
        const char *name_string;
        const char *type_string;

        if (pattern == NULL)
                return;
        switch (pgroup_type(pattern)) {
        case PG_PATTERN_PG:
                name_string = gettext("pg_pattern name");
                type_string = gettext("pg_pattern type");
                break;
        case PROP_PATTERN_PG:
                name_string = gettext("prop_pattern name");
                type_string = gettext("prop_pattern type");
                break;
        default:
                assert(0);
                abort();
        }
        if (srcflag) {
                im_perror_item(out, gettext("Template source"),
                    (void *)pattern->sc_parent->sc_fmri, SCF_TYPE_FMRI, flags);
        }
        c = (void *)find_name_specification(pattern);
        im_perror_item(out, name_string,
            (c == NULL) ? "" : c, SCF_TYPE_ASTRING, flags);
        c = (void *)find_type_specification(pattern);
        im_perror_item(out, type_string,
            (c == NULL) ? "" : c, SCF_TYPE_ASTRING, flags);
}

/*
 * Print information about the template specifications that were violated,
 * so that the user can find the specification.
 */
static void
im_perror_template_info(FILE *out, im_tmpl_error_t *i, int *flags)
{
        pgroup_t *pg_pattern = i->ite_pg_pattern;
        pgroup_t *prop_pattern = i->ite_prop_pattern;
        int srcflag = 1;

        if (pg_pattern != NULL) {
                im_perror_pattern_info(out, pg_pattern, flags, srcflag);
                srcflag = 0;
        }
        if (prop_pattern != NULL) {
                im_perror_pattern_info(out, prop_pattern, flags, srcflag);
        }
}

/* Print error message for TVS_BAD_CONVERSION errors. */
static void
im_perror_bad_conversion(FILE *out, im_tmpl_error_t *i, const char *prefix)
{
        int flags = 0;

        (void) fprintf(out, gettext("%sUnable to convert property value"),
            prefix);
        im_perror_fmri(out, i, &flags);
        im_perror_pg_name(out, i, &flags);
        im_perror_item(out, gettext("Property"),
            (void *)i->ite_prop->sc_property_name, SCF_TYPE_ASTRING, &flags);
        im_perror_template_info(out, i, &flags);
        (void) fputc('\n', out);
}

/* Print error message for TVS_BAD_TEMPLATE errors. */
static void
im_perror_bad_template(FILE *out, im_tmpl_error_t *i, const char *prefix)
{
        int flags = 0;

        assert(i->ite_einfo.ei_type == EIT_BAD_TEMPLATE);
        (void) fprintf(out, gettext("%sInvalid template - %s"), prefix,
            i->ite_einfo.ei_u.ei_bad_template.ei_reason);
        im_perror_fmri(out, i, &flags);
        im_perror_template_info(out, i, &flags);
        (void) fputc('\n', out);
}

/*
 * Print error message for TVS_INVALID_TYPE_SPECIFICATION errors.  This
 * error occurs if a prop_pattern has an invalid type specification.  Thus,
 * it is an indication of an invalid template rather than a violation of a
 * template.
 */
static void
im_perror_invalid_type(FILE *out, im_tmpl_error_t *i, const char *prefix)
{
        int flags = 0;
        const char *prop_pattern_name;

        (void) fprintf(out, gettext("%sInvalid type in prop_pattern"), prefix);
        im_perror_pg_name(out, i, &flags);
        if (i->ite_prop_pattern != NULL) {
                prop_pattern_name =
                    find_name_specification(i->ite_prop_pattern);
                im_perror_item(out, gettext("prop_pattern name"),
                    (void *)prop_pattern_name, SCF_TYPE_ASTRING, &flags);
        }
        im_perror_template_info(out, i, &flags);
        (void) fputc('\n', out);
}

/*
 * Print error message for TVS_MISSING_PG_TYPE errors.  In this case the
 * template specifies a type, but the property group itself has no type.
 */
static void
im_perror_missing_pg_type(FILE *out, im_tmpl_error_t *i, const char *prefix)
{
        int flags = 0;
        const char *type_spec;

        (void) fprintf(out, gettext("%sProperty group has no type"), prefix);
        im_perror_fmri(out, i, &flags);
        im_perror_pg_name(out, i, &flags);
        if (i->ite_pg_pattern != NULL) {
                type_spec = find_type_specification(i->ite_pg_pattern);
                im_perror_item(out, gettext("Type specified in pg_pattern"),
                    (void *)type_spec, SCF_TYPE_ASTRING, &flags);
        }
        (void) fputc('\n', out);
}

/*
 * Print error message for TVS_MISSING_TYPE_SPECIFICATION errors.  A
 * property group has a "required" attribute of true, but it does not have
 * a type specification.
 */
static void
im_perror_missing_type(FILE *out, im_tmpl_error_t *i, const char *prefix)
{
        int flags = 0;
        const char *pg_pattern_name;

        (void) fprintf(out, gettext("%sPg_pattern with true required attribute "
            "is missing the type attribute"), prefix);
        im_perror_fmri(out, i, &flags);
        if (i->ite_pg_pattern != NULL) {
                pg_pattern_name = find_name_specification(i->ite_pg_pattern);
                im_perror_item(out, gettext("Pg_pattern name"),
                    (void *)pg_pattern_name, SCF_TYPE_ASTRING, &flags);
        }
        im_perror_template_info(out, i, &flags);
        (void) fputc('\n', out);
}

static void
im_tmpl_error_print(FILE *out, im_tmpl_error_t *ite, const char *prefix)
{
        switch (ite->ite_type) {
        case TVS_BAD_CONVERSION:
                im_perror_bad_conversion(out, ite, prefix);
                break;
        case TVS_BAD_TEMPLATE:
                im_perror_bad_template(out, ite, prefix);
                break;
        case TVS_INVALID_TYPE_SPECIFICATION:
                im_perror_invalid_type(out, ite, prefix);
                break;
        case TVS_MISSING_PG_TYPE:
                im_perror_missing_pg_type(out, ite, prefix);
                break;
        case TVS_MISSING_TYPE_SPECIFICATION:
                im_perror_missing_type(out, ite, prefix);
                break;
        case TVS_NOMATCH:
                /*
                 * TVS_NOMATCH should be handled where it occurs.  Thus,
                 * there are no error messages associated with it.
                 */
                assert(0);
                abort();
                break;
        case TVS_SUCCESS:
                break;
        default:
                assert(0);
                abort();
        }
}

static char *
int64_to_str(int64_t i)
{
        char *c;
        const char *fmt;
        int size;

        fmt = "%" PRIi64;
        size = snprintf(NULL, 0, fmt, i) + 1;
        c = safe_malloc(size);
        (void) snprintf(c, size, fmt, i);
        return (c);
}

static char *
uint64_to_str(uint64_t u)
{
        char *c;
        const char *fmt;
        int size;

        fmt = "%" PRIu64;
        size = snprintf(NULL, 0, fmt, u) + 1;
        c = safe_malloc(size);
        (void) snprintf(c, size, fmt, u);
        return (c);
}

/*
 * Convert the value to a string.  The returned value must be freed using
 * free(3C).
 */
static const char *
value_to_string(value_t *v)
{
        char *c;

        if (is_numeric_type(v->sc_type)) {
                switch (v->sc_type) {
                case SCF_TYPE_BOOLEAN:
                        if (v->sc_u.sc_count == 0) {
                                c = gettext("false");
                        } else {
                                c = gettext("true");
                        }
                        break;
                case SCF_TYPE_COUNT:
                        c = uint64_to_str(v->sc_u.sc_count);
                        return (c);
                case SCF_TYPE_INTEGER:
                        c = int64_to_str(v->sc_u.sc_integer);
                        return (c);
                default:
                        /* unhandled numeric type */
                        abort();
                }
        } else {
                c = v->sc_u.sc_string;
        }

        return (safe_strdup(c));
}

/*
 * Subscripts for common error data.
 */
#define ED_PG_NAME      0
#define ED_PROP_NAME    1
#define ED_TMPL_FMRI    2
#define ED_TMPL_PG_NAME 3
#define ED_TMPL_PG_TYPE 4
#define ED_TMPL_PROP_NAME       5
#define ED_TMPL_PROP_TYPE       6
#define ED_COUNT        7

/*
 * This function converts the error information specified by the function
 * parameters.  It converts it to form needed by _scf_tmpl_add_error().
 * _scf_tmpl_add_error() requires that the error information be in the form
 * of allocated strings that can be freed when it is done with them.  Thus,
 * the bulk of this function is devoted to producing those allocated
 * strings.
 *
 * Once the strings are ready, we call _scf_tmpl_add_error() to add an
 * new error structure to errs.
 */
static int
add_scf_error(tmpl_errors_t *errs, scf_tmpl_error_type_t ec,
    pgroup_t *pg_pattern, pgroup_t *pg, pgroup_t *prop_pattern,
    property_t *prop, value_t *val, error_info_t *einfo)
{
        const char *actual = NULL;
        char *c;
        pgroup_t *conflict;
        const char *ed[ED_COUNT];
        const char *ev1 = NULL;
        const char *ev2 = NULL;
        int i;
        scf_type_t prop_type;
        int rc;

        (void) memset(ed, 0, sizeof (ed));

        /* Set values that are common to most error types. */
        if (pg != NULL) {
                ed[ED_PG_NAME] = pg->sc_pgroup_name;
        }
        if (prop != NULL) {
                ed[ED_PROP_NAME] = prop->sc_property_name;
        }
        if (pg_pattern == NULL) {
                if (prop_pattern != NULL) {
                        ed[ED_TMPL_FMRI] = prop_pattern->sc_parent->sc_fmri;
                }
        } else {
                ed[ED_TMPL_FMRI] = pg_pattern->sc_parent->sc_fmri;
                ed[ED_TMPL_PG_NAME] = find_name_specification(pg_pattern);
                ed[ED_TMPL_PG_TYPE] = find_type_specification(pg_pattern);
        }
        if (prop_pattern != NULL) {
                ed[ED_TMPL_PROP_NAME] = find_name_specification(prop_pattern);
                ed[ED_TMPL_PROP_TYPE] = find_type_specification(prop_pattern);
        }

        /*
         * All of the strings that we've found must be strduped.  This is
         * so that scf_tmpl_errors_destroy() can free them.  We cannot use
         * the flag argument of _scf_create_errors() to indicate that the
         * strings should not be freed.  The flag argument is an all or
         * nothing thing.  In the code below we need to convert integers to
         * strings, and this requires memory allocation.  Since we have to
         * allocate memory for that data, we need to allocate it for every
         * thing.
         */
        for (i = 0; i < ED_COUNT; i++) {
                if (ed[i] == NULL)
                        continue;
                ed[i] = safe_strdup(ed[i]);
        }

        /* actual, ev1 and ev2 are error code specific. */
        switch (ec) {
        case SCF_TERR_CARDINALITY_VIOLATION:
                assert(einfo != NULL);
                assert(einfo->ei_type == EIT_CARDINALITY);
                ev1 = uint64_to_str(einfo->ei_u.ei_cardinality.ei_min);
                ev2 = uint64_to_str(einfo->ei_u.ei_cardinality.ei_max);
                actual = uint64_to_str(einfo->ei_u.ei_cardinality.ei_count);
                break;
        case SCF_TERR_WRONG_PG_TYPE:
                /* Specified type. */
                if (pg_pattern != NULL) {
                        ev1 = find_type_specification(pg_pattern);
                        if (ev1 != NULL) {
                                ev1 = safe_strdup(ev1);
                        }
                }
                /* Actual type. */
                if (pg != NULL) {
                        actual = pg->sc_pgroup_type;
                        if (actual != NULL) {
                                actual = safe_strdup(actual);
                        }
                }
                break;
        case SCF_TERR_WRONG_PROP_TYPE:
                assert(einfo->ei_type == EIT_PROP_TYPE);
                prop_type = einfo->ei_u.ei_prop_type.ei_specified;
                ev1 = safe_strdup(scf_type_to_string(prop_type));
                prop_type = einfo->ei_u.ei_prop_type.ei_actual;
                actual = safe_strdup(scf_type_to_string(prop_type));
                break;
        case SCF_TERR_VALUE_CONSTRAINT_VIOLATED:
                actual = value_to_string(val);
                break;
        case SCF_TERR_MISSING_PG:
                assert(einfo->ei_type == EIT_MISSING_PG);
                ev1 = safe_strdup(einfo->ei_u.ei_missing_pg.ei_pg_name);
                ev2 = safe_strdup(einfo->ei_u.ei_missing_pg.ei_pg_type);
                break;
        case SCF_TERR_MISSING_PROP:
                assert(einfo->ei_type == EIT_MISSING_PROP);
                ev1 = safe_strdup(einfo->ei_u.ei_missing_prop.ei_prop_name);
                break;
        case SCF_TERR_RANGE_VIOLATION:
                assert(einfo->ei_type == EIT_RANGE);
                if (einfo->ei_u.ei_range.ei_rtype == SCF_TYPE_COUNT) {
                        c = uint64_to_str(einfo->ei_u.ei_range.ei_uvalue);
                } else {
                        c = int64_to_str(einfo->ei_u.ei_range.ei_ivalue);
                }
                actual = c;
                break;
        case SCF_TERR_PG_PATTERN_CONFLICT:
        case SCF_TERR_PROP_PATTERN_CONFLICT:
        case SCF_TERR_GENERAL_REDEFINE:
                assert(einfo->ei_type == EIT_PATTERN_CONFLICT);
                conflict = einfo->ei_u.ei_pattern_conflict.ei_pattern;
                ev1 = safe_strdup(conflict->sc_parent->sc_fmri);
                ev2 = find_name_specification(conflict);
                if (ev2 != NULL)
                        ev2 = safe_strdup(ev2);
                actual = find_type_specification(conflict);
                if (actual != NULL)
                        actual = safe_strdup(actual);
                break;
        case SCF_TERR_INCLUDE_VALUES:
                assert(einfo->ei_type == EIT_INCLUDE_VALUES);
                ev1 = safe_strdup(einfo->ei_u.ei_inc_values.ei_type);
                break;
        case SCF_TERR_PG_PATTERN_INCOMPLETE:
        case SCF_TERR_PROP_PATTERN_INCOMPLETE:
                break;
        default:
                assert(0);
                abort();
        };

        rc = _scf_tmpl_add_error(errs->te_cur_scf->tve_errors, ec,
            ed[ED_PG_NAME], ed[ED_PROP_NAME], ev1, ev2, actual,
            ed[ED_TMPL_FMRI], ed[ED_TMPL_PG_NAME], ed[ED_TMPL_PG_TYPE],
            ed[ED_TMPL_PROP_NAME], ed[ED_TMPL_PROP_TYPE]);

        return (rc);
}

/*
 * Create and initialize a new im_tmpl_error structure and add it to the
 * list of errors in errs.  The rest of the parameters are used to
 * initialize the im_tmpl_error structure.
 */
static tmpl_validate_status_t
tmpl_errors_add_im(tmpl_errors_t *errs, tmpl_validate_status_t ec, entity_t *e,
    pgroup_t *pg_pattern, pgroup_t *pg, pgroup_t *prop_pattern,
    property_t *prop, value_t *val, error_info_t *einfo)
{
        im_tmpl_error_t *ite;
        int result;

        ite = uu_zalloc(sizeof (*ite));
        if (ite == NULL)
                uu_die(emesg_nomem);
        uu_list_node_init(ite, &ite->ite_node, inmem_errors_pool);
        ite->ite_type = ec;
        ite->ite_entity = e;
        ite->ite_pg = pg;
        ite->ite_pg_pattern = pg_pattern;
        ite->ite_prop = prop;
        ite->ite_prop_pattern = prop_pattern;
        ite->ite_value = val;
        if (einfo != NULL)
                ite->ite_einfo = *einfo;

        result = uu_list_insert_after(errs->te_list, NULL, ite);
        assert(result == 0);
        return (TVS_SUCCESS);
}

/*
 * pattern must point to a pg_pattern or a prop_pattern.  This function
 * finds the property named required and returns the property's value.  If
 * the property does not exist, false is return since it is the default.
 */
static int
is_required(pgroup_t *pattern)
{
        property_t *required;
        value_t *value;

        assert((strcmp(pattern->sc_pgroup_type,
            SCF_GROUP_TEMPLATE_PG_PATTERN) == 0) ||
            (strcmp(pattern->sc_pgroup_type,
            SCF_GROUP_TEMPLATE_PROP_PATTERN) == 0));

        required = property_find(pattern, SCF_PROPERTY_TM_REQUIRED);

        /* Default if there is no required property is false. */
        if (required == NULL)
                return (0);

        /* Retrieve the value of the required property. */
        value = uu_list_first(required->sc_property_values);
        if (value == NULL)
                return (0);
        if (value->sc_type == SCF_TYPE_BOOLEAN)
                return (value->sc_u.sc_count == 0 ? 0 : 1);

        /* No boolean property values, so return false. */
        return (0);
}

/*
 * Load the service's restarter instance and the global instance from the
 * repository.  This will allow us to use their templates in validating the
 * service.
 *
 * There is no function to unload the general templates.  The memory that
 * is allocated by load_general_templates() will be freed automatically in
 * internal_service_free() which is called by internal_bundle_free().
 */
static void
load_general_templates(entity_t *svc)
{
        const char *restarter;
        int is_global = 0;
        int r;

        assert(svc->sc_etype == SVCCFG_SERVICE_OBJECT);

        /*
         * If e is the global service, we only need to load the restarter.
         */
        if ((strcmp(svc->sc_fmri, SCF_INSTANCE_GLOBAL) == 0) ||
            (strcmp(svc->sc_fmri, SCF_SERVICE_GLOBAL) == 0)) {
                is_global = 1;
        }

        /*
         * Load the templates for the service's restarter.
         */
        restarter = find_restarter(svc);
        if (restarter == NULL)
                restarter = SCF_SERVICE_STARTD;
        if ((r = load_instance(restarter, "restarter",
            &svc->sc_u.sc_service.sc_restarter)) != 0) {
                /*
                 * During initial manifest import, restarter may
                 * not be in the repository yet.  In this case we
                 * continue on without it.
                 */
                if (r == EINVAL)
                        warn(gettext("WARNING: restarter FMRI %s is invalid\n"),
                            restarter);

                if (r == ENOTSUP)
                        warn(gettext("WARNING: restarter FMRI %s is not valid; "
                            "instance fmri required.\n"), restarter);

                if (r == ENOMEM)
                        uu_die(emesg_nomem);

                svc->sc_u.sc_service.sc_restarter = NULL;
        }
        if (is_global == 0) {
                if ((r = load_instance(SCF_INSTANCE_GLOBAL, "global",
                    &svc->sc_u.sc_service.sc_global)) != 0) {
                        /*
                         * During initial manifest import, global may not be in
                         * the repository yet.
                         */
                        if (r == ENOMEM)
                                uu_die(emesg_nomem);
                        else
                                svc->sc_u.sc_service.sc_global = NULL;
                }
        }
}

/*
 * Load the instance specific restarter if one is declared.
 *
 * There is no corresponding unload_instance_restarter() function because
 * it is not needed.  The memory will be freed in internal_instance_free()
 * when internal_bundle_free() is called.
 */
static void
load_instance_restarter(entity_t *i)
{
        const char *restarter;
        int r;

        assert(i->sc_etype == SVCCFG_INSTANCE_OBJECT);

        restarter = find_restarter(i);
        if (restarter == NULL) {
                /* No instance specific restarter */
                return;
        }
        r = load_instance(restarter, "instance_restarter",
            &i->sc_u.sc_instance.sc_instance_restarter);
        if (r != 0) {
                /*
                 * During initial manifest import, the restarter may not be
                 * in the repository yet.  In this case we continue on
                 * without it.
                 */
                if (r == EINVAL)
                        warn(gettext("WARNING: restarter FMRI %s is invalid\n"),
                            restarter);

                if (r == ENOTSUP)
                        warn(gettext("WARNING: restarter FMRI %s is not valid; "
                            "instance fmri required.\n"), restarter);

                if (r == ENOMEM)
                        uu_die(emesg_nomem);
        }
}

/*
 * Find the next property after current in the property group at pg.  If
 * the property group contains a tree of composed properties, that tree is
 * walked.  Otherwise, we walk through the uu_list at sc_pgroup_props.
 */
static property_t *
next_property(pgroup_t *pg, property_t *current)
{
        composed_pg_t *cpg;
        property_t *prop;

        cpg = pg->sc_pgroup_composed;
        if ((cpg != NULL) && (cpg->cpg_composed_props != NULL)) {
                /* Walk through composed property list. */
                if (current) {
                        prop = uu_avl_next(cpg->cpg_composed_props, current);
                } else {
                        prop = uu_avl_first(cpg->cpg_composed_props);
                }
        } else {
                /* No composition available, so walk the list of properties */
                if (current) {
                        prop = uu_list_next(pg->sc_pgroup_props, current);
                } else {
                        prop = uu_list_first(pg->sc_pgroup_props);
                }
        }

        return (prop);
}

static ptrn_info_t *
ptrn_info_create(pgroup_t *pat)
{
        entity_t *e;
        ptrn_info_t *info;
        composed_pg_t *match;
        composed_pg_t cpg;

        info = safe_malloc(sizeof (*info));

        switch (pgroup_type(pat)) {
        case PG_PATTERN_PG:
                info->pi_ptrn_type = PG_PATTERN;
                break;
        case PROP_PATTERN_PG:
                info->pi_ptrn_type = PROP_PATTERN;
                break;
        default:
                assert(0);
                abort();
        }
        info->pi_ptrnpg = pat;
        info->pi_name = find_name_specification(pat);
        info->pi_name = EMPTY_TO_NULL(info->pi_name);
        info->pi_type = find_type_specification(pat);
        info->pi_type = EMPTY_TO_NULL(info->pi_type);
        if (info->pi_ptrn_type == PG_PATTERN) {
                info->pi_target = find_astring_value_in_pg(pat,
                    SCF_PROPERTY_TM_TARGET);
                if (info->pi_target == NULL)
                        info->pi_target = SCF_TM_TARGET_THIS;
        }
        if (info->pi_ptrn_type == PROP_PATTERN) {
                info->pi_pgp_name = find_astring_value_in_pg(pat,
                    SCF_PROPERTY_TM_PG_PATTERN);
                assert((info->pi_pgp_name != NULL) &&
                    (*(info->pi_pgp_name) != 0));

                /*
                 * Find the property group that defines the pg_pattern that
                 * holds this prop_pattern.
                 */
                e = pat->sc_parent;
                if (e->sc_etype == SVCCFG_INSTANCE_OBJECT) {
                        (void) memset(&cpg, 0, sizeof (cpg));
                        cpg.cpg_name = info->pi_pgp_name;
                        cpg.cpg_type = SCF_GROUP_TEMPLATE_PG_PATTERN;
                        match = uu_avl_find(e->sc_u.sc_instance.sc_composed,
                            &cpg, NULL, NULL);
                        assert(match != NULL);
                        info->pi_enc_pgp = CPG2PG(match);
                } else {
                        info->pi_enc_pgp = internal_pgroup_find(e,
                            info->pi_pgp_name, SCF_GROUP_TEMPLATE_PG_PATTERN);
                }
                assert(info->pi_enc_pgp != NULL);
        }
        uu_avl_node_init(info, &info->pi_link, ptrn_info_pool);
        return (info);
}

static void
ptrn_info_destroy(ptrn_info_t *info)
{
        if (info == NULL)
                return;
        uu_avl_node_fini(info, &info->pi_link, ptrn_info_pool);
        free(info);
}

/*
 * Walk through the property groups of the instance or service at e looking
 * for definitions of pg_patterns or prop_patterns as specified by type.
 * For each property group that matches type create a ptrn_info_t and add
 * it to the avl tree at tree.  If duplicates are found add an error entry
 * to errs.
 */
static tmpl_validate_status_t
gather_pattern(entity_t *e, ptrn_type_t type, uu_avl_t *tree,
    tmpl_errors_t *errs)
{
        error_info_t einfo;
        ptrn_info_t *info = NULL;
        uu_avl_index_t marker;
        ptrn_info_t *match;
        pgroup_t *pg;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        const char *selector;

        switch (type) {
        case PG_PATTERN:
                selector = SCF_GROUP_TEMPLATE_PG_PATTERN;
                break;
        case PROP_PATTERN:
                selector = SCF_GROUP_TEMPLATE_PROP_PATTERN;
                break;
        default:
                assert(0);
                abort();
        }

        for (pg = uu_list_first(e->sc_pgroups);
            pg != NULL;
            pg = uu_list_next(e->sc_pgroups, pg)) {
                if (strcmp(pg->sc_pgroup_type, selector) != 0) {
                        continue;
                }
                if (info != NULL) {
                        /* Get rid of old structure. */
                        ptrn_info_destroy(info);
                }
                info = ptrn_info_create(pg);
                match = uu_avl_find(tree, info, NULL, &marker);
                if (match == NULL) {
                        /* No match.  Insert the info. */
                        uu_avl_insert(tree, info, marker);
                        info = NULL;
                        continue;
                }

                /* Got a match.  Determine if it is a conflict. */
                if ((info->pi_name == NULL) ||
                    (info->pi_type == NULL) ||
                    (match->pi_name == NULL) ||
                    (match->pi_type == NULL)) {
                        /* No conflicts if any wild cards. */
                        continue;
                }

                /*
                 * Name already matches, or we wouldn't have gotten
                 * here.  Make sure that the type also matches.
                 */
                if (strcmp(info->pi_type, match->pi_type) == 0) {
                        continue;
                }

                /*
                 * If we get to this point we have a conflict, and
                 * we need to generate the correct type of error.
                 */
                CLEAR_ERROR_INFO(&einfo);
                einfo.ei_type = EIT_PATTERN_CONFLICT;
                einfo.ei_u.ei_pattern_conflict.ei_pattern =
                    match->pi_ptrnpg;
                if (type == PG_PATTERN) {
                        rc = TVS_VALIDATION;
                        if (add_scf_error(errs, SCF_TERR_PG_PATTERN_CONFLICT,
                            info->pi_ptrnpg, NULL, NULL, NULL, NULL,
                            &einfo) != 0) {
                                /*
                                 * If we can no longer accumulate
                                 * errors, break out of the loop.
                                 */
                                break;
                        }
                } else {
                        /*
                         * Possible conflicting prop_pattern.  See if the
                         * prop_patterns are declared in the same
                         * pg_pattern.
                         */
                        if ((info->pi_pgp_name == NULL) ||
                            (match->pi_pgp_name == NULL)) {
                                continue;
                        }
                        if (strcmp(info->pi_pgp_name, match->pi_pgp_name) != 0)
                                continue;

                        /* It is a real conflict. */
                        rc = TVS_VALIDATION;
                        if (add_scf_error(errs, SCF_TERR_PROP_PATTERN_CONFLICT,
                            info->pi_enc_pgp, NULL, info->pi_ptrnpg, NULL, NULL,
                            &einfo) != 0) {
                                /*
                                 * If we can no longer accumulate
                                 * errors, break out of the loop.
                                 */
                                break;
                        }
                }
        }

        ptrn_info_destroy(info);
        return (rc);
}

/*
 * Free the pg_iter structure.
 */
static void
pg_iter_destroy(pg_iter_t *i)
{
        if (i == NULL)
                return;

        uu_free(i);
}

/*
 * Create a property group iterator for the instance at e.  This iterator
 * will walk through the composed property groups of the instance.  It will
 * then step through the property groups of the instance's restarter and
 * finally the global service.  If you wish to iterate over a specific type
 * of property group, set restriction to point the the desired type.
 * Otherwise set restriction to NULL.
 *
 * The returned interator must be freed by calling pg_iter_destroy().  NULL
 * is returned if we are unable to allocate the necessary memory.
 */
static pg_iter_t *
pg_iter_create(entity_t *e, const char *restriction)
{
        pg_iter_t *i;

        assert(e->sc_etype == SVCCFG_INSTANCE_OBJECT);

        i = uu_zalloc(sizeof (*i));
        if (i == NULL)
                return (NULL);

        i->pgi_entity = e;
        i->pgi_restrict = restriction;
        i->pgi_level = TL_COMPOSED;
        i->pgi_service = e->sc_parent;

        return (i);
}

/*
 * Return the next property group in the iteration.  NULL is returned if we
 * reach the end of the list.  The iterator will automatically proceed from
 * most specific to most general levels.
 */
static pgroup_t *
next_pattern_pg(pg_iter_t *i)
{
        composed_pg_t *cpg;
        entity_t *e;
        pgroup_t *pg;
        uu_avl_t *composed_tree;

        assert(i->pgi_level != TL_NOLEVEL);

        while (i->pgi_entity != NULL) {
                if (i->pgi_level == TL_COMPOSED) {
                        composed_tree =
                            i->pgi_entity->sc_u.sc_instance.sc_composed;
                        cpg = i->pgi_current.pgi_cpg;
                        if (cpg == NULL) {
                                cpg = uu_avl_first(composed_tree);
                        } else {
                                cpg = uu_avl_next(composed_tree, cpg);
                        }
                        if (cpg == NULL) {
                                pg = NULL;
                        } else {
                                pg = CPG2PG(cpg);
                                i->pgi_current.pgi_cpg = cpg;
                        }
                } else {
                        pg = i->pgi_current.pgi_pg;
                        if (pg == NULL) {
                                pg = uu_list_first(i->pgi_entity->sc_pgroups);
                        } else {
                                pg = uu_list_next(i->pgi_entity->sc_pgroups,
                                    pg);
                        }
                        i->pgi_current.pgi_pg = pg;
                }

                if (pg == NULL) {
                        /*
                         * End of the list.  Reset current and break out of
                         * the loop.
                         */
                        (void) memset(&i->pgi_current, 0,
                            sizeof (i->pgi_current));
                        break;
                }

                /*
                 * If this iteration is for a specific type, verify that
                 * this pg is of that type.
                 */
                if (i->pgi_restrict) {
                        if (strcmp(pg->sc_pgroup_type, i->pgi_restrict) != 0) {
                                continue;
                        }
                }

                return (pg);
        }

        /*
         * End of the list in the current level.  Move up to the next
         * level.
         */
        switch (i->pgi_level) {
        case TL_COMPOSED:
                /* Skip service if we've finished a composed instance. */
                e = i->pgi_entity;
                if (e->sc_u.sc_instance.sc_instance_restarter == NULL) {
                        /* Use service restarter */
                        i->pgi_entity =
                            i->pgi_service->sc_u.sc_service.sc_restarter;
                } else {
                        /* Use instance restarter */
                        i->pgi_entity =
                            e->sc_u.sc_instance.sc_instance_restarter;
                }
                i->pgi_level = TL_RESTARTER;
                break;
        case TL_RESTARTER:
                i->pgi_entity = i->pgi_service->sc_u.sc_service.sc_global;
                i->pgi_level = TL_GLOBAL;
                break;
        case TL_GLOBAL:
                i->pgi_level = TL_NOLEVEL;
                return (NULL);
        default:
                assert(0);
                abort();
        }

        /* Go process the next level. */
        return (next_pattern_pg(i));
}

/*
 * Compare two pattern info structures (ptrn_info_t).  If both structures
 * have names, the comparison is based on the name.  If only one has a
 * name, the structure with no name will be first.  If neither structure
 * has a name, the comparison is based on their types using similar wild
 * card logic.
 */
/* ARGSUSED2 */
static int
ptrn_info_compare(const  void *left, const void *right, void *unused)
{
        ptrn_info_t *l = (ptrn_info_t *)left;
        ptrn_info_t *r = (ptrn_info_t *)right;

        if ((l->pi_name != NULL) && (r->pi_name != NULL))
                return (strcmp(l->pi_name, r->pi_name));
        if ((l->pi_name == NULL) && (r->pi_name == NULL)) {
                /* No names, so we need to compare types. */
                if ((l->pi_type != NULL) && (r->pi_type != NULL))
                        return (strcmp(l->pi_type, r->pi_type));
                if ((l->pi_type == NULL) && (r->pi_type == NULL))
                        return (0);

                /* If we get here, exactly one of the types is NULL */
                if (l->pi_type == NULL)
                        return (-1);
                return (1);
        }

        /* If we get here, exactly one of the names is NULL */
        if (l->pi_name == NULL)
                return (-1);
        return (1);
}

/*
 * The target of a pg_pattern in combination with the level at which the
 * pg_pattern was defined determines whether or not it should be applied.
 * The following combinations should be ignored, and all others should be
 * applied.
 *
 *      Target          Level
 *      ------          -----
 *      this            TL_RESTARTER, TL_GLOBAL
 *                      "this" only applies if the pg_pattern was defined
 *                      at the instance or service level
 *      delegate        TL_INSTANCE, TL_SERVICE
 *                      Only restarters and the global service can
 *                      delegate.
 *      instance        TL_INSTANCE, TL_RESTARTER, TL_GLOBAL
 *                      Only the service level can specify the "instance"
 *                      target.
 *      all             TL_INSTANCE, TL_SERVICE, TL_RESTARTER
 *                      Only the global service can specify the "all"
 *                      target.
 *
 * Return Values:
 *      1       apply the pg_pattern
 *      0       ignore the pg_pattern
 */
static int
target_check(const char *target, tmpl_level_t level)
{
        if ((target == NULL) || (*target == 0)) {
                /* Default is this */
                target = SCF_TM_TARGET_THIS;
        }
        if (strcmp(target, SCF_TM_TARGET_THIS) == 0) {
                if ((level == TL_RESTARTER) ||
                    (level == TL_GLOBAL)) {
                        return (0);
                } else {
                        return (1);
                }
        }
        if (strcmp(target, SCF_TM_TARGET_DELEGATE) == 0) {
                if ((level == TL_INSTANCE) ||
                    (level == TL_SERVICE)) {
                        return (0);
                } else {
                        return (1);
                }
        }
        if (strcmp(target, SCF_TM_TARGET_INSTANCE) == 0) {
                /*
                 * Note that the test is inverted from the other cases.
                 * This is because there is only one instance where apply
                 * is the correct thing to do.
                 */
                if (level == TL_SERVICE) {
                        return (1);
                } else {
                        return (0);
                }
        }
        if (strcmp(target, SCF_TM_TARGET_ALL) == 0) {
                if ((level == TL_INSTANCE) ||
                    (level == TL_SERVICE) ||
                    (level == TL_RESTARTER)) {
                        return (0);
                }
        }
        return (1);
}

static int
pg_target_check(pgroup_t *pg_pattern, tmpl_level_t level)
{
        const char *target;

        target = find_astring_value_in_pg(pg_pattern, SCF_PROPERTY_TM_TARGET);
        if (level == TL_COMPOSED) {
                switch (pg_pattern->sc_parent->sc_etype) {
                case SVCCFG_INSTANCE_OBJECT:
                        level = TL_INSTANCE;
                        break;
                case SVCCFG_SERVICE_OBJECT:
                        level = TL_SERVICE;
                        break;
                default:
                        assert(0);
                        abort();
                }
        }
        return (target_check(target, level));
}

/*
 * Find the prop_pattern's type sepcification and convert it to the
 * appropriate scf_type.
 */
static tmpl_validate_status_t
prop_pattern_type(pgroup_t *pattern, scf_type_t *type)
{
        const char *type_spec;

        assert(strcmp(pattern->sc_pgroup_type,
            SCF_GROUP_TEMPLATE_PROP_PATTERN) == 0);

        type_spec = find_type_specification(pattern);
        if ((type_spec == NULL) || (*type_spec == 0))
                return (TVS_MISSING_TYPE_SPECIFICATION);
        *type = scf_string_to_type(type_spec);
        return (TVS_SUCCESS);
}

/*
 * This function is analagous to scf_property_is_type(3SCF), but it works
 * on the in memory representation of the property.
 *
 * RETURNS:
 *      0               The property at prop does not have the specified
 *                      type.
 *      non-zero        The property at prop does have the specified type.
 */
static int
property_is_type(property_t *prop, scf_type_t type)
{
        return (scf_is_compatible_type(type, prop->sc_value_type) ==
            SCF_SUCCESS);
}

/*
 * This function generates a property group name for a template's
 * pg_pattern.  The name and type of the pg_pattern are used to construct
 * the name, but either or both may be null.  A pointer to the constructed
 * name is returned, and the referenced memory must be freed using
 * free(3c).  NULL is returned if we are unable to allocate enough memory.
 */
static char *
gen_pg_pattern_pg_name(const char *name, const char *type)
{
        char *pg_name;
        char *rv = NULL;
        ssize_t name_size;

        name_size = scf_limit(SCF_LIMIT_MAX_NAME_LENGTH);
        pg_name = safe_malloc(name_size);
        rv = pg_name;

        /*
         * There are four cases -- name and type are both null, name and
         * type are both non-null, only name is present or only type is
         * present.
         */
        if ((name == NULL) || (*name == 0)) {
                if ((type == NULL) || (*type == 0)) {
                        /*
                         * Name and type are both null, so the PG name
                         * contains only the prefix.
                         */
                        if (strlcpy(pg_name, SCF_PG_TM_PG_PATTERN_PREFIX,
                            name_size) >= name_size) {
                                rv = NULL;
                        }
                } else {
                        /*
                         * If we have a type and no name, the type becomes
                         * part of the pg_pattern property group name.
                         */
                        if (snprintf(pg_name, name_size, "%s%s",
                            SCF_PG_TM_PG_PATTERN_T_PREFIX, type) >=
                            name_size) {
                                rv = NULL;
                        }
                }
        } else {
                /*
                 * As long as the pg_pattern has a name, it becomes part of
                 * the name of the pg_pattern property group name.  We
                 * merely need to pick the appropriate prefix.
                 */
                const char *prefix;
                if ((type == NULL) || (*type == 0)) {
                        prefix = SCF_PG_TM_PG_PATTERN_N_PREFIX;
                } else {
                        prefix = SCF_PG_TM_PG_PATTERN_NT_PREFIX;
                }
                if (snprintf(pg_name, name_size, "%s%s", prefix, name) >=
                    name_size) {
                        rv = NULL;
                }
        }

        if (rv == NULL) {
                /* Name was too big. */
                free(pg_name);
        }
        return (rv);
}

/*
 * pinfo contains information about a prop_pattern.  An include_values
 * element with a type of type has been included in the prop_pattern
 * specification.  We need to determine if the prop_pattern also contains
 * constraints or values specifications as determined by type.  Thus, we
 * search the prop_pattern for properties whose names start with the
 * correct prefix.
 */
static tmpl_validate_status_t
include_values_support(ptrn_info_t *pinfo, const char *type,
    tmpl_errors_t *errs)
{
        error_info_t einfo;
        int i;
        const char **prefixes;
        const char *pfx;
        property_t *prop;
        pgroup_t *ptrn;

        if (strcmp(type, "constraints") == 0) {
                prefixes = constraint_prefixes;
        } else if (strcmp(type, "values") == 0) {
                prefixes = value_prefixes;
        } else {
                CLEAR_ERROR_INFO(&einfo);
                einfo.ei_type = EIT_BAD_TEMPLATE;
                einfo.ei_u.ei_bad_template.ei_reason = gettext("include_values "
                    "type must be \"constraints\" or \"values\"");
                (void) tmpl_errors_add_im(errs, TVS_BAD_TEMPLATE,
                    pinfo->pi_ptrnpg->sc_parent, pinfo->pi_enc_pgp,
                    NULL, pinfo->pi_ptrnpg, NULL, NULL, &einfo);
                return (TVS_BAD_TEMPLATE);
        }

        /*
         * Now see if the prop_pattern has a property whose name starts
         * with one of these prefixes.
         */
        ptrn = pinfo->pi_ptrnpg;
        for (prop = uu_list_first(ptrn->sc_pgroup_props);
            prop != NULL;
            prop = uu_list_next(ptrn->sc_pgroup_props, prop)) {
                for (pfx = prefixes[0], i = 0;
                    pfx != NULL;
                    ++i, pfx = prefixes[i]) {
                        if (strncmp(prop->sc_property_name, pfx,
                            strlen(pfx)) == 0) {
                                return (TVS_SUCCESS);
                        }
                }
        }

        /* No match found.  Generate error */
        CLEAR_ERROR_INFO(&einfo);
        einfo.ei_type = EIT_INCLUDE_VALUES;
        einfo.ei_u.ei_inc_values.ei_type = type;
        (void) add_scf_error(errs, SCF_TERR_INCLUDE_VALUES, pinfo->pi_enc_pgp,
            NULL, ptrn, NULL, NULL, &einfo);

        return (TVS_VALIDATION);
}

/*
 * Walk through the prop_patterns in tree, looking for any that have an
 * include_values, SCF_PROPERTY_TM_CHOICES_INCLUDE_VALUES, property.  For
 * the prop_patterns with the include values property, verify that the
 * prop_pattern has constraint or values declarations as specified by the
 * include_values property.
 */
static tmpl_validate_status_t
tmpl_include_values_check(uu_avl_t *tree, tmpl_errors_t *errs)
{
        ptrn_info_t *info;
        property_t *iv;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        value_t *v;

        for (info = uu_avl_first(tree);
            info != NULL;
            info = uu_avl_next(tree, info)) {
                iv = internal_property_find(info->pi_ptrnpg,
                    SCF_PROPERTY_TM_CHOICES_INCLUDE_VALUES);
                if (iv == NULL)
                        continue;
                for (v = uu_list_first(iv->sc_property_values);
                    v != NULL;
                    v = uu_list_next(iv->sc_property_values, v)) {
                        assert(is_numeric_type(v->sc_type) == 0);
                        r = include_values_support(info, v->sc_u.sc_string,
                            errs);
                        if (r != TVS_SUCCESS)
                                rc = r;
                }
        }
        return (rc);
}

/*
 * Verify that there are no conflicting definitions of pg_pattern or
 * prop_pattern.  Two patterns are said to be in conflict if they have the
 * same name and differing types.  There is a caveat, however.  Empty
 * pattern names or types are considered to be wild cards.  There is no
 * conflict if a pattern has a wild card.
 */
static tmpl_validate_status_t
tmpl_pattern_conflict(entity_t *inst, uu_avl_t *tree, ptrn_type_t type,
    tmpl_errors_t *errs)
{
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc;

        /* First walk the instance. */
        rc = gather_pattern(inst, type, tree, errs);

        /* Now walk the service */
        r = gather_pattern(inst->sc_parent, type, tree, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        return (rc);
}

static tmpl_validate_status_t
tmpl_required_attr_present(uu_avl_t *tree, tmpl_errors_t *errs)
{
        ptrn_info_t *pinfo;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        int reported_name;
        int rv;

        for (pinfo = uu_avl_first(tree);
            pinfo != NULL;
            pinfo = uu_avl_next(tree, pinfo)) {
                if (is_required(pinfo->pi_ptrnpg) == 0) {
                        /* Nothing to check if pattern is not required. */
                        continue;
                }

                /*
                 * For pg_pattern both name and type are optional unless
                 * the required attribute has a value of true.  For
                 * prop_patterns only the type is optional, but it must be
                 * provided if the required attribute has a value of true.
                 */
                reported_name = 0;
                if ((pinfo->pi_ptrn_type == PG_PATTERN) &&
                    (pinfo->pi_name == NULL)) {
                        rc = TVS_VALIDATION;
                        if (add_scf_error(errs, SCF_TERR_PG_PATTERN_INCOMPLETE,
                            pinfo->pi_ptrnpg,
                            NULL, NULL, NULL, NULL, NULL) != 0) {
                                /*
                                 * If we're unable to report errors, break
                                 * out of the loop.
                                 */
                                break;
                        }
                        /*
                         * Don't report the error twice if both name and
                         * type are missing.  One error message is
                         * adequate.
                         */
                        reported_name = 1;
                }
                if ((pinfo->pi_type == NULL) && (reported_name == 0)) {
                        rc = TVS_VALIDATION;
                        if (pinfo->pi_ptrn_type == PG_PATTERN) {
                                rv = add_scf_error(errs,
                                    SCF_TERR_PG_PATTERN_INCOMPLETE,
                                    pinfo->pi_ptrnpg,
                                    NULL, NULL, NULL, NULL, NULL);
                        } else {
                                rv = add_scf_error(errs,
                                    SCF_TERR_PROP_PATTERN_INCOMPLETE,
                                    pinfo->pi_enc_pgp, NULL, pinfo->pi_ptrnpg,
                                    NULL, NULL, NULL);
                        }
                        /* If we're unable to log errors, break out of loop. */
                        if (rv != 0)
                                break;
                }
        }
        return (rc);
}

/*
 * Look for pg_pattern definitions in general.  general is either the
 * restarter serivce for inst or it is the global service.  tree contains
 * the ptrn_info_t structures describing the pg_patterns for an instance.
 * For each general pg_pattern, see if the instance contains an overriding
 * definition in tree.  If it does generate an error entry.
 *
 * If a redefinition is found, TVS_WARN is returned.  This is because a
 * redefinition is not sufficient reason to inhibit the import operation.
 */
static tmpl_validate_status_t
tmpl_scan_general(entity_t *general, uu_avl_t *tree,
    tmpl_level_t level, tmpl_errors_t *errs)
{
        tmpl_level_t cur_level;
        error_info_t einfo;
        pgroup_t *pg;
        ptrn_info_t *ginfo = NULL;
        ptrn_info_t *match;
        tmpl_validate_status_t rc = TVS_SUCCESS;

        /*
         * General services may not be in repository yet.  It depends on
         * the order that manifests are imported.
         */
        if (general == NULL)
                return (TVS_SUCCESS);

        for (pg = uu_list_first(general->sc_pgroups);
            pg != NULL;
            pg = uu_list_next(general->sc_pgroups, pg)) {
                if (strcmp(pg->sc_pgroup_type,
                    SCF_GROUP_TEMPLATE_PG_PATTERN) != 0) {
                        /* Not a pg_pattern */
                        continue;
                }
                if (ginfo != NULL)
                        ptrn_info_destroy(ginfo);
                ginfo = ptrn_info_create(pg);
                match = uu_avl_find(tree, ginfo, NULL, NULL);
                if (match != NULL) {
                        /* See if global pg_pattern is targeted at us. */
                        if (target_check(ginfo->pi_target, level) == 0)
                                continue;

                        /*
                         * See if the match applies to us.  If we happen to
                         * be a restarter, the pg_pattern could have a
                         * target of delegate.  That wouldn't apply to this
                         * instance, it would only apply to our delegates.
                         * Cases such as this are not a redefinition.
                         */
                        if (match->pi_ptrnpg->sc_parent->sc_etype ==
                            SVCCFG_INSTANCE_OBJECT) {
                                cur_level = TL_INSTANCE;
                        } else {
                                cur_level = TL_SERVICE;
                        }
                        if (target_check(match->pi_target, cur_level) == 0)
                                continue;

                        /*
                         * Instance or service overrides a general
                         * definition.  We need to issue a warning message.
                         */
                        rc = TVS_WARN;
                        CLEAR_ERROR_INFO(&einfo);
                        einfo.ei_type = EIT_PATTERN_CONFLICT;
                        einfo.ei_u.ei_pattern_conflict.ei_pattern = pg;
                        if (add_scf_error(errs, SCF_TERR_GENERAL_REDEFINE,
                            match->pi_ptrnpg, NULL, NULL, NULL, NULL,
                            &einfo) != 0) {
                                /*
                                 * No need to continue the search if we
                                 * cannot record errors.
                                 */
                                break;
                        }
                }
        }

        if (ginfo != NULL)
                ptrn_info_destroy(ginfo);
        return (rc);
}

/*
 * tree contains the pg_pattern definitions for the instance at inst.  See
 * if these pg_patterns redefine any pg_patterns in the instance's
 * restarter or in the global service.  TVS_WARN is returned if a
 * redefinition is encountered.
 */
static tmpl_validate_status_t
tmpl_level_redefine(entity_t *inst, uu_avl_t *tree, tmpl_errors_t *errs)
{
        entity_t *restarter;
        entity_t *svc = inst->sc_parent;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc;

        restarter = inst->sc_u.sc_instance.sc_instance_restarter;
        if (restarter == NULL) {
                /* No instance restarter.  Use the service restarter */
                restarter = svc->sc_u.sc_service.sc_restarter;
        }
        rc = tmpl_scan_general(restarter, tree, TL_RESTARTER, errs);
        r = tmpl_scan_general(svc->sc_u.sc_service.sc_global, tree,
            TL_GLOBAL, errs);
        if (r != TVS_SUCCESS)
                rc = r;
        return (rc);
}

/*
 * Perform the following consistency checks on the template specifications
 * themselves:
 *
 *      - No conflicting definitions of `pg_pattern` are allowed within a
 *        single instance.
 *
 *      - Templates at a narrow target (e.g. instance) which define
 *        property groups already templated at a broad target
 *        (e.g. restarter or all) are strongly discouraged.
 *
 *      - Developers may not define a template which specifies a single
 *        prop_pattern name with differing types on the same target
 *        entity.
 *
 *      - If a pg_pattern has a required attribute with a value of true,
 *        then its name and type attributes must be specified.
 *
 *      - If a prop_pattern has a required attribute with a value of true,
 *        then its type attribute must be specified.
 *
 *      - If a prop_pattern has an include values make sure that the
 *        appropriate constraints or values element has also been
 *        declared.
 */
static tmpl_validate_status_t
tmpl_consistency(entity_t *inst, tmpl_errors_t *errs)
{
        void *marker = NULL;
        ptrn_info_t *info;
        uu_avl_t *tree;
        tmpl_validate_status_t rc;
        tmpl_validate_status_t r;

        /* Allocate the tree. */
        tree = uu_avl_create(ptrn_info_pool, NULL, TMPL_DEBUG_TREE);
        if (tree == NULL) {
                uu_die(gettext("pg_info tree creation failed: %s\n"),
                    uu_strerror(uu_error()));
        }

        rc = tmpl_pattern_conflict(inst, tree, PG_PATTERN, errs);

        /*
         * The tree now contains the instance and service pg_patterns.
         * Check to see if they override any pg_pattern definitions in the
         * restarter and global services.
         */
        r = tmpl_level_redefine(inst, tree, errs);
        if (r != TVS_SUCCESS) {
                /*
                 * tmpl_level_redefine() can return a warning.  Don't
                 * override a serious error with a warning.
                 */
                if (r == TVS_WARN) {
                        if (rc == TVS_SUCCESS)
                                rc = r;
                } else {
                        rc = r;
                }
        }

        /*
         * If the pg_pattern has a required attribute with a value of true,
         * then it must also have name and type attributes.
         */
        r = tmpl_required_attr_present(tree, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        /* Empty the tree, so that we can reuse it for prop_patterns. */
        while ((info = uu_avl_teardown(tree, &marker)) != NULL) {
                ptrn_info_destroy(info);
        }

        r = tmpl_pattern_conflict(inst, tree, PROP_PATTERN, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        /*
         * If a prop_pattern has required attribute with a value of true,
         * then it must also have a type attribute.
         */
        r = tmpl_required_attr_present(tree, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        /*
         * Insure that include_values have the constraint for values
         * elements that are needed.
         */
        r = tmpl_include_values_check(tree, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        /* Tear down the tree. */
        marker = NULL;
        while ((info = uu_avl_teardown(tree, &marker)) != NULL) {
                ptrn_info_destroy(info);
        }
        uu_avl_destroy(tree);

        return (rc);
}

/*
 * Release memory associated with the tmpl_errors structure and then free
 * the structure itself.
 */
void
tmpl_errors_destroy(tmpl_errors_t *te)
{
        im_tmpl_error_t *ite;
        tv_errors_t *ste;
        void *marker = NULL;

        if (te == NULL)
                return;
        if (te->te_list) {
                while ((ite = uu_list_teardown(te->te_list, &marker)) != NULL) {
                        uu_list_node_fini(ite, &ite->ite_node,
                            inmem_errors_pool);
                        uu_free(ite);
                }
                uu_list_destroy(te->te_list);
        }
        if (te->te_scf) {
                marker = NULL;
                while ((ste = uu_list_teardown(te->te_scf, &marker)) != NULL) {
                        destroy_scf_errors(ste);
                }
                uu_list_destroy(te->te_scf);
        }
        uu_free(te);
}

/*
 * Allocate and initialize a tmpl_errors structure.  The address of the
 * structure is returned, unless we are unable to allocate enough memory.
 * In the case of memory allocation failures, NULL is returned.
 *
 * The allocated structure should be freed by calling
 * tmpl_errors_destroy().
 */
static tmpl_errors_t *
tmpl_errors_create()
{
        tmpl_errors_t *te;

        te = uu_zalloc(sizeof (*te));
        if (te == NULL)
                return (NULL);
        te->te_list = uu_list_create(inmem_errors_pool, NULL, TMPL_DEBUG_LIST);
        if (te->te_list == NULL) {
                uu_free(te);
                return (NULL);
        }
        te->te_scf = uu_list_create(tv_errors_pool, NULL, TMPL_DEBUG_LIST);
        if (te->te_scf == NULL) {
                tmpl_errors_destroy(te);
                return (NULL);
        }

        return (te);
}

void
tmpl_errors_print(FILE *out, tmpl_errors_t *errs, const char *prefix)
{
        scf_tmpl_error_t *cur;
        size_t buf_size = 4096;
        im_tmpl_error_t *ite;
        char *s = NULL;
        scf_tmpl_errors_t *scferrs;
        tv_errors_t *scft;
        int interactive = (est->sc_cmd_flags & SC_CMD_IACTIVE) ?
            SCF_TMPL_STRERROR_HUMAN : 0;

        for (ite = uu_list_first(errs->te_list);
            ite != NULL;
            ite = uu_list_next(errs->te_list, ite)) {
                im_tmpl_error_print(out, ite, prefix);
        }

        /* Now handle the errors that can be printed via libscf. */
        s = safe_malloc(buf_size);
        for (scft = uu_list_first(errs->te_scf);
            scft != NULL;
            scft = uu_list_next(errs->te_scf, scft)) {
                scferrs = scft->tve_errors;
                if (_scf_tmpl_error_set_prefix(scferrs, prefix) != 0)
                        uu_die(emesg_nomem);
                while ((cur = scf_tmpl_next_error(scferrs)) != NULL) {
                        (void) scf_tmpl_strerror(cur, s, buf_size, interactive);
                        (void) fputs(s, out);
                        (void) fputc('\n', out);
                }
        }

        free(s);
}

/*
 * This function finds the prop_pattern for the property, prop.  e is the
 * instance where the search for the prop_pattern will start.  pg_pattern
 * is the address of the pg_pattern that holds the prop_pattern.
 */
static tmpl_validate_status_t
tmpl_find_prop_pattern(entity_t *inst, pgroup_t *pg_pattern,
    property_t *prop, pgroup_t **prop_pattern)
{
        pgroup_t *candidate;
        pg_iter_t *iter = NULL;
        char *prop_pattern_name = NULL;
        tmpl_validate_status_t rc;

        /*
         * Get the name of the property group that holds the prop_pattern
         * definition.
         */
        rc = gen_prop_pattern_pg_name(pg_pattern,
            prop->sc_property_name, &prop_pattern_name);
        if (rc != TVS_SUCCESS)
                goto out;

        /* Find the property group. */
        iter = pg_iter_create(inst, SCF_GROUP_TEMPLATE_PROP_PATTERN);
        if (iter == NULL)
                goto out;
        while ((candidate = next_pattern_pg(iter)) != NULL) {
                const char *c;

                if (strcmp(prop_pattern_name, candidate->sc_pgroup_name) != 0)
                        continue;
                c = find_astring_value_in_pg(candidate,
                    SCF_PROPERTY_TM_PG_PATTERN);
                if (c == NULL)
                        continue;
                if (strcmp(pg_pattern->sc_pgroup_name, c) == 0)
                        break;
        }
        *prop_pattern = candidate;
        if (candidate == NULL)
                rc = TVS_NOMATCH;

out:
        pg_iter_destroy(iter);
        uu_free((void *)prop_pattern_name);
        return (rc);
}

/*
 * Indexes for pg_pattern property group names.  Indexes are arranged
 * from most specific to least specific.
 */
#define PGN_BOTH        0       /* both name and type */
#define PGN_NAME        1       /* name only */
#define PGN_TYPE        2       /* type only */
#define PGN_NEITHER     3       /* neither name nor type */
#define PGN_MAX         4       /* Size of array */

/*
 * Given an instance entity, e, and a propety group, pg, within the
 * instance; return the address of the pg_pattern for the property group.
 * The address of the pg_pattern is placed at pgp.  NULL indicates that no
 * pg_pattern was specified.
 */
static tmpl_validate_status_t
tmpl_find_pg_pattern(entity_t *e, pgroup_t *pg, pgroup_t **pgp)
{
        pgroup_t *cpg;          /* candidate property group */
        int i;
        pg_iter_t *iter = NULL;
        char *pg_names[PGN_MAX];
        pgroup_t *pg_patterns[PGN_MAX];
        tmpl_validate_status_t rv = TVS_SUCCESS;

        (void) memset(pg_patterns, 0, sizeof (pg_patterns));
        *pgp = NULL;

        /* Generate candidate names for pg_pattern property groups. */
        pg_names[PGN_BOTH] = gen_pg_pattern_pg_name(pg->sc_pgroup_name,
            pg->sc_pgroup_type);
        pg_names[PGN_NAME] = gen_pg_pattern_pg_name(pg->sc_pgroup_name,
            NULL);
        pg_names[PGN_TYPE] = gen_pg_pattern_pg_name(NULL,
            pg->sc_pgroup_type);
        pg_names[PGN_NEITHER] = gen_pg_pattern_pg_name(NULL, NULL);
        for (i = 0; i < PGN_MAX; i++) {
                if (pg_names[i] == NULL) {
                        rv = TVS_BAD_TEMPLATE;
                        goto errout;
                }
        }

        /* Search for property groups that match these names */
        iter = pg_iter_create(e, SCF_GROUP_TEMPLATE_PG_PATTERN);
        if (iter == NULL) {
                uu_die(emesg_nomem);
        }
        while ((cpg = next_pattern_pg(iter)) != NULL) {
                if (pg_target_check(cpg, iter->pgi_level) == 0)
                        continue;

                /* See if we have a name match. */
                for (i = 0; i < PGN_MAX; i++) {
                        if (strcmp(cpg->sc_pgroup_name, pg_names[i]) == 0) {
                                /*
                                 * If we already have a lower level
                                 * pg_pattern, keep it.
                                 */
                                if (pg_patterns[i] == NULL)
                                        pg_patterns[i] = cpg;
                                break;
                        }
                }
        }

        /* Find the most specific pg_pattern. */
        for (i = 0; i < PGN_MAX; i++) {
                if (pg_patterns[i] != NULL) {
                        *pgp = pg_patterns[i];
                        break;
                }
        }
errout:
        for (i = 0; i < PGN_MAX; i++) {
                free(pg_names[i]);
        }
        pg_iter_destroy(iter);
        return (rv);
}

/*
 * Initialize structures that are required for validation using
 * templates specifications.
 */
void
tmpl_init(void)
{
        emesg_nomem = gettext("Out of memory.\n");

        composed_pg_pool = uu_avl_pool_create("composed_pg",
            sizeof (composed_pg_t), offsetof(composed_pg_t, cpg_node),
            composed_pg_compare, TMPL_DEBUG_AVL_POOL);
        if (composed_pg_pool == NULL) {
                uu_die(gettext("composed_pg pool creation failed: %s\n"),
                    uu_strerror(uu_error()));
        }
        composed_prop_pool = uu_avl_pool_create("composed_prop",
            sizeof (property_t), offsetof(property_t, sc_composed_node),
            composed_prop_compare, TMPL_DEBUG_AVL_POOL);
        if (composed_prop_pool == NULL) {
                uu_die(gettext("composed_prop pool creation failed. %s\n"),
                    uu_strerror(uu_error()));
        }
        ptrn_info_pool = uu_avl_pool_create("ptrn_info", sizeof (ptrn_info_t),
            offsetof(ptrn_info_t, pi_link), ptrn_info_compare,
            TMPL_DEBUG_AVL_POOL);
        if (ptrn_info_pool == NULL) {
                uu_die(gettext("pg_pattern info pool creation failed: %s\n"),
                    uu_strerror(uu_error()));
        }
        inmem_errors_pool = uu_list_pool_create("errors-internal",
            sizeof (im_tmpl_error_t), offsetof(im_tmpl_error_t,
            ite_node), NULL, TMPL_DEBUG_LIST_POOL);
        if (inmem_errors_pool == NULL) {
                uu_die(gettext("inmem_errors_pool pool creation failed: "
                    "%s\n"), uu_strerror(uu_error()));
        }
        tv_errors_pool = uu_list_pool_create("scf-terrors",
            sizeof (tv_errors_t), offsetof(tv_errors_t, tve_node),
            NULL,  TMPL_DEBUG_LIST_POOL);
        if (tv_errors_pool == NULL) {
                uu_die(gettext("tv_errors_pool pool creation failed: %s\n"),
                    uu_strerror(uu_error()));
        }
}

/*
 * Clean up the composed property node in the property.
 */
void
tmpl_property_fini(property_t *p)
{
        uu_avl_node_fini(p, &p->sc_composed_node, composed_prop_pool);
}

/*
 * Initialize the composed property node in the property.
 */
void
tmpl_property_init(property_t *p)
{
        uu_avl_node_init(p, &p->sc_composed_node, composed_prop_pool);
}

/*
 * Use the cardinality specification in the prop_pattern to verify the
 * cardinality of the property at prop.  The cardinality of the property is
 * the number of values that it has.
 *
 * pg is the property group that holds prop, and pg_pattern is the
 * pg_pattern for the property group.  pg and pg_pattern are only used for
 * error reporting.
 */
static tmpl_validate_status_t
tmpl_validate_cardinality(pgroup_t *prop_pattern, property_t *prop,
    pgroup_t *pg, pgroup_t *pg_pattern, tmpl_errors_t *errs)
{
        size_t count;
        uint64_t max;
        uint64_t min;
        tmpl_validate_status_t rc;
        error_info_t einfo;

        assert(strcmp(prop_pattern->sc_pgroup_type,
            SCF_GROUP_TEMPLATE_PROP_PATTERN) == 0);

        rc = get_cardinality(prop_pattern, &min, &max);
        switch (rc) {
        case TVS_NOMATCH:
                /* Nothing to check. */
                return (TVS_SUCCESS);
        case TVS_SUCCESS:
                /* Process the limits. */
                break;
        default:
                return (rc);
        }

        if ((min == 0) && (max == ULLONG_MAX)) {
                /* Any number of values is permitted.  No need to count. */
                return (TVS_SUCCESS);
        }

        count = count_prop_values(prop);
        if ((count < min) || (count > max)) {
                CLEAR_ERROR_INFO(&einfo);
                einfo.ei_type = EIT_CARDINALITY;
                einfo.ei_u.ei_cardinality.ei_min = min;
                einfo.ei_u.ei_cardinality.ei_max = max;
                einfo.ei_u.ei_cardinality.ei_count = count;
                (void) add_scf_error(errs, SCF_TERR_CARDINALITY_VIOLATION,
                    pg_pattern, pg, prop_pattern, prop, NULL, &einfo);
                return (TVS_VALIDATION);
        }

        return (TVS_SUCCESS);
}

/*
 * Iterate over pg_patterns in the entity, e.  If the pg_pattern's required
 * attribute is true, verify that the entity contains the corresponding
 * property group.
 */
static tmpl_validate_status_t
tmpl_required_pg_present(entity_t *e, tmpl_errors_t *errs)
{
        composed_pg_t cpg;
        composed_pg_t *match;
        error_info_t einfo;
        pg_iter_t *iter;
        pgroup_t *pg;
        const char *pg_name;
        const char *pg_type;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        uu_avl_t *tree;

        assert(e->sc_etype == SVCCFG_INSTANCE_OBJECT);

        iter = pg_iter_create(e, SCF_GROUP_TEMPLATE_PG_PATTERN);
        if (iter == NULL)
                uu_die(emesg_nomem);

        CLEAR_ERROR_INFO(&einfo);
        einfo.ei_type = EIT_MISSING_PG;

        while ((pg = next_pattern_pg(iter)) != NULL) {
                if (is_required(pg) == 0) {
                        /* If pg is not required, there is nothing to check. */
                        continue;
                }
                pg_name = find_astring_value_in_pg(pg, SCF_PROPERTY_TM_NAME);
                pg_type = find_astring_value_in_pg(pg, SCF_PROPERTY_TM_TYPE);
                if (pg_target_check(pg, iter->pgi_level) == 0)
                        continue;
                einfo.ei_u.ei_missing_pg.ei_pg_name = pg_name;
                einfo.ei_u.ei_missing_pg.ei_pg_type = pg_type;
                tree = e->sc_u.sc_instance.sc_composed;
                (void) memset(&cpg, 0, sizeof (cpg));
                cpg.cpg_name = pg_name;
                cpg.cpg_type = pg_type;
                match = uu_avl_find(tree, &cpg, NULL, NULL);
                if (match == NULL) {
                        rc = TVS_VALIDATION;
                        if (add_scf_error(errs, SCF_TERR_MISSING_PG, pg,
                            NULL, NULL, NULL, NULL, &einfo) != 0) {
                                break;
                        }
                }
        }

        pg_iter_destroy(iter);
        return (rc);
}

/*
 * Verify that the property group, pg, contains property declarations for
 * all required properties.  Unfortunately, there is no direct way to find
 * the prop_patterns for a given property group.  Therefore, we need to
 * scan the entity at e looking for property groups with a type of
 * SCF_GROUP_TEMPLATE_PROP_PATTERN.  That is, we scan the entity looking
 * for all prop_patterns.  When we find a prop_pattern, we look at the
 * value of its pg_pattern property to see if it matches the name of the
 * pg_pattern.  If they match, this is a prop_pattern that is of interest
 * to us.
 *
 * When we find an interesting prop_pattern, we see if it's required
 * property is true.  If it is, we verify that the property group at pg
 * contains the specified property.
 */
static tmpl_validate_status_t
tmpl_required_props_present(entity_t *e, pgroup_t *pg, pgroup_t *pg_pattern,
    tmpl_errors_t *errs)
{
        error_info_t einfo;
        pg_iter_t *iter;
        const char *prop_name;
        const char *prop_pg_pattern_name;
        pgroup_t *prop_pattern;
        scf_tmpl_error_type_t ec;
        tmpl_validate_status_t rc = TVS_SUCCESS;

        /*
         * Scan the entity's property groups looking for ones with a type
         * of SCF_GROUP_TEMPLATE_PROP_PATTERN.
         */
        iter = pg_iter_create(e, SCF_GROUP_TEMPLATE_PROP_PATTERN);
        if (iter == NULL)
                uu_die(emesg_nomem);
        CLEAR_ERROR_INFO(&einfo);
        for (prop_pattern = next_pattern_pg(iter);
            prop_pattern != NULL;
            prop_pattern = next_pattern_pg(iter)) {
                /*
                 * Find the pg_pattern property in this prop_pattern.
                 * Verify that its value matches the name of the
                 * pg_pattern.
                 */
                prop_pg_pattern_name = find_astring_value_in_pg(prop_pattern,
                    SCF_PROPERTY_TM_PG_PATTERN);
                assert(prop_pg_pattern_name != NULL);
                if (strcmp(pg_pattern->sc_pgroup_name,
                    prop_pg_pattern_name) != 0) {
                        continue;
                }

                /* If the property is required, see if it is in the pg. */
                if (is_required(prop_pattern) == 0)
                        continue;
                prop_name = find_astring_value_in_pg(prop_pattern,
                    SCF_PROPERTY_TM_NAME);
                assert(prop_name != NULL);
                if (property_find(pg, prop_name) == NULL) {
                        ec = SCF_TERR_MISSING_PROP;
                        rc = TVS_VALIDATION;
                        einfo.ei_type = EIT_MISSING_PROP;
                        einfo.ei_u.ei_missing_prop.ei_prop_name = prop_name;
                        if (add_scf_error(errs, ec, pg_pattern, pg,
                            prop_pattern, NULL, NULL, &einfo) != 0) {
                                /*
                                 * If we can no longer accumulate errors,
                                 * break out of the loop.
                                 */
                                break;
                        }
                }
        }

        pg_iter_destroy(iter);
        return (rc);
}

/*
 * Check the value at v to see if it falls within any of the ranges at r.
 * count is the number of ranges at r, and type tells whether to treat the
 * value as signed or unsigned.
 *
 * Return 1 if the value falls within one of the ranges.  Otherwise return
 * 0.
 */
static int
value_in_range(value_t *v, scf_type_t type, range_t *r, size_t count)
{
        for (; count > 0; --count, r++) {
                if (type == SCF_TYPE_COUNT) {
                        if ((v->sc_u.sc_count >=
                            r->rng_u.rng_unsigned.rng_min) &&
                            (v->sc_u.sc_count <=
                            r->rng_u.rng_unsigned.rng_max))
                                return (1);
                } else {
                        if ((v->sc_u.sc_integer >=
                            r->rng_u.rng_signed.rng_min) &&
                            (v->sc_u.sc_integer <=
                            r->rng_u.rng_signed.rng_max))
                                return (1);
                }
        }
        return (0);
}

/*
 * If the template prop_pattern at pattern contains a constraint_range
 * property, use the specified range to validate all the numeric property
 * values of the property at prop.
 *
 * pg is the property group that holds prop, and pg_pattern is the
 * pg_pattern for the property group.  pg and pg_pattern are only used for
 * error reporting.
 */
static tmpl_validate_status_t
tmpl_validate_value_range(pgroup_t *pattern, property_t *prop, pgroup_t *pg,
    pgroup_t *pg_pattern, tmpl_errors_t *errs)
{
        uint_t count;
        error_info_t einfo;
        property_t *range_prop;
        range_t *ranges;
        tmpl_validate_status_t rc;
        scf_type_t type;
        value_t *v;

        /* Get the range constraints if they exist. */
        if ((range_prop = property_find(pattern,
            SCF_PROPERTY_TM_CONSTRAINT_RANGE)) == NULL) {
                /* No range to check. */
                return (TVS_SUCCESS);
        }
        type = prop->sc_value_type;
        if ((type != SCF_TYPE_COUNT) && (type != SCF_TYPE_INTEGER)) {
                rc = TVS_BAD_TEMPLATE;
                CLEAR_ERROR_INFO(&einfo);
                einfo.ei_type = EIT_BAD_TEMPLATE;
                einfo.ei_u.ei_bad_template.ei_reason =
                    gettext("Property does not have correct type for "
                    "a range specification");
                (void) tmpl_errors_add_im(errs, rc, pg_pattern->sc_parent,
                    pg_pattern, pg, pattern, prop, NULL, &einfo);
                return (rc);
        }
        if ((rc = get_ranges(range_prop, prop->sc_value_type, &ranges,
            &count)) != TVS_SUCCESS) {
                rc = TVS_BAD_TEMPLATE;
                CLEAR_ERROR_INFO(&einfo);
                einfo.ei_type = EIT_BAD_TEMPLATE;
                einfo.ei_u.ei_bad_template.ei_reason = gettext("Illegal range "
                    "value");
                (void) tmpl_errors_add_im(errs, rc, pg_pattern->sc_parent,
                    pg_pattern, pg, pattern, prop, NULL, &einfo);
                return (rc);
        }

        /* Set up error info before entering loop. */
        CLEAR_ERROR_INFO(&einfo);
        einfo.ei_type = EIT_RANGE;
        einfo.ei_u.ei_range.ei_rtype = type;

        /* Compare numeric values of the property to the range. */
        for (v = uu_list_first(prop->sc_property_values);
            v != NULL;
            v = uu_list_next(prop->sc_property_values, v)) {
                if (value_in_range(v, type, ranges, count) == 1)
                        continue;
                if (type == SCF_TYPE_COUNT) {
                        einfo.ei_u.ei_range.ei_uvalue = v->sc_u.sc_count;
                } else {
                        einfo.ei_u.ei_range.ei_ivalue = v->sc_u.sc_integer;
                }
                rc = TVS_VALIDATION;
                if (add_scf_error(errs, SCF_TERR_RANGE_VIOLATION, pg_pattern,
                    pg, pattern, prop, v, &einfo) != 0) {
                        return (rc);
                }
        }

        return (rc);
}

/*
 * If the prop_pattern has value constraints, verify that all the values
 * for the property at prop are legal values.
 *
 * pg is the property group that holds prop, and pg_pattern is the
 * pg_pattern for the property group.  pg and pg_pattern are only used for
 * error reporting.
 */
static tmpl_validate_status_t
tmpl_validate_values(pgroup_t *prop_pattern, property_t *prop, pgroup_t *pg,
    pgroup_t *pg_pattern, tmpl_errors_t *errs)
{
        int found;
        uint_t i;
        avalues_t *legal;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        value_t *v;

        /* Get list of legal values. */
        r = av_get_values(prop_pattern, SCF_PROPERTY_TM_CONSTRAINT_NAME,
            prop->sc_value_type, &legal);
        switch (r) {
        case TVS_BAD_CONVERSION:
                (void) tmpl_errors_add_im(errs, r, pg->sc_parent, pg_pattern,
                    pg, prop_pattern, prop, NULL, NULL);
                return (r);
        case TVS_NOMATCH:
                /* No constraints in template. */
                return (TVS_SUCCESS);
        case TVS_SUCCESS:
                /* process the constraints. */
                break;
        default:
                assert(0);
                abort();
        }

        /* Check the property values against the legal values. */
        for (v = uu_list_first(prop->sc_property_values);
            v != NULL;
            v = uu_list_next(prop->sc_property_values, v)) {
                /* Check this property value against the legal values. */
                found = 0;
                for (i = 0; (i < legal->av_count) && (found == 0); i++) {
                        switch (v->sc_type) {
                        case SCF_TYPE_BOOLEAN:
                        case SCF_TYPE_COUNT:
                                if (av_get_unsigned(legal, i) ==
                                    v->sc_u.sc_count) {
                                        found = 1;
                                }
                                break;
                        case SCF_TYPE_INTEGER:
                                if (av_get_integer(legal, i) ==
                                    v->sc_u.sc_integer) {
                                        found = 1;
                                }
                                break;
                        default:
                                if (strcmp(av_get_string(legal, i),
                                    v->sc_u.sc_string) == 0) {
                                        found = 1;
                                }
                                break;
                        }
                }
                if (found == 0) {
                        rc = TVS_VALIDATION;
                        if (add_scf_error(errs,
                            SCF_TERR_VALUE_CONSTRAINT_VIOLATED, pg_pattern, pg,
                            prop_pattern, prop, v, NULL) != 0) {
                                /*
                                 * Exit loop if no longer able to report
                                 * errors.
                                 */
                                break;
                        }
                }
        }

out:
        av_destroy(legal);
        return (rc);
}

/*
 * Verify the following items about the values of property, prop.
 *
 *      - The values all have the type specified by the prop_pattern at
 *        pattern.
 *      - Check numeric values against range constraints.
 *      - If the prop_pattern has one or more value constraints, validate
 *        the property's values against the constraints.
 *
 * pg is the property group that holds prop, and pg_pattern is the
 * pg_pattern for the property group.  pg and pg_pattern are only used for
 * error reporting.
 */
static tmpl_validate_status_t
tmpl_validate_value_constraints(pgroup_t *pattern, property_t *prop,
    pgroup_t *pg, pgroup_t *pg_pattern, tmpl_errors_t *errs)
{
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc;

        rc = tmpl_validate_value_range(pattern, prop, pg, pg_pattern, errs);
        r = tmpl_validate_values(pattern, prop, pg, pg_pattern, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        return (rc);
}

/*
 * Perform the following validations on the property, prop.
 *
 *      - Verify that the property's type agrees with the type specified in
 *        the prop_pattern template, tmpl.
 *      - Verify the cardinality.
 *      - Verify that the property values satisfy the constraints specified
 *        by the template.
 *
 * pg is the property group that holds prop, and pg_pattern is the
 * pg_pattern for the property group.  pg and pg_pattern are only used for
 * error reporting.
 */
static tmpl_validate_status_t
tmpl_validate_prop(property_t *prop, pgroup_t *tmpl, pgroup_t *pg,
    pgroup_t *pg_pattern, tmpl_errors_t *errs)
{
        scf_tmpl_error_type_t ec;
        error_info_t einfo;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        int status;
        scf_type_t type;

        r = prop_pattern_type(tmpl, &type);
        switch (r) {
        case TVS_SUCCESS:
                if (type == SCF_TYPE_INVALID) {
                        rc = TVS_INVALID_TYPE_SPECIFICATION;
                        r = tmpl_errors_add_im(errs, rc, pg->sc_parent, NULL,
                            pg, tmpl, NULL, NULL, NULL);
                        if (r != TVS_SUCCESS) {
                                /*
                                 * Give up if we can no longer accumulate
                                 * errors.
                                 */
                                return (rc);
                        }
                } else {
                        if (property_is_type(prop, type) == 0) {
                                CLEAR_ERROR_INFO(&einfo);
                                rc = TVS_VALIDATION;
                                ec = SCF_TERR_WRONG_PROP_TYPE;
                                einfo.ei_type  = EIT_PROP_TYPE;
                                einfo.ei_u.ei_prop_type.ei_specified = type;
                                einfo.ei_u.ei_prop_type.ei_actual =
                                    prop->sc_value_type;
                                status = add_scf_error(errs, ec,
                                    pg_pattern, pg, tmpl, prop, NULL, &einfo);
                                if (status != 0) {
                                        /*
                                         * Give up if we can no longer
                                         * accumulate errors.
                                         */
                                        return (rc);
                                }
                        }
                }
                break;
        case TVS_MISSING_TYPE_SPECIFICATION:
                /*
                 * A null type specification means that we do not need to
                 * check the property's type.
                 */
                break;
        default:
                rc = r;
        }

        /* Validate the cardinality */
        r = tmpl_validate_cardinality(tmpl, prop, pg, pg_pattern, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        /* Validate that property values satisfy constraints. */
        r = tmpl_validate_value_constraints(tmpl, prop, pg, pg_pattern, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        return (rc);
}

/*
 * Validate the property group at pg by performing the following checks:
 *
 *      - Verify that the types of the pg and the pg_pattern are
 *        compatible.
 *      - Verify the properties in the pg.
 *      - Verify that required properties are present.
 */
static tmpl_validate_status_t
tmpl_validate_pg(entity_t *e, pgroup_t *pg, tmpl_errors_t *errs)
{
        error_info_t einfo;
        const char *pg_pattern_type;    /* Type declared by pg_pattern. */
        pgroup_t *pg_pattern;   /* Prop. group for pg_pattern */
        property_t *prop;
        pgroup_t *prop_pattern;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        int stat;

        /*
         * See if there is a pg_pattern for this property group.  If it
         * exists, use it to validate the property group.  If there is no
         * pg_pattern, then there is no validation to do.
         */
        rc = tmpl_find_pg_pattern(e, pg, &pg_pattern);
        switch (rc) {
        case TVS_SUCCESS:
                break;
        case TVS_BAD_TEMPLATE:
                CLEAR_ERROR_INFO(&einfo);
                einfo.ei_type = EIT_BAD_TEMPLATE;
                einfo.ei_u.ei_bad_template.ei_reason = gettext("Property "
                    "group name too long");
                (void) tmpl_errors_add_im(errs, rc, e, NULL, pg, NULL, NULL,
                    NULL, &einfo);
                return (rc);
        default:
                assert(0);
                abort();
        }
        if (pg_pattern == NULL)
                return (TVS_SUCCESS);

        /*
         * If the pg_pattern declares a type, verify that the PG has the
         * correct type.
         */
        pg_pattern_type = find_type_specification(pg_pattern);
        if ((pg_pattern_type != NULL) &&
            (*pg_pattern_type != 0)) {
                if ((pg->sc_pgroup_type != NULL) &&
                    (*(pg->sc_pgroup_type) != 0)) {
                        if (strcmp(pg_pattern_type,
                            pg->sc_pgroup_type) != 0) {
                                rc = TVS_VALIDATION;
                                stat = add_scf_error(errs,
                                    SCF_TERR_WRONG_PG_TYPE, pg_pattern, pg,
                                    NULL, NULL, NULL, NULL);
                                if (stat != 0) {
                                        /*
                                         * If we can no longer accumulate
                                         * errors, return without trying to
                                         * do further validation.
                                         */
                                        return (rc);
                                }
                        }
                } else {
                        rc = TVS_MISSING_PG_TYPE;
                        r = tmpl_errors_add_im(errs, rc, e, pg_pattern, pg,
                            NULL, NULL, NULL, NULL);
                        if (r != TVS_SUCCESS) {
                                /*
                                 * If we can no longer accumulate errors,
                                 * return without trying to do further
                                 * validation.
                                 */
                                return (rc);
                        }
                }
        }

        /* Verify the properties in the property group. */
        prop = NULL;
        while ((prop = next_property(pg, prop)) != NULL) {
                r = tmpl_find_prop_pattern(e, pg_pattern, prop, &prop_pattern);
                switch (r) {
                case TVS_SUCCESS:
                        /* Found match.  Validate property. */
                        break;
                case TVS_NOMATCH:
                        /* No prop_patern.  Go on to next property. */
                        continue;
                case TVS_BAD_TEMPLATE:
                        CLEAR_ERROR_INFO(&einfo);
                        einfo.ei_type = EIT_BAD_TEMPLATE;
                        einfo.ei_u.ei_bad_template.ei_reason =
                            gettext("prop_pattern name too long");
                        (void) tmpl_errors_add_im(errs, r, e, NULL, pg, NULL,
                            NULL, NULL, &einfo);
                        continue;
                default:
                        assert(0);
                        abort();
                }
                r = tmpl_validate_prop(prop, prop_pattern, pg, pg_pattern,
                    errs);
                if (r != TVS_SUCCESS)
                        rc = r;
        }

        /*
         * Confirm required properties are present.
         */
        r = tmpl_required_props_present(e, pg, pg_pattern, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        return (rc);
}

/*
 * Validate that the property groups in the entity conform to the template
 * specifications.  Specifically, this means do the following:
 *
 *      - Loop through the property groups in the entity skipping the ones
 *        that are of type "template".
 *
 *      - For the PG search for the corresponding template_pg_pattern
 *        property group.  It is possible that one may not exist.
 *
 *      - Verify that the PG is in conformance with the pg_pattern
 *        specification if it exists.
 */
static tmpl_validate_status_t
tmpl_validate_entity_pgs(entity_t *e, tmpl_errors_t *errs)
{
        composed_pg_t *cpg;
        uu_avl_t *pgroups;
        pgroup_t *pg;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;

        assert(e->sc_etype == SVCCFG_INSTANCE_OBJECT);

        pgroups = e->sc_u.sc_instance.sc_composed;
        for (cpg = uu_avl_first(pgroups);
            cpg != NULL;
            cpg = uu_avl_next(pgroups, cpg)) {
                if (strcmp(cpg->cpg_type, SCF_GROUP_TEMPLATE) == 0)
                        continue;
                pg = CPG2PG(cpg);
                if ((r = tmpl_validate_pg(e, pg, errs)) != TVS_SUCCESS)
                        rc = r;
        }

        return (rc);
}

/*
 * Validate the instance, e, by performing the following checks:
 *
 *      - Verify template consistency.
 *
 *      - Validate each property group in the entity is in conformance
 *        with the template specifications.
 *
 *      - Verify that all required property groups are present in the
 *        entity.
 */
static tmpl_validate_status_t
tmpl_validate_instance(entity_t *e, tmpl_errors_t *errs)
{
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;
        int status;
        tv_errors_t *ste;

        /* Prepare to collect errors for this instance. */
        ste = tv_errors_create(e->sc_fmri);
        status = uu_list_insert_after(errs->te_scf, errs->te_cur_scf, ste);
        assert(status == 0);
        errs->te_cur_scf = ste;

        /* Verify template consistency */
        rc = tmpl_consistency(e, errs);

        /* Validate the property groups in the entity. */
        r = tmpl_validate_entity_pgs(e, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        /* Verify that all required property groups are present. */
        r = tmpl_required_pg_present(e, errs);
        if (r != TVS_SUCCESS)
                rc = r;

        return (rc);
}

/*
 * First validate the instances of the service.
 */
static tmpl_validate_status_t
tmpl_validate_service(entity_t *svc, tmpl_errors_t *errs)
{
        entity_t *inst;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;

        assert(svc->sc_etype == SVCCFG_SERVICE_OBJECT);

        load_general_templates(svc);

        /* Validate the service's instances. */
        for (inst = uu_list_first(svc->sc_u.sc_service.sc_service_instances);
            inst != NULL;
            inst = uu_list_next(svc->sc_u.sc_service.sc_service_instances,
            inst)) {
                load_instance_restarter(inst);
                build_composed_instance(inst);
                r = tmpl_validate_instance(inst, errs);
                if (r != TVS_SUCCESS)
                        rc = r;
                demolish_composed_instance(inst);
        }

        return (rc);
}

/*
 * Validate all services and instances in the bundle against their
 * templates.  If err_list is not NULL, a tmpl_errors structure will be
 * allocated and its address will be returned to err_list.  This structure
 * can be used to generate error messages.
 */
tmpl_validate_status_t
tmpl_validate_bundle(bundle_t *bndl, tmpl_errors_t **err_list)
{
        tmpl_errors_t *errs = NULL;
        entity_t *svc;
        tmpl_validate_status_t r;
        tmpl_validate_status_t rc = TVS_SUCCESS;

        if (err_list != NULL)
                *err_list = NULL;
        if (bndl->sc_bundle_type != SVCCFG_MANIFEST) {
                semerr(gettext("Bundle is not a manifest.  Unable to validate "
                    "against templates.\n"));
                return (TVS_FATAL);
        }

        errs = tmpl_errors_create();
        if (errs == NULL)
                uu_die(emesg_nomem);

        lscf_prep_hndl();               /* Initialize g_hndl */
        if (load_init() != 0)
                uu_die(emesg_nomem);

        /*
         * We will process all services in the bundle, unless we get a
         * fatal error.  That way we can report all errors on all services
         * on a single run of svccfg.
         */
        for (svc = uu_list_first(bndl->sc_bundle_services);
            svc != NULL;
            svc = uu_list_next(bndl->sc_bundle_services, svc)) {
                if (svc->sc_etype != SVCCFG_SERVICE_OBJECT) {
                        semerr(gettext("Manifest for %s contains an object "
                            "named \"%s\" that is not a service.\n"),
                            bndl->sc_bundle_name, svc->sc_name);
                        tmpl_errors_destroy(errs);
                        load_fini();
                        return (TVS_FATAL);
                }
                if ((r = tmpl_validate_service(svc, errs)) != TVS_SUCCESS)
                        rc = r;
                if (r == TVS_FATAL)
                        break;
        }

        if (err_list == NULL) {
                tmpl_errors_destroy(errs);
        } else {
                *err_list = errs;
        }

        load_fini();

        return (rc);
}