No OneTemporary
Actions

Size

428 KB

Referenced Files

None

Subscribers

None

View Options

This file is larger than 256 KB, so syntax highlighting was skipped.

	diff --git a/daemons/based/based_messages.c b/daemons/based/based_messages.c
	index 0ff2dc26b8..f9844dc670 100644
	--- a/daemons/based/based_messages.c
	+++ b/daemons/based/based_messages.c
	@@ -1,537 +1,539 @@
	/*
	* Copyright 2004-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <stdio.h>
	#include <unistd.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <time.h>

	#include <sys/param.h>
	#include <sys/types.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/msg_xml.h>

	#include <crm/common/xml.h>
	#include <crm/common/ipc_internal.h>
	+#include <crm/common/xml_internal.h>
	#include <crm/cluster/internal.h>

	#include <pacemaker-based.h>

	/* Maximum number of diffs to ignore while waiting for a resync */
	#define MAX_DIFF_RETRY 5

	gboolean cib_is_master = FALSE;

	xmlNode *the_cib = NULL;
	int revision_check(xmlNode * cib_update, xmlNode * cib_copy, int flags);
	int get_revision(xmlNode * xml_obj, int cur_revision);

	int updateList(xmlNode * local_cib, xmlNode * update_command, xmlNode * failed,
	int operation, const char *section);

	gboolean update_results(xmlNode * failed, xmlNode * target, const char *operation, int return_code);

	int cib_update_counter(xmlNode * xml_obj, const char *field, gboolean reset);

	int sync_our_cib(xmlNode * request, gboolean all);

	int
	cib_process_shutdown_req(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	const char *host = crm_element_value(req, F_ORIG);

	*answer = NULL;

	if (crm_element_value(req, F_CIB_ISREPLY) == NULL) {
	crm_info("Peer %s is requesting to shut down", host);
	return pcmk_ok;
	}

	if (cib_shutdown_flag == FALSE) {
	crm_err("Peer %s mistakenly thinks we wanted to shut down", host);
	return -EINVAL;
	}

	crm_info("Peer %s has acknowledged our shutdown request", host);
	terminate_cib(__func__, 0);
	return pcmk_ok;
	}

	int
	cib_process_default(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event", op);
	*answer = NULL;

	if (op == NULL) {
	result = -EINVAL;
	crm_err("No operation specified");

	} else if (strcasecmp(CRM_OP_NOOP, op) == 0) {
	;

	} else {
	result = -EPROTONOSUPPORT;
	crm_err("Action [%s] is not supported by the CIB manager", op);
	}
	return result;
	}

	int
	cib_process_readwrite(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event", op);

	if (pcmk__str_eq(op, CIB_OP_ISMASTER, pcmk__str_casei)) {
	if (cib_is_master == TRUE) {
	result = pcmk_ok;
	} else {
	result = -EPERM;
	}
	return result;
	}

	if (pcmk__str_eq(op, CIB_OP_MASTER, pcmk__str_casei)) {
	if (cib_is_master == FALSE) {
	crm_info("We are now in R/W mode");
	cib_is_master = TRUE;
	} else {
	crm_debug("We are still in R/W mode");
	}

	} else if (cib_is_master) {
	crm_info("We are now in R/O mode");
	cib_is_master = FALSE;
	}

	return result;
	}

	/* Set to 1 when a sync is requested, incremented when a diff is ignored,
	* reset to 0 when a sync is received
	*/
	static int sync_in_progress = 0;

	void
	send_sync_request(const char *host)
	{
	xmlNode *sync_me = create_xml_node(NULL, "sync-me");

	crm_info("Requesting re-sync from %s", (host? host : "all peers"));
	sync_in_progress = 1;

	crm_xml_add(sync_me, F_TYPE, "cib");
	crm_xml_add(sync_me, F_CIB_OPERATION, CIB_OP_SYNC_ONE);
	crm_xml_add(sync_me, F_CIB_DELEGATED, cib_our_uname);

	send_cluster_message(host ? crm_get_peer(0, host) : NULL, crm_msg_cib, sync_me, FALSE);
	free_xml(sync_me);
	}

	int
	cib_process_ping(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	const char *host = crm_element_value(req, F_ORIG);
	const char *seq = crm_element_value(req, F_CIB_PING_ID);
	char *digest = calculate_xml_versioned_digest(the_cib, FALSE, TRUE, CRM_FEATURE_SET);

	static struct qb_log_callsite *cs = NULL;

	crm_trace("Processing \"%s\" event %s from %s", op, seq, host);
	*answer = create_xml_node(NULL, XML_CRM_TAG_PING);

	crm_xml_add(*answer, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	crm_xml_add(*answer, XML_ATTR_DIGEST, digest);
	crm_xml_add(*answer, F_CIB_PING_ID, seq);

	if (cs == NULL) {
	cs = qb_log_callsite_get(__func__, __FILE__, __func__, LOG_TRACE,
	__LINE__, crm_trace_nonlog);
	}
	if (cs && cs->targets) {
	/* Append additional detail so the reciever can log the differences */
	add_message_xml(*answer, F_CIB_CALLDATA, the_cib);

	} else {
	/* Always include at least the version details */
	const char *tag = TYPE(the_cib);
	xmlNode *shallow = create_xml_node(NULL, tag);

	copy_in_properties(shallow, the_cib);
	add_message_xml(*answer, F_CIB_CALLDATA, shallow);
	free_xml(shallow);
	}

	crm_info("Reporting our current digest to %s: %s for %s.%s.%s (%p %d)",
	host, digest,
	crm_element_value(existing_cib, XML_ATTR_GENERATION_ADMIN),
	crm_element_value(existing_cib, XML_ATTR_GENERATION),
	crm_element_value(existing_cib, XML_ATTR_NUMUPDATES),
	existing_cib,
	cs && cs->targets);

	free(digest);

	return pcmk_ok;
	}

	int
	cib_process_sync(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	return sync_our_cib(req, TRUE);
	}

	int
	cib_process_upgrade_server(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	int rc = pcmk_ok;

	*answer = NULL;

	if(crm_element_value(req, F_CIB_SCHEMA_MAX)) {
	/* The originator of an upgrade request sends it to the DC, without
	* F_CIB_SCHEMA_MAX. If an upgrade is needed, the DC re-broadcasts the
	* request with F_CIB_SCHEMA_MAX, and each node performs the upgrade
	* (and notifies its local clients) here.
	*/
	return cib_process_upgrade(
	op, options, section, req, input, existing_cib, result_cib, answer);

	} else {
	int new_version = 0;
	int current_version = 0;
	xmlNode *scratch = copy_xml(existing_cib);
	const char *host = crm_element_value(req, F_ORIG);
	const char *value = crm_element_value(existing_cib, XML_ATTR_VALIDATION);
	const char *client_id = crm_element_value(req, F_CIB_CLIENTID);
	const char *call_opts = crm_element_value(req, F_CIB_CALLOPTS);
	const char *call_id = crm_element_value(req, F_CIB_CALLID);

	crm_trace("Processing \"%s\" event", op);
	if (value != NULL) {
	current_version = get_schema_version(value);
	}

	rc = update_validation(&scratch, &new_version, 0, TRUE, TRUE);
	if (new_version > current_version) {
	xmlNode *up = create_xml_node(NULL, __func__);

	rc = pcmk_ok;
	crm_notice("Upgrade request from %s verified", host);

	crm_xml_add(up, F_TYPE, "cib");
	crm_xml_add(up, F_CIB_OPERATION, CIB_OP_UPGRADE);
	crm_xml_add(up, F_CIB_SCHEMA_MAX, get_schema_name(new_version));
	crm_xml_add(up, F_CIB_DELEGATED, host);
	crm_xml_add(up, F_CIB_CLIENTID, client_id);
	crm_xml_add(up, F_CIB_CALLOPTS, call_opts);
	crm_xml_add(up, F_CIB_CALLID, call_id);

	if (cib_legacy_mode() && cib_is_master) {
	rc = cib_process_upgrade(
	op, options, section, up, input, existing_cib, result_cib, answer);

	} else {
	send_cluster_message(NULL, crm_msg_cib, up, FALSE);
	}

	free_xml(up);

	} else if(rc == pcmk_ok) {
	rc = -pcmk_err_schema_unchanged;
	}

	if (rc != pcmk_ok) {
	// Notify originating peer so it can notify its local clients
	crm_node_t *origin = crm_find_peer(0, host);

	crm_info("Rejecting upgrade request from %s: %s "
	CRM_XS " rc=%d peer=%s", host, pcmk_strerror(rc), rc,
	(origin? origin->uname : "lost"));

	if (origin) {
	xmlNode *up = create_xml_node(NULL, __func__);

	crm_xml_add(up, F_TYPE, "cib");
	crm_xml_add(up, F_CIB_OPERATION, CIB_OP_UPGRADE);
	crm_xml_add(up, F_CIB_DELEGATED, host);
	crm_xml_add(up, F_CIB_ISREPLY, host);
	crm_xml_add(up, F_CIB_CLIENTID, client_id);
	crm_xml_add(up, F_CIB_CALLOPTS, call_opts);
	crm_xml_add(up, F_CIB_CALLID, call_id);
	crm_xml_add_int(up, F_CIB_UPGRADE_RC, rc);
	if (send_cluster_message(origin, crm_msg_cib, up, TRUE)
	== FALSE) {
	crm_warn("Could not send CIB upgrade result to %s", host);
	}
	free_xml(up);
	}
	}
	free_xml(scratch);
	}
	return rc;
	}

	int
	cib_process_sync_one(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	return sync_our_cib(req, FALSE);
	}

	int
	cib_server_process_diff(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int rc = pcmk_ok;

	if (sync_in_progress > MAX_DIFF_RETRY) {
	/* Don't ignore diffs forever; the last request may have been lost.
	* If the diff fails, we'll ask for another full resync.
	*/
	sync_in_progress = 0;
	}

	/* The master should never ignore a diff */
	if (sync_in_progress && !cib_is_master) {
	int diff_add_updates = 0;
	int diff_add_epoch = 0;
	int diff_add_admin_epoch = 0;

	int diff_del_updates = 0;
	int diff_del_epoch = 0;
	int diff_del_admin_epoch = 0;

	cib_diff_version_details(input,
	&diff_add_admin_epoch, &diff_add_epoch, &diff_add_updates,
	&diff_del_admin_epoch, &diff_del_epoch, &diff_del_updates);

	sync_in_progress++;
	crm_notice("Not applying diff %d.%d.%d -> %d.%d.%d (sync in progress)",
	diff_del_admin_epoch, diff_del_epoch, diff_del_updates,
	diff_add_admin_epoch, diff_add_epoch, diff_add_updates);
	return -pcmk_err_diff_resync;
	}

	rc = cib_process_diff(op, options, section, req, input, existing_cib, result_cib, answer);
	crm_trace("result: %s (%d), %s", pcmk_strerror(rc), rc, cib_is_master?"master":"slave");

	if (rc == -pcmk_err_diff_resync && cib_is_master == FALSE) {
	free_xml(*result_cib);
	*result_cib = NULL;
	send_sync_request(NULL);

	} else if (rc == -pcmk_err_diff_resync) {
	rc = -pcmk_err_diff_failed;
	if (options & cib_force_diff) {
	crm_warn("Not requesting full refresh in R/W mode");
	}

	} else if ((rc != pcmk_ok) && !cib_is_master && cib_legacy_mode()) {
	crm_warn("Requesting full CIB refresh because update failed: %s"
	CRM_XS " rc=%d", pcmk_strerror(rc), rc);
	xml_log_patchset(LOG_INFO, __func__, input);
	free_xml(*result_cib);
	*result_cib = NULL;
	send_sync_request(NULL);
	}

	return rc;
	}

	int
	cib_process_replace_svr(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	const char *tag = crm_element_name(input);
	int rc =
	cib_process_replace(op, options, section, req, input, existing_cib, result_cib, answer);
	if (rc == pcmk_ok && pcmk__str_eq(tag, XML_TAG_CIB, pcmk__str_casei)) {
	sync_in_progress = 0;
	}
	return rc;
	}

	static int
	delete_cib_object(xmlNode * parent, xmlNode * delete_spec)
	{
	const char *object_name = NULL;
	const char *object_id = NULL;
	xmlNode *equiv_node = NULL;
	int result = pcmk_ok;

	if (delete_spec != NULL) {
	object_name = crm_element_name(delete_spec);
	}
	object_id = crm_element_value(delete_spec, XML_ATTR_ID);

	crm_trace("Processing: <%s id=%s>", crm_str(object_name), crm_str(object_id));

	if (delete_spec == NULL) {
	result = -EINVAL;

	} else if (parent == NULL) {
	result = -EINVAL;

	} else if (object_id == NULL) {
	/* placeholder object */
	equiv_node = find_xml_node(parent, object_name, FALSE);

	} else {
	- equiv_node = find_entity(parent, object_name, object_id);
	+ equiv_node = pcmk__xe_match(parent, object_name, XML_ATTR_ID,
	+ object_id);
	}

	if (result != pcmk_ok) {
	; /* nothing */

	} else if (equiv_node == NULL) {
	result = pcmk_ok;

	} else if (xml_has_children(delete_spec) == FALSE) {
	/* only leaves are deleted */
	crm_debug("Removing leaf: <%s id=%s>", crm_str(object_name), crm_str(object_id));
	free_xml(equiv_node);
	equiv_node = NULL;

	} else {
	xmlNode *child = NULL;

	for (child = __xml_first_child(delete_spec); child != NULL; child = __xml_next(child)) {
	int tmp_result = delete_cib_object(equiv_node, child);

	/* only the first error is likely to be interesting */
	if (tmp_result != pcmk_ok && result == pcmk_ok) {
	result = tmp_result;
	}
	}
	}

	return result;
	}

	int
	cib_process_delete_absolute(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	xmlNode *failed = NULL;
	int result = pcmk_ok;
	xmlNode *update_section = NULL;

	crm_trace("Processing \"%s\" event for section=%s", op, crm_str(section));
	if (pcmk__str_eq(XML_CIB_TAG_SECTION_ALL, section, pcmk__str_casei)) {
	section = NULL;

	} else if (pcmk__str_eq(XML_TAG_CIB, section, pcmk__str_casei)) {
	section = NULL;

	} else if (pcmk__str_eq(crm_element_name(input), XML_TAG_CIB, pcmk__str_casei)) {
	section = NULL;
	}

	CRM_CHECK(strcasecmp(CIB_OP_DELETE, op) == 0, return -EINVAL);

	if (input == NULL) {
	crm_err("Cannot perform modification with no data");
	return -EINVAL;
	}

	failed = create_xml_node(NULL, XML_TAG_FAILED);

	update_section = get_object_root(section, *result_cib);
	result = delete_cib_object(update_section, input);
	update_results(failed, input, op, result);

	if ((result == pcmk_ok) && xml_has_children(failed)) {
	result = -EINVAL;
	}

	if (result != pcmk_ok) {
	crm_log_xml_err(failed, "CIB Update failures");
	*answer = failed;

	} else {
	free_xml(failed);
	}

	return result;
	}

	int
	sync_our_cib(xmlNode * request, gboolean all)
	{
	int result = pcmk_ok;
	char *digest = NULL;
	const char *host = crm_element_value(request, F_ORIG);
	const char *op = crm_element_value(request, F_CIB_OPERATION);

	xmlNode *replace_request = cib_msg_copy(request, FALSE);

	CRM_CHECK(the_cib != NULL,;);
	CRM_CHECK(replace_request != NULL,;);

	crm_debug("Syncing CIB to %s", all ? "all peers" : host);
	if (all == FALSE && host == NULL) {
	crm_log_xml_err(request, "bad sync");
	}

	/* remove the "all == FALSE" condition
	*
	* sync_from was failing, the local client wasn't being notified
	* because it didn't know it was a reply
	* setting this does not prevent the other nodes from applying it
	* if all == TRUE
	*/
	if (host != NULL) {
	crm_xml_add(replace_request, F_CIB_ISREPLY, host);
	}
	if (all) {
	xml_remove_prop(replace_request, F_CIB_HOST);
	}

	crm_xml_add(replace_request, F_CIB_OPERATION, CIB_OP_REPLACE);
	crm_xml_add(replace_request, "original_" F_CIB_OPERATION, op);
	crm_xml_add(replace_request, F_CIB_GLOBAL_UPDATE, XML_BOOLEAN_TRUE);

	crm_xml_add(replace_request, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	digest = calculate_xml_versioned_digest(the_cib, FALSE, TRUE, CRM_FEATURE_SET);
	crm_xml_add(replace_request, XML_ATTR_DIGEST, digest);

	add_message_xml(replace_request, F_CIB_CALLDATA, the_cib);

	if (send_cluster_message
	(all ? NULL : crm_get_peer(0, host), crm_msg_cib, replace_request, FALSE) == FALSE) {
	result = -ENOTCONN;
	}
	free_xml(replace_request);
	free(digest);
	return result;
	}
	diff --git a/daemons/controld/controld_schedulerd.c b/daemons/controld/controld_schedulerd.c
	index 439dfd7bb1..d3a176770d 100644
	--- a/daemons/controld/controld_schedulerd.c
	+++ b/daemons/controld/controld_schedulerd.c
	@@ -1,470 +1,474 @@
	/*
	* Copyright 2004-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <unistd.h> /* pid_t, sleep, ssize_t */

	#include <crm/cib.h>
	#include <crm/cluster.h>
	#include <crm/common/xml.h>
	#include <crm/crm.h>
	#include <crm/msg_xml.h>
	+#include <crm/common/xml_internal.h>

	#include <pacemaker-controld.h>

	static mainloop_io_t *pe_subsystem = NULL;

	/*!
	* \internal
	* \brief Close any scheduler connection and free associated memory
	*/
	void
	pe_subsystem_free(void)
	{
	controld_clear_fsa_input_flags(R_PE_REQUIRED);
	if (pe_subsystem) {
	controld_expect_sched_reply(NULL);
	mainloop_del_ipc_client(pe_subsystem);
	pe_subsystem = NULL;
	controld_clear_fsa_input_flags(R_PE_CONNECTED);
	}
	}

	/*!
	* \internal
	* \brief Save CIB query result to file, raising FSA error
	*
	* \param[in] msg Ignored
	* \param[in] call_id Call ID of CIB query
	* \param[in] rc Return code of CIB query
	* \param[in] output Result of CIB query
	* \param[in] user_data Unique identifier for filename (will be freed)
	*
	* \note This is intended to be called after a scheduler connection fails.
	*/
	static void
	save_cib_contents(xmlNode msg, int call_id, int rc, xmlNode output,
	void *user_data)
	{
	char *id = user_data;

	register_fsa_error_adv(C_FSA_INTERNAL, I_ERROR, NULL, NULL, __func__);
	CRM_CHECK(id != NULL, return);

	if (rc == pcmk_ok) {
	char *filename = crm_strdup_printf(PE_STATE_DIR "/pe-core-%s.bz2", id);

	if (write_xml_file(output, filename, TRUE) < 0) {
	crm_err("Could not save Cluster Information Base to %s after scheduler crash",
	filename);
	} else {
	crm_notice("Saved Cluster Information Base to %s after scheduler crash",
	filename);
	}
	free(filename);
	}
	}

	/*!
	* \internal
	* \brief Respond to scheduler connection failure
	*
	* \param[in] user_data Ignored
	*/
	static void
	pe_ipc_destroy(gpointer user_data)
	{
	// If we aren't connected to the scheduler, we can't expect a reply
	controld_expect_sched_reply(NULL);

	if (pcmk_is_set(fsa_input_register, R_PE_REQUIRED)) {
	int rc = pcmk_ok;
	char *uuid_str = crm_generate_uuid();

	crm_crit("Connection to the scheduler failed "
	CRM_XS " uuid=%s", uuid_str);

	/*
	* The scheduler died...
	*
	* Save the current CIB so that we have a chance of
	* figuring out what killed it.
	*
	* Delay raising the I_ERROR until the query below completes or
	* 5s is up, whichever comes first.
	*
	*/
	rc = fsa_cib_conn->cmds->query(fsa_cib_conn, NULL, NULL, cib_scope_local);
	fsa_register_cib_callback(rc, FALSE, uuid_str, save_cib_contents);

	} else {
	crm_info("Connection to the scheduler released");
	}

	controld_clear_fsa_input_flags(R_PE_CONNECTED);
	pe_subsystem = NULL;
	mainloop_set_trigger(fsa_source);
	return;
	}

	/*!
	* \internal
	* \brief Handle message from scheduler connection
	*
	* \param[in] buffer XML message (will be freed)
	* \param[in] length Ignored
	* \param[in] userdata Ignored
	*
	* \return 0
	*/
	static int
	pe_ipc_dispatch(const char *buffer, ssize_t length, gpointer userdata)
	{
	xmlNode *msg = string2xml(buffer);

	if (msg) {
	route_message(C_IPC_MESSAGE, msg);
	}
	free_xml(msg);
	return 0;
	}

	/*!
	* \internal
	* \brief Make new connection to scheduler
	*
	* \return TRUE on success, FALSE otherwise
	*/
	static bool
	pe_subsystem_new(void)
	{
	struct ipc_client_callbacks pe_callbacks = {
	.dispatch = pe_ipc_dispatch,
	.destroy = pe_ipc_destroy
	};

	controld_set_fsa_input_flags(R_PE_REQUIRED);
	pe_subsystem = mainloop_add_ipc_client(CRM_SYSTEM_PENGINE,
	G_PRIORITY_DEFAULT,
	5 * 1024 * 1024 /* 5MB */,
	NULL, &pe_callbacks);
	if (pe_subsystem == NULL) {
	return FALSE;
	}
	controld_set_fsa_input_flags(R_PE_CONNECTED);
	return TRUE;
	}

	/*!
	* \internal
	* \brief Send an XML message to the scheduler
	*
	* \param[in] cmd XML message to send
	*
	* \return pcmk_ok on success, -errno otherwise
	*/
	static int
	pe_subsystem_send(xmlNode *cmd)
	{
	if (pe_subsystem) {
	int sent = crm_ipc_send(mainloop_get_ipc_client(pe_subsystem), cmd,
	0, 0, NULL);

	if (sent == 0) {
	sent = -ENODATA;
	} else if (sent > 0) {
	sent = pcmk_ok;
	}
	return sent;
	}
	return -ENOTCONN;
	}

	static void do_pe_invoke_callback(xmlNode *msg, int call_id, int rc,
	xmlNode output, void user_data);

	/* A_PE_START, A_PE_STOP, O_PE_RESTART */
	void
	do_pe_control(long long action,
	enum crmd_fsa_cause cause,
	enum crmd_fsa_state cur_state,
	enum crmd_fsa_input current_input, fsa_data_t * msg_data)
	{
	if (action & A_PE_STOP) {
	pe_subsystem_free();
	}
	if ((action & A_PE_START)
	&& !pcmk_is_set(fsa_input_register, R_PE_CONNECTED)) {

	if (cur_state == S_STOPPING) {
	crm_info("Ignoring request to connect to scheduler while shutting down");

	} else if (!pe_subsystem_new()) {
	crm_warn("Could not connect to scheduler");
	register_fsa_error(C_FSA_INTERNAL, I_FAIL, NULL);
	}
	}
	}

	int fsa_pe_query = 0;
	char *fsa_pe_ref = NULL;
	static mainloop_timer_t *controld_sched_timer = NULL;

	// @TODO Make this a configurable cluster option if there's demand for it
	#define SCHED_TIMEOUT_MS (120000)

	/*!
	* \internal
	* \brief Handle a timeout waiting for scheduler reply
	*
	* \param[in] user_data Ignored
	*
	* \return FALSE (indicating that timer should not be restarted)
	*/
	static gboolean
	controld_sched_timeout(gpointer user_data)
	{
	if (AM_I_DC) {
	/* If this node is the DC but can't communicate with the scheduler, just
	* exit (and likely get fenced) so this node doesn't interfere with any
	* further DC elections.
	*
	* @TODO We could try something less drastic first, like disconnecting
	* and reconnecting to the scheduler, but something is likely going
	* seriously wrong, so perhaps it's better to just fail as quickly as
	* possible.
	*/
	crmd_exit(CRM_EX_FATAL);
	}
	return FALSE;
	}

	void
	controld_stop_sched_timer(void)
	{
	if (controld_sched_timer && fsa_pe_ref) {
	crm_trace("Stopping timer for scheduler reply %s", fsa_pe_ref);
	}
	mainloop_timer_stop(controld_sched_timer);
	}

	/*!
	* \internal
	* \brief Set the scheduler request currently being waited on
	*
	* \param[in] msg Request to expect reply to (or NULL for none)
	*/
	void
	controld_expect_sched_reply(xmlNode *msg)
	{
	char *ref = NULL;

	if (msg) {
	ref = crm_element_value_copy(msg, XML_ATTR_REFERENCE);
	CRM_ASSERT(ref != NULL);

	if (controld_sched_timer == NULL) {
	controld_sched_timer = mainloop_timer_add("scheduler_reply_timer",
	SCHED_TIMEOUT_MS, FALSE,
	controld_sched_timeout,
	NULL);
	}
	mainloop_timer_start(controld_sched_timer);
	} else {
	controld_stop_sched_timer();
	}
	free(fsa_pe_ref);
	fsa_pe_ref = ref;
	}

	/*!
	* \internal
	* \brief Free the scheduler reply timer
	*/
	void
	controld_free_sched_timer(void)
	{
	if (controld_sched_timer != NULL) {
	mainloop_timer_del(controld_sched_timer);
	controld_sched_timer = NULL;
	}
	}

	/* A_PE_INVOKE */
	void
	do_pe_invoke(long long action,
	enum crmd_fsa_cause cause,
	enum crmd_fsa_state cur_state,
	enum crmd_fsa_input current_input, fsa_data_t * msg_data)
	{
	if (AM_I_DC == FALSE) {
	crm_err("Not invoking scheduler because not DC: %s",
	fsa_action2string(action));
	return;
	}

	if (!pcmk_is_set(fsa_input_register, R_PE_CONNECTED)) {
	if (pcmk_is_set(fsa_input_register, R_SHUTDOWN)) {
	crm_err("Cannot shut down gracefully without the scheduler");
	register_fsa_input_before(C_FSA_INTERNAL, I_TERMINATE, NULL);

	} else {
	crm_info("Waiting for the scheduler to connect");
	crmd_fsa_stall(FALSE);
	controld_set_fsa_action_flags(A_PE_START);
	trigger_fsa();
	}
	return;
	}

	if (cur_state != S_POLICY_ENGINE) {
	crm_notice("Not invoking scheduler because in state %s",
	fsa_state2string(cur_state));
	return;
	}
	if (!pcmk_is_set(fsa_input_register, R_HAVE_CIB)) {
	crm_err("Attempted to invoke scheduler without consistent Cluster Information Base!");

	/* start the join from scratch */
	register_fsa_input_before(C_FSA_INTERNAL, I_ELECTION, NULL);
	return;
	}

	fsa_pe_query = fsa_cib_conn->cmds->query(fsa_cib_conn, NULL, NULL, cib_scope_local);

	crm_debug("Query %d: Requesting the current CIB: %s", fsa_pe_query,
	fsa_state2string(fsa_state));

	controld_expect_sched_reply(NULL);
	fsa_register_cib_callback(fsa_pe_query, FALSE, NULL, do_pe_invoke_callback);
	}

	static void
	force_local_option(xmlNode xml, const char attr_name, const char *attr_value)
	{
	int max = 0;
	int lpc = 0;
	char *xpath_string = NULL;
	xmlXPathObjectPtr xpathObj = NULL;

	xpath_string = crm_strdup_printf("%.128s//%s//nvpair[@name='%.128s']",
	get_object_path(XML_CIB_TAG_CRMCONFIG),
	XML_CIB_TAG_PROPSET, attr_name);
	xpathObj = xpath_search(xml, xpath_string);
	max = numXpathResults(xpathObj);
	free(xpath_string);

	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *match = getXpathResult(xpathObj, lpc);
	crm_trace("Forcing %s/%s = %s", ID(match), attr_name, attr_value);
	crm_xml_add(match, XML_NVPAIR_ATTR_VALUE, attr_value);
	}

	if(max == 0) {
	xmlNode *configuration = NULL;
	xmlNode *crm_config = NULL;
	xmlNode *cluster_property_set = NULL;

	crm_trace("Creating %s-%s for %s=%s",
	CIB_OPTIONS_FIRST, attr_name, attr_name, attr_value);

	- configuration = find_entity(xml, XML_CIB_TAG_CONFIGURATION, NULL);
	+ configuration = pcmk__xe_match(xml, XML_CIB_TAG_CONFIGURATION, NULL,
	+ NULL);
	if (configuration == NULL) {
	configuration = create_xml_node(xml, XML_CIB_TAG_CONFIGURATION);
	}

	- crm_config = find_entity(configuration, XML_CIB_TAG_CRMCONFIG, NULL);
	+ crm_config = pcmk__xe_match(configuration, XML_CIB_TAG_CRMCONFIG, NULL,
	+ NULL);
	if (crm_config == NULL) {
	crm_config = create_xml_node(configuration, XML_CIB_TAG_CRMCONFIG);
	}

	- cluster_property_set = find_entity(crm_config, XML_CIB_TAG_PROPSET, NULL);
	+ cluster_property_set = pcmk__xe_match(crm_config, XML_CIB_TAG_PROPSET,
	+ NULL, NULL);
	if (cluster_property_set == NULL) {
	cluster_property_set = create_xml_node(crm_config, XML_CIB_TAG_PROPSET);
	crm_xml_add(cluster_property_set, XML_ATTR_ID, CIB_OPTIONS_FIRST);
	}

	xml = create_xml_node(cluster_property_set, XML_CIB_TAG_NVPAIR);

	crm_xml_set_id(xml, "%s-%s", CIB_OPTIONS_FIRST, attr_name);
	crm_xml_add(xml, XML_NVPAIR_ATTR_NAME, attr_name);
	crm_xml_add(xml, XML_NVPAIR_ATTR_VALUE, attr_value);
	}
	freeXpathObject(xpathObj);
	}

	static void
	do_pe_invoke_callback(xmlNode * msg, int call_id, int rc, xmlNode * output, void *user_data)
	{
	xmlNode *cmd = NULL;
	pid_t watchdog = pcmk__locate_sbd();

	if (rc != pcmk_ok) {
	crm_err("Could not retrieve the Cluster Information Base: %s "
	CRM_XS " rc=%d call=%d", pcmk_strerror(rc), rc, call_id);
	register_fsa_error_adv(C_FSA_INTERNAL, I_ERROR, NULL, NULL, __func__);
	return;

	} else if (call_id != fsa_pe_query) {
	crm_trace("Skipping superseded CIB query: %d (current=%d)", call_id, fsa_pe_query);
	return;

	} else if (!AM_I_DC \|\| !pcmk_is_set(fsa_input_register, R_PE_CONNECTED)) {
	crm_debug("No need to invoke the scheduler anymore");
	return;

	} else if (fsa_state != S_POLICY_ENGINE) {
	crm_debug("Discarding scheduler request in state: %s",
	fsa_state2string(fsa_state));
	return;

	/* this callback counts as 1 */
	} else if (num_cib_op_callbacks() > 1) {
	crm_debug("Re-asking for the CIB: %d other peer updates still pending",
	(num_cib_op_callbacks() - 1));
	sleep(1);
	controld_set_fsa_action_flags(A_PE_INVOKE);
	trigger_fsa();
	return;

	} else if (fsa_state != S_POLICY_ENGINE) {
	crm_err("Invoking scheduler in state: %s", fsa_state2string(fsa_state));
	return;
	}

	CRM_LOG_ASSERT(output != NULL);

	/* Refresh the remote node cache and the known node cache when the
	* scheduler is invoked */
	crm_peer_caches_refresh(output);

	crm_xml_add(output, XML_ATTR_DC_UUID, fsa_our_uuid);
	crm_xml_add_int(output, XML_ATTR_HAVE_QUORUM, fsa_has_quorum);

	force_local_option(output, XML_ATTR_HAVE_WATCHDOG, pcmk__btoa(watchdog));

	if (ever_had_quorum && crm_have_quorum == FALSE) {
	crm_xml_add_int(output, XML_ATTR_QUORUM_PANIC, 1);
	}

	cmd = create_request(CRM_OP_PECALC, output, NULL, CRM_SYSTEM_PENGINE, CRM_SYSTEM_DC, NULL);

	rc = pe_subsystem_send(cmd);
	if (rc < 0) {
	crm_err("Could not contact the scheduler: %s " CRM_XS " rc=%d",
	pcmk_strerror(rc), rc);
	register_fsa_error_adv(C_FSA_INTERNAL, I_ERROR, NULL, NULL, __func__);
	} else {
	controld_expect_sched_reply(cmd);
	crm_debug("Invoking the scheduler: query=%d, ref=%s, seq=%llu, quorate=%d",
	fsa_pe_query, fsa_pe_ref, crm_peer_seq, fsa_has_quorum);
	}
	free_xml(cmd);
	}
	diff --git a/include/crm/common/logging.h b/include/crm/common/logging.h
	index 4f99df6b82..18bcccfe2a 100644
	--- a/include/crm/common/logging.h
	+++ b/include/crm/common/logging.h
	@@ -1,408 +1,408 @@
	/*
	* Copyright 2004-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief Wrappers for and extensions to libqb logging
	* \ingroup core
	*/

	#ifndef CRM_LOGGING__H
	# define CRM_LOGGING__H

	# include <stdio.h>
	# include <glib.h>
	# include <qb/qblog.h>
	# include <libxml/tree.h>

	/* Define custom log priorities.
	*
	* syslog(3) uses int for priorities, but libqb's struct qb_log_callsite uses
	* uint8_t, so make sure they fit in the latter.
	*/

	// Define something even less desired than debug
	# ifndef LOG_TRACE
	# define LOG_TRACE (LOG_DEBUG+1)
	# endif

	// Print message to stdout instead of logging it
	# ifndef LOG_STDOUT
	# define LOG_STDOUT 254
	# endif

	// Don't send message anywhere
	# ifndef LOG_NEVER
	# define LOG_NEVER 255
	# endif

	/* "Extended information" logging support */
	#ifdef QB_XS
	# define CRM_XS QB_XS
	# define crm_extended_logging(t, e) qb_log_ctl((t), QB_LOG_CONF_EXTENDED, (e))
	#else
	# define CRM_XS "\|"

	/* A caller might want to check the return value, so we can't define this as a
	* no-op, and we can't simply define it to be 0 because gcc will then complain
	* when the value isn't checked.
	*/
	static inline int
	crm_extended_logging(int t, int e)
	{
	return 0;
	}
	#endif

	extern unsigned int crm_log_level;
	extern unsigned int crm_trace_nonlog;

	/* These are set when a configuration issue is found, and turn on extra messages
	* at the end of processing. They are set via wrapper functions and do not need
	* to be set directly.
	*/
	extern bool pcmk__config_error;
	extern bool pcmk__config_warning;

	enum xml_log_options
	{
	xml_log_option_filtered = 0x0001,
	xml_log_option_formatted = 0x0002,
	xml_log_option_text = 0x0004, /* add this option to dump text into xml */
	- xml_log_option_full_fledged = 0x0008, /* crm_xml_dump: serialize using libxml */
	+ xml_log_option_full_fledged = 0x0008, // Use libxml when converting XML to text
	xml_log_option_diff_plus = 0x0010,
	xml_log_option_diff_minus = 0x0020,
	xml_log_option_diff_short = 0x0040,
	xml_log_option_diff_all = 0x0100,
	xml_log_option_dirty_add = 0x1000,
	xml_log_option_open = 0x2000,
	xml_log_option_children = 0x4000,
	xml_log_option_close = 0x8000,
	};

	void crm_enable_blackbox(int nsig);
	void crm_disable_blackbox(int nsig);
	void crm_write_blackbox(int nsig, struct qb_log_callsite *callsite);

	void crm_update_callsites(void);

	void crm_log_deinit(void);

	gboolean crm_log_cli_init(const char *entity);

	void crm_log_preinit(const char entity, int argc, char *argv);
	gboolean crm_log_init(const char *entity, uint8_t level, gboolean daemon,
	gboolean to_stderr, int argc, char **argv, gboolean quiet);

	void crm_log_args(int argc, char **argv);
	void crm_log_output_fn(const char file, const char function, int line, int level,
	const char prefix, const char output);

	// Log a block of text line by line
	#define crm_log_output(level, prefix, output) \
	crm_log_output_fn(__FILE__, __func__, __LINE__, level, prefix, output)

	gboolean crm_add_logfile(const char *filename);

	void crm_bump_log_level(int argc, char **argv);

	void crm_enable_stderr(int enable);

	gboolean crm_is_callsite_active(struct qb_log_callsite *cs, uint8_t level, uint32_t tags);

	void log_data_element(int log_level, const char file, const char function, int line,
	const char prefix, xmlNode data, int depth, gboolean formatted);

	/* returns the old value */
	unsigned int set_crm_log_level(unsigned int level);

	unsigned int get_crm_log_level(void);

	/*
	* Throughout the macros below, note the leading, pre-comma, space in the
	* various ' , ##args' occurrences to aid portability across versions of 'gcc'.
	* https://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html#Variadic-Macros
	*/
	#if defined(__clang__)
	# define CRM_TRACE_INIT_DATA(name)
	# else
	# include <assert.h> // required by QB_LOG_INIT_DATA() macro
	# define CRM_TRACE_INIT_DATA(name) QB_LOG_INIT_DATA(name)
	#endif

	/* Using "switch" instead of "if" in these macro definitions keeps
	* static analysis from complaining about constant evaluations
	*/

	/*!
	* \brief Log a message
	*
	* \param[in] level Priority at which to log the message
	* \param[in] fmt printf-style format string literal for message
	* \param[in] args Any arguments needed by format string
	*
	* \note This is a macro, and \p level may be evaluated more than once.
	*/
	# define do_crm_log(level, fmt, args...) do { \
	switch (level) { \
	case LOG_STDOUT: \
	printf(fmt "\n" , ##args); \
	break; \
	case LOG_NEVER: \
	break; \
	default: \
	qb_log_from_external_source(__func__, __FILE__, fmt, \
	(level), __LINE__, 0 , ##args); \
	break; \
	} \
	} while (0)

	/*!
	* \brief Log a message that is likely to be filtered out
	*
	* \param[in] level Priority at which to log the message
	* \param[in] fmt printf-style format string for message
	* \param[in] args Any arguments needed by format string
	*
	* \note This is a macro, and \p level may be evaluated more than once.
	* This does nothing when level is LOG_STDOUT.
	*/
	# define do_crm_log_unlikely(level, fmt, args...) do { \
	switch (level) { \
	case LOG_STDOUT: case LOG_NEVER: \
	break; \
	default: { \
	static struct qb_log_callsite *trace_cs = NULL; \
	if (trace_cs == NULL) { \
	trace_cs = qb_log_callsite_get(__func__, __FILE__, fmt, \
	(level), __LINE__, 0); \
	} \
	if (crm_is_callsite_active(trace_cs, (level), 0)) { \
	qb_log_from_external_source(__func__, __FILE__, fmt, \
	(level), __LINE__, 0 , ##args); \
	} \
	} \
	break; \
	} \
	} while (0)

	# define CRM_LOG_ASSERT(expr) do { \
	if(__unlikely((expr) == FALSE)) { \
	static struct qb_log_callsite *core_cs = NULL; \
	if(core_cs == NULL) { \
	core_cs = qb_log_callsite_get(__func__, __FILE__, \
	"log-assert", LOG_TRACE, \
	__LINE__, 0); \
	} \
	crm_abort(__FILE__, __func__, __LINE__, #expr, \
	core_cs?core_cs->targets:FALSE, TRUE); \
	} \
	} while(0)

	/* 'failure_action' MUST NOT be 'continue' as it will apply to the
	* macro's do-while loop
	*/
	# define CRM_CHECK(expr, failure_action) do { \
	if (__unlikely((expr) == FALSE)) { \
	static struct qb_log_callsite *core_cs = NULL; \
	if (core_cs == NULL) { \
	core_cs = qb_log_callsite_get(__func__, __FILE__, \
	"check-assert", \
	LOG_TRACE, __LINE__, 0); \
	} \
	crm_abort(__FILE__, __func__, __LINE__, #expr, \
	(core_cs? core_cs->targets: FALSE), TRUE); \
	failure_action; \
	} \
	} while(0)

	/*!
	* \brief Log XML line-by-line in a formatted fashion
	*
	* \param[in] level Priority at which to log the messages
	* \param[in] text Prefix for each line
	* \param[in] xml XML to log
	*
	* \note This is a macro, and \p level may be evaluated more than once.
	* This does nothing when level is LOG_STDOUT.
	*/
	# define do_crm_log_xml(level, text, xml) do { \
	switch (level) { \
	case LOG_STDOUT: case LOG_NEVER: \
	break; \
	default: { \
	static struct qb_log_callsite *xml_cs = NULL; \
	if (xml_cs == NULL) { \
	xml_cs = qb_log_callsite_get(__func__, __FILE__, \
	"xml-blob", (level), __LINE__, 0); \
	} \
	if (crm_is_callsite_active(xml_cs, (level), 0)) { \
	log_data_element((level), __FILE__, __func__, \
	__LINE__, text, xml, 1, xml_log_option_formatted); \
	} \
	} \
	break; \
	} \
	} while(0)

	/*!
	* \brief Log a message as if it came from a different code location
	*
	* \param[in] level Priority at which to log the message
	* \param[in] file Source file name to use instead of __FILE__
	* \param[in] function Source function name to use instead of __func__
	* \param[in] line Source line number to use instead of __line__
	* \param[in] fmt printf-style format string literal for message
	* \param[in] args Any arguments needed by format string
	*
	* \note This is a macro, and \p level may be evaluated more than once.
	*/
	# define do_crm_log_alias(level, file, function, line, fmt, args...) do { \
	switch (level) { \
	case LOG_STDOUT: \
	printf(fmt "\n" , ##args); \
	break; \
	case LOG_NEVER: \
	break; \
	default: \
	qb_log_from_external_source(function, file, fmt, (level), \
	line, 0 , ##args); \
	break; \
	} \
	} while (0)

	/*!
	* \brief Send a system error message to both the log and stderr
	*
	* \param[in] level Priority at which to log the message
	* \param[in] fmt printf-style format string for message
	* \param[in] args Any arguments needed by format string
	*
	* \deprecated One of the other logging functions should be used with
	* pcmk_strerror() instead.
	* \note This is a macro, and \p level may be evaluated more than once.
	* \note Because crm_perror() adds the system error message and error number
	* onto the end of fmt, that information will become extended information
	* if CRM_XS is used inside fmt and will not show up in syslog.
	*/
	# define crm_perror(level, fmt, args...) do { \
	switch (level) { \
	case LOG_NEVER: \
	break; \
	default: { \
	const char *err = strerror(errno); \
	/* cast to int makes coverity happy when level == 0 */ \
	if ((level) <= (int) crm_log_level) { \
	fprintf(stderr, fmt ": %s (%d)\n" , ##args, err, errno);\
	} \
	do_crm_log((level), fmt ": %s (%d)" , ##args, err, errno); \
	} \
	break; \
	} \
	} while (0)

	/*!
	* \brief Log a message with a tag (for use with PCMK_trace_tags)
	*
	* \param[in] level Priority at which to log the message
	* \param[in] tag String to tag message with
	* \param[in] fmt printf-style format string for message
	* \param[in] args Any arguments needed by format string
	*
	* \note This is a macro, and \p level may be evaluated more than once.
	* This does nothing when level is LOG_STDOUT.
	*/
	# define crm_log_tag(level, tag, fmt, args...) do { \
	switch (level) { \
	case LOG_STDOUT: case LOG_NEVER: \
	break; \
	default: { \
	static struct qb_log_callsite *trace_tag_cs = NULL; \
	int converted_tag = g_quark_try_string(tag); \
	if (trace_tag_cs == NULL) { \
	trace_tag_cs = qb_log_callsite_get(__func__, __FILE__, \
	fmt, (level), __LINE__, converted_tag); \
	} \
	if (crm_is_callsite_active(trace_tag_cs, (level), \
	converted_tag)) { \
	qb_log_from_external_source(__func__, __FILE__, fmt, \
	(level), __LINE__, converted_tag , ##args); \
	} \
	} \
	} \
	} while (0)

	# define crm_emerg(fmt, args...) qb_log(LOG_EMERG, fmt , ##args)
	# define crm_crit(fmt, args...) qb_logt(LOG_CRIT, 0, fmt , ##args)
	# define crm_err(fmt, args...) qb_logt(LOG_ERR, 0, fmt , ##args)
	# define crm_warn(fmt, args...) qb_logt(LOG_WARNING, 0, fmt , ##args)
	# define crm_notice(fmt, args...) qb_logt(LOG_NOTICE, 0, fmt , ##args)
	# define crm_info(fmt, args...) qb_logt(LOG_INFO, 0, fmt , ##args)

	# define crm_debug(fmt, args...) do_crm_log_unlikely(LOG_DEBUG, fmt , ##args)
	# define crm_trace(fmt, args...) do_crm_log_unlikely(LOG_TRACE, fmt , ##args)

	# define crm_log_xml_crit(xml, text) do_crm_log_xml(LOG_CRIT, text, xml)
	# define crm_log_xml_err(xml, text) do_crm_log_xml(LOG_ERR, text, xml)
	# define crm_log_xml_warn(xml, text) do_crm_log_xml(LOG_WARNING, text, xml)
	# define crm_log_xml_notice(xml, text) do_crm_log_xml(LOG_NOTICE, text, xml)
	# define crm_log_xml_info(xml, text) do_crm_log_xml(LOG_INFO, text, xml)
	# define crm_log_xml_debug(xml, text) do_crm_log_xml(LOG_DEBUG, text, xml)
	# define crm_log_xml_trace(xml, text) do_crm_log_xml(LOG_TRACE, text, xml)

	# define crm_log_xml_explicit(xml, text) do { \
	static struct qb_log_callsite *digest_cs = NULL; \
	digest_cs = qb_log_callsite_get( \
	__func__, __FILE__, text, LOG_TRACE, __LINE__, \
	crm_trace_nonlog); \
	if (digest_cs && digest_cs->targets) { \
	do_crm_log_xml(LOG_TRACE, text, xml); \
	} \
	} while(0)

	# define crm_str(x) (const char*)(x?x:"<null>")

	#ifndef PCMK__NO_COMPAT

	/* Everything here is deprecated and kept only for public API backward
	* compatibility. It will be moved to compatibility.h in a future release.
	*/

	/*!
	* \brief Log a message using constant priority
	*
	* \param[in] level Priority at which to log the message
	* \param[in] fmt printf-style format string literal for message
	* \param[in] args Any arguments needed by format string
	*
	* \deprecated Use one of the other logging functions instead
	* \note This is a macro, and \p level may be evaluated more than once.
	* This does nothing when level is LOG_STDOUT.
	*/
	# define do_crm_log_always(level, fmt, args...) do { \
	switch (level) { \
	case LOG_STDOUT: case LOG_NEVER: \
	break; \
	default: \
	qb_log((level), fmt , ##args); \
	break; \
	} \
	} while (0)

	#endif // PCMK__NO_COMPAT

	#ifdef __cplusplus
	}
	#endif

	#endif
	diff --git a/include/crm/common/xml.h b/include/crm/common/xml.h
	index ea193cd272..5bc8850483 100644
	--- a/include/crm/common/xml.h
	+++ b/include/crm/common/xml.h
	@@ -1,348 +1,355 @@
	/*
	* Copyright 2004-2020 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 CRM_COMMON_XML__H
	# define CRM_COMMON_XML__H

	#ifdef __cplusplus
	extern "C" {
	#endif

	/**
	* \file
	* \brief Wrappers for and extensions to libxml2
	* \ingroup core
	*/

	# include <stdio.h>
	# include <sys/types.h>
	# include <unistd.h>

	# include <stdlib.h>
	# include <errno.h>
	# include <fcntl.h>

	# include <libxml/tree.h>
	# include <libxml/xpath.h>

	# include <crm/crm.h>
	# include <crm/common/nvpair.h>

	/* Define compression parameters for IPC messages
	*
	* Compression costs a LOT, so we don't want to do it unless we're hitting
	* message limits. Currently, we use 128KB as the threshold, because higher
	* values don't play well with the heartbeat stack. With an earlier limit of
	* 10KB, compressing 184 of 1071 messages accounted for 23% of the total CPU
	* used by the cib.
	*/
	# define CRM_BZ2_BLOCKS 4
	# define CRM_BZ2_WORK 20
	# define CRM_BZ2_THRESHOLD 128 * 1024

	# define XML_PARANOIA_CHECKS 0

	typedef const xmlChar *pcmkXmlStr;

	gboolean add_message_xml(xmlNode * msg, const char field, xmlNode xml);
	xmlNode get_message_xml(xmlNode msg, const char *field);

	xmlDoc getDocPtr(xmlNode node);

	/*
	* Replacement function for xmlCopyPropList which at the very least,
	* doesn't work the way I would expect it to.
	*
	* Copy all the attributes/properties from src into target.
	*
	* Not recursive, does not return anything.
	*
	*/
	void copy_in_properties(xmlNode * target, xmlNode * src);
	void expand_plus_plus(xmlNode * target, const char name, const char value);
	void fix_plus_plus_recursive(xmlNode * target);

	/*
	* Create a node named "name" as a child of "parent"
	* If parent is NULL, creates an unconnected node.
	*
	* Returns the created node
	*
	*/
	xmlNode create_xml_node(xmlNode parent, const char *name);

	/*
	* Create a node named "name" as a child of "parent", giving it the provided
	* text content.
	* If parent is NULL, creates an unconnected node.
	*
	* Returns the created node
	*
	*/
	xmlNode pcmk_create_xml_text_node(xmlNode parent, const char name, const char content);

	/*
	* Create a new HTML node named "element_name" as a child of "parent", giving it the
	* provided text content. Optionally, apply a CSS #id and #class.
	*
	* Returns the created node.
	*/
	xmlNode pcmk_create_html_node(xmlNode parent, const char element_name, const char id,
	const char class_name, const char text);

	/*
	*
	*/
	void purge_diff_markers(xmlNode * a_node);

	/*
	* Returns a deep copy of src_node
	*
	*/
	xmlNode copy_xml(xmlNode src_node);

	/*
	* Add a copy of xml_node to new_parent
	*/
	xmlNode add_node_copy(xmlNode new_parent, xmlNode * xml_node);

	int add_node_nocopy(xmlNode * parent, const char name, xmlNode child);

	/*
	* XML I/O Functions
	*
	* Whitespace between tags is discarded.
	*/
	xmlNode filename2xml(const char filename);

	xmlNode *stdin2xml(void);

	xmlNode string2xml(const char input);

	int write_xml_fd(xmlNode * xml_node, const char *filename, int fd, gboolean compress);
	int write_xml_file(xmlNode * xml_node, const char *filename, gboolean compress);

	char dump_xml_formatted(xmlNode msg);
	/* Also dump the text node with xml_log_option_text enabled */
	char dump_xml_formatted_with_text(xmlNode msg);

	char dump_xml_unformatted(xmlNode msg);

	/*
	* Diff related Functions
	*/
	xmlNode diff_xml_object(xmlNode left, xmlNode * right, gboolean suppress);

	xmlNode subtract_xml_object(xmlNode parent, xmlNode * left, xmlNode * right,
	gboolean full, gboolean * changed, const char *marker);

	gboolean can_prune_leaf(xmlNode * xml_node);

	gboolean apply_xml_diff(xmlNode old_xml, xmlNode diff, xmlNode **new_xml);

	/*
	* Searching & Modifying
	*/
	xmlNode find_xml_node(xmlNode cib, const char *node_path, gboolean must_find);

	-xmlNode find_entity(xmlNode parent, const char node_name, const char id);
	-
	void xml_remove_prop(xmlNode * obj, const char *name);

	gboolean replace_xml_child(xmlNode * parent, xmlNode * child, xmlNode * update,
	gboolean delete_only);

	gboolean update_xml_child(xmlNode * child, xmlNode * to_update);

	int find_xml_children(xmlNode ** children, xmlNode * root,
	const char tag, const char field, const char *value,
	gboolean search_matches);

	xmlNode get_xpath_object(const char xpath, xmlNode * xml_obj, int error_level);
	xmlNode get_xpath_object_relative(const char xpath, xmlNode * xml_obj, int error_level);

	static inline const char *
	crm_element_name(const xmlNode *xml)
	{
	return xml? (const char *)(xml->name) : NULL;
	}

	static inline const char *
	crm_map_element_name(const xmlNode *xml)
	{
	const char *name = crm_element_name(xml);

	if (strcmp(name, "master") == 0) {
	return "clone";
	} else {
	return name;
	}
	}

	gboolean xml_has_children(const xmlNode * root);

	char calculate_on_disk_digest(xmlNode local_cib);
	char calculate_operation_digest(xmlNode local_cib, const char *version);
	char calculate_xml_versioned_digest(xmlNode input, gboolean sort, gboolean do_filter,
	const char *version);

	/* schema-related functions (from schemas.c) */
	gboolean validate_xml(xmlNode * xml_blob, const char *validation, gboolean to_logs);
	gboolean validate_xml_verbose(xmlNode * xml_blob);

	/*!
	* \brief Update CIB XML to most recent schema version
	*
	* "Update" means either actively employ XSLT-based transformation(s)
	* (if intermediate product to transform valid per its declared schema version,
	* transformation available, proceeded successfully with a result valid per
	* expectated newer schema version), or just try to bump the marked validating
	* schema until all gradually rising schema versions attested or the first
	* such attempt subsequently fails to validate. Which of the two styles will
	* be used depends on \p transform parameter (positive/negative, respectively).
	*
	* \param[in,out] xml_blob XML tree representing CIB, may be swapped with
	* an "updated" one
	* \param[out] best The highest configuration version (per its index
	* in the global schemas table) it was possible to
	* reach during the update steps while ensuring
	* the validity of the result; if no validation
	* success was observed against possibly multiple
	* schemas, the value is less or equal the result
	* of \c get_schema_version applied on the input
	* \p xml_blob value (unless that function maps it
	* to -1, then 0 would be used instead)
	* \param[in] max When \p transform is positive, this allows to
	* set upper boundary schema (per its index in the
	* global schemas table) beyond which it's forbidden
	* to update by the means of XSLT transformation
	* \param[in] transform Whether to employ XSLT-based transformation so
	* as to allow overcoming possible incompatibilities
	* between major schema versions (see above)
	* \param[in] to_logs If true, output notable progress info to
	* internal log streams; if false, to stderr
	*
	* \return \c pcmk_ok if no non-recoverable error encountered (up to
	* caller to evaluate if the update satisfies the requirements
	* per returned \p best value), negative value carrying the reason
	* otherwise
	*/
	int update_validation(xmlNode *xml_blob, int best, int max,
	gboolean transform, gboolean to_logs);

	int get_schema_version(const char *name);
	const char *get_schema_name(int version);
	const char *xml_latest_schema(void);
	gboolean cli_config_update(xmlNode ** xml, int *best_version, gboolean to_logs);

	void crm_xml_init(void);
	void crm_xml_cleanup(void);

	static inline xmlNode *
	__xml_first_child(const xmlNode *parent)
	{
	xmlNode *child = parent? parent->children : NULL;

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

	static inline xmlNode *
	__xml_next(const xmlNode *child)
	{
	xmlNode *next = child? child->next : NULL;

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

	static inline xmlNode *
	__xml_first_child_element(const xmlNode *parent)
	{
	xmlNode *child = parent? parent->children : NULL;

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

	static inline xmlNode *
	__xml_next_element(const xmlNode *child)
	{
	xmlNode *next = child? child->next : NULL;

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

	void pcmk_free_xml_subtree(xmlNode *xml);
	void free_xml(xmlNode * child);

	xmlNode first_named_child(const xmlNode parent, const char *name);
	xmlNode crm_next_same_xml(const xmlNode sibling);

	xmlNode sorted_xml(xmlNode input, xmlNode * parent, gboolean recursive);
	xmlXPathObjectPtr xpath_search(xmlNode * xml_top, const char *path);
	void crm_foreach_xpath_result(xmlNode xml, const char xpath,
	void (helper)(xmlNode, void), void user_data);
	xmlNode expand_idref(xmlNode input, xmlNode * top);

	void freeXpathObject(xmlXPathObjectPtr xpathObj);
	xmlNode *getXpathResult(xmlXPathObjectPtr xpathObj, int index);
	void dedupXpathResults(xmlXPathObjectPtr xpathObj);

	static inline int numXpathResults(xmlXPathObjectPtr xpathObj)
	{
	if(xpathObj == NULL \|\| xpathObj->nodesetval == NULL) {
	return 0;
	}
	return xpathObj->nodesetval->nodeNr;
	}

	bool xml_tracking_changes(xmlNode * xml);
	bool xml_document_dirty(xmlNode *xml);
	void xml_track_changes(xmlNode * xml, const char user, xmlNode acl_source, bool enforce_acls);
	void xml_calculate_changes(xmlNode old_xml, xmlNode new_xml);
	void xml_calculate_significant_changes(xmlNode old_xml, xmlNode new_xml);
	void xml_accept_changes(xmlNode * xml);
	void xml_log_changes(uint8_t level, const char function, xmlNode xml);
	void xml_log_patchset(uint8_t level, const char function, xmlNode xml);
	bool xml_patch_versions(xmlNode *patchset, int add[3], int del[3]);

	xmlNode *xml_create_patchset(
	int format, xmlNode source, xmlNode target, bool *config, bool manage_version);
	int xml_apply_patchset(xmlNode xml, xmlNode patchset, bool check_version);

	void patchset_process_digest(xmlNode patch, xmlNode source, xmlNode *target, bool with_digest);

	void save_xml_to_file(xmlNode * xml, const char desc, const char filename);
	char xml_get_path(xmlNode xml);

	char * crm_xml_escape(const char *text);
	void crm_xml_sanitize_id(char *id);
	void crm_xml_set_id(xmlNode xml, const char format, ...)
	__attribute__ ((__format__ (__printf__, 2, 3)));

	/*!
	* \brief xmlNode destructor which can be used in glib collections
	*/
	void crm_destroy_xml(gpointer data);

	+#ifndef PCMK__NO_COMPAT
	+/* Everything here is deprecated and kept only for public API backward
	+ * compatibility. It will be moved to compatibility.h in a future release.
	+ */
	+
	+xmlNode find_entity(xmlNode parent, const char node_name, const char id);
	+
	+#endif
	+
	#ifdef __cplusplus
	}
	#endif

	#endif
	diff --git a/include/crm/common/xml_internal.h b/include/crm/common/xml_internal.h
	index d482cb5a89..e28f3433d6 100644
	--- a/include/crm/common/xml_internal.h
	+++ b/include/crm/common/xml_internal.h
	@@ -1,166 +1,162 @@
	/*
	- * Copyright 2017-2018 the Pacemaker project contributors
	+ * Copyright 2017-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	- * This program is free software; you can redistribute it and/or
	- * modify it under the terms of the GNU Lesser General Public
	- * License as published by the Free Software Foundation; either
	- * version 2 of the License, or (at your option) any later version.
	- *
	- * This software is distributed in the hope that it will be useful,
	- * but WITHOUT ANY WARRANTY; without even the implied warranty of
	- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	- * General Public License for more details.
	- *
	- * You should have received a copy of the GNU Lesser General Public
	- * License along with this library; if not, write to the Free Software
	- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
	+ * This source code is licensed under the GNU Lesser General Public License
	+ * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/
	-#ifndef CRM_COMMON_XML_INTERNAL__H
	-# define CRM_COMMON_XML_INTERNAL__H
	+
	+#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 */


	/*!
	* \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 CRM_XML_LOG_BASE(priority, dechunk, postemit, prefix, fmt, ap) \
	+#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_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(xmlNode parent, const char *node_name,
	+ const char attr_n, const char attr_v);
	+
	/*!
	* \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);

	-#endif
	+#endif // PCMK__XML_INTERNAL__H
	diff --git a/include/crm_internal.h b/include/crm_internal.h
	index 6d2743b200..f5a8e9b875 100644
	--- a/include/crm_internal.h
	+++ b/include/crm_internal.h
	@@ -1,98 +1,92 @@
	/*
	* Copyright 2006-2020 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 CRM_INTERNAL__H
	# define CRM_INTERNAL__H

	# include <config.h>
	# include <portability.h>

	# include <glib.h>
	# include <stdbool.h>
	# include <libxml/tree.h>

	/* Public API headers can guard deprecated code with this symbol, thus
	* preventing internal code (which includes this header) from using it, while
	* still allowing external code (which can't include this header) to use it,
	* for backward compatibility.
	*/
	#define PCMK__NO_COMPAT

	# include <crm/lrmd.h>
	# include <crm/common/logging.h>
	# include <crm/common/ipc_internal.h>
	# include <crm/common/options_internal.h>
	# include <crm/common/internal.h>

	-void strip_text_nodes(xmlNode * xml);
	-

	/*
	* XML attribute names used only by internal code
	*/

	#define PCMK__XA_ATTR_DAMPENING "attr_dampening"
	#define PCMK__XA_ATTR_FORCE "attrd_is_force_write"
	#define PCMK__XA_ATTR_INTERVAL "attr_clear_interval"
	#define PCMK__XA_ATTR_IS_PRIVATE "attr_is_private"
	#define PCMK__XA_ATTR_IS_REMOTE "attr_is_remote"
	#define PCMK__XA_ATTR_NAME "attr_name"
	#define PCMK__XA_ATTR_NODE_ID "attr_host_id"
	#define PCMK__XA_ATTR_NODE_NAME "attr_host"
	#define PCMK__XA_ATTR_OPERATION "attr_clear_operation"
	#define PCMK__XA_ATTR_PATTERN "attr_regex"
	#define PCMK__XA_ATTR_RESOURCE "attr_resource"
	#define PCMK__XA_ATTR_SECTION "attr_section"
	#define PCMK__XA_ATTR_SET "attr_set"
	#define PCMK__XA_ATTR_USER "attr_user"
	#define PCMK__XA_ATTR_UUID "attr_key"
	#define PCMK__XA_ATTR_VALUE "attr_value"
	#define PCMK__XA_ATTR_VERSION "attr_version"
	#define PCMK__XA_ATTR_WRITER "attr_writer"
	#define PCMK__XA_MODE "mode"
	#define PCMK__XA_TASK "task"


	/*
	* IPC service names that are only used internally
	*/

	# define PCMK__SERVER_BASED_RO "cib_ro"
	# define PCMK__SERVER_BASED_RW "cib_rw"
	# define PCMK__SERVER_BASED_SHM "cib_shm"

	/*
	* IPC commands that can be sent to Pacemaker daemons
	*/

	#define PCMK__ATTRD_CMD_PEER_REMOVE "peer-remove"
	#define PCMK__ATTRD_CMD_UPDATE "update"
	#define PCMK__ATTRD_CMD_UPDATE_BOTH "update-both"
	#define PCMK__ATTRD_CMD_UPDATE_DELAY "update-delay"
	#define PCMK__ATTRD_CMD_QUERY "query"
	#define PCMK__ATTRD_CMD_REFRESH "refresh"
	#define PCMK__ATTRD_CMD_FLUSH "flush"
	#define PCMK__ATTRD_CMD_SYNC "sync"
	#define PCMK__ATTRD_CMD_SYNC_RESPONSE "sync-response"
	#define PCMK__ATTRD_CMD_CLEAR_FAILURE "clear-failure"

	#define PCMK__CONTROLD_CMD_NODES "list-nodes"

	/*
	* Environment variables used by Pacemaker
	*/

	#define PCMK__ENV_PHYSICAL_HOST "physical_host"


	-const char crm_xml_add_last_written(xmlNode xml_node);
	-void crm_xml_dump(xmlNode * data, int options, char *buffer, int offset, int *max, int depth);
	-void crm_buffer_add_char(char *buffer, int offset, int *max, char c);
	-
	#endif /* CRM_INTERNAL__H */
	diff --git a/lib/cib/cib_file.c b/lib/cib/cib_file.c
	index 38e057ee7c..e831253731 100644
	--- a/lib/cib/cib_file.c
	+++ b/lib/cib/cib_file.c
	@@ -1,892 +1,893 @@
	/*
	* Original copyright 2004 International Business Machines
	* Later changes copyright 2008-2020 the Pacemaker project contributors
	*
	* 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 <unistd.h>
	#include <limits.h>
	#include <stdlib.h>
	#include <stdint.h>
	#include <stdio.h>
	#include <stdarg.h>
	#include <string.h>
	#include <pwd.h>

	#include <sys/stat.h>
	#include <sys/types.h>
	#include <glib.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/msg_xml.h>
	#include <crm/common/ipc.h>
	#include <crm/common/xml.h>
	+#include <crm/common/xml_internal.h>

	enum cib_file_flags {
	cib_file_flag_dirty = (1 << 0),
	cib_file_flag_live = (1 << 1),
	};

	typedef struct cib_file_opaque_s {
	uint32_t flags; // Group of enum cib_file_flags
	char *filename;
	} cib_file_opaque_t;

	#define cib_set_file_flags(cibfile, flags_to_set) do { \
	(cibfile)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_TRACE, "CIB file", \
	cibfile->filename, \
	(cibfile)->flags, \
	(flags_to_set), \
	#flags_to_set); \
	} while (0)

	#define cib_clear_file_flags(cibfile, flags_to_clear) do { \
	(cibfile)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_TRACE, "CIB file", \
	cibfile->filename, \
	(cibfile)->flags, \
	(flags_to_clear), \
	#flags_to_clear); \
	} while (0)

	int cib_file_perform_op(cib_t * cib, const char op, const char host, const char *section,
	xmlNode * data, xmlNode ** output_data, int call_options);

	int cib_file_perform_op_delegate(cib_t * cib, const char op, const char host, const char *section,
	xmlNode * data, xmlNode ** output_data, int call_options,
	const char *user_name);

	int cib_file_signon(cib_t * cib, const char *name, enum cib_conn_type type);
	int cib_file_signoff(cib_t * cib);
	int cib_file_free(cib_t * cib);

	static int
	cib_file_inputfd(cib_t * cib)
	{
	return -EPROTONOSUPPORT;
	}

	static int
	cib_file_set_connection_dnotify(cib_t * cib, void (*dnotify) (gpointer user_data))
	{
	return -EPROTONOSUPPORT;
	}

	static int
	cib_file_register_notification(cib_t * cib, const char *callback, int enabled)
	{
	return -EPROTONOSUPPORT;
	}

	/*!
	* \internal
	* \brief Compare the calculated digest of an XML tree against a signature file
	*
	* \param[in] root Root of XML tree to compare
	* \param[in] sigfile Name of signature file containing digest to compare
	*
	* \return TRUE if digests match or signature file does not exist, else FALSE
	*/
	static gboolean
	cib_file_verify_digest(xmlNode root, const char sigfile)
	{
	gboolean passed = FALSE;
	char *expected;
	int rc = pcmk__file_contents(sigfile, &expected);

	switch (rc) {
	case pcmk_rc_ok:
	if (expected == NULL) {
	crm_err("On-disk digest at %s is empty", sigfile);
	return FALSE;
	}
	break;
	case ENOENT:
	crm_warn("No on-disk digest present at %s", sigfile);
	return TRUE;
	default:
	crm_err("Could not read on-disk digest from %s: %s",
	sigfile, pcmk_rc_str(rc));
	return FALSE;
	}
	passed = pcmk__verify_digest(root, expected);
	free(expected);
	return passed;
	}

	/*!
	* \internal
	* \brief Read an XML tree from a file and verify its digest
	*
	* \param[in] filename Name of XML file to read
	* \param[in] sigfile Name of signature file containing digest to compare
	* \param[in] root If non-NULL, will be set to pointer to parsed XML tree
	*
	* \return 0 if file was successfully read, parsed and verified, otherwise:
	* -errno on stat() failure,
	* -pcmk_err_cib_corrupt if file size is 0 or XML is not parseable, or
	* -pcmk_err_cib_modified if digests do not match
	* \note If root is non-NULL, it is the caller's responsibility to free *root on
	* successful return.
	*/
	int
	cib_file_read_and_verify(const char filename, const char sigfile, xmlNode **root)
	{
	int s_res;
	struct stat buf;
	char *local_sigfile = NULL;
	xmlNode *local_root = NULL;

	CRM_ASSERT(filename != NULL);
	if (root) {
	*root = NULL;
	}

	/* Verify that file exists and its size is nonzero */
	s_res = stat(filename, &buf);
	if (s_res < 0) {
	crm_perror(LOG_WARNING, "Could not verify cluster configuration file %s", filename);
	return -errno;
	} else if (buf.st_size == 0) {
	crm_warn("Cluster configuration file %s is corrupt (size is zero)", filename);
	return -pcmk_err_cib_corrupt;
	}

	/* Parse XML */
	local_root = filename2xml(filename);
	if (local_root == NULL) {
	crm_warn("Cluster configuration file %s is corrupt (unparseable as XML)", filename);
	return -pcmk_err_cib_corrupt;
	}

	/* If sigfile is not specified, use original file name plus .sig */
	if (sigfile == NULL) {
	sigfile = local_sigfile = crm_strdup_printf("%s.sig", filename);
	}

	/* Verify that digests match */
	if (cib_file_verify_digest(local_root, sigfile) == FALSE) {
	free(local_sigfile);
	free_xml(local_root);
	return -pcmk_err_cib_modified;
	}

	free(local_sigfile);
	if (root) {
	*root = local_root;
	} else {
	free_xml(local_root);
	}
	return pcmk_ok;
	}

	#define CIB_SERIES "cib"
	#define CIB_SERIES_MAX 100
	#define CIB_SERIES_BZIP FALSE /* Must be false because archived copies are
	created with hard links
	*/

	#define CIB_LIVE_NAME CIB_SERIES ".xml"

	/*!
	* \internal
	* \brief Check whether a file is the live CIB
	*
	* \param[in] filename Name of file to check
	*
	* \return TRUE if file exists and its real path is same as live CIB's
	*/
	static gboolean
	cib_file_is_live(const char *filename)
	{
	gboolean same = FALSE;

	if (filename != NULL) {
	// Canonicalize file names for true comparison
	char *real_filename = NULL;

	if (pcmk__real_path(filename, &real_filename) == pcmk_rc_ok) {
	char *real_livename = NULL;

	if (pcmk__real_path(CRM_CONFIG_DIR "/" CIB_LIVE_NAME,
	&real_livename) == pcmk_rc_ok) {
	same = !strcmp(real_filename, real_livename);
	free(real_livename);
	}
	free(real_filename);
	}
	}
	return same;
	}

	/* cib_file_backup() and cib_file_write_with_digest() need to chown the
	* written files only in limited circumstances, so these variables allow
	* that to be indicated without affecting external callers
	*/
	static uid_t cib_file_owner = 0;
	static uid_t cib_file_group = 0;
	static gboolean cib_do_chown = FALSE;

	/*!
	* \internal
	* \brief Back up a CIB
	*
	* \param[in] cib_dirname Directory containing CIB file and backups
	* \param[in] cib_filename Name (relative to cib_dirname) of CIB file to back up
	*
	* \return 0 on success, -1 on error
	*/
	static int
	cib_file_backup(const char cib_dirname, const char cib_filename)
	{
	int rc = 0;
	unsigned int seq;
	char *cib_path = crm_strdup_printf("%s/%s", cib_dirname, cib_filename);
	char *cib_digest = crm_strdup_printf("%s.sig", cib_path);
	char *backup_path;
	char *backup_digest;

	// Determine backup and digest file names
	if (pcmk__read_series_sequence(cib_dirname, CIB_SERIES,
	&seq) != pcmk_rc_ok) {
	// @TODO maybe handle errors better ...
	seq = 0;
	}
	backup_path = pcmk__series_filename(cib_dirname, CIB_SERIES, seq,
	CIB_SERIES_BZIP);
	backup_digest = crm_strdup_printf("%s.sig", backup_path);

	/* Remove the old backups if they exist */
	unlink(backup_path);
	unlink(backup_digest);

	/* Back up the CIB, by hard-linking it to the backup name */
	if ((link(cib_path, backup_path) < 0) && (errno != ENOENT)) {
	crm_perror(LOG_ERR, "Could not archive %s by linking to %s",
	cib_path, backup_path);
	rc = -1;

	/* Back up the CIB signature similarly */
	} else if ((link(cib_digest, backup_digest) < 0) && (errno != ENOENT)) {
	crm_perror(LOG_ERR, "Could not archive %s by linking to %s",
	cib_digest, backup_digest);
	rc = -1;

	/* Update the last counter and ensure everything is sync'd to media */
	} else {
	pcmk__write_series_sequence(cib_dirname, CIB_SERIES, ++seq,
	CIB_SERIES_MAX);
	if (cib_do_chown) {
	int rc2;

	if ((chown(backup_path, cib_file_owner, cib_file_group) < 0)
	&& (errno != ENOENT)) {
	crm_perror(LOG_ERR, "Could not set owner of %s", backup_path);
	rc = -1;
	}
	if ((chown(backup_digest, cib_file_owner, cib_file_group) < 0)
	&& (errno != ENOENT)) {
	crm_perror(LOG_ERR, "Could not set owner of %s", backup_digest);
	rc = -1;
	}
	rc2 = pcmk__chown_series_sequence(cib_dirname, CIB_SERIES,
	cib_file_owner, cib_file_group);
	if (rc2 != pcmk_rc_ok) {
	crm_err("Could not set owner of sequence file in %s: %s",
	cib_dirname, pcmk_rc_str(rc2));
	rc = -1;
	}
	}
	pcmk__sync_directory(cib_dirname);
	crm_info("Archived previous version as %s", backup_path);
	}

	free(cib_path);
	free(cib_digest);
	free(backup_path);
	free(backup_digest);
	return rc;
	}

	/*!
	* \internal
	* \brief Prepare CIB XML to be written to disk
	*
	* Set num_updates to 0, set cib-last-written to the current timestamp,
	* and strip out the status section.
	*
	* \param[in] root Root of CIB XML tree
	*
	* \return void
	*/
	static void
	cib_file_prepare_xml(xmlNode *root)
	{
	xmlNode *cib_status_root = NULL;

	/* Always write out with num_updates=0 and current last-written timestamp */
	crm_xml_add(root, XML_ATTR_NUMUPDATES, "0");
	- crm_xml_add_last_written(root);
	+ pcmk__xe_add_last_written(root);

	/* Delete status section before writing to file, because
	* we discard it on startup anyway, and users get confused by it */
	cib_status_root = find_xml_node(root, XML_CIB_TAG_STATUS, TRUE);
	CRM_LOG_ASSERT(cib_status_root != NULL);
	if (cib_status_root != NULL) {
	free_xml(cib_status_root);
	}
	}

	/*!
	* \internal
	* \brief Write CIB to disk, along with a signature file containing its digest
	*
	* \param[in] cib_root Root of XML tree to write
	* \param[in] cib_dirname Directory containing CIB and signature files
	* \param[in] cib_filename Name (relative to cib_dirname) of file to write
	*
	* \return pcmk_ok on success,
	* pcmk_err_cib_modified if existing cib_filename doesn't match digest,
	* pcmk_err_cib_backup if existing cib_filename couldn't be backed up,
	* or pcmk_err_cib_save if new cib_filename couldn't be saved
	*/
	int
	cib_file_write_with_digest(xmlNode cib_root, const char cib_dirname,
	const char *cib_filename)
	{
	int exit_rc = pcmk_ok;
	int rc, fd;
	char *digest = NULL;

	/* Detect CIB version for diagnostic purposes */
	const char *epoch = crm_element_value(cib_root, XML_ATTR_GENERATION);
	const char *admin_epoch = crm_element_value(cib_root,
	XML_ATTR_GENERATION_ADMIN);

	/* Determine full CIB and signature pathnames */
	char *cib_path = crm_strdup_printf("%s/%s", cib_dirname, cib_filename);
	char *digest_path = crm_strdup_printf("%s.sig", cib_path);

	/* Create temporary file name patterns for writing out CIB and signature */
	char *tmp_cib = crm_strdup_printf("%s/cib.XXXXXX", cib_dirname);
	char *tmp_digest = crm_strdup_printf("%s/cib.XXXXXX", cib_dirname);

	CRM_ASSERT((cib_path != NULL) && (digest_path != NULL)
	&& (tmp_cib != NULL) && (tmp_digest != NULL));

	/* Ensure the admin didn't modify the existing CIB underneath us */
	crm_trace("Reading cluster configuration file %s", cib_path);
	rc = cib_file_read_and_verify(cib_path, NULL, NULL);
	if ((rc != pcmk_ok) && (rc != -ENOENT)) {
	crm_err("%s was manually modified while the cluster was active!",
	cib_path);
	exit_rc = pcmk_err_cib_modified;
	goto cleanup;
	}

	/* Back up the existing CIB */
	if (cib_file_backup(cib_dirname, cib_filename) < 0) {
	exit_rc = pcmk_err_cib_backup;
	goto cleanup;
	}

	crm_debug("Writing CIB to disk");
	umask(S_IWGRP \| S_IWOTH \| S_IROTH);
	cib_file_prepare_xml(cib_root);

	/* Write the CIB to a temporary file, so we can deploy (near) atomically */
	fd = mkstemp(tmp_cib);
	if (fd < 0) {
	crm_perror(LOG_ERR, "Couldn't open temporary file %s for writing CIB",
	tmp_cib);
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}

	/* Protect the temporary file */
	if (fchmod(fd, S_IRUSR \| S_IWUSR) < 0) {
	crm_perror(LOG_ERR, "Couldn't protect temporary file %s for writing CIB",
	tmp_cib);
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}
	if (cib_do_chown && (fchown(fd, cib_file_owner, cib_file_group) < 0)) {
	crm_perror(LOG_ERR, "Couldn't protect temporary file %s for writing CIB",
	tmp_cib);
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}

	/* Write out the CIB */
	if (write_xml_fd(cib_root, tmp_cib, fd, FALSE) <= 0) {
	crm_err("Changes couldn't be written to %s", tmp_cib);
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}

	/* Calculate CIB digest */
	digest = calculate_on_disk_digest(cib_root);
	CRM_ASSERT(digest != NULL);
	crm_info("Wrote version %s.%s.0 of the CIB to disk (digest: %s)",
	(admin_epoch ? admin_epoch : "0"), (epoch ? epoch : "0"), digest);

	/* Write the CIB digest to a temporary file */
	fd = mkstemp(tmp_digest);
	if (fd < 0) {
	crm_perror(LOG_ERR, "Could not create temporary file for CIB digest");
	exit_rc = pcmk_err_cib_save;
	goto cleanup;
	}
	if (cib_do_chown && (fchown(fd, cib_file_owner, cib_file_group) < 0)) {
	crm_perror(LOG_ERR, "Couldn't protect temporary file %s for writing CIB",
	tmp_cib);
	exit_rc = pcmk_err_cib_save;
	close(fd);
	goto cleanup;
	}
	rc = pcmk__write_sync(fd, digest);
	if (rc != pcmk_rc_ok) {
	crm_err("Could not write digest to %s: %s",
	tmp_digest, pcmk_rc_str(rc));
	exit_rc = pcmk_err_cib_save;
	close(fd);
	goto cleanup;
	}
	close(fd);
	crm_debug("Wrote digest %s to disk", digest);

	/* Verify that what we wrote is sane */
	crm_info("Reading cluster configuration file %s (digest: %s)",
	tmp_cib, tmp_digest);
	rc = cib_file_read_and_verify(tmp_cib, tmp_digest, NULL);
	CRM_ASSERT(rc == 0);

	/* Rename temporary files to live, and sync directory changes to media */
	crm_debug("Activating %s", tmp_cib);
	if (rename(tmp_cib, cib_path) < 0) {
	crm_perror(LOG_ERR, "Couldn't rename %s as %s", tmp_cib, cib_path);
	exit_rc = pcmk_err_cib_save;
	}
	if (rename(tmp_digest, digest_path) < 0) {
	crm_perror(LOG_ERR, "Couldn't rename %s as %s", tmp_digest,
	digest_path);
	exit_rc = pcmk_err_cib_save;
	}
	pcmk__sync_directory(cib_dirname);

	cleanup:
	free(cib_path);
	free(digest_path);
	free(digest);
	free(tmp_digest);
	free(tmp_cib);
	return exit_rc;
	}

	cib_t *
	cib_file_new(const char *cib_location)
	{
	cib_file_opaque_t *private = NULL;
	cib_t *cib = cib_new_variant();

	private = calloc(1, sizeof(cib_file_opaque_t));
	CRM_ASSERT((cib != NULL) && (private != NULL));

	cib->variant = cib_file;
	cib->variant_opaque = private;

	if (cib_location == NULL) {
	cib_location = getenv("CIB_file");
	}
	private->flags = 0;
	if (cib_file_is_live(cib_location)) {
	cib_set_file_flags(private, cib_file_flag_live);
	crm_trace("File %s detected as live CIB", cib_location);
	}
	private->filename = strdup(cib_location);

	/* assign variant specific ops */
	cib->delegate_fn = cib_file_perform_op_delegate;
	cib->cmds->signon = cib_file_signon;
	cib->cmds->signoff = cib_file_signoff;
	cib->cmds->free = cib_file_free;
	cib->cmds->inputfd = cib_file_inputfd;

	cib->cmds->register_notification = cib_file_register_notification;
	cib->cmds->set_connection_dnotify = cib_file_set_connection_dnotify;

	return cib;
	}

	static xmlNode *in_mem_cib = NULL;

	/*!
	* \internal
	* \brief Read CIB from disk and validate it against XML schema
	*
	* \param[in] filename Name of file to read CIB from
	*
	* \return pcmk_ok on success,
	* -ENXIO if file does not exist (or stat() otherwise fails), or
	* -pcmk_err_schema_validation if XML doesn't parse or validate
	* \note If filename is the live CIB, this will not verify its digest,
	* though that functionality would be trivial to add here.
	* Also, this will not verify that the file is writable,
	* because some callers might not need to write.
	*/
	static int
	load_file_cib(const char *filename)
	{
	struct stat buf;
	xmlNode *root = NULL;

	/* Ensure file is readable */
	if (stat(filename, &buf) < 0) {
	return -ENXIO;
	}

	/* Parse XML from file */
	root = filename2xml(filename);
	if (root == NULL) {
	return -pcmk_err_schema_validation;
	}

	/* Add a status section if not already present */
	if (find_xml_node(root, XML_CIB_TAG_STATUS, FALSE) == NULL) {
	create_xml_node(root, XML_CIB_TAG_STATUS);
	}

	/* Validate XML against its specified schema */
	if (validate_xml(root, NULL, TRUE) == FALSE) {
	const char *schema = crm_element_value(root, XML_ATTR_VALIDATION);

	crm_err("CIB does not validate against %s", schema);
	free_xml(root);
	return -pcmk_err_schema_validation;
	}

	/* Remember the parsed XML for later use */
	in_mem_cib = root;
	return pcmk_ok;
	}

	int
	cib_file_signon(cib_t * cib, const char *name, enum cib_conn_type type)
	{
	int rc = pcmk_ok;
	cib_file_opaque_t *private = cib->variant_opaque;

	if (private->filename == NULL) {
	rc = -EINVAL;
	} else {
	rc = load_file_cib(private->filename);
	}

	if (rc == pcmk_ok) {
	crm_debug("Opened connection to local file '%s' for %s",
	private->filename, name);
	cib->state = cib_connected_command;
	cib->type = cib_command;

	} else {
	crm_info("Connection to local file '%s' for %s failed: %s\n",
	private->filename, name, pcmk_strerror(rc));
	}
	return rc;
	}

	/*!
	* \internal
	* \brief Write out the in-memory CIB to a live CIB file
	*
	* param[in] path Full path to file to write
	*
	* \return 0 on success, -1 on failure
	*/
	static int
	cib_file_write_live(char *path)
	{
	uid_t uid = geteuid();
	struct passwd *daemon_pwent;
	char *sep = strrchr(path, '/');
	const char cib_dirname, cib_filename;
	int rc = 0;

	/* Get the desired uid/gid */
	errno = 0;
	daemon_pwent = getpwnam(CRM_DAEMON_USER);
	if (daemon_pwent == NULL) {
	crm_perror(LOG_ERR, "Could not find %s user", CRM_DAEMON_USER);
	return -1;
	}

	/* If we're root, we can change the ownership;
	* if we're daemon, anything we create will be OK;
	* otherwise, block access so we don't create wrong owner
	*/
	if ((uid != 0) && (uid != daemon_pwent->pw_uid)) {
	crm_perror(LOG_ERR, "Must be root or %s to modify live CIB",
	CRM_DAEMON_USER);
	return 0;
	}

	/* fancy footwork to separate dirname from filename
	* (we know the canonical name maps to the live CIB,
	* but the given name might be relative, or symlinked)
	*/
	if (sep == NULL) { /* no directory component specified */
	cib_dirname = "./";
	cib_filename = path;
	} else if (sep == path) { /* given name is in / */
	cib_dirname = "/";
	cib_filename = path + 1;
	} else { /* typical case; split given name into parts */
	*sep = '\0';
	cib_dirname = path;
	cib_filename = sep + 1;
	}

	/* if we're root, we want to update the file ownership */
	if (uid == 0) {
	cib_file_owner = daemon_pwent->pw_uid;
	cib_file_group = daemon_pwent->pw_gid;
	cib_do_chown = TRUE;
	}

	/* write the file */
	if (cib_file_write_with_digest(in_mem_cib, cib_dirname,
	cib_filename) != pcmk_ok) {
	rc = -1;
	}

	/* turn off file ownership changes, for other callers */
	if (uid == 0) {
	cib_do_chown = FALSE;
	}

	/* undo fancy stuff */
	if ((sep != NULL) && (*sep == '\0')) {
	*sep = '/';
	}

	return rc;
	}

	/*!
	* \internal
	* \brief Sign-off method for CIB file variants
	*
	* This will write the file to disk if needed, and free the in-memory CIB. If
	* the file is the live CIB, it will compute and write a signature as well.
	*
	* \param[in] cib CIB object to sign off
	*
	* \return pcmk_ok on success, pcmk_err_generic on failure
	* \todo This method should refuse to write the live CIB if the CIB manager is
	* running.
	*/
	int
	cib_file_signoff(cib_t * cib)
	{
	int rc = pcmk_ok;
	cib_file_opaque_t *private = cib->variant_opaque;

	crm_debug("Disconnecting from the CIB manager");
	cib->state = cib_disconnected;
	cib->type = cib_no_connection;

	/* If the in-memory CIB has been changed, write it to disk */
	if (pcmk_is_set(private->flags, cib_file_flag_dirty)) {

	/* If this is the live CIB, write it out with a digest */
	if (pcmk_is_set(private->flags, cib_file_flag_live)) {
	if (cib_file_write_live(private->filename) < 0) {
	rc = pcmk_err_generic;
	}

	/* Otherwise, it's a simple write */
	} else {
	gboolean do_bzip = pcmk__ends_with_ext(private->filename, ".bz2");

	if (write_xml_file(in_mem_cib, private->filename, do_bzip) <= 0) {
	rc = pcmk_err_generic;
	}
	}

	if (rc == pcmk_ok) {
	crm_info("Wrote CIB to %s", private->filename);
	cib_clear_file_flags(private, cib_file_flag_dirty);
	} else {
	crm_err("Could not write CIB to %s", private->filename);
	}
	}

	/* Free the in-memory CIB */
	free_xml(in_mem_cib);
	in_mem_cib = NULL;
	return rc;
	}

	int
	cib_file_free(cib_t * cib)
	{
	int rc = pcmk_ok;

	if (cib->state != cib_disconnected) {
	rc = cib_file_signoff(cib);
	}

	if (rc == pcmk_ok) {
	cib_file_opaque_t *private = cib->variant_opaque;

	free(private->filename);
	free(cib->cmds);
	free(private);
	free(cib);

	} else {
	fprintf(stderr, "Couldn't sign off: %d\n", rc);
	}

	return rc;
	}

	struct cib_func_entry {
	const char *op;
	gboolean read_only;
	cib_op_t fn;
	};

	/* INDENT-OFF */
	static struct cib_func_entry cib_file_ops[] = {
	{CIB_OP_QUERY, TRUE, cib_process_query},
	{CIB_OP_MODIFY, FALSE, cib_process_modify},
	{CIB_OP_APPLY_DIFF, FALSE, cib_process_diff},
	{CIB_OP_BUMP, FALSE, cib_process_bump},
	{CIB_OP_REPLACE, FALSE, cib_process_replace},
	{CIB_OP_CREATE, FALSE, cib_process_create},
	{CIB_OP_DELETE, FALSE, cib_process_delete},
	{CIB_OP_ERASE, FALSE, cib_process_erase},
	{CIB_OP_UPGRADE, FALSE, cib_process_upgrade},
	};
	/* INDENT-ON */

	int
	cib_file_perform_op(cib_t * cib, const char op, const char host, const char *section,
	xmlNode * data, xmlNode ** output_data, int call_options)
	{
	return cib_file_perform_op_delegate(cib, op, host, section, data, output_data, call_options,
	NULL);
	}

	int
	cib_file_perform_op_delegate(cib_t * cib, const char op, const char host, const char *section,
	xmlNode * data, xmlNode ** output_data, int call_options,
	const char *user_name)
	{
	int rc = pcmk_ok;
	char *effective_user = NULL;
	gboolean query = FALSE;
	gboolean changed = FALSE;
	xmlNode *request = NULL;
	xmlNode *output = NULL;
	xmlNode *cib_diff = NULL;
	xmlNode *result_cib = NULL;
	cib_op_t *fn = NULL;
	int lpc = 0;
	static int max_msg_types = DIMOF(cib_file_ops);
	cib_file_opaque_t *private = cib->variant_opaque;

	#if ENABLE_ACL
	crm_info("Handling %s operation for %s as %s",
	(op? op : "invalid"), (section? section : "entire CIB"),
	(user_name? user_name : "default user"));
	#else
	crm_info("Handling %s operation for %s",
	(op? op : "invalid"), (section? section : "entire CIB"));
	#endif

	cib__set_call_options(call_options, "file operation",
	cib_no_mtime\|cib_inhibit_bcast\|cib_scope_local);

	if (cib->state == cib_disconnected) {
	return -ENOTCONN;
	}

	if (output_data != NULL) {
	*output_data = NULL;
	}

	if (op == NULL) {
	return -EINVAL;
	}

	for (lpc = 0; lpc < max_msg_types; lpc++) {
	if (pcmk__str_eq(op, cib_file_ops[lpc].op, pcmk__str_casei)) {
	fn = &(cib_file_ops[lpc].fn);
	query = cib_file_ops[lpc].read_only;
	break;
	}
	}

	if (fn == NULL) {
	return -EPROTONOSUPPORT;
	}

	cib->call_id++;
	request = cib_create_op(cib->call_id, "dummy-token", op, host, section, data, call_options, user_name);
	#if ENABLE_ACL
	if(user_name) {
	crm_xml_add(request, XML_ACL_TAG_USER, user_name);
	}
	#endif

	/* Mirror the logic in cib_prepare_common() */
	if (section != NULL && data != NULL && pcmk__str_eq(crm_element_name(data), XML_TAG_CIB, pcmk__str_none)) {
	data = get_object_root(section, data);
	}

	rc = cib_perform_op(op, call_options, fn, query,
	section, request, data, TRUE, &changed, in_mem_cib, &result_cib, &cib_diff,
	&output);

	free_xml(request);
	if (rc == -pcmk_err_schema_validation) {
	validate_xml_verbose(result_cib);
	}

	if (rc != pcmk_ok) {
	free_xml(result_cib);

	} else if (query == FALSE) {
	xml_log_patchset(LOG_DEBUG, "cib:diff", cib_diff);
	free_xml(in_mem_cib);
	in_mem_cib = result_cib;
	cib_set_file_flags(private, cib_file_flag_dirty);
	}

	free_xml(cib_diff);

	if (cib->op_callback != NULL) {
	cib->op_callback(NULL, cib->call_id, rc, output);
	}

	if (output_data && output) {
	if(output == in_mem_cib) {
	*output_data = copy_xml(output);
	} else {
	*output_data = output;
	}

	} else if(output != in_mem_cib) {
	free_xml(output);
	}

	free(effective_user);
	return rc;
	}
	diff --git a/lib/cib/cib_ops.c b/lib/cib/cib_ops.c
	index b7906a4f65..3bb16e0231 100644
	--- a/lib/cib/cib_ops.c
	+++ b/lib/cib/cib_ops.c
	@@ -1,833 +1,835 @@
	/*
	* Copyright 2004-2020 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 <unistd.h>
	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <time.h>

	#include <sys/param.h>
	#include <sys/types.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/msg_xml.h>

	#include <crm/common/xml.h>
	+#include <crm/common/xml_internal.h>

	int
	cib_process_query(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	xmlNode *obj_root = NULL;
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event for section=%s", op, crm_str(section));

	if (options & cib_xpath) {
	return cib_process_xpath(op, options, section, req, input,
	existing_cib, result_cib, answer);
	}

	CRM_CHECK(answer == NULL, free_xml(answer));
	*answer = NULL;

	if (pcmk__str_eq(XML_CIB_TAG_SECTION_ALL, section, pcmk__str_casei)) {
	section = NULL;
	}

	obj_root = get_object_root(section, existing_cib);

	if (obj_root == NULL) {
	result = -ENXIO;

	} else if (options & cib_no_children) {
	const char *tag = TYPE(obj_root);
	xmlNode shallow = create_xml_node(answer, tag);

	copy_in_properties(shallow, obj_root);
	*answer = shallow;

	} else {
	*answer = obj_root;
	}

	if (result == pcmk_ok && *answer == NULL) {
	crm_err("Error creating query response");
	result = -ENOMSG;
	}

	return result;
	}

	int
	cib_process_erase(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event", op);
	*answer = NULL;
	free_xml(*result_cib);
	*result_cib = createEmptyCib(0);

	copy_in_properties(*result_cib, existing_cib);
	cib_update_counter(*result_cib, XML_ATTR_GENERATION_ADMIN, FALSE);

	return result;
	}

	int
	cib_process_upgrade(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	int rc = 0;
	int new_version = 0;
	int current_version = 0;
	int max_version = 0;
	const char *max = crm_element_value(req, F_CIB_SCHEMA_MAX);
	const char *value = crm_element_value(existing_cib, XML_ATTR_VALIDATION);

	*answer = NULL;
	crm_trace("Processing \"%s\" event with max=%s", op, max);

	if (value != NULL) {
	current_version = get_schema_version(value);
	}

	if (max) {
	max_version = get_schema_version(max);
	}

	rc = update_validation(result_cib, &new_version, max_version, TRUE,
	!(options & cib_verbose));
	if (new_version > current_version) {
	cib_update_counter(*result_cib, XML_ATTR_GENERATION_ADMIN, FALSE);
	cib_update_counter(*result_cib, XML_ATTR_GENERATION, TRUE);
	cib_update_counter(*result_cib, XML_ATTR_NUMUPDATES, TRUE);
	return pcmk_ok;
	}

	return rc;
	}

	int
	cib_process_bump(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event for epoch=%s",
	op, crm_str(crm_element_value(existing_cib, XML_ATTR_GENERATION)));

	*answer = NULL;
	cib_update_counter(*result_cib, XML_ATTR_GENERATION, FALSE);

	return result;
	}

	int
	cib_update_counter(xmlNode * xml_obj, const char *field, gboolean reset)
	{
	char *new_value = NULL;
	char *old_value = NULL;
	int int_value = -1;

	if (reset == FALSE && crm_element_value(xml_obj, field) != NULL) {
	old_value = crm_element_value_copy(xml_obj, field);
	}
	if (old_value != NULL) {
	int_value = atoi(old_value);
	new_value = crm_itoa(++int_value);
	} else {
	new_value = strdup("1");
	}

	crm_trace("%s %d(%s)->%s", field, int_value, crm_str(old_value), crm_str(new_value));
	crm_xml_add(xml_obj, field, new_value);

	free(new_value);
	free(old_value);

	return pcmk_ok;
	}

	int
	cib_process_replace(const char op, int options, const char section, xmlNode * req,
	xmlNode * input, xmlNode * existing_cib, xmlNode ** result_cib,
	xmlNode ** answer)
	{
	const char *tag = NULL;
	int result = pcmk_ok;

	crm_trace("Processing \"%s\" event for section=%s", op, crm_str(section));

	if (options & cib_xpath) {
	return cib_process_xpath(op, options, section, req, input,
	existing_cib, result_cib, answer);
	}

	*answer = NULL;

	if (input == NULL) {
	return -EINVAL;
	}

	tag = crm_element_name(input);

	if (pcmk__str_eq(XML_CIB_TAG_SECTION_ALL, section, pcmk__str_casei)) {
	section = NULL;

	} else if (pcmk__str_eq(tag, section, pcmk__str_casei)) {
	section = NULL;
	}

	if (pcmk__str_eq(tag, XML_TAG_CIB, pcmk__str_casei)) {
	int updates = 0;
	int epoch = 0;
	int admin_epoch = 0;

	int replace_updates = 0;
	int replace_epoch = 0;
	int replace_admin_epoch = 0;

	const char *reason = NULL;
	const char *peer = crm_element_value(req, F_ORIG);
	const char *digest = crm_element_value(req, XML_ATTR_DIGEST);

	if (digest) {
	const char *version = crm_element_value(req, XML_ATTR_CRM_VERSION);
	char *digest_verify = calculate_xml_versioned_digest(input, FALSE, TRUE,
	version ? version :
	CRM_FEATURE_SET);

	if (!pcmk__str_eq(digest_verify, digest, pcmk__str_casei)) {
	crm_err("Digest mis-match on replace from %s: %s vs. %s (expected)", peer,
	digest_verify, digest);
	reason = "digest mismatch";

	} else {
	crm_info("Digest matched on replace from %s: %s", peer, digest);
	}
	free(digest_verify);

	} else {
	crm_trace("No digest to verify");
	}

	cib_version_details(existing_cib, &admin_epoch, &epoch, &updates);
	cib_version_details(input, &replace_admin_epoch, &replace_epoch, &replace_updates);

	if (replace_admin_epoch < admin_epoch) {
	reason = XML_ATTR_GENERATION_ADMIN;

	} else if (replace_admin_epoch > admin_epoch) {
	/* no more checks */

	} else if (replace_epoch < epoch) {
	reason = XML_ATTR_GENERATION;

	} else if (replace_epoch > epoch) {
	/* no more checks */

	} else if (replace_updates < updates) {
	reason = XML_ATTR_NUMUPDATES;
	}

	if (reason != NULL) {
	crm_info("Replacement %d.%d.%d from %s not applied to %d.%d.%d:"
	" current %s is greater than the replacement",
	replace_admin_epoch, replace_epoch,
	replace_updates, peer, admin_epoch, epoch, updates, reason);
	result = -pcmk_err_old_data;
	} else {
	crm_info("Replaced %d.%d.%d with %d.%d.%d from %s",
	admin_epoch, epoch, updates,
	replace_admin_epoch, replace_epoch, replace_updates, peer);
	}

	free_xml(*result_cib);
	*result_cib = copy_xml(input);

	} else {
	xmlNode *obj_root = NULL;
	gboolean ok = TRUE;

	obj_root = get_object_root(section, *result_cib);
	ok = replace_xml_child(NULL, obj_root, input, FALSE);
	if (ok == FALSE) {
	crm_trace("No matching object to replace");
	result = -ENXIO;
	}
	}

	return result;
	}

	int
	cib_process_delete(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	xmlNode *obj_root = NULL;

	crm_trace("Processing \"%s\" event", op);

	if (options & cib_xpath) {
	return cib_process_xpath(op, options, section, req, input,
	existing_cib, result_cib, answer);
	}

	if (input == NULL) {
	crm_err("Cannot perform modification with no data");
	return -EINVAL;
	}

	obj_root = get_object_root(section, *result_cib);
	if(pcmk__str_eq(crm_element_name(input), section, pcmk__str_casei)) {
	xmlNode *child = NULL;
	for(child = __xml_first_child(input); child; child = __xml_next(child)) {
	if (replace_xml_child(NULL, obj_root, child, TRUE) == FALSE) {
	crm_trace("No matching object to delete: %s=%s", child->name, ID(child));
	}
	}

	} else if (replace_xml_child(NULL, obj_root, input, TRUE) == FALSE) {
	crm_trace("No matching object to delete: %s=%s", input->name, ID(input));
	}

	return pcmk_ok;
	}

	int
	cib_process_modify(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	xmlNode *obj_root = NULL;

	crm_trace("Processing \"%s\" event", op);

	if (options & cib_xpath) {
	return cib_process_xpath(op, options, section, req, input,
	existing_cib, result_cib, answer);
	}

	if (input == NULL) {
	crm_err("Cannot perform modification with no data");
	return -EINVAL;
	}

	obj_root = get_object_root(section, *result_cib);
	if (obj_root == NULL) {
	xmlNode *tmp_section = NULL;
	const char *path = get_object_parent(section);

	if (path == NULL) {
	return -EINVAL;
	}

	tmp_section = create_xml_node(NULL, section);
	cib_process_xpath(CIB_OP_CREATE, 0, path, NULL, tmp_section, NULL, result_cib, answer);
	free_xml(tmp_section);

	obj_root = get_object_root(section, *result_cib);
	}

	CRM_CHECK(obj_root != NULL, return -EINVAL);

	if (update_xml_child(obj_root, input) == FALSE) {
	if (options & cib_can_create) {
	add_node_copy(obj_root, input);
	} else {
	return -ENXIO;
	}
	}

	if(options & cib_mixed_update) {
	int max = 0, lpc;
	xmlXPathObjectPtr xpathObj = xpath_search(*result_cib, "//@__delete__");

	if (xpathObj) {
	max = numXpathResults(xpathObj);
	crm_log_xml_trace(*result_cib, "Mixed result");
	}

	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *match = getXpathResult(xpathObj, lpc);
	xmlChar *match_path = xmlGetNodePath(match);

	crm_debug("Destroying %s", match_path);
	free(match_path);
	free_xml(match);
	}

	freeXpathObject(xpathObj);
	}
	return pcmk_ok;
	}

	static int
	update_cib_object(xmlNode * parent, xmlNode * update)
	{
	int result = pcmk_ok;
	xmlNode *target = NULL;
	xmlNode *a_child = NULL;
	const char *replace = NULL;
	const char *object_id = NULL;
	const char *object_name = NULL;

	CRM_CHECK(update != NULL, return -EINVAL);
	CRM_CHECK(parent != NULL, return -EINVAL);

	object_name = crm_element_name(update);
	CRM_CHECK(object_name != NULL, return -EINVAL);

	object_id = ID(update);
	crm_trace("Processing: <%s id=%s>", crm_str(object_name), crm_str(object_id));

	if (object_id == NULL) {
	/* placeholder object */
	target = find_xml_node(parent, object_name, FALSE);

	} else {
	- target = find_entity(parent, object_name, object_id);
	+ target = pcmk__xe_match(parent, object_name, XML_ATTR_ID, object_id);
	}

	if (target == NULL) {
	target = create_xml_node(parent, object_name);
	}

	crm_trace("Found node <%s id=%s> to update", crm_str(object_name), crm_str(object_id));

	replace = crm_element_value(update, XML_CIB_ATTR_REPLACE);
	if (replace != NULL) {
	xmlNode *remove = NULL;
	int last = 0, lpc = 0, len = 0;

	len = strlen(replace);
	while (lpc <= len) {
	if (replace[lpc] == ',' \|\| replace[lpc] == 0) {
	char *replace_item = NULL;

	if (last == lpc) {
	/* nothing to do */
	last = lpc + 1;
	goto incr;
	}

	replace_item = strndup(replace + last, lpc - last);
	remove = find_xml_node(target, replace_item, FALSE);
	if (remove != NULL) {
	crm_trace("Replacing node <%s> in <%s>",
	replace_item, crm_element_name(target));
	free_xml(remove);
	remove = NULL;
	}
	free(replace_item);
	last = lpc + 1;
	}
	incr:
	lpc++;
	}
	xml_remove_prop(update, XML_CIB_ATTR_REPLACE);
	xml_remove_prop(target, XML_CIB_ATTR_REPLACE);
	}

	copy_in_properties(target, update);

	crm_trace("Processing children of <%s id=%s>", crm_str(object_name), crm_str(object_id));

	for (a_child = __xml_first_child(update); a_child != NULL; a_child = __xml_next(a_child)) {
	int tmp_result = 0;

	crm_trace("Updating child <%s id=%s>", crm_element_name(a_child), ID(a_child));

	tmp_result = update_cib_object(target, a_child);

	/* only the first error is likely to be interesting */
	if (tmp_result != pcmk_ok) {
	crm_err("Error updating child <%s id=%s>", crm_element_name(a_child), ID(a_child));

	if (result == pcmk_ok) {
	result = tmp_result;
	}
	}
	}

	crm_trace("Finished with <%s id=%s>", crm_str(object_name), crm_str(object_id));

	return result;
	}

	static int
	add_cib_object(xmlNode * parent, xmlNode * new_obj)
	{
	int result = pcmk_ok;
	const char *object_name = NULL;
	const char *object_id = NULL;
	xmlNode *equiv_node = NULL;

	if (new_obj != NULL) {
	object_name = crm_element_name(new_obj);
	}
	object_id = crm_element_value(new_obj, XML_ATTR_ID);

	crm_trace("Processing: <%s id=%s>", crm_str(object_name), crm_str(object_id));

	if (new_obj == NULL \|\| object_name == NULL) {
	result = -EINVAL;

	} else if (parent == NULL) {
	result = -EINVAL;

	} else if (object_id == NULL) {
	/* placeholder object */
	equiv_node = find_xml_node(parent, object_name, FALSE);

	} else {
	- equiv_node = find_entity(parent, object_name, object_id);
	+ equiv_node = pcmk__xe_match(parent, object_name, XML_ATTR_ID,
	+ object_id);
	}

	if (result != pcmk_ok) {
	; /* do nothing */

	} else if (equiv_node != NULL) {
	result = -EEXIST;

	} else {
	result = update_cib_object(parent, new_obj);
	}

	return result;
	}

	int
	cib_process_create(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	xmlNode *failed = NULL;
	int result = pcmk_ok;
	xmlNode *update_section = NULL;

	crm_trace("Processing \"%s\" event for section=%s", op, crm_str(section));
	if (pcmk__str_eq(XML_CIB_TAG_SECTION_ALL, section, pcmk__str_casei)) {
	section = NULL;

	} else if (pcmk__str_eq(XML_TAG_CIB, section, pcmk__str_casei)) {
	section = NULL;

	} else if (pcmk__str_eq(crm_element_name(input), XML_TAG_CIB, pcmk__str_casei)) {
	section = NULL;
	}

	CRM_CHECK(strcasecmp(CIB_OP_CREATE, op) == 0, return -EINVAL);

	if (input == NULL) {
	crm_err("Cannot perform modification with no data");
	return -EINVAL;
	}

	if (section == NULL) {
	return cib_process_modify(op, options, section, req, input, existing_cib, result_cib,
	answer);
	}

	failed = create_xml_node(NULL, XML_TAG_FAILED);

	update_section = get_object_root(section, *result_cib);
	if (pcmk__str_eq(crm_element_name(input), section, pcmk__str_casei)) {
	xmlNode *a_child = NULL;

	for (a_child = __xml_first_child(input); a_child != NULL; a_child = __xml_next(a_child)) {
	result = add_cib_object(update_section, a_child);
	if (update_results(failed, a_child, op, result)) {
	break;
	}
	}

	} else {
	result = add_cib_object(update_section, input);
	update_results(failed, input, op, result);
	}

	if ((result == pcmk_ok) && xml_has_children(failed)) {
	result = -EINVAL;
	}

	if (result != pcmk_ok) {
	crm_log_xml_err(failed, "CIB Update failures");
	*answer = failed;

	} else {
	free_xml(failed);
	}

	return result;
	}

	int
	cib_process_diff(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	const char *originator = NULL;

	if (req != NULL) {
	originator = crm_element_value(req, F_ORIG);
	}

	crm_trace("Processing \"%s\" event from %s%s",
	op, originator,
	(pcmk_is_set(options, cib_force_diff)? " (global update)" : ""));

	free_xml(*result_cib);
	*result_cib = copy_xml(existing_cib);
	return xml_apply_patchset(*result_cib, input, TRUE);
	}

	gboolean
	cib_config_changed(xmlNode * last, xmlNode * next, xmlNode ** diff)
	{
	int lpc = 0, max = 0;
	gboolean config_changes = FALSE;
	xmlXPathObject *xpathObj = NULL;
	int format = 1;

	CRM_ASSERT(diff != NULL);

	if (*diff == NULL && last != NULL && next != NULL) {
	*diff = diff_xml_object(last, next, FALSE);
	}

	if (*diff == NULL) {
	goto done;
	}

	crm_element_value_int(*diff, "format", &format);
	/* This function only applies to v1 diffs. */
	CRM_LOG_ASSERT(format == 1);

	xpathObj = xpath_search(*diff, "//" XML_CIB_TAG_CONFIGURATION);
	if (numXpathResults(xpathObj) > 0) {
	config_changes = TRUE;
	goto done;
	}
	freeXpathObject(xpathObj);

	/*
	* Do not check XML_TAG_DIFF_ADDED "//" XML_TAG_CIB
	* This always contains every field and would produce a false positive
	* every time if the checked value existed
	*/
	xpathObj = xpath_search(*diff, "//" XML_TAG_DIFF_REMOVED "//" XML_TAG_CIB);
	max = numXpathResults(xpathObj);

	for (lpc = 0; lpc < max; lpc++) {
	xmlNode *top = getXpathResult(xpathObj, lpc);

	if (crm_element_value(top, XML_ATTR_GENERATION) != NULL) {
	config_changes = TRUE;
	goto done;
	}
	if (crm_element_value(top, XML_ATTR_GENERATION_ADMIN) != NULL) {
	config_changes = TRUE;
	goto done;
	}

	if (crm_element_value(top, XML_ATTR_VALIDATION) != NULL) {
	config_changes = TRUE;
	goto done;
	}
	if (crm_element_value(top, XML_ATTR_CRM_VERSION) != NULL) {
	config_changes = TRUE;
	goto done;
	}
	if (crm_element_value(top, "remote-clear-port") != NULL) {
	config_changes = TRUE;
	goto done;
	}
	if (crm_element_value(top, "remote-tls-port") != NULL) {
	config_changes = TRUE;
	goto done;
	}
	}

	done:
	freeXpathObject(xpathObj);
	return config_changes;
	}

	int
	cib_process_xpath(const char op, int options, const char section, xmlNode * req, xmlNode * input,
	xmlNode * existing_cib, xmlNode result_cib, xmlNode answer)
	{
	int lpc = 0;
	int max = 0;
	int rc = pcmk_ok;
	gboolean is_query = pcmk__str_eq(op, CIB_OP_QUERY, pcmk__str_casei);

	xmlXPathObjectPtr xpathObj = NULL;

	crm_trace("Processing \"%s\" event", op);

	if (is_query) {
	xpathObj = xpath_search(existing_cib, section);
	} else {
	xpathObj = xpath_search(*result_cib, section);
	}

	max = numXpathResults(xpathObj);

	if (max < 1 && pcmk__str_eq(op, CIB_OP_DELETE, pcmk__str_casei)) {
	crm_debug("%s was already removed", section);

	} else if (max < 1) {
	crm_debug("%s: %s does not exist", op, section);
	rc = -ENXIO;

	} else if (is_query) {
	if (max > 1) {
	*answer = create_xml_node(NULL, "xpath-query");
	}
	}

	if (pcmk__str_eq(op, CIB_OP_DELETE, pcmk__str_casei) && (options & cib_multiple)) {
	dedupXpathResults(xpathObj);
	}

	for (lpc = 0; lpc < max; lpc++) {
	xmlChar *path = NULL;
	xmlNode *match = getXpathResult(xpathObj, lpc);

	if (match == NULL) {
	continue;
	}

	path = xmlGetNodePath(match);
	crm_debug("Processing %s op for %s with %s", op, section, path);
	free(path);

	if (pcmk__str_eq(op, CIB_OP_DELETE, pcmk__str_casei)) {
	if (match == *result_cib) {
	/* Attempting to delete the whole "/cib" */
	crm_warn("Cannot perform %s for %s: The xpath is addressing the whole /cib", op, section);
	rc = -EINVAL;
	break;
	}

	free_xml(match);
	if ((options & cib_multiple) == 0) {
	break;
	}

	} else if (pcmk__str_eq(op, CIB_OP_MODIFY, pcmk__str_casei)) {
	if (update_xml_child(match, input) == FALSE) {
	rc = -ENXIO;
	} else if ((options & cib_multiple) == 0) {
	break;
	}

	} else if (pcmk__str_eq(op, CIB_OP_CREATE, pcmk__str_casei)) {
	add_node_copy(match, input);
	break;

	} else if (pcmk__str_eq(op, CIB_OP_QUERY, pcmk__str_casei)) {

	if (options & cib_no_children) {
	const char *tag = TYPE(match);
	xmlNode shallow = create_xml_node(answer, tag);

	copy_in_properties(shallow, match);

	if (*answer == NULL) {
	*answer = shallow;
	}

	} else if (options & cib_xpath_address) {
	char *path = NULL;
	xmlNode *parent = match;

	while (parent && parent->type == XML_ELEMENT_NODE) {
	const char *id = crm_element_value(parent, XML_ATTR_ID);
	char *new_path = NULL;

	if (id) {
	new_path = crm_strdup_printf("/%s[@id='%s']%s",
	parent->name, id,
	(path? path : ""));
	} else {
	new_path = crm_strdup_printf("/%s%s", parent->name,
	(path? path : ""));
	}
	free(path);
	path = new_path;
	parent = parent->parent;
	}
	crm_trace("Got: %s", path);

	if (*answer == NULL) {
	*answer = create_xml_node(NULL, "xpath-query");
	}
	parent = create_xml_node(*answer, "xpath-query-path");
	crm_xml_add(parent, XML_ATTR_ID, path);
	free(path);

	} else if (*answer) {
	add_node_copy(*answer, match);

	} else {
	*answer = match;
	}

	} else if (pcmk__str_eq(op, CIB_OP_REPLACE, pcmk__str_casei)) {
	xmlNode *parent = match->parent;

	free_xml(match);
	if (input != NULL) {
	add_node_copy(parent, input);
	}

	if ((options & cib_multiple) == 0) {
	break;
	}
	}
	}

	freeXpathObject(xpathObj);
	return rc;
	}

	/* remove this function */
	gboolean
	update_results(xmlNode * failed, xmlNode * target, const char *operation, int return_code)
	{
	xmlNode *xml_node = NULL;
	gboolean was_error = FALSE;
	const char *error_msg = NULL;

	if (return_code != pcmk_ok) {
	error_msg = pcmk_strerror(return_code);

	was_error = TRUE;
	xml_node = create_xml_node(failed, XML_FAIL_TAG_CIB);
	add_node_copy(xml_node, target);

	crm_xml_add(xml_node, XML_FAILCIB_ATTR_ID, ID(target));
	crm_xml_add(xml_node, XML_FAILCIB_ATTR_OBJTYPE, TYPE(target));
	crm_xml_add(xml_node, XML_FAILCIB_ATTR_OP, operation);
	crm_xml_add(xml_node, XML_FAILCIB_ATTR_REASON, error_msg);

	crm_warn("Action %s failed: %s (cde=%d)", operation, error_msg, return_code);
	}

	return was_error;
	}
	diff --git a/lib/cib/cib_utils.c b/lib/cib/cib_utils.c
	index 890d7be509..234f9beb3d 100644
	--- a/lib/cib/cib_utils.c
	+++ b/lib/cib/cib_utils.c
	@@ -1,774 +1,775 @@
	/*
	* Original copyright 2004 International Business Machines
	* Later changes copyright 2008-2020 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 <unistd.h>
	#include <stdlib.h>
	#include <stdio.h>
	#include <stdarg.h>
	#include <string.h>
	#include <sys/utsname.h>

	#include <glib.h>

	#include <crm/crm.h>
	#include <crm/cib/internal.h>
	#include <crm/msg_xml.h>
	#include <crm/common/iso8601_internal.h>
	#include <crm/common/xml.h>
	+#include <crm/common/xml_internal.h>
	#include <crm/pengine/rules.h>

	struct config_root_s {
	const char *name;
	const char *parent;
	const char *path;
	};

	/*
	* "//crm_config" will also work in place of "/cib/configuration/crm_config"
	* The / prefix means find starting from the root, whereas the // prefix means
	* find anywhere and risks multiple matches
	*/
	/* INDENT-OFF */
	struct config_root_s known_paths[] = {
	{ NULL, NULL, "//cib" },
	{ XML_TAG_CIB, NULL, "//cib" },
	{ XML_CIB_TAG_STATUS, "/cib", "//cib/status" },
	{ XML_CIB_TAG_CONFIGURATION, "/cib", "//cib/configuration" },
	{ XML_CIB_TAG_CRMCONFIG, "/cib/configuration", "//cib/configuration/crm_config" },
	{ XML_CIB_TAG_NODES, "/cib/configuration", "//cib/configuration/nodes" },
	{ XML_CIB_TAG_RESOURCES, "/cib/configuration", "//cib/configuration/resources" },
	{ XML_CIB_TAG_CONSTRAINTS, "/cib/configuration", "//cib/configuration/constraints" },
	{ XML_CIB_TAG_OPCONFIG, "/cib/configuration", "//cib/configuration/op_defaults" },
	{ XML_CIB_TAG_RSCCONFIG, "/cib/configuration", "//cib/configuration/rsc_defaults" },
	{ XML_CIB_TAG_ACLS, "/cib/configuration", "//cib/configuration/acls" },
	{ XML_TAG_FENCING_TOPOLOGY, "/cib/configuration", "//cib/configuration/fencing-topology" },
	{ XML_CIB_TAG_TAGS, "/cib/configuration", "//cib/configuration/tags" },
	{ XML_CIB_TAG_ALERTS, "/cib/configuration", "//cib/configuration/alerts" },
	{ XML_CIB_TAG_SECTION_ALL, NULL, "//cib" },
	};
	/* INDENT-ON */

	xmlNode *
	cib_get_generation(cib_t * cib)
	{
	xmlNode *the_cib = NULL;
	xmlNode *generation = create_xml_node(NULL, XML_CIB_TAG_GENERATION_TUPPLE);

	cib->cmds->query(cib, NULL, &the_cib, cib_scope_local \| cib_sync_call);
	if (the_cib != NULL) {
	copy_in_properties(generation, the_cib);
	free_xml(the_cib);
	}

	return generation;
	}

	gboolean
	cib_version_details(xmlNode * cib, int admin_epoch, int epoch, int *updates)
	{
	*epoch = -1;
	*updates = -1;
	*admin_epoch = -1;

	if (cib == NULL) {
	return FALSE;

	} else {
	crm_element_value_int(cib, XML_ATTR_GENERATION, epoch);
	crm_element_value_int(cib, XML_ATTR_NUMUPDATES, updates);
	crm_element_value_int(cib, XML_ATTR_GENERATION_ADMIN, admin_epoch);
	}
	return TRUE;
	}

	gboolean
	cib_diff_version_details(xmlNode * diff, int admin_epoch, int epoch, int *updates,
	int _admin_epoch, int _epoch, int *_updates)
	{
	int add[] = { 0, 0, 0 };
	int del[] = { 0, 0, 0 };

	xml_patch_versions(diff, add, del);

	*admin_epoch = add[0];
	*epoch = add[1];
	*updates = add[2];

	*_admin_epoch = del[0];
	*_epoch = del[1];
	*_updates = del[2];

	return TRUE;
	}

	/*
	* The caller should never free the return value
	*/

	const char *
	get_object_path(const char *object_type)
	{
	int lpc = 0;
	int max = DIMOF(known_paths);

	for (; lpc < max; lpc++) {
	if ((object_type == NULL && known_paths[lpc].name == NULL)
	\|\| pcmk__str_eq(object_type, known_paths[lpc].name, pcmk__str_casei)) {
	return known_paths[lpc].path;
	}
	}
	return NULL;
	}

	const char *
	get_object_parent(const char *object_type)
	{
	int lpc = 0;
	int max = DIMOF(known_paths);

	for (; lpc < max; lpc++) {
	if (pcmk__str_eq(object_type, known_paths[lpc].name, pcmk__str_casei)) {
	return known_paths[lpc].parent;
	}
	}
	return NULL;
	}

	xmlNode *
	get_object_root(const char object_type, xmlNode the_root)
	{
	const char *xpath = get_object_path(object_type);

	if (xpath == NULL) {
	return the_root; /* or return NULL? */
	}

	return get_xpath_object(xpath, the_root, LOG_TRACE);
	}

	/*
	* It is the callers responsibility to free both the new CIB (output)
	* and the new CIB (input)
	*/
	xmlNode *
	createEmptyCib(int admin_epoch)
	{
	xmlNode cib_root = NULL, config = NULL;

	cib_root = create_xml_node(NULL, XML_TAG_CIB);
	crm_xml_add(cib_root, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);
	crm_xml_add(cib_root, XML_ATTR_VALIDATION, xml_latest_schema());

	crm_xml_add_int(cib_root, XML_ATTR_GENERATION, admin_epoch);
	crm_xml_add_int(cib_root, XML_ATTR_NUMUPDATES, 0);
	crm_xml_add_int(cib_root, XML_ATTR_GENERATION_ADMIN, 0);

	config = create_xml_node(cib_root, XML_CIB_TAG_CONFIGURATION);
	create_xml_node(cib_root, XML_CIB_TAG_STATUS);

	create_xml_node(config, XML_CIB_TAG_CRMCONFIG);
	create_xml_node(config, XML_CIB_TAG_NODES);
	create_xml_node(config, XML_CIB_TAG_RESOURCES);
	create_xml_node(config, XML_CIB_TAG_CONSTRAINTS);

	return cib_root;
	}

	static bool
	cib_acl_enabled(xmlNode xml, const char user)
	{
	bool rc = FALSE;

	#if ENABLE_ACL
	if(pcmk_acl_required(user)) {
	const char *value = NULL;
	GHashTable *options = crm_str_table_new();

	cib_read_config(options, xml);
	value = cib_pref(options, "enable-acl");
	rc = crm_is_true(value);
	g_hash_table_destroy(options);
	}

	crm_trace("CIB ACL is %s", rc ? "enabled" : "disabled");
	#endif
	return rc;
	}

	int
	cib_perform_op(const char op, int call_options, cib_op_t fn, gboolean is_query,
	const char section, xmlNode req, xmlNode * input,
	gboolean manage_counters, gboolean * config_changed,
	xmlNode * current_cib, xmlNode result_cib, xmlNode diff, xmlNode ** output)
	{
	int rc = pcmk_ok;
	gboolean check_schema = TRUE;
	xmlNode *top = NULL;
	xmlNode *scratch = NULL;
	xmlNode *local_diff = NULL;

	const char *new_version = NULL;
	static struct qb_log_callsite *diff_cs = NULL;
	const char *user = crm_element_value(req, F_CIB_USER);
	bool with_digest = FALSE;

	crm_trace("Begin %s%s%s op",
	(pcmk_is_set(call_options, cib_dryrun)? "dry run of " : ""),
	(is_query? "read-only " : ""), op);

	CRM_CHECK(output != NULL, return -ENOMSG);
	CRM_CHECK(result_cib != NULL, return -ENOMSG);
	CRM_CHECK(config_changed != NULL, return -ENOMSG);

	if(output) {
	*output = NULL;
	}

	*result_cib = NULL;
	*config_changed = FALSE;

	if (fn == NULL) {
	return -EINVAL;
	}

	if (is_query) {
	xmlNode *cib_ro = current_cib;
	xmlNode *cib_filtered = NULL;

	if(cib_acl_enabled(cib_ro, user)) {
	if(xml_acl_filtered_copy(user, current_cib, current_cib, &cib_filtered)) {
	if (cib_filtered == NULL) {
	crm_debug("Pre-filtered the entire cib");
	return -EACCES;
	}
	cib_ro = cib_filtered;
	crm_log_xml_trace(cib_ro, "filtered");
	}
	}

	rc = (*fn) (op, call_options, section, req, input, cib_ro, result_cib, output);

	if(output == NULL \|\| *output == NULL) {
	/* nothing */

	} else if(cib_filtered == *output) {
	cib_filtered = NULL; /* Let them have this copy */

	} else if(*output == current_cib) {
	/* They already know not to free it */

	} else if(cib_filtered && (*output)->doc == cib_filtered->doc) {
	/* We're about to free the document of which output is a part /
	output = copy_xml(output);

	} else if((*output)->doc == current_cib->doc) {
	/* Give them a copy they can free */
	output = copy_xml(output);
	}

	free_xml(cib_filtered);
	return rc;
	}


	if (pcmk_is_set(call_options, cib_zero_copy)) {
	/* Conditional on v2 patch style */

	scratch = current_cib;

	/* Create a shallow copy of current_cib for the version details */
	current_cib = create_xml_node(NULL, (const char *)scratch->name);
	copy_in_properties(current_cib, scratch);
	top = current_cib;

	xml_track_changes(scratch, user, NULL, cib_acl_enabled(scratch, user));
	rc = (*fn) (op, call_options, section, req, input, scratch, &scratch, output);

	} else {
	scratch = copy_xml(current_cib);
	xml_track_changes(scratch, user, NULL, cib_acl_enabled(scratch, user));
	rc = (*fn) (op, call_options, section, req, input, current_cib, &scratch, output);

	if(scratch && xml_tracking_changes(scratch) == FALSE) {
	crm_trace("Inferring changes after %s op", op);
	xml_track_changes(scratch, user, current_cib, cib_acl_enabled(current_cib, user));
	xml_calculate_changes(current_cib, scratch);
	}
	CRM_CHECK(current_cib != scratch, return -EINVAL);
	}

	xml_acl_disable(scratch); /* Allow the system to make any additional changes */

	if (rc == pcmk_ok && scratch == NULL) {
	rc = -EINVAL;
	goto done;

	} else if(rc == pcmk_ok && xml_acl_denied(scratch)) {
	crm_trace("ACL rejected part or all of the proposed changes");
	rc = -EACCES;
	goto done;

	} else if (rc != pcmk_ok) {
	goto done;
	}

	if (scratch) {
	new_version = crm_element_value(scratch, XML_ATTR_CRM_VERSION);

	if (new_version && compare_version(new_version, CRM_FEATURE_SET) > 0) {
	crm_err("Discarding update with feature set '%s' greater than our own '%s'",
	new_version, CRM_FEATURE_SET);
	rc = -EPROTONOSUPPORT;
	goto done;
	}
	}

	if (current_cib) {
	int old = 0;
	int new = 0;

	crm_element_value_int(scratch, XML_ATTR_GENERATION_ADMIN, &new);
	crm_element_value_int(current_cib, XML_ATTR_GENERATION_ADMIN, &old);

	if (old > new) {
	crm_err("%s went backwards: %d -> %d (Opts: 0x%x)",
	XML_ATTR_GENERATION_ADMIN, old, new, call_options);
	crm_log_xml_warn(req, "Bad Op");
	crm_log_xml_warn(input, "Bad Data");
	rc = -pcmk_err_old_data;

	} else if (old == new) {
	crm_element_value_int(scratch, XML_ATTR_GENERATION, &new);
	crm_element_value_int(current_cib, XML_ATTR_GENERATION, &old);
	if (old > new) {
	crm_err("%s went backwards: %d -> %d (Opts: 0x%x)",
	XML_ATTR_GENERATION, old, new, call_options);
	crm_log_xml_warn(req, "Bad Op");
	crm_log_xml_warn(input, "Bad Data");
	rc = -pcmk_err_old_data;
	}
	}
	}

	crm_trace("Massaging CIB contents");
	- strip_text_nodes(scratch);
	+ pcmk__strip_xml_text(scratch);
	fix_plus_plus_recursive(scratch);

	if (pcmk_is_set(call_options, cib_zero_copy)) {
	/* At this point, current_cib is just the 'cib' tag and its properties,
	*
	* The v1 format would barf on this, but we know the v2 patch
	* format only needs it for the top-level version fields
	*/
	local_diff = xml_create_patchset(2, current_cib, scratch, (bool*)config_changed, manage_counters);

	} else {
	static time_t expires = 0;
	time_t tm_now = time(NULL);

	if (expires < tm_now) {
	expires = tm_now + 60; /* Validate clients are correctly applying v2-style diffs at most once a minute */
	with_digest = TRUE;
	}

	local_diff = xml_create_patchset(0, current_cib, scratch, (bool*)config_changed, manage_counters);
	}

	xml_log_changes(LOG_TRACE, __func__, scratch);
	xml_accept_changes(scratch);

	if (diff_cs == NULL) {
	diff_cs = qb_log_callsite_get(__PRETTY_FUNCTION__, __FILE__, "diff-validation", LOG_DEBUG, __LINE__, crm_trace_nonlog);
	}

	if(local_diff) {
	patchset_process_digest(local_diff, current_cib, scratch, with_digest);

	xml_log_patchset(LOG_INFO, __func__, local_diff);
	crm_log_xml_trace(local_diff, "raw patch");
	}

	if (!pcmk_is_set(call_options, cib_zero_copy) // Original to compare against doesn't exist
	&& local_diff
	&& crm_is_callsite_active(diff_cs, LOG_TRACE, 0)) {

	/* Validate the calculated patch set */
	int test_rc, format = 1;
	xmlNode * c = copy_xml(current_cib);

	crm_element_value_int(local_diff, "format", &format);
	test_rc = xml_apply_patchset(c, local_diff, manage_counters);

	if(test_rc != pcmk_ok) {
	save_xml_to_file(c, "PatchApply:calculated", NULL);
	save_xml_to_file(current_cib, "PatchApply:input", NULL);
	save_xml_to_file(scratch, "PatchApply:actual", NULL);
	save_xml_to_file(local_diff, "PatchApply:diff", NULL);
	crm_err("v%d patchset error, patch failed to apply: %s (%d)", format, pcmk_strerror(test_rc), test_rc);
	}
	free_xml(c);
	}

	if (pcmk__str_eq(section, XML_CIB_TAG_STATUS, pcmk__str_casei)) {
	/* Throttle the amount of costly validation we perform due to status updates
	* a) we don't really care whats in the status section
	* b) we don't validate any of its contents at the moment anyway
	*/
	check_schema = FALSE;
	}

	/* === scratch must not be modified after this point ===
	* Exceptions, anything in:

	static filter_t filter[] = {
	{ 0, XML_ATTR_ORIGIN },
	{ 0, XML_CIB_ATTR_WRITTEN },
	{ 0, XML_ATTR_UPDATE_ORIG },
	{ 0, XML_ATTR_UPDATE_CLIENT },
	{ 0, XML_ATTR_UPDATE_USER },
	};
	*/

	if (*config_changed && !pcmk_is_set(call_options, cib_no_mtime)) {
	const char *schema = crm_element_value(scratch, XML_ATTR_VALIDATION);

	- crm_xml_add_last_written(scratch);
	+ pcmk__xe_add_last_written(scratch);
	if (schema) {
	static int minimum_schema = 0;
	int current_schema = get_schema_version(schema);

	if (minimum_schema == 0) {
	minimum_schema = get_schema_version("pacemaker-1.2");
	}

	/* Does the CIB support the "update-" attributes... /
	if (current_schema >= minimum_schema) {
	const char *origin = crm_element_value(req, F_ORIG);

	CRM_LOG_ASSERT(origin != NULL);
	crm_xml_replace(scratch, XML_ATTR_UPDATE_ORIG, origin);
	crm_xml_replace(scratch, XML_ATTR_UPDATE_CLIENT,
	crm_element_value(req, F_CIB_CLIENTNAME));
	#if ENABLE_ACL
	crm_xml_replace(scratch, XML_ATTR_UPDATE_USER, crm_element_value(req, F_CIB_USER));
	#endif
	}
	}
	}

	crm_trace("Perform validation: %s", pcmk__btoa(check_schema));
	if ((rc == pcmk_ok) && check_schema && !validate_xml(scratch, NULL, TRUE)) {
	const char *current_schema = crm_element_value(scratch,
	XML_ATTR_VALIDATION);

	crm_warn("Updated CIB does not validate against %s schema",
	crm_str(current_schema));
	rc = -pcmk_err_schema_validation;
	}

	done:

	*result_cib = scratch;
	#if ENABLE_ACL
	if(rc != pcmk_ok && cib_acl_enabled(current_cib, user)) {
	if(xml_acl_filtered_copy(user, current_cib, scratch, result_cib)) {
	if (*result_cib == NULL) {
	crm_debug("Pre-filtered the entire cib result");
	}
	free_xml(scratch);
	}
	}
	#endif

	if(diff) {
	*diff = local_diff;
	} else {
	free_xml(local_diff);
	}

	free_xml(top);
	crm_trace("Done");
	return rc;
	}

	xmlNode *
	cib_create_op(int call_id, const char token, const char op, const char host, const char section,
	xmlNode * data, int call_options, const char *user_name)
	{
	xmlNode *op_msg = create_xml_node(NULL, "cib_command");

	CRM_CHECK(op_msg != NULL, return NULL);
	CRM_CHECK(token != NULL, return NULL);

	crm_xml_add(op_msg, F_XML_TAGNAME, "cib_command");

	crm_xml_add(op_msg, F_TYPE, T_CIB);
	crm_xml_add(op_msg, F_CIB_CALLBACK_TOKEN, token);
	crm_xml_add(op_msg, F_CIB_OPERATION, op);
	crm_xml_add(op_msg, F_CIB_HOST, host);
	crm_xml_add(op_msg, F_CIB_SECTION, section);
	crm_xml_add_int(op_msg, F_CIB_CALLID, call_id);
	#if ENABLE_ACL
	if (user_name) {
	crm_xml_add(op_msg, F_CIB_USER, user_name);
	}
	#endif
	crm_trace("Sending call options: %.8lx, %d", (long)call_options, call_options);
	crm_xml_add_int(op_msg, F_CIB_CALLOPTS, call_options);

	if (data != NULL) {
	add_message_xml(op_msg, F_CIB_CALLDATA, data);
	}

	if (call_options & cib_inhibit_bcast) {
	CRM_CHECK((call_options & cib_scope_local), return NULL);
	}
	return op_msg;
	}

	void
	cib_native_callback(cib_t * cib, xmlNode * msg, int call_id, int rc)
	{
	xmlNode *output = NULL;
	cib_callback_client_t *blob = NULL;

	if (msg != NULL) {
	crm_element_value_int(msg, F_CIB_RC, &rc);
	crm_element_value_int(msg, F_CIB_CALLID, &call_id);
	output = get_message_xml(msg, F_CIB_CALLDATA);
	}

	blob = g_hash_table_lookup(cib_op_callback_table, GINT_TO_POINTER(call_id));
	if (blob == NULL) {
	crm_trace("No callback found for call %d", call_id);
	}

	if (cib == NULL) {
	crm_debug("No cib object supplied");
	}

	if (rc == -pcmk_err_diff_resync) {
	/* This is an internal value that clients do not and should not care about */
	rc = pcmk_ok;
	}

	if (blob && blob->callback && (rc == pcmk_ok \|\| blob->only_success == FALSE)) {
	crm_trace("Invoking callback %s for call %d", crm_str(blob->id), call_id);
	blob->callback(msg, call_id, rc, output, blob->user_data);

	} else if (cib && cib->op_callback == NULL && rc != pcmk_ok) {
	crm_warn("CIB command failed: %s", pcmk_strerror(rc));
	crm_log_xml_debug(msg, "Failed CIB Update");
	}

	/* This may free user_data, so do it after the callback */
	if (blob) {
	remove_cib_op_callback(call_id, FALSE);
	}

	if (cib && cib->op_callback != NULL) {
	crm_trace("Invoking global callback for call %d", call_id);
	cib->op_callback(msg, call_id, rc, output);
	}
	crm_trace("OP callback activated for %d", call_id);
	}

	void
	cib_native_notify(gpointer data, gpointer user_data)
	{
	xmlNode *msg = user_data;
	cib_notify_client_t *entry = data;
	const char *event = NULL;

	if (msg == NULL) {
	crm_warn("Skipping callback - NULL message");
	return;
	}

	event = crm_element_value(msg, F_SUBTYPE);

	if (entry == NULL) {
	crm_warn("Skipping callback - NULL callback client");
	return;

	} else if (entry->callback == NULL) {
	crm_warn("Skipping callback - NULL callback");
	return;

	} else if (!pcmk__str_eq(entry->event, event, pcmk__str_casei)) {
	crm_trace("Skipping callback - event mismatch %p/%s vs. %s", entry, entry->event, event);
	return;
	}

	crm_trace("Invoking callback for %p/%s event...", entry, event);
	entry->callback(event, msg);
	crm_trace("Callback invoked...");
	}

	static pcmk__cluster_option_t cib_opts[] = {
	/* name, legacy name, type, allowed values,
	* default value, validator,
	* short description,
	* long description
	*/
	{
	"enable-acl", NULL, "boolean", NULL,
	"false", pcmk__valid_boolean,
	"Enable Access Control Lists (ACLs) for the CIB",
	NULL
	},
	{
	"cluster-ipc-limit", NULL, "integer", NULL,
	"500", pcmk__valid_positive_number,
	"Maximum IPC message backlog before disconnecting a cluster daemon",
	"Raise this if log has \"Evicting client\" messages for cluster daemon"
	" PIDs (a good value is the number of resources in the cluster"
	" multiplied by the number of nodes)."
	},
	};

	void
	cib_metadata(void)
	{
	pcmk__print_option_metadata("pacemaker-based", "1.0",
	"Cluster Information Base manager options",
	"Cluster options used by Pacemaker's "
	"Cluster Information Base manager",
	cib_opts, DIMOF(cib_opts));
	}

	void
	verify_cib_options(GHashTable * options)
	{
	pcmk__validate_cluster_options(options, cib_opts, DIMOF(cib_opts));
	}

	const char *
	cib_pref(GHashTable * options, const char *name)
	{
	return pcmk__cluster_option(options, cib_opts, DIMOF(cib_opts), name);
	}

	gboolean
	cib_read_config(GHashTable * options, xmlNode * current_cib)
	{
	xmlNode *config = NULL;
	crm_time_t *now = NULL;

	if (options == NULL \|\| current_cib == NULL) {
	return FALSE;
	}

	now = crm_time_new(NULL);

	g_hash_table_remove_all(options);

	config = get_object_root(XML_CIB_TAG_CRMCONFIG, current_cib);
	if (config) {
	pe_unpack_nvpairs(current_cib, config, XML_CIB_TAG_PROPSET, NULL,
	options, CIB_OPTIONS_FIRST, TRUE, now, NULL);
	}

	verify_cib_options(options);

	crm_time_free(now);

	return TRUE;
	}

	/* v2 and v2 patch formats */
	#define XPATH_CONFIG_CHANGE \
	"//" XML_CIB_TAG_CRMCONFIG " \| " \
	"//" XML_DIFF_CHANGE "[contains(@" XML_DIFF_PATH ",'/" XML_CIB_TAG_CRMCONFIG "/')]"

	gboolean
	cib_internal_config_changed(xmlNode *diff)
	{
	gboolean changed = FALSE;

	if (diff) {
	xmlXPathObject *xpathObj = xpath_search(diff, XPATH_CONFIG_CHANGE);

	if (numXpathResults(xpathObj) > 0) {
	changed = TRUE;
	}
	freeXpathObject(xpathObj);
	}
	return changed;
	}

	int
	cib_internal_op(cib_t * cib, const char op, const char host,
	const char section, xmlNode data,
	xmlNode ** output_data, int call_options, const char *user_name)
	{
	int (delegate) (cib_t cib, const char op, const char host,
	const char section, xmlNode data,
	xmlNode ** output_data, int call_options, const char *user_name) =
	cib->delegate_fn;

	#if ENABLE_ACL
	if(user_name == NULL) {
	user_name = getenv("CIB_user");
	}
	#endif

	return delegate(cib, op, host, section, data, output_data, call_options, user_name);
	}

	// Deprecated functions kept only for backward API compatibility
	int cib_apply_patch_event(xmlNode event, xmlNode input, xmlNode **output,
	int level);

	/*!
	* \deprecated
	*/
	int
	cib_apply_patch_event(xmlNode event, xmlNode input, xmlNode **output,
	int level)
	{
	int rc = pcmk_err_generic;

	xmlNode *diff = NULL;

	CRM_ASSERT(event);
	CRM_ASSERT(input);
	CRM_ASSERT(output);

	crm_element_value_int(event, F_CIB_RC, &rc);
	diff = get_message_xml(event, F_CIB_UPDATE_RESULT);

	if (rc < pcmk_ok \|\| diff == NULL) {
	return rc;
	}

	if (level > LOG_CRIT) {
	xml_log_patchset(level, "Config update", diff);
	}

	if (input != NULL) {
	rc = cib_process_diff(NULL, cib_none, NULL, event, diff, input, output,
	NULL);

	if (rc != pcmk_ok) {
	crm_debug("Update didn't apply: %s (%d) %p",
	pcmk_strerror(rc), rc, *output);

	if (rc == -pcmk_err_old_data) {
	crm_trace("Masking error, we already have the supplied update");
	return pcmk_ok;
	}
	free_xml(*output);
	*output = NULL;
	return rc;
	}
	}
	return rc;
	}
	diff --git a/lib/common/crmcommon_private.h b/lib/common/crmcommon_private.h
	index 2c33d344db..4059c8f8a3 100644
	--- a/lib/common/crmcommon_private.h
	+++ b/lib/common/crmcommon_private.h
	@@ -1,243 +1,253 @@
	/*
	* Copyright 2018-2020 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 CRMCOMMON_PRIVATE__H
	# define CRMCOMMON_PRIVATE__H

	/* This header is for the sole use of libcrmcommon, so that functions can be
	* declared with G_GNUC_INTERNAL for efficiency.
	*/

	#include <stdint.h> // uint8_t, uint32_t
	#include <stdbool.h> // bool
	#include <sys/types.h> // size_t
	#include <glib.h> // GList
	#include <libxml/tree.h> // xmlNode, xmlAttr
	#include <qb/qbipcc.h> // struct qb_ipc_response_header

	/*
	* XML and ACLs
	*/

	enum xml_private_flags {
	xpf_none = 0x0000,
	xpf_dirty = 0x0001,
	xpf_deleted = 0x0002,
	xpf_created = 0x0004,
	xpf_modified = 0x0008,

	xpf_tracking = 0x0010,
	xpf_processed = 0x0020,
	xpf_skip = 0x0040,
	xpf_moved = 0x0080,

	xpf_acl_enabled = 0x0100,
	xpf_acl_read = 0x0200,
	xpf_acl_write = 0x0400,
	xpf_acl_deny = 0x0800,

	xpf_acl_create = 0x1000,
	xpf_acl_denied = 0x2000,
	xpf_lazy = 0x4000,
	};

	typedef struct xml_private_s {
	long check;
	uint32_t flags;
	char *user;
	GList *acls;
	GList *deleted_objs;
	} xml_private_t;

	#define pcmk__set_xml_flags(xml_priv, flags_to_set) do { \
	(xml_priv)->flags = pcmk__set_flags_as(__func__, __LINE__, \
	LOG_NEVER, "XML", "XML node", (xml_priv)->flags, \
	(flags_to_set), #flags_to_set); \
	} while (0)

	#define pcmk__clear_xml_flags(xml_priv, flags_to_clear) do { \
	(xml_priv)->flags = pcmk__clear_flags_as(__func__, __LINE__, \
	LOG_NEVER, "XML", "XML node", (xml_priv)->flags, \
	(flags_to_clear), #flags_to_clear); \
	} while (0)

	+G_GNUC_INTERNAL
	+void pcmk__xml2text(xmlNode data, int options, char buffer, int offset,
	+ int *max, int depth);
	+
	+G_GNUC_INTERNAL
	+void pcmk__buffer_add_char(char *buffer, int offset, int *max, char c);
	+
	G_GNUC_INTERNAL
	void pcmk__set_xml_doc_flag(xmlNode *xml, enum xml_private_flags flag);

	G_GNUC_INTERNAL
	bool pcmk__tracking_xml_changes(xmlNode *xml, bool lazy);

	G_GNUC_INTERNAL
	int pcmk__element_xpath(const char prefix, xmlNode xml, char *buffer,
	int offset, size_t buffer_size);

	G_GNUC_INTERNAL
	void pcmk__free_acls(GList *acls);

	G_GNUC_INTERNAL
	void pcmk__unpack_acl(xmlNode source, xmlNode target, const char *user);

	G_GNUC_INTERNAL
	bool pcmk__check_acl(xmlNode xml, const char name,
	enum xml_private_flags mode);

	G_GNUC_INTERNAL
	void pcmk__apply_acl(xmlNode *xml);

	G_GNUC_INTERNAL
	void pcmk__apply_creation_acl(xmlNode *xml, bool check_top);

	G_GNUC_INTERNAL
	void pcmk__mark_xml_attr_dirty(xmlAttr *a);

	+G_GNUC_INTERNAL
	+bool pcmk__xa_filterable(const char *name);
	+
	static inline xmlAttr *
	pcmk__first_xml_attr(const xmlNode *xml)
	{
	return xml? xml->properties : NULL;
	}

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

	/*
	* IPC
	*/

	#define PCMK__IPC_VERSION 1

	#define PCMK__CONTROLD_API_MAJOR "1"
	#define PCMK__CONTROLD_API_MINOR "0"

	// IPC behavior that varies by daemon
	typedef struct pcmk__ipc_methods_s {
	/*!
	* \internal
	* \brief Allocate any private data needed by daemon IPC
	*
	* \param[in] api IPC API connection
	*
	* \return Standard Pacemaker return code
	*/
	int (new_data)(pcmk_ipc_api_t api);

	/*!
	* \internal
	* \brief Free any private data used by daemon IPC
	*
	* \param[in] api_data Data allocated by new_data() method
	*/
	void (free_data)(void api_data);

	/*!
	* \internal
	* \brief Perform daemon-specific handling after successful connection
	*
	* Some daemons require clients to register before sending any other
	* commands. The controller requires a CRM_OP_HELLO (with no reply), and
	* the CIB manager, executor, and fencer require a CRM_OP_REGISTER (with a
	* reply). Ideally this would be consistent across all daemons, but for now
	* this allows each to do its own authorization.
	*
	* \param[in] api IPC API connection
	*
	* \return Standard Pacemaker return code
	*/
	int (post_connect)(pcmk_ipc_api_t api);

	/*!
	* \internal
	* \brief Check whether an IPC request results in a reply
	*
	* \parma[in] api IPC API connection
	* \param[in] request IPC request XML
	*
	* \return true if request would result in an IPC reply, false otherwise
	*/
	bool (reply_expected)(pcmk_ipc_api_t api, xmlNode *request);

	/*!
	* \internal
	* \brief Perform daemon-specific handling of an IPC message
	*
	* \param[in] api IPC API connection
	* \param[in] msg Message read from IPC connection
	*/
	void (dispatch)(pcmk_ipc_api_t api, xmlNode *msg);

	/*!
	* \internal
	* \brief Perform daemon-specific handling of an IPC disconnect
	*
	* \param[in] api IPC API connection
	*/
	void (post_disconnect)(pcmk_ipc_api_t api);
	} pcmk__ipc_methods_t;

	// Implementation of pcmk_ipc_api_t
	struct pcmk_ipc_api_s {
	enum pcmk_ipc_server server; // Daemon this IPC API instance is for
	enum pcmk_ipc_dispatch dispatch_type; // How replies should be dispatched
	size_t ipc_size_max; // maximum IPC buffer size
	crm_ipc_t *ipc; // IPC connection
	mainloop_io_t *mainloop_io; // If using mainloop, I/O source for IPC
	bool free_on_disconnect; // Whether disconnect should free object
	pcmk_ipc_callback_t cb; // Caller-registered callback (if any)
	void *user_data; // Caller-registered data (if any)
	void *api_data; // For daemon-specific use
	pcmk__ipc_methods_t *cmds; // Behavior that varies by daemon
	};

	typedef struct pcmk__ipc_header_s {
	struct qb_ipc_response_header qb;
	uint32_t size_uncompressed;
	uint32_t size_compressed;
	uint32_t flags;
	uint8_t version;
	} pcmk__ipc_header_t;

	G_GNUC_INTERNAL
	int pcmk__send_ipc_request(pcmk_ipc_api_t api, xmlNode request);

	G_GNUC_INTERNAL
	void pcmk__call_ipc_callback(pcmk_ipc_api_t *api,
	enum pcmk_ipc_event event_type,
	crm_exit_t status, void *event_data);

	G_GNUC_INTERNAL
	unsigned int pcmk__ipc_buffer_size(unsigned int max);

	G_GNUC_INTERNAL
	bool pcmk__valid_ipc_header(const pcmk__ipc_header_t *header);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__controld_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__pacemakerd_api_methods(void);


	/*
	* Logging
	*/

	/* This says whether the current application is a Pacemaker daemon or not,
	* and is used to change default logging settings such as whether to log to
	* stderr, etc., as well as a few other details such as whether blackbox signal
	* handling is enabled.
	*
	* It is set when logging is initialized, and does not need to be set directly.
	*/
	G_GNUC_INTERNAL
	extern bool pcmk__is_daemon;

	#endif // CRMCOMMON_PRIVATE__H
	diff --git a/lib/common/digest.c b/lib/common/digest.c
	index ef4d902197..711c25dca6 100644
	--- a/lib/common/digest.c
	+++ b/lib/common/digest.c
	@@ -1,238 +1,267 @@
	/*
	* Copyright 2015-2020 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 <unistd.h>
	#include <string.h>
	#include <stdlib.h>

	#include <crm/crm.h>
	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	+#include "crmcommon_private.h"

	#define BEST_EFFORT_STATUS 0

	/*!
	* \brief Dump XML in a format used with v1 digests
	*
	* \param[in] an_xml_node Root of XML to dump
	*
	* \return Newly allocated buffer containing dumped XML
	*/
	static char *
	dump_xml_for_digest(xmlNode * an_xml_node)
	{
	char *buffer = NULL;
	int offset = 0, max = 0;

	/* for compatibility with the old result which is used for v1 digests */
	- crm_buffer_add_char(&buffer, &offset, &max, ' ');
	- crm_xml_dump(an_xml_node, 0, &buffer, &offset, &max, 0);
	- crm_buffer_add_char(&buffer, &offset, &max, '\n');
	+ pcmk__buffer_add_char(&buffer, &offset, &max, ' ');
	+ pcmk__xml2text(an_xml_node, 0, &buffer, &offset, &max, 0);
	+ pcmk__buffer_add_char(&buffer, &offset, &max, '\n');

	return buffer;
	}

	/*!
	* \brief Calculate and return v1 digest of XML tree
	*
	* \param[in] input Root of XML to digest
	* \param[in] sort Whether to sort the XML before calculating digest
	* \param[in] ignored Not used
	*
	* \return Newly allocated string containing digest
	* \note Example return value: "c048eae664dba840e1d2060f00299e9d"
	*/
	static char *
	calculate_xml_digest_v1(xmlNode * input, gboolean sort, gboolean ignored)
	{
	char *digest = NULL;
	char *buffer = NULL;
	xmlNode *copy = NULL;

	if (sort) {
	crm_trace("Sorting xml...");
	copy = sorted_xml(input, NULL, TRUE);
	crm_trace("Done");
	input = copy;
	}

	buffer = dump_xml_for_digest(input);
	CRM_CHECK(buffer != NULL && strlen(buffer) > 0, free_xml(copy);
	free(buffer);
	return NULL);

	digest = crm_md5sum(buffer);
	crm_log_xml_trace(input, "digest:source");

	free(buffer);
	free_xml(copy);
	return digest;
	}

	/*!
	* \brief Calculate and return v2 digest of XML tree
	*
	* \param[in] source Root of XML to digest
	* \param[in] do_filter Whether to filter certain XML attributes
	*
	* \return Newly allocated string containing digest
	*/
	static char *
	calculate_xml_digest_v2(xmlNode * source, gboolean do_filter)
	{
	char *digest = NULL;
	char *buffer = NULL;
	int offset, max;

	static struct qb_log_callsite *digest_cs = NULL;

	crm_trace("Begin digest %s", do_filter?"filtered":"");
	if (do_filter && BEST_EFFORT_STATUS) {
	/* Exclude the status calculation from the digest
	*
	* This doesn't mean it won't be sync'd, we just won't be paranoid
	* about it being an _exact_ copy
	*
	* We don't need it to be exact, since we throw it away and regenerate
	* from our peers whenever a new DC is elected anyway
	*
	* Importantly, this reduces the amount of XML to copy+export as
	* well as the amount of data for MD5 needs to operate on
	*/

	} else {
	- crm_xml_dump(source, do_filter ? xml_log_option_filtered : 0, &buffer, &offset, &max, 0);
	+ pcmk__xml2text(source, (do_filter? xml_log_option_filtered : 0),
	+ &buffer, &offset, &max, 0);
	}

	CRM_ASSERT(buffer != NULL);
	digest = crm_md5sum(buffer);

	if (digest_cs == NULL) {
	digest_cs = qb_log_callsite_get(__func__, __FILE__, "cib-digest", LOG_TRACE, __LINE__,
	crm_trace_nonlog);
	}
	if (digest_cs && digest_cs->targets) {
	char *trace_file = crm_strdup_printf("%s/digest-%s",
	pcmk__get_tmpdir(), digest);

	crm_trace("Saving %s.%s.%s to %s",
	crm_element_value(source, XML_ATTR_GENERATION_ADMIN),
	crm_element_value(source, XML_ATTR_GENERATION),
	crm_element_value(source, XML_ATTR_NUMUPDATES), trace_file);
	save_xml_to_file(source, "digest input", trace_file);
	free(trace_file);
	}

	free(buffer);
	crm_trace("End digest");
	return digest;
	}

	/*!
	* \brief Calculate and return digest of XML tree, suitable for storing on disk
	*
	* \param[in] input Root of XML to digest
	*
	* \return Newly allocated string containing digest
	*/
	char *
	calculate_on_disk_digest(xmlNode * input)
	{
	/* Always use the v1 format for on-disk digests
	* a) it's a compatibility nightmare
	* b) we only use this once at startup, all other
	* invocations are in a separate child process
	*/
	return calculate_xml_digest_v1(input, FALSE, FALSE);
	}

	/*!
	* \brief Calculate and return digest of XML operation
	*
	* \param[in] input Root of XML to digest
	* \param[in] version Not used
	*
	* \return Newly allocated string containing digest
	*/
	char *
	calculate_operation_digest(xmlNode input, const char version)
	{
	/* We still need the sorting for operation digests */
	return calculate_xml_digest_v1(input, TRUE, FALSE);
	}

	/*!
	* \brief Calculate and return digest of XML tree
	*
	* \param[in] input Root of XML to digest
	* \param[in] sort Whether to sort XML before calculating digest
	* \param[in] do_filter Whether to filter certain XML attributes
	* \param[in] version CRM feature set version (used to select v1/v2 digest)
	*
	* \return Newly allocated string containing digest
	*/
	char *
	calculate_xml_versioned_digest(xmlNode * input, gboolean sort, gboolean do_filter,
	const char *version)
	{
	/*
	* @COMPAT digests (on-disk or in diffs/patchsets) created <1.1.4;
	* removing this affects even full-restart upgrades from old versions
	*
	* The sorting associated with v1 digest creation accounted for 23% of
	* the CIB manager's CPU usage on the server. v2 drops this.
	*
	* The filtering accounts for an additional 2.5% and we may want to
	* remove it in future.
	*
	* v2 also uses the xmlBuffer contents directly to avoid additional copying
	*/
	if (version == NULL \|\| compare_version("3.0.5", version) > 0) {
	crm_trace("Using v1 digest algorithm for %s", crm_str(version));
	return calculate_xml_digest_v1(input, sort, do_filter);
	}
	crm_trace("Using v2 digest algorithm for %s", crm_str(version));
	return calculate_xml_digest_v2(input, do_filter);
	}

	/*!
	* \internal
	* \brief Check whether calculated digest of given XML matches expected digest
	*
	* \param[in] input Root of XML tree to digest
	* \param[in] expected Expected digest in on-disk format
	*
	* \return true if digests match, false on mismatch or error
	*/
	bool
	pcmk__verify_digest(xmlNode input, const char expected)
	{
	char *calculated = NULL;
	bool passed;

	if (input != NULL) {
	calculated = calculate_on_disk_digest(input);
	if (calculated == NULL) {
	crm_perror(LOG_ERR, "Could not calculate digest for comparison");
	return false;
	}
	}
	passed = pcmk__str_eq(expected, calculated, pcmk__str_casei);
	if (passed) {
	crm_trace("Digest comparison passed: %s", calculated);
	} else {
	crm_err("Digest comparison failed: expected %s, calculated %s",
	expected, calculated);
	}
	free(calculated);
	return passed;
	}
	+
	+/*!
	+ * \internal
	+ * \brief Check whether an XML attribute should be excluded from CIB digests
	+ *
	+ * \param[in] name XML attribute name
	+ *
	+ * \return true if XML attribute should be excluded from CIB digest calculation
	+ */
	+bool
	+pcmk__xa_filterable(const char *name)
	+{
	+ static const char *filter[] = {
	+ XML_ATTR_ORIGIN,
	+ XML_CIB_ATTR_WRITTEN,
	+ XML_ATTR_UPDATE_ORIG,
	+ XML_ATTR_UPDATE_CLIENT,
	+ XML_ATTR_UPDATE_USER,
	+ };
	+
	+ for (int i = 0; i < DIMOF(filter); i++) {
	+ if (strcmp(name, filter[i]) == 0) {
	+ return true;
	+ }
	+ }
	+ return false;
	+}
	diff --git a/lib/common/schemas.c b/lib/common/schemas.c
	index db1a7d9678..1c88ea16ca 100644
	--- a/lib/common/schemas.c
	+++ b/lib/common/schemas.c
	@@ -1,1302 +1,1302 @@
	/*
	* Copyright 2004-2020 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>

	#if HAVE_LIBXSLT
	# include <libxslt/xslt.h>
	# include <libxslt/transform.h>
	# include <libxslt/security.h>
	# include <libxslt/xsltutils.h>
	#endif

	#include <crm/msg_xml.h>
	#include <crm/common/xml.h>
	-#include <crm/common/xml_internal.h> /* CRM_XML_LOG_BASE */
	+#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 bool silent_logging = FALSE;

	static void
	xml_log(int priority, const char *fmt, ...)
	G_GNUC_PRINTF(2, 3);

	static void
	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? */
	- CRM_XML_LOG_BASE(priority, FALSE, 0, NULL, fmt, ap);
	+ PCMK__XML_LOG_BASE(priority, FALSE, 0, NULL, fmt, ap);
	}
	va_end(ap);
	}

	static int
	xml_latest_schema_index(void)
	{
	return xml_schema_max - 3; // index from 0, ignore "pacemaker-next"/"none"
	}

	static int
	xml_minimum_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;
	}
	}
	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);
	}

	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)
	{
	int last = xml_schema_max;
	bool have_version = FALSE;

	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;

	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, "");
	} else {
	CRM_ASSERT(name);
	schema_scanf(name, "%*[^-]-", known_schemas[last].version, "");
	known_schemas[last].name = strdup(name);
	}

	if (transform) {
	known_schemas[last].transform = strdup(transform);
	}
	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 */
	}
	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);

	} 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);

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

	/*!
	* \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)
	{
	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);

	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)
	== ENOENT) {
	break;
	}
	}

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

	add_schema(schema_validator_rng, &zero, "pacemaker-next",
	NULL, NULL, FALSE, -1);

	add_schema(schema_validator_none, &zero, "none", NULL, NULL, FALSE, -1);
	}

	#if 0
	static void
	relaxng_invalid_stderr(void *userData, xmlErrorPtr error)
	{
	/*
	Structure xmlError
	struct _xmlError {
	int domain : What part of the library raised this er
	int code : The error code, e.g. an xmlParserError
	char * message : human-readable informative error messag
	xmlErrorLevel level : how consequent is the error
	char * file : the filename
	int line : the line number if available
	char * str1 : extra string information
	char * str2 : extra string information
	char * str3 : extra string information
	int int1 : extra number information
	int int2 : column number of the error or 0 if N/A
	void * ctxt : the parser context if available
	void * node : the node in the tree
	}
	*/
	crm_err("Structured error: line=%d, level=%d %s", error->line, error->level, error->message);
	}
	#endif

	static gboolean
	validate_with_relaxng(xmlDocPtr doc, gboolean to_logs, 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 (to_logs) {
	xmlRelaxNGSetParserErrors(ctx->parser,
	(xmlRelaxNGValidityErrorFunc) xml_log,
	(xmlRelaxNGValidityWarningFunc) xml_log,
	GUINT_TO_POINTER(LOG_ERR));
	} 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 (to_logs) {
	xmlRelaxNGSetValidErrors(ctx->valid,
	(xmlRelaxNGValidityErrorFunc) xml_log,
	(xmlRelaxNGValidityWarningFunc) xml_log,
	GUINT_TO_POINTER(LOG_ERR));
	} else {
	xmlRelaxNGSetValidErrors(ctx->valid,
	(xmlRelaxNGValidityErrorFunc) fprintf,
	(xmlRelaxNGValidityWarningFunc) fprintf,
	stderr);
	}
	}

	/* xmlRelaxNGSetValidStructuredErrors( */
	/* valid, relaxng_invalid_stderr, valid); */

	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;
	}

	/*!
	* \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);
	known_schemas = NULL;

	wrap_libxslt(true);
	}

	static gboolean
	validate_with(xmlNode *xml, int method, gboolean to_logs)
	{
	xmlDocPtr doc = NULL;
	gboolean valid = FALSE;
	char *file = NULL;

	if (method < 0) {
	return FALSE;
	}

	if (known_schemas[method].validator == schema_validator_none) {
	return TRUE;
	}

	CRM_CHECK(xml != NULL, return FALSE);
	doc = getDocPtr(xml);
	file = pcmk__xml_artefact_path(pcmk__xml_artefact_ns_legacy_rng,
	known_schemas[method].name);

	crm_trace("Validating with: %s (type=%d)",
	crm_str(file), known_schemas[method].validator);
	switch (known_schemas[method].validator) {
	case schema_validator_rng:
	valid =
	validate_with_relaxng(doc, to_logs, file,
	(relaxng_ctx_cache_t **) & (known_schemas[method].cache));
	break;
	default:
	crm_err("Unknown validator type: %d",
	known_schemas[method].validator);
	break;
	}

	free(file);
	return valid;
	}

	static bool
	validate_with_silent(xmlNode *xml, int method)
	{
	bool rc, sl_backup = silent_logging;
	silent_logging = TRUE;
	rc = validate_with(xml, method, TRUE);
	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(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)
	{
	int version = 0;

	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, FALSE)) {
	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;
	}
	}
	}

	return valid;
	}

	version = get_schema_version(validation);
	if (strcmp(validation, "none") == 0) {
	return TRUE;
	} else if (version < xml_schema_max) {
	return validate_with(xml_blob, version, to_logs);
	}

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

	#if HAVE_LIBXSLT

	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
	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 {
	- CRM_XML_LOG_BASE(msg_log_level, TRUE, 0, "CIB upgrade: ", fmt, ap);
	+ PCMK__XML_LOG_BASE(msg_log_level, TRUE, 0, "CIB upgrade: ", fmt, ap);
	}

	va_end(aq);
	va_end(ap);
	}


	/* Denotes temporary emergency fix for "xmldiff'ing not text-node-ready";
	proper fix is most likely to teach __xml_diff_object and friends to
	deal with XML_TEXT_NODE (and more?), i.e., those nodes currently
	missing "_private" field (implicitly as NULL) which clashes with
	unchecked accesses (e.g. in __xml_offset) -- the outcome may be that
	those unexpected XML nodes will simply be ignored for the purpose of
	diff'ing, or it may be made more robust, or per the user's preference
	(which then may be exposed as crm_diff switch).

	Said XML_TEXT_NODE may appear unexpectedly due to how upgrade-2.10.xsl
	is arranged.

	The emergency fix is simple: reparse XSLT output with blank-ignoring
	parser. */
	#ifndef PCMK_SCHEMAS_EMERGENCY_XSLT
	#define PCMK_SCHEMAS_EMERGENCY_XSLT 1
	#endif

	static xmlNode *
	apply_transformation(xmlNode xml, const char transform, gboolean to_logs)
	{
	char *xform = NULL;
	xmlNode *out = NULL;
	xmlDocPtr res = NULL;
	xmlDocPtr doc = NULL;
	xsltStylesheet *xslt = NULL;
	#if PCMK_SCHEMAS_EMERGENCY_XSLT != 0
	xmlChar *emergency_result;
	int emergency_txt_len;
	int emergency_res;
	#endif

	CRM_CHECK(xml != NULL, return FALSE);
	doc = getDocPtr(xml);
	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, doc, NULL);
	CRM_CHECK(res != NULL, goto cleanup);

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


	#if PCMK_SCHEMAS_EMERGENCY_XSLT != 0
	emergency_res = xsltSaveResultToString(&emergency_result,
	&emergency_txt_len, res, xslt);
	xmlFreeDoc(res);
	CRM_CHECK(emergency_res == 0, goto cleanup);
	out = string2xml((const char *) emergency_result);
	free(emergency_result);
	#else
	out = xmlDocGetRootElement(res);
	#endif

	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;
	}

	#endif /* HAVE_LIBXSLT */

	const char *
	get_schema_name(int version)
	{
	if (version < 0 \|\| version >= xml_schema_max) {
	return "unknown";
	}
	return known_schemas[version].name;
	}

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

	if (name == NULL) {
	name = "none";
	}
	for (; lpc < xml_schema_max; lpc++) {
	if (pcmk__str_eq(name, known_schemas[lpc].name, pcmk__str_casei)) {
	return 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 */

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

	CRM_CHECK(xml_blob != NULL, return -EINVAL);
	CRM_CHECK(*xml_blob != 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) {
	crm_debug("Testing '%s' validation (%d of %d)",
	known_schemas[lpc].name ? known_schemas[lpc].name : "<unset>",
	lpc, max_stable_schemas);

	if (validate_with(xml, lpc, to_logs) == FALSE) {
	if (next != -1) {
	crm_info("Configuration not valid for schema: %s",
	known_schemas[lpc].name);
	next = -1;
	} else {
	crm_trace("%s validation failed",
	known_schemas[lpc].name ? known_schemas[lpc].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);
	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;

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

	} else 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);
	break;

	} else if (known_schemas[lpc].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)) {
	crm_debug("%s-style configuration is also valid for %s",
	known_schemas[lpc].name, known_schemas[next].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);

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

	} else if (validate_with(upgrade, next, to_logs)) {
	crm_info("Transformation %s.xsl successful",
	known_schemas[lpc].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);
	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) {
	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);
	}

	*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();

	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),
	crm_str(value));
	} 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),
	crm_str(value));
	}
	}

	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("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;
	}
	diff --git a/lib/common/xml.c b/lib/common/xml.c
	index 6b4cacabcf..f7fb1a3d75 100644
	--- a/lib/common/xml.c
	+++ b/lib/common/xml.c
	@@ -1,4529 +1,4598 @@
	/*
	* Copyright 2004-2020 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 <sys/types.h>
	#include <unistd.h>
	#include <time.h>
	#include <string.h>
	#include <stdlib.h>
	#include <stdarg.h>
	#include <bzlib.h>

	#include <libxml/parser.h>
	#include <libxml/tree.h>
	#include <libxml/xmlIO.h> /* xmlAllocOutputBuffer */

	#include <crm/crm.h>
	#include <crm/msg_xml.h>
	#include <crm/common/iso8601_internal.h>
	#include <crm/common/xml.h>
	-#include <crm/common/xml_internal.h> /* CRM_XML_LOG_BASE */
	+#include <crm/common/xml_internal.h> // PCMK__XML_LOG_BASE, etc.
	#include "crmcommon_private.h"

	#define XML_BUFFER_SIZE 4096
	#define XML_PARSER_DEBUG 0

	/* @TODO XML_PARSE_RECOVER allows some XML errors to be silently worked around
	* by libxml2, which is potentially ambiguous and dangerous. We should drop it
	* when we can break backward compatibility with configurations that might be
	* relying on it (i.e. pacemaker 3.0.0).
	*
	* It might be a good idea to have a transitional period where we first try
	* parsing without XML_PARSE_RECOVER, and if that fails, try parsing again with
	* it, logging a warning if it succeeds.
	*/
	#define PCMK__XML_PARSE_OPTS (XML_PARSE_NOBLANKS \| XML_PARSE_RECOVER)

	-typedef struct {
	- int found;
	- const char *string;
	-} filter_t;
	-
	typedef struct xml_deleted_obj_s {
	char *path;
	int position;
	} xml_deleted_obj_t;

	-/* INDENT-OFF */
	-
	-static filter_t filter[] = {
	- { 0, XML_ATTR_ORIGIN },
	- { 0, XML_CIB_ATTR_WRITTEN },
	- { 0, XML_ATTR_UPDATE_ORIG },
	- { 0, XML_ATTR_UPDATE_CLIENT },
	- { 0, XML_ATTR_UPDATE_USER },
	-};
	-/* INDENT-ON */

	static xmlNode subtract_xml_comment(xmlNode parent, xmlNode * left, xmlNode * right, gboolean * changed);
	static xmlNode find_xml_comment(xmlNode root, xmlNode * search_comment, gboolean exact);
	-static int add_xml_comment(xmlNode * parent, xmlNode * target, xmlNode * update);
	+static void add_xml_comment(xmlNode parent, xmlNode target, xmlNode *update);

	#define CHUNK_SIZE 1024

	bool
	pcmk__tracking_xml_changes(xmlNode *xml, bool lazy)
	{
	if(xml == NULL \|\| xml->doc == NULL \|\| xml->doc->_private == NULL) {
	return FALSE;
	} else if (!pcmk_is_set(((xml_private_t *)xml->doc->_private)->flags,
	xpf_tracking)) {
	return FALSE;
	} else if (lazy && !pcmk_is_set(((xml_private_t *)xml->doc->_private)->flags,
	xpf_lazy)) {
	return FALSE;
	}
	return TRUE;
	}

	#define buffer_print(buffer, max, offset, fmt, args...) do { \
	int rc = (max); \
	if(buffer) { \
	rc = snprintf((buffer) + (offset), (max) - (offset), fmt, ##args); \
	} \
	if(buffer && rc < 0) { \
	crm_perror(LOG_ERR, "snprintf failed at offset %d", offset); \
	(buffer)[(offset)] = 0; \
	break; \
	} else if(rc >= ((max) - (offset))) { \
	char *tmp = NULL; \
	(max) = QB_MAX(CHUNK_SIZE, (max) * 2); \
	tmp = pcmk__realloc((buffer), (max)); \
	CRM_ASSERT(tmp); \
	(buffer) = tmp; \
	} else { \
	offset += rc; \
	break; \
	} \
	} while(1);

	static void
	insert_prefix(int options, char *buffer, int offset, int *max, int depth)
	{
	if (options & xml_log_option_formatted) {
	size_t spaces = 2 * depth;

	if ((buffer) == NULL \|\| spaces >= ((max) - (*offset))) {
	(max) = QB_MAX(CHUNK_SIZE, (max) * 2);
	(buffer) = pcmk__realloc((buffer), (*max));
	}
	memset((buffer) + (offset), ' ', spaces);
	(*offset) += spaces;
	}
	}

	static void
	set_parent_flag(xmlNode *xml, long flag)
	{

	for(; xml; xml = xml->parent) {
	xml_private_t *p = xml->_private;

	if(p == NULL) {
	/* During calls to xmlDocCopyNode(), _private will be unset for parent nodes */
	} else {
	pcmk__set_xml_flags(p, flag);
	}
	}
	}

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

	if(xml && xml->doc && xml->doc->_private){
	/* During calls to xmlDocCopyNode(), xml->doc may be unset */
	xml_private_t *p = xml->doc->_private;

	pcmk__set_xml_flags(p, flag);
	}
	}

	+// Mark document, element, and all element's parents as changed
	static void
	-__xml_node_dirty(xmlNode *xml)
	+mark_xml_node_dirty(xmlNode *xml)
	{
	pcmk__set_xml_doc_flag(xml, xpf_dirty);
	set_parent_flag(xml, xpf_dirty);
	}

	+// Clear flags on XML node and its children
	static void
	-__xml_node_clean(xmlNode *xml)
	+reset_xml_node_flags(xmlNode *xml)
	{
	xmlNode *cIter = NULL;
	xml_private_t *p = xml->_private;

	- if(p) {
	+ if (p) {
	p->flags = 0;
	}

	for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) {
	- __xml_node_clean(cIter);
	+ reset_xml_node_flags(cIter);
	}
	}

	+// Set xpf_created flag on XML node and any children
	static void
	-crm_node_created(xmlNode *xml)
	+mark_xml_node_created(xmlNode *xml)
	{
	xmlNode *cIter = NULL;
	xml_private_t *p = xml->_private;

	- if(p && pcmk__tracking_xml_changes(xml, FALSE)) {
	+ if (p && pcmk__tracking_xml_changes(xml, FALSE)) {
	if (!pcmk_is_set(p->flags, xpf_created)) {
	pcmk__set_xml_flags(p, xpf_created);
	- __xml_node_dirty(xml);
	+ mark_xml_node_dirty(xml);
	}
	-
	for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) {
	- crm_node_created(cIter);
	+ mark_xml_node_created(cIter);
	}
	}
	}

	void
	pcmk__mark_xml_attr_dirty(xmlAttr *a)
	{
	xmlNode *parent = a->parent;
	xml_private_t *p = NULL;

	p = a->_private;
	pcmk__set_xml_flags(p, xpf_dirty\|xpf_modified);
	pcmk__clear_xml_flags(p, xpf_deleted);
	- __xml_node_dirty(parent);
	+ mark_xml_node_dirty(parent);
	}

	-int get_tag_name(const char *input, size_t offset, size_t max);
	-int get_attr_name(const char *input, size_t offset, size_t max);
	-int get_attr_value(const char *input, size_t offset, size_t max);
	-gboolean can_prune_leaf(xmlNode * xml_node);
	-
	-static int add_xml_object(xmlNode * parent, xmlNode * target, xmlNode * update, gboolean as_diff);
	+static void add_xml_object(xmlNode parent, xmlNode target, xmlNode *update,
	+ bool as_diff);

	#define XML_PRIVATE_MAGIC (long) 0x81726354

	+// Free an XML object previously marked as deleted
	static void
	-__xml_deleted_obj_free(void *data)
	+free_deleted_object(void *data)
	{
	if(data) {
	xml_deleted_obj_t *deleted_obj = data;

	free(deleted_obj->path);
	free(deleted_obj);
	}
	}

	+// Free and NULL user, ACLs, and deleted objects in an XML node's private data
	static void
	-__xml_private_clean(xml_private_t *p)
	+reset_xml_private_data(xml_private_t *p)
	{
	if(p) {
	CRM_ASSERT(p->check == XML_PRIVATE_MAGIC);

	free(p->user);
	p->user = NULL;

	if(p->acls) {
	pcmk__free_acls(p->acls);
	p->acls = NULL;
	}

	if(p->deleted_objs) {
	- g_list_free_full(p->deleted_objs, __xml_deleted_obj_free);
	+ g_list_free_full(p->deleted_objs, free_deleted_object);
	p->deleted_objs = NULL;
	}
	}
	}

	-
	-static void
	-__xml_private_free(xml_private_t *p)
	-{
	- __xml_private_clean(p);
	- free(p);
	-}
	-
	+// Free all private data associated with an XML node
	static void
	-pcmkDeregisterNode(xmlNodePtr node)
	+free_private_data(xmlNode *node)
	{
	/* need to explicitly avoid our custom _private field cleanup when
	called from internal XSLT cleanup (xsltApplyStylesheetInternal
	-> xsltFreeTransformContext -> xsltFreeRVTs -> xmlFreeDoc)
	onto result tree fragments, represented as standalone documents
	with otherwise infeasible space-prefixed name (xsltInternals.h:
	XSLT_MARK_RES_TREE_FRAG) and carrying it's own load at _private
	field -- later assert on the XML_PRIVATE_MAGIC would explode */
	if (node->type != XML_DOCUMENT_NODE \|\| node->name == NULL
	\|\| node->name[0] != ' ') {
	- __xml_private_free(node->_private);
	+ reset_xml_private_data(node->_private);
	+ free(node->_private);
	}
	}

	+// Allocate and initialize private data for an XML node
	static void
	-pcmkRegisterNode(xmlNodePtr node)
	+new_private_data(xmlNode *node)
	{
	xml_private_t *p = NULL;

	switch(node->type) {
	case XML_ELEMENT_NODE:
	case XML_DOCUMENT_NODE:
	case XML_ATTRIBUTE_NODE:
	case XML_COMMENT_NODE:
	p = calloc(1, sizeof(xml_private_t));
	p->check = XML_PRIVATE_MAGIC;
	/* Flags will be reset if necessary when tracking is enabled */
	pcmk__set_xml_flags(p, xpf_dirty\|xpf_created);
	node->_private = p;
	break;
	case XML_TEXT_NODE:
	case XML_DTD_NODE:
	case XML_CDATA_SECTION_NODE:
	break;
	default:
	/* Ignore */
	crm_trace("Ignoring %p %d", node, node->type);
	CRM_LOG_ASSERT(node->type == XML_ELEMENT_NODE);
	break;
	}

	if(p && pcmk__tracking_xml_changes(node, FALSE)) {
	/* XML_ELEMENT_NODE doesn't get picked up here, node->doc is
	* not hooked up at the point we are called
	*/
	- __xml_node_dirty(node);
	+ mark_xml_node_dirty(node);
	}
	}

	void
	xml_track_changes(xmlNode * xml, const char user, xmlNode acl_source, bool enforce_acls)
	{
	xml_accept_changes(xml);
	crm_trace("Tracking changes%s to %p", enforce_acls?" with ACLs":"", xml);
	pcmk__set_xml_doc_flag(xml, xpf_tracking);
	if(enforce_acls) {
	if(acl_source == NULL) {
	acl_source = xml;
	}
	pcmk__set_xml_doc_flag(xml, xpf_acl_enabled);
	pcmk__unpack_acl(acl_source, xml, user);
	pcmk__apply_acl(xml);
	}
	}

	bool xml_tracking_changes(xmlNode * xml)
	{
	return (xml != NULL) && (xml->doc != NULL) && (xml->doc->_private != NULL)
	&& pcmk_is_set(((xml_private_t *)(xml->doc->_private))->flags,
	xpf_tracking);
	}

	bool xml_document_dirty(xmlNode *xml)
	{
	return (xml != NULL) && (xml->doc != NULL) && (xml->doc->_private != NULL)
	&& pcmk_is_set(((xml_private_t *)(xml->doc->_private))->flags,
	xpf_dirty);
	}

	/*
	<diff format="2.0">
	<version>
	<source admin_epoch="1" epoch="2" num_updates="3"/>
	<target admin_epoch="1" epoch="3" num_updates="0"/>
	</version>
	<change operation="add" xpath="/cib/configuration/nodes">
	<node id="node2" uname="node2" description="foo"/>
	</change>
	<change operation="add" xpath="/cib/configuration/nodes/node[node2]">
	<instance_attributes id="nodes-node"><!-- NOTE: can be a full tree -->
	<nvpair id="nodes-node2-ram" name="ram" value="1024M"/>
	</instance_attributes>
	</change>
	<change operation="update" xpath="/cib/configuration/nodes[@id='node2']">
	<change-list>
	<change-attr operation="set" name="type" value="member"/>
	<change-attr operation="unset" name="description"/>
	</change-list>
	<change-result>
	<node id="node2" uname="node2" type="member"/><!-- NOTE: not recursive -->
	</change-result>
	</change>
	<change operation="delete" xpath="/cib/configuration/nodes/node[@id='node3'] /">
	<change operation="update" xpath="/cib/configuration/resources/group[@id='g1']">
	<change-list>
	<change-attr operation="set" name="description" value="some garbage here"/>
	</change-list>
	<change-result>
	<group id="g1" description="some garbage here"/><!-- NOTE: not recursive -->
	</change-result>
	</change>
	<change operation="update" xpath="/cib/status/node_state[@id='node2]/lrm[@id='node2']/lrm_resources/lrm_resource[@id='Fence']">
	<change-list>
	<change-attr operation="set" name="oper" value="member"/>
	<change-attr operation="set" name="operation_key" value="Fence_start_0"/>
	<change-attr operation="set" name="operation" value="start"/>
	<change-attr operation="set" name="transition-key" value="2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"/>
	<change-attr operation="set" name="transition-magic" value="0:0;2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"/>
	<change-attr operation="set" name="call-id" value="2"/>
	<change-attr operation="set" name="rc-code" value="0"/>
	</change-list>
	<change-result>
	<lrm_rsc_op id="Fence_last_0" operation_key="Fence_start_0" operation="start" crm-debug-origin="crm_simulate" transition-key="2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" transition-magic="0:0;2:-1:0:xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx" call-id="2" rc-code="0" op-status="0" interval="0" exec-time="0" queue-time="0" op-digest="f2317cad3d54cec5d7d7aa7d0bf35cf8"/>
	</change-result>
	</change>
	</diff>
	*/
	-static int __xml_offset(xmlNode *xml)
	-{
	- int position = 0;
	- xmlNode *cIter = NULL;
	-
	- for(cIter = xml; cIter->prev; cIter = cIter->prev) {
	- xml_private_t p = ((xmlNode)cIter->prev)->_private;

	- if (!pcmk_is_set(p->flags, xpf_skip)) {
	- position++;
	- }
	- }
	-
	- return position;
	-}
	-
	-static int __xml_offset_no_deletions(xmlNode *xml)
	+/*!
	+ * \internal
	+ * \brief Return ordinal position of an XML node among its siblings
	+ *
	+ * \param[in] xml XML node to check
	+ * \param[in] ignore_if_set Don't count siblings with this flag set
	+ *
	+ * \return Ordinal position of \p xml (starting with 0)
	+ */
	+static int
	+position_within_parent(xmlNode *xml, enum xml_private_flags ignore_if_set)
	{
	int position = 0;
	xmlNode *cIter = NULL;

	for(cIter = xml; cIter->prev; cIter = cIter->prev) {
	xml_private_t p = ((xmlNode)cIter->prev)->_private;

	- if (!pcmk_is_set(p->flags, xpf_deleted)) {
	+ if (!pcmk_is_set(p->flags, ignore_if_set)) {
	position++;
	}
	}

	return position;
	}

	+// Add changes for specified XML to patchset
	static void
	-__xml_build_changes(xmlNode * xml, xmlNode *patchset)
	+add_xml_changes_to_patchset(xmlNode xml, xmlNode patchset)
	{
	xmlNode *cIter = NULL;
	xmlAttr *pIter = NULL;
	xmlNode *change = NULL;
	xml_private_t *p = xml->_private;

	+ // If this XML node is new, just report that
	if (patchset && pcmk_is_set(p->flags, xpf_created)) {
	int offset = 0;
	char buffer[XML_BUFFER_SIZE];

	if (pcmk__element_xpath(NULL, xml->parent, buffer, offset,
	sizeof(buffer)) > 0) {
	- int position = __xml_offset_no_deletions(xml);
	+ int position = position_within_parent(xml, xpf_deleted);

	change = create_xml_node(patchset, XML_DIFF_CHANGE);

	crm_xml_add(change, XML_DIFF_OP, "create");
	crm_xml_add(change, XML_DIFF_PATH, buffer);
	crm_xml_add_int(change, XML_DIFF_POSITION, position);
	add_node_copy(change, xml);
	}

	return;
	}

	+ // Check each of the XML node's attributes for changes
	for (pIter = pcmk__first_xml_attr(xml); pIter != NULL; pIter = pIter->next) {
	xmlNode *attr = NULL;

	p = pIter->_private;
	if (!pcmk_any_flags_set(p->flags, xpf_deleted\|xpf_dirty)) {
	continue;
	}

	if(change == NULL) {
	int offset = 0;
	char buffer[XML_BUFFER_SIZE];

	if (pcmk__element_xpath(NULL, xml, buffer, offset,
	sizeof(buffer)) > 0) {
	change = create_xml_node(patchset, XML_DIFF_CHANGE);

	crm_xml_add(change, XML_DIFF_OP, "modify");
	crm_xml_add(change, XML_DIFF_PATH, buffer);

	change = create_xml_node(change, XML_DIFF_LIST);
	}
	}

	attr = create_xml_node(change, XML_DIFF_ATTR);

	crm_xml_add(attr, XML_NVPAIR_ATTR_NAME, (const char *)pIter->name);
	if(p->flags & xpf_deleted) {
	crm_xml_add(attr, XML_DIFF_OP, "unset");

	} else {
	const char value = crm_element_value(xml, (const char )pIter->name);

	crm_xml_add(attr, XML_DIFF_OP, "set");
	crm_xml_add(attr, XML_NVPAIR_ATTR_VALUE, value);
	}
	}

	if(change) {
	xmlNode *result = NULL;

	change = create_xml_node(change->parent, XML_DIFF_RESULT);
	result = create_xml_node(change, (const char *)xml->name);

	for (pIter = pcmk__first_xml_attr(xml); pIter != NULL; pIter = pIter->next) {
	const char value = crm_element_value(xml, (const char )pIter->name);

	p = pIter->_private;
	if (!pcmk_is_set(p->flags, xpf_deleted)) {
	crm_xml_add(result, (const char *)pIter->name, value);
	}
	}
	}

	+ // Now recursively do the same for each child node of this node
	for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) {
	- __xml_build_changes(cIter, patchset);
	+ add_xml_changes_to_patchset(cIter, patchset);
	}

	p = xml->_private;
	if (patchset && pcmk_is_set(p->flags, xpf_moved)) {
	int offset = 0;
	char buffer[XML_BUFFER_SIZE];

	- crm_trace("%s.%s moved to position %d", xml->name, ID(xml), __xml_offset(xml));
	+ crm_trace("%s.%s moved to position %d",
	+ xml->name, ID(xml), position_within_parent(xml, xpf_skip));
	if (pcmk__element_xpath(NULL, xml, buffer, offset,
	sizeof(buffer)) > 0) {
	change = create_xml_node(patchset, XML_DIFF_CHANGE);

	crm_xml_add(change, XML_DIFF_OP, "move");
	crm_xml_add(change, XML_DIFF_PATH, buffer);
	- crm_xml_add_int(change, XML_DIFF_POSITION, __xml_offset_no_deletions(xml));
	+ crm_xml_add_int(change, XML_DIFF_POSITION,
	+ position_within_parent(xml, xpf_deleted));
	}
	}
	}

	+// Remove all attributes marked as deleted from an XML node
	static void
	-__xml_accept_changes(xmlNode * xml)
	+accept_attr_deletions(xmlNode *xml)
	{
	xmlNode *cIter = NULL;
	xmlAttr *pIter = NULL;
	xml_private_t *p = xml->_private;

	p->flags = xpf_none;
	pIter = pcmk__first_xml_attr(xml);

	while (pIter != NULL) {
	const xmlChar *name = pIter->name;

	p = pIter->_private;
	pIter = pIter->next;

	if(p->flags & xpf_deleted) {
	xml_remove_prop(xml, (const char *)name);

	} else {
	p->flags = xpf_none;
	}
	}

	for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) {
	- __xml_accept_changes(cIter);
	+ accept_attr_deletions(cIter);
	}
	}

	static bool
	is_config_change(xmlNode *xml)
	{
	GListPtr gIter = NULL;
	xml_private_t *p = NULL;
	xmlNode *config = first_named_child(xml, XML_CIB_TAG_CONFIGURATION);

	if(config) {
	p = config->_private;
	}
	if (p && pcmk_is_set(p->flags, xpf_dirty)) {
	return TRUE;
	}

	if(xml->doc && xml->doc->_private) {
	p = xml->doc->_private;
	for(gIter = p->deleted_objs; gIter; gIter = gIter->next) {
	xml_deleted_obj_t *deleted_obj = gIter->data;

	if(strstr(deleted_obj->path, "/"XML_TAG_CIB"/"XML_CIB_TAG_CONFIGURATION) != NULL) {
	return TRUE;
	}
	}
	}

	return FALSE;
	}

	static void
	xml_repair_v1_diff(xmlNode * last, xmlNode * next, xmlNode * local_diff, gboolean changed)
	{
	int lpc = 0;
	xmlNode *cib = NULL;
	xmlNode *diff_child = NULL;

	const char *tag = NULL;

	const char *vfields[] = {
	XML_ATTR_GENERATION_ADMIN,
	XML_ATTR_GENERATION,
	XML_ATTR_NUMUPDATES,
	};

	if (local_diff == NULL) {
	crm_trace("Nothing to do");
	return;
	}

	tag = "diff-removed";
	diff_child = find_xml_node(local_diff, tag, FALSE);
	if (diff_child == NULL) {
	diff_child = create_xml_node(local_diff, tag);
	}

	tag = XML_TAG_CIB;
	cib = find_xml_node(diff_child, tag, FALSE);
	if (cib == NULL) {
	cib = create_xml_node(diff_child, tag);
	}

	for(lpc = 0; last && lpc < DIMOF(vfields); lpc++){
	const char *value = crm_element_value(last, vfields[lpc]);

	crm_xml_add(diff_child, vfields[lpc], value);
	if(changed \|\| lpc == 2) {
	crm_xml_add(cib, vfields[lpc], value);
	}
	}

	tag = "diff-added";
	diff_child = find_xml_node(local_diff, tag, FALSE);
	if (diff_child == NULL) {
	diff_child = create_xml_node(local_diff, tag);
	}

	tag = XML_TAG_CIB;
	cib = find_xml_node(diff_child, tag, FALSE);
	if (cib == NULL) {
	cib = create_xml_node(diff_child, tag);
	}

	for(lpc = 0; next && lpc < DIMOF(vfields); lpc++){
	const char *value = crm_element_value(next, vfields[lpc]);

	crm_xml_add(diff_child, vfields[lpc], value);
	}

	if (next) {
	xmlAttrPtr xIter = NULL;

	for (xIter = next->properties; xIter; xIter = xIter->next) {
	const char p_name = (const char )xIter->name;
	const char *p_value = crm_element_value(next, p_name);

	xmlSetProp(cib, (pcmkXmlStr) p_name, (pcmkXmlStr) p_value);
	}
	}

	crm_log_xml_explicit(local_diff, "Repaired-diff");
	}

	static xmlNode *
	xml_create_patchset_v1(xmlNode source, xmlNode target, bool config, bool suppress)
	{
	xmlNode *patchset = diff_xml_object(source, target, suppress);

	if(patchset) {
	CRM_LOG_ASSERT(xml_document_dirty(target));
	xml_repair_v1_diff(source, target, patchset, config);
	crm_xml_add(patchset, "format", "1");
	}
	return patchset;
	}

	static xmlNode *
	xml_create_patchset_v2(xmlNode source, xmlNode target)
	{
	int lpc = 0;
	GListPtr gIter = NULL;
	xml_private_t *doc = NULL;

	xmlNode *v = NULL;
	xmlNode *version = NULL;
	xmlNode *patchset = NULL;
	const char *vfields[] = {
	XML_ATTR_GENERATION_ADMIN,
	XML_ATTR_GENERATION,
	XML_ATTR_NUMUPDATES,
	};

	CRM_ASSERT(target);
	if(xml_document_dirty(target) == FALSE) {
	return NULL;
	}

	CRM_ASSERT(target->doc);
	doc = target->doc->_private;

	patchset = create_xml_node(NULL, XML_TAG_DIFF);
	crm_xml_add_int(patchset, "format", 2);

	version = create_xml_node(patchset, XML_DIFF_VERSION);

	v = create_xml_node(version, XML_DIFF_VSOURCE);
	for(lpc = 0; lpc < DIMOF(vfields); lpc++){
	const char *value = crm_element_value(source, vfields[lpc]);

	if(value == NULL) {
	value = "1";
	}
	crm_xml_add(v, vfields[lpc], value);
	}

	v = create_xml_node(version, XML_DIFF_VTARGET);
	for(lpc = 0; lpc < DIMOF(vfields); lpc++){
	const char *value = crm_element_value(target, vfields[lpc]);

	if(value == NULL) {
	value = "1";
	}
	crm_xml_add(v, vfields[lpc], value);
	}

	for(gIter = doc->deleted_objs; gIter; gIter = gIter->next) {
	xml_deleted_obj_t *deleted_obj = gIter->data;
	xmlNode *change = create_xml_node(patchset, XML_DIFF_CHANGE);

	crm_xml_add(change, XML_DIFF_OP, "delete");
	crm_xml_add(change, XML_DIFF_PATH, deleted_obj->path);
	if (deleted_obj->position >= 0) {
	crm_xml_add_int(change, XML_DIFF_POSITION, deleted_obj->position);
	}
	}

	- __xml_build_changes(target, patchset);
	+ add_xml_changes_to_patchset(target, patchset);
	return patchset;
	}

	xmlNode *
	xml_create_patchset(int format, xmlNode source, xmlNode target, bool *config_changed, bool manage_version)
	{
	int counter = 0;
	bool config = FALSE;
	xmlNode *patch = NULL;
	const char *version = crm_element_value(source, XML_ATTR_CRM_VERSION);

	xml_acl_disable(target);
	if(xml_document_dirty(target) == FALSE) {
	crm_trace("No change %d", format);
	return NULL; /* No change */
	}

	config = is_config_change(target);
	if(config_changed) {
	*config_changed = config;
	}

	if(manage_version && config) {
	crm_trace("Config changed %d", format);
	crm_xml_add(target, XML_ATTR_NUMUPDATES, "0");

	crm_element_value_int(target, XML_ATTR_GENERATION, &counter);
	crm_xml_add_int(target, XML_ATTR_GENERATION, counter+1);

	} else if(manage_version) {
	crm_element_value_int(target, XML_ATTR_NUMUPDATES, &counter);
	crm_trace("Status changed %d - %d %s", format, counter, crm_element_value(source, XML_ATTR_NUMUPDATES));
	crm_xml_add_int(target, XML_ATTR_NUMUPDATES, counter+1);
	}

	if(format == 0) {
	if (compare_version("3.0.8", version) < 0) {
	format = 2;

	} else {
	format = 1;
	}
	crm_trace("Using patch format %d for version: %s", format, version);
	}

	switch(format) {
	case 1:
	patch = xml_create_patchset_v1(source, target, config, FALSE);
	break;
	case 2:
	patch = xml_create_patchset_v2(source, target);
	break;
	default:
	crm_err("Unknown patch format: %d", format);
	return NULL;
	}

	return patch;
	}

	void
	patchset_process_digest(xmlNode patch, xmlNode source, xmlNode *target, bool with_digest)
	{
	int format = 1;
	const char *version = NULL;
	char *digest = NULL;

	if (patch == NULL \|\| source == NULL \|\| target == NULL) {
	return;
	}

	/* NOTE: We should always call xml_accept_changes() before calculating digest. */
	/* Otherwise, with an on-tracking dirty target, we could get a wrong digest. */
	CRM_LOG_ASSERT(xml_document_dirty(target) == FALSE);

	crm_element_value_int(patch, "format", &format);
	if (format > 1 && with_digest == FALSE) {
	return;
	}

	version = crm_element_value(source, XML_ATTR_CRM_VERSION);
	digest = calculate_xml_versioned_digest(target, FALSE, TRUE, version);

	crm_xml_add(patch, XML_ATTR_DIGEST, digest);
	free(digest);

	return;
	}

	static void
	-__xml_log_element(int log_level, const char file, const char function, int line,
	- const char prefix, xmlNode data, int depth, int options);
	+log_xml_element(int log_level, const char file, const char function, int line,
	+ const char prefix, xmlNode data, int depth, int options);

	void
	xml_log_patchset(uint8_t log_level, const char function, xmlNode patchset)
	{
	int format = 1;
	xmlNode *child = NULL;
	xmlNode *added = NULL;
	xmlNode *removed = NULL;
	gboolean is_first = TRUE;

	int add[] = { 0, 0, 0 };
	int del[] = { 0, 0, 0 };

	const char *fmt = NULL;
	const char *digest = NULL;
	int options = xml_log_option_formatted;

	static struct qb_log_callsite *patchset_cs = NULL;

	if (log_level == LOG_NEVER) {
	return;
	}
	if (patchset_cs == NULL) {
	patchset_cs = qb_log_callsite_get(function, __FILE__, "xml-patchset", log_level, __LINE__, 0);
	}

	if (patchset == NULL) {
	crm_trace("Empty patch");
	return;

	} else if ((log_level != LOG_STDOUT)
	&& !crm_is_callsite_active(patchset_cs, log_level, 0)) {
	return;
	}

	xml_patch_versions(patchset, add, del);
	fmt = crm_element_value(patchset, "format");
	digest = crm_element_value(patchset, XML_ATTR_DIGEST);

	if (add[2] != del[2] \|\| add[1] != del[1] \|\| add[0] != del[0]) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__,
	"Diff: --- %d.%d.%d %s", del[0], del[1], del[2], fmt);
	do_crm_log_alias(log_level, __FILE__, function, __LINE__,
	"Diff: +++ %d.%d.%d %s", add[0], add[1], add[2], digest);

	} else if (patchset != NULL && (add[0] \|\| add[1] \|\| add[2])) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__,
	"%s: Local-only Change: %d.%d.%d", function ? function : "",
	add[0], add[1], add[2]);
	}

	crm_element_value_int(patchset, "format", &format);
	if(format == 2) {
	xmlNode *change = NULL;

	for (change = __xml_first_child(patchset); change != NULL; change = __xml_next(change)) {
	const char *op = crm_element_value(change, XML_DIFF_OP);
	const char *xpath = crm_element_value(change, XML_DIFF_PATH);

	if(op == NULL) {
	} else if(strcmp(op, "create") == 0) {
	int lpc = 0, max = 0;
	char *prefix = crm_strdup_printf("++ %s: ", xpath);

	max = strlen(prefix);
	- __xml_log_element(log_level, __FILE__, function, __LINE__, prefix, change->children,
	- 0, xml_log_option_formatted\|xml_log_option_open);
	+ log_xml_element(log_level, __FILE__, function, __LINE__, prefix,
	+ change->children, 0,
	+ xml_log_option_formatted\|xml_log_option_open);

	for(lpc = 2; lpc < max; lpc++) {
	prefix[lpc] = ' ';
	}

	- __xml_log_element(log_level, __FILE__, function, __LINE__, prefix, change->children,
	- 0, xml_log_option_formatted\|xml_log_option_close\|xml_log_option_children);
	+ log_xml_element(log_level, __FILE__, function, __LINE__, prefix,
	+ change->children, 0, xml_log_option_formatted
	+ \|xml_log_option_close
	+ \|xml_log_option_children);
	free(prefix);

	} else if(strcmp(op, "move") == 0) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "+~ %s moved to offset %s", xpath, crm_element_value(change, XML_DIFF_POSITION));

	} else if(strcmp(op, "modify") == 0) {
	xmlNode *clist = first_named_child(change, XML_DIFF_LIST);
	char buffer_set[XML_BUFFER_SIZE];
	char buffer_unset[XML_BUFFER_SIZE];
	int o_set = 0;
	int o_unset = 0;

	buffer_set[0] = 0;
	buffer_unset[0] = 0;
	for (child = __xml_first_child(clist); child != NULL; child = __xml_next(child)) {
	const char *name = crm_element_value(child, "name");

	op = crm_element_value(child, XML_DIFF_OP);
	if(op == NULL) {
	} else if(strcmp(op, "set") == 0) {
	const char *value = crm_element_value(child, "value");

	if(o_set > 0) {
	o_set += snprintf(buffer_set + o_set, XML_BUFFER_SIZE - o_set, ", ");
	}
	o_set += snprintf(buffer_set + o_set, XML_BUFFER_SIZE - o_set, "@%s=%s", name, value);

	} else if(strcmp(op, "unset") == 0) {
	if(o_unset > 0) {
	o_unset += snprintf(buffer_unset + o_unset, XML_BUFFER_SIZE - o_unset, ", ");
	}
	o_unset += snprintf(buffer_unset + o_unset, XML_BUFFER_SIZE - o_unset, "@%s", name);
	}
	}
	if(o_set) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "+ %s: %s", xpath, buffer_set);
	}
	if(o_unset) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s: %s", xpath, buffer_unset);
	}

	} else if(strcmp(op, "delete") == 0) {
	int position = -1;

	crm_element_value_int(change, XML_DIFF_POSITION, &position);
	if (position >= 0) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s (%d)", xpath, position);

	} else {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s", xpath);
	}
	}
	}
	return;
	}

	if (log_level < LOG_DEBUG \|\| function == NULL) {
	options \|= xml_log_option_diff_short;
	}

	removed = find_xml_node(patchset, "diff-removed", FALSE);
	for (child = __xml_first_child(removed); child != NULL; child = __xml_next(child)) {
	log_data_element(log_level, __FILE__, function, __LINE__, "- ", child, 0,
	options \| xml_log_option_diff_minus);
	if (is_first) {
	is_first = FALSE;
	} else {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, " --- ");
	}
	}

	is_first = TRUE;
	added = find_xml_node(patchset, "diff-added", FALSE);
	for (child = __xml_first_child(added); child != NULL; child = __xml_next(child)) {
	log_data_element(log_level, __FILE__, function, __LINE__, "+ ", child, 0,
	options \| xml_log_option_diff_plus);
	if (is_first) {
	is_first = FALSE;
	} else {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, " +++ ");
	}
	}
	}

	void
	xml_log_changes(uint8_t log_level, const char function, xmlNode xml)
	{
	GListPtr gIter = NULL;
	xml_private_t *doc = NULL;

	if (log_level == LOG_NEVER) {
	return;
	}

	CRM_ASSERT(xml);
	CRM_ASSERT(xml->doc);

	doc = xml->doc->_private;
	if (!pcmk_is_set(doc->flags, xpf_dirty)) {
	return;
	}

	for(gIter = doc->deleted_objs; gIter; gIter = gIter->next) {
	xml_deleted_obj_t *deleted_obj = gIter->data;

	if (deleted_obj->position >= 0) {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s (%d)",
	deleted_obj->path, deleted_obj->position);

	} else {
	do_crm_log_alias(log_level, __FILE__, function, __LINE__, "-- %s",
	deleted_obj->path);
	}
	}

	log_data_element(log_level, __FILE__, function, __LINE__, "+ ", xml, 0,
	xml_log_option_formatted\|xml_log_option_dirty_add);
	}

	void
	xml_accept_changes(xmlNode * xml)
	{
	xmlNode *top = NULL;
	xml_private_t *doc = NULL;

	if(xml == NULL) {
	return;
	}

	crm_trace("Accepting changes to %p", xml);
	doc = xml->doc->_private;
	top = xmlDocGetRootElement(xml->doc);

	- __xml_private_clean(xml->doc->_private);
	+ reset_xml_private_data(xml->doc->_private);

	if (!pcmk_is_set(doc->flags, xpf_dirty)) {
	doc->flags = xpf_none;
	return;
	}

	doc->flags = xpf_none;
	- __xml_accept_changes(top);
	+ accept_attr_deletions(top);
	}

	static xmlNode *
	find_element(xmlNode haystack, xmlNode needle, gboolean exact)
	{
	CRM_CHECK(needle != NULL, return NULL);
	- return (needle->type == XML_COMMENT_NODE)?
	- find_xml_comment(haystack, needle, exact)
	- : find_entity(haystack, crm_element_name(needle), ID(needle));
	+
	+ if (needle->type == XML_COMMENT_NODE) {
	+ return find_xml_comment(haystack, needle, exact);
	+
	+ } else {
	+ const char *id = ID(needle);
	+ const char *attr = (id == NULL)? NULL : XML_ATTR_ID;
	+
	+ return pcmk__xe_match(haystack, crm_element_name(needle), attr, id);
	+ }
	}

	-/* Simplified version for applying v1-style XML patches */
	+// Apply the removals section of an v1 patchset to an XML node
	static void
	-__subtract_xml_object(xmlNode * target, xmlNode * patch)
	+process_v1_removals(xmlNode target, xmlNode patch)
	{
	xmlNode *patch_child = NULL;
	xmlNode *cIter = NULL;
	xmlAttrPtr xIter = NULL;

	char *id = NULL;
	const char *name = NULL;
	const char *value = NULL;

	if (target == NULL \|\| patch == NULL) {
	return;
	}

	if (target->type == XML_COMMENT_NODE) {
	gboolean dummy;

	subtract_xml_comment(target->parent, target, patch, &dummy);
	}

	name = crm_element_name(target);
	CRM_CHECK(name != NULL, return);
	CRM_CHECK(pcmk__str_eq(crm_element_name(target), crm_element_name(patch), pcmk__str_casei),
	return);
	CRM_CHECK(pcmk__str_eq(ID(target), ID(patch), pcmk__str_casei), return);

	/* check for XML_DIFF_MARKER in a child */
	id = crm_element_value_copy(target, XML_ATTR_ID);
	value = crm_element_value(patch, XML_DIFF_MARKER);
	if (value != NULL && strcmp(value, "removed:top") == 0) {
	crm_trace("We are the root of the deletion: %s.id=%s", name, id);
	free_xml(target);
	free(id);
	return;
	}

	for (xIter = pcmk__first_xml_attr(patch); xIter != NULL; xIter = xIter->next) {
	const char p_name = (const char )xIter->name;

	/* Removing and then restoring the id field would change the ordering of properties */
	if (!pcmk__str_eq(p_name, XML_ATTR_ID, pcmk__str_casei)) {
	xml_remove_prop(target, p_name);
	}
	}

	/* changes to child objects */
	cIter = __xml_first_child(target);
	while (cIter) {
	xmlNode *target_child = cIter;

	cIter = __xml_next(cIter);
	patch_child = find_element(patch, target_child, FALSE);
	- __subtract_xml_object(target_child, patch_child);
	+ process_v1_removals(target_child, patch_child);
	}
	free(id);
	}

	+// Apply the additions section of an v1 patchset to an XML node
	static void
	-__add_xml_object(xmlNode * parent, xmlNode * target, xmlNode * patch)
	+process_v1_additions(xmlNode parent, xmlNode target, xmlNode *patch)
	{
	xmlNode *patch_child = NULL;
	xmlNode *target_child = NULL;
	xmlAttrPtr xIter = NULL;

	const char *id = NULL;
	const char *name = NULL;
	const char *value = NULL;

	if (patch == NULL) {
	return;
	} else if (parent == NULL && target == NULL) {
	return;
	}

	/* check for XML_DIFF_MARKER in a child */
	value = crm_element_value(patch, XML_DIFF_MARKER);
	if (target == NULL
	&& value != NULL
	&& strcmp(value, "added:top") == 0) {
	id = ID(patch);
	name = crm_element_name(patch);
	crm_trace("We are the root of the addition: %s.id=%s", name, id);
	add_node_copy(parent, patch);
	return;

	} else if(target == NULL) {
	id = ID(patch);
	name = crm_element_name(patch);
	crm_err("Could not locate: %s.id=%s", name, id);
	return;
	}

	if (target->type == XML_COMMENT_NODE) {
	add_xml_comment(parent, target, patch);
	}

	name = crm_element_name(target);
	CRM_CHECK(name != NULL, return);
	CRM_CHECK(pcmk__str_eq(crm_element_name(target), crm_element_name(patch), pcmk__str_casei),
	return);
	CRM_CHECK(pcmk__str_eq(ID(target), ID(patch), pcmk__str_casei), return);

	for (xIter = pcmk__first_xml_attr(patch); xIter != NULL; xIter = xIter->next) {
	const char p_name = (const char )xIter->name;
	const char *p_value = crm_element_value(patch, p_name);

	xml_remove_prop(target, p_name); /* Preserve the patch order */
	crm_xml_add(target, p_name, p_value);
	}

	/* changes to child objects */
	for (patch_child = __xml_first_child(patch); patch_child != NULL;
	patch_child = __xml_next(patch_child)) {

	target_child = find_element(target, patch_child, FALSE);
	- __add_xml_object(target, target_child, patch_child);
	+ process_v1_additions(target, target_child, patch_child);
	}
	}

	/*!
	* \internal
	* \brief Find additions or removals in a patch set
	*
	* \param[in] patchset XML of patch
	* \param[in] format Patch version
	* \param[in] added TRUE if looking for additions, FALSE if removals
	* \param[in,out] patch_node Will be set to node if found
	*
	* \return TRUE if format is valid, FALSE if invalid
	*/
	static bool
	find_patch_xml_node(xmlNode *patchset, int format, bool added,
	xmlNode **patch_node)
	{
	xmlNode *cib_node;
	const char *label;

	switch(format) {
	case 1:
	label = added? "diff-added" : "diff-removed";
	*patch_node = find_xml_node(patchset, label, FALSE);
	cib_node = find_xml_node(*patch_node, "cib", FALSE);
	if (cib_node != NULL) {
	*patch_node = cib_node;
	}
	break;
	case 2:
	label = added? "target" : "source";
	*patch_node = find_xml_node(patchset, "version", FALSE);
	patch_node = find_xml_node(patch_node, label, FALSE);
	break;
	default:
	crm_warn("Unknown patch format: %d", format);
	*patch_node = NULL;
	return FALSE;
	}
	return TRUE;
	}

	-bool xml_patch_versions(xmlNode *patchset, int add[3], int del[3])
	+// Get CIB versions used for additions and deletions in a patchset
	+bool
	+xml_patch_versions(xmlNode *patchset, int add[3], int del[3])
	{
	int lpc = 0;
	int format = 1;
	xmlNode *tmp = NULL;

	const char *vfields[] = {
	XML_ATTR_GENERATION_ADMIN,
	XML_ATTR_GENERATION,
	XML_ATTR_NUMUPDATES,
	};


	crm_element_value_int(patchset, "format", &format);

	/* Process removals */
	if (!find_patch_xml_node(patchset, format, FALSE, &tmp)) {
	return -EINVAL;
	}
	if (tmp) {
	for(lpc = 0; lpc < DIMOF(vfields); lpc++) {
	crm_element_value_int(tmp, vfields[lpc], &(del[lpc]));
	crm_trace("Got %d for del[%s]", del[lpc], vfields[lpc]);
	}
	}

	/* Process additions */
	if (!find_patch_xml_node(patchset, format, TRUE, &tmp)) {
	return -EINVAL;
	}
	if (tmp) {
	for(lpc = 0; lpc < DIMOF(vfields); lpc++) {
	crm_element_value_int(tmp, vfields[lpc], &(add[lpc]));
	crm_trace("Got %d for add[%s]", add[lpc], vfields[lpc]);
	}
	}

	return pcmk_ok;
	}

	+/*!
	+ * \internal
	+ * \brief Check whether patchset can be applied to current CIB
	+ *
	+ * \param[in] xml Root of current CIB
	+ * \param[in] patchset Patchset to check
	+ * \param[in] format Patchset version
	+ *
	+ * \return Standard Pacemaker return code
	+ */
	static int
	-xml_patch_version_check(xmlNode xml, xmlNode patchset, int format)
	+xml_patch_version_check(xmlNode xml, xmlNode patchset, int format)
	{
	int lpc = 0;
	bool changed = FALSE;

	int this[] = { 0, 0, 0 };
	int add[] = { 0, 0, 0 };
	int del[] = { 0, 0, 0 };

	const char *vfields[] = {
	XML_ATTR_GENERATION_ADMIN,
	XML_ATTR_GENERATION,
	XML_ATTR_NUMUPDATES,
	};

	for(lpc = 0; lpc < DIMOF(vfields); lpc++) {
	crm_element_value_int(xml, vfields[lpc], &(this[lpc]));
	crm_trace("Got %d for this[%s]", this[lpc], vfields[lpc]);
	if (this[lpc] < 0) {
	this[lpc] = 0;
	}
	}

	/* Set some defaults in case nothing is present */
	add[0] = this[0];
	add[1] = this[1];
	add[2] = this[2] + 1;
	for(lpc = 0; lpc < DIMOF(vfields); lpc++) {
	del[lpc] = this[lpc];
	}

	xml_patch_versions(patchset, add, del);

	for(lpc = 0; lpc < DIMOF(vfields); lpc++) {
	if(this[lpc] < del[lpc]) {
	crm_debug("Current %s is too low (%d.%d.%d < %d.%d.%d --> %d.%d.%d)", vfields[lpc],
	this[0], this[1], this[2], del[0], del[1], del[2], add[0], add[1], add[2]);
	- return -pcmk_err_diff_resync;
	+ return pcmk_rc_diff_resync;

	} else if(this[lpc] > del[lpc]) {
	crm_info("Current %s is too high (%d.%d.%d > %d.%d.%d --> %d.%d.%d) %p", vfields[lpc],
	this[0], this[1], this[2], del[0], del[1], del[2], add[0], add[1], add[2], patchset);
	crm_log_xml_info(patchset, "OldPatch");
	- return -pcmk_err_old_data;
	+ return pcmk_rc_old_data;
	}
	}

	for(lpc = 0; lpc < DIMOF(vfields); lpc++) {
	if(add[lpc] > del[lpc]) {
	changed = TRUE;
	}
	}

	if(changed == FALSE) {
	crm_notice("Versions did not change in patch %d.%d.%d", add[0], add[1], add[2]);
	- return -pcmk_err_old_data;
	+ return pcmk_rc_old_data;
	}

	crm_debug("Can apply patch %d.%d.%d to %d.%d.%d",
	add[0], add[1], add[2], this[0], this[1], this[2]);
	- return pcmk_ok;
	+ return pcmk_rc_ok;
	}

	+/*!
	+ * \internal
	+ * \brief Apply a version 1 patchset to an XML node
	+ *
	+ * \param[in,out] xml XML to apply patchset to
	+ * \param[in] patchset Patchset to apply
	+ *
	+ * \return Standard Pacemaker return code
	+ */
	static int
	-xml_apply_patchset_v1(xmlNode xml, xmlNode patchset)
	+apply_v1_patchset(xmlNode xml, xmlNode patchset)
	{
	- int rc = pcmk_ok;
	+ int rc = pcmk_rc_ok;
	int root_nodes_seen = 0;

	xmlNode *child_diff = NULL;
	xmlNode *added = find_xml_node(patchset, "diff-added", FALSE);
	xmlNode *removed = find_xml_node(patchset, "diff-removed", FALSE);
	xmlNode *old = copy_xml(xml);

	crm_trace("Subtraction Phase");
	for (child_diff = __xml_first_child(removed); child_diff != NULL;
	child_diff = __xml_next(child_diff)) {
	CRM_CHECK(root_nodes_seen == 0, rc = FALSE);
	if (root_nodes_seen == 0) {
	- __subtract_xml_object(xml, child_diff);
	+ process_v1_removals(xml, child_diff);
	}
	root_nodes_seen++;
	}

	if (root_nodes_seen > 1) {
	crm_err("(-) Diffs cannot contain more than one change set... saw %d", root_nodes_seen);
	- rc = -ENOTUNIQ;
	+ rc = ENOTUNIQ;
	}

	root_nodes_seen = 0;
	crm_trace("Addition Phase");
	- if (rc == pcmk_ok) {
	+ if (rc == pcmk_rc_ok) {
	xmlNode *child_diff = NULL;

	for (child_diff = __xml_first_child(added); child_diff != NULL;
	child_diff = __xml_next(child_diff)) {
	CRM_CHECK(root_nodes_seen == 0, rc = FALSE);
	if (root_nodes_seen == 0) {
	- __add_xml_object(NULL, xml, child_diff);
	+ process_v1_additions(NULL, xml, child_diff);
	}
	root_nodes_seen++;
	}
	}

	if (root_nodes_seen > 1) {
	crm_err("(+) Diffs cannot contain more than one change set... saw %d", root_nodes_seen);
	- rc = -ENOTUNIQ;
	+ rc = ENOTUNIQ;
	}

	purge_diff_markers(xml); /* Purge prior to checking the digest */

	free_xml(old);
	return rc;
	}

	+// Return first child matching element name and optionally id or position
	static xmlNode *
	-__first_xml_child_match(xmlNode parent, const char name, const char *id, int position)
	+first_matching_xml_child(xmlNode parent, const char name, const char *id,
	+ int position)
	{
	xmlNode *cIter = NULL;

	for (cIter = __xml_first_child(parent); cIter != NULL; cIter = __xml_next(cIter)) {
	if(strcmp((const char *)cIter->name, name) != 0) {
	continue;
	} else if(id) {
	const char *cid = ID(cIter);
	if(cid == NULL \|\| strcmp(cid, id) != 0) {
	continue;
	}
	}

	/* The "position" makes sense only for XML comments for now */
	if (cIter->type == XML_COMMENT_NODE
	&& position >= 0
	- && __xml_offset(cIter) != position) {
	+ && (position_within_parent(cIter, xpf_skip) != position)) {
	continue;
	}

	return cIter;
	}
	return NULL;
	}

	/*!
	* \internal
	* \brief Simplified, more efficient alternative to get_xpath_object()
	*
	* \param[in] top Root of XML to search
	* \param[in] key Search xpath
	* \param[in] target_position If deleting, where to delete
	*
	* \return XML child matching xpath if found, NULL otherwise
	*
	* \note This only works on simplified xpaths found in v2 patchset diffs,
	* i.e. the only allowed search predicate is [@id='XXX'].
	*/
	static xmlNode *
	-__xml_find_path(xmlNode top, const char key, int target_position)
	+search_v2_xpath(xmlNode top, const char key, int target_position)
	{
	xmlNode target = (xmlNode) top->doc;
	const char *current = key;
	char *section;
	char *remainder;
	char *id;
	char *tag;
	char *path = NULL;
	int rc;
	size_t key_len;

	CRM_CHECK(key != NULL, return NULL);
	key_len = strlen(key);

	/* These are scanned from key after a slash, so they can't be bigger
	* than key_len - 1 characters plus a null terminator.
	*/

	remainder = calloc(key_len, sizeof(char));
	CRM_ASSERT(remainder != NULL);

	section = calloc(key_len, sizeof(char));
	CRM_ASSERT(section != NULL);

	id = calloc(key_len, sizeof(char));
	CRM_ASSERT(id != NULL);

	tag = calloc(key_len, sizeof(char));
	CRM_ASSERT(tag != NULL);

	do {
	// Look for /NEXT_COMPONENT/REMAINING_COMPONENTS
	rc = sscanf(current, "/%[^/]%s", section, remainder);
	if (rc > 0) {
	// Separate FIRST_COMPONENT into TAG[@id='ID']
	int f = sscanf(section, "%[^[][@id='%[^']", tag, id);
	int current_position = -1;

	/* The target position is for the final component tag, so only use
	* it if there is nothing left to search after this component.
	*/
	if ((rc == 1) && (target_position >= 0)) {
	current_position = target_position;
	}

	switch (f) {
	case 1:
	- target = __first_xml_child_match(target, tag, NULL, current_position);
	+ target = first_matching_xml_child(target, tag, NULL,
	+ current_position);
	break;
	case 2:
	- target = __first_xml_child_match(target, tag, id, current_position);
	+ target = first_matching_xml_child(target, tag, id,
	+ current_position);
	break;
	default:
	// This should not be possible
	target = NULL;
	break;
	}
	current = remainder;
	}

	// Continue if something remains to search, and we've matched so far
	} while ((rc == 2) && target);

	if (target) {
	crm_trace("Found %s for %s",
	(path = (char *) xmlGetNodePath(target)), key);
	free(path);
	} else {
	crm_debug("No match for %s", key);
	}

	free(remainder);
	free(section);
	free(tag);
	free(id);
	return target;
	}

	typedef struct xml_change_obj_s {
	xmlNode *change;
	xmlNode *match;
	} xml_change_obj_t;

	static gint
	sort_change_obj_by_position(gconstpointer a, gconstpointer b)
	{
	const xml_change_obj_t *change_obj_a = a;
	const xml_change_obj_t *change_obj_b = b;
	int position_a = -1;
	int position_b = -1;

	crm_element_value_int(change_obj_a->change, XML_DIFF_POSITION, &position_a);
	crm_element_value_int(change_obj_b->change, XML_DIFF_POSITION, &position_b);

	if (position_a < position_b) {
	return -1;

	} else if (position_a > position_b) {
	return 1;
	}

	return 0;
	}

	+/*!
	+ * \internal
	+ * \brief Apply a version 2 patchset to an XML node
	+ *
	+ * \param[in,out] xml XML to apply patchset to
	+ * \param[in] patchset Patchset to apply
	+ *
	+ * \return Standard Pacemaker return code
	+ */
	static int
	-xml_apply_patchset_v2(xmlNode xml, xmlNode patchset)
	+apply_v2_patchset(xmlNode xml, xmlNode patchset)
	{
	- int rc = pcmk_ok;
	+ int rc = pcmk_rc_ok;
	xmlNode *change = NULL;
	GListPtr change_objs = NULL;
	GListPtr gIter = NULL;

	for (change = __xml_first_child(patchset); change != NULL; change = __xml_next(change)) {
	xmlNode *match = NULL;
	const char *op = crm_element_value(change, XML_DIFF_OP);
	const char *xpath = crm_element_value(change, XML_DIFF_PATH);
	int position = -1;

	if(op == NULL) {
	continue;
	}

	crm_trace("Processing %s %s", change->name, op);

	// "delete" changes for XML comments are generated with "position"
	if(strcmp(op, "delete") == 0) {
	crm_element_value_int(change, XML_DIFF_POSITION, &position);
	}
	- match = __xml_find_path(xml, xpath, position);
	+ match = search_v2_xpath(xml, xpath, position);
	crm_trace("Performing %s on %s with %p", op, xpath, match);

	if(match == NULL && strcmp(op, "delete") == 0) {
	crm_debug("No %s match for %s in %p", op, xpath, xml->doc);
	continue;

	} else if(match == NULL) {
	crm_err("No %s match for %s in %p", op, xpath, xml->doc);
	- rc = -pcmk_err_diff_failed;
	+ rc = pcmk_rc_diff_failed;
	continue;

	} else if (strcmp(op, "create") == 0 \|\| strcmp(op, "move") == 0) {
	// Delay the adding of a "create" object
	xml_change_obj_t *change_obj = calloc(1, sizeof(xml_change_obj_t));

	CRM_ASSERT(change_obj != NULL);

	change_obj->change = change;
	change_obj->match = match;

	change_objs = g_list_append(change_objs, change_obj);

	if (strcmp(op, "move") == 0) {
	// Temporarily put the "move" object after the last sibling
	if (match->parent != NULL && match->parent->last != NULL) {
	xmlAddNextSibling(match->parent->last, match);
	}
	}

	} else if(strcmp(op, "delete") == 0) {
	free_xml(match);

	} else if(strcmp(op, "modify") == 0) {
	xmlAttr *pIter = pcmk__first_xml_attr(match);
	xmlNode *attrs = __xml_first_child(first_named_child(change, XML_DIFF_RESULT));

	if(attrs == NULL) {
	- rc = -ENOMSG;
	+ rc = ENOMSG;
	continue;
	}
	while(pIter != NULL) {
	const char name = (const char )pIter->name;

	pIter = pIter->next;
	xml_remove_prop(match, name);
	}

	for (pIter = pcmk__first_xml_attr(attrs); pIter != NULL; pIter = pIter->next) {
	const char name = (const char )pIter->name;
	const char *value = crm_element_value(attrs, name);

	crm_xml_add(match, name, value);
	}

	} else {
	crm_err("Unknown operation: %s", op);
	- rc = -pcmk_err_diff_failed;
	+ rc = pcmk_rc_diff_failed;
	}
	}

	// Changes should be generated in the right order. Double checking.
	change_objs = g_list_sort(change_objs, sort_change_obj_by_position);

	for (gIter = change_objs; gIter; gIter = gIter->next) {
	xml_change_obj_t *change_obj = gIter->data;
	xmlNode *match = change_obj->match;
	const char *op = NULL;
	const char *xpath = NULL;

	change = change_obj->change;

	op = crm_element_value(change, XML_DIFF_OP);
	xpath = crm_element_value(change, XML_DIFF_PATH);

	crm_trace("Continue performing %s on %s with %p", op, xpath, match);

	if(strcmp(op, "create") == 0) {
	int position = 0;
	xmlNode *child = NULL;
	xmlNode *match_child = NULL;

	match_child = match->children;
	crm_element_value_int(change, XML_DIFF_POSITION, &position);

	- while(match_child && position != __xml_offset(match_child)) {
	+ while ((match_child != NULL)
	+ && (position != position_within_parent(match_child, xpf_skip))) {
	match_child = match_child->next;
	}

	child = xmlDocCopyNode(change->children, match->doc, 1);
	if(match_child) {
	crm_trace("Adding %s at position %d", child->name, position);
	xmlAddPrevSibling(match_child, child);

	} else if(match->last) { /* Add to the end */
	crm_trace("Adding %s at position %d (end)", child->name, position);
	xmlAddNextSibling(match->last, child);

	} else {
	crm_trace("Adding %s at position %d (first)", child->name, position);
	CRM_LOG_ASSERT(position == 0);
	xmlAddChild(match, child);
	}
	- crm_node_created(child);
	+ mark_xml_node_created(child);

	} else if(strcmp(op, "move") == 0) {
	int position = 0;

	crm_element_value_int(change, XML_DIFF_POSITION, &position);
	- if(position != __xml_offset(match)) {
	+ if (position != position_within_parent(match, xpf_skip)) {
	xmlNode *match_child = NULL;
	int p = position;

	- if(p > __xml_offset(match)) {
	+ if (p > position_within_parent(match, xpf_skip)) {
	p++; /* Skip ourselves */
	}

	CRM_ASSERT(match->parent != NULL);
	match_child = match->parent->children;

	- while(match_child && p != __xml_offset(match_child)) {
	+ while ((match_child != NULL)
	+ && (p != position_within_parent(match_child, xpf_skip))) {
	match_child = match_child->next;
	}

	crm_trace("Moving %s to position %d (was %d, prev %p, %s %p)",
	- match->name, position, __xml_offset(match), match->prev,
	- match_child?"next":"last", match_child?match_child:match->parent->last);
	+ match->name, position,
	+ position_within_parent(match, xpf_skip),
	+ match->prev, (match_child? "next":"last"),
	+ (match_child? match_child : match->parent->last));

	if(match_child) {
	xmlAddPrevSibling(match_child, match);

	} else {
	CRM_ASSERT(match->parent->last != NULL);
	xmlAddNextSibling(match->parent->last, match);
	}

	} else {
	crm_trace("%s is already in position %d", match->name, position);
	}

	- if(position != __xml_offset(match)) {
	+ if (position != position_within_parent(match, xpf_skip)) {
	crm_err("Moved %s.%s to position %d instead of %d (%p)",
	- match->name, ID(match), __xml_offset(match), position, match->prev);
	- rc = -pcmk_err_diff_failed;
	+ match->name, ID(match),
	+ position_within_parent(match, xpf_skip),
	+ position, match->prev);
	+ rc = pcmk_rc_diff_failed;
	}
	}
	}

	g_list_free_full(change_objs, free);
	return rc;
	}

	int
	xml_apply_patchset(xmlNode xml, xmlNode patchset, bool check_version)
	{
	int format = 1;
	int rc = pcmk_ok;
	xmlNode *old = NULL;
	const char *digest = crm_element_value(patchset, XML_ATTR_DIGEST);

	if(patchset == NULL) {
	return rc;
	}

	xml_log_patchset(LOG_TRACE, __func__, patchset);

	crm_element_value_int(patchset, "format", &format);
	if(check_version) {
	- rc = xml_patch_version_check(xml, patchset, format);
	+ rc = pcmk_rc2legacy(xml_patch_version_check(xml, patchset, format));
	if(rc != pcmk_ok) {
	return rc;
	}
	}

	if(digest) {
	/* Make it available for logging if the result doesn't have the expected digest */
	old = copy_xml(xml);
	}

	if(rc == pcmk_ok) {
	switch(format) {
	case 1:
	- rc = xml_apply_patchset_v1(xml, patchset);
	+ rc = pcmk_rc2legacy(apply_v1_patchset(xml, patchset));
	break;
	case 2:
	- rc = xml_apply_patchset_v2(xml, patchset);
	+ rc = pcmk_rc2legacy(apply_v2_patchset(xml, patchset));
	break;
	default:
	crm_err("Unknown patch format: %d", format);
	rc = -EINVAL;
	}
	}

	if(rc == pcmk_ok && digest) {
	static struct qb_log_callsite *digest_cs = NULL;

	char *new_digest = NULL;
	char *version = crm_element_value_copy(xml, XML_ATTR_CRM_VERSION);

	if (digest_cs == NULL) {
	digest_cs =
	qb_log_callsite_get(__func__, __FILE__, "diff-digest", LOG_TRACE, __LINE__,
	crm_trace_nonlog);
	}

	new_digest = calculate_xml_versioned_digest(xml, FALSE, TRUE, version);
	if (!pcmk__str_eq(new_digest, digest, pcmk__str_casei)) {
	crm_info("v%d digest mis-match: expected %s, calculated %s", format, digest, new_digest);
	rc = -pcmk_err_diff_failed;

	if (digest_cs && digest_cs->targets) {
	save_xml_to_file(old, "PatchDigest:input", NULL);
	save_xml_to_file(xml, "PatchDigest:result", NULL);
	save_xml_to_file(patchset,"PatchDigest:diff", NULL);

	} else {
	crm_trace("%p %.6x", digest_cs, digest_cs ? digest_cs->targets : 0);
	}

	} else {
	crm_trace("v%d digest matched: expected %s, calculated %s", format, digest, new_digest);
	}
	free(new_digest);
	free(version);
	}
	free_xml(old);
	return rc;
	}

	xmlNode *
	find_xml_node(xmlNode * root, const char *search_path, gboolean must_find)
	{
	xmlNode *a_child = NULL;
	const char *name = "NULL";

	if (root != NULL) {
	name = crm_element_name(root);
	}

	if (search_path == NULL) {
	crm_warn("Will never find <NULL>");
	return NULL;
	}

	for (a_child = __xml_first_child(root); a_child != NULL; a_child = __xml_next(a_child)) {
	if (strcmp((const char *)a_child->name, search_path) == 0) {
	/* crm_trace("returning node (%s).", crm_element_name(a_child)); */
	return a_child;
	}
	}

	if (must_find) {
	crm_warn("Could not find %s in %s.", search_path, name);
	} else if (root != NULL) {
	crm_trace("Could not find %s in %s.", search_path, name);
	} else {
	crm_trace("Could not find %s in <NULL>.", search_path);
	}

	return NULL;
	}

	-/* As the name suggests, the perfect match is required for both node
	- name and fully specified attribute, otherwise, when attribute not
	- specified, the outcome is the first node matching on the name. */
	-static xmlNode *
	-find_entity_by_attr_or_just_name(xmlNode parent, const char node_name,
	- const char attr_n, const char attr_v)
	-{
	- xmlNode *child;
	+#define attr_matches(c, n, v) pcmk__str_eq(crm_element_value((c), (n)), \
	+ (v), pcmk__str_none)

	+/*!
	+ * \internal
	+ * \brief Find first XML child element matching given criteria
	+ *
	+ * \param[in] parent XML element to search
	+ * \param[in] node_name If not NULL, only match children of this type
	+ * \param[in] attr_n If not NULL, only match children with an attribute
	+ * of this name and a value of \p attr_v
	+ * \param[in] attr_v If \p attr_n and this are not NULL, only match children
	+ * with an attribute named \p attr_n and this value
	+ *
	+ * \return Matching XML child element, or NULL if none found
	+ */
	+xmlNode *
	+pcmk__xe_match(xmlNode parent, const char node_name,
	+ const char attr_n, const char attr_v)
	+{
	/* ensure attr_v specified when attr_n is */
	CRM_CHECK(attr_n == NULL \|\| attr_v != NULL, return NULL);

	- for (child = __xml_first_child(parent); child != NULL; child = __xml_next(child)) {
	- /* XXX uncertain if the first check is strictly necessary here */
	- if (pcmk__str_eq(node_name, (const char *)child->name, pcmk__str_null_matches)) {
	- if (attr_n == NULL
	- \|\| pcmk__str_eq(crm_element_value(child, attr_n), attr_v, pcmk__str_none)) {
	- return child;
	- }
	+ for (xmlNode *child = __xml_first_child(parent); child != NULL;
	+ child = __xml_next(child)) {
	+ if (pcmk__str_eq(node_name, (const char *) (child->name),
	+ pcmk__str_null_matches)
	+ && ((attr_n == NULL) \|\| attr_matches(child, attr_n, attr_v))) {
	+ return child;
	}
	}
	-
	- crm_trace("node <%s%s%s%s%s> not found in %s", crm_str(node_name),
	- attr_n ? " " : "",
	- attr_n ? attr_n : "",
	- attr_n ? "=" : "",
	- attr_n ? attr_v : "",
	+ crm_trace("XML child node <%s%s%s%s%s> not found in %s",
	+ (node_name? node_name : "(any)"),
	+ (attr_n? " " : ""),
	+ (attr_n? attr_n : ""),
	+ (attr_n? "=" : ""),
	+ (attr_n? attr_v : ""),
	crm_element_name(parent));
	-
	return NULL;
	}

	-xmlNode *
	-find_entity(xmlNode parent, const char node_name, const char *id)
	-{
	- return find_entity_by_attr_or_just_name(parent, node_name,
	- (id == NULL) ? id : XML_ATTR_ID, id);
	-}
	-
	void
	copy_in_properties(xmlNode * target, xmlNode * src)
	{
	if (src == NULL) {
	crm_warn("No node to copy properties from");

	} else if (target == NULL) {
	crm_err("No node to copy properties into");

	} else {
	xmlAttrPtr pIter = NULL;

	for (pIter = pcmk__first_xml_attr(src); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	expand_plus_plus(target, p_name, p_value);
	}
	}

	return;
	}

	void
	fix_plus_plus_recursive(xmlNode * target)
	{
	/* TODO: Remove recursion and use xpath searches for value++ */
	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;

	for (pIter = pcmk__first_xml_attr(target); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	expand_plus_plus(target, p_name, p_value);
	}
	for (child = __xml_first_child(target); child != NULL; child = __xml_next(child)) {
	fix_plus_plus_recursive(child);
	}
	}

	void
	expand_plus_plus(xmlNode * target, const char name, const char value)
	{
	int offset = 1;
	int name_len = 0;
	int int_value = 0;
	int value_len = 0;

	const char *old_value = NULL;

	if (value == NULL \|\| name == NULL) {
	return;
	}

	old_value = crm_element_value(target, name);

	if (old_value == NULL) {
	/* if no previous value, set unexpanded */
	goto set_unexpanded;

	} else if (strstr(value, name) != value) {
	goto set_unexpanded;
	}

	name_len = strlen(name);
	value_len = strlen(value);
	if (value_len < (name_len + 2)
	\|\| value[name_len] != '+' \|\| (value[name_len + 1] != '+' && value[name_len + 1] != '=')) {
	goto set_unexpanded;
	}

	/* if we are expanding ourselves,
	* then no previous value was set and leave int_value as 0
	*/
	if (old_value != value) {
	int_value = char2score(old_value);
	}

	if (value[name_len + 1] != '+') {
	const char *offset_s = value + (name_len + 2);

	offset = char2score(offset_s);
	}
	int_value += offset;

	if (int_value > INFINITY) {
	int_value = (int)INFINITY;
	}

	crm_xml_add_int(target, name, int_value);
	return;

	set_unexpanded:
	if (old_value == value) {
	/* the old value is already set, nothing to do */
	return;
	}
	crm_xml_add(target, name, value);
	return;
	}

	xmlDoc *
	getDocPtr(xmlNode * node)
	{
	xmlDoc *doc = NULL;

	CRM_CHECK(node != NULL, return NULL);

	doc = node->doc;
	if (doc == NULL) {
	doc = xmlNewDoc((pcmkXmlStr) "1.0");
	xmlDocSetRootElement(doc, node);
	xmlSetTreeDoc(node, doc);
	}
	return doc;
	}

	xmlNode *
	add_node_copy(xmlNode * parent, xmlNode * src_node)
	{
	xmlNode *child = NULL;
	xmlDoc *doc = getDocPtr(parent);

	CRM_CHECK(src_node != NULL, return NULL);

	child = xmlDocCopyNode(src_node, doc, 1);
	xmlAddChild(parent, child);
	- crm_node_created(child);
	+ mark_xml_node_created(child);
	return child;
	}

	int
	add_node_nocopy(xmlNode * parent, const char name, xmlNode child)
	{
	add_node_copy(parent, child);
	free_xml(child);
	return 1;
	}

	xmlNode *
	create_xml_node(xmlNode * parent, const char *name)
	{
	xmlDoc *doc = NULL;
	xmlNode *node = NULL;

	if (pcmk__str_empty(name)) {
	CRM_CHECK(name != NULL && name[0] == 0, return NULL);
	return NULL;
	}

	if (parent == NULL) {
	doc = xmlNewDoc((pcmkXmlStr) "1.0");
	node = xmlNewDocRawNode(doc, NULL, (pcmkXmlStr) name, NULL);
	xmlDocSetRootElement(doc, node);

	} else {
	doc = getDocPtr(parent);
	node = xmlNewDocRawNode(doc, NULL, (pcmkXmlStr) name, NULL);
	xmlAddChild(parent, node);
	}
	- crm_node_created(node);
	+ mark_xml_node_created(node);
	return node;
	}

	xmlNode *
	pcmk_create_xml_text_node(xmlNode * parent, const char name, const char content)
	{
	xmlNode *node = create_xml_node(parent, name);

	if (node != NULL) {
	xmlNodeSetContent(node, (pcmkXmlStr) content);
	}

	return node;
	}

	xmlNode *
	pcmk_create_html_node(xmlNode * parent, const char element_name, const char id,
	const char class_name, const char text)
	{
	xmlNode *node = pcmk_create_xml_text_node(parent, element_name, text);

	if (class_name != NULL) {
	xmlSetProp(node, (pcmkXmlStr) "class", (pcmkXmlStr) class_name);
	}

	if (id != NULL) {
	xmlSetProp(node, (pcmkXmlStr) "id", (pcmkXmlStr) id);
	}

	return node;
	}

	int
	pcmk__element_xpath(const char prefix, xmlNode xml, char *buffer,
	int offset, size_t buffer_size)
	{
	const char *id = ID(xml);

	if(offset == 0 && prefix == NULL && xml->parent) {
	offset = pcmk__element_xpath(NULL, xml->parent, buffer, offset,
	buffer_size);
	}

	if(id) {
	offset += snprintf(buffer + offset, buffer_size - offset,
	"/%s[@id='%s']", (const char *) xml->name, id);
	} else if(xml->name) {
	offset += snprintf(buffer + offset, buffer_size - offset,
	"/%s", (const char *) xml->name);
	}

	return offset;
	}

	char *
	xml_get_path(xmlNode *xml)
	{
	int offset = 0;
	char buffer[XML_BUFFER_SIZE];

	if (pcmk__element_xpath(NULL, xml, buffer, offset, sizeof(buffer)) > 0) {
	return strdup(buffer);
	}
	return NULL;
	}

	/*!
	* Free an XML element and all of its children, removing it from its parent
	*
	* \param[in] xml XML element to free
	*/
	void
	pcmk_free_xml_subtree(xmlNode *xml)
	{
	xmlUnlinkNode(xml); // Detaches from parent and siblings
	xmlFreeNode(xml); // Frees
	}

	static void
	free_xml_with_position(xmlNode * child, int position)
	{
	if (child != NULL) {
	xmlNode *top = NULL;
	xmlDoc *doc = child->doc;
	xml_private_t *p = child->_private;

	if (doc != NULL) {
	top = xmlDocGetRootElement(doc);
	}

	if (doc != NULL && top == child) {
	/* Free everything */
	xmlFreeDoc(doc);

	} else if (pcmk__check_acl(child, NULL, xpf_acl_write) == FALSE) {
	int offset = 0;
	char buffer[XML_BUFFER_SIZE];

	pcmk__element_xpath(NULL, child, buffer, offset, sizeof(buffer));
	crm_trace("Cannot remove %s %x", buffer, p->flags);
	return;

	} else {
	if (doc && pcmk__tracking_xml_changes(child, FALSE)
	&& !pcmk_is_set(p->flags, xpf_created)) {
	int offset = 0;
	char buffer[XML_BUFFER_SIZE];

	if (pcmk__element_xpath(NULL, child, buffer, offset,
	sizeof(buffer)) > 0) {
	xml_deleted_obj_t *deleted_obj = calloc(1, sizeof(xml_deleted_obj_t));

	crm_trace("Deleting %s %p from %p", buffer, child, doc);

	deleted_obj->path = strdup(buffer);

	deleted_obj->position = -1;
	/* Record the "position" only for XML comments for now */
	if (child->type == XML_COMMENT_NODE) {
	if (position >= 0) {
	deleted_obj->position = position;

	} else {
	- deleted_obj->position = __xml_offset(child);
	+ deleted_obj->position = position_within_parent(child, xpf_skip);
	}
	}

	p = doc->_private;
	p->deleted_objs = g_list_append(p->deleted_objs, deleted_obj);
	pcmk__set_xml_doc_flag(child, xpf_dirty);
	}
	}
	pcmk_free_xml_subtree(child);
	}
	}
	}


	void
	free_xml(xmlNode * child)
	{
	free_xml_with_position(child, -1);
	}

	xmlNode *
	copy_xml(xmlNode * src)
	{
	xmlDoc *doc = xmlNewDoc((pcmkXmlStr) "1.0");
	xmlNode *copy = xmlDocCopyNode(src, doc, 1);

	xmlDocSetRootElement(doc, copy);
	xmlSetTreeDoc(copy, doc);
	return copy;
	}

	static void
	-crm_xml_err(void ctx, const char fmt, ...)
	+log_xmllib_err(void ctx, const char fmt, ...)
	G_GNUC_PRINTF(2, 3);

	+// Log an XML library error
	static void
	-crm_xml_err(void ctx, const char fmt, ...)
	+log_xmllib_err(void ctx, const char fmt, ...)
	{
	va_list ap;
	static struct qb_log_callsite *xml_error_cs = NULL;

	if (xml_error_cs == NULL) {
	xml_error_cs = qb_log_callsite_get(
	__func__, __FILE__, "xml library error", LOG_TRACE, __LINE__, crm_trace_nonlog);
	}

	va_start(ap, fmt);
	if (xml_error_cs && xml_error_cs->targets) {
	- CRM_XML_LOG_BASE(LOG_ERR, TRUE,
	- crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, "xml library error",
	- TRUE, TRUE),
	- "XML Error: ", fmt, ap);
	+ PCMK__XML_LOG_BASE(LOG_ERR, TRUE,
	+ crm_abort(__FILE__, __PRETTY_FUNCTION__, __LINE__, "xml library error",
	+ TRUE, TRUE),
	+ "XML Error: ", fmt, ap);
	} else {
	- CRM_XML_LOG_BASE(LOG_ERR, TRUE, 0, "XML Error: ", fmt, ap);
	+ PCMK__XML_LOG_BASE(LOG_ERR, TRUE, 0, "XML Error: ", fmt, ap);
	}
	va_end(ap);
	}

	xmlNode *
	string2xml(const char *input)
	{
	xmlNode *xml = NULL;
	xmlDocPtr output = NULL;
	xmlParserCtxtPtr ctxt = NULL;
	xmlErrorPtr last_error = NULL;

	if (input == NULL) {
	crm_err("Can't parse NULL input");
	return NULL;
	}

	/* create a parser context */
	ctxt = xmlNewParserCtxt();
	CRM_CHECK(ctxt != NULL, return NULL);

	xmlCtxtResetLastError(ctxt);
	- xmlSetGenericErrorFunc(ctxt, crm_xml_err);
	+ xmlSetGenericErrorFunc(ctxt, log_xmllib_err);
	output = xmlCtxtReadDoc(ctxt, (pcmkXmlStr) input, NULL, NULL,
	PCMK__XML_PARSE_OPTS);
	if (output) {
	xml = xmlDocGetRootElement(output);
	}
	last_error = xmlCtxtGetLastError(ctxt);
	if (last_error && last_error->code != XML_ERR_OK) {
	/* crm_abort(__FILE__,__func__,__LINE__, "last_error->code != XML_ERR_OK", TRUE, TRUE); */
	/*
	* http://xmlsoft.org/html/libxml-xmlerror.html#xmlErrorLevel
	* http://xmlsoft.org/html/libxml-xmlerror.html#xmlParserErrors
	*/
	crm_warn("Parsing failed (domain=%d, level=%d, code=%d): %s",
	last_error->domain, last_error->level, last_error->code, last_error->message);

	if (last_error->code == XML_ERR_DOCUMENT_EMPTY) {
	CRM_LOG_ASSERT("Cannot parse an empty string");

	} else if (last_error->code != XML_ERR_DOCUMENT_END) {
	crm_err("Couldn't%s parse %d chars: %s", xml ? " fully" : "", (int)strlen(input),
	input);
	if (xml != NULL) {
	crm_log_xml_err(xml, "Partial");
	}

	} else {
	int len = strlen(input);
	int lpc = 0;

	while(lpc < len) {
	crm_warn("Parse error[+%.3d]: %.80s", lpc, input+lpc);
	lpc += 80;
	}

	CRM_LOG_ASSERT("String parsing error");
	}
	}

	xmlFreeParserCtxt(ctxt);
	return xml;
	}

	xmlNode *
	stdin2xml(void)
	{
	size_t data_length = 0;
	size_t read_chars = 0;

	char *xml_buffer = NULL;
	xmlNode *xml_obj = NULL;

	do {
	xml_buffer = pcmk__realloc(xml_buffer, data_length + XML_BUFFER_SIZE);
	read_chars = fread(xml_buffer + data_length, 1, XML_BUFFER_SIZE, stdin);
	data_length += read_chars;
	} while (read_chars == XML_BUFFER_SIZE);

	if (data_length == 0) {
	crm_warn("No XML supplied on stdin");
	free(xml_buffer);
	return NULL;
	}

	xml_buffer[data_length] = '\0';
	xml_obj = string2xml(xml_buffer);
	free(xml_buffer);

	crm_log_xml_trace(xml_obj, "Created fragment");
	return xml_obj;
	}

	static char *
	decompress_file(const char *filename)
	{
	char *buffer = NULL;

	#if HAVE_BZLIB_H
	int rc = 0;
	size_t length = 0, read_len = 0;

	BZFILE *bz_file = NULL;
	FILE *input = fopen(filename, "r");

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

	bz_file = BZ2_bzReadOpen(&rc, input, 0, 0, NULL, 0);
	if (rc != BZ_OK) {
	crm_err("Could not prepare to read compressed %s: %s "
	CRM_XS " bzerror=%d", filename, bz2_strerror(rc), rc);
	BZ2_bzReadClose(&rc, bz_file);
	return NULL;
	}

	rc = BZ_OK;
	// cppcheck seems not to understand the abort-logic in pcmk__realloc
	// cppcheck-suppress memleak
	while (rc == BZ_OK) {
	buffer = pcmk__realloc(buffer, XML_BUFFER_SIZE + length + 1);
	read_len = BZ2_bzRead(&rc, bz_file, buffer + length, XML_BUFFER_SIZE);

	crm_trace("Read %ld bytes from file: %d", (long)read_len, rc);

	if (rc == BZ_OK \|\| rc == BZ_STREAM_END) {
	length += read_len;
	}
	}

	buffer[length] = '\0';

	if (rc != BZ_STREAM_END) {
	crm_err("Could not read compressed %s: %s "
	CRM_XS " bzerror=%d", filename, bz2_strerror(rc), rc);
	free(buffer);
	buffer = NULL;
	}

	BZ2_bzReadClose(&rc, bz_file);
	fclose(input);

	#else
	crm_err("Could not read compressed %s: not built with bzlib support",
	filename);
	#endif
	return buffer;
	}

	+/*!
	+ * \internal
	+ * \brief Remove XML text nodes from specified XML and all its children
	+ *
	+ * \param[in,out] xml XML to strip text from
	+ */
	void
	-strip_text_nodes(xmlNode * xml)
	+pcmk__strip_xml_text(xmlNode *xml)
	{
	xmlNode *iter = xml->children;

	while (iter) {
	xmlNode *next = iter->next;

	switch (iter->type) {
	case XML_TEXT_NODE:
	/* Remove it */
	pcmk_free_xml_subtree(iter);
	break;

	case XML_ELEMENT_NODE:
	/* Search it */
	- strip_text_nodes(iter);
	+ pcmk__strip_xml_text(iter);
	break;

	default:
	/* Leave it */
	break;
	}

	iter = next;
	}
	}

	xmlNode *
	filename2xml(const char *filename)
	{
	xmlNode *xml = NULL;
	xmlDocPtr output = NULL;
	gboolean uncompressed = TRUE;
	xmlParserCtxtPtr ctxt = NULL;
	xmlErrorPtr last_error = NULL;

	/* create a parser context */
	ctxt = xmlNewParserCtxt();
	CRM_CHECK(ctxt != NULL, return NULL);

	xmlCtxtResetLastError(ctxt);
	- xmlSetGenericErrorFunc(ctxt, crm_xml_err);
	+ xmlSetGenericErrorFunc(ctxt, log_xmllib_err);

	if (filename) {
	uncompressed = !pcmk__ends_with_ext(filename, ".bz2");
	}

	if (filename == NULL) {
	/* STDIN_FILENO == fileno(stdin) */
	output = xmlCtxtReadFd(ctxt, STDIN_FILENO, "unknown.xml", NULL,
	PCMK__XML_PARSE_OPTS);

	} else if (uncompressed) {
	output = xmlCtxtReadFile(ctxt, filename, NULL, PCMK__XML_PARSE_OPTS);

	} else {
	char *input = decompress_file(filename);

	output = xmlCtxtReadDoc(ctxt, (pcmkXmlStr) input, NULL, NULL,
	PCMK__XML_PARSE_OPTS);
	free(input);
	}

	if (output && (xml = xmlDocGetRootElement(output))) {
	- strip_text_nodes(xml);
	+ pcmk__strip_xml_text(xml);
	}

	last_error = xmlCtxtGetLastError(ctxt);
	if (last_error && last_error->code != XML_ERR_OK) {
	/* crm_abort(__FILE__,__func__,__LINE__, "last_error->code != XML_ERR_OK", TRUE, TRUE); */
	/*
	* http://xmlsoft.org/html/libxml-xmlerror.html#xmlErrorLevel
	* http://xmlsoft.org/html/libxml-xmlerror.html#xmlParserErrors
	*/
	crm_err("Parsing failed (domain=%d, level=%d, code=%d): %s",
	last_error->domain, last_error->level, last_error->code, last_error->message);

	if (last_error && last_error->code != XML_ERR_OK) {
	crm_err("Couldn't%s parse %s", xml ? " fully" : "", filename);
	if (xml != NULL) {
	crm_log_xml_err(xml, "Partial");
	}
	}
	}

	xmlFreeParserCtxt(ctxt);
	return xml;
	}

	/*!
	* \internal
	- * \brief Add a "last written" attribute to an XML node, set to current time
	+ * \brief Add a "last written" attribute to an XML element, set to current time
	*
	- * \param[in] xml_node XML node to get attribute
	+ * \param[in] xe XML element to add attribute to
	*
	* \return Value that was set, or NULL on error
	*/
	const char *
	-crm_xml_add_last_written(xmlNode *xml_node)
	+pcmk__xe_add_last_written(xmlNode *xe)
	{
	const char *now_str = pcmk__epoch2str(NULL);

	- return crm_xml_add(xml_node, XML_CIB_ATTR_WRITTEN,
	+ return crm_xml_add(xe, XML_CIB_ATTR_WRITTEN,
	now_str ? now_str : "Could not determine current time");
	}

	/*!
	* \brief Sanitize a string so it is usable as an XML ID
	*
	* \param[in,out] id String to sanitize
	*/
	void
	crm_xml_sanitize_id(char *id)
	{
	char *c;

	for (c = id; *c; ++c) {
	/* @TODO Sanitize more comprehensively */
	switch (*c) {
	case ':':
	case '#':
	*c = '.';
	}
	}
	}

	/*!
	* \brief Set the ID of an XML element using a format
	*
	* \param[in,out] xml XML element
	* \param[in] fmt printf-style format
	* \param[in] ... any arguments required by format
	*/
	void
	crm_xml_set_id(xmlNode xml, const char format, ...)
	{
	va_list ap;
	int len = 0;
	char *id = NULL;

	/* equivalent to crm_strdup_printf() */
	va_start(ap, format);
	len = vasprintf(&id, format, ap);
	va_end(ap);
	CRM_ASSERT(len > 0);

	crm_xml_sanitize_id(id);
	crm_xml_add(xml, XML_ATTR_ID, id);
	free(id);
	}

	/*!
	* \internal
	* \brief Write XML to a file stream
	*
	* \param[in] xml_node XML to write
	* \param[in] filename Name of file being written (for logging only)
	* \param[in] stream Open file stream corresponding to filename
	* \param[in] compress Whether to compress XML before writing
	+ * \param[out] nbytes Number of bytes written
	*
	- * \return Number of bytes written on success, -errno otherwise
	+ * \return Standard Pacemaker return code
	*/
	static int
	-write_xml_stream(xmlNode * xml_node, const char filename, FILE stream, gboolean compress)
	+write_xml_stream(xmlNode xml_node, const char filename, FILE *stream,
	+ bool compress, unsigned int *nbytes)
	{
	- int res = 0;
	+ int rc = pcmk_rc_ok;
	char *buffer = NULL;
	- unsigned int out = 0;

	+ *nbytes = 0;
	crm_log_xml_trace(xml_node, "writing");

	buffer = dump_xml_formatted(xml_node);
	CRM_CHECK(buffer && strlen(buffer),
	crm_log_xml_warn(xml_node, "formatting failed");
	- res = -pcmk_err_generic;
	+ rc = pcmk_rc_error;
	goto bail);

	if (compress) {
	#if HAVE_BZLIB_H
	- int rc = BZ_OK;
	unsigned int in = 0;
	BZFILE *bz_file = NULL;

	+ rc = BZ_OK;
	bz_file = BZ2_bzWriteOpen(&rc, stream, 5, 0, 30);
	if (rc != BZ_OK) {
	crm_warn("Not compressing %s: could not prepare file stream: %s "
	CRM_XS " bzerror=%d", filename, bz2_strerror(rc), rc);
	} else {
	BZ2_bzWrite(&rc, bz_file, buffer, strlen(buffer));
	if (rc != BZ_OK) {
	crm_warn("Not compressing %s: could not compress data: %s "
	CRM_XS " bzerror=%d errno=%d",
	filename, bz2_strerror(rc), rc, errno);
	}
	}

	if (rc == BZ_OK) {
	- BZ2_bzWriteClose(&rc, bz_file, 0, &in, &out);
	+ BZ2_bzWriteClose(&rc, bz_file, 0, &in, nbytes);
	if (rc != BZ_OK) {
	crm_warn("Not compressing %s: could not write compressed data: %s "
	CRM_XS " bzerror=%d errno=%d",
	filename, bz2_strerror(rc), rc, errno);
	- out = 0; // retry without compression
	+ *nbytes = 0; // retry without compression
	} else {
	- res = (int) out;
	crm_trace("Compressed XML for %s from %u bytes to %u",
	- filename, in, out);
	+ filename, in, *nbytes);
	}
	}
	+ rc = pcmk_rc_ok; // Either true, or we'll retry without compression
	#else
	crm_warn("Not compressing %s: not built with bzlib support", filename);
	#endif
	}

	- if (out == 0) {
	- res = fprintf(stream, "%s", buffer);
	- if (res < 0) {
	- res = -errno;
	+ if (*nbytes == 0) {
	+ rc = fprintf(stream, "%s", buffer);
	+ if (rc < 0) {
	+ rc = errno;
	crm_perror(LOG_ERR, "writing %s", filename);
	- goto bail;
	+ } else {
	+ *nbytes = (unsigned int) rc;
	+ rc = pcmk_rc_ok;
	}
	}

	bail:

	if (fflush(stream) != 0) {
	- res = -errno;
	+ rc = errno;
	crm_perror(LOG_ERR, "flushing %s", filename);
	}

	/* Don't report error if the file does not support synchronization */
	if (fsync(fileno(stream)) < 0 && errno != EROFS && errno != EINVAL) {
	- res = -errno;
	+ rc = errno;
	crm_perror(LOG_ERR, "synchronizing %s", filename);
	}

	fclose(stream);

	- crm_trace("Saved %d bytes%s to %s as XML",
	- res, ((out > 0)? " (compressed)" : ""), filename);
	+ crm_trace("Saved %d bytes to %s as XML", *nbytes, filename);
	free(buffer);

	- return res;
	+ return rc;
	}

	/*!
	* \brief Write XML to a file descriptor
	*
	* \param[in] xml_node XML to write
	* \param[in] filename Name of file being written (for logging only)
	* \param[in] fd Open file descriptor corresponding to filename
	* \param[in] compress Whether to compress XML before writing
	*
	* \return Number of bytes written on success, -errno otherwise
	*/
	int
	write_xml_fd(xmlNode * xml_node, const char *filename, int fd, gboolean compress)
	{
	FILE *stream = NULL;
	+ unsigned int nbytes = 0;
	+ int rc = pcmk_rc_ok;

	CRM_CHECK(xml_node && (fd > 0), return -EINVAL);
	stream = fdopen(fd, "w");
	if (stream == NULL) {
	return -errno;
	}
	- return write_xml_stream(xml_node, filename, stream, compress);
	+ rc = write_xml_stream(xml_node, filename, stream, compress, &nbytes);
	+ if (rc != pcmk_rc_ok) {
	+ return pcmk_rc2legacy(rc);
	+ }
	+ return (int) nbytes;
	}

	/*!
	* \brief Write XML to a file
	*
	* \param[in] xml_node XML to write
	* \param[in] filename Name of file to write
	* \param[in] compress Whether to compress XML before writing
	*
	* \return Number of bytes written on success, -errno otherwise
	*/
	int
	write_xml_file(xmlNode * xml_node, const char *filename, gboolean compress)
	{
	FILE *stream = NULL;
	+ unsigned int nbytes = 0;
	+ int rc = pcmk_rc_ok;

	CRM_CHECK(xml_node && filename, return -EINVAL);
	stream = fopen(filename, "w");
	if (stream == NULL) {
	return -errno;
	}
	- return write_xml_stream(xml_node, filename, stream, compress);
	+ rc = write_xml_stream(xml_node, filename, stream, compress, &nbytes);
	+ if (rc != pcmk_rc_ok) {
	+ return pcmk_rc2legacy(rc);
	+ }
	+ return (int) nbytes;
	}

	+// Replace a portion of a dynamically allocated string (reallocating memory)
	static char *
	-crm_xml_escape_shuffle(char text, int start, int length, const char *replace)
	+replace_text(char text, int start, int length, const char *replace)
	{
	int lpc;
	int offset = strlen(replace) - 1; /* We have space for 1 char already */

	*length += offset;
	text = pcmk__realloc(text, *length);

	for (lpc = (*length) - 1; lpc > (start + offset); lpc--) {
	text[lpc] = text[lpc - offset];
	}

	memcpy(text + start, replace, offset + 1);
	return text;
	}

	char *
	crm_xml_escape(const char *text)
	{
	int index;
	int changes = 0;
	int length = 1 + strlen(text);
	char *copy = strdup(text);

	/*
	* When xmlCtxtReadDoc() parses < and friends in a
	* value, it converts them to their human readable
	* form.
	*
	* If one uses xmlNodeDump() to convert it back to a
	* string, all is well, because special characters are
	* converted back to their escape sequences.
	*
	* However xmlNodeDump() is randomly dog slow, even with the same
	* input. So we need to replicate the escaping in our custom
	* version so that the result can be re-parsed by xmlCtxtReadDoc()
	* when necessary.
	*/

	for (index = 0; index < length; index++) {
	switch (copy[index]) {
	case 0:
	break;
	case '<':
	- copy = crm_xml_escape_shuffle(copy, index, &length, "<");
	+ copy = replace_text(copy, index, &length, "<");
	changes++;
	break;
	case '>':
	- copy = crm_xml_escape_shuffle(copy, index, &length, ">");
	+ copy = replace_text(copy, index, &length, ">");
	changes++;
	break;
	case '"':
	- copy = crm_xml_escape_shuffle(copy, index, &length, """);
	+ copy = replace_text(copy, index, &length, """);
	changes++;
	break;
	case '\'':
	- copy = crm_xml_escape_shuffle(copy, index, &length, "'");
	+ copy = replace_text(copy, index, &length, "'");
	changes++;
	break;
	case '&':
	- copy = crm_xml_escape_shuffle(copy, index, &length, "&");
	+ copy = replace_text(copy, index, &length, "&");
	changes++;
	break;
	case '\t':
	/* Might as well just expand to a few spaces... */
	- copy = crm_xml_escape_shuffle(copy, index, &length, " ");
	+ copy = replace_text(copy, index, &length, " ");
	changes++;
	break;
	case '\n':
	/* crm_trace("Convert: \\%.3o", copy[index]); */
	- copy = crm_xml_escape_shuffle(copy, index, &length, "\\n");
	+ copy = replace_text(copy, index, &length, "\\n");
	changes++;
	break;
	case '\r':
	- copy = crm_xml_escape_shuffle(copy, index, &length, "\\r");
	+ copy = replace_text(copy, index, &length, "\\r");
	changes++;
	break;
	/* For debugging...
	case '\\':
	crm_trace("Passthrough: \\%c", copy[index+1]);
	break;
	*/
	default:
	/* Check for and replace non-printing characters with their octal equivalent */
	if(copy[index] < ' ' \|\| copy[index] > '~') {
	char *replace = crm_strdup_printf("\\%.3o", copy[index]);

	/* crm_trace("Convert to octal: \\%.3o", copy[index]); */
	- copy = crm_xml_escape_shuffle(copy, index, &length, replace);
	+ copy = replace_text(copy, index, &length, replace);
	free(replace);
	changes++;
	}
	}
	}

	if (changes) {
	crm_trace("Dumped '%s'", copy);
	}
	return copy;
	}

	static inline void
	dump_xml_attr(xmlAttrPtr attr, int options, char *buffer, int offset, int *max)
	{
	char *p_value = NULL;
	const char *p_name = NULL;
	xml_private_t *p = NULL;

	CRM_ASSERT(buffer != NULL);
	if (attr == NULL \|\| attr->children == NULL) {
	return;
	}

	p = attr->_private;
	if (p && pcmk_is_set(p->flags, xpf_deleted)) {
	return;
	}

	p_name = (const char *)attr->name;
	p_value = crm_xml_escape((const char *)attr->children->content);
	buffer_print(buffer, max, *offset, " %s=\"%s\"", p_name, p_value);
	free(p_value);
	}

	+// Log an XML element (and any children) in a formatted way
	static void
	-__xml_log_element(int log_level, const char file, const char function, int line,
	- const char prefix, xmlNode data, int depth, int options)
	+log_xml_element(int log_level, const char file, const char function, int line,
	+ const char prefix, xmlNode data, int depth, int options)
	{
	int max = 0;
	int offset = 0;
	const char *name = NULL;
	const char *hidden = NULL;

	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;

	if ((data == NULL) \|\| (log_level == LOG_NEVER)) {
	return;
	}

	name = crm_element_name(data);

	if (pcmk_is_set(options, xml_log_option_open)) {
	char *buffer = NULL;

	insert_prefix(options, &buffer, &offset, &max, depth);

	if (data->type == XML_COMMENT_NODE) {
	buffer_print(buffer, max, offset, "<!--%s-->", data->content);

	} else {
	buffer_print(buffer, max, offset, "<%s", name);

	hidden = crm_element_value(data, "hidden");
	for (pIter = pcmk__first_xml_attr(data); pIter != NULL; pIter = pIter->next) {
	xml_private_t *p = pIter->_private;
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);
	char *p_copy = NULL;

	if (pcmk_is_set(p->flags, xpf_deleted)) {
	continue;
	} else if (pcmk_any_flags_set(options,
	xml_log_option_diff_plus
	\|xml_log_option_diff_minus)
	&& (strcmp(XML_DIFF_MARKER, p_name) == 0)) {
	continue;

	} else if (hidden != NULL && p_name[0] != 0 && strstr(hidden, p_name) != NULL) {
	p_copy = strdup("*****");

	} else {
	p_copy = crm_xml_escape(p_value);
	}

	buffer_print(buffer, max, offset, " %s=\"%s\"", p_name, p_copy);
	free(p_copy);
	}

	if(xml_has_children(data) == FALSE) {
	buffer_print(buffer, max, offset, "/>");

	} else if (pcmk_is_set(options, xml_log_option_children)) {
	buffer_print(buffer, max, offset, ">");

	} else {
	buffer_print(buffer, max, offset, "/>");
	}
	}

	do_crm_log_alias(log_level, file, function, line, "%s %s", prefix, buffer);
	free(buffer);
	}

	if(data->type == XML_COMMENT_NODE) {
	return;

	} else if(xml_has_children(data) == FALSE) {
	return;

	} else if (pcmk_is_set(options, xml_log_option_children)) {
	offset = 0;
	max = 0;

	for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) {
	- __xml_log_element(log_level, file, function, line, prefix, child, depth + 1, options\|xml_log_option_open\|xml_log_option_close);
	+ log_xml_element(log_level, file, function, line, prefix, child,
	+ depth + 1,
	+ options\|xml_log_option_open\|xml_log_option_close);
	}
	}

	if (pcmk_is_set(options, xml_log_option_close)) {
	char *buffer = NULL;

	insert_prefix(options, &buffer, &offset, &max, depth);
	buffer_print(buffer, max, offset, "</%s>", name);

	do_crm_log_alias(log_level, file, function, line, "%s %s", prefix, buffer);
	free(buffer);
	}
	}

	+// Log XML portions that have been marked as changed
	static void
	-__xml_log_change_element(int log_level, const char file, const char function, int line,
	- const char prefix, xmlNode data, int depth, int options)
	+log_xml_changes(int log_level, const char file, const char function, int line,
	+ const char prefix, xmlNode data, int depth, int options)
	{
	xml_private_t *p;
	char *prefix_m = NULL;
	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;

	if ((data == NULL) \|\| (log_level == LOG_NEVER)) {
	return;
	}

	p = data->_private;

	prefix_m = strdup(prefix);
	prefix_m[1] = '+';

	if (pcmk_all_flags_set(p->flags, xpf_dirty\|xpf_created)) {
	/* Continue and log full subtree */
	- __xml_log_element(log_level, file, function, line,
	- prefix_m, data, depth, options\|xml_log_option_open\|xml_log_option_close\|xml_log_option_children);
	+ log_xml_element(log_level, file, function, line, prefix_m, data, depth,
	+ options
	+ \|xml_log_option_open
	+ \|xml_log_option_close
	+ \|xml_log_option_children);

	} else if (pcmk_is_set(p->flags, xpf_dirty)) {
	char *spaces = calloc(80, 1);
	int s_count = 0, s_max = 80;
	char *prefix_del = NULL;
	char *prefix_moved = NULL;
	const char *flags = prefix;

	insert_prefix(options, &spaces, &s_count, &s_max, depth);
	prefix_del = strdup(prefix);
	prefix_del[0] = '-';
	prefix_del[1] = '-';
	prefix_moved = strdup(prefix);
	prefix_moved[1] = '~';

	if (pcmk_is_set(p->flags, xpf_moved)) {
	flags = prefix_moved;
	} else {
	flags = prefix;
	}

	- __xml_log_element(log_level, file, function, line,
	- flags, data, depth, options\|xml_log_option_open);
	+ log_xml_element(log_level, file, function, line, flags, data, depth,
	+ options\|xml_log_option_open);

	for (pIter = pcmk__first_xml_attr(data); pIter != NULL; pIter = pIter->next) {
	const char aname = (const char)pIter->name;

	p = pIter->_private;
	if (pcmk_is_set(p->flags, xpf_deleted)) {
	const char *value = crm_element_value(data, aname);
	flags = prefix_del;
	do_crm_log_alias(log_level, file, function, line,
	"%s %s @%s=%s", flags, spaces, aname, value);

	} else if (pcmk_is_set(p->flags, xpf_dirty)) {
	const char *value = crm_element_value(data, aname);

	if (pcmk_is_set(p->flags, xpf_created)) {
	flags = prefix_m;

	} else if (pcmk_is_set(p->flags, xpf_modified)) {
	flags = prefix;

	} else if (pcmk_is_set(p->flags, xpf_moved)) {
	flags = prefix_moved;

	} else {
	flags = prefix;
	}
	do_crm_log_alias(log_level, file, function, line,
	"%s %s @%s=%s", flags, spaces, aname, value);
	}
	}
	free(prefix_moved);
	free(prefix_del);
	free(spaces);

	for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) {
	- __xml_log_change_element(log_level, file, function, line, prefix, child, depth + 1, options);
	+ log_xml_changes(log_level, file, function, line, prefix, child,
	+ depth + 1, options);
	}

	- __xml_log_element(log_level, file, function, line,
	- prefix, data, depth, options\|xml_log_option_close);
	+ log_xml_element(log_level, file, function, line, prefix, data, depth,
	+ options\|xml_log_option_close);

	} else {
	for (child = __xml_first_child(data); child != NULL; child = __xml_next(child)) {
	- __xml_log_change_element(log_level, file, function, line, prefix, child, depth + 1, options);
	+ log_xml_changes(log_level, file, function, line, prefix, child,
	+ depth + 1, options);
	}
	}

	free(prefix_m);

	}

	void
	log_data_element(int log_level, const char file, const char function, int line,
	const char prefix, xmlNode data, int depth, int options)
	{
	xmlNode *a_child = NULL;

	char *prefix_m = NULL;

	if (log_level == LOG_NEVER) {
	return;
	}

	if (prefix == NULL) {
	prefix = "";
	}

	/* Since we use the same file and line, to avoid confusing libqb, we need to use the same format strings */
	if (data == NULL) {
	do_crm_log_alias(log_level, file, function, line, "%s: %s", prefix,
	"No data to dump as XML");
	return;
	}

	if (pcmk_is_set(options, xml_log_option_dirty_add)) {
	- __xml_log_change_element(log_level, file, function, line, prefix, data, depth, options);
	+ log_xml_changes(log_level, file, function, line, prefix, data, depth,
	+ options);
	return;
	}

	if (pcmk_is_set(options, xml_log_option_formatted)) {
	if (pcmk_is_set(options, xml_log_option_diff_plus)
	&& (data->children == NULL \|\| crm_element_value(data, XML_DIFF_MARKER))) {
	options \|= xml_log_option_diff_all;
	prefix_m = strdup(prefix);
	prefix_m[1] = '+';
	prefix = prefix_m;

	} else if (pcmk_is_set(options, xml_log_option_diff_minus)
	&& (data->children == NULL \|\| crm_element_value(data, XML_DIFF_MARKER))) {
	options \|= xml_log_option_diff_all;
	prefix_m = strdup(prefix);
	prefix_m[1] = '-';
	prefix = prefix_m;
	}
	}

	if (pcmk_is_set(options, xml_log_option_diff_short)
	&& !pcmk_is_set(options, xml_log_option_diff_all)) {
	/* Still searching for the actual change */
	for (a_child = __xml_first_child(data); a_child != NULL; a_child = __xml_next(a_child)) {
	log_data_element(log_level, file, function, line, prefix, a_child, depth + 1, options);
	}
	} else {
	- __xml_log_element(log_level, file, function, line, prefix, data, depth,
	- options\|xml_log_option_open\|xml_log_option_close\|xml_log_option_children);
	+ log_xml_element(log_level, file, function, line, prefix, data, depth,
	+ options
	+ \|xml_log_option_open
	+ \|xml_log_option_close
	+ \|xml_log_option_children);
	}
	free(prefix_m);
	}

	static void
	dump_filtered_xml(xmlNode * data, int options, char *buffer, int offset, int *max)
	{
	- int lpc;
	xmlAttrPtr xIter = NULL;
	- static int filter_len = DIMOF(filter);
	-
	- for (lpc = 0; options && lpc < filter_len; lpc++) {
	- filter[lpc].found = FALSE;
	- }

	for (xIter = pcmk__first_xml_attr(data); xIter != NULL; xIter = xIter->next) {
	- bool skip = FALSE;
	- const char p_name = (const char )xIter->name;
	-
	- for (lpc = 0; skip == FALSE && lpc < filter_len; lpc++) {
	- if (filter[lpc].found == FALSE && strcmp(p_name, filter[lpc].string) == 0) {
	- filter[lpc].found = TRUE;
	- skip = TRUE;
	- break;
	- }
	- }
	-
	- if (skip == FALSE) {
	+ if (!pcmk__xa_filterable((const char *) (xIter->name))) {
	dump_xml_attr(xIter, options, buffer, offset, max);
	}
	}
	}

	static void
	dump_xml_element(xmlNode * data, int options, char *buffer, int offset, int *max, int depth)
	{
	const char *name = NULL;

	CRM_ASSERT(max != NULL);
	CRM_ASSERT(offset != NULL);
	CRM_ASSERT(buffer != NULL);

	if (data == NULL) {
	crm_trace("Nothing to dump");
	return;
	}

	if (*buffer == NULL) {
	*offset = 0;
	*max = 0;
	}

	name = crm_element_name(data);
	CRM_ASSERT(name != NULL);

	insert_prefix(options, buffer, offset, max, depth);
	buffer_print(buffer, max, *offset, "<%s", name);

	if (options & xml_log_option_filtered) {
	dump_filtered_xml(data, options, buffer, offset, max);

	} else {
	xmlAttrPtr xIter = NULL;

	for (xIter = pcmk__first_xml_attr(data); xIter != NULL; xIter = xIter->next) {
	dump_xml_attr(xIter, options, buffer, offset, max);
	}
	}

	if (data->children == NULL) {
	buffer_print(buffer, max, *offset, "/>");

	} else {
	buffer_print(buffer, max, *offset, ">");
	}

	if (options & xml_log_option_formatted) {
	buffer_print(buffer, max, *offset, "\n");
	}

	if (data->children) {
	xmlNode *xChild = NULL;
	for(xChild = data->children; xChild != NULL; xChild = xChild->next) {
	- crm_xml_dump(xChild, options, buffer, offset, max, depth + 1);
	+ pcmk__xml2text(xChild, options, buffer, offset, max, depth + 1);
	}

	insert_prefix(options, buffer, offset, max, depth);
	buffer_print(buffer, max, *offset, "</%s>", name);

	if (options & xml_log_option_formatted) {
	buffer_print(buffer, max, *offset, "\n");
	}
	}
	}

	static void
	dump_xml_text(xmlNode * data, int options, char *buffer, int offset, int *max, int depth)
	{
	CRM_ASSERT(max != NULL);
	CRM_ASSERT(offset != NULL);
	CRM_ASSERT(buffer != NULL);

	if (data == NULL) {
	crm_trace("Nothing to dump");
	return;
	}

	if (*buffer == NULL) {
	*offset = 0;
	*max = 0;
	}

	insert_prefix(options, buffer, offset, max, depth);

	buffer_print(buffer, max, *offset, "%s", data->content);

	if (options & xml_log_option_formatted) {
	buffer_print(buffer, max, *offset, "\n");
	}
	}

	static void
	dump_xml_cdata(xmlNode * data, int options, char *buffer, int offset, int *max, int depth)
	{
	CRM_ASSERT(max != NULL);
	CRM_ASSERT(offset != NULL);
	CRM_ASSERT(buffer != NULL);

	if (data == NULL) {
	crm_trace("Nothing to dump");
	return;
	}

	if (*buffer == NULL) {
	*offset = 0;
	*max = 0;
	}

	insert_prefix(options, buffer, offset, max, depth);

	buffer_print(buffer, max, *offset, "<![CDATA[");
	buffer_print(buffer, max, *offset, "%s", data->content);
	buffer_print(buffer, max, *offset, "]]>");

	if (options & xml_log_option_formatted) {
	buffer_print(buffer, max, *offset, "\n");
	}
	}

	-
	static void
	dump_xml_comment(xmlNode * data, int options, char *buffer, int offset, int *max, int depth)
	{
	CRM_ASSERT(max != NULL);
	CRM_ASSERT(offset != NULL);
	CRM_ASSERT(buffer != NULL);

	if (data == NULL) {
	crm_trace("Nothing to dump");
	return;
	}

	if (*buffer == NULL) {
	*offset = 0;
	*max = 0;
	}

	insert_prefix(options, buffer, offset, max, depth);

	buffer_print(buffer, max, *offset, "<!--");
	buffer_print(buffer, max, *offset, "%s", data->content);
	buffer_print(buffer, max, *offset, "-->");

	if (options & xml_log_option_formatted) {
	buffer_print(buffer, max, *offset, "\n");
	}
	}

	#define PCMK__XMLDUMP_STATS 0

	+/*!
	+ * \internal
	+ * \brief Create a text representation of an XML object
	+ *
	+ * \param[in] data XML to convert
	+ * \param[in] options Group of enum xml_log_options flags
	+ * \param[in,out] buffer Buffer to store text in (may be reallocated)
	+ * \param[in,out] offset Current position of null terminator within \p buffer
	+ * \param[in,out] max Current size of \p buffer in bytes
	+ * \param[in] depth Current indentation level
	+ */
	void
	-crm_xml_dump(xmlNode * data, int options, char *buffer, int offset, int *max, int depth)
	+pcmk__xml2text(xmlNode data, int options, char buffer, int offset,
	+ int *max, int depth)
	{
	if(data == NULL) {
	*offset = 0;
	*max = 0;
	return;
	}

	if (!pcmk_is_set(options, xml_log_option_filtered)
	&& pcmk_is_set(options, xml_log_option_full_fledged)) {
	/* libxml's serialization reuse is a good idea, sadly we cannot
	apply it for the filtered cases (preceding filtering pass
	would preclude further reuse of such in-situ modified XML
	in generic context and is likely not a win performance-wise),
	and there's also a historically unstable throughput argument
	(likely stemming from memory allocation overhead, eventhough
	that shall be minimized with defaults preset in crm_xml_init) */
	#if (PCMK__XMLDUMP_STATS - 0)
	time_t next, new = time(NULL);
	#endif
	xmlDoc *doc;
	xmlOutputBuffer *xml_buffer;

	doc = getDocPtr(data);
	/* doc will only be NULL if data is */
	CRM_CHECK(doc != NULL, return);

	xml_buffer = xmlAllocOutputBuffer(NULL);
	CRM_ASSERT(xml_buffer != NULL);

	/* XXX we could setup custom allocation scheme for the particular
	buffer, but it's subsumed with crm_xml_init that needs to
	be invoked prior to entering this function as such, since
	its other branch vitally depends on it -- what can be done
	about this all is to have a facade parsing functions that
	would 100% mark entering libxml code for us, since we don't
	do anything as crazy as swapping out the binary form of the
	parsed tree (but those would need to be strictly used as
	opposed to libxml's raw functions) */

	xmlNodeDumpOutput(xml_buffer, doc, data, 0,
	(options & xml_log_option_formatted), NULL);
	/* attempt adding final NL - failing shouldn't be fatal here */
	(void) xmlOutputBufferWrite(xml_buffer, sizeof("\n") - 1, "\n");
	if (xml_buffer->buffer != NULL) {
	buffer_print(buffer, max, *offset, "%s",
	(char *) xmlBufContent(xml_buffer->buffer));
	}

	#if (PCMK__XMLDUMP_STATS - 0)
	next = time(NULL);
	if ((now + 1) < next) {
	crm_log_xml_trace(data, "Long time");
	crm_err("xmlNodeDump() -> %dbytes took %ds", *max, next - now);
	}
	#endif

	/* asserted allocation before so there should be something to remove */
	(void) xmlOutputBufferClose(xml_buffer);
	return;
	}

	switch(data->type) {
	case XML_ELEMENT_NODE:
	/* Handle below */
	dump_xml_element(data, options, buffer, offset, max, depth);
	break;
	case XML_TEXT_NODE:
	/* if option xml_log_option_text is enabled, then dump XML_TEXT_NODE */
	if (options & xml_log_option_text) {
	dump_xml_text(data, options, buffer, offset, max, depth);
	}
	return;
	case XML_COMMENT_NODE:
	dump_xml_comment(data, options, buffer, offset, max, depth);
	break;
	case XML_CDATA_SECTION_NODE:
	dump_xml_cdata(data, options, buffer, offset, max, depth);
	break;
	default:
	crm_warn("Unhandled type: %d", data->type);
	return;

	/*
	XML_ATTRIBUTE_NODE = 2
	XML_ENTITY_REF_NODE = 5
	XML_ENTITY_NODE = 6
	XML_PI_NODE = 7
	XML_DOCUMENT_NODE = 9
	XML_DOCUMENT_TYPE_NODE = 10
	XML_DOCUMENT_FRAG_NODE = 11
	XML_NOTATION_NODE = 12
	XML_HTML_DOCUMENT_NODE = 13
	XML_DTD_NODE = 14
	XML_ELEMENT_DECL = 15
	XML_ATTRIBUTE_DECL = 16
	XML_ENTITY_DECL = 17
	XML_NAMESPACE_DECL = 18
	XML_XINCLUDE_START = 19
	XML_XINCLUDE_END = 20
	XML_DOCB_DOCUMENT_NODE = 21
	*/
	}

	}

	+/*!
	+ * \internal
	+ * \brief Add a single character to a dynamically allocated buffer
	+ *
	+ * \param[in,out] buffer Buffer to store text in (may be reallocated)
	+ * \param[in,out] offset Current position of null terminator within \p buffer
	+ * \param[in,out] max Current size of \p buffer in bytes
	+ * \param[in] c Character to add to \p buffer
	+ */
	void
	-crm_buffer_add_char(char *buffer, int offset, int *max, char c)
	+pcmk__buffer_add_char(char *buffer, int offset, int *max, char c)
	{
	buffer_print(buffer, max, *offset, "%c", c);
	}

	char *
	dump_xml_formatted_with_text(xmlNode * an_xml_node)
	{
	char *buffer = NULL;
	int offset = 0, max = 0;

	- crm_xml_dump(an_xml_node,
	- xml_log_option_formatted\|xml_log_option_full_fledged,
	- &buffer, &offset, &max, 0);
	+ pcmk__xml2text(an_xml_node,
	+ xml_log_option_formatted\|xml_log_option_full_fledged,
	+ &buffer, &offset, &max, 0);
	return buffer;
	}

	char *
	dump_xml_formatted(xmlNode * an_xml_node)
	{
	char *buffer = NULL;
	int offset = 0, max = 0;

	- crm_xml_dump(an_xml_node, xml_log_option_formatted, &buffer, &offset, &max, 0);
	+ pcmk__xml2text(an_xml_node, xml_log_option_formatted, &buffer, &offset,
	+ &max, 0);
	return buffer;
	}

	char *
	dump_xml_unformatted(xmlNode * an_xml_node)
	{
	char *buffer = NULL;
	int offset = 0, max = 0;

	- crm_xml_dump(an_xml_node, 0, &buffer, &offset, &max, 0);
	+ pcmk__xml2text(an_xml_node, 0, &buffer, &offset, &max, 0);
	return buffer;
	}

	gboolean
	xml_has_children(const xmlNode * xml_root)
	{
	if (xml_root != NULL && xml_root->children != NULL) {
	return TRUE;
	}
	return FALSE;
	}

	void
	xml_remove_prop(xmlNode * obj, const char *name)
	{
	if (pcmk__check_acl(obj, NULL, xpf_acl_write) == FALSE) {
	crm_trace("Cannot remove %s from %s", name, obj->name);

	} else if (pcmk__tracking_xml_changes(obj, FALSE)) {
	/* Leave in place (marked for removal) until after the diff is calculated */
	xml_private_t *p = NULL;
	xmlAttr *attr = xmlHasProp(obj, (pcmkXmlStr) name);

	p = attr->_private;
	set_parent_flag(obj, xpf_dirty);
	pcmk__set_xml_flags(p, xpf_deleted);
	} else {
	xmlUnsetProp(obj, (pcmkXmlStr) name);
	}
	}

	void
	purge_diff_markers(xmlNode * a_node)
	{
	xmlNode *child = NULL;

	CRM_CHECK(a_node != NULL, return);

	xml_remove_prop(a_node, XML_DIFF_MARKER);
	for (child = __xml_first_child(a_node); child != NULL; child = __xml_next(child)) {
	purge_diff_markers(child);
	}
	}

	void
	save_xml_to_file(xmlNode * xml, const char desc, const char filename)
	{
	char *f = NULL;

	if (filename == NULL) {
	char *uuid = crm_generate_uuid();

	f = crm_strdup_printf("%s/%s", pcmk__get_tmpdir(), uuid);
	filename = f;
	free(uuid);
	}

	crm_info("Saving %s to %s", desc, filename);
	write_xml_file(xml, filename, FALSE);
	free(f);
	}

	gboolean
	apply_xml_diff(xmlNode old_xml, xmlNode diff, xmlNode **new_xml)
	{
	gboolean result = TRUE;
	int root_nodes_seen = 0;
	static struct qb_log_callsite *digest_cs = NULL;
	const char *digest = crm_element_value(diff, XML_ATTR_DIGEST);
	const char *version = crm_element_value(diff, XML_ATTR_CRM_VERSION);

	xmlNode *child_diff = NULL;
	xmlNode *added = find_xml_node(diff, "diff-added", FALSE);
	xmlNode *removed = find_xml_node(diff, "diff-removed", FALSE);

	CRM_CHECK(new_xml != NULL, return FALSE);
	if (digest_cs == NULL) {
	digest_cs =
	qb_log_callsite_get(__func__, __FILE__, "diff-digest", LOG_TRACE, __LINE__,
	crm_trace_nonlog);
	}

	crm_trace("Subtraction Phase");
	for (child_diff = __xml_first_child(removed); child_diff != NULL;
	child_diff = __xml_next(child_diff)) {
	CRM_CHECK(root_nodes_seen == 0, result = FALSE);
	if (root_nodes_seen == 0) {
	*new_xml = subtract_xml_object(NULL, old_xml, child_diff, FALSE, NULL, NULL);
	}
	root_nodes_seen++;
	}

	if (root_nodes_seen == 0) {
	*new_xml = copy_xml(old_xml);

	} else if (root_nodes_seen > 1) {
	crm_err("(-) Diffs cannot contain more than one change set..." " saw %d", root_nodes_seen);
	result = FALSE;
	}

	root_nodes_seen = 0;
	crm_trace("Addition Phase");
	if (result) {
	xmlNode *child_diff = NULL;

	for (child_diff = __xml_first_child(added); child_diff != NULL;
	child_diff = __xml_next(child_diff)) {
	CRM_CHECK(root_nodes_seen == 0, result = FALSE);
	if (root_nodes_seen == 0) {
	- add_xml_object(NULL, *new_xml, child_diff, TRUE);
	+ add_xml_object(NULL, *new_xml, child_diff, true);
	}
	root_nodes_seen++;
	}
	}

	if (root_nodes_seen > 1) {
	crm_err("(+) Diffs cannot contain more than one change set..." " saw %d", root_nodes_seen);
	result = FALSE;

	} else if (result && digest) {
	char *new_digest = NULL;

	purge_diff_markers(new_xml); / Purge now so the diff is ok */
	new_digest = calculate_xml_versioned_digest(*new_xml, FALSE, TRUE, version);
	if (!pcmk__str_eq(new_digest, digest, pcmk__str_casei)) {
	crm_info("Digest mis-match: expected %s, calculated %s", digest, new_digest);
	result = FALSE;

	crm_trace("%p %.6x", digest_cs, digest_cs ? digest_cs->targets : 0);
	if (digest_cs && digest_cs->targets) {
	save_xml_to_file(old_xml, "diff:original", NULL);
	save_xml_to_file(diff, "diff:input", NULL);
	save_xml_to_file(*new_xml, "diff:new", NULL);
	}

	} else {
	crm_trace("Digest matched: expected %s, calculated %s", digest, new_digest);
	}
	free(new_digest);

	} else if (result) {
	purge_diff_markers(new_xml); / Purge now so the diff is ok */
	}

	return result;
	}

	/*!
	* \internal
	* \brief Set a flag on all attributes of an XML element
	*
	* \param[in,out] xml XML node to set flags on
	* \param[in] flag XML private flag to set
	*/
	static void
	set_attrs_flag(xmlNode *xml, enum xml_private_flags flag)
	{
	for (xmlAttr *attr = pcmk__first_xml_attr(xml); attr; attr = attr->next) {
	pcmk__set_xml_flags((xml_private_t *) (attr->_private), flag);
	}
	}

	/*!
	* \internal
	* \brief Add an XML attribute to a node, marked as deleted
	*
	* When calculating XML changes, we need to know when an attribute has been
	* deleted. Add the attribute back to the new XML, so that we can check the
	* removal against ACLs, and mark it as deleted for later removal after
	* differences have been calculated.
	*/
	static void
	mark_attr_deleted(xmlNode new_xml, const char element, const char *attr_name,
	const char *old_value)
	{
	xml_private_t *p = new_xml->doc->_private;
	xmlAttr *attr = NULL;

	// Prevent the dirty flag being set recursively upwards
	pcmk__clear_xml_flags(p, xpf_tracking);

	// Restore the old value (and the tracking flag)
	attr = xmlSetProp(new_xml, (pcmkXmlStr) attr_name, (pcmkXmlStr) old_value);
	pcmk__set_xml_flags(p, xpf_tracking);

	// Reset flags (so the attribute doesn't appear as newly created)
	p = attr->_private;
	p->flags = 0;

	// Check ACLs and mark restored value for later removal
	xml_remove_prop(new_xml, attr_name);

	crm_trace("XML attribute %s=%s was removed from %s",
	attr_name, old_value, element);
	}

	/*
	* \internal
	* \brief Check ACLs for a changed XML attribute
	*/
	static void
	mark_attr_changed(xmlNode new_xml, const char element, const char *attr_name,
	const char *old_value)
	{
	char *vcopy = crm_element_value_copy(new_xml, attr_name);

	crm_trace("XML attribute %s was changed from '%s' to '%s' in %s",
	attr_name, old_value, vcopy, element);

	// Restore the original value
	xmlSetProp(new_xml, (pcmkXmlStr) attr_name, (pcmkXmlStr) old_value);

	// Change it back to the new value, to check ACLs
	crm_xml_add(new_xml, attr_name, vcopy);
	free(vcopy);
	}

	/*!
	* \internal
	* \brief Mark an XML attribute as having changed position
	*/
	static void
	mark_attr_moved(xmlNode new_xml, const char element, xmlAttr *old_attr,
	xmlAttr *new_attr, int p_old, int p_new)
	{
	xml_private_t *p = new_attr->_private;

	crm_trace("XML attribute %s moved from position %d to %d in %s",
	old_attr->name, p_old, p_new, element);

	// Mark document, element, and all element's parents as changed
	- __xml_node_dirty(new_xml);
	+ mark_xml_node_dirty(new_xml);

	// Mark attribute as changed
	pcmk__set_xml_flags(p, xpf_dirty\|xpf_moved);

	p = (p_old > p_new)? old_attr->_private : new_attr->_private;
	pcmk__set_xml_flags(p, xpf_skip);
	}

	/*!
	* \internal
	* \brief Calculate differences in all previously existing XML attributes
	*/
	static void
	xml_diff_old_attrs(xmlNode old_xml, xmlNode new_xml)
	{
	xmlAttr *attr_iter = pcmk__first_xml_attr(old_xml);

	while (attr_iter != NULL) {
	xmlAttr *old_attr = attr_iter;
	xmlAttr *new_attr = xmlHasProp(new_xml, attr_iter->name);
	const char name = (const char ) attr_iter->name;
	const char *old_value = crm_element_value(old_xml, name);

	attr_iter = attr_iter->next;
	if (new_attr == NULL) {
	mark_attr_deleted(new_xml, (const char *) old_xml->name, name,
	old_value);

	} else {
	xml_private_t *p = new_attr->_private;
	- int new_pos = __xml_offset((xmlNode*) new_attr);
	- int old_pos = __xml_offset((xmlNode*) old_attr);
	+ int new_pos = position_within_parent((xmlNode*) new_attr, xpf_skip);
	+ int old_pos = position_within_parent((xmlNode*) old_attr, xpf_skip);
	const char *new_value = crm_element_value(new_xml, name);

	// This attribute isn't new
	pcmk__clear_xml_flags(p, xpf_created);

	if (strcmp(new_value, old_value) != 0) {
	mark_attr_changed(new_xml, (const char *) old_xml->name, name,
	old_value);

	} else if ((old_pos != new_pos)
	&& !pcmk__tracking_xml_changes(new_xml, TRUE)) {
	mark_attr_moved(new_xml, (const char *) old_xml->name,
	old_attr, new_attr, old_pos, new_pos);
	}
	}
	}
	}

	/*!
	* \internal
	* \brief Check all attributes in new XML for creation
	*/
	static void
	mark_created_attrs(xmlNode *new_xml)
	{
	xmlAttr *attr_iter = pcmk__first_xml_attr(new_xml);

	while (attr_iter != NULL) {
	xmlAttr *new_attr = attr_iter;
	xml_private_t *p = attr_iter->_private;

	attr_iter = attr_iter->next;
	if (pcmk_is_set(p->flags, xpf_created)) {
	const char attr_name = (const char ) new_attr->name;

	crm_trace("Created new attribute %s=%s in %s",
	attr_name, crm_element_value(new_xml, attr_name),
	new_xml->name);

	/* Check ACLs (we can't use the remove-then-create trick because it
	* would modify the attribute position).
	*/
	if (pcmk__check_acl(new_xml, attr_name, xpf_acl_write)) {
	pcmk__mark_xml_attr_dirty(new_attr);
	} else {
	// Creation was not allowed, so remove the attribute
	xmlUnsetProp(new_xml, new_attr->name);
	}
	}
	}
	}

	/*!
	* \internal
	* \brief Calculate differences in attributes between two XML nodes
	*/
	static void
	xml_diff_attrs(xmlNode old_xml, xmlNode new_xml)
	{
	set_attrs_flag(new_xml, xpf_created); // cleared later if not really new
	xml_diff_old_attrs(old_xml, new_xml);
	mark_created_attrs(new_xml);
	}

	/*!
	* \internal
	* \brief Add an XML child element to a node, marked as deleted
	*
	* When calculating XML changes, we need to know when a child element has been
	* deleted. Add the child back to the new XML, so that we can check the removal
	* against ACLs, and mark it as deleted for later removal after differences have
	* been calculated.
	*/
	static void
	mark_child_deleted(xmlNode old_child, xmlNode new_parent)
	{
	// Re-create the child element so we can check ACLs
	xmlNode *candidate = add_node_copy(new_parent, old_child);

	// Clear flags on new child and its children
	- __xml_node_clean(candidate);
	+ reset_xml_node_flags(candidate);

	// Check whether ACLs allow the deletion
	pcmk__apply_acl(xmlDocGetRootElement(candidate->doc));

	// Remove the child again (which will track it in document's deleted_objs)
	- free_xml_with_position(candidate, __xml_offset(old_child));
	+ free_xml_with_position(candidate,
	+ position_within_parent(old_child, xpf_skip));

	if (find_element(new_parent, old_child, TRUE) == NULL) {
	pcmk__set_xml_flags((xml_private_t *) (old_child->_private), xpf_skip);
	}
	}

	static void
	mark_child_moved(xmlNode old_child, xmlNode new_parent, xmlNode *new_child,
	int p_old, int p_new)
	{
	xml_private_t *p = new_child->_private;

	crm_trace("Child element %s with id='%s' moved from position %d to %d under %s",
	new_child->name, (ID(new_child)? ID(new_child) : "<no id>"),
	p_old, p_new, new_parent->name);
	- __xml_node_dirty(new_parent);
	+ mark_xml_node_dirty(new_parent);
	pcmk__set_xml_flags(p, xpf_moved);

	if (p_old > p_new) {
	p = old_child->_private;
	} else {
	p = new_child->_private;
	}
	pcmk__set_xml_flags(p, xpf_skip);
	}

	+// Given original and new XML, mark new XML portions that have changed
	static void
	-__xml_diff_object(xmlNode old_xml, xmlNode new_xml, bool check_top)
	+mark_xml_changes(xmlNode old_xml, xmlNode new_xml, bool check_top)
	{
	xmlNode *cIter = NULL;
	xml_private_t *p = NULL;

	CRM_CHECK(new_xml != NULL, return);
	if (old_xml == NULL) {
	- crm_node_created(new_xml);
	+ mark_xml_node_created(new_xml);
	pcmk__apply_creation_acl(new_xml, check_top);
	return;
	}

	p = new_xml->_private;
	CRM_CHECK(p != NULL, return);

	if(p->flags & xpf_processed) {
	/* Avoid re-comparing nodes */
	return;
	}
	pcmk__set_xml_flags(p, xpf_processed);

	xml_diff_attrs(old_xml, new_xml);

	// Check for differences in the original children
	for (cIter = __xml_first_child(old_xml); cIter != NULL; ) {
	xmlNode *old_child = cIter;
	xmlNode *new_child = find_element(new_xml, cIter, TRUE);

	cIter = __xml_next(cIter);
	if(new_child) {
	- __xml_diff_object(old_child, new_child, TRUE);
	+ mark_xml_changes(old_child, new_child, TRUE);

	} else {
	mark_child_deleted(old_child, new_xml);
	}
	}

	// Check for moved or created children
	for (cIter = __xml_first_child(new_xml); cIter != NULL; ) {
	xmlNode *new_child = cIter;
	xmlNode *old_child = find_element(old_xml, cIter, TRUE);

	cIter = __xml_next(cIter);
	if(old_child == NULL) {
	// This is a newly created child
	p = new_child->_private;
	pcmk__set_xml_flags(p, xpf_skip);
	- __xml_diff_object(old_child, new_child, TRUE);
	+ mark_xml_changes(old_child, new_child, TRUE);

	} else {
	/* Check for movement, we already checked for differences */
	- int p_new = __xml_offset(new_child);
	- int p_old = __xml_offset(old_child);
	+ int p_new = position_within_parent(new_child, xpf_skip);
	+ int p_old = position_within_parent(old_child, xpf_skip);

	if(p_old != p_new) {
	mark_child_moved(old_child, new_xml, new_child, p_old, p_new);
	}
	}
	}
	}

	void
	xml_calculate_significant_changes(xmlNode old_xml, xmlNode new_xml)
	{
	pcmk__set_xml_doc_flag(new_xml, xpf_lazy);
	xml_calculate_changes(old_xml, new_xml);
	}

	void
	xml_calculate_changes(xmlNode old_xml, xmlNode new_xml)
	{
	CRM_CHECK(pcmk__str_eq(crm_element_name(old_xml), crm_element_name(new_xml), pcmk__str_casei),
	return);
	CRM_CHECK(pcmk__str_eq(ID(old_xml), ID(new_xml), pcmk__str_casei), return);

	if(xml_tracking_changes(new_xml) == FALSE) {
	xml_track_changes(new_xml, NULL, NULL, FALSE);
	}

	- __xml_diff_object(old_xml, new_xml, FALSE);
	+ mark_xml_changes(old_xml, new_xml, FALSE);
	}

	xmlNode *
	diff_xml_object(xmlNode * old, xmlNode * new, gboolean suppress)
	{
	xmlNode *tmp1 = NULL;
	xmlNode *diff = create_xml_node(NULL, "diff");
	xmlNode *removed = create_xml_node(diff, "diff-removed");
	xmlNode *added = create_xml_node(diff, "diff-added");

	crm_xml_add(diff, XML_ATTR_CRM_VERSION, CRM_FEATURE_SET);

	tmp1 = subtract_xml_object(removed, old, new, FALSE, NULL, "removed:top");
	if (suppress && tmp1 != NULL && can_prune_leaf(tmp1)) {
	free_xml(tmp1);
	}

	tmp1 = subtract_xml_object(added, new, old, TRUE, NULL, "added:top");
	if (suppress && tmp1 != NULL && can_prune_leaf(tmp1)) {
	free_xml(tmp1);
	}

	if (added->children == NULL && removed->children == NULL) {
	free_xml(diff);
	diff = NULL;
	}

	return diff;
	}

	gboolean
	can_prune_leaf(xmlNode * xml_node)
	{
	xmlNode *cIter = NULL;
	xmlAttrPtr pIter = NULL;
	gboolean can_prune = TRUE;
	const char *name = crm_element_name(xml_node);

	if (pcmk__strcase_any_of(name, XML_TAG_RESOURCE_REF, XML_CIB_TAG_OBJ_REF,
	XML_ACL_TAG_ROLE_REF, XML_ACL_TAG_ROLE_REFv1, NULL)) {
	return FALSE;
	}

	for (pIter = pcmk__first_xml_attr(xml_node); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;

	if (strcmp(p_name, XML_ATTR_ID) == 0) {
	continue;
	}
	can_prune = FALSE;
	}

	cIter = __xml_first_child(xml_node);
	while (cIter) {
	xmlNode *child = cIter;

	cIter = __xml_next(cIter);
	if (can_prune_leaf(child)) {
	free_xml(child);
	} else {
	can_prune = FALSE;
	}
	}
	return can_prune;
	}

	static xmlNode *
	find_xml_comment(xmlNode * root, xmlNode * search_comment, gboolean exact)
	{
	xmlNode *a_child = NULL;
	- int search_offset = __xml_offset(search_comment);
	+ int search_offset = position_within_parent(search_comment, xpf_skip);

	CRM_CHECK(search_comment->type == XML_COMMENT_NODE, return NULL);

	for (a_child = __xml_first_child(root); a_child != NULL; a_child = __xml_next(a_child)) {
	if (exact) {
	- int offset = __xml_offset(a_child);
	+ int offset = position_within_parent(a_child, xpf_skip);
	xml_private_t *p = a_child->_private;

	if (offset < search_offset) {
	continue;

	} else if (offset > search_offset) {
	return NULL;
	}

	if (pcmk_is_set(p->flags, xpf_skip)) {
	continue;
	}
	}

	if (a_child->type == XML_COMMENT_NODE
	&& pcmk__str_eq((const char )a_child->content, (const char )search_comment->content, pcmk__str_casei)) {
	return a_child;

	} else if (exact) {
	return NULL;
	}
	}

	return NULL;
	}

	static xmlNode *
	subtract_xml_comment(xmlNode * parent, xmlNode * left, xmlNode * right,
	gboolean * changed)
	{
	CRM_CHECK(left != NULL, return NULL);
	CRM_CHECK(left->type == XML_COMMENT_NODE, return NULL);

	if (right == NULL
	\|\| !pcmk__str_eq((const char )left->content, (const char )right->content, pcmk__str_casei)) {
	xmlNode *deleted = NULL;

	deleted = add_node_copy(parent, left);
	*changed = TRUE;

	return deleted;
	}

	return NULL;
	}

	xmlNode *
	subtract_xml_object(xmlNode * parent, xmlNode * left, xmlNode * right,
	gboolean full, gboolean * changed, const char *marker)
	{
	gboolean dummy = FALSE;
	- gboolean skip = FALSE;
	xmlNode *diff = NULL;
	xmlNode *right_child = NULL;
	xmlNode *left_child = NULL;
	xmlAttrPtr xIter = NULL;

	const char *id = NULL;
	const char *name = NULL;
	const char *value = NULL;
	const char *right_val = NULL;

	- int lpc = 0;
	- static int filter_len = DIMOF(filter);
	-
	if (changed == NULL) {
	changed = &dummy;
	}

	if (left == NULL) {
	return NULL;
	}

	if (left->type == XML_COMMENT_NODE) {
	return subtract_xml_comment(parent, left, right, changed);
	}

	id = ID(left);
	if (right == NULL) {
	xmlNode *deleted = NULL;

	crm_trace("Processing <%s id=%s> (complete copy)", crm_element_name(left), id);
	deleted = add_node_copy(parent, left);
	crm_xml_add(deleted, XML_DIFF_MARKER, marker);

	*changed = TRUE;
	return deleted;
	}

	name = crm_element_name(left);
	CRM_CHECK(name != NULL, return NULL);
	CRM_CHECK(pcmk__str_eq(crm_element_name(left), crm_element_name(right), pcmk__str_casei),
	return NULL);

	/* check for XML_DIFF_MARKER in a child */
	value = crm_element_value(right, XML_DIFF_MARKER);
	if (value != NULL && strcmp(value, "removed:top") == 0) {
	crm_trace("We are the root of the deletion: %s.id=%s", name, id);
	*changed = TRUE;
	return NULL;
	}

	/* Avoiding creating the full heirarchy would save even more work here */
	diff = create_xml_node(parent, name);

	- /* Reset filter */
	- for (lpc = 0; lpc < filter_len; lpc++) {
	- filter[lpc].found = FALSE;
	- }
	-
	/* changes to child objects */
	for (left_child = __xml_first_child(left); left_child != NULL;
	left_child = __xml_next(left_child)) {
	gboolean child_changed = FALSE;

	right_child = find_element(right, left_child, FALSE);
	subtract_xml_object(diff, left_child, right_child, full, &child_changed, marker);
	if (child_changed) {
	*changed = TRUE;
	}
	}

	if (*changed == FALSE) {
	/* Nothing to do */

	} else if (full) {
	xmlAttrPtr pIter = NULL;

	for (pIter = pcmk__first_xml_attr(left); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	xmlSetProp(diff, (pcmkXmlStr) p_name, (pcmkXmlStr) p_value);
	}

	/* We already have everything we need... */
	goto done;
	}

	/* changes to name/value pairs */
	for (xIter = pcmk__first_xml_attr(left); xIter != NULL; xIter = xIter->next) {
	const char prop_name = (const char )xIter->name;
	xmlAttrPtr right_attr = NULL;
	xml_private_t *p = NULL;

	if (strcmp(prop_name, XML_ATTR_ID) == 0) {
	/* id already obtained when present ~ this case, so just reuse */
	xmlSetProp(diff, (pcmkXmlStr) XML_ATTR_ID, (pcmkXmlStr) id);
	continue;
	}

	- skip = FALSE;
	- for (lpc = 0; skip == FALSE && lpc < filter_len; lpc++) {
	- if (filter[lpc].found == FALSE && strcmp(prop_name, filter[lpc].string) == 0) {
	- filter[lpc].found = TRUE;
	- skip = TRUE;
	- break;
	- }
	- }
	-
	- if (skip) {
	+ if (pcmk__xa_filterable(prop_name)) {
	continue;
	}

	right_attr = xmlHasProp(right, (pcmkXmlStr) prop_name);
	if (right_attr) {
	p = right_attr->_private;
	}

	right_val = crm_element_value(right, prop_name);
	if ((right_val == NULL) \|\| (p && pcmk_is_set(p->flags, xpf_deleted))) {
	/* new */
	*changed = TRUE;
	if (full) {
	xmlAttrPtr pIter = NULL;

	for (pIter = pcmk__first_xml_attr(left); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	xmlSetProp(diff, (pcmkXmlStr) p_name, (pcmkXmlStr) p_value);
	}
	break;

	} else {
	const char *left_value = crm_element_value(left, prop_name);

	xmlSetProp(diff, (pcmkXmlStr) prop_name, (pcmkXmlStr) value);
	crm_xml_add(diff, prop_name, left_value);
	}

	} else {
	/* Only now do we need the left value */
	const char *left_value = crm_element_value(left, prop_name);

	if (strcmp(left_value, right_val) == 0) {
	/* unchanged */

	} else {
	*changed = TRUE;
	if (full) {
	xmlAttrPtr pIter = NULL;

	crm_trace("Changes detected to %s in <%s id=%s>", prop_name,
	crm_element_name(left), id);
	for (pIter = pcmk__first_xml_attr(left); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	xmlSetProp(diff, (pcmkXmlStr) p_name, (pcmkXmlStr) p_value);
	}
	break;

	} else {
	crm_trace("Changes detected to %s (%s -> %s) in <%s id=%s>",
	prop_name, left_value, right_val, crm_element_name(left), id);
	crm_xml_add(diff, prop_name, left_value);
	}
	}
	}
	}

	if (*changed == FALSE) {
	free_xml(diff);
	return NULL;

	} else if (full == FALSE && id) {
	crm_xml_add(diff, XML_ATTR_ID, id);
	}
	done:
	return diff;
	}

	-static int
	-add_xml_comment(xmlNode * parent, xmlNode * target, xmlNode * update)
	+// Add or update XML comment "update" to "parent" at "target"
	+static void
	+add_xml_comment(xmlNode parent, xmlNode target, xmlNode *update)
	{
	- CRM_CHECK(update != NULL, return 0);
	- CRM_CHECK(update->type == XML_COMMENT_NODE, return 0);
	+ CRM_CHECK(update != NULL, return);
	+ CRM_CHECK(update->type == XML_COMMENT_NODE, return);

	if (target == NULL) {
	target = find_xml_comment(parent, update, FALSE);
	}

	if (target == NULL) {
	add_node_copy(parent, update);

	- /* We won't reach here currently */
	} else if (!pcmk__str_eq((const char )target->content, (const char )update->content, pcmk__str_casei)) {
	xmlFree(target->content);
	target->content = xmlStrdup(update->content);
	}
	-
	- return 0;
	}

	-static int
	-add_xml_object(xmlNode * parent, xmlNode * target, xmlNode * update, gboolean as_diff)
	+// Add or update XML "update" to "parent" at "target"
	+static void
	+add_xml_object(xmlNode parent, xmlNode target, xmlNode *update, bool as_diff)
	{
	xmlNode *a_child = NULL;
	const char *object_name = NULL,
	*object_href = NULL,
	*object_href_val = NULL;

	#if XML_PARSE_DEBUG
	crm_log_xml_trace("update:", update);
	crm_log_xml_trace("target:", target);
	#endif

	- CRM_CHECK(update != NULL, return 0);
	+ CRM_CHECK(update != NULL, return);

	if (update->type == XML_COMMENT_NODE) {
	- return add_xml_comment(parent, target, update);
	+ add_xml_comment(parent, target, update);
	+ return;
	}

	object_name = crm_element_name(update);
	object_href_val = ID(update);
	if (object_href_val != NULL) {
	object_href = XML_ATTR_ID;
	} else {
	object_href_val = crm_element_value(update, XML_ATTR_IDREF);
	object_href = (object_href_val == NULL) ? NULL : XML_ATTR_IDREF;
	}

	- CRM_CHECK(object_name != NULL, return 0);
	- CRM_CHECK(target != NULL \|\| parent != NULL, return 0);
	+ CRM_CHECK(object_name != NULL, return);
	+ CRM_CHECK(target != NULL \|\| parent != NULL, return);

	if (target == NULL) {
	- target = find_entity_by_attr_or_just_name(parent, object_name,
	- object_href, object_href_val);
	+ target = pcmk__xe_match(parent, object_name,
	+ object_href, object_href_val);
	}

	if (target == NULL) {
	target = create_xml_node(parent, object_name);
	- CRM_CHECK(target != NULL, return 0);
	+ CRM_CHECK(target != NULL, return);
	#if XML_PARSER_DEBUG
	crm_trace("Added <%s%s%s%s%s/>", crm_str(object_name),
	object_href ? " " : "",
	object_href ? object_href : "",
	object_href ? "=" : "",
	object_href ? object_href_val : "");

	} else {
	crm_trace("Found node <%s%s%s%s%s/> to update", crm_str(object_name),
	object_href ? " " : "",
	object_href ? object_href : "",
	object_href ? "=" : "",
	object_href ? object_href_val : "");
	#endif
	}

	- CRM_CHECK(pcmk__str_eq(crm_element_name(target), crm_element_name(update), pcmk__str_casei),
	- return 0);
	+ CRM_CHECK(pcmk__str_eq(crm_element_name(target), crm_element_name(update),
	+ pcmk__str_casei),
	+ return);

	if (as_diff == FALSE) {
	/* So that expand_plus_plus() gets called */
	copy_in_properties(target, update);

	} else {
	/* No need for expand_plus_plus(), just raw speed */
	xmlAttrPtr pIter = NULL;

	for (pIter = pcmk__first_xml_attr(update); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	/* Remove it first so the ordering of the update is preserved */
	xmlUnsetProp(target, (pcmkXmlStr) p_name);
	xmlSetProp(target, (pcmkXmlStr) p_name, (pcmkXmlStr) p_value);
	}
	}

	for (a_child = __xml_first_child(update); a_child != NULL; a_child = __xml_next(a_child)) {
	#if XML_PARSER_DEBUG
	crm_trace("Updating child <%s%s%s%s%s/>", crm_str(object_name),
	object_href ? " " : "",
	object_href ? object_href : "",
	object_href ? "=" : "",
	object_href ? object_href_val : "");
	#endif
	add_xml_object(target, NULL, a_child, as_diff);
	}

	#if XML_PARSER_DEBUG
	crm_trace("Finished with <%s%s%s%s%s/>", crm_str(object_name),
	object_href ? " " : "",
	object_href ? object_href : "",
	object_href ? "=" : "",
	object_href ? object_href_val : "");
	#endif
	- return 0;
	}

	gboolean
	update_xml_child(xmlNode * child, xmlNode * to_update)
	{
	gboolean can_update = TRUE;
	xmlNode *child_of_child = NULL;

	CRM_CHECK(child != NULL, return FALSE);
	CRM_CHECK(to_update != NULL, return FALSE);

	if (!pcmk__str_eq(crm_element_name(to_update), crm_element_name(child), pcmk__str_casei)) {
	can_update = FALSE;

	} else if (!pcmk__str_eq(ID(to_update), ID(child), pcmk__str_casei)) {
	can_update = FALSE;

	} else if (can_update) {
	#if XML_PARSER_DEBUG
	crm_log_xml_trace(child, "Update match found...");
	#endif
	- add_xml_object(NULL, child, to_update, FALSE);
	+ add_xml_object(NULL, child, to_update, false);
	}

	for (child_of_child = __xml_first_child(child); child_of_child != NULL;
	child_of_child = __xml_next(child_of_child)) {
	/* only update the first one */
	if (can_update) {
	break;
	}
	can_update = update_xml_child(child_of_child, to_update);
	}

	return can_update;
	}

	int
	find_xml_children(xmlNode ** children, xmlNode * root,
	const char tag, const char field, const char *value, gboolean search_matches)
	{
	int match_found = 0;

	CRM_CHECK(root != NULL, return FALSE);
	CRM_CHECK(children != NULL, return FALSE);

	if (tag != NULL && !pcmk__str_eq(tag, crm_element_name(root), pcmk__str_casei)) {

	} else if (value != NULL && !pcmk__str_eq(value, crm_element_value(root, field), pcmk__str_casei)) {

	} else {
	if (*children == NULL) {
	*children = create_xml_node(NULL, __func__);
	}
	add_node_copy(*children, root);
	match_found = 1;
	}

	if (search_matches \|\| match_found == 0) {
	xmlNode *child = NULL;

	for (child = __xml_first_child(root); child != NULL; child = __xml_next(child)) {
	match_found += find_xml_children(children, child, tag, field, value, search_matches);
	}
	}

	return match_found;
	}

	gboolean
	replace_xml_child(xmlNode * parent, xmlNode * child, xmlNode * update, gboolean delete_only)
	{
	gboolean can_delete = FALSE;
	xmlNode *child_of_child = NULL;

	const char *up_id = NULL;
	const char *child_id = NULL;
	const char *right_val = NULL;

	CRM_CHECK(child != NULL, return FALSE);
	CRM_CHECK(update != NULL, return FALSE);

	up_id = ID(update);
	child_id = ID(child);

	if (up_id == NULL \|\| (child_id && strcmp(child_id, up_id) == 0)) {
	can_delete = TRUE;
	}
	if (!pcmk__str_eq(crm_element_name(update), crm_element_name(child), pcmk__str_casei)) {
	can_delete = FALSE;
	}
	if (can_delete && delete_only) {
	xmlAttrPtr pIter = NULL;

	for (pIter = pcmk__first_xml_attr(update); pIter != NULL; pIter = pIter->next) {
	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	right_val = crm_element_value(child, p_name);
	if (!pcmk__str_eq(p_value, right_val, pcmk__str_casei)) {
	can_delete = FALSE;
	}
	}
	}

	if (can_delete && parent != NULL) {
	crm_log_xml_trace(child, "Delete match found...");
	if (delete_only \|\| update == NULL) {
	free_xml(child);

	} else {
	xmlNode *tmp = copy_xml(update);
	xmlDoc *doc = tmp->doc;
	xmlNode *old = NULL;

	xml_accept_changes(tmp);
	old = xmlReplaceNode(child, tmp);

	if(xml_tracking_changes(tmp)) {
	/* Replaced sections may have included relevant ACLs */
	pcmk__apply_acl(tmp);
	}

	xml_calculate_changes(old, tmp);
	xmlDocSetRootElement(doc, old);
	free_xml(old);
	}
	child = NULL;
	return TRUE;

	} else if (can_delete) {
	crm_log_xml_debug(child, "Cannot delete the search root");
	can_delete = FALSE;
	}

	child_of_child = __xml_first_child(child);
	while (child_of_child) {
	xmlNode *next = __xml_next(child_of_child);

	can_delete = replace_xml_child(child, child_of_child, update, delete_only);

	/* only delete the first one */
	if (can_delete) {
	child_of_child = NULL;
	} else {
	child_of_child = next;
	}
	}

	return can_delete;
	}

	xmlNode *
	sorted_xml(xmlNode input, xmlNode parent, gboolean recursive)
	{
	xmlNode *child = NULL;
	GSList *nvpairs = NULL;
	xmlNode *result = NULL;
	const char *name = NULL;

	CRM_CHECK(input != NULL, return NULL);

	name = crm_element_name(input);
	CRM_CHECK(name != NULL, return NULL);

	result = create_xml_node(parent, name);
	nvpairs = pcmk_xml_attrs2nvpairs(input);
	nvpairs = pcmk_sort_nvpairs(nvpairs);
	pcmk_nvpairs2xml_attrs(nvpairs, result);
	pcmk_free_nvpairs(nvpairs);

	for (child = __xml_first_child(input); child != NULL;
	child = __xml_next(child)) {

	if (recursive) {
	sorted_xml(child, result, recursive);
	} else {
	add_node_copy(result, child);
	}
	}

	return result;
	}

	xmlNode *
	first_named_child(const xmlNode parent, const char name)
	{
	xmlNode *match = NULL;

	for (match = __xml_first_child_element(parent); match != NULL;
	match = __xml_next_element(match)) {
	/*
	* name == NULL gives first child regardless of name; this is
	* semantically incorrect in this function, but may be necessary
	* due to prior use of xml_child_iter_filter
	*/
	if (pcmk__str_eq(name, (const char *)match->name, pcmk__str_null_matches)) {
	return match;
	}
	}
	return NULL;
	}

	/*!
	* \brief Get next instance of same XML tag
	*
	* \param[in] sibling XML tag to start from
	*
	* \return Next sibling XML tag with same name
	*/
	xmlNode *
	crm_next_same_xml(const xmlNode *sibling)
	{
	xmlNode *match = __xml_next_element(sibling);
	const char *name = crm_element_name(sibling);

	while (match != NULL) {
	if (!strcmp(crm_element_name(match), name)) {
	return match;
	}
	match = __xml_next_element(match);
	}
	return NULL;
	}

	void
	crm_xml_init(void)
	{
	static bool init = TRUE;

	if(init) {
	init = FALSE;
	/* The default allocator XML_BUFFER_ALLOC_EXACT does far too many
	* pcmk__realloc()s and it can take upwards of 18 seconds (yes, seconds)
	* to dump a 28kb tree which XML_BUFFER_ALLOC_DOUBLEIT can do in
	* less than 1 second.
	*/
	xmlSetBufferAllocationScheme(XML_BUFFER_ALLOC_DOUBLEIT);

	/* Populate and free the _private field when nodes are created and destroyed */
	- xmlDeregisterNodeDefault(pcmkDeregisterNode);
	- xmlRegisterNodeDefault(pcmkRegisterNode);
	+ xmlDeregisterNodeDefault(free_private_data);
	+ xmlRegisterNodeDefault(new_private_data);

	crm_schema_init();
	}
	}

	void
	crm_xml_cleanup(void)
	{
	crm_info("Cleaning up memory from libxml2");
	crm_schema_cleanup();
	xmlCleanupParser();
	}

	#define XPATH_MAX 512

	xmlNode *
	expand_idref(xmlNode * input, xmlNode * top)
	{
	const char *tag = NULL;
	const char *ref = NULL;
	xmlNode *result = input;

	if (result == NULL) {
	return NULL;

	} else if (top == NULL) {
	top = input;
	}

	tag = crm_element_name(result);
	ref = crm_element_value(result, XML_ATTR_IDREF);

	if (ref != NULL) {
	char *xpath_string = crm_strdup_printf("//%s[@id='%s']", tag, ref);

	result = get_xpath_object(xpath_string, top, LOG_ERR);
	if (result == NULL) {
	char nodePath = (char )xmlGetNodePath(top);

	crm_err("No match for %s found in %s: Invalid configuration", xpath_string,
	crm_str(nodePath));
	free(nodePath);
	}
	free(xpath_string);
	}
	return result;
	}

	void
	crm_destroy_xml(gpointer data)
	{
	free_xml(data);
	}

	char *
	pcmk__xml_artefact_root(enum pcmk__xml_artefact_ns ns)
	{
	static const char *base = NULL;
	char *ret = NULL;

	if (base == NULL) {
	base = getenv("PCMK_schema_directory");
	}
	if (pcmk__str_empty(base)) {
	base = CRM_SCHEMA_DIRECTORY;
	}

	switch (ns) {
	case pcmk__xml_artefact_ns_legacy_rng:
	case pcmk__xml_artefact_ns_legacy_xslt:
	ret = strdup(base);
	break;
	case pcmk__xml_artefact_ns_base_rng:
	case pcmk__xml_artefact_ns_base_xslt:
	ret = crm_strdup_printf("%s/base", base);
	break;
	default:
	crm_err("XML artefact family specified as %u not recognized", ns);
	}
	return ret;
	}

	char *
	pcmk__xml_artefact_path(enum pcmk__xml_artefact_ns ns, const char *filespec)
	{
	char base = pcmk__xml_artefact_root(ns), ret = NULL;

	switch (ns) {
	case pcmk__xml_artefact_ns_legacy_rng:
	case pcmk__xml_artefact_ns_base_rng:
	ret = crm_strdup_printf("%s/%s.rng", base, filespec);
	break;
	case pcmk__xml_artefact_ns_legacy_xslt:
	case pcmk__xml_artefact_ns_base_xslt:
	ret = crm_strdup_printf("%s/%s.xsl", base, filespec);
	break;
	default:
	crm_err("XML artefact family specified as %u not recognized", ns);
	}
	free(base);

	return ret;
	}
	+
	+// Deprecated functions kept only for backward API compatibility
	+xmlNode find_entity(xmlNode parent, const char node_name, const char id);
	+
	+xmlNode *
	+find_entity(xmlNode parent, const char node_name, const char *id)
	+{
	+ return pcmk__xe_match(parent, node_name,
	+ ((id == NULL)? id : XML_ATTR_ID), id);
	+}
	diff --git a/lib/pacemaker/pcmk_sched_utils.c b/lib/pacemaker/pcmk_sched_utils.c
	index 6cfb752dad..eaaf5261a3 100644
	--- a/lib/pacemaker/pcmk_sched_utils.c
	+++ b/lib/pacemaker/pcmk_sched_utils.c
	@@ -1,766 +1,767 @@
	/*
	* Copyright 2004-2020 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>
	#include <crm/msg_xml.h>
	#include <crm/lrmd.h> // lrmd_event_data_t
	+#include <crm/common/xml_internal.h>
	#include <pacemaker-internal.h>

	pe__location_t *
	rsc2node_new(const char id, pe_resource_t rsc,
	int node_weight, const char *discover_mode,
	pe_node_t foo_node, pe_working_set_t data_set)
	{
	pe__location_t *new_con = NULL;

	if (rsc == NULL \|\| id == NULL) {
	pe_err("Invalid constraint %s for rsc=%p", crm_str(id), rsc);
	return NULL;

	} else if (foo_node == NULL) {
	CRM_CHECK(node_weight == 0, return NULL);
	}

	new_con = calloc(1, sizeof(pe__location_t));
	if (new_con != NULL) {
	new_con->id = strdup(id);
	new_con->rsc_lh = rsc;
	new_con->node_list_rh = NULL;
	new_con->role_filter = RSC_ROLE_UNKNOWN;


	if (pcmk__str_eq(discover_mode, "always", pcmk__str_null_matches \| pcmk__str_casei)) {
	new_con->discover_mode = pe_discover_always;
	} else if (pcmk__str_eq(discover_mode, "never", pcmk__str_casei)) {
	new_con->discover_mode = pe_discover_never;
	} else if (pcmk__str_eq(discover_mode, "exclusive", pcmk__str_casei)) {
	new_con->discover_mode = pe_discover_exclusive;
	rsc->exclusive_discover = TRUE;
	} else {
	pe_err("Invalid %s value %s in location constraint", XML_LOCATION_ATTR_DISCOVERY, discover_mode);
	}

	if (foo_node != NULL) {
	pe_node_t *copy = pe__copy_node(foo_node);

	copy->weight = node_weight;
	new_con->node_list_rh = g_list_prepend(NULL, copy);
	}

	data_set->placement_constraints = g_list_prepend(data_set->placement_constraints, new_con);
	rsc->rsc_location = g_list_prepend(rsc->rsc_location, new_con);
	}

	return new_con;
	}

	gboolean
	can_run_resources(const pe_node_t * node)
	{
	if (node == NULL) {
	return FALSE;
	}
	#if 0
	if (node->weight < 0) {
	return FALSE;
	}
	#endif

	if (node->details->online == FALSE
	\|\| node->details->shutdown \|\| node->details->unclean
	\|\| node->details->standby \|\| node->details->maintenance) {
	crm_trace("%s: online=%d, unclean=%d, standby=%d, maintenance=%d",
	node->details->uname, node->details->online,
	node->details->unclean, node->details->standby, node->details->maintenance);
	return FALSE;
	}
	return TRUE;
	}

	/*!
	* \internal
	* \brief Copy a hash table of node objects
	*
	* \param[in] nodes Hash table to copy
	*
	* \return New copy of nodes (or NULL if nodes is NULL)
	*/
	GHashTable *
	pcmk__copy_node_table(GHashTable *nodes)
	{
	GHashTable *new_table = NULL;
	GHashTableIter iter;
	pe_node_t *node = NULL;

	if (nodes == NULL) {
	return NULL;
	}
	new_table = g_hash_table_new_full(crm_str_hash, g_str_equal, NULL, free);
	g_hash_table_iter_init(&iter, nodes);
	while (g_hash_table_iter_next(&iter, NULL, (gpointer *) &node)) {
	pe_node_t *new_node = pe__copy_node(node);

	g_hash_table_insert(new_table, (gpointer) new_node->details->id,
	new_node);
	}
	return new_table;
	}

	/*!
	* \internal
	* \brief Copy a list of node objects
	*
	* \param[in] list List to copy
	* \param[in] reset Set copies' scores to 0
	*
	* \return New list of shallow copies of nodes in original list
	*/
	GList *
	pcmk__copy_node_list(const GList *list, bool reset)
	{
	GList *result = NULL;

	for (const GList *gIter = list; gIter != NULL; gIter = gIter->next) {
	pe_node_t *new_node = NULL;
	pe_node_t this_node = (pe_node_t ) gIter->data;

	new_node = pe__copy_node(this_node);
	if (reset) {
	new_node->weight = 0;
	}
	result = g_list_prepend(result, new_node);
	}
	return result;
	}

	struct node_weight_s {
	pe_node_t *active;
	pe_working_set_t *data_set;
	};

	/* return -1 if 'a' is more preferred
	* return 1 if 'b' is more preferred
	*/

	static gint
	sort_node_weight(gconstpointer a, gconstpointer b, gpointer data)
	{
	const pe_node_t node1 = (const pe_node_t )a;
	const pe_node_t node2 = (const pe_node_t )b;
	struct node_weight_s *nw = data;

	int node1_weight = 0;
	int node2_weight = 0;

	int result = 0;

	if (a == NULL) {
	return 1;
	}
	if (b == NULL) {
	return -1;
	}

	node1_weight = node1->weight;
	node2_weight = node2->weight;

	if (can_run_resources(node1) == FALSE) {
	node1_weight = -INFINITY;
	}
	if (can_run_resources(node2) == FALSE) {
	node2_weight = -INFINITY;
	}

	if (node1_weight > node2_weight) {
	crm_trace("%s (%d) > %s (%d) : weight",
	node1->details->uname, node1_weight, node2->details->uname, node2_weight);
	return -1;
	}

	if (node1_weight < node2_weight) {
	crm_trace("%s (%d) < %s (%d) : weight",
	node1->details->uname, node1_weight, node2->details->uname, node2_weight);
	return 1;
	}

	crm_trace("%s (%d) == %s (%d) : weight",
	node1->details->uname, node1_weight, node2->details->uname, node2_weight);

	if (pcmk__str_eq(nw->data_set->placement_strategy, "minimal", pcmk__str_casei)) {
	goto equal;
	}

	if (pcmk__str_eq(nw->data_set->placement_strategy, "balanced", pcmk__str_casei)) {
	result = compare_capacity(node1, node2);
	if (result < 0) {
	crm_trace("%s > %s : capacity (%d)",
	node1->details->uname, node2->details->uname, result);
	return -1;
	} else if (result > 0) {
	crm_trace("%s < %s : capacity (%d)",
	node1->details->uname, node2->details->uname, result);
	return 1;
	}
	}

	/* now try to balance resources across the cluster */
	if (node1->details->num_resources < node2->details->num_resources) {
	crm_trace("%s (%d) > %s (%d) : resources",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return -1;

	} else if (node1->details->num_resources > node2->details->num_resources) {
	crm_trace("%s (%d) < %s (%d) : resources",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return 1;
	}

	if (nw->active && nw->active->details == node1->details) {
	crm_trace("%s (%d) > %s (%d) : active",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return -1;
	} else if (nw->active && nw->active->details == node2->details) {
	crm_trace("%s (%d) < %s (%d) : active",
	node1->details->uname, node1->details->num_resources,
	node2->details->uname, node2->details->num_resources);
	return 1;
	}
	equal:
	crm_trace("%s = %s", node1->details->uname, node2->details->uname);
	return strcmp(node1->details->uname, node2->details->uname);
	}

	GList *
	sort_nodes_by_weight(GList nodes, pe_node_t active_node,
	pe_working_set_t *data_set)
	{
	struct node_weight_s nw = { active_node, data_set };

	return g_list_sort_with_data(nodes, sort_node_weight, &nw);
	}

	void
	native_deallocate(pe_resource_t * rsc)
	{
	if (rsc->allocated_to) {
	pe_node_t *old = rsc->allocated_to;

	crm_info("Deallocating %s from %s", rsc->id, old->details->uname);
	pe__set_resource_flags(rsc, pe_rsc_provisional);
	rsc->allocated_to = NULL;

	old->details->allocated_rsc = g_list_remove(old->details->allocated_rsc, rsc);
	old->details->num_resources--;
	/* old->count--; */
	calculate_utilization(old->details->utilization, rsc->utilization, TRUE);
	free(old);
	}
	}

	gboolean
	native_assign_node(pe_resource_t * rsc, GListPtr nodes, pe_node_t * chosen, gboolean force)
	{
	CRM_ASSERT(rsc->variant == pe_native);

	if (force == FALSE && chosen != NULL) {
	bool unset = FALSE;

	if(chosen->weight < 0) {
	unset = TRUE;

	// Allow the graph to assume that the remote resource will come up
	} else if (!can_run_resources(chosen) && !pe__is_guest_node(chosen)) {
	unset = TRUE;
	}

	if(unset) {
	crm_debug("All nodes for resource %s are unavailable"
	", unclean or shutting down (%s: %d, %d)",
	rsc->id, chosen->details->uname, can_run_resources(chosen), chosen->weight);
	rsc->next_role = RSC_ROLE_STOPPED;
	chosen = NULL;
	}
	}

	/* todo: update the old node for each resource to reflect its
	* new resource count
	*/

	native_deallocate(rsc);
	pe__clear_resource_flags(rsc, pe_rsc_provisional);

	if (chosen == NULL) {
	GListPtr gIter = NULL;
	char *rc_inactive = crm_itoa(PCMK_OCF_NOT_RUNNING);

	crm_debug("Could not allocate a node for %s", rsc->id);
	rsc->next_role = RSC_ROLE_STOPPED;

	for (gIter = rsc->actions; gIter != NULL; gIter = gIter->next) {
	pe_action_t op = (pe_action_t ) gIter->data;
	const char *interval_ms_s = g_hash_table_lookup(op->meta, XML_LRM_ATTR_INTERVAL_MS);

	crm_debug("Processing %s", op->uuid);
	if(pcmk__str_eq(RSC_STOP, op->task, pcmk__str_casei)) {
	update_action_flags(op, pe_action_optional \| pe_action_clear,
	__func__, __LINE__);

	} else if(pcmk__str_eq(RSC_START, op->task, pcmk__str_casei)) {
	update_action_flags(op, pe_action_runnable \| pe_action_clear,
	__func__, __LINE__);
	//pe__set_resource_flags(rsc, pe_rsc_block);

	} else if (interval_ms_s && !pcmk__str_eq(interval_ms_s, "0", pcmk__str_casei)) {
	if(pcmk__str_eq(rc_inactive, g_hash_table_lookup(op->meta, XML_ATTR_TE_TARGET_RC), pcmk__str_casei)) {
	/* This is a recurring monitor for the stopped state, leave it alone */

	} else {
	/* Normal monitor operation, cancel it */
	update_action_flags(op, pe_action_runnable \| pe_action_clear,
	__func__, __LINE__);
	}
	}
	}

	free(rc_inactive);
	return FALSE;
	}

	crm_debug("Assigning %s to %s", chosen->details->uname, rsc->id);
	rsc->allocated_to = pe__copy_node(chosen);

	chosen->details->allocated_rsc = g_list_prepend(chosen->details->allocated_rsc, rsc);
	chosen->details->num_resources++;
	chosen->count++;
	calculate_utilization(chosen->details->utilization, rsc->utilization, FALSE);
	dump_rsc_utilization((show_utilization? LOG_STDOUT : LOG_TRACE),
	__func__, rsc, chosen);

	return TRUE;
	}

	void
	log_action(unsigned int log_level, const char pre_text, pe_action_t action, gboolean details)
	{
	const char *node_uname = NULL;
	const char *node_uuid = NULL;
	const char *desc = NULL;

	if (action == NULL) {
	crm_trace("%s%s: <NULL>", pre_text == NULL ? "" : pre_text, pre_text == NULL ? "" : ": ");
	return;
	}

	if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	node_uname = NULL;
	node_uuid = NULL;

	} else if (action->node != NULL) {
	node_uname = action->node->details->uname;
	node_uuid = action->node->details->id;
	} else {
	node_uname = "<none>";
	node_uuid = NULL;
	}

	switch (text2task(action->task)) {
	case stonith_node:
	case shutdown_crm:
	if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	desc = "Pseudo ";
	} else if (pcmk_is_set(action->flags, pe_action_optional)) {
	desc = "Optional ";
	} else if (!pcmk_is_set(action->flags, pe_action_runnable)) {
	desc = "!!Non-Startable!! ";
	} else if (pcmk_is_set(action->flags, pe_action_processed)) {
	desc = "";
	} else {
	desc = "(Provisional) ";
	}
	crm_trace("%s%s%sAction %d: %s%s%s%s%s%s",
	((pre_text == NULL)? "" : pre_text),
	((pre_text == NULL)? "" : ": "),
	desc, action->id, action->uuid,
	(node_uname? "\ton " : ""), (node_uname? node_uname : ""),
	(node_uuid? "\t\t(" : ""), (node_uuid? node_uuid : ""),
	(node_uuid? ")" : ""));
	break;
	default:
	if (pcmk_is_set(action->flags, pe_action_optional)) {
	desc = "Optional ";
	} else if (pcmk_is_set(action->flags, pe_action_pseudo)) {
	desc = "Pseudo ";
	} else if (!pcmk_is_set(action->flags, pe_action_runnable)) {
	desc = "!!Non-Startable!! ";
	} else if (pcmk_is_set(action->flags, pe_action_processed)) {
	desc = "";
	} else {
	desc = "(Provisional) ";
	}
	crm_trace("%s%s%sAction %d: %s %s%s%s%s%s%s",
	((pre_text == NULL)? "" : pre_text),
	((pre_text == NULL)? "" : ": "),
	desc, action->id, action->uuid,
	(action->rsc? action->rsc->id : "<none>"),
	(node_uname? "\ton " : ""), (node_uname? node_uname : ""),
	(node_uuid? "\t\t(" : ""), (node_uuid? node_uuid : ""),
	(node_uuid? ")" : ""));
	break;
	}

	if (details) {
	GListPtr gIter = NULL;

	crm_trace("\t\t====== Preceding Actions");

	gIter = action->actions_before;
	for (; gIter != NULL; gIter = gIter->next) {
	pe_action_wrapper_t other = (pe_action_wrapper_t ) gIter->data;

	log_action(log_level + 1, "\t\t", other->action, FALSE);
	}

	crm_trace("\t\t====== Subsequent Actions");

	gIter = action->actions_after;
	for (; gIter != NULL; gIter = gIter->next) {
	pe_action_wrapper_t other = (pe_action_wrapper_t ) gIter->data;

	log_action(log_level + 1, "\t\t", other->action, FALSE);
	}

	crm_trace("\t\t====== End");

	} else {
	crm_trace("\t\t(before=%d, after=%d)",
	g_list_length(action->actions_before), g_list_length(action->actions_after));
	}
	}

	gboolean
	can_run_any(GHashTable * nodes)
	{
	GHashTableIter iter;
	pe_node_t *node = NULL;

	if (nodes == NULL) {
	return FALSE;
	}

	g_hash_table_iter_init(&iter, nodes);
	while (g_hash_table_iter_next(&iter, NULL, (void **)&node)) {
	if (can_run_resources(node) && node->weight >= 0) {
	return TRUE;
	}
	}

	return FALSE;
	}

	pe_action_t *
	create_pseudo_resource_op(pe_resource_t * rsc, const char task, bool optional, bool runnable, pe_working_set_t data_set)
	{
	pe_action_t *action = custom_action(rsc, pcmk__op_key(rsc->id, task, 0),
	task, NULL, optional, TRUE, data_set);
	update_action_flags(action, pe_action_pseudo, __func__, __LINE__);
	update_action_flags(action, pe_action_runnable, __func__, __LINE__);
	if(runnable) {
	update_action_flags(action, pe_action_runnable, __func__, __LINE__);
	}
	return action;
	}

	/*!
	* \internal
	* \brief Create an executor cancel op
	*
	* \param[in] rsc Resource of action to cancel
	* \param[in] task Name of action to cancel
	* \param[in] interval_ms Interval of action to cancel
	* \param[in] node Node of action to cancel
	* \param[in] data_set Working set of cluster
	*
	* \return Created op
	*/
	pe_action_t *
	pe_cancel_op(pe_resource_t rsc, const char task, guint interval_ms,
	pe_node_t node, pe_working_set_t data_set)
	{
	pe_action_t *cancel_op;
	char *interval_ms_s = crm_strdup_printf("%u", interval_ms);

	// @TODO dangerous if possible to schedule another action with this key
	char *key = pcmk__op_key(rsc->id, task, interval_ms);

	cancel_op = custom_action(rsc, key, RSC_CANCEL, node, FALSE, TRUE,
	data_set);

	free(cancel_op->task);
	cancel_op->task = strdup(RSC_CANCEL);

	free(cancel_op->cancel_task);
	cancel_op->cancel_task = strdup(task);

	add_hash_param(cancel_op->meta, XML_LRM_ATTR_TASK, task);
	add_hash_param(cancel_op->meta, XML_LRM_ATTR_INTERVAL_MS, interval_ms_s);
	free(interval_ms_s);

	return cancel_op;
	}

	/*!
	* \internal
	* \brief Create a shutdown op for a scheduler transition
	*
	* \param[in] node Node being shut down
	* \param[in] data_set Working set of cluster
	*
	* \return Created op
	*/
	pe_action_t *
	sched_shutdown_op(pe_node_t node, pe_working_set_t data_set)
	{
	char *shutdown_id = crm_strdup_printf("%s-%s", CRM_OP_SHUTDOWN,
	node->details->uname);

	pe_action_t *shutdown_op = custom_action(NULL, shutdown_id, CRM_OP_SHUTDOWN,
	node, FALSE, TRUE, data_set);

	crm_notice("Scheduling shutdown of node %s", node->details->uname);
	shutdown_constraints(node, shutdown_op, data_set);
	add_hash_param(shutdown_op->meta, XML_ATTR_TE_NOWAIT, XML_BOOLEAN_TRUE);
	return shutdown_op;
	}

	static char *
	generate_transition_magic(const char *transition_key, int op_status, int op_rc)
	{
	CRM_CHECK(transition_key != NULL, return NULL);
	return crm_strdup_printf("%d:%d;%s", op_status, op_rc, transition_key);
	}

	static void
	append_digest(lrmd_event_data_t op, xmlNode update, const char *version,
	const char *magic, int level)
	{
	/* this will enable us to later determine that the
	* resource's parameters have changed and we should force
	* a restart
	*/
	char *digest = NULL;
	xmlNode *args_xml = NULL;

	if (op->params == NULL) {
	return;
	}

	args_xml = create_xml_node(NULL, XML_TAG_PARAMS);
	g_hash_table_foreach(op->params, hash2field, args_xml);
	pcmk__filter_op_for_digest(args_xml);
	digest = calculate_operation_digest(args_xml, version);

	#if 0
	if (level < get_crm_log_level()
	&& op->interval_ms == 0 && pcmk__str_eq(op->op_type, CRMD_ACTION_START, pcmk__str_none)) {
	char *digest_source = dump_xml_unformatted(args_xml);

	do_crm_log(level, "Calculated digest %s for %s (%s). Source: %s\n",
	digest, ID(update), magic, digest_source);
	free(digest_source);
	}
	#endif
	crm_xml_add(update, XML_LRM_ATTR_OP_DIGEST, digest);

	free_xml(args_xml);
	free(digest);
	}

	#define FAKE_TE_ID "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

	/*!
	* \internal
	* \brief Create XML for resource operation history update
	*
	* \param[in,out] parent Parent XML node to add to
	* \param[in,out] op Operation event data
	* \param[in] caller_version DC feature set
	* \param[in] target_rc Expected result of operation
	* \param[in] node Name of node on which operation was performed
	* \param[in] origin Arbitrary description of update source
	* \param[in] level A log message will be logged at this level
	*
	* \return Newly created XML node for history update
	*/
	xmlNode *
	pcmk__create_history_xml(xmlNode parent, lrmd_event_data_t op,
	const char *caller_version, int target_rc,
	const char node, const char origin, int level)
	{
	char *key = NULL;
	char *magic = NULL;
	char *op_id = NULL;
	char *op_id_additional = NULL;
	char *local_user_data = NULL;
	const char *exit_reason = NULL;

	xmlNode *xml_op = NULL;
	const char *task = NULL;

	CRM_CHECK(op != NULL, return NULL);
	do_crm_log(level, "%s: Updating resource %s after %s op %s (interval=%u)",
	origin, op->rsc_id, op->op_type, services_lrm_status_str(op->op_status),
	op->interval_ms);

	crm_trace("DC version: %s", caller_version);

	task = op->op_type;

	/* Record a successful reload as a start, and a failed reload as a monitor,
	* to make life easier for the scheduler when determining the current state.
	*/
	if (pcmk__str_eq(task, "reload", pcmk__str_none)) {
	if (op->op_status == PCMK_LRM_OP_DONE) {
	task = CRMD_ACTION_START;
	} else {
	task = CRMD_ACTION_STATUS;
	}
	}

	key = pcmk__op_key(op->rsc_id, task, op->interval_ms);
	if (pcmk__str_eq(task, CRMD_ACTION_NOTIFY, pcmk__str_none)) {
	const char *n_type = crm_meta_value(op->params, "notify_type");
	const char *n_task = crm_meta_value(op->params, "notify_operation");

	CRM_LOG_ASSERT(n_type != NULL);
	CRM_LOG_ASSERT(n_task != NULL);
	op_id = pcmk__notify_key(op->rsc_id, n_type, n_task);

	if (op->op_status != PCMK_LRM_OP_PENDING) {
	/* Ignore notify errors.
	*
	* @TODO It might be better to keep the correct result here, and
	* ignore it in process_graph_event().
	*/
	op->op_status = PCMK_LRM_OP_DONE;
	op->rc = 0;
	}

	} else if (did_rsc_op_fail(op, target_rc)) {
	op_id = pcmk__op_key(op->rsc_id, "last_failure", 0);
	if (op->interval_ms == 0) {
	// Ensure 'last' gets updated, in case record-pending is true
	op_id_additional = pcmk__op_key(op->rsc_id, "last", 0);
	}
	exit_reason = op->exit_reason;

	} else if (op->interval_ms > 0) {
	op_id = strdup(key);

	} else {
	op_id = pcmk__op_key(op->rsc_id, "last", 0);
	}

	again:
	- xml_op = find_entity(parent, XML_LRM_TAG_RSC_OP, op_id);
	+ xml_op = pcmk__xe_match(parent, XML_LRM_TAG_RSC_OP, XML_ATTR_ID, op_id);
	if (xml_op == NULL) {
	xml_op = create_xml_node(parent, XML_LRM_TAG_RSC_OP);
	}

	if (op->user_data == NULL) {
	crm_debug("Generating fake transition key for: " PCMK__OP_FMT
	" %d from %s", op->rsc_id, op->op_type, op->interval_ms,
	op->call_id, origin);
	local_user_data = pcmk__transition_key(-1, op->call_id, target_rc,
	FAKE_TE_ID);
	op->user_data = local_user_data;
	}

	if(magic == NULL) {
	magic = generate_transition_magic(op->user_data, op->op_status, op->rc);
	}

	crm_xml_add(xml_op, XML_ATTR_ID, op_id);
	crm_xml_add(xml_op, XML_LRM_ATTR_TASK_KEY, key);
	crm_xml_add(xml_op, XML_LRM_ATTR_TASK, task);
	crm_xml_add(xml_op, XML_ATTR_ORIGIN, origin);
	crm_xml_add(xml_op, XML_ATTR_CRM_VERSION, caller_version);
	crm_xml_add(xml_op, XML_ATTR_TRANSITION_KEY, op->user_data);
	crm_xml_add(xml_op, XML_ATTR_TRANSITION_MAGIC, magic);
	crm_xml_add(xml_op, XML_LRM_ATTR_EXIT_REASON, exit_reason == NULL ? "" : exit_reason);
	crm_xml_add(xml_op, XML_LRM_ATTR_TARGET, node); /* For context during triage */

	crm_xml_add_int(xml_op, XML_LRM_ATTR_CALLID, op->call_id);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_RC, op->rc);
	crm_xml_add_int(xml_op, XML_LRM_ATTR_OPSTATUS, op->op_status);
	crm_xml_add_ms(xml_op, XML_LRM_ATTR_INTERVAL_MS, op->interval_ms);

	if (compare_version("2.1", caller_version) <= 0) {
	if (op->t_run \|\| op->t_rcchange \|\| op->exec_time \|\| op->queue_time) {
	crm_trace("Timing data (" PCMK__OP_FMT
	"): last=%u change=%u exec=%u queue=%u",
	op->rsc_id, op->op_type, op->interval_ms,
	op->t_run, op->t_rcchange, op->exec_time, op->queue_time);

	if (op->interval_ms == 0) {
	crm_xml_add_ll(xml_op, XML_RSC_OP_LAST_CHANGE,
	(long long) op->t_run);

	// @COMPAT last-run is deprecated
	crm_xml_add_ll(xml_op, XML_RSC_OP_LAST_RUN,
	(long long) op->t_run);

	} else if(op->t_rcchange) {
	/* last-run is not accurate for recurring ops */
	crm_xml_add_ll(xml_op, XML_RSC_OP_LAST_CHANGE,
	(long long) op->t_rcchange);

	} else {
	/* ...but is better than nothing otherwise */
	crm_xml_add_ll(xml_op, XML_RSC_OP_LAST_CHANGE,
	(long long) op->t_run);
	}

	crm_xml_add_int(xml_op, XML_RSC_OP_T_EXEC, op->exec_time);
	crm_xml_add_int(xml_op, XML_RSC_OP_T_QUEUE, op->queue_time);
	}
	}

	if (pcmk__str_any_of(op->op_type, CRMD_ACTION_MIGRATE, CRMD_ACTION_MIGRATED, NULL)) {
	/*
	* Record migrate_source and migrate_target always for migrate ops.
	*/
	const char *name = XML_LRM_ATTR_MIGRATE_SOURCE;

	crm_xml_add(xml_op, name, crm_meta_value(op->params, name));

	name = XML_LRM_ATTR_MIGRATE_TARGET;
	crm_xml_add(xml_op, name, crm_meta_value(op->params, name));
	}

	append_digest(op, xml_op, caller_version, magic, LOG_DEBUG);

	if (op_id_additional) {
	free(op_id);
	op_id = op_id_additional;
	op_id_additional = NULL;
	goto again;
	}

	if (local_user_data) {
	free(local_user_data);
	op->user_data = NULL;
	}
	free(magic);
	free(op_id);
	free(key);
	return xml_op;
	}
	diff --git a/lib/pengine/complex.c b/lib/pengine/complex.c
	index 167e98a4dd..593a62768a 100644
	--- a/lib/pengine/complex.c
	+++ b/lib/pengine/complex.c
	@@ -1,995 +1,997 @@
	/*
	* Copyright 2004-2020 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 <crm/pengine/rules.h>
	#include <crm/pengine/internal.h>
	#include <crm/msg_xml.h>
	+#include <crm/common/xml_internal.h>

	void populate_hash(xmlNode * nvpair_list, GHashTable * hash, const char **attrs, int attrs_length);

	resource_object_functions_t resource_class_functions[] = {
	{
	native_unpack,
	native_find_rsc,
	native_parameter,
	native_print,
	native_active,
	native_resource_state,
	native_location,
	native_free,
	pe__count_common,
	pe__native_is_filtered,
	},
	{
	group_unpack,
	native_find_rsc,
	native_parameter,
	group_print,
	group_active,
	group_resource_state,
	native_location,
	group_free,
	pe__count_common,
	pe__group_is_filtered,
	},
	{
	clone_unpack,
	native_find_rsc,
	native_parameter,
	clone_print,
	clone_active,
	clone_resource_state,
	native_location,
	clone_free,
	pe__count_common,
	pe__clone_is_filtered,
	},
	{
	pe__unpack_bundle,
	native_find_rsc,
	native_parameter,
	pe__print_bundle,
	pe__bundle_active,
	pe__bundle_resource_state,
	native_location,
	pe__free_bundle,
	pe__count_bundle,
	pe__bundle_is_filtered,
	}
	};

	static enum pe_obj_types
	get_resource_type(const char *name)
	{
	if (pcmk__str_eq(name, XML_CIB_TAG_RESOURCE, pcmk__str_casei)) {
	return pe_native;

	} else if (pcmk__str_eq(name, XML_CIB_TAG_GROUP, pcmk__str_casei)) {
	return pe_group;

	} else if (pcmk__str_eq(name, XML_CIB_TAG_INCARNATION, pcmk__str_casei)) {
	return pe_clone;

	} else if (pcmk__str_eq(name, XML_CIB_TAG_MASTER, pcmk__str_casei)) {
	// @COMPAT deprecated since 2.0.0
	return pe_clone;

	} else if (pcmk__str_eq(name, XML_CIB_TAG_CONTAINER, pcmk__str_casei)) {
	return pe_container;
	}

	return pe_unknown;
	}

	static void
	dup_attr(gpointer key, gpointer value, gpointer user_data)
	{
	add_hash_param(user_data, key, value);
	}

	void
	get_meta_attributes(GHashTable * meta_hash, pe_resource_t * rsc,
	pe_node_t * node, pe_working_set_t * data_set)
	{
	pe_rsc_eval_data_t rsc_rule_data = {
	.standard = crm_element_value(rsc->xml, XML_AGENT_ATTR_CLASS),
	.provider = crm_element_value(rsc->xml, XML_AGENT_ATTR_PROVIDER),
	.agent = crm_element_value(rsc->xml, XML_EXPR_ATTR_TYPE)
	};

	pe_rule_eval_data_t rule_data = {
	.node_hash = NULL,
	.role = RSC_ROLE_UNKNOWN,
	.now = data_set->now,
	.match_data = NULL,
	.rsc_data = &rsc_rule_data,
	.op_data = NULL
	};

	if (node) {
	rule_data.node_hash = node->details->attrs;
	}

	if (rsc->xml) {
	xmlAttrPtr xIter = NULL;

	for (xIter = rsc->xml->properties; xIter; xIter = xIter->next) {
	const char prop_name = (const char )xIter->name;
	const char *prop_value = crm_element_value(rsc->xml, prop_name);

	add_hash_param(meta_hash, prop_name, prop_value);
	}
	}

	pe__unpack_dataset_nvpairs(rsc->xml, XML_TAG_META_SETS, &rule_data,
	meta_hash, NULL, FALSE, data_set);

	/* set anything else based on the parent */
	if (rsc->parent != NULL) {
	g_hash_table_foreach(rsc->parent->meta, dup_attr, meta_hash);
	}

	/* and finally check the defaults */
	pe__unpack_dataset_nvpairs(data_set->rsc_defaults, XML_TAG_META_SETS,
	&rule_data, meta_hash, NULL, FALSE, data_set);
	}

	void
	get_rsc_attributes(GHashTable * meta_hash, pe_resource_t * rsc,
	pe_node_t * node, pe_working_set_t * data_set)
	{
	pe_rule_eval_data_t rule_data = {
	.node_hash = NULL,
	.role = RSC_ROLE_UNKNOWN,
	.now = data_set->now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	if (node) {
	rule_data.node_hash = node->details->attrs;
	}

	pe__unpack_dataset_nvpairs(rsc->xml, XML_TAG_ATTR_SETS, &rule_data,
	meta_hash, NULL, FALSE, data_set);

	/* set anything else based on the parent */
	if (rsc->parent != NULL) {
	get_rsc_attributes(meta_hash, rsc->parent, node, data_set);

	} else {
	/* and finally check the defaults */
	pe__unpack_dataset_nvpairs(data_set->rsc_defaults, XML_TAG_ATTR_SETS,
	&rule_data, meta_hash, NULL, FALSE, data_set);
	}
	}

	#if ENABLE_VERSIONED_ATTRS
	void
	pe_get_versioned_attributes(xmlNode * meta_hash, pe_resource_t * rsc,
	pe_node_t * node, pe_working_set_t * data_set)
	{
	GHashTable *node_hash = NULL;

	if (node) {
	node_hash = node->details->attrs;
	}

	pe_unpack_versioned_attributes(data_set->input, rsc->xml, XML_TAG_ATTR_SETS, node_hash,
	meta_hash, data_set->now, NULL);

	/* set anything else based on the parent */
	if (rsc->parent != NULL) {
	pe_get_versioned_attributes(meta_hash, rsc->parent, node, data_set);

	} else {
	/* and finally check the defaults */
	pe_unpack_versioned_attributes(data_set->input, data_set->rsc_defaults, XML_TAG_ATTR_SETS,
	node_hash, meta_hash, data_set->now, NULL);
	}
	}
	#endif

	static char *
	template_op_key(xmlNode * op)
	{
	const char *name = crm_element_value(op, "name");
	const char *role = crm_element_value(op, "role");
	char *key = NULL;

	if (pcmk__str_eq(role, RSC_ROLE_STARTED_S, pcmk__str_null_matches)
	\|\| pcmk__str_eq(role, RSC_ROLE_SLAVE_S, pcmk__str_none)) {
	role = RSC_ROLE_UNKNOWN_S;
	}

	key = crm_strdup_printf("%s-%s", name, role);
	return key;
	}

	static gboolean
	unpack_template(xmlNode * xml_obj, xmlNode ** expanded_xml, pe_working_set_t * data_set)
	{
	xmlNode *cib_resources = NULL;
	xmlNode *template = NULL;
	xmlNode *new_xml = NULL;
	xmlNode *child_xml = NULL;
	xmlNode *rsc_ops = NULL;
	xmlNode *template_ops = NULL;
	const char *template_ref = NULL;
	const char *clone = NULL;
	const char *id = NULL;

	if (xml_obj == NULL) {
	pe_err("No resource object for template unpacking");
	return FALSE;
	}

	template_ref = crm_element_value(xml_obj, XML_CIB_TAG_RSC_TEMPLATE);
	if (template_ref == NULL) {
	return TRUE;
	}

	id = ID(xml_obj);
	if (id == NULL) {
	pe_err("'%s' object must have a id", crm_element_name(xml_obj));
	return FALSE;
	}

	if (pcmk__str_eq(template_ref, id, pcmk__str_none)) {
	pe_err("The resource object '%s' should not reference itself", id);
	return FALSE;
	}

	cib_resources = get_xpath_object("//"XML_CIB_TAG_RESOURCES, data_set->input, LOG_TRACE);
	if (cib_resources == NULL) {
	pe_err("No resources configured");
	return FALSE;
	}

	- template = find_entity(cib_resources, XML_CIB_TAG_RSC_TEMPLATE, template_ref);
	+ template = pcmk__xe_match(cib_resources, XML_CIB_TAG_RSC_TEMPLATE,
	+ XML_ATTR_ID, template_ref);
	if (template == NULL) {
	pe_err("No template named '%s'", template_ref);
	return FALSE;
	}

	new_xml = copy_xml(template);
	xmlNodeSetName(new_xml, xml_obj->name);
	crm_xml_replace(new_xml, XML_ATTR_ID, id);

	clone = crm_element_value(xml_obj, XML_RSC_ATTR_INCARNATION);
	if(clone) {
	crm_xml_add(new_xml, XML_RSC_ATTR_INCARNATION, clone);
	}

	template_ops = find_xml_node(new_xml, "operations", FALSE);

	for (child_xml = __xml_first_child_element(xml_obj); child_xml != NULL;
	child_xml = __xml_next_element(child_xml)) {
	xmlNode *new_child = NULL;

	new_child = add_node_copy(new_xml, child_xml);

	if (pcmk__str_eq((const char *)new_child->name, "operations", pcmk__str_none)) {
	rsc_ops = new_child;
	}
	}

	if (template_ops && rsc_ops) {
	xmlNode *op = NULL;
	GHashTable *rsc_ops_hash = g_hash_table_new_full(crm_str_hash,
	g_str_equal, free,
	NULL);

	for (op = __xml_first_child_element(rsc_ops); op != NULL;
	op = __xml_next_element(op)) {

	char *key = template_op_key(op);

	g_hash_table_insert(rsc_ops_hash, key, op);
	}

	for (op = __xml_first_child_element(template_ops); op != NULL;
	op = __xml_next_element(op)) {

	char *key = template_op_key(op);

	if (g_hash_table_lookup(rsc_ops_hash, key) == NULL) {
	add_node_copy(rsc_ops, op);
	}

	free(key);
	}

	if (rsc_ops_hash) {
	g_hash_table_destroy(rsc_ops_hash);
	}

	free_xml(template_ops);
	}

	/free_xml(expanded_xml); */
	*expanded_xml = new_xml;

	/* Disable multi-level templates for now */
	/*if(unpack_template(new_xml, expanded_xml, data_set) == FALSE) {
	free_xml(*expanded_xml);
	*expanded_xml = NULL;

	return FALSE;
	} */

	return TRUE;
	}

	static gboolean
	add_template_rsc(xmlNode * xml_obj, pe_working_set_t * data_set)
	{
	const char *template_ref = NULL;
	const char *id = NULL;

	if (xml_obj == NULL) {
	pe_err("No resource object for processing resource list of template");
	return FALSE;
	}

	template_ref = crm_element_value(xml_obj, XML_CIB_TAG_RSC_TEMPLATE);
	if (template_ref == NULL) {
	return TRUE;
	}

	id = ID(xml_obj);
	if (id == NULL) {
	pe_err("'%s' object must have a id", crm_element_name(xml_obj));
	return FALSE;
	}

	if (pcmk__str_eq(template_ref, id, pcmk__str_none)) {
	pe_err("The resource object '%s' should not reference itself", id);
	return FALSE;
	}

	if (add_tag_ref(data_set->template_rsc_sets, template_ref, id) == FALSE) {
	return FALSE;
	}

	return TRUE;
	}

	static bool
	detect_promotable(pe_resource_t *rsc)
	{
	const char *promotable = g_hash_table_lookup(rsc->meta,
	XML_RSC_ATTR_PROMOTABLE);

	if (crm_is_true(promotable)) {
	return TRUE;
	}

	// @COMPAT deprecated since 2.0.0
	if (pcmk__str_eq(crm_element_name(rsc->xml), XML_CIB_TAG_MASTER, pcmk__str_casei)) {
	/* @TODO in some future version, pe_warn_once() here,
	* then drop support in even later version
	*/
	g_hash_table_insert(rsc->meta, strdup(XML_RSC_ATTR_PROMOTABLE),
	strdup(XML_BOOLEAN_TRUE));
	return TRUE;
	}
	return FALSE;
	}

	gboolean
	common_unpack(xmlNode * xml_obj, pe_resource_t ** rsc,
	pe_resource_t * parent, pe_working_set_t * data_set)
	{
	bool isdefault = FALSE;
	xmlNode *expanded_xml = NULL;
	xmlNode *ops = NULL;
	const char *value = NULL;
	const char rclass = NULL; / Look for this after any templates have been expanded */
	const char *id = crm_element_value(xml_obj, XML_ATTR_ID);
	bool guest_node = FALSE;
	bool remote_node = FALSE;
	bool has_versioned_params = FALSE;

	pe_rule_eval_data_t rule_data = {
	.node_hash = NULL,
	.role = RSC_ROLE_UNKNOWN,
	.now = data_set->now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	crm_log_xml_trace(xml_obj, "Processing resource input...");

	if (id == NULL) {
	pe_err("Must specify id tag in <resource>");
	return FALSE;

	} else if (rsc == NULL) {
	pe_err("Nowhere to unpack resource into");
	return FALSE;

	}

	if (unpack_template(xml_obj, &expanded_xml, data_set) == FALSE) {
	return FALSE;
	}

	*rsc = calloc(1, sizeof(pe_resource_t));
	(*rsc)->cluster = data_set;

	if (expanded_xml) {
	crm_log_xml_trace(expanded_xml, "Expanded resource...");
	(*rsc)->xml = expanded_xml;
	(*rsc)->orig_xml = xml_obj;

	} else {
	(*rsc)->xml = xml_obj;
	(*rsc)->orig_xml = NULL;
	}

	/* Do not use xml_obj from here on, use (rsc)->xml in case templates are involved /
	rclass = crm_element_value((*rsc)->xml, XML_AGENT_ATTR_CLASS);
	(*rsc)->parent = parent;

	ops = find_xml_node((*rsc)->xml, "operations", FALSE);
	(*rsc)->ops_xml = expand_idref(ops, data_set->input);

	(rsc)->variant = get_resource_type(crm_element_name((rsc)->xml));
	if ((*rsc)->variant == pe_unknown) {
	pe_err("Unknown resource type: %s", crm_element_name((*rsc)->xml));
	free(*rsc);
	return FALSE;
	}

	(*rsc)->parameters = crm_str_table_new();

	#if ENABLE_VERSIONED_ATTRS
	(*rsc)->versioned_parameters = create_xml_node(NULL, XML_TAG_RSC_VER_ATTRS);
	#endif

	(*rsc)->meta = crm_str_table_new();

	(*rsc)->allowed_nodes =
	g_hash_table_new_full(crm_str_hash, g_str_equal, NULL, free);

	(*rsc)->known_on = g_hash_table_new_full(crm_str_hash, g_str_equal, NULL,
	free);

	value = crm_element_value((*rsc)->xml, XML_RSC_ATTR_INCARNATION);
	if (value) {
	(*rsc)->id = crm_strdup_printf("%s:%s", id, value);
	add_hash_param((*rsc)->meta, XML_RSC_ATTR_INCARNATION, value);

	} else {
	(*rsc)->id = strdup(id);
	}

	(rsc)->fns = &resource_class_functions[(rsc)->variant];
	pe_rsc_trace((*rsc), "Unpacking resource...");

	get_meta_attributes((rsc)->meta, rsc, NULL, data_set);
	get_rsc_attributes((rsc)->parameters, rsc, NULL, data_set);
	#if ENABLE_VERSIONED_ATTRS
	pe_get_versioned_attributes((rsc)->versioned_parameters, rsc, NULL, data_set);
	#endif

	(*rsc)->flags = 0;
	pe__set_resource_flags(*rsc, pe_rsc_runnable\|pe_rsc_provisional);

	if (!pcmk_is_set(data_set->flags, pe_flag_maintenance_mode)) {
	pe__set_resource_flags(*rsc, pe_rsc_managed);
	}

	(*rsc)->rsc_cons = NULL;
	(*rsc)->rsc_tickets = NULL;
	(*rsc)->actions = NULL;
	(*rsc)->role = RSC_ROLE_STOPPED;
	(*rsc)->next_role = RSC_ROLE_UNKNOWN;

	(*rsc)->recovery_type = recovery_stop_start;
	(*rsc)->stickiness = 0;
	(*rsc)->migration_threshold = INFINITY;
	(*rsc)->failure_timeout = 0;

	value = g_hash_table_lookup((*rsc)->meta, XML_CIB_ATTR_PRIORITY);
	(*rsc)->priority = crm_parse_int(value, "0");

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_NOTIFY);
	if (crm_is_true(value)) {
	pe__set_resource_flags(*rsc, pe_rsc_notify);
	}

	if (xml_contains_remote_node((*rsc)->xml)) {
	(*rsc)->is_remote_node = TRUE;
	if (g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_CONTAINER)) {
	guest_node = TRUE;
	} else {
	remote_node = TRUE;
	}
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_OP_ATTR_ALLOW_MIGRATE);
	#if ENABLE_VERSIONED_ATTRS
	has_versioned_params = xml_has_children((*rsc)->versioned_parameters);
	#endif
	if (crm_is_true(value) && has_versioned_params) {
	pe_rsc_trace((*rsc), "Migration is disabled for resources with versioned parameters");
	} else if (crm_is_true(value)) {
	pe__set_resource_flags(*rsc, pe_rsc_allow_migrate);
	} else if ((value == NULL) && remote_node && !has_versioned_params) {
	/* By default, we want remote nodes to be able
	* to float around the cluster without having to stop all the
	* resources within the remote-node before moving. Allowing
	* migration support enables this feature. If this ever causes
	* problems, migration support can be explicitly turned off with
	* allow-migrate=false.
	* We don't support migration for versioned resources, though. */
	pe__set_resource_flags(*rsc, pe_rsc_allow_migrate);
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_MANAGED);
	if (value != NULL && !pcmk__str_eq("default", value, pcmk__str_casei)) {
	if (crm_is_true(value)) {
	pe__set_resource_flags(*rsc, pe_rsc_managed);
	} else {
	pe__clear_resource_flags(*rsc, pe_rsc_managed);
	}
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_MAINTENANCE);
	if (crm_is_true(value)) {
	pe__clear_resource_flags(*rsc, pe_rsc_managed);
	pe__set_resource_flags(*rsc, pe_rsc_maintenance);
	}
	if (pcmk_is_set(data_set->flags, pe_flag_maintenance_mode)) {
	pe__clear_resource_flags(*rsc, pe_rsc_managed);
	pe__set_resource_flags(*rsc, pe_rsc_maintenance);
	}

	if (pe_rsc_is_clone(uber_parent(*rsc))) {
	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_UNIQUE);
	if (crm_is_true(value)) {
	pe__set_resource_flags(*rsc, pe_rsc_unique);
	}
	if (detect_promotable(*rsc)) {
	pe__set_resource_flags(*rsc, pe_rsc_promotable);
	}
	} else {
	pe__set_resource_flags(*rsc, pe_rsc_unique);
	}

	pe_rsc_trace((rsc), "Options for %s", (rsc)->id);

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_RESTART);
	if (pcmk__str_eq(value, "restart", pcmk__str_casei)) {
	(*rsc)->restart_type = pe_restart_restart;
	pe_rsc_trace((*rsc), "\tDependency restart handling: restart");
	pe_warn_once(pe_wo_restart_type,
	"Support for restart-type is deprecated and will be removed in a future release");

	} else {
	(*rsc)->restart_type = pe_restart_ignore;
	pe_rsc_trace((*rsc), "\tDependency restart handling: ignore");
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_MULTIPLE);
	if (pcmk__str_eq(value, "stop_only", pcmk__str_casei)) {
	(*rsc)->recovery_type = recovery_stop_only;
	pe_rsc_trace((*rsc), "\tMultiple running resource recovery: stop only");

	} else if (pcmk__str_eq(value, "block", pcmk__str_casei)) {
	(*rsc)->recovery_type = recovery_block;
	pe_rsc_trace((*rsc), "\tMultiple running resource recovery: block");

	} else {
	(*rsc)->recovery_type = recovery_stop_start;
	pe_rsc_trace((*rsc), "\tMultiple running resource recovery: stop/start");
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_STICKINESS);
	if (value != NULL && !pcmk__str_eq("default", value, pcmk__str_casei)) {
	(*rsc)->stickiness = char2score(value);
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_FAIL_STICKINESS);
	if (value != NULL && !pcmk__str_eq("default", value, pcmk__str_casei)) {
	(*rsc)->migration_threshold = char2score(value);
	if ((*rsc)->migration_threshold < 0) {
	/* @TODO We use 1 here to preserve previous behavior, but this
	* should probably use the default (INFINITY) or 0 (to disable)
	* instead.
	*/
	pe_warn_once(pe_wo_neg_threshold,
	XML_RSC_ATTR_FAIL_STICKINESS
	" must be non-negative, using 1 instead");
	(*rsc)->migration_threshold = 1;
	}
	}

	if (pcmk__str_eq(rclass, PCMK_RESOURCE_CLASS_STONITH, pcmk__str_casei)) {
	pe__set_working_set_flags(data_set, pe_flag_have_stonith_resource);
	pe__set_resource_flags(*rsc, pe_rsc_fence_device);
	}

	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_REQUIRES);

	handle_requires_pref:
	if (pcmk__str_eq(value, "nothing", pcmk__str_casei)) {

	} else if (pcmk__str_eq(value, "quorum", pcmk__str_casei)) {
	pe__set_resource_flags(*rsc, pe_rsc_needs_quorum);

	} else if (pcmk__str_eq(value, "unfencing", pcmk__str_casei)) {
	if (pcmk_is_set((*rsc)->flags, pe_rsc_fence_device)) {
	pcmk__config_warn("Resetting '" XML_RSC_ATTR_REQUIRES "' for %s "
	"to 'quorum' because fencing devices cannot "
	"require unfencing", (*rsc)->id);
	value = "quorum";
	isdefault = TRUE;
	goto handle_requires_pref;

	} else if (!pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)) {
	pcmk__config_warn("Resetting '" XML_RSC_ATTR_REQUIRES "' for %s "
	"to 'quorum' because fencing is disabled",
	(*rsc)->id);
	value = "quorum";
	isdefault = TRUE;
	goto handle_requires_pref;

	} else {
	pe__set_resource_flags(*rsc, pe_rsc_needs_fencing
	\|pe_rsc_needs_unfencing);
	}

	} else if (pcmk__str_eq(value, "fencing", pcmk__str_casei)) {
	pe__set_resource_flags(*rsc, pe_rsc_needs_fencing);
	if (!pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)) {
	pcmk__config_warn("%s requires fencing but fencing is disabled",
	(*rsc)->id);
	}

	} else {
	const char *orig_value = value;

	isdefault = TRUE;
	if (pcmk_is_set((*rsc)->flags, pe_rsc_fence_device)) {
	value = "quorum";

	} else if (((*rsc)->variant == pe_native)
	&& pcmk__str_eq(crm_element_value((*rsc)->xml, XML_AGENT_ATTR_CLASS), PCMK_RESOURCE_CLASS_OCF, pcmk__str_casei)
	&& pcmk__str_eq(crm_element_value((*rsc)->xml, XML_AGENT_ATTR_PROVIDER), "pacemaker", pcmk__str_casei)
	&& pcmk__str_eq(crm_element_value((*rsc)->xml, XML_ATTR_TYPE), "remote", pcmk__str_casei)
	) {
	value = "quorum";

	} else if (pcmk_is_set(data_set->flags, pe_flag_enable_unfencing)) {
	value = "unfencing";

	} else if (pcmk_is_set(data_set->flags, pe_flag_stonith_enabled)) {
	value = "fencing";

	} else if (data_set->no_quorum_policy == no_quorum_ignore) {
	value = "nothing";

	} else {
	value = "quorum";
	}

	if (orig_value != NULL) {
	pcmk__config_err("Resetting '" XML_RSC_ATTR_REQUIRES "' for %s "
	"to '%s' because '%s' is not valid",
	(*rsc)->id, value, orig_value);
	}

	goto handle_requires_pref;
	}

	pe_rsc_trace((*rsc), "\tRequired to start: %s%s", value, isdefault?" (default)":"");
	value = g_hash_table_lookup((*rsc)->meta, XML_RSC_ATTR_FAIL_TIMEOUT);
	if (value != NULL) {
	// Stored as seconds
	(*rsc)->failure_timeout = (int) (crm_parse_interval_spec(value) / 1000);
	}

	if (remote_node) {
	value = g_hash_table_lookup((*rsc)->parameters, XML_REMOTE_ATTR_RECONNECT_INTERVAL);
	if (value) {
	/* reconnect delay works by setting failure_timeout and preventing the
	* connection from starting until the failure is cleared. */
	(*rsc)->remote_reconnect_ms = crm_parse_interval_spec(value);
	/* we want to override any default failure_timeout in use when remote
	* reconnect_interval is in use. */
	(rsc)->failure_timeout = (rsc)->remote_reconnect_ms / 1000;
	}
	}

	get_target_role(rsc, &((rsc)->next_role));
	pe_rsc_trace((*rsc), "\tDesired next state: %s",
	(rsc)->next_role != RSC_ROLE_UNKNOWN ? role2text((rsc)->next_role) : "default");

	if ((rsc)->fns->unpack(rsc, data_set) == FALSE) {
	return FALSE;
	}

	if (pcmk_is_set(data_set->flags, pe_flag_symmetric_cluster)) {
	// This tag must stay exactly the same because it is tested elsewhere
	resource_location(*rsc, NULL, 0, "symmetric_default", data_set);
	} else if (guest_node) {
	/* remote resources tied to a container resource must always be allowed
	* to opt-in to the cluster. Whether the connection resource is actually
	* allowed to be placed on a node is dependent on the container resource */
	resource_location(*rsc, NULL, 0, "remote_connection_default", data_set);
	}

	pe_rsc_trace((*rsc), "\tAction notification: %s",
	pcmk_is_set((*rsc)->flags, pe_rsc_notify)? "required" : "not required");

	(*rsc)->utilization = crm_str_table_new();

	pe__unpack_dataset_nvpairs((*rsc)->xml, XML_TAG_UTILIZATION, &rule_data,
	(*rsc)->utilization, NULL, FALSE, data_set);

	/* data_set->resources = g_list_append(data_set->resources, (rsc)); /

	if (expanded_xml) {
	if (add_template_rsc(xml_obj, data_set) == FALSE) {
	return FALSE;
	}
	}
	return TRUE;
	}

	void
	common_update_score(pe_resource_t * rsc, const char *id, int score)
	{
	pe_node_t *node = NULL;

	node = pe_hash_table_lookup(rsc->allowed_nodes, id);
	if (node != NULL) {
	pe_rsc_trace(rsc, "Updating score for %s on %s: %d + %d", rsc->id, id, node->weight, score);
	node->weight = pe__add_scores(node->weight, score);
	}

	if (rsc->children) {
	GListPtr gIter = rsc->children;

	for (; gIter != NULL; gIter = gIter->next) {
	pe_resource_t child_rsc = (pe_resource_t ) gIter->data;

	common_update_score(child_rsc, id, score);
	}
	}
	}

	gboolean
	is_parent(pe_resource_t child, pe_resource_t rsc)
	{
	pe_resource_t *parent = child;

	if (parent == NULL \|\| rsc == NULL) {
	return FALSE;
	}
	while (parent->parent != NULL) {
	if (parent->parent == rsc) {
	return TRUE;
	}
	parent = parent->parent;
	}
	return FALSE;
	}

	pe_resource_t *
	uber_parent(pe_resource_t * rsc)
	{
	pe_resource_t *parent = rsc;

	if (parent == NULL) {
	return NULL;
	}
	while (parent->parent != NULL && parent->parent->variant != pe_container) {
	parent = parent->parent;
	}
	return parent;
	}

	void
	common_free(pe_resource_t * rsc)
	{
	if (rsc == NULL) {
	return;
	}

	pe_rsc_trace(rsc, "Freeing %s %d", rsc->id, rsc->variant);

	g_list_free(rsc->rsc_cons);
	g_list_free(rsc->rsc_cons_lhs);
	g_list_free(rsc->rsc_tickets);
	g_list_free(rsc->dangling_migrations);

	if (rsc->parameters != NULL) {
	g_hash_table_destroy(rsc->parameters);
	}
	#if ENABLE_VERSIONED_ATTRS
	if (rsc->versioned_parameters != NULL) {
	free_xml(rsc->versioned_parameters);
	}
	#endif
	if (rsc->meta != NULL) {
	g_hash_table_destroy(rsc->meta);
	}
	if (rsc->utilization != NULL) {
	g_hash_table_destroy(rsc->utilization);
	}

	if ((rsc->parent == NULL) && pcmk_is_set(rsc->flags, pe_rsc_orphan)) {
	free_xml(rsc->xml);
	rsc->xml = NULL;
	free_xml(rsc->orig_xml);
	rsc->orig_xml = NULL;

	/* if rsc->orig_xml, then rsc->xml is an expanded xml from a template */
	} else if (rsc->orig_xml) {
	free_xml(rsc->xml);
	rsc->xml = NULL;
	}
	if (rsc->running_on) {
	g_list_free(rsc->running_on);
	rsc->running_on = NULL;
	}
	if (rsc->known_on) {
	g_hash_table_destroy(rsc->known_on);
	rsc->known_on = NULL;
	}
	if (rsc->actions) {
	g_list_free(rsc->actions);
	rsc->actions = NULL;
	}
	if (rsc->allowed_nodes) {
	g_hash_table_destroy(rsc->allowed_nodes);
	rsc->allowed_nodes = NULL;
	}
	g_list_free(rsc->fillers);
	g_list_free(rsc->rsc_location);
	pe_rsc_trace(rsc, "Resource freed");
	free(rsc->id);
	free(rsc->clone_name);
	free(rsc->allocated_to);
	free(rsc->variant_opaque);
	free(rsc->pending_task);
	free(rsc);
	}

	/*!
	* \brief
	* \internal Find a node (and optionally count all) where resource is active
	*
	* \param[in] rsc Resource to check
	* \param[out] count_all If not NULL, will be set to count of active nodes
	* \param[out] count_clean If not NULL, will be set to count of clean nodes
	*
	* \return An active node (or NULL if resource is not active anywhere)
	*
	* \note The order of preference is: an active node that is the resource's
	* partial migration source; if the resource's "requires" is "quorum" or
	* "nothing", the first active node in the list that is clean and online;
	* the first active node in the list.
	*/
	pe_node_t *
	pe__find_active_on(const pe_resource_t rsc, unsigned int count_all,
	unsigned int *count_clean)
	{
	pe_node_t *active = NULL;
	pe_node_t *node = NULL;
	bool keep_looking = FALSE;
	bool is_happy = FALSE;

	if (count_all) {
	*count_all = 0;
	}
	if (count_clean) {
	*count_clean = 0;
	}
	if (rsc == NULL) {
	return NULL;
	}

	for (GList *node_iter = rsc->running_on; node_iter != NULL;
	node_iter = node_iter->next) {

	node = node_iter->data;
	keep_looking = FALSE;

	is_happy = node->details->online && !node->details->unclean;

	if (count_all) {
	++*count_all;
	}
	if (count_clean && is_happy) {
	++*count_clean;
	}
	if (count_all \|\| count_clean) {
	// If we're counting, we need to go through entire list
	keep_looking = TRUE;
	}

	if (rsc->partial_migration_source != NULL) {
	if (node->details == rsc->partial_migration_source->details) {
	// This is the migration source
	active = node;
	} else {
	keep_looking = TRUE;
	}
	} else if (!pcmk_is_set(rsc->flags, pe_rsc_needs_fencing)) {
	if (is_happy && (!active \|\| !active->details->online
	\|\| active->details->unclean)) {
	// This is the first clean node
	active = node;
	} else {
	keep_looking = TRUE;
	}
	}
	if (active == NULL) {
	// This is first node in list
	active = node;
	}

	if (keep_looking == FALSE) {
	// Don't waste time iterating if we don't have to
	break;
	}
	}
	return active;
	}

	/*!
	* \brief
	* \internal Find and count active nodes according to "requires"
	*
	* \param[in] rsc Resource to check
	* \param[out] count If not NULL, will be set to count of active nodes
	*
	* \return An active node (or NULL if resource is not active anywhere)
	*
	* \note This is a convenience wrapper for pe__find_active_on() where the count
	* of all active nodes or only clean active nodes is desired according to
	* the "requires" meta-attribute.
	*/
	pe_node_t *
	pe__find_active_requires(const pe_resource_t rsc, unsigned int count)
	{
	if (rsc && !pcmk_is_set(rsc->flags, pe_rsc_needs_fencing)) {
	return pe__find_active_on(rsc, NULL, count);
	}
	return pe__find_active_on(rsc, count, NULL);
	}

	void
	pe__count_common(pe_resource_t *rsc)
	{
	if (rsc->children != NULL) {
	for (GList *item = rsc->children; item != NULL; item = item->next) {
	((pe_resource_t *) item->data)->fns->count(item->data);
	}

	} else if (!pcmk_is_set(rsc->flags, pe_rsc_orphan)
	\|\| (rsc->role > RSC_ROLE_STOPPED)) {
	rsc->cluster->ninstances++;
	if (pe__resource_is_disabled(rsc)) {
	rsc->cluster->disabled_resources++;
	}
	if (pcmk_is_set(rsc->flags, pe_rsc_block)) {
	rsc->cluster->blocked_resources++;
	}
	}
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 3:54 AM (4 h, 47 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1018188
Default Alt Text: (428 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions