No OneTemporary
Actions

Size

66 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/common/xml_internal.h b/include/crm/common/xml_internal.h
	index ddb4384e29..f319856c83 100644
	--- a/include/crm/common/xml_internal.h
	+++ b/include/crm/common/xml_internal.h
	@@ -1,448 +1,451 @@
	/*
	* Copyright 2017-2023 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef PCMK__XML_INTERNAL__H
	# define PCMK__XML_INTERNAL__H

	/*
	* Internal-only wrappers for and extensions to libxml2 (libxslt)
	*/

	# include <stdlib.h>
	# include <stdio.h>
	# include <string.h>

	# include <crm/crm.h> /* transitively imports qblog.h */
	# include <crm/common/output_internal.h>

	# include <libxml/relaxng.h>

	/*!
	* \brief Base for directing lib{xml2,xslt} log into standard libqb backend
	*
	* This macro implements the core of what can be needed for directing
	* libxml2 or libxslt error messaging into standard, preconfigured
	* libqb-backed log stream.
	*
	* It's a bit unfortunate that libxml2 (and more sparsely, also libxslt)
	* emits a single message by chunks (location is emitted separatedly from
	* the message itself), so we have to take the effort to combine these
	* chunks back to single message. Whether to do this or not is driven
	* with \p dechunk toggle.
	*
	* The form of a macro was chosen for implicit deriving of __FILE__, etc.
	* and also because static dechunking buffer should be differentiated per
	* library (here we assume different functions referring to this macro
	* will not ever be using both at once), preferably also per-library
	* context of use to avoid clashes altogether.
	*
	* Note that we cannot use qb_logt, because callsite data have to be known
	* at the moment of compilation, which it is not always the case -- xml_log
	* (and unfortunately there's no clear explanation of the fail to compile).
	*
	* Also note that there's no explicit guard against said libraries producing
	* never-newline-terminated chunks (which would just keep consuming memory),
	* as it's quite improbable. Termination of the program in between the
	* same-message chunks will raise a flag with valgrind and the likes, though.
	*
	* And lastly, regarding how dechunking combines with other non-message
	* parameters -- for \p priority, most important running specification
	* wins (possibly elevated to LOG_ERR in case of nonconformance with the
	* newline-termination "protocol"), \p dechunk is expected to always be
	* on once it was at the start, and the rest (\p postemit and \p prefix)
	* are picked directly from the last chunk entry finalizing the message
	* (also reasonable to always have it the same with all related entries).
	*
	* \param[in] priority Syslog priority for the message to be logged
	* \param[in] dechunk Whether to dechunk new-line terminated message
	* \param[in] postemit Code to be executed once message is sent out
	* \param[in] prefix How to prefix the message or NULL for raw passing
	* \param[in] fmt Format string as with printf-like functions
	* \param[in] ap Variable argument list to supplement \p fmt format string
	*/
	#define PCMK__XML_LOG_BASE(priority, dechunk, postemit, prefix, fmt, ap) \
	do { \
	if (!(dechunk) && (prefix) == NULL) { /* quick pass */ \
	qb_log_from_external_source_va(__func__, __FILE__, (fmt), \
	(priority), __LINE__, 0, (ap)); \
	(void) (postemit); \
	} else { \
	int CXLB_len = 0; \
	char *CXLB_buf = NULL; \
	static int CXLB_buffer_len = 0; \
	static char *CXLB_buffer = NULL; \
	static uint8_t CXLB_priority = 0; \
	\
	CXLB_len = vasprintf(&CXLB_buf, (fmt), (ap)); \
	\
	if (CXLB_len <= 0 \|\| CXLB_buf[CXLB_len - 1] == '\n' \|\| !(dechunk)) { \
	if (CXLB_len < 0) { \
	CXLB_buf = (char ) "LOG CORRUPTION HAZARD"; /we don't modify*/\
	CXLB_priority = QB_MIN(CXLB_priority, LOG_ERR); \
	} else if (CXLB_len > 0 /* && (dechunk) */ \
	&& CXLB_buf[CXLB_len - 1] == '\n') { \
	CXLB_buf[CXLB_len - 1] = '\0'; \
	} \
	if (CXLB_buffer) { \
	qb_log_from_external_source(__func__, __FILE__, "%s%s%s", \
	CXLB_priority, __LINE__, 0, \
	(prefix) != NULL ? (prefix) : "", \
	CXLB_buffer, CXLB_buf); \
	free(CXLB_buffer); \
	} else { \
	qb_log_from_external_source(__func__, __FILE__, "%s%s", \
	(priority), __LINE__, 0, \
	(prefix) != NULL ? (prefix) : "", \
	CXLB_buf); \
	} \
	if (CXLB_len < 0) { \
	CXLB_buf = NULL; /* restore temporary override */ \
	} \
	CXLB_buffer = NULL; \
	CXLB_buffer_len = 0; \
	(void) (postemit); \
	\
	} else if (CXLB_buffer == NULL) { \
	CXLB_buffer_len = CXLB_len; \
	CXLB_buffer = CXLB_buf; \
	CXLB_buf = NULL; \
	CXLB_priority = (priority); /* remember as a running severest */ \
	\
	} else { \
	CXLB_buffer = realloc(CXLB_buffer, 1 + CXLB_buffer_len + CXLB_len); \
	memcpy(CXLB_buffer + CXLB_buffer_len, CXLB_buf, CXLB_len); \
	CXLB_buffer_len += CXLB_len; \
	CXLB_buffer[CXLB_buffer_len] = '\0'; \
	CXLB_priority = QB_MIN(CXLB_priority, (priority)); /* severest? */ \
	} \
	free(CXLB_buf); \
	} \
	} while (0)

	/*
	* \enum pcmk__xml_fmt_options
	* \brief Bit flags to control format in XML logs and dumps
	*/
	enum pcmk__xml_fmt_options {
	//! Exclude certain XML attributes (for calculating digests)
	pcmk__xml_fmt_filtered = (1 << 0),

	//! Include indentation and newlines
	pcmk__xml_fmt_pretty = (1 << 1),

	//! Include the opening tag of an XML element, and include XML comments
	pcmk__xml_fmt_open = (1 << 3),

	//! Include the children of an XML element
	pcmk__xml_fmt_children = (1 << 4),

	//! Include the closing tag of an XML element
	pcmk__xml_fmt_close = (1 << 5),

	//! Include XML text nodes
	pcmk__xml_fmt_text = (1 << 6),

	// @COMPAT Remove when v1 patchsets are removed
	//! Log a created XML subtree
	pcmk__xml_fmt_diff_plus = (1 << 7),

	// @COMPAT Remove when v1 patchsets are removed
	//! Log a removed XML subtree
	pcmk__xml_fmt_diff_minus = (1 << 8),

	// @COMPAT Remove when v1 patchsets are removed
	//! Log a minimal version of an XML diff (only showing the changes)
	pcmk__xml_fmt_diff_short = (1 << 9),
	};

	int pcmk__xml_show(pcmk__output_t out, const char prefix, const xmlNode *data,
	int depth, uint32_t options);
	int pcmk__xml_show_changes(pcmk__output_t out, const xmlNode xml);

	/* XML search strings for guest, remote and pacemaker_remote nodes */

	/* search string to find CIB resources entries for cluster nodes */
	#define PCMK__XP_MEMBER_NODE_CONFIG \
	"//" XML_TAG_CIB "/" XML_CIB_TAG_CONFIGURATION "/" XML_CIB_TAG_NODES \
	"/" XML_CIB_TAG_NODE "[not(@type) or @type='member']"

	/* search string to find CIB resources entries for guest nodes */
	#define PCMK__XP_GUEST_NODE_CONFIG \
	"//" XML_TAG_CIB "//" XML_CIB_TAG_CONFIGURATION "//" XML_CIB_TAG_RESOURCE \
	"//" XML_TAG_META_SETS "//" XML_CIB_TAG_NVPAIR \
	"[@name='" XML_RSC_ATTR_REMOTE_NODE "']"

	/* search string to find CIB resources entries for remote nodes */
	#define PCMK__XP_REMOTE_NODE_CONFIG \
	"//" XML_TAG_CIB "//" XML_CIB_TAG_CONFIGURATION "//" XML_CIB_TAG_RESOURCE \
	"[@type='remote'][@provider='pacemaker']"

	/* search string to find CIB node status entries for pacemaker_remote nodes */
	#define PCMK__XP_REMOTE_NODE_STATUS \
	"//" XML_TAG_CIB "//" XML_CIB_TAG_STATUS "//" XML_CIB_TAG_STATE \
	"[@" XML_NODE_IS_REMOTE "='true']"
	/*!
	* \internal
	* \brief Serialize XML (using libxml) into provided descriptor
	*
	* \param[in] fd File descriptor to (piece-wise) write to
	* \param[in] cur XML subtree to proceed
	*
	* \return a standard Pacemaker return code
	*/
	int pcmk__xml2fd(int fd, xmlNode *cur);

	enum pcmk__xml_artefact_ns {
	pcmk__xml_artefact_ns_legacy_rng = 1,
	pcmk__xml_artefact_ns_legacy_xslt,
	pcmk__xml_artefact_ns_base_rng,
	pcmk__xml_artefact_ns_base_xslt,
	};

	void pcmk__strip_xml_text(xmlNode *xml);
	const char pcmk__xe_add_last_written(xmlNode xe);

	xmlNode pcmk__xe_match(const xmlNode parent, const char *node_name,
	const char attr_n, const char attr_v);

	void pcmk__xe_remove_matching_attrs(xmlNode *element,
	bool (match)(xmlAttrPtr, void ),
	void *user_data);

	GString pcmk__element_xpath(const xmlNode xml);

	/*!
	* \internal
	* \brief Get the root directory to scan XML artefacts of given kind for
	*
	* \param[in] ns governs the hierarchy nesting against the inherent root dir
	*
	* \return root directory to scan XML artefacts of given kind for
	*/
	char *
	pcmk__xml_artefact_root(enum pcmk__xml_artefact_ns ns);

	/*!
	* \internal
	* \brief Get the fully unwrapped path to particular XML artifact (RNG/XSLT)
	*
	* \param[in] ns denotes path forming details (parent dir, suffix)
	* \param[in] filespec symbolic file specification to be combined with
	* #artefact_ns to form the final path
	* \return unwrapped path to particular XML artifact (RNG/XSLT)
	*/
	char *pcmk__xml_artefact_path(enum pcmk__xml_artefact_ns ns,
	const char *filespec);

	/*!
	* \internal
	* \brief Check whether an XML element is of a particular type
	*
	* \param[in] xml XML element to compare
	* \param[in] name XML element name to compare
	*
	* \return \c true if \p xml is of type \p name, otherwise \c false
	*/
	static inline bool
	pcmk__xe_is(const xmlNode xml, const char name)
	{
	return (xml != NULL) && (xml->name != NULL) && (name != NULL)
	&& (strcmp((const char *) xml->name, name) == 0);
	}

	/*!
	* \internal
	* \brief Return first non-text child node of an XML node
	*
	* \param[in] parent XML node to check
	*
	* \return First non-text child node of \p parent (or NULL if none)
	*/
	static inline xmlNode *
	pcmk__xml_first_child(const xmlNode *parent)
	{
	xmlNode *child = (parent? parent->children : NULL);

	while (child && (child->type == XML_TEXT_NODE)) {
	child = child->next;
	}
	return child;
	}

	/*!
	* \internal
	* \brief Return next non-text sibling node of an XML node
	*
	* \param[in] child XML node to check
	*
	* \return Next non-text sibling of \p child (or NULL if none)
	*/
	static inline xmlNode *
	pcmk__xml_next(const xmlNode *child)
	{
	xmlNode *next = (child? child->next : NULL);

	while (next && (next->type == XML_TEXT_NODE)) {
	next = next->next;
	}
	return next;
	}

	/*!
	* \internal
	* \brief Return first non-text child element of an XML node
	*
	* \param[in] parent XML node to check
	*
	* \return First child element of \p parent (or NULL if none)
	*/
	static inline xmlNode *
	pcmk__xe_first_child(const xmlNode *parent)
	{
	xmlNode *child = (parent? parent->children : NULL);

	while (child && (child->type != XML_ELEMENT_NODE)) {
	child = child->next;
	}
	return child;
	}

	/*!
	* \internal
	* \brief Return next non-text sibling element of an XML element
	*
	* \param[in] child XML element to check
	*
	* \return Next sibling element of \p child (or NULL if none)
	*/
	static inline xmlNode *
	pcmk__xe_next(const xmlNode *child)
	{
	xmlNode *next = child? child->next : NULL;

	while (next && (next->type != XML_ELEMENT_NODE)) {
	next = next->next;
	}
	return next;
	}

	/*!
	* \internal
	* \brief Like pcmk__xe_set_props, but takes a va_list instead of
	* arguments directly.
	*
	* \param[in,out] node XML to add attributes to
	* \param[in] pairs NULL-terminated list of name/value pairs to add
	*/
	void
	pcmk__xe_set_propv(xmlNodePtr node, va_list pairs);

	/*!
	* \internal
	* \brief Add a NULL-terminated list of name/value pairs to the given
	* XML node as properties.
	*
	* \param[in,out] node XML node to add properties to
	* \param[in] ... NULL-terminated list of name/value pairs
	*
	* \note A NULL name terminates the arguments; a NULL value will be skipped.
	*/
	void
	pcmk__xe_set_props(xmlNodePtr node, ...)
	G_GNUC_NULL_TERMINATED;

	/*!
	* \internal
	* \brief Get first attribute of an XML element
	*
	* \param[in] xe XML element to check
	*
	* \return First attribute of \p xe (or NULL if \p xe is NULL or has none)
	*/
	static inline xmlAttr *
	pcmk__xe_first_attr(const xmlNode *xe)
	{
	return (xe == NULL)? NULL : xe->properties;
	}

	/*!
	* \internal
	* \brief Extract the ID attribute from an XML element
	*
	* \param[in] xpath String to search
	* \param[in] node Node to get the ID for
	*
	* \return ID attribute of \p node in xpath string \p xpath
	*/
	char *
	pcmk__xpath_node_id(const char xpath, const char node);

	/* internal XML-related utilities */

	enum xml_private_flags {
	pcmk__xf_none = 0x0000,
	pcmk__xf_dirty = 0x0001,
	pcmk__xf_deleted = 0x0002,
	pcmk__xf_created = 0x0004,
	pcmk__xf_modified = 0x0008,

	pcmk__xf_tracking = 0x0010,
	pcmk__xf_processed = 0x0020,
	pcmk__xf_skip = 0x0040,
	pcmk__xf_moved = 0x0080,

	pcmk__xf_acl_enabled = 0x0100,
	pcmk__xf_acl_read = 0x0200,
	pcmk__xf_acl_write = 0x0400,
	pcmk__xf_acl_deny = 0x0800,

	pcmk__xf_acl_create = 0x1000,
	pcmk__xf_acl_denied = 0x2000,
	pcmk__xf_lazy = 0x4000,
	};

	void pcmk__set_xml_doc_flag(xmlNode *xml, enum xml_private_flags flag);

	/*!
	* \internal
	* \brief Iterate over child elements of \p xml
	*
	* This function iterates over the children of \p xml, performing the
	* callback function \p handler on each node. If the callback returns
	* a value other than pcmk_rc_ok, the iteration stops and the value is
	* returned. It is therefore possible that not all children will be
	* visited.
	*
	* \param[in,out] xml The starting XML node. Can be NULL.
	* \param[in] child_element_name The name that the node must match in order
	* for \p handler to be run. If NULL, all
	* child elements will match.
	* \param[in] handler The callback function.
	* \param[in,out] userdata User data to pass to the callback function.
	* Can be NULL.
	*
	* \return Standard Pacemaker return code
	*/
	int
	pcmk__xe_foreach_child(xmlNode xml, const char child_element_name,
	int (handler)(xmlNode xml, void *userdata),
	void *userdata);

	static inline const char *
	pcmk__xml_attr_value(const xmlAttr *attr)
	{
	return ((attr == NULL) \|\| (attr->children == NULL))? NULL
	: (const char *) attr->children->content;
	}

	+
	gboolean pcmk__validate_xml(xmlNode xml_blob, const char validation,
	xmlRelaxNGValidityErrorFunc error_handler,
	void *error_handler_context);

	+void pcmk__log_known_schemas(void);
	+
	#endif // PCMK__XML_INTERNAL__H
	diff --git a/lib/common/schemas.c b/lib/common/schemas.c
	index a4ae350ea8..53c21f1687 100644
	--- a/lib/common/schemas.c
	+++ b/lib/common/schemas.c
	@@ -1,1245 +1,1279 @@
	/*
	* Copyright 2004-2023 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <string.h>
	#include <dirent.h>
	#include <errno.h>
	#include <sys/stat.h>
	#include <stdarg.h>

	#include <libxml/relaxng.h>
	#include <libxslt/xslt.h>
	#include <libxslt/transform.h>
	#include <libxslt/security.h>
	#include <libxslt/xsltutils.h>

	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	#include <crm/common/xml_internal.h> /* PCMK__XML_LOG_BASE */

	typedef struct {
	unsigned char v[2];
	} schema_version_t;

	#define SCHEMA_ZERO { .v = { 0, 0 } }

	-#define schema_scanf(s, prefix, version, suffix) \
	- sscanf((s), prefix "%hhu.%hhu" suffix, &((version).v[0]), &((version).v[1]))
	-
	#define schema_strdup_printf(prefix, version, suffix) \
	crm_strdup_printf(prefix "%u.%u" suffix, (version).v[0], (version).v[1])

	typedef struct {
	xmlRelaxNGPtr rng;
	xmlRelaxNGValidCtxtPtr valid;
	xmlRelaxNGParserCtxtPtr parser;
	} relaxng_ctx_cache_t;

	enum schema_validator_e {
	schema_validator_none,
	schema_validator_rng
	};

	struct schema_s {
	char *name;
	char *transform;
	void *cache;
	enum schema_validator_e validator;
	- int after_transform;
	schema_version_t version;
	char *transform_enter;
	bool transform_onleave;
	};

	-static struct schema_s *known_schemas = NULL;
	-static int xml_schema_max = 0;
	+static GList *known_schemas = NULL;
	static bool silent_logging = FALSE;

	-static void
	-xml_log(int priority, const char *fmt, ...)
	-G_GNUC_PRINTF(2, 3);
	-
	-static void
	+static void G_GNUC_PRINTF(2, 3)
	xml_log(int priority, const char *fmt, ...)
	{
	va_list ap;

	va_start(ap, fmt);
	if (silent_logging == FALSE) {
	/* XXX should not this enable dechunking as well? */
	PCMK__XML_LOG_BASE(priority, FALSE, 0, NULL, fmt, ap);
	}
	va_end(ap);
	}

	static int
	xml_latest_schema_index(void)
	{
	// @COMPAT: pacemaker-next is deprecated since 2.1.5
	- return xml_schema_max - 3; // index from 0, ignore "pacemaker-next"/"none"
	+ // FIXME: This function assumes at least three schemas have been added
	+ // before it has been called for the first time.
	+ return g_list_length(known_schemas) - 3; // index from 0, ignore "pacemaker-next"/"none"
	}

	+/* Return the index of the most recent X.0 schema. */
	static int
	-xml_minimum_schema_index(void)
	+xml_find_x_0_schema_index(void)
	{
	static int best = 0;
	- if (best == 0) {
	- int lpc = 0;
	-
	- best = xml_latest_schema_index();
	- for (lpc = best; lpc > 0; lpc--) {
	- if (known_schemas[lpc].version.v[0]
	- < known_schemas[best].version.v[0]) {
	- return best;
	- } else {
	- best = lpc;
	- }
	+ int i = 0;
	+ struct schema_s *best_schema = NULL;
	+
	+ if (best != 0) {
	+ return best;
	+ }
	+
	+ /* Get the most recent schema so we can look at its version number. */
	+ best = xml_latest_schema_index();
	+ best_schema = g_list_nth(known_schemas, best)->data;
	+
	+ /* Iterate over the schema list until we find a schema with the same major
	+ * version as best, and with a minor version number of 0.
	+ *
	+ * This assumes that the first schema in a major series is always X.0,
	+ * which seems like a safe assumption.
	+ */
	+ for (GList *iter = known_schemas; iter != NULL; iter = iter->next) {
	+ struct schema_s *schema = iter->data;
	+
	+ /* If we hit the initial best schema, the only things left in the list
	+ * are "pacemaker-next" and "none" which aren't worth checking.
	+ */
	+ if (schema == best_schema) {
	+ break;
	}
	- best = xml_latest_schema_index();
	+
	+ if (schema->version.v[0] == best_schema->version.v[0] &&
	+ schema->version.v[1] == 0) {
	+ best = i;
	+ return best;
	+ }
	+
	+ i++;
	}
	+
	+ /* If we got here, we never found a match. Just return the latest. */
	+ best = xml_latest_schema_index();
	return best;
	}

	const char *
	xml_latest_schema(void)
	{
	return get_schema_name(xml_latest_schema_index());
	}

	static inline bool
	version_from_filename(const char filename, schema_version_t version)
	{
	- int rc = schema_scanf(filename, "pacemaker-", *version, ".rng");
	-
	- return (rc == 2);
	+ return sscanf(filename, "pacemaker-%hhu.%hhu.rng", &(version->v[0]), &(version->v[1])) == 2;
	}

	static int
	schema_filter(const struct dirent *a)
	{
	int rc = 0;
	schema_version_t version = SCHEMA_ZERO;

	if (strstr(a->d_name, "pacemaker-") != a->d_name) {
	/* crm_trace("%s - wrong prefix", a->d_name); */

	} else if (!pcmk__ends_with_ext(a->d_name, ".rng")) {
	/* crm_trace("%s - wrong suffix", a->d_name); */

	} else if (!version_from_filename(a->d_name, &version)) {
	/* crm_trace("%s - wrong format", a->d_name); */

	} else {
	/* crm_debug("%s - candidate", a->d_name); */
	rc = 1;
	}

	return rc;
	}

	static int
	schema_sort(const struct dirent a, const struct dirent b)
	{
	schema_version_t a_version = SCHEMA_ZERO;
	schema_version_t b_version = SCHEMA_ZERO;

	if (!version_from_filename(a[0]->d_name, &a_version)
	\|\| !version_from_filename(b[0]->d_name, &b_version)) {
	// Shouldn't be possible, but makes static analysis happy
	return 0;
	}

	for (int i = 0; i < 2; ++i) {
	if (a_version.v[i] < b_version.v[i]) {
	return -1;
	} else if (a_version.v[i] > b_version.v[i]) {
	return 1;
	}
	}
	return 0;
	}

	/*!
	* \internal
	* \brief Add given schema + auxiliary data to internal bookkeeping.
	*
	* \note When providing \p version, should not be called directly but
	* through \c add_schema_by_version.
	*/
	static void
	add_schema(enum schema_validator_e validator, const schema_version_t *version,
	const char name, const char transform,
	- const char *transform_enter, bool transform_onleave,
	- int after_transform)
	+ const char *transform_enter, bool transform_onleave)
	{
	- int last = xml_schema_max;
	- bool have_version = FALSE;
	+ struct schema_s *schema = NULL;
	+ int last = g_list_length(known_schemas);

	- xml_schema_max++;
	- known_schemas = pcmk__realloc(known_schemas,
	- xml_schema_max * sizeof(struct schema_s));
	- CRM_ASSERT(known_schemas != NULL);
	- memset(known_schemas+last, 0, sizeof(struct schema_s));
	- known_schemas[last].validator = validator;
	- known_schemas[last].after_transform = after_transform;
	+ schema = calloc(1, sizeof(struct schema_s));
	+ CRM_ASSERT(schema != NULL);

	- for (int i = 0; i < 2; ++i) {
	- known_schemas[last].version.v[i] = version->v[i];
	- if (version->v[i]) {
	- have_version = TRUE;
	- }
	- }
	- if (have_version) {
	- known_schemas[last].name = schema_strdup_printf("pacemaker-", *version, "");
	+ schema->validator = validator;
	+ schema->version.v[0] = version->v[0];
	+ schema->version.v[1] = version->v[1];
	+ schema->transform_onleave = transform_onleave;
	+
	+ if (version->v[0] \|\| version->v[1]) {
	+ schema->name = schema_strdup_printf("pacemaker-", *version, "");
	} else {
	- CRM_ASSERT(name);
	- schema_scanf(name, "%*[^-]-", known_schemas[last].version, "");
	- known_schemas[last].name = strdup(name);
	+ schema->name = strdup(name);
	+ CRM_ASSERT(schema->name != NULL);
	}

	if (transform) {
	- known_schemas[last].transform = strdup(transform);
	+ schema->transform = strdup(transform);
	+ CRM_ASSERT(schema->transform != NULL);
	}
	+
	if (transform_enter) {
	- known_schemas[last].transform_enter = strdup(transform_enter);
	- }
	- known_schemas[last].transform_onleave = transform_onleave;
	- if (after_transform == 0) {
	- after_transform = xml_schema_max; /* upgrade is a one-way */
	+ schema->transform_enter = strdup(transform_enter);
	+ CRM_ASSERT(schema->transform_enter != NULL);
	}
	- known_schemas[last].after_transform = after_transform;

	- if (known_schemas[last].after_transform < 0) {
	- crm_debug("Added supported schema %d: %s",
	- last, known_schemas[last].name);
	+ known_schemas = g_list_append(known_schemas, schema);

	- } else if (known_schemas[last].transform) {
	- crm_debug("Added supported schema %d: %s (upgrades to %d with %s.xsl)",
	- last, known_schemas[last].name,
	- known_schemas[last].after_transform,
	- known_schemas[last].transform);
	+ if (schema->transform != NULL) {
	+ crm_debug("Added supported schema %d: %s (upgrades with %s.xsl)",
	+ last, schema->name, schema->transform);

	} else {
	- crm_debug("Added supported schema %d: %s (upgrades to %d)",
	- last, known_schemas[last].name,
	- known_schemas[last].after_transform);
	+ crm_debug("Added supported schema %d: %s", last, schema->name);
	}
	}

	/*!
	* \internal
	* \brief Add version-specified schema + auxiliary data to internal bookkeeping.
	* \return Standard Pacemaker return value (the only possible values are
	* \c ENOENT when no upgrade schema is associated, or \c pcmk_rc_ok otherwise.
	*
	* \note There's no reliance on the particular order of schemas entering here.
	*
	* \par A bit of theory
	* We track 3 XSLT stylesheets that differ per usage:
	* - "upgrade":
	* . sparsely spread over the sequence of all available schemas,
	* as they are only relevant when major version of the schema
	* is getting bumped -- in that case, it MUST be set
	* . name convention: upgrade-X.Y.xsl
	* - "upgrade-enter":
	* . may only accompany "upgrade" occurrence, but doesn't need to
	* be present anytime such one is, i.e., it MAY not be set when
	* "upgrade" is
	* . name convention: upgrade-X.Y-enter.xsl,
	* when not present: upgrade-enter.xsl
	* - "upgrade-leave":
	* . like "upgrade-enter", but SHOULD be present whenever
	* "upgrade-enter" is (and vice versa, but that's only
	* to prevent confusion based on observing the files,
	* it would get ignored regardless)
	* . name convention: (see "upgrade-enter")
	*/
	static int
	-add_schema_by_version(const schema_version_t *version, int next,
	- bool transform_expected)
	+add_schema_by_version(const schema_version_t *version, bool transform_expected)
	{
	bool transform_onleave = FALSE;
	int rc = pcmk_rc_ok;
	struct stat s;
	char *xslt = NULL,
	*transform_upgrade = NULL,
	*transform_enter = NULL;

	/* prologue for further transform_expected handling */
	if (transform_expected) {
	/* check if there's suitable "upgrade" stylesheet */
	transform_upgrade = schema_strdup_printf("upgrade-", *version, );
	xslt = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,
	transform_upgrade);
	}

	if (!transform_expected) {
	/* jump directly to the end */

	} else if (stat(xslt, &s) == 0) {
	/* perhaps there's also a targeted "upgrade-enter" stylesheet */
	transform_enter = schema_strdup_printf("upgrade-", *version, "-enter");
	free(xslt);
	xslt = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,
	transform_enter);
	if (stat(xslt, &s) != 0) {
	/* or initially, at least a generic one */
	crm_debug("Upgrade-enter transform %s.xsl not found", xslt);
	free(xslt);
	free(transform_enter);
	transform_enter = strdup("upgrade-enter");
	xslt = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,
	transform_enter);
	if (stat(xslt, &s) != 0) {
	crm_debug("Upgrade-enter transform %s.xsl not found, either", xslt);
	free(xslt);
	xslt = NULL;
	}
	}
	/* xslt contains full path to "upgrade-enter" stylesheet */
	if (xslt != NULL) {
	/* then there should be "upgrade-leave" counterpart (enter->leave) */
	memcpy(strrchr(xslt, '-') + 1, "leave", sizeof("leave") - 1);
	transform_onleave = (stat(xslt, &s) == 0);
	free(xslt);
	} else {
	free(transform_enter);
	transform_enter = NULL;
	}

	} else {
	crm_err("Upgrade transform %s not found", xslt);
	free(xslt);
	free(transform_upgrade);
	transform_upgrade = NULL;
	- next = -1;
	rc = ENOENT;
	}

	add_schema(schema_validator_rng, version, NULL,
	- transform_upgrade, transform_enter, transform_onleave, next);
	+ transform_upgrade, transform_enter, transform_onleave);

	free(transform_upgrade);
	free(transform_enter);

	return rc;
	}

	static void
	wrap_libxslt(bool finalize)
	{
	static xsltSecurityPrefsPtr secprefs;
	int ret = 0;

	/* security framework preferences */
	if (!finalize) {
	CRM_ASSERT(secprefs == NULL);
	secprefs = xsltNewSecurityPrefs();
	ret = xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_WRITE_FILE,
	xsltSecurityForbid)
	\| xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_CREATE_DIRECTORY,
	xsltSecurityForbid)
	\| xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_READ_NETWORK,
	xsltSecurityForbid)
	\| xsltSetSecurityPrefs(secprefs, XSLT_SECPREF_WRITE_NETWORK,
	xsltSecurityForbid);
	if (ret != 0) {
	return;
	}
	} else {
	xsltFreeSecurityPrefs(secprefs);
	secprefs = NULL;
	}

	/* cleanup only */
	if (finalize) {
	xsltCleanupGlobals();
	}
	}

	/*!
	* \internal
	* \brief Load pacemaker schemas into cache
	*
	* \note This currently also serves as an entry point for the
	* generic initialization of the libxslt library.
	*/
	void
	crm_schema_init(void)
	{
	int lpc, max;
	char *base = pcmk__xml_artefact_root(pcmk__xml_artefact_ns_legacy_rng);
	struct dirent **namelist = NULL;
	const schema_version_t zero = SCHEMA_ZERO;

	wrap_libxslt(false);

	max = scandir(base, &namelist, schema_filter, schema_sort);
	if (max < 0) {
	crm_notice("scandir(%s) failed: %s (%d)", base, strerror(errno), errno);
	free(base);

	} else {
	free(base);
	for (lpc = 0; lpc < max; lpc++) {
	bool transform_expected = FALSE;
	- int next = 0;
	schema_version_t version = SCHEMA_ZERO;

	if (!version_from_filename(namelist[lpc]->d_name, &version)) {
	// Shouldn't be possible, but makes static analysis happy
	crm_err("Skipping schema '%s': could not parse version",
	namelist[lpc]->d_name);
	continue;
	}
	if ((lpc + 1) < max) {
	schema_version_t next_version = SCHEMA_ZERO;

	if (version_from_filename(namelist[lpc+1]->d_name, &next_version)
	&& (version.v[0] < next_version.v[0])) {
	transform_expected = TRUE;
	}
	-
	- } else {
	- next = -1;
	}
	- if (add_schema_by_version(&version, next, transform_expected)
	+
	+ if (add_schema_by_version(&version, transform_expected)
	== ENOENT) {
	break;
	}
	}

	for (lpc = 0; lpc < max; lpc++) {
	free(namelist[lpc]);
	}
	free(namelist);
	}

	// @COMPAT: Deprecated since 2.1.5
	add_schema(schema_validator_rng, &zero, "pacemaker-next",
	- NULL, NULL, FALSE, -1);
	+ NULL, NULL, FALSE);

	add_schema(schema_validator_none, &zero, PCMK__VALUE_NONE,
	- NULL, NULL, FALSE, -1);
	+ NULL, NULL, FALSE);
	}

	static gboolean
	validate_with_relaxng(xmlDocPtr doc, xmlRelaxNGValidityErrorFunc error_handler, void error_handler_context, const char relaxng_file,
	relaxng_ctx_cache_t **cached_ctx)
	{
	int rc = 0;
	gboolean valid = TRUE;
	relaxng_ctx_cache_t *ctx = NULL;

	CRM_CHECK(doc != NULL, return FALSE);
	CRM_CHECK(relaxng_file != NULL, return FALSE);

	if (cached_ctx && *cached_ctx) {
	ctx = *cached_ctx;

	} else {
	crm_debug("Creating RNG parser context");
	ctx = calloc(1, sizeof(relaxng_ctx_cache_t));

	xmlLoadExtDtdDefaultValue = 1;
	ctx->parser = xmlRelaxNGNewParserCtxt(relaxng_file);
	CRM_CHECK(ctx->parser != NULL, goto cleanup);

	if (error_handler) {
	xmlRelaxNGSetParserErrors(ctx->parser,
	(xmlRelaxNGValidityErrorFunc) error_handler,
	(xmlRelaxNGValidityWarningFunc) error_handler,
	error_handler_context);
	} else {
	xmlRelaxNGSetParserErrors(ctx->parser,
	(xmlRelaxNGValidityErrorFunc) fprintf,
	(xmlRelaxNGValidityWarningFunc) fprintf,
	stderr);
	}

	ctx->rng = xmlRelaxNGParse(ctx->parser);
	CRM_CHECK(ctx->rng != NULL,
	crm_err("Could not find/parse %s", relaxng_file);
	goto cleanup);

	ctx->valid = xmlRelaxNGNewValidCtxt(ctx->rng);
	CRM_CHECK(ctx->valid != NULL, goto cleanup);

	if (error_handler) {
	xmlRelaxNGSetValidErrors(ctx->valid,
	(xmlRelaxNGValidityErrorFunc) error_handler,
	(xmlRelaxNGValidityWarningFunc) error_handler,
	error_handler_context);
	} else {
	xmlRelaxNGSetValidErrors(ctx->valid,
	(xmlRelaxNGValidityErrorFunc) fprintf,
	(xmlRelaxNGValidityWarningFunc) fprintf,
	stderr);
	}
	}

	xmlLineNumbersDefault(1);
	rc = xmlRelaxNGValidateDoc(ctx->valid, doc);
	if (rc > 0) {
	valid = FALSE;

	} else if (rc < 0) {
	crm_err("Internal libxml error during validation");
	}

	cleanup:

	if (cached_ctx) {
	*cached_ctx = ctx;

	} else {
	if (ctx->parser != NULL) {
	xmlRelaxNGFreeParserCtxt(ctx->parser);
	}
	if (ctx->valid != NULL) {
	xmlRelaxNGFreeValidCtxt(ctx->valid);
	}
	if (ctx->rng != NULL) {
	xmlRelaxNGFree(ctx->rng);
	}
	free(ctx);
	}

	return valid;
	}

	+static void
	+free_schema(gpointer data)
	+{
	+ struct schema_s *schema = data;
	+ relaxng_ctx_cache_t *ctx = NULL;
	+
	+ switch (schema->validator) {
	+ case schema_validator_none: // not cached
	+ break;
	+
	+ case schema_validator_rng: // cached
	+ ctx = (relaxng_ctx_cache_t *) schema->cache;
	+ if (ctx == NULL) {
	+ break;
	+ }
	+
	+ if (ctx->parser != NULL) {
	+ xmlRelaxNGFreeParserCtxt(ctx->parser);
	+ }
	+
	+ if (ctx->valid != NULL) {
	+ xmlRelaxNGFreeValidCtxt(ctx->valid);
	+ }
	+
	+ if (ctx->rng != NULL) {
	+ xmlRelaxNGFree(ctx->rng);
	+ }
	+
	+ free(ctx);
	+ schema->cache = NULL;
	+ break;
	+ }
	+
	+ free(schema->name);
	+ free(schema->transform);
	+ free(schema->transform_enter);
	+}
	+
	/*!
	* \internal
	* \brief Clean up global memory associated with XML schemas
	*/
	void
	crm_schema_cleanup(void)
	{
	- int lpc;
	- relaxng_ctx_cache_t *ctx = NULL;
	-
	- for (lpc = 0; lpc < xml_schema_max; lpc++) {
	-
	- switch (known_schemas[lpc].validator) {
	- case schema_validator_none: // not cached
	- break;
	- case schema_validator_rng: // cached
	- ctx = (relaxng_ctx_cache_t *) known_schemas[lpc].cache;
	- if (ctx == NULL) {
	- break;
	- }
	- if (ctx->parser != NULL) {
	- xmlRelaxNGFreeParserCtxt(ctx->parser);
	- }
	- if (ctx->valid != NULL) {
	- xmlRelaxNGFreeValidCtxt(ctx->valid);
	- }
	- if (ctx->rng != NULL) {
	- xmlRelaxNGFree(ctx->rng);
	- }
	- free(ctx);
	- known_schemas[lpc].cache = NULL;
	- break;
	- }
	- free(known_schemas[lpc].name);
	- free(known_schemas[lpc].transform);
	- free(known_schemas[lpc].transform_enter);
	- }
	- free(known_schemas);
	+ g_list_free_full(known_schemas, free_schema);
	known_schemas = NULL;

	wrap_libxslt(true);
	}

	static gboolean
	-validate_with(xmlNode xml, int method, xmlRelaxNGValidityErrorFunc error_handler, void error_handler_context)
	+validate_with(xmlNode xml, struct schema_s schema, xmlRelaxNGValidityErrorFunc error_handler, void* error_handler_context)
	{
	gboolean valid = FALSE;
	char *file = NULL;
	- struct schema_s *schema = NULL;
	relaxng_ctx_cache_t **cache = NULL;

	- if (method < 0) {
	+ if (schema == NULL) {
	return FALSE;
	}

	- schema = &(known_schemas[method]);
	if (schema->validator == schema_validator_none) {
	return TRUE;
	}

	if (pcmk__str_eq(schema->name, "pacemaker-next", pcmk__str_none)) {
	crm_warn("The pacemaker-next schema is deprecated and will be removed "
	"in a future release.");
	}

	file = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_rng,
	schema->name);

	crm_trace("Validating with %s (type=%d)",
	pcmk__s(file, "missing schema"), schema->validator);
	switch (schema->validator) {
	case schema_validator_rng:
	cache = (relaxng_ctx_cache_t **) &(schema->cache);
	valid = validate_with_relaxng(xml->doc, error_handler, error_handler_context, file, cache);
	break;
	default:
	- crm_err("Unknown validator type: %d",
	- known_schemas[method].validator);
	+ crm_err("Unknown validator type: %d", schema->validator);
	break;
	}

	free(file);
	return valid;
	}

	static bool
	-validate_with_silent(xmlNode *xml, int method)
	+validate_with_silent(xmlNode xml, struct schema_s schema)
	{
	bool rc, sl_backup = silent_logging;
	silent_logging = TRUE;
	- rc = validate_with(xml, method, (xmlRelaxNGValidityErrorFunc) xml_log, GUINT_TO_POINTER(LOG_ERR));
	+ rc = validate_with(xml, schema, (xmlRelaxNGValidityErrorFunc) xml_log, GUINT_TO_POINTER(LOG_ERR));
	silent_logging = sl_backup;
	return rc;
	}

	static void
	dump_file(const char *filename)
	{

	FILE *fp = NULL;
	int ch, line = 0;

	CRM_CHECK(filename != NULL, return);

	fp = fopen(filename, "r");
	if (fp == NULL) {
	crm_perror(LOG_ERR, "Could not open %s for reading", filename);
	return;
	}

	fprintf(stderr, "%4d ", ++line);
	do {
	ch = getc(fp);
	if (ch == EOF) {
	putc('\n', stderr);
	break;
	} else if (ch == '\n') {
	fprintf(stderr, "\n%4d ", ++line);
	} else {
	putc(ch, stderr);
	}
	} while (1);

	fclose(fp);
	}

	gboolean
	validate_xml_verbose(const xmlNode *xml_blob)
	{
	int fd = 0;
	xmlDoc *doc = NULL;
	xmlNode *xml = NULL;
	gboolean rc = FALSE;
	char *filename = NULL;

	filename = crm_strdup_printf("%s/cib-invalid.XXXXXX", pcmk__get_tmpdir());

	umask(S_IWGRP \| S_IWOTH \| S_IROTH);
	fd = mkstemp(filename);
	write_xml_fd(xml_blob, filename, fd, FALSE);

	dump_file(filename);

	doc = xmlParseFile(filename);
	xml = xmlDocGetRootElement(doc);
	rc = validate_xml(xml, NULL, FALSE);
	free_xml(xml);

	unlink(filename);
	free(filename);

	return rc;
	}

	gboolean
	validate_xml(xmlNode xml_blob, const char validation, gboolean to_logs)
	{
	return pcmk__validate_xml(xml_blob, validation, to_logs ? (xmlRelaxNGValidityErrorFunc) xml_log : NULL, GUINT_TO_POINTER(LOG_ERR));
	}

	gboolean
	pcmk__validate_xml(xmlNode xml_blob, const char validation, xmlRelaxNGValidityErrorFunc error_handler, void* error_handler_context)
	{
	int version = 0;

	CRM_CHECK((xml_blob != NULL) && (xml_blob->doc != NULL), return FALSE);

	if (validation == NULL) {
	validation = crm_element_value(xml_blob, XML_ATTR_VALIDATION);
	}

	if (validation == NULL) {
	- int lpc = 0;
	bool valid = FALSE;

	- for (lpc = 0; lpc < xml_schema_max; lpc++) {
	- if (validate_with(xml_blob, lpc, NULL, NULL)) {
	+ for (GList *iter = known_schemas; iter != NULL; iter = iter->next) {
	+ struct schema_s *schema = iter->data;
	+
	+ if (validate_with(xml_blob, schema, NULL, NULL)) {
	valid = TRUE;
	- crm_xml_add(xml_blob, XML_ATTR_VALIDATION,
	- known_schemas[lpc].name);
	- crm_info("XML validated against %s", known_schemas[lpc].name);
	- if(known_schemas[lpc].after_transform == 0) {
	- break;
	- }
	+ crm_xml_add(xml_blob, XML_ATTR_VALIDATION, schema->name);
	+ crm_info("XML validated against %s", schema->name);
	}
	}

	return valid;
	}

	version = get_schema_version(validation);
	if (strcmp(validation, PCMK__VALUE_NONE) == 0) {
	return TRUE;
	- } else if (version < xml_schema_max) {
	- return validate_with(xml_blob, version, error_handler, error_handler_context);
	+ } else if (version < g_list_length(known_schemas)) {
	+ struct schema_s *schema = g_list_nth_data(known_schemas, version);
	+ return validate_with(xml_blob, schema, error_handler,
	+ error_handler_context);
	}

	crm_err("Unknown validator: %s", validation);
	return FALSE;
	}

	-static void
	-cib_upgrade_err(void ctx, const char fmt, ...)
	-G_GNUC_PRINTF(2, 3);
	-
	/* With this arrangement, an attempt to identify the message severity
	as explicitly signalled directly from XSLT is performed in rather
	a smart way (no reliance on formatting string + arguments being
	always specified as ["%s", purposeful_string], as it can also be
	["%s: %s", some_prefix, purposeful_string] etc. so every argument
	pertaining %s specifier is investigated), and if such a mark found,
	the respective level is determined and, when the messages are to go
	to the native logs, the mark itself gets dropped
	(by the means of string shift).

	NOTE: whether the native logging is the right sink is decided per
	the ctx parameter -- NULL denotes this case, otherwise it
	carries a pointer to the numeric expression of the desired
	target logging level (messages with higher level will be
	suppressed)

	NOTE: on some architectures, this string shift may not have any
	effect, but that's an acceptable tradeoff

	The logging level for not explicitly designated messages
	(suspicious, likely internal errors or some runaways) is
	LOG_WARNING.
	*/
	-static void
	+static void G_GNUC_PRINTF(2, 3)
	cib_upgrade_err(void ctx, const char fmt, ...)
	{
	va_list ap, aq;
	char *arg_cur;

	bool found = FALSE;
	const char *fmt_iter = fmt;
	uint8_t msg_log_level = LOG_WARNING; /* default for runaway messages */
	const unsigned * log_level = (const unsigned *) ctx;
	enum {
	escan_seennothing,
	escan_seenpercent,
	} scan_state = escan_seennothing;

	va_start(ap, fmt);
	va_copy(aq, ap);

	while (!found && *fmt_iter != '\0') {
	/* while casing schema borrowed from libqb:qb_vsnprintf_serialize */
	switch (*fmt_iter++) {
	case '%':
	if (scan_state == escan_seennothing) {
	scan_state = escan_seenpercent;
	} else if (scan_state == escan_seenpercent) {
	scan_state = escan_seennothing;
	}
	break;
	case 's':
	if (scan_state == escan_seenpercent) {
	scan_state = escan_seennothing;
	arg_cur = va_arg(aq, char *);
	if (arg_cur != NULL) {
	switch (arg_cur[0]) {
	case 'W':
	if (!strncmp(arg_cur, "WARNING: ",
	sizeof("WARNING: ") - 1)) {
	msg_log_level = LOG_WARNING;
	}
	if (ctx == NULL) {
	memmove(arg_cur, arg_cur + sizeof("WARNING: ") - 1,
	strlen(arg_cur + sizeof("WARNING: ") - 1) + 1);
	}
	found = TRUE;
	break;
	case 'I':
	if (!strncmp(arg_cur, "INFO: ",
	sizeof("INFO: ") - 1)) {
	msg_log_level = LOG_INFO;
	}
	if (ctx == NULL) {
	memmove(arg_cur, arg_cur + sizeof("INFO: ") - 1,
	strlen(arg_cur + sizeof("INFO: ") - 1) + 1);
	}
	found = TRUE;
	break;
	case 'D':
	if (!strncmp(arg_cur, "DEBUG: ",
	sizeof("DEBUG: ") - 1)) {
	msg_log_level = LOG_DEBUG;
	}
	if (ctx == NULL) {
	memmove(arg_cur, arg_cur + sizeof("DEBUG: ") - 1,
	strlen(arg_cur + sizeof("DEBUG: ") - 1) + 1);
	}
	found = TRUE;
	break;
	}
	}
	}
	break;
	case '#': case '-': case ' ': case '+': case '\'': case 'I': case '.':
	case '0': case '1': case '2': case '3': case '4':
	case '5': case '6': case '7': case '8': case '9':
	case '*':
	break;
	case 'l':
	case 'z':
	case 't':
	case 'j':
	case 'd': case 'i':
	case 'o':
	case 'u':
	case 'x': case 'X':
	case 'e': case 'E':
	case 'f': case 'F':
	case 'g': case 'G':
	case 'a': case 'A':
	case 'c':
	case 'p':
	if (scan_state == escan_seenpercent) {
	(void) va_arg(aq, void ); / skip forward */
	scan_state = escan_seennothing;
	}
	break;
	default:
	scan_state = escan_seennothing;
	break;
	}
	}

	if (log_level != NULL) {
	/* intention of the following offset is:
	cibadmin -V -> start showing INFO labelled messages */
	if (*log_level + 4 >= msg_log_level) {
	vfprintf(stderr, fmt, ap);
	}
	} else {
	PCMK__XML_LOG_BASE(msg_log_level, TRUE, 0, "CIB upgrade: ", fmt, ap);
	}

	va_end(aq);
	va_end(ap);
	}

	static xmlNode *
	apply_transformation(xmlNode xml, const char transform, gboolean to_logs)
	{
	char *xform = NULL;
	xmlNode *out = NULL;
	xmlDocPtr res = NULL;
	xsltStylesheet *xslt = NULL;

	xform = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_xslt,
	transform);

	xmlLoadExtDtdDefaultValue = 1;
	xmlSubstituteEntitiesDefault(1);

	/* for capturing, e.g., what's emitted via <xsl:message> */
	if (to_logs) {
	xsltSetGenericErrorFunc(NULL, cib_upgrade_err);
	} else {
	xsltSetGenericErrorFunc(&crm_log_level, cib_upgrade_err);
	}

	xslt = xsltParseStylesheetFile((pcmkXmlStr) xform);
	CRM_CHECK(xslt != NULL, goto cleanup);

	res = xsltApplyStylesheet(xslt, xml->doc, NULL);
	CRM_CHECK(res != NULL, goto cleanup);

	xsltSetGenericErrorFunc(NULL, NULL); /* restore default one */

	out = xmlDocGetRootElement(res);

	cleanup:
	if (xslt) {
	xsltFreeStylesheet(xslt);
	}

	free(xform);

	return out;
	}

	/*!
	* \internal
	* \brief Possibly full enter->upgrade->leave trip per internal bookkeeping.
	*
	* \note Only emits warnings about enter/leave phases in case of issues.
	*/
	static xmlNode *
	apply_upgrade(xmlNode xml, const struct schema_s schema, gboolean to_logs)
	{
	bool transform_onleave = schema->transform_onleave;
	char *transform_leave;
	xmlNode *upgrade = NULL,
	*final = NULL;

	if (schema->transform_enter) {
	crm_debug("Upgrading %s-style configuration, pre-upgrade phase with %s.xsl",
	schema->name, schema->transform_enter);
	upgrade = apply_transformation(xml, schema->transform_enter, to_logs);
	if (upgrade == NULL) {
	crm_warn("Upgrade-enter transformation %s.xsl failed",
	schema->transform_enter);
	transform_onleave = FALSE;
	}
	}
	if (upgrade == NULL) {
	upgrade = xml;
	}

	crm_debug("Upgrading %s-style configuration, main phase with %s.xsl",
	schema->name, schema->transform);
	final = apply_transformation(upgrade, schema->transform, to_logs);
	if (upgrade != xml) {
	free_xml(upgrade);
	upgrade = NULL;
	}

	if (final != NULL && transform_onleave) {
	upgrade = final;
	/* following condition ensured in add_schema_by_version */
	CRM_ASSERT(schema->transform_enter != NULL);
	transform_leave = strdup(schema->transform_enter);
	/* enter -> leave */
	memcpy(strrchr(transform_leave, '-') + 1, "leave", sizeof("leave") - 1);
	crm_debug("Upgrading %s-style configuration, post-upgrade phase with %s.xsl",
	schema->name, transform_leave);
	final = apply_transformation(upgrade, transform_leave, to_logs);
	if (final == NULL) {
	crm_warn("Upgrade-leave transformation %s.xsl failed", transform_leave);
	final = upgrade;
	} else {
	free_xml(upgrade);
	}
	free(transform_leave);
	}

	return final;
	}

	const char *
	get_schema_name(int version)
	{
	- if (version < 0 \|\| version >= xml_schema_max) {
	+ struct schema_s *schema = g_list_nth_data(known_schemas, version);
	+
	+ if (schema == NULL) {
	return "unknown";
	}
	- return known_schemas[version].name;
	+
	+ return schema->name;
	}

	int
	get_schema_version(const char *name)
	{
	int lpc = 0;

	if (name == NULL) {
	name = PCMK__VALUE_NONE;
	}
	- for (; lpc < xml_schema_max; lpc++) {
	- if (pcmk__str_eq(name, known_schemas[lpc].name, pcmk__str_casei)) {
	+
	+ for (GList *iter = known_schemas; iter != NULL; iter = iter->next) {
	+ struct schema_s *schema = iter->data;
	+
	+ if (pcmk__str_eq(name, schema->name, pcmk__str_casei)) {
	return lpc;
	}
	+
	+ lpc++;
	}
	+
	return -1;
	}

	/* set which validation to use */
	int
	update_validation(xmlNode *xml_blob, int best, int max, gboolean transform,
	gboolean to_logs)
	{
	xmlNode *xml = NULL;
	char *value = NULL;
	int max_stable_schemas = xml_latest_schema_index();
	int lpc = 0, match = -1, rc = pcmk_ok;
	int next = -1; /* -1 denotes "inactive" value */
	xmlRelaxNGValidityErrorFunc error_handler =
	to_logs ? (xmlRelaxNGValidityErrorFunc) xml_log : NULL;

	CRM_CHECK(best != NULL, return -EINVAL);
	*best = 0;

	CRM_CHECK((xml_blob != NULL) && (*xml_blob != NULL)
	&& ((*xml_blob)->doc != NULL),
	return -EINVAL);

	xml = *xml_blob;
	value = crm_element_value_copy(xml, XML_ATTR_VALIDATION);

	if (value != NULL) {
	match = get_schema_version(value);

	lpc = match;
	if (lpc >= 0 && transform == FALSE) {
	*best = lpc++;

	} else if (lpc < 0) {
	crm_debug("Unknown validation schema");
	lpc = 0;
	}
	}

	if (match >= max_stable_schemas) {
	/* nothing to do */
	free(value);
	*best = match;
	return pcmk_ok;
	}

	while (lpc <= max_stable_schemas) {
	+ /* FIXME: This will cause us to walk the known_schemas list every time
	+ * this loop iterates, which is not ideal. However, for now it's a lot
	+ * easier than trying to get all the loop indices we're using here
	+ * sorted out and working correctly.
	+ */
	+ struct schema_s *schema = g_list_nth_data(known_schemas, lpc);
	+
	crm_debug("Testing '%s' validation (%d of %d)",
	- known_schemas[lpc].name ? known_schemas[lpc].name : "<unset>",
	- lpc, max_stable_schemas);
	+ pcmk__s(schema->name, "<unset>"), lpc, max_stable_schemas);

	- if (validate_with(xml, lpc, error_handler, GUINT_TO_POINTER(LOG_ERR)) == FALSE) {
	+ if (validate_with(xml, schema, error_handler, GUINT_TO_POINTER(LOG_ERR)) == FALSE) {
	if (next != -1) {
	crm_info("Configuration not valid for schema: %s",
	- known_schemas[lpc].name);
	+ schema->name);
	next = -1;
	} else {
	- crm_trace("%s validation failed",
	- known_schemas[lpc].name ? known_schemas[lpc].name : "<unset>");
	+ crm_trace("%s validation failed", pcmk__s(schema->name, "<unset>"));
	}
	if (*best) {
	/* we've satisfied the validation, no need to check further */
	break;
	}
	rc = -pcmk_err_schema_validation;

	} else {
	if (next != -1) {
	- crm_debug("Configuration valid for schema: %s",
	- known_schemas[next].name);
	+ crm_debug("Configuration valid for schema: %s", schema->name);
	next = -1;
	}
	rc = pcmk_ok;
	}

	if (rc == pcmk_ok) {
	*best = lpc;
	}

	if (rc == pcmk_ok && transform) {
	xmlNode *upgrade = NULL;
	- next = known_schemas[lpc].after_transform;
	+ struct schema_s *next_schema = NULL;
	+ next = lpc+1;

	- if (next <= lpc) {
	- /* There is no next version, or next would regress */
	- crm_trace("Stopping at %s", known_schemas[lpc].name);
	+ if (next > max_stable_schemas) {
	+ /* There is no next version */
	+ crm_trace("Stopping at %s", schema->name);
	break;
	+ }

	- } else if (max > 0 && (lpc == max \|\| next > max)) {
	+ if (max > 0 && (lpc == max \|\| next > max)) {
	crm_trace("Upgrade limit reached at %s (lpc=%d, next=%d, max=%d)",
	- known_schemas[lpc].name, lpc, next, max);
	+ schema->name, lpc, next, max);
	break;
	+ }
	+
	+ next_schema = g_list_nth_data(known_schemas, next);
	+ CRM_ASSERT(next_schema != NULL);

	- } else if (known_schemas[lpc].transform == NULL
	+ if (schema->transform == NULL
	/* possibly avoid transforming when readily valid
	(in general more restricted when crossing the major
	version boundary, as X.0 "transitional" version is
	expected to be more strict than it's successors that
	may re-allow constructs from previous major line) */
	- \|\| validate_with_silent(xml, next)) {
	+ \|\| validate_with_silent(xml, next_schema)) {
	crm_debug("%s-style configuration is also valid for %s",
	- known_schemas[lpc].name, known_schemas[next].name);
	+ schema->name, next_schema->name);

	lpc = next;

	} else {
	crm_debug("Upgrading %s-style configuration to %s with %s.xsl",
	- known_schemas[lpc].name, known_schemas[next].name,
	- known_schemas[lpc].transform);
	+ schema->name, next_schema->name, schema->transform);

	- upgrade = apply_upgrade(xml, &known_schemas[lpc], to_logs);
	+ upgrade = apply_upgrade(xml, schema, to_logs);
	if (upgrade == NULL) {
	- crm_err("Transformation %s.xsl failed",
	- known_schemas[lpc].transform);
	+ crm_err("Transformation %s.xsl failed", schema->transform);
	rc = -pcmk_err_transform_failed;

	- } else if (validate_with(upgrade, next, error_handler, GUINT_TO_POINTER(LOG_ERR))) {
	- crm_info("Transformation %s.xsl successful",
	- known_schemas[lpc].transform);
	+ } else if (validate_with(upgrade, next_schema, error_handler,
	+ GUINT_TO_POINTER(LOG_ERR))) {
	+ crm_info("Transformation %s.xsl successful", schema->transform);
	lpc = next;
	*best = next;
	free_xml(xml);
	xml = upgrade;
	rc = pcmk_ok;

	} else {
	crm_err("Transformation %s.xsl did not produce a valid configuration",
	- known_schemas[lpc].transform);
	+ schema->transform);
	crm_log_xml_info(upgrade, "transform:bad");
	free_xml(upgrade);
	rc = -pcmk_err_schema_validation;
	}
	next = -1;
	}
	}

	if (transform == FALSE \|\| rc != pcmk_ok) {
	/* we need some progress! */
	lpc++;
	}
	}

	if (best > match && best) {
	+ struct schema_s best_schema = g_list_nth_data(known_schemas, best);
	+
	crm_info("%s the configuration from %s to %s",
	- transform?"Transformed":"Upgraded",
	- value ? value : "<none>", known_schemas[*best].name);
	- crm_xml_add(xml, XML_ATTR_VALIDATION, known_schemas[*best].name);
	+ transform?"Transformed":"Upgraded", pcmk__s(value, "<none>"),
	+ best_schema->name);
	+ crm_xml_add(xml, XML_ATTR_VALIDATION, best_schema->name);
	}

	*xml_blob = xml;
	free(value);
	return rc;
	}

	gboolean
	cli_config_update(xmlNode *xml, int best_version, gboolean to_logs)
	{
	gboolean rc = TRUE;
	const char value = crm_element_value(xml, XML_ATTR_VALIDATION);
	char *const orig_value = strdup(value == NULL ? "(none)" : value);

	int version = get_schema_version(value);
	int orig_version = version;
	- int min_version = xml_minimum_schema_index();
	+ int min_version = xml_find_x_0_schema_index();

	if (version < min_version) {
	// Current configuration schema is not acceptable, try to update
	xmlNode *converted = NULL;

	converted = copy_xml(*xml);
	update_validation(&converted, &version, 0, TRUE, to_logs);

	value = crm_element_value(converted, XML_ATTR_VALIDATION);
	if (version < min_version) {
	// Updated configuration schema is still not acceptable

	if (version < orig_version \|\| orig_version == -1) {
	// We couldn't validate any schema at all
	if (to_logs) {
	pcmk__config_err("Cannot upgrade configuration (claiming "
	"schema %s) to at least %s because it "
	"does not validate with any schema from "
	"%s to %s",
	orig_value,
	get_schema_name(min_version),
	get_schema_name(orig_version),
	xml_latest_schema());
	} else {
	fprintf(stderr, "Cannot upgrade configuration (claiming "
	"schema %s) to at least %s because it "
	"does not validate with any schema from "
	"%s to %s\n",
	orig_value,
	get_schema_name(min_version),
	get_schema_name(orig_version),
	xml_latest_schema());
	}
	} else {
	// We updated configuration successfully, but still too low
	if (to_logs) {
	pcmk__config_err("Cannot upgrade configuration (claiming "
	"schema %s) to at least %s because it "
	"would not upgrade past %s",
	orig_value,
	get_schema_name(min_version),
	pcmk__s(value, "unspecified version"));
	} else {
	fprintf(stderr, "Cannot upgrade configuration (claiming "
	"schema %s) to at least %s because it "
	"would not upgrade past %s\n",
	orig_value,
	get_schema_name(min_version),
	pcmk__s(value, "unspecified version"));
	}
	}

	free_xml(converted);
	converted = NULL;
	rc = FALSE;

	} else {
	// Updated configuration schema is acceptable
	free_xml(*xml);
	*xml = converted;

	if (version < xml_latest_schema_index()) {
	if (to_logs) {
	pcmk__config_warn("Configuration with schema %s was "
	"internally upgraded to acceptable (but "
	"not most recent) %s",
	orig_value, get_schema_name(version));
	}
	} else {
	if (to_logs) {
	crm_info("Configuration with schema %s was internally "
	"upgraded to latest version %s",
	orig_value, get_schema_name(version));
	}
	}
	}

	} else if (version >= get_schema_version(PCMK__VALUE_NONE)) {
	// Schema validation is disabled
	if (to_logs) {
	pcmk__config_warn("Schema validation of configuration is disabled "
	"(enabling is encouraged and prevents common "
	"misconfigurations)");

	} else {
	fprintf(stderr, "Schema validation of configuration is disabled "
	"(enabling is encouraged and prevents common "
	"misconfigurations)\n");
	}
	}

	if (best_version) {
	*best_version = version;
	}

	free(orig_value);
	return rc;
	}
	+
	+void
	+pcmk__log_known_schemas(void)
	+{
	+ int lpc = 0;
	+
	+ for (GList *iter = known_schemas; iter != NULL; iter = iter->next) {
	+ struct schema_s *schema = iter->data;
	+
	+ if (schema->transform != NULL) {
	+ crm_debug("known_schemas[%d] => %s (upgrades with %s.xsl)",
	+ lpc, schema->name, schema->transform);
	+
	+ } else {
	+ crm_debug("known_schemas[%d] => %s", lpc, schema->name);
	+ }
	+
	+ lpc++;
	+ }
	+}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 29, 8:56 PM (1 d, 14 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 942636
Default Alt Text: (66 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions