No OneTemporary
Actions

Size

336 KB

Referenced Files

None

Subscribers

None

View Options

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

	diff --git a/include/crm/common/iso8601_internal.h b/include/crm/common/iso8601_internal.h
	index afeca97f0b..058c367226 100644
	--- a/include/crm/common/iso8601_internal.h
	+++ b/include/crm/common/iso8601_internal.h
	@@ -1,50 +1,50 @@
	/*
	* Copyright 2015-2017 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
	*/

	#ifndef CRM_COMMON_ISO8601_INTERNAL
	# define CRM_COMMON_ISO8601_INTERNAL
	#include <time.h>
	#include <sys/time.h>
	#include <ctype.h>
	#include <crm/common/iso8601.h>

	typedef struct crm_time_us crm_time_hr_t;
	crm_time_hr_t crm_time_hr_convert(crm_time_hr_t target, crm_time_t *dt);
	void crm_time_set_hr_dt(crm_time_t target, crm_time_hr_t hr_dt);
	crm_time_hr_t crm_time_timeval_hr_convert(crm_time_hr_t target,
	struct timeval *tv);
	crm_time_hr_t crm_time_hr_new(const char date_time);
	void crm_time_hr_free(crm_time_hr_t * hr_dt);
	char crm_time_format_hr(const char format, crm_time_hr_t * hr_dt);
	-const char *crm_now_string(void);
	+const char crm_now_string(time_t when);

	crm_time_t parse_date(const char date_str); /* in iso8601.c global but
	not in header */

	struct crm_time_us {
	int years;
	int months; /* Only for durations */
	int days;
	int seconds;
	int offset; /* Seconds */
	bool duration;
	int useconds;
	};
	#endif
	diff --git a/lib/cib/cib_utils.c b/lib/cib/cib_utils.c
	index 78a07a76ad..35adf67864 100644
	--- a/lib/cib/cib_utils.c
	+++ b/lib/cib/cib_utils.c
	@@ -1,773 +1,774 @@
	/*
	* Copyright (c) 2004 International Business Machines
	*
	* This library 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.1 of the License, or (at your option) any later version.
	*
	* This library 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
	* Lesser 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
	*
	*/
	#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/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_DOMAINS, "/cib/configuration", "//cib/configuration/domains" },
	{ 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_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)
	\|\| safe_str_eq(object_type, known_paths[lpc].name)) {
	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 (safe_str_eq(object_type, known_paths[lpc].name)) {
	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", 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 (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);
	fix_plus_plus_recursive(scratch);

	if (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, __FUNCTION__, 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, __FUNCTION__, local_diff);
	crm_log_xml_trace(local_diff, "raw patch");
	}

	if (is_not_set(call_options, cib_zero_copy) /* The 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 (safe_str_eq(section, XML_CIB_TAG_STATUS)) {
	/* 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 && is_not_set(call_options, cib_no_mtime)) {
	- const char *now_str = crm_now_string();
	+ const char *now_str = crm_now_string(NULL);
	const char *schema = crm_element_value(scratch, XML_ATTR_VALIDATION);

	- crm_xml_replace(scratch, XML_CIB_ATTR_WRITTEN, now_str);
	+ crm_xml_replace(scratch, XML_CIB_ATTR_WRITTEN,
	+ now_str ? now_str : "Could not determine current time");

	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", (check_schema? "true" : "false"));
	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 (safe_str_neq(entry->event, event)) {
	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 pe_cluster_option cib_opts[] = {
	/*
	* name, legacy name,
	* type, allowed values, default, validator,
	* short description,
	* long description
	*/
	{
	"enable-acl", NULL,
	"boolean", NULL, "false", &check_boolean,
	"Enable CIB ACL",
	NULL
	},
	{
	"cluster-ipc-limit", NULL,
	"integer", NULL, "500", &check_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)
	{
	config_metadata("Cluster Information Base", "1.0",
	"Cluster Information Base Options",
	"This is a fake resource that details the options that can be configured for the Cluster Information Base.",
	cib_opts, DIMOF(cib_opts));
	}

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

	const char *
	cib_pref(GHashTable * options, const char *name)
	{
	return get_cluster_pref(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) {
	unpack_instance_attributes(current_cib, config, XML_CIB_TAG_PROPSET, NULL, options,
	CIB_OPTIONS_FIRST, TRUE, now);
	}

	verify_cib_options(options);

	crm_time_free(now);

	return TRUE;
	}

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

	/* 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);
	}
	diff --git a/lib/common/iso8601.c b/lib/common/iso8601.c
	index e77543ee1f..0261b67402 100644
	--- a/lib/common/iso8601.c
	+++ b/lib/common/iso8601.c
	@@ -1,1457 +1,1468 @@
	/*
	* Copyright 2005-2019 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.
	*/

	/*
	* References:
	* https://en.wikipedia.org/wiki/ISO_8601
	* http://www.staff.science.uu.nl/~gent0113/calendar/isocalendar.htm
	*/

	#include <crm_internal.h>
	#include <crm/crm.h>
	#include <time.h>
	#include <ctype.h>
	#include <crm/common/iso8601.h>
	#include <crm/common/iso8601_internal.h>

	/*
	* Andrew's code was originally written for OSes whose "struct tm" contains:
	* long tm_gmtoff; :: Seconds east of UTC
	* const char *tm_zone; :: Timezone abbreviation
	* Some OSes lack these, instead having:
	* time_t (or long) timezone;
	:: "difference between UTC and local standard time"
	* char *tzname[2] = { "...", "..." };
	* I (David Lee) confess to not understanding the details. So my attempted
	* generalisations for where their use is necessary may be flawed.
	*
	* 1. Does "difference between ..." subtract the same or opposite way?
	* 2. Should it use "altzone" instead of "timezone"?
	* 3. Should it use tzname[0] or tzname[1]? Interaction with timezone/altzone?
	*/
	#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
	# define GMTOFF(tm) ((tm)->tm_gmtoff)
	#else
	/* Note: extern variable; macro argument not actually used. */
	# define GMTOFF(tm) (-timezone+daylight)
	#endif

	struct crm_time_s {
	int years;
	int months; /* Only for durations */
	int days;
	int seconds;
	int offset; /* Seconds */
	bool duration;
	};

	char crm_time_as_string(crm_time_t date_time, int flags);
	crm_time_t parse_date(const char date_str);

	gboolean check_for_ordinal(const char *str);

	static crm_time_t *
	crm_get_utc_time(crm_time_t * dt)
	{
	crm_time_t *utc = calloc(1, sizeof(crm_time_t));

	utc->years = dt->years;
	utc->days = dt->days;
	utc->seconds = dt->seconds;
	utc->offset = 0;

	if (dt->offset) {
	crm_time_add_seconds(utc, -dt->offset);
	} else {
	/* Durations (which are the only things that can include months, never have a timezone */
	utc->months = dt->months;
	}

	crm_time_log(LOG_TRACE, "utc-source", dt,
	crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	crm_time_log(LOG_TRACE, "utc-target", utc,
	crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	return utc;
	}

	crm_time_t *
	crm_time_new(const char *date_time)
	{
	time_t tm_now;
	crm_time_t *dt = NULL;

	tzset();
	if (date_time == NULL) {
	tm_now = time(NULL);
	dt = calloc(1, sizeof(crm_time_t));
	crm_time_set_timet(dt, &tm_now);
	} else {
	dt = parse_date(date_time);
	}
	return dt;
	}

	void
	crm_time_free(crm_time_t * dt)
	{
	if (dt == NULL) {
	return;
	}
	free(dt);
	}

	static int
	year_days(int year)
	{
	int d = 365;

	if (crm_time_leapyear(year)) {
	d++;
	}
	return d;
	}

	/* From http://myweb.ecu.edu/mccartyr/ISOwdALG.txt :
	*
	* 5. Find the Jan1Weekday for Y (Monday=1, Sunday=7)
	* YY = (Y-1) % 100
	* C = (Y-1) - YY
	* G = YY + YY/4
	* Jan1Weekday = 1 + (((((C / 100) % 4) x 5) + G) % 7)
	*/
	int
	crm_time_january1_weekday(int year)
	{
	int YY = (year - 1) % 100;
	int C = (year - 1) - YY;
	int G = YY + YY / 4;
	int jan1 = 1 + (((((C / 100) % 4) * 5) + G) % 7);

	crm_trace("YY=%d, C=%d, G=%d", YY, C, G);
	crm_trace("January 1 %.4d: %d", year, jan1);
	return jan1;
	}

	int
	crm_time_weeks_in_year(int year)
	{
	int weeks = 52;
	int jan1 = crm_time_january1_weekday(year);

	/* if jan1 == thursday */
	if (jan1 == 4) {
	weeks++;
	} else {
	jan1 = crm_time_january1_weekday(year + 1);
	/* if dec31 == thursday aka. jan1 of next year is a friday */
	if (jan1 == 5) {
	weeks++;
	}

	}
	return weeks;
	}

	int month_days[14] = { 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31, 29 };

	int
	crm_time_days_in_month(int month, int year)
	{
	if (month == 2 && crm_time_leapyear(year)) {
	month = 13;
	}
	return month_days[month];
	}

	bool
	crm_time_leapyear(int year)
	{
	gboolean is_leap = FALSE;

	if (year % 4 == 0) {
	is_leap = TRUE;
	}
	if (year % 100 == 0 && year % 400 != 0) {
	is_leap = FALSE;
	}
	return is_leap;
	}

	static uint32_t
	get_ordinal_days(uint32_t y, uint32_t m, uint32_t d)
	{
	int lpc;

	for (lpc = 1; lpc < m; lpc++) {
	d += crm_time_days_in_month(lpc, y);
	}
	return d;
	}

	void
	crm_time_log_alias(int log_level, const char file, const char function, int line,
	const char prefix, crm_time_t date_time, int flags)
	{
	char *date_s = crm_time_as_string(date_time, flags);

	if (log_level < LOG_CRIT) {
	printf("%s%s%s\n",
	prefix ? prefix : "", prefix ? ": " : "", date_s ? date_s : "__invalid_date__");
	} else {
	do_crm_log_alias(log_level, file, function, line, "%s%s%s",
	prefix ? prefix : "", prefix ? ": " : "",
	date_s ? date_s : "__invalid_date__");
	}
	free(date_s);
	}

	static int
	crm_time_get_sec(int sec, uint * h, uint * m, uint * s)
	{
	uint hours, minutes, seconds;

	if (sec < 0) {
	seconds = 0 - sec;
	} else {
	seconds = sec;
	}

	hours = seconds / (60 * 60);
	seconds -= 60 * 60 * hours;

	minutes = seconds / (60);
	seconds -= 60 * minutes;

	crm_trace("%d == %.2d:%.2d:%.2d", sec, hours, minutes, seconds);

	*h = hours;
	*m = minutes;
	*s = seconds;

	return TRUE;
	}

	int
	crm_time_get_timeofday(crm_time_t * dt, uint * h, uint * m, uint * s)
	{
	return crm_time_get_sec(dt->seconds, h, m, s);
	}

	int
	crm_time_get_timezone(crm_time_t * dt, uint * h, uint * m)
	{
	uint s;

	return crm_time_get_sec(dt->seconds, h, m, &s);
	}

	long long
	crm_time_get_seconds(crm_time_t * dt)
	{
	int lpc;
	crm_time_t *utc = NULL;
	long long in_seconds = 0;

	utc = crm_get_utc_time(dt);

	for (lpc = 1; lpc < utc->years; lpc++) {
	int dmax = year_days(lpc);

	in_seconds += 60 * 60 * 24 * dmax;
	}

	/* utc->months is an offset that can only be set for a duration
	* By definiton, the value is variable depending on the date to
	* which it is applied
	*
	* Force 30-day months so that something vaguely sane happens
	* for anyone that tries to use a month in this way
	*/
	if (utc->months > 0) {
	in_seconds += 60 * 60 * 24 * 30 * utc->months;
	}

	if (utc->days > 0) {
	in_seconds += 60 * 60 * 24 * (utc->days - 1);
	}
	in_seconds += utc->seconds;

	crm_time_free(utc);
	return in_seconds;
	}

	#define EPOCH_SECONDS 62135596800ULL /* Calculated using crm_time_get_seconds() */
	long long
	crm_time_get_seconds_since_epoch(crm_time_t * dt)
	{
	return crm_time_get_seconds(dt) - EPOCH_SECONDS;
	}

	int
	crm_time_get_gregorian(crm_time_t * dt, uint * y, uint * m, uint * d)
	{
	int months = 0;
	int days = dt->days;

	if(dt->years != 0) {
	for (months = 1; months <= 12 && days > 0; months++) {
	int mdays = crm_time_days_in_month(months, dt->years);

	if (mdays >= days) {
	break;
	} else {
	days -= mdays;
	}
	}

	} else if (dt->months) {
	/* This is a duration including months, don't convert the days field */
	months = dt->months;

	} else {
	/* This is a duration not including months, still don't convert the days field */
	}

	*y = dt->years;
	*m = months;
	*d = days;
	crm_trace("%.4d-%.3d -> %.4d-%.2d-%.2d", dt->years, dt->days, dt->years, months, days);
	return TRUE;
	}

	int
	crm_time_get_ordinal(crm_time_t * dt, uint * y, uint * d)
	{
	*y = dt->years;
	*d = dt->days;
	return TRUE;
	}

	int
	crm_time_get_isoweek(crm_time_t * dt, uint * y, uint * w, uint * d)
	{
	/*
	* Monday 29 December 2008 is written "2009-W01-1"
	* Sunday 3 January 2010 is written "2009-W53-7"
	*/
	int year_num = 0;
	int jan1 = crm_time_january1_weekday(dt->years);
	int h = -1;

	CRM_CHECK(dt->days > 0, return FALSE);

	/* 6. Find the Weekday for Y M D */
	h = dt->days + jan1 - 1;
	*d = 1 + ((h - 1) % 7);

	/* 7. Find if Y M D falls in YearNumber Y-1, WeekNumber 52 or 53 */
	if (dt->days <= (8 - jan1) && jan1 > 4) {
	crm_trace("year--, jan1=%d", jan1);
	year_num = dt->years - 1;
	*w = crm_time_weeks_in_year(year_num);

	} else {
	year_num = dt->years;
	}

	/* 8. Find if Y M D falls in YearNumber Y+1, WeekNumber 1 */
	if (year_num == dt->years) {
	int dmax = year_days(year_num);
	int correction = 4 - *d;

	if ((dmax - dt->days) < correction) {
	crm_trace("year++, jan1=%d, i=%d vs. %d", jan1, dmax - dt->days, correction);
	year_num = dt->years + 1;
	*w = 1;
	}
	}

	/* 9. Find if Y M D falls in YearNumber Y, WeekNumber 1 through 53 */
	if (year_num == dt->years) {
	int j = dt->days + (7 - *d) + (jan1 - 1);

	*w = j / 7;
	if (jan1 > 4) {
	*w -= 1;
	}
	}

	*y = year_num;
	crm_trace("Converted %.4d-%.3d to %.4d-W%.2d-%d", dt->years, dt->days, y, w, *d);
	return TRUE;
	}

	#define DATE_MAX 128

	char *
	crm_time_as_string(crm_time_t * date_time, int flags)
	{
	char *date_s = NULL;
	char *time_s = NULL;
	char *offset_s = NULL;
	char *result_s = NULL;
	crm_time_t *dt = NULL;
	crm_time_t *utc = NULL;

	if (date_time == NULL) {
	return strdup("");

	} else if (date_time->offset && (flags & crm_time_log_with_timezone) == 0) {
	crm_trace("UTC conversion");
	utc = crm_get_utc_time(date_time);
	dt = utc;
	} else {
	dt = date_time;
	}

	CRM_CHECK(dt != NULL, return NULL);
	if (flags & crm_time_log_duration) {
	uint h = 0, m = 0, s = 0;
	int offset = 0;

	date_s = calloc(1, DATE_MAX);
	crm_time_get_sec(dt->seconds, &h, &m, &s);

	if (date_s == NULL) {
	goto done;
	}

	if(dt->years) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%4d year%s ", dt->years, dt->years>1?"s":"");
	}
	if(dt->months) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%2d month%s ", dt->months, dt->months>1?"s":"");
	}
	if(dt->days) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%2d day%s ", dt->days, dt->days>1?"s":"");
	}
	if(dt->seconds) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%d seconds ( ", dt->seconds);
	if(h) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%u hour%s ", h, h>1?"s":"");
	}
	if(m) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%u minute%s ", m, m>1?"s":"");
	}
	if(s) {
	offset += snprintf(date_s+offset, DATE_MAX - offset, "%u second%s ", s, s>1?"s":"");
	}
	offset += snprintf(date_s+offset, DATE_MAX - offset, ")");
	}
	goto done;
	}

	if (flags & crm_time_log_date) {
	date_s = calloc(1, 34);
	if (date_s == NULL) {
	goto done;

	} else if (flags & crm_time_seconds) {
	long long s = crm_time_get_seconds(date_time);

	snprintf(date_s, 32, "%lld", s);
	goto done;

	} else if (flags & crm_time_epoch) {
	long long s = crm_time_get_seconds_since_epoch(date_time);

	snprintf(date_s, 32, "%lld", s);
	goto done;

	} else if (flags & crm_time_weeks) {
	/* YYYY-Www-D */
	uint y, w, d;

	if (crm_time_get_isoweek(dt, &y, &w, &d)) {
	snprintf(date_s, 34, "%u-W%.2u-%u", y, w, d);
	}

	} else if (flags & crm_time_ordinal) {
	/* YYYY-DDD */
	uint y, d;

	if (crm_time_get_ordinal(dt, &y, &d)) {
	snprintf(date_s, 22, "%u-%.3u", y, d);
	}

	} else {
	/* YYYY-MM-DD */
	uint y, m, d;

	if (crm_time_get_gregorian(dt, &y, &m, &d)) {
	snprintf(date_s, 33, "%.4u-%.2u-%.2u", y, m, d);
	}
	}
	}

	if (flags & crm_time_log_timeofday) {
	uint h, m, s;

	time_s = calloc(1, 33);
	if (time_s == NULL) {
	goto cleanup;
	}

	if (crm_time_get_timeofday(dt, &h, &m, &s)) {
	snprintf(time_s, 33, "%.2u:%.2u:%.2u", h, m, s);
	}

	if (dt->offset != 0) {
	crm_time_get_sec(dt->offset, &h, &m, &s);
	}

	offset_s = calloc(1, 31);
	if ((flags & crm_time_log_with_timezone) == 0 \|\| dt->offset == 0) {
	crm_trace("flags %6x %6x", flags, crm_time_log_with_timezone);
	snprintf(offset_s, 31, "Z");

	} else {
	snprintf(offset_s, 24, " %c%.2u:%.2u", dt->offset < 0 ? '-' : '+', h, m);
	}
	}

	done:
	result_s = calloc(1, 100);

	snprintf(result_s, 100, "%s%s%s%s",
	date_s ? date_s : "", (date_s != NULL && time_s != NULL) ? " " : "",
	time_s ? time_s : "", offset_s ? offset_s : "");

	cleanup:
	free(date_s);
	free(time_s);
	free(offset_s);
	crm_time_free(utc);

	return result_s;
	}

	static int
	crm_time_parse_sec(const char *time_str)
	{
	int rc;
	uint hour = 0;
	uint minute = 0;
	uint second = 0;

	rc = sscanf(time_str, "%d:%d:%d", &hour, &minute, &second);
	if (rc == 1) {
	rc = sscanf(time_str, "%2d%2d%2d", &hour, &minute, &second);
	}

	if (rc > 0 && rc < 4) {
	crm_trace("Got valid time: %.2d:%.2d:%.2d", hour, minute, second);
	if (hour >= 24) {
	crm_err("Invalid hour: %d", hour);
	} else if (minute >= 60) {
	crm_err("Invalid minute: %d", minute);
	} else if (second >= 60) {
	crm_err("Invalid second: %d", second);
	} else {
	second += (minute * 60);
	second += (hour * 60 * 60);
	}
	} else {
	crm_err("Bad time: %s (%d)", time_str, rc);
	}
	return second;
	}

	static int
	crm_time_parse_offset(const char *offset_str)
	{
	int offset = 0;

	tzset();
	if (offset_str == NULL) {
	#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
	time_t now = time(NULL);
	struct tm *now_tm = localtime(&now);
	#endif
	int h_offset = GMTOFF(now_tm) / (3600);
	int m_offset = (GMTOFF(now_tm) - (3600 * h_offset)) / (60);

	if (h_offset < 0 && m_offset < 0) {
	m_offset = 0 - m_offset;
	}
	offset += (60 * 60 * h_offset);
	offset += (60 * m_offset);

	} else if (offset_str[0] == 'Z') {

	} else if (offset_str[0] == '+' \|\| offset_str[0] == '-' \|\| isdigit((int)offset_str[0])) {
	gboolean negate = FALSE;

	if (offset_str[0] == '-') {
	negate = TRUE;
	offset_str++;
	}
	offset = crm_time_parse_sec(offset_str);
	if (negate) {
	offset = 0 - offset;
	}
	}
	return offset;
	}

	static crm_time_t *
	crm_time_parse(const char time_str, crm_time_t a_time)
	{
	uint h, m, s;
	char *offset_s = NULL;
	crm_time_t *dt = a_time;

	tzset();
	if (a_time == NULL) {
	dt = calloc(1, sizeof(crm_time_t));
	}

	if (time_str) {
	dt->seconds = crm_time_parse_sec(time_str);

	offset_s = strstr(time_str, "Z");
	if (offset_s == NULL) {
	offset_s = strstr(time_str, " ");
	}
	}

	if (offset_s) {
	while (isspace(offset_s[0])) {
	offset_s++;
	}
	}
	dt->offset = crm_time_parse_offset(offset_s);
	crm_time_get_sec(dt->offset, &h, &m, &s);
	crm_trace("Got tz: %c%2.d:%.2d", dt->offset < 0 ? '-' : '+', h, m);
	return dt;
	}

	crm_time_t *
	parse_date(const char *date_str)
	{
	char *time_s;
	crm_time_t *dt = NULL;

	int year = 0;
	int month = 0;
	int week = 0;
	int day = 0;
	int rc = 0;

	CRM_CHECK(date_str != NULL, return NULL);
	CRM_CHECK(strlen(date_str) > 0, return NULL);

	if (date_str[0] == 'T' \|\| date_str[2] == ':') {
	/* Just a time supplied - Infer current date */
	dt = crm_time_new(NULL);
	dt = crm_time_parse(date_str, dt);
	goto done;

	} else {
	dt = calloc(1, sizeof(crm_time_t));
	}

	if (safe_str_eq("epoch", date_str)) {
	dt->days = 1;
	dt->years = 1970;
	crm_time_log(LOG_TRACE, "Unpacked", dt, crm_time_log_date \| crm_time_log_timeofday);
	return dt;
	}

	/* YYYY-MM-DD */
	rc = sscanf(date_str, "%d-%d-%d", &year, &month, &day);
	if (rc == 1) {
	/* YYYYMMDD */
	rc = sscanf(date_str, "%4d%2d%2d", &year, &month, &day);
	}
	if (rc == 3) {
	if (month > 12) {
	crm_err("Invalid month: %d", month);
	} else if (day > 31) {
	crm_err("Invalid day: %d", day);
	} else {
	dt->years = year;
	dt->days = get_ordinal_days(year, month, day);
	crm_trace("Got gergorian date: %.4d-%.3d", year, dt->days);
	}
	goto done;
	}

	/* YYYY-DDD */
	rc = sscanf(date_str, "%d-%d", &year, &day);
	if (rc == 2) {
	crm_trace("Got ordinal date");
	if (day > year_days(year)) {
	crm_err("Invalid day: %d (max=%d)", day, year_days(year));
	} else {
	dt->days = day;
	dt->years = year;
	}
	goto done;
	}

	/* YYYY-Www-D */
	rc = sscanf(date_str, "%d-W%d-%d", &year, &week, &day);
	if (rc == 3) {
	crm_trace("Got week date");
	if (week > crm_time_weeks_in_year(year)) {
	crm_err("Invalid week: %d (max=%d)", week, crm_time_weeks_in_year(year));
	} else if (day < 1 \|\| day > 7) {
	crm_err("Invalid day: %d", day);
	} else {
	/*
	* See https://en.wikipedia.org/wiki/ISO_week_date
	*
	* Monday 29 December 2008 is written "2009-W01-1"
	* Sunday 3 January 2010 is written "2009-W53-7"
	* Saturday 27 September 2008 is written "2008-W37-6"
	*
	* If 1 January is on a Monday, Tuesday, Wednesday or Thursday, it is in week 01.
	* If 1 January is on a Friday, Saturday or Sunday, it is in week 52 or 53 of the previous year.
	*/
	int jan1 = crm_time_january1_weekday(year);

	crm_trace("Jan 1 = %d", jan1);

	dt->years = year;
	crm_time_add_days(dt, (week - 1) * 7);

	if (jan1 <= 4) {
	crm_time_add_days(dt, 1 - jan1);
	} else {
	crm_time_add_days(dt, 8 - jan1);
	}

	crm_time_add_days(dt, day);
	}
	goto done;
	}

	crm_err("Couldn't parse %s", date_str);
	done:

	time_s = strstr(date_str, " ");
	if (time_s == NULL) {
	time_s = strstr(date_str, "T");
	}

	if (dt && time_s) {
	time_s++;
	crm_time_parse(time_s, dt);
	}

	crm_time_log(LOG_TRACE, "Unpacked", dt, crm_time_log_date \| crm_time_log_timeofday);

	CRM_CHECK(crm_time_check(dt), return NULL);

	return dt;
	}

	static int
	parse_int(const char str, int field_width, int uppper_bound, int result)
	{
	int lpc = 0;
	int offset = 0;
	int intermediate = 0;
	gboolean fraction = FALSE;
	gboolean negate = FALSE;

	CRM_CHECK(str != NULL, return FALSE);
	CRM_CHECK(result != NULL, return FALSE);

	*result = 0;

	if (*str == '\0') {
	return FALSE;
	}

	if (str[offset] == 'T') {
	offset++;
	}

	if (str[offset] == '.' \|\| str[offset] == ',') {
	fraction = TRUE;
	field_width = -1;
	offset++;
	} else if (str[offset] == '-') {
	negate = TRUE;
	offset++;
	} else if (str[offset] == '+' \|\| str[offset] == ':') {
	offset++;
	}

	for (; (fraction \|\| lpc < field_width) && isdigit((int)str[offset]); lpc++) {
	if (fraction) {
	intermediate = (str[offset] - '0') / (10 ^ lpc);
	} else {
	result = 10;
	intermediate = str[offset] - '0';
	}
	*result += intermediate;
	offset++;
	}
	if (fraction) {
	result = (int)(result * uppper_bound);

	} else if (uppper_bound > 0 && *result > uppper_bound) {
	*result = uppper_bound;
	}
	if (negate) {
	result = 0 - result;
	}
	if (lpc > 0) {
	crm_trace("Found int: %d. Stopped at str[%d]='%c'", *result, lpc, str[lpc]);
	return offset;
	}
	return 0;
	}

	crm_time_t *
	crm_time_parse_duration(const char *period_s)
	{
	gboolean is_time = FALSE;
	crm_time_t *diff = NULL;

	CRM_CHECK(period_s != NULL, goto bail);
	CRM_CHECK(strlen(period_s) > 0, goto bail);
	CRM_CHECK(period_s[0] == 'P', goto bail);
	period_s++;

	diff = calloc(1, sizeof(crm_time_t));

	while (isspace((int)period_s[0]) == FALSE) {
	int an_int = 0, rc;
	char ch = 0;

	if (period_s[0] == 'T') {
	is_time = TRUE;
	period_s++;
	}

	rc = parse_int(period_s, 10, 0, &an_int);
	if (rc == 0) {
	break;
	}
	period_s += rc;

	ch = period_s[0];
	period_s++;

	crm_trace("Testing %c=%d, rc=%d", ch, an_int, rc);

	switch (ch) {
	case 0:
	return diff;
	break;
	case 'Y':
	diff->years = an_int;
	break;
	case 'M':
	if (is_time) {
	/* Minutes */
	diff->seconds += an_int * 60;
	} else {
	diff->months = an_int;
	}
	break;
	case 'W':
	diff->days += an_int * 7;
	break;
	case 'D':
	diff->days += an_int;
	break;
	case 'H':
	diff->seconds += an_int * 60 * 60;
	break;
	case 'S':
	diff->seconds += an_int;
	break;
	default:
	goto bail;
	break;
	}
	}
	return diff;

	bail:
	free(diff);
	return NULL;
	}

	crm_time_period_t *
	crm_time_parse_period(const char *period_str)
	{
	gboolean invalid = FALSE;
	const char *original = period_str;
	crm_time_period_t *period = NULL;

	CRM_CHECK(period_str != NULL, return NULL);
	CRM_CHECK(strlen(period_str) > 0, return NULL);

	tzset();
	period = calloc(1, sizeof(crm_time_period_t));

	if (period_str[0] == 'P') {
	period->diff = crm_time_parse_duration(period_str);
	} else {
	period->start = parse_date(period_str);
	}

	period_str = strstr(original, "/");
	if (period_str) {
	CRM_CHECK(period_str[0] == '/', invalid = TRUE;
	goto bail);
	period_str++;

	if (period_str[0] == 'P') {
	period->diff = crm_time_parse_duration(period_str);
	} else {
	period->end = parse_date(period_str);
	}

	} else if (period->diff != NULL) {
	/* just aduration starting from now */
	period->start = crm_time_new(NULL);

	} else {
	invalid = TRUE;
	CRM_CHECK(period_str != NULL, goto bail);
	}

	/* sanity checks */
	if (period->start == NULL && period->end == NULL) {
	crm_err("Invalid time period: %s", original);
	invalid = TRUE;

	} else if (period->start == NULL && period->diff == NULL) {
	crm_err("Invalid time period: %s", original);
	invalid = TRUE;

	} else if (period->end == NULL && period->diff == NULL) {
	crm_err("Invalid time period: %s", original);
	invalid = TRUE;
	}

	bail:
	if (invalid) {
	free(period->start);
	free(period->end);
	free(period->diff);
	free(period);
	return NULL;
	}
	if (period->end == NULL && period->diff == NULL) {
	}

	if (period->start == NULL) {
	period->start = crm_time_subtract(period->end, period->diff);

	} else if (period->end == NULL) {
	period->end = crm_time_add(period->start, period->diff);
	}

	crm_time_check(period->start);
	crm_time_check(period->end);

	return period;
	}

	void
	crm_time_set(crm_time_t * target, crm_time_t * source)
	{
	crm_trace("target=%p, source=%p", target, source);

	CRM_CHECK(target != NULL && source != NULL, return);

	target->years = source->years;
	target->days = source->days;
	target->months = source->months; /* Only for durations */
	target->seconds = source->seconds;
	target->offset = source->offset;

	crm_time_log(LOG_TRACE, "source", source,
	crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	crm_time_log(LOG_TRACE, "target", target,
	crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	}

	static void
	ha_set_tm_time(crm_time_t * target, struct tm *source)
	{
	int h_offset = 0;
	int m_offset = 0;

	/* Ensure target is fully initialized */
	target->years = 0;
	target->months = 0;
	target->days = 0;
	target->seconds = 0;
	target->offset = 0;
	target->duration = FALSE;

	if (source->tm_year > 0) {
	/* years since 1900 */
	target->years = 1900 + source->tm_year;
	}

	if (source->tm_yday >= 0) {
	/* days since January 1 [0-365] */
	target->days = 1 + source->tm_yday;
	}

	if (source->tm_hour >= 0) {
	target->seconds += 60 * 60 * source->tm_hour;
	}
	if (source->tm_min >= 0) {
	target->seconds += 60 * source->tm_min;
	}
	if (source->tm_sec >= 0) {
	target->seconds += source->tm_sec;
	}

	/* tm_gmtoff == offset from UTC in seconds */
	h_offset = GMTOFF(source) / (3600);
	m_offset = (GMTOFF(source) - (3600 * h_offset)) / (60);
	crm_trace("Offset (s): %ld, offset (hh:mm): %.2d:%.2d", GMTOFF(source), h_offset, m_offset);

	target->offset += 60 * 60 * h_offset;
	target->offset += 60 * m_offset;
	}

	void
	crm_time_set_timet(crm_time_t * target, time_t * source)
	{
	ha_set_tm_time(target, localtime(source));
	}

	crm_time_t *
	crm_time_add(crm_time_t * dt, crm_time_t * value)
	{
	crm_time_t *utc = NULL;
	crm_time_t *answer = NULL;

	CRM_CHECK(dt != NULL && value != NULL, return NULL);

	answer = calloc(1, sizeof(crm_time_t));
	crm_time_set(answer, dt);

	utc = crm_get_utc_time(value);

	answer->years += utc->years;
	crm_time_add_months(answer, utc->months);
	crm_time_add_days(answer, utc->days);
	crm_time_add_seconds(answer, utc->seconds);

	crm_time_free(utc);
	return answer;
	}

	crm_time_t *
	crm_time_calculate_duration(crm_time_t * dt, crm_time_t * value)
	{
	crm_time_t *utc = NULL;
	crm_time_t *answer = NULL;

	CRM_CHECK(dt != NULL && value != NULL, return NULL);

	utc = crm_get_utc_time(value);
	answer = crm_get_utc_time(dt);
	answer->duration = TRUE;

	answer->years -= utc->years;
	if(utc->months != 0) {
	crm_time_add_months(answer, -utc->months);
	}
	crm_time_add_days(answer, -utc->days);
	crm_time_add_seconds(answer, -utc->seconds);

	crm_time_free(utc);
	return answer;
	}

	crm_time_t *
	crm_time_subtract(crm_time_t * dt, crm_time_t * value)
	{
	crm_time_t *utc = NULL;
	crm_time_t *answer = NULL;

	CRM_CHECK(dt != NULL && value != NULL, return NULL);

	answer = calloc(1, sizeof(crm_time_t));
	crm_time_set(answer, dt);
	utc = crm_get_utc_time(value);

	answer->years -= utc->years;
	if(utc->months != 0) {
	crm_time_add_months(answer, -utc->months);
	}
	crm_time_add_days(answer, -utc->days);
	crm_time_add_seconds(answer, -utc->seconds);

	return answer;
	}

	bool
	crm_time_check(crm_time_t * dt)
	{
	int ydays = 0;

	CRM_CHECK(dt != NULL, return FALSE);

	ydays = year_days(dt->years);
	crm_trace("max ydays: %d", ydays);

	CRM_CHECK(dt->days > 0, return FALSE);
	CRM_CHECK(dt->days <= ydays, return FALSE);

	CRM_CHECK(dt->seconds >= 0, return FALSE);
	CRM_CHECK(dt->seconds < 24 * 60 * 60, return FALSE);

	return TRUE;
	}

	#define do_cmp_field(l, r, field) \
	if(rc == 0) { \
	if(l->field > r->field) { \
	crm_trace("%s: %d > %d", \
	#field, l->field, r->field); \
	rc = 1; \
	} else if(l->field < r->field) { \
	crm_trace("%s: %d < %d", \
	#field, l->field, r->field); \
	rc = -1; \
	} \
	}

	int
	crm_time_compare(crm_time_t * a, crm_time_t * b)
	{
	int rc = 0;
	crm_time_t *t1 = NULL;
	crm_time_t *t2 = NULL;

	if (a == NULL && b == NULL) {
	return 0;
	} else if (a == NULL) {
	return -1;
	} else if (b == NULL) {
	return 1;
	}

	t1 = crm_get_utc_time(a);
	t2 = crm_get_utc_time(b);

	do_cmp_field(t1, t2, years);
	do_cmp_field(t1, t2, days);
	do_cmp_field(t1, t2, seconds);

	crm_time_free(t1);
	crm_time_free(t2);
	return rc;
	}

	void
	crm_time_add_seconds(crm_time_t * a_time, int extra)
	{
	int days = 0;
	int seconds = 24 * 60 * 60;

	crm_trace("Adding %d seconds to %d (max=%d)", extra, a_time->seconds, seconds);

	a_time->seconds += extra;
	while (a_time->seconds >= seconds) {
	a_time->seconds -= seconds;
	days++;
	}

	while (a_time->seconds < 0) {
	a_time->seconds += seconds;
	days--;
	}
	crm_time_add_days(a_time, days);
	}

	void
	crm_time_add_days(crm_time_t * a_time, int extra)
	{
	int lower_bound = 1;
	int ydays = crm_time_leapyear(a_time->years) ? 366 : 365;

	crm_trace("Adding %d days to %.4d-%.3d", extra, a_time->years, a_time->days);

	a_time->days += extra;
	while (a_time->days > ydays) {
	a_time->years++;
	a_time->days -= ydays;
	ydays = crm_time_leapyear(a_time->years) ? 366 : 365;
	}

	if(a_time->duration) {
	lower_bound = 0;
	}

	while (a_time->days < lower_bound) {
	a_time->years--;
	a_time->days += crm_time_leapyear(a_time->years) ? 366 : 365;
	}
	}

	void
	crm_time_add_months(crm_time_t * a_time, int extra)
	{
	int lpc;
	uint32_t y, m, d, dmax;

	crm_time_get_gregorian(a_time, &y, &m, &d);
	crm_trace("Adding %d months to %.4d-%.2d-%.2d", extra, y, m, d);

	if (extra > 0) {
	for (lpc = extra; lpc > 0; lpc--) {
	m++;
	if (m == 13) {
	m = 1;
	y++;
	}
	}
	} else {
	for (lpc = -extra; lpc > 0; lpc--) {
	m--;
	if (m == 0) {
	m = 12;
	y--;
	}
	}
	}

	dmax = crm_time_days_in_month(m, y);
	if (dmax < d) {
	/* Preserve day-of-month unless the month doesn't have enough days */
	d = dmax;
	}

	crm_trace("Calculated %.4d-%.2d-%.2d", y, m, d);

	a_time->years = y;
	a_time->days = get_ordinal_days(y, m, d);

	crm_time_get_gregorian(a_time, &y, &m, &d);
	crm_trace("Got %.4d-%.2d-%.2d", y, m, d);
	}

	void
	crm_time_add_minutes(crm_time_t * a_time, int extra)
	{
	crm_time_add_seconds(a_time, extra * 60);
	}

	void
	crm_time_add_hours(crm_time_t * a_time, int extra)
	{
	crm_time_add_seconds(a_time, extra * 60 * 60);
	}

	void
	crm_time_add_weeks(crm_time_t * a_time, int extra)
	{
	crm_time_add_days(a_time, extra * 7);
	}

	void
	crm_time_add_years(crm_time_t * a_time, int extra)
	{
	a_time->years += extra;
	}

	static void
	ha_get_tm_time( struct tm target, crm_time_t source)
	{
	*target = (struct tm) {
	.tm_year = source->years - 1900,
	.tm_mday = source->days,
	.tm_sec = source->seconds % 60,
	.tm_min = ( source->seconds / 60 ) % 60,
	.tm_hour = source->seconds / 60 / 60,
	.tm_isdst = -1, /* don't adjust */

	#if defined(HAVE_STRUCT_TM_TM_GMTOFF)
	.tm_gmtoff = source->offset
	#endif
	};
	mktime(target);
	}

	crm_time_hr_t *
	crm_time_hr_convert(crm_time_hr_t target, crm_time_t dt)
	{
	crm_time_hr_t *hr_dt = NULL;

	if (dt) {
	hr_dt = target?target:calloc(1, sizeof(crm_time_hr_t));
	if (hr_dt) {
	*hr_dt = (crm_time_hr_t) {
	.years = dt->years,
	.months = dt->months,
	.days = dt->days,
	.seconds = dt->seconds,
	.offset = dt->offset,
	.duration = dt->duration
	};
	}
	}

	return hr_dt;
	}

	void
	crm_time_set_hr_dt(crm_time_t target, crm_time_hr_t hr_dt)
	{
	CRM_ASSERT((hr_dt) && (target));
	*target = (crm_time_t) {
	.years = hr_dt->years,
	.months = hr_dt->months,
	.days = hr_dt->days,
	.seconds = hr_dt->seconds,
	.offset = hr_dt->offset,
	.duration = hr_dt->duration
	};
	}

	crm_time_hr_t *
	crm_time_timeval_hr_convert(crm_time_hr_t target, struct timeval tv)
	{
	crm_time_t dt;
	crm_time_hr_t *ret;

	crm_time_set_timet(&dt, &tv->tv_sec);
	ret = crm_time_hr_convert(target, &dt);
	if (ret) {
	ret->useconds = tv->tv_usec;
	}
	return ret;
	}

	crm_time_hr_t *
	crm_time_hr_new(const char *date_time)
	{
	crm_time_hr_t *hr_dt = NULL;
	struct timeval tv_now;

	if (!date_time) {
	if (gettimeofday(&tv_now, NULL) == 0) {
	hr_dt = crm_time_timeval_hr_convert(NULL, &tv_now);
	}
	} else {
	crm_time_t *dt;

	dt = parse_date(date_time);
	hr_dt = crm_time_hr_convert(NULL, dt);
	crm_time_free(dt);
	}
	return hr_dt;
	}

	void
	crm_time_hr_free(crm_time_hr_t * hr_dt)
	{
	free(hr_dt);
	}

	char *
	crm_time_format_hr(const char format, crm_time_hr_t hr_dt)
	{
	const char *mark_s;
	int max = 128, scanned_pos = 0, printed_pos = 0, fmt_pos = 0,
	date_len = 0, nano_digits = 0;
	char nano_s[10], date_s[max+1], nanofmt_s[5] = "%", *tmp_fmt_s;
	struct tm tm;
	crm_time_t dt;

	if (!format) {
	return NULL;
	}
	crm_time_set_hr_dt(&dt, hr_dt);
	ha_get_tm_time(&tm, &dt);
	sprintf(nano_s, "%06d000", hr_dt->useconds);

	while ((format[scanned_pos]) != '\0') {
	mark_s = strchr(&format[scanned_pos], '%');
	if (mark_s) {
	int fmt_len = 1;

	fmt_pos = mark_s - format;
	while ((format[fmt_pos+fmt_len] != '\0') &&
	(format[fmt_pos+fmt_len] >= '0') &&
	(format[fmt_pos+fmt_len] <= '9')) {
	fmt_len++;
	}
	scanned_pos = fmt_pos + fmt_len + 1;
	if (format[fmt_pos+fmt_len] == 'N') {
	nano_digits = atoi(&format[fmt_pos+1]);
	nano_digits = (nano_digits > 6)?6:nano_digits;
	nano_digits = (nano_digits < 0)?0:nano_digits;
	sprintf(&nanofmt_s[1], ".%ds", nano_digits);
	} else {
	if (format[scanned_pos] != '\0') {
	continue;
	}
	fmt_pos = scanned_pos; /* print till end */
	}
	} else {
	scanned_pos = strlen(format);
	fmt_pos = scanned_pos; /* print till end */
	}
	tmp_fmt_s = strndup(&format[printed_pos], fmt_pos - printed_pos);
	#ifdef GCC_FORMAT_NONLITERAL_CHECKING_ENABLED
	#pragma GCC diagnostic push
	#pragma GCC diagnostic ignored "-Wformat-nonliteral"
	#endif
	date_len += strftime(&date_s[date_len], max-date_len, tmp_fmt_s, &tm);
	#ifdef GCC_FORMAT_NONLITERAL_CHECKING_ENABLED
	#pragma GCC diagnostic pop
	#endif
	printed_pos = scanned_pos;
	free(tmp_fmt_s);
	if (nano_digits) {
	#ifdef GCC_FORMAT_NONLITERAL_CHECKING_ENABLED
	#pragma GCC diagnostic push
	#pragma GCC diagnostic ignored "-Wformat-nonliteral"
	#endif
	date_len += snprintf(&date_s[date_len], max-date_len,
	nanofmt_s, nano_s);
	#ifdef GCC_FORMAT_NONLITERAL_CHECKING_ENABLED
	#pragma GCC diagnostic pop
	#endif
	nano_digits = 0;
	}
	}

	return (date_len == 0)?NULL:strdup(date_s);
	}

	/*!
	* \internal
	* \brief Return human-friendly string representing current time
	*
	* \return Current time as string (as by ctime() but without newline) on success
	* or "Could not determine current time" on error
	* \note The return value points to a statically allocated string which might be
	* overwritten by subsequent calls to any of the C library date and time functions.
	*/
	const char *
	-crm_now_string(void)
	+crm_now_string(time_t *when)
	{
	- time_t a_time = time(NULL);
	- char *since_epoch = ctime(&a_time);
	+ char *since_epoch = NULL;

	- if ((a_time == (time_t) -1) \|\| (since_epoch == NULL)) {
	- return "Could not determine current time";
	+ if (when == NULL) {
	+ time_t a_time = time(NULL);
	+
	+ if (a_time == (time_t) -1) {
	+ return NULL;
	+ } else {
	+ since_epoch = ctime(&a_time);
	+ }
	+ } else {
	+ since_epoch = ctime(when);
	+ }
	+
	+ if (since_epoch == NULL) {
	+ return NULL;
	+ } else {
	+ return crm_strip_trailing_newline(since_epoch);
	}
	- since_epoch[strlen(since_epoch) - 1] = EOS; /* trim newline */
	- return (since_epoch);
	}
	diff --git a/lib/common/xml.c b/lib/common/xml.c
	index 4f05ed747a..23adb1cf9e 100644
	--- a/lib/common/xml.c
	+++ b/lib/common/xml.c
	@@ -1,4363 +1,4364 @@
	/*
	* Copyright 2004-2019 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 <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 "crmcommon_private.h"

	#define XML_BUFFER_SIZE 4096
	#define XML_PARSER_DEBUG 0

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

	#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(is_not_set(((xml_private_t *)xml->doc->_private)->flags, xpf_tracking)) {
	return FALSE;
	} else if (lazy && is_not_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 = realloc_safe((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) = realloc_safe((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 {
	p->flags \|= flag;
	/* crm_trace("Setting flag %x due to %s[@id=%s]", flag, xml->name, ID(xml)); */
	}
	}
	}

	void
	pcmk__set_xml_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;

	p->flags \|= flag;
	/* crm_trace("Setting flag %x due to %s[@id=%s]", flag, xml->name, ID(xml)); */
	}
	}

	static void
	__xml_node_dirty(xmlNode *xml)
	{
	pcmk__set_xml_flag(xml, xpf_dirty);
	set_parent_flag(xml, xpf_dirty);
	}

	static void
	__xml_node_clean(xmlNode *xml)
	{
	xmlNode *cIter = NULL;
	xml_private_t *p = xml->_private;

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

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

	static void
	crm_node_created(xmlNode *xml)
	{
	xmlNode *cIter = NULL;
	xml_private_t *p = xml->_private;

	if(p && pcmk__tracking_xml_changes(xml, FALSE)) {
	if(is_not_set(p->flags, xpf_created)) {
	p->flags \|= xpf_created;
	__xml_node_dirty(xml);
	}

	for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) {
	crm_node_created(cIter);
	}
	}
	}

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

	p = a->_private;
	p->flags \|= (xpf_dirty\|xpf_modified);
	p->flags = (p->flags & ~xpf_deleted);
	/* crm_trace("Setting flag %x due to %s[@id=%s, @%s=%s]", */
	/* xpf_dirty, parent?parent->name:NULL, ID(parent), a->name, a->children->content); */

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

	#define XML_PRIVATE_MAGIC (long) 0x81726354

	static void
	__xml_deleted_obj_free(void *data)
	{
	if(data) {
	xml_deleted_obj_t *deleted_obj = data;

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

	static void
	__xml_private_clean(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);
	p->deleted_objs = NULL;
	}
	}
	}


	static void
	__xml_private_free(xml_private_t *p)
	{
	__xml_private_clean(p);
	free(p);
	}

	static void
	pcmkDeregisterNode(xmlNodePtr 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);
	}
	}

	static void
	pcmkRegisterNode(xmlNodePtr 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 */
	p->flags \|= (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
	*/
	pcmk__set_xml_flag(node, xpf_dirty);
	__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_flag(xml, xpf_tracking);
	if(enforce_acls) {
	if(acl_source == NULL) {
	acl_source = xml;
	}
	pcmk__set_xml_flag(xml, xpf_acl_enabled);
	pcmk__unpack_acl(acl_source, xml, user);
	pcmk__apply_acl(xml);
	}
	}

	bool xml_tracking_changes(xmlNode * xml)
	{
	if(xml == NULL) {
	return FALSE;

	} else if(is_set(((xml_private_t *)xml->doc->_private)->flags, xpf_tracking)) {
	return TRUE;
	}
	return FALSE;
	}

	bool xml_document_dirty(xmlNode *xml)
	{
	if(xml != NULL && xml->doc && xml->doc->_private) {
	xml_private_t *doc = xml->doc->_private;

	return is_set(doc->flags, xpf_dirty);
	}
	return FALSE;
	}

	/*
	<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 grabage here"/>
	</change-list>
	<change-result>
	<group id="g1" description="some grabage 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(is_not_set(p->flags, xpf_skip)) {
	position++;
	}
	}

	return position;
	}

	static int __xml_offset_no_deletions(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(is_not_set(p->flags, xpf_deleted)) {
	position++;
	}
	}

	return position;
	}

	static void
	__xml_build_changes(xmlNode * xml, xmlNode *patchset)
	{
	xmlNode *cIter = NULL;
	xmlAttr *pIter = NULL;
	xmlNode *change = NULL;
	xml_private_t *p = xml->_private;

	if(patchset && 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);

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

	for (pIter = pcmk__first_xml_attr(xml); pIter != NULL; pIter = pIter->next) {
	xmlNode *attr = NULL;

	p = pIter->_private;
	if(is_not_set(p->flags, xpf_deleted) && is_not_set(p->flags, 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 (is_not_set(p->flags, xpf_deleted)) {
	crm_xml_add(result, (const char *)pIter->name, value);
	}
	}
	}

	for (cIter = __xml_first_child(xml); cIter != NULL; cIter = __xml_next(cIter)) {
	__xml_build_changes(cIter, patchset);
	}

	p = xml->_private;
	if(patchset && 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));
	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));
	}
	}
	}

	static void
	__xml_accept_changes(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);
	}
	}

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

	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 (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 == 0) {
	/* Log to stdout */
	} else if (crm_is_callsite_active(patchset_cs, log_level, 0) == FALSE) {
	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);

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

	CRM_ASSERT(xml);
	CRM_ASSERT(xml->doc);

	doc = xml->doc->_private;
	if(is_not_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);

	if(is_not_set(doc->flags, xpf_dirty)) {
	doc->flags = xpf_none;
	return;
	}

	doc->flags = xpf_none;
	__xml_accept_changes(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));
	}

	/* Simplified version for applying v1-style XML patches */
	static void
	__subtract_xml_object(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(safe_str_eq(crm_element_name(target), crm_element_name(patch)), return);
	CRM_CHECK(safe_str_eq(ID(target), ID(patch)), 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 (safe_str_neq(p_name, XML_ATTR_ID)) {
	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);
	}
	free(id);
	}

	static void
	__add_xml_object(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(safe_str_eq(crm_element_name(target), crm_element_name(patch)), return);
	CRM_CHECK(safe_str_eq(ID(target), ID(patch)), 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);
	}
	}

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

	static int
	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;

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

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

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

	static int
	xml_apply_patchset_v1(xmlNode xml, xmlNode patchset)
	{
	int rc = pcmk_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);
	}
	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;
	}

	root_nodes_seen = 0;
	crm_trace("Addition Phase");
	if (rc == pcmk_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);
	}
	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;
	}

	purge_diff_markers(xml); /* Purge prior to checking the digest */

	free_xml(old);
	return rc;
	}

	static xmlNode *
	__first_xml_child_match(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) {
	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)
	{
	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);
	break;
	case 2:
	target = __first_xml_child_match(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;
	}

	static int
	xml_apply_patchset_v2(xmlNode xml, xmlNode patchset)
	{
	int rc = pcmk_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);
	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;
	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;
	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;
	}
	}

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

	} else if(strcmp(op, "move") == 0) {
	int position = 0;

	crm_element_value_int(change, XML_DIFF_POSITION, &position);
	if(position != __xml_offset(match)) {
	xmlNode *match_child = NULL;
	int p = position;

	if(p > __xml_offset(match)) {
	p++; /* Skip ourselves */
	}

	CRM_ASSERT(match->parent != NULL);
	match_child = match->parent->children;

	while(match_child && p != __xml_offset(match_child)) {
	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);

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

	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, __FUNCTION__, patchset);

	crm_element_value_int(patchset, "format", &format);
	if(check_version) {
	rc = 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);
	break;
	case 2:
	rc = xml_apply_patchset_v2(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 (safe_str_neq(new_digest, digest)) {
	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;

	/* 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 (node_name == NULL \|\| !strcmp((const char *) child->name, node_name)) {
	if (attr_n == NULL
	\|\| crm_str_eq(crm_element_value(child, attr_n), attr_v, TRUE)) {
	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_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);
	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 (name == NULL \|\| name[0] == 0) {
	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);
	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)
	&& is_not_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);
	}
	}

	p = doc->_private;
	p->deleted_objs = g_list_append(p->deleted_objs, deleted_obj);
	pcmk__set_xml_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, ...)
	G_GNUC_PRINTF(2, 3);

	static void
	crm_xml_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);
	} else {
	CRM_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);

	/* xmlCtxtUseOptions(ctxt, XML_PARSE_NOBLANKS\|XML_PARSE_RECOVER); */

	xmlCtxtResetLastError(ctxt);
	xmlSetGenericErrorFunc(ctxt, crm_xml_err);
	/* initGenericErrorDefaultFunc(crm_xml_err); */
	output =
	xmlCtxtReadDoc(ctxt, (pcmkXmlStr) input, NULL, NULL,
	XML_PARSE_NOBLANKS \| XML_PARSE_RECOVER);
	if (output) {
	xml = xmlDocGetRootElement(output);
	}
	last_error = xmlCtxtGetLastError(ctxt);
	if (last_error && last_error->code != XML_ERR_OK) {
	/* crm_abort(__FILE__,__FUNCTION__,__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 = realloc_safe(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;
	while (rc == BZ_OK) {
	buffer = realloc_safe(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;
	}

	void
	strip_text_nodes(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);
	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;
	static int xml_options = XML_PARSE_NOBLANKS \| XML_PARSE_RECOVER;

	/* create a parser context */
	ctxt = xmlNewParserCtxt();
	CRM_CHECK(ctxt != NULL, return NULL);

	/* xmlCtxtUseOptions(ctxt, XML_PARSE_NOBLANKS\|XML_PARSE_RECOVER); */

	xmlCtxtResetLastError(ctxt);
	xmlSetGenericErrorFunc(ctxt, crm_xml_err);
	/* initGenericErrorDefaultFunc(crm_xml_err); */

	if (filename) {
	uncompressed = !crm_ends_with_ext(filename, ".bz2");
	}

	if (filename == NULL) {
	/* STDIN_FILENO == fileno(stdin) */
	output = xmlCtxtReadFd(ctxt, STDIN_FILENO, "unknown.xml", NULL, xml_options);

	} else if (uncompressed) {
	output = xmlCtxtReadFile(ctxt, filename, NULL, xml_options);

	} else {
	char *input = decompress_file(filename);

	output = xmlCtxtReadDoc(ctxt, (pcmkXmlStr) input, NULL, NULL,
	xml_options);
	free(input);
	}

	if (output && (xml = xmlDocGetRootElement(output))) {
	strip_text_nodes(xml);
	}

	last_error = xmlCtxtGetLastError(ctxt);
	if (last_error && last_error->code != XML_ERR_OK) {
	/* crm_abort(__FILE__,__FUNCTION__,__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
	*
	* \param[in] xml_node XML node to get attribute
	*
	* \return Value that was set, or NULL on error
	*/
	const char *
	crm_xml_add_last_written(xmlNode *xml_node)
	{
	- const char *now_str = crm_now_string();
	- return crm_xml_add(xml_node, XML_CIB_ATTR_WRITTEN, now_str);
	+ const char *now_str = crm_now_string(NULL);
	+ return crm_xml_add(xml_node, 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
	*
	* \return Number of bytes written on success, -errno otherwise
	*/
	static int
	write_xml_stream(xmlNode * xml_node, const char filename, FILE stream, gboolean compress)
	{
	int res = 0;
	char *buffer = NULL;
	unsigned int out = 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;
	goto bail);

	if (compress) {
	#if HAVE_BZLIB_H
	int rc = BZ_OK;
	unsigned int in = 0;
	BZFILE *bz_file = NULL;

	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);
	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
	} else {
	res = (int) out;
	crm_trace("Compressed XML for %s from %u bytes to %u",
	filename, in, out);
	}
	}
	#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;
	crm_perror(LOG_ERR, "writing %s", filename);
	goto bail;
	}
	}

	bail:

	if (fflush(stream) != 0) {
	res = -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;
	crm_perror(LOG_ERR, "synchronizing %s", filename);
	}

	fclose(stream);

	crm_trace("Saved %d bytes%s to %s as XML",
	res, ((out > 0)? " (compressed)" : ""), filename);
	free(buffer);

	return res;
	}

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

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

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

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

	xmlNode *
	get_message_xml(xmlNode * msg, const char *field)
	{
	xmlNode *tmp = first_named_child(msg, field);

	return __xml_first_child(tmp);
	}

	gboolean
	add_message_xml(xmlNode * msg, const char field, xmlNode xml)
	{
	xmlNode *holder = create_xml_node(msg, field);

	add_node_copy(holder, xml);
	return TRUE;
	}

	static char *
	crm_xml_escape_shuffle(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 = realloc_safe(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, "<");
	changes++;
	break;
	case '>':
	copy = crm_xml_escape_shuffle(copy, index, &length, ">");
	changes++;
	break;
	case '"':
	copy = crm_xml_escape_shuffle(copy, index, &length, """);
	changes++;
	break;
	case '\'':
	copy = crm_xml_escape_shuffle(copy, index, &length, "'");
	changes++;
	break;
	case '&':
	copy = crm_xml_escape_shuffle(copy, index, &length, "&");
	changes++;
	break;
	case '\t':
	/* Might as well just expand to a few spaces... */
	copy = crm_xml_escape_shuffle(copy, index, &length, " ");
	changes++;
	break;
	case '\n':
	/* crm_trace("Convert: \\%.3o", copy[index]); */
	copy = crm_xml_escape_shuffle(copy, index, &length, "\\n");
	changes++;
	break;
	case '\r':
	copy = crm_xml_escape_shuffle(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);
	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 && 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);
	}

	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)
	{
	int max = 0;
	int offset = 0;
	const char *name = NULL;
	const char *hidden = NULL;

	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;

	if(data == NULL) {
	return;
	}

	name = crm_element_name(data);

	if(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(is_set(p->flags, xpf_deleted)) {
	continue;
	} else if ((is_set(options, xml_log_option_diff_plus)
	\|\| is_set(options, 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(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(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);
	}
	}

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

	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)
	{
	xml_private_t *p;
	char *prefix_m = NULL;
	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;

	if(data == NULL) {
	return;
	}

	p = data->_private;

	prefix_m = strdup(prefix);
	prefix_m[1] = '+';

	if(is_set(p->flags, xpf_dirty) && is_set(p->flags, 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);

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

	for (pIter = pcmk__first_xml_attr(data); pIter != NULL; pIter = pIter->next) {
	const char aname = (const char)pIter->name;

	p = pIter->_private;
	if(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(is_set(p->flags, xpf_dirty)) {
	const char *value = crm_element_value(data, aname);

	if(is_set(p->flags, xpf_created)) {
	flags = prefix_m;

	} else if(is_set(p->flags, xpf_modified)) {
	flags = prefix;

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

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

	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 (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(is_set(options, xml_log_option_dirty_add) \|\| is_set(options, xml_log_option_dirty_add)) {
	__xml_log_change_element(log_level, file, function, line, prefix, data, depth, options);
	return;
	}

	if (is_set(options, xml_log_option_formatted)) {
	if (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 (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 (is_set(options, xml_log_option_diff_short)
	&& is_not_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);
	}
	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) {
	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);
	}

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

	void
	crm_xml_dump(xmlNode * data, int options, char *buffer, int offset, int *max, int depth)
	{
	if(data == NULL) {
	*offset = 0;
	*max = 0;
	return;
	}
	#if 0
	if (is_not_set(options, xml_log_option_filtered)) {
	/* Turning this code on also changes the scheduler tests for some reason
	* (not just newlines). Figure out why before considering to
	* enable this permanently.
	*
	* It exists to help debug slowness in xmlNodeDump() and
	* potentially if we ever want to go back to it.
	*
	* In theory it's a good idea (reuse) but our custom version does
	* better for the filtered case and avoids the final strdup() for
	* everything
	*/

	time_t now, next;
	xmlDoc *doc = NULL;
	xmlBuffer *xml_buffer = NULL;

	*buffer = NULL;
	doc = getDocPtr(data);
	/* doc will only be NULL if data is */
	CRM_CHECK(doc != NULL, return);

	now = time(NULL);
	xml_buffer = xmlBufferCreate();
	CRM_ASSERT(xml_buffer != NULL);

	/* The default allocator XML_BUFFER_ALLOC_EXACT does far too many
	* 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.
	*
	* We could also use xmlBufferCreateSize() to start with a
	* sane-ish initial size and avoid the first few doubles.
	*/
	xmlBufferSetAllocationScheme(xml_buffer, XML_BUFFER_ALLOC_DOUBLEIT);

	*max = xmlNodeDump(xml_buffer, doc, data, 0, (options & xml_log_option_formatted));
	if (*max > 0) {
	buffer = strdup((char )xml_buffer->content);
	}

	next = time(NULL);
	if ((now + 1) < next) {
	crm_log_xml_trace(data, "Long time");
	crm_err("xmlNodeDump() -> %dbytes took %ds", *max, next - now);
	}

	xmlBufferFree(xml_buffer);
	return;
	}
	#endif

	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
	*/
	}

	}

	void
	crm_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_text, &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);
	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);
	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);
	p->flags \|= xpf_deleted;
	/* crm_trace("Setting flag %x due to %s[@id=%s].%s", xpf_dirty, obj->name, ID(obj), name); */

	} 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", crm_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);
	}
	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 (safe_str_neq(new_digest, digest)) {
	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;
	}

	static void
	__xml_diff_object(xmlNode old_xml, xmlNode new_xml, bool check_top)
	{
	xmlNode *cIter = NULL;
	xmlAttr *pIter = NULL;

	CRM_CHECK(new_xml != NULL, return);
	if (old_xml == NULL) {
	crm_node_created(new_xml);
	pcmk__apply_creation_acl(new_xml, check_top);
	return;

	} else {
	xml_private_t *p = new_xml->_private;

	if(p->flags & xpf_processed) {
	/* Avoid re-comparing nodes */
	return;
	}
	p->flags \|= xpf_processed;
	}

	for (pIter = pcmk__first_xml_attr(new_xml); pIter != NULL; pIter = pIter->next) {
	xml_private_t *p = pIter->_private;

	/* Assume everything was just created and take it from there */
	p->flags \|= xpf_created;
	}

	for (pIter = pcmk__first_xml_attr(old_xml); pIter != NULL; ) {
	xmlAttr *prop = pIter;
	xml_private_t *p = NULL;
	const char name = (const char )pIter->name;
	const char *old_value = crm_element_value(old_xml, name);
	xmlAttr *exists = xmlHasProp(new_xml, pIter->name);

	pIter = pIter->next;
	if(exists == NULL) {
	p = new_xml->doc->_private;

	/* Prevent the dirty flag being set recursively upwards */
	clear_bit(p->flags, xpf_tracking);
	exists = xmlSetProp(new_xml, (pcmkXmlStr) name,
	(pcmkXmlStr) old_value);
	set_bit(p->flags, xpf_tracking);

	p = exists->_private;
	p->flags = 0;

	crm_trace("Lost %s@%s=%s", old_xml->name, name, old_value);
	xml_remove_prop(new_xml, name);

	} else {
	int p_new = __xml_offset((xmlNode*)exists);
	int p_old = __xml_offset((xmlNode*)prop);
	const char *value = crm_element_value(new_xml, name);

	p = exists->_private;
	p->flags = (p->flags & ~xpf_created);

	if(strcmp(value, old_value) != 0) {
	/* Restore the original value, so we can call crm_xml_add(),
	* which checks ACLs
	*/
	char *vcopy = crm_element_value_copy(new_xml, name);

	crm_trace("Modified %s@%s %s->%s",
	old_xml->name, name, old_value, vcopy);
	xmlSetProp(new_xml, prop->name, (pcmkXmlStr) old_value);
	crm_xml_add(new_xml, name, vcopy);
	free(vcopy);

	} else if ((p_old != p_new)
	&& !pcmk__tracking_xml_changes(new_xml, TRUE)) {
	crm_info("Moved %s@%s (%d -> %d)",
	old_xml->name, name, p_old, p_new);
	__xml_node_dirty(new_xml);
	p->flags \|= xpf_dirty\|xpf_moved;

	if(p_old > p_new) {
	p = prop->_private;
	p->flags \|= xpf_skip;

	} else {
	p = exists->_private;
	p->flags \|= xpf_skip;
	}
	}
	}
	}

	for (pIter = pcmk__first_xml_attr(new_xml); pIter != NULL; ) {
	xmlAttr *prop = pIter;
	xml_private_t *p = pIter->_private;

	pIter = pIter->next;
	if(is_set(p->flags, xpf_created)) {
	char name = strdup((const char )prop->name);
	char *value = crm_element_value_copy(new_xml, name);

	crm_trace("Created %s@%s=%s", new_xml->name, name, value);
	/* Remove plus create won't work as it will modify the relative attribute ordering */
	if (pcmk__check_acl(new_xml, name, xpf_acl_write)) {
	pcmk__mark_xml_attr_dirty(prop);
	} else {
	xmlUnsetProp(new_xml, prop->name); /* Remove - change not allowed */
	}

	free(value);
	free(name);
	}
	}

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

	} else {
	/* Create then free (which will check the acls if necessary) */
	xmlNode *candidate = add_node_copy(new_xml, old_child);
	xmlNode *top = xmlDocGetRootElement(candidate->doc);

	__xml_node_clean(candidate);
	pcmk__apply_acl(top); /* Make sure any ACLs are applied to 'candidate' */
	/* Record the old position */
	free_xml_with_position(candidate, __xml_offset(old_child));

	if (find_element(new_xml, old_child, TRUE) == NULL) {
	xml_private_t *p = old_child->_private;

	p->flags \|= xpf_skip;
	}
	}
	}

	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) {
	xml_private_t *p = new_child->_private;
	p->flags \|= xpf_skip;
	__xml_diff_object(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);

	if(p_old != p_new) {
	xml_private_t *p = new_child->_private;

	crm_info("%s.%s moved from %d to %d",
	new_child->name, ID(new_child), p_old, p_new);
	__xml_node_dirty(new_xml);
	p->flags \|= xpf_moved;

	if(p_old > p_new) {
	p = old_child->_private;
	} else {
	p = new_child->_private;
	}
	p->flags \|= xpf_skip;
	}
	}
	}
	}

	void
	xml_calculate_significant_changes(xmlNode old_xml, xmlNode new_xml)
	{
	pcmk__set_xml_flag(new_xml, xpf_lazy);
	xml_calculate_changes(old_xml, new_xml);
	}

	void
	xml_calculate_changes(xmlNode old_xml, xmlNode new_xml)
	{
	CRM_CHECK(safe_str_eq(crm_element_name(old_xml),
	crm_element_name(new_xml)),
	return);
	CRM_CHECK(safe_str_eq(ID(old_xml), ID(new_xml)), return);

	if(xml_tracking_changes(new_xml) == FALSE) {
	xml_track_changes(new_xml, NULL, NULL, FALSE);
	}

	__xml_diff_object(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 (safe_str_eq(name, XML_TAG_RESOURCE_REF)
	\|\| safe_str_eq(name, XML_CIB_TAG_OBJ_REF)
	\|\| safe_str_eq(name, XML_ACL_TAG_ROLE_REF)
	\|\| safe_str_eq(name, XML_ACL_TAG_ROLE_REFv1)) {
	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);

	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);
	xml_private_t *p = a_child->_private;

	if (offset < search_offset) {
	continue;

	} else if (offset > search_offset) {
	return NULL;
	}

	if (is_set(p->flags, xpf_skip)) {
	continue;
	}
	}

	if (a_child->type == XML_COMMENT_NODE
	&& safe_str_eq((const char )a_child->content, (const char )search_comment->content)) {
	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
	\|\| safe_str_neq((const char )left->content, (const char )right->content)) {
	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(safe_str_eq(crm_element_name(left), crm_element_name(right)), 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) {
	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 && 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)
	{
	CRM_CHECK(update != NULL, return 0);
	CRM_CHECK(update->type == XML_COMMENT_NODE, return 0);

	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 (safe_str_neq((const char )target->content, (const char )update->content)) {
	xmlFree(target->content);
	target->content = xmlStrdup(update->content);
	}

	return 0;
	}

	static int
	add_xml_object(xmlNode * parent, xmlNode * target, xmlNode * update, gboolean 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);

	if (update->type == XML_COMMENT_NODE) {
	return add_xml_comment(parent, target, update);
	}

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

	if (target == NULL) {
	target = find_entity_by_attr_or_just_name(parent, object_name,
	object_href, object_href_val);
	}

	if (target == NULL) {
	target = create_xml_node(parent, object_name);
	CRM_CHECK(target != NULL, return 0);
	#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(safe_str_eq(crm_element_name(target), crm_element_name(update)), return 0);

	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 (safe_str_neq(crm_element_name(to_update), crm_element_name(child))) {
	can_update = FALSE;

	} else if (safe_str_neq(ID(to_update), ID(child))) {
	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);
	}

	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 && safe_str_neq(tag, crm_element_name(root))) {

	} else if (value != NULL && safe_str_neq(value, crm_element_value(root, field))) {

	} else {
	if (*children == NULL) {
	*children = create_xml_node(NULL, __FUNCTION__);
	}
	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 (safe_str_neq(crm_element_name(update), crm_element_name(child))) {
	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 (safe_str_neq(p_value, right_val)) {
	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(parent); match != NULL; match = __xml_next(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 (name == NULL \|\| strcmp((const char *)match->name, name) == 0) {
	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(sibling);
	const char *name = crm_element_name(sibling);

	while (match != NULL) {
	if (!strcmp(crm_element_name(match), name)) {
	return match;
	}
	match = __xml_next(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
	* realloc_safe()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);

	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);
	}
	diff --git a/tools/crm_mon.c b/tools/crm_mon.c
	index bed079611c..4b7b101d67 100644
	--- a/tools/crm_mon.c
	+++ b/tools/crm_mon.c
	@@ -1,4414 +1,4425 @@
	/*
	* Copyright 2004-2019 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 <sys/param.h>

	#include <crm/crm.h>

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

	#include <stdlib.h>
	#include <errno.h>
	#include <fcntl.h>
	#include <libgen.h>
	#include <signal.h>
	#include <sys/utsname.h>

	#include <crm/msg_xml.h>
	#include <crm/services.h>
	#include <crm/lrmd.h>
	#include <crm/common/internal.h> /* crm_ends_with_ext */
	#include <crm/common/ipc.h>
	#include <crm/common/iso8601_internal.h>
	#include <crm/common/mainloop.h>
	#include <crm/common/util.h>
	#include <crm/common/xml.h>

	#include <crm/cib/internal.h>
	#include <crm/pengine/status.h>
	#include <crm/pengine/internal.h>
	#include <../lib/pengine/unpack.h>
	#include <pacemaker-internal.h>
	#include <crm/stonith-ng.h>

	static void clean_up_connections(void);
	static crm_exit_t clean_up(crm_exit_t exit_code);
	static void crm_diff_update(const char event, xmlNode msg);
	static gboolean mon_refresh_display(gpointer user_data);
	static int cib_connect(gboolean full);
	static void mon_st_callback_event(stonith_t * st, stonith_event_t * e);
	static void mon_st_callback_display(stonith_t * st, stonith_event_t * e);
	static void kick_refresh(gboolean data_updated);
	static char get_node_display_name(node_t node);

	/*
	* Definitions indicating which items to print
	*/

	#define mon_show_times (0x0001U)
	#define mon_show_stack (0x0002U)
	#define mon_show_dc (0x0004U)
	#define mon_show_count (0x0008U)
	#define mon_show_nodes (0x0010U)
	#define mon_show_resources (0x0020U)
	#define mon_show_attributes (0x0040U)
	#define mon_show_failcounts (0x0080U)
	#define mon_show_operations (0x0100U)
	#define mon_show_tickets (0x0200U)
	#define mon_show_bans (0x0400U)
	#define mon_show_fence_history (0x0800U)

	#define mon_show_headers (mon_show_times \| mon_show_stack \| mon_show_dc \
	\| mon_show_count)
	#define mon_show_default (mon_show_headers \| mon_show_nodes \
	\| mon_show_resources)
	#define mon_show_all (mon_show_default \| mon_show_attributes \
	\| mon_show_failcounts \| mon_show_operations \
	\| mon_show_tickets \| mon_show_bans \
	\| mon_show_fence_history)

	static unsigned int show = mon_show_default;

	/*
	* Definitions indicating how to output
	*/

	enum mon_output_format_e {
	mon_output_none,
	mon_output_monitor,
	mon_output_plain,
	mon_output_console,
	mon_output_xml,
	mon_output_html,
	mon_output_cgi
	} output_format = mon_output_console;

	static char output_filename = NULL; / if sending output to a file, its name */

	/* other globals */
	static char *pid_file = NULL;

	static gboolean group_by_node = FALSE;
	static gboolean inactive_resources = FALSE;
	static int reconnect_msec = 5000;
	static gboolean daemonize = FALSE;
	static GMainLoop *mainloop = NULL;
	static guint timer_id = 0;
	static mainloop_timer_t *refresh_timer = NULL;
	static pe_working_set_t *mon_data_set = NULL;
	static GList *attr_list = NULL;

	static const char *external_agent = NULL;
	static const char *external_recipient = NULL;

	static cib_t *cib = NULL;
	static stonith_t *st = NULL;
	static xmlNode *current_cib = NULL;

	static gboolean one_shot = FALSE;
	static gboolean has_warnings = FALSE;
	static gboolean print_timing = FALSE;
	static gboolean watch_fencing = FALSE;
	static gboolean fence_history = FALSE;
	static gboolean fence_full_history = FALSE;
	static gboolean fence_connect = FALSE;
	static int fence_history_level = 1;
	static gboolean print_brief = FALSE;
	static gboolean print_pending = TRUE;
	static gboolean print_clone_detail = FALSE;
	#if CURSES_ENABLED
	static gboolean curses_console_initialized = FALSE;
	#endif

	/* FIXME allow, detect, and correctly interpret glob pattern or regex? */
	const char *print_neg_location_prefix = "";

	/* Never display node attributes whose name starts with one of these prefixes */
	#define FILTER_STR { CRM_FAIL_COUNT_PREFIX, CRM_LAST_FAILURE_PREFIX, \
	"shutdown", "terminate", "standby", "probe_complete", \
	"#", NULL }

	long last_refresh = 0;
	crm_trigger_t *refresh_trigger = NULL;

	/* Define exit codes for monitoring-compatible output
	* For nagios plugins, the possibilities are
	* OK=0, WARN=1, CRIT=2, and UNKNOWN=3
	*/
	#define MON_STATUS_WARN CRM_EX_ERROR
	#define MON_STATUS_CRIT CRM_EX_INVALID_PARAM
	#define MON_STATUS_UNKNOWN CRM_EX_UNIMPLEMENT_FEATURE

	/* Convenience macro for prettifying output (e.g. "node" vs "nodes") */
	#define s_if_plural(i) (((i) == 1)? "" : "s")

	#if CURSES_ENABLED
	# define print_dot() if (output_format == mon_output_console) { \
	printw("."); \
	clrtoeol(); \
	refresh(); \
	} else { \
	fprintf(stdout, "."); \
	}
	#else
	# define print_dot() fprintf(stdout, ".");
	#endif

	#if CURSES_ENABLED
	# define print_as(fmt, args...) if (output_format == mon_output_console) { \
	printw(fmt, ##args); \
	clrtoeol(); \
	refresh(); \
	} else { \
	fprintf(stdout, fmt, ##args); \
	}
	#else
	# define print_as(fmt, args...) fprintf(stdout, fmt, ##args);
	#endif

	static void
	blank_screen(void)
	{
	#if CURSES_ENABLED
	int lpc = 0;

	for (lpc = 0; lpc < LINES; lpc++) {
	move(lpc, 0);
	clrtoeol();
	}
	move(0, 0);
	refresh();
	#endif
	}

	static gboolean
	mon_timer_popped(gpointer data)
	{
	int rc = pcmk_ok;

	#if CURSES_ENABLED
	if (output_format == mon_output_console) {
	clear();
	refresh();
	}
	#endif

	if (timer_id > 0) {
	g_source_remove(timer_id);
	timer_id = 0;
	}

	print_as("Reconnecting...\n");
	rc = cib_connect(TRUE);

	if (rc != pcmk_ok) {
	timer_id = g_timeout_add(reconnect_msec, mon_timer_popped, NULL);
	}
	return FALSE;
	}

	static void
	mon_cib_connection_destroy(gpointer user_data)
	{
	print_as("Connection to the cluster-daemons terminated\n");
	if (refresh_timer != NULL) {
	/* we'll trigger a refresh after reconnect */
	mainloop_timer_stop(refresh_timer);
	}
	if (timer_id) {
	/* we'll trigger a new reconnect-timeout at the end */
	g_source_remove(timer_id);
	timer_id = 0;
	}
	if (st) {
	/* the client API won't properly reconnect notifications
	* if they are still in the table - so remove them
	*/
	st->cmds->remove_notification(st, T_STONITH_NOTIFY_DISCONNECT);
	st->cmds->remove_notification(st, T_STONITH_NOTIFY_FENCE);
	st->cmds->remove_notification(st, T_STONITH_NOTIFY_HISTORY);
	if (st->state != stonith_disconnected) {
	st->cmds->disconnect(st);
	}
	}
	if (cib) {
	cib->cmds->signoff(cib);
	timer_id = g_timeout_add(reconnect_msec, mon_timer_popped, NULL);
	}
	return;
	}

	/*
	* Mainloop signal handler.
	*/
	static void
	mon_shutdown(int nsig)
	{
	clean_up(CRM_EX_OK);
	}

	#if CURSES_ENABLED
	static sighandler_t ncurses_winch_handler;

	static void
	mon_winresize(int nsig)
	{
	static int not_done;
	int lines = 0, cols = 0;

	if (!not_done++) {
	if (ncurses_winch_handler)
	/* the original ncurses WINCH signal handler does the
	* magic of retrieving the new window size;
	* otherwise, we'd have to use ioctl or tgetent */
	(*ncurses_winch_handler) (SIGWINCH);
	getmaxyx(stdscr, lines, cols);
	resizeterm(lines, cols);
	mainloop_set_trigger(refresh_trigger);
	}
	not_done--;
	}
	#endif

	static int
	cib_connect(gboolean full)
	{
	int rc = pcmk_ok;
	static gboolean need_pass = TRUE;

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

	if (getenv("CIB_passwd") != NULL) {
	need_pass = FALSE;
	}

	if ((fence_connect) && (st == NULL)) {
	st = stonith_api_new();
	}

	if ((fence_connect) && (st->state == stonith_disconnected)) {
	rc = st->cmds->connect(st, crm_system_name, NULL);
	if (rc == pcmk_ok) {
	crm_trace("Setting up stonith callbacks");
	if (watch_fencing) {
	st->cmds->register_notification(st, T_STONITH_NOTIFY_DISCONNECT,
	mon_st_callback_event);
	st->cmds->register_notification(st, T_STONITH_NOTIFY_FENCE, mon_st_callback_event);
	} else {
	st->cmds->register_notification(st, T_STONITH_NOTIFY_DISCONNECT,
	mon_st_callback_display);
	st->cmds->register_notification(st, T_STONITH_NOTIFY_HISTORY, mon_st_callback_display);
	}
	}
	}

	if (cib->state != cib_connected_query && cib->state != cib_connected_command) {
	crm_trace("Connecting to the CIB");
	if ((output_format == mon_output_console) && need_pass && (cib->variant == cib_remote)) {
	need_pass = FALSE;
	print_as("Password:");
	}

	rc = cib->cmds->signon(cib, crm_system_name, cib_query);

	if (rc != pcmk_ok) {
	return rc;
	}

	rc = cib->cmds->query(cib, NULL, &current_cib, cib_scope_local \| cib_sync_call);
	if (rc == pcmk_ok) {
	mon_refresh_display(NULL);
	}

	if (rc == pcmk_ok && full) {
	if (rc == pcmk_ok) {
	rc = cib->cmds->set_connection_dnotify(cib, mon_cib_connection_destroy);
	if (rc == -EPROTONOSUPPORT) {
	print_as
	("Notification setup not supported, won't be able to reconnect after failure");
	if (output_format == mon_output_console) {
	sleep(2);
	}
	rc = pcmk_ok;
	}

	}

	if (rc == pcmk_ok) {
	cib->cmds->del_notify_callback(cib, T_CIB_DIFF_NOTIFY, crm_diff_update);
	rc = cib->cmds->add_notify_callback(cib, T_CIB_DIFF_NOTIFY, crm_diff_update);
	}

	if (rc != pcmk_ok) {
	print_as("Notification setup failed, could not monitor CIB actions");
	if (output_format == mon_output_console) {
	sleep(2);
	}
	clean_up_connections();
	}
	}
	}
	return rc;
	}

	/* INDENT-OFF */
	static struct crm_option long_options[] = {
	/* Top-level Options */
	{"help", 0, 0, '?', "\tThis text"},
	{"version", 0, 0, '$', "\tVersion information" },
	{"verbose", 0, 0, 'V', "\tIncrease debug output"},
	{"quiet", 0, 0, 'Q', "\tDisplay only essential output" },

	{"-spacer-", 1, 0, '-', "\nModes (mutually exclusive):"},
	{"as-html", 1, 0, 'h', "\tWrite cluster status to the named html file"},
	{"as-xml", 0, 0, 'X', "\t\tWrite cluster status as xml to stdout. This will enable one-shot mode."},
	{"web-cgi", 0, 0, 'w', "\t\tWeb mode with output suitable for CGI (preselected when run as *.cgi)"},
	{"simple-status", 0, 0, 's', "\tDisplay the cluster status once as a simple one line output (suitable for nagios)"},
	{"-spacer-", 1, 0, '-', "\nDisplay Options:"},
	{"group-by-node", 0, 0, 'n', "\tGroup resources by node" },
	{"inactive", 0, 0, 'r', "\t\tDisplay inactive resources" },
	{"failcounts", 0, 0, 'f', "\tDisplay resource fail counts"},
	{"operations", 0, 0, 'o', "\tDisplay resource operation history" },
	{"timing-details", 0, 0, 't', "\tDisplay resource operation history with timing details" },
	{"tickets", 0, 0, 'c', "\t\tDisplay cluster tickets"},
	{"watch-fencing", 0, 0, 'W', "\tListen for fencing events. For use with --external-agent"},
	{"fence-history", 2, 0, 'm', "Show fence history\n"
	"\t\t\t\t\t0=off, 1=failures and pending (default without option),\n"
	"\t\t\t\t\t2=add successes (default without value for option),\n"
	"\t\t\t\t\t3=show full history without reduction to most recent of each flavor"},
	{"neg-locations", 2, 0, 'L', "Display negative location constraints [optionally filtered by id prefix]"},
	{"show-node-attributes", 0, 0, 'A', "Display node attributes" },
	{"hide-headers", 0, 0, 'D', "\tHide all headers" },
	{"show-detail", 0, 0, 'R', "\tShow more details (node IDs, individual clone instances)" },
	{"brief", 0, 0, 'b', "\t\tBrief output" },
	{"pending", 0, 0, 'j', "\t\tDisplay pending state if 'record-pending' is enabled", pcmk_option_hidden},

	{"-spacer-", 1, 0, '-', "\nAdditional Options:"},
	{"interval", 1, 0, 'i', "\tUpdate frequency in seconds" },
	{"one-shot", 0, 0, '1', "\t\tDisplay the cluster status once on the console and exit"},
	{"disable-ncurses",0, 0, 'N', "\tDisable the use of ncurses", !CURSES_ENABLED},
	{"daemonize", 0, 0, 'd', "\tRun in the background as a daemon"},
	{"pid-file", 1, 0, 'p', "\t(Advanced) Daemon pid file location"},
	{"external-agent", 1, 0, 'E', "A program to run when resource operations take place."},
	{"external-recipient",1, 0, 'e', "A recipient for your program (assuming you want the program to send something to someone)."},


	{"xml-file", 1, 0, 'x', NULL, pcmk_option_hidden},

	{"-spacer-", 1, 0, '-', "\nExamples:", pcmk_option_paragraph},
	{"-spacer-", 1, 0, '-', "Display the cluster status on the console with updates as they occur:", pcmk_option_paragraph},
	{"-spacer-", 1, 0, '-', " crm_mon", pcmk_option_example},
	{"-spacer-", 1, 0, '-', "Display the cluster status on the console just once then exit:", pcmk_option_paragraph},
	{"-spacer-", 1, 0, '-', " crm_mon -1", pcmk_option_example},
	{"-spacer-", 1, 0, '-', "Display your cluster status, group resources by node, and include inactive resources in the list:", pcmk_option_paragraph},
	{"-spacer-", 1, 0, '-', " crm_mon --group-by-node --inactive", pcmk_option_example},
	{"-spacer-", 1, 0, '-', "Start crm_mon as a background daemon and have it write the cluster status to an HTML file:", pcmk_option_paragraph},
	{"-spacer-", 1, 0, '-', " crm_mon --daemonize --as-html /path/to/docroot/filename.html", pcmk_option_example},
	{"-spacer-", 1, 0, '-', "Start crm_mon and export the current cluster status as xml to stdout, then exit.:", pcmk_option_paragraph},
	{"-spacer-", 1, 0, '-', " crm_mon --as-xml", pcmk_option_example},

	{NULL, 0, 0, 0}
	};
	/* INDENT-ON */

	#if CURSES_ENABLED
	static const char *
	get_option_desc(char c)
	{
	int lpc;

	for (lpc = 0; long_options[lpc].name != NULL; lpc++) {

	if (long_options[lpc].name[0] == '-')
	continue;

	if (long_options[lpc].val == c) {
	static char *buf = NULL;
	const char *rv;
	char *nl;

	/* chop off tabs and cut at newline */
	free(buf); /* free string from last usage */
	buf = strdup(long_options[lpc].desc);
	rv = buf; /* make a copy to keep buf pointer unaltered
	for freeing when we come by next time.
	Like this the result stays valid until
	the next call.
	*/
	while(isspace(rv[0])) {
	rv++;
	}
	nl = strchr(rv, '\n');
	if (nl) {
	*nl = '\0';
	}
	return rv;
	}
	}

	return NULL;
	}

	#define print_option_help(option, condition) \
	print_as("%c %c: \t%s\n", ((condition)? '*': ' '), option, get_option_desc(option));

	static gboolean
	detect_user_input(GIOChannel *channel, GIOCondition condition, gpointer unused)
	{
	int c;
	gboolean config_mode = FALSE;

	while (1) {

	/* Get user input */
	c = getchar();

	switch (c) {
	case 'm':
	if (!fence_history_level) {
	fence_history = TRUE;
	fence_connect = TRUE;
	if (st == NULL) {
	mon_cib_connection_destroy(NULL);
	}
	}
	show ^= mon_show_fence_history;
	break;
	case 'c':
	show ^= mon_show_tickets;
	break;
	case 'f':
	show ^= mon_show_failcounts;
	break;
	case 'n':
	group_by_node = ! group_by_node;
	break;
	case 'o':
	show ^= mon_show_operations;
	if ((show & mon_show_operations) == 0) {
	print_timing = 0;
	}
	break;
	case 'r':
	inactive_resources = ! inactive_resources;
	break;
	case 'R':
	print_clone_detail = ! print_clone_detail;
	break;
	case 't':
	print_timing = ! print_timing;
	if (print_timing) {
	show \|= mon_show_operations;
	}
	break;
	case 'A':
	show ^= mon_show_attributes;
	break;
	case 'L':
	show ^= mon_show_bans;
	break;
	case 'D':
	/* If any header is shown, clear them all, otherwise set them all */
	if (show & mon_show_headers) {
	show &= ~mon_show_headers;
	} else {
	show \|= mon_show_headers;
	}
	break;
	case 'b':
	print_brief = ! print_brief;
	break;
	case 'j':
	print_pending = ! print_pending;
	break;
	case '?':
	config_mode = TRUE;
	break;
	default:
	goto refresh;
	}

	if (!config_mode)
	goto refresh;

	blank_screen();

	print_as("Display option change mode\n");
	print_as("\n");
	print_option_help('c', show & mon_show_tickets);
	print_option_help('f', show & mon_show_failcounts);
	print_option_help('n', group_by_node);
	print_option_help('o', show & mon_show_operations);
	print_option_help('r', inactive_resources);
	print_option_help('t', print_timing);
	print_option_help('A', show & mon_show_attributes);
	print_option_help('L', show & mon_show_bans);
	print_option_help('D', (show & mon_show_headers) == 0);
	print_option_help('R', print_clone_detail);
	print_option_help('b', print_brief);
	print_option_help('j', print_pending);
	print_option_help('m', (show & mon_show_fence_history));
	print_as("\n");
	print_as("Toggle fields via field letter, type any other key to return");
	}

	refresh:
	mon_refresh_display(NULL);
	return TRUE;
	}
	#endif

	// Basically crm_signal_handler(SIGCHLD, SIG_IGN) plus the SA_NOCLDWAIT flag
	static void
	avoid_zombies()
	{
	struct sigaction sa;

	memset(&sa, 0, sizeof(struct sigaction));
	if (sigemptyset(&sa.sa_mask) < 0) {
	crm_warn("Cannot avoid zombies: %s", pcmk_strerror(errno));
	return;
	}
	sa.sa_handler = SIG_IGN;
	sa.sa_flags = SA_RESTART\|SA_NOCLDWAIT;
	if (sigaction(SIGCHLD, &sa, NULL) < 0) {
	crm_warn("Cannot avoid zombies: %s", pcmk_strerror(errno));
	}
	}

	int
	main(int argc, char **argv)
	{
	int flag;
	int argerr = 0;
	int option_index = 0;
	int rc = pcmk_ok;

	pid_file = strdup("/tmp/ClusterMon.pid");
	crm_log_cli_init("crm_mon");
	crm_set_options(NULL, "mode [options]", long_options,
	"Provides a summary of cluster's current state."
	"\n\nOutputs varying levels of detail in a number of different formats.\n");

	// Avoid needing to wait for subprocesses forked for -E/--external-agent
	avoid_zombies();

	if (crm_ends_with_ext(argv[0], ".cgi") == TRUE) {
	output_format = mon_output_cgi;
	one_shot = TRUE;
	}

	/* to enable stonith-connection when called via some application like pcs
	* set environment-variable FENCE_HISTORY to desired level
	* so you don't have to modify this application
	*/
	/* fence_history_level = crm_atoi(getenv("FENCE_HISTORY"), "0"); */

	while (1) {
	flag = crm_get_option(argc, argv, &option_index);
	if (flag == -1)
	break;

	switch (flag) {
	case 'V':
	crm_bump_log_level(argc, argv);
	break;
	case 'Q':
	show &= ~mon_show_times;
	break;
	case 'i':
	reconnect_msec = crm_get_msec(optarg);
	break;
	case 'n':
	group_by_node = TRUE;
	break;
	case 'r':
	inactive_resources = TRUE;
	break;
	case 'W':
	watch_fencing = TRUE;
	fence_connect = TRUE;
	break;
	case 'm':
	fence_history_level = crm_atoi(optarg, "2");
	break;
	case 'd':
	daemonize = TRUE;
	break;
	case 't':
	print_timing = TRUE;
	show \|= mon_show_operations;
	break;
	case 'o':
	show \|= mon_show_operations;
	break;
	case 'f':
	show \|= mon_show_failcounts;
	break;
	case 'A':
	show \|= mon_show_attributes;
	break;
	case 'L':
	show \|= mon_show_bans;
	print_neg_location_prefix = optarg? optarg : "";
	break;
	case 'D':
	show &= ~mon_show_headers;
	break;
	case 'b':
	print_brief = TRUE;
	break;
	case 'j':
	print_pending = TRUE;
	break;
	case 'R':
	print_clone_detail = TRUE;
	break;
	case 'c':
	show \|= mon_show_tickets;
	break;
	case 'p':
	free(pid_file);
	if(optarg == NULL) {
	crm_help(flag, CRM_EX_USAGE);
	}
	pid_file = strdup(optarg);
	break;
	case 'x':
	if(optarg == NULL) {
	crm_help(flag, CRM_EX_USAGE);
	}
	setenv("CIB_file", optarg, 1);
	one_shot = TRUE;
	break;
	case 'h':
	if(optarg == NULL) {
	crm_help(flag, CRM_EX_USAGE);
	}
	argerr += (output_format != mon_output_console);
	output_format = mon_output_html;
	output_filename = strdup(optarg);
	umask(S_IWGRP \| S_IWOTH);
	break;
	case 'X':
	argerr += (output_format != mon_output_console);
	output_format = mon_output_xml;
	one_shot = TRUE;
	break;
	case 'w':
	/* do not allow argv[0] and argv[1...] redundancy */
	argerr += (output_format != mon_output_console);
	output_format = mon_output_cgi;
	one_shot = TRUE;
	break;
	case 's':
	argerr += (output_format != mon_output_console);
	output_format = mon_output_monitor;
	one_shot = TRUE;
	break;
	case 'E':
	external_agent = optarg;
	break;
	case 'e':
	external_recipient = optarg;
	break;
	case '1':
	one_shot = TRUE;
	break;
	case 'N':
	if (output_format == mon_output_console) {
	output_format = mon_output_plain;
	}
	break;
	case '$':
	case '?':
	crm_help(flag, CRM_EX_OK);
	break;
	default:
	printf("Argument code 0%o (%c) is not (?yet?) supported\n", flag, flag);
	++argerr;
	break;
	}
	}

	if (watch_fencing) {
	/* don't moan as fence_history_level == 1 is default */
	fence_history_level = 0;
	}

	/* create the cib-object early to be able to do further
	* decisions based on the cib-source
	*/
	cib = cib_new();

	if (cib == NULL) {
	rc = -EINVAL;
	} else {
	switch (cib->variant) {

	case cib_native:
	/* cib & fencing - everything available */
	break;

	case cib_file:
	/* Don't try to connect to fencing as we
	* either don't have a running cluster or
	* the fencing-information would possibly
	* not match the cib data from a file.
	* As we don't expect cib-updates coming
	* in enforce one-shot. */
	fence_history_level = 0;
	one_shot = TRUE;
	break;

	case cib_remote:
	/* updates coming in but no fencing */
	fence_history_level = 0;
	break;

	case cib_undefined:
	case cib_database:
	default:
	/* something is odd */
	rc = -EINVAL;
	crm_err("Invalid cib-source");
	break;
	}
	}

	switch (fence_history_level) {
	case 3:
	fence_full_history = TRUE;
	/* fall through to next lower level */
	case 2:
	show \|= mon_show_fence_history;
	/* fall through to next lower level */
	case 1:
	fence_history = TRUE;
	fence_connect = TRUE;
	break;
	default:
	break;
	}

	/* Extra sanity checks when in CGI mode */
	if (output_format == mon_output_cgi) {
	argerr += (optind < argc);
	argerr += (output_filename != NULL);
	argerr += ((cib) && (cib->variant == cib_file));
	argerr += (external_agent != NULL);
	argerr += (daemonize == TRUE); /* paranoia */

	} else if (optind < argc) {
	printf("non-option ARGV-elements: ");
	while (optind < argc)
	printf("%s ", argv[optind++]);
	printf("\n");
	}

	if (argerr) {
	return clean_up(CRM_EX_USAGE);
	}

	/* XML output always prints everything */
	if (output_format == mon_output_xml) {
	show = mon_show_all;
	print_timing = TRUE;
	}

	if (one_shot) {
	if (output_format == mon_output_console) {
	output_format = mon_output_plain;
	}

	} else if (daemonize) {
	if ((output_format == mon_output_console) \|\| (output_format == mon_output_plain)) {
	output_format = mon_output_none;
	}
	crm_enable_stderr(FALSE);

	if ((output_format != mon_output_html)
	&& !external_agent) {
	printf ("Looks like you forgot to specify one or more of: "
	"--as-html, --external-agent\n");
	return clean_up(CRM_EX_USAGE);
	}

	if (cib) {
	/* to be on the safe side don't have cib-object around
	* when we are forking
	*/
	cib_delete(cib);
	cib = NULL;
	crm_make_daemon(crm_system_name, TRUE, pid_file);
	cib = cib_new();
	if (cib == NULL) {
	rc = -EINVAL;
	}
	/* otherwise assume we've got the same cib-object we've just destroyed
	* in our parent
	*/
	}


	} else if (output_format == mon_output_console) {
	#if CURSES_ENABLED
	initscr();
	cbreak();
	noecho();
	crm_enable_stderr(FALSE);
	curses_console_initialized = TRUE;
	#else
	one_shot = TRUE;
	output_format = mon_output_plain;
	printf("Defaulting to one-shot mode\n");
	printf("You need to have curses available at compile time to enable console mode\n");
	#endif
	}

	crm_info("Starting %s", crm_system_name);

	if (cib) {

	do {
	if (!one_shot) {
	print_as("Waiting until cluster is available on this node ...\n");
	}
	rc = cib_connect(!one_shot);

	if (one_shot) {
	break;

	} else if (rc != pcmk_ok) {
	sleep(reconnect_msec / 1000);
	#if CURSES_ENABLED
	if (output_format == mon_output_console) {
	clear();
	refresh();
	}
	#endif
	} else {
	if (output_format == mon_output_html) {
	print_as("Writing html to %s ...\n", output_filename);
	}
	}

	} while (rc == -ENOTCONN);
	}

	if (rc != pcmk_ok) {
	if (output_format == mon_output_monitor) {
	printf("CLUSTER CRIT: Connection to cluster failed: %s\n",
	pcmk_strerror(rc));
	return clean_up(MON_STATUS_CRIT);
	} else {
	if (rc == -ENOTCONN) {
	print_as("\nError: cluster is not available on this node\n");
	} else {
	print_as("\nConnection to cluster failed: %s\n",
	pcmk_strerror(rc));
	}
	}
	if (output_format == mon_output_console) {
	sleep(2);
	}
	return clean_up(crm_errno2exit(rc));
	}

	if (one_shot) {
	return clean_up(CRM_EX_OK);
	}

	mainloop = g_main_loop_new(NULL, FALSE);

	mainloop_add_signal(SIGTERM, mon_shutdown);
	mainloop_add_signal(SIGINT, mon_shutdown);
	#if CURSES_ENABLED
	if (output_format == mon_output_console) {
	ncurses_winch_handler = crm_signal_handler(SIGWINCH, mon_winresize);
	if (ncurses_winch_handler == SIG_DFL \|\|
	ncurses_winch_handler == SIG_IGN \|\| ncurses_winch_handler == SIG_ERR)
	ncurses_winch_handler = NULL;
	g_io_add_watch(g_io_channel_unix_new(STDIN_FILENO), G_IO_IN, detect_user_input, NULL);
	}
	#endif
	refresh_trigger = mainloop_add_trigger(G_PRIORITY_LOW, mon_refresh_display, NULL);

	g_main_loop_run(mainloop);
	g_main_loop_unref(mainloop);

	crm_info("Exiting %s", crm_system_name);

	return clean_up(CRM_EX_OK);
	}

	#define mon_warn(fmt...) do { \
	if (!has_warnings) { \
	print_as("CLUSTER WARN:"); \
	} else { \
	print_as(","); \
	} \
	print_as(fmt); \
	has_warnings = TRUE; \
	} while(0)

	static int
	count_resources(pe_working_set_t * data_set, resource_t * rsc)
	{
	int count = 0;
	GListPtr gIter = NULL;

	if (rsc == NULL) {
	gIter = data_set->resources;
	} else if (rsc->children) {
	gIter = rsc->children;
	} else {
	return is_not_set(rsc->flags, pe_rsc_orphan);
	}

	for (; gIter != NULL; gIter = gIter->next) {
	count += count_resources(data_set, gIter->data);
	}
	return count;
	}

	/*!
	* \internal
	* \brief Print one-line status suitable for use with monitoring software
	*
	* \param[in] data_set Working set of CIB state
	* \param[in] history List of stonith actions
	*
	* \note This function's output (and the return code when the program exits)
	* should conform to https://www.monitoring-plugins.org/doc/guidelines.html
	*/
	static void
	print_simple_status(pe_working_set_t * data_set,
	stonith_history_t *history)
	{
	GListPtr gIter = NULL;
	int nodes_online = 0;
	int nodes_standby = 0;
	int nodes_maintenance = 0;

	if (data_set->dc_node == NULL) {
	mon_warn(" No DC");
	}

	for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) {
	node_t node = (node_t ) gIter->data;

	if (node->details->standby && node->details->online) {
	nodes_standby++;
	} else if (node->details->maintenance && node->details->online) {
	nodes_maintenance++;
	} else if (node->details->online) {
	nodes_online++;
	} else {
	mon_warn(" offline node: %s", node->details->uname);
	}
	}

	if (!has_warnings) {
	int nresources = count_resources(data_set, NULL);

	print_as("CLUSTER OK: %d node%s online", nodes_online, s_if_plural(nodes_online));
	if (nodes_standby > 0) {
	print_as(", %d standby node%s", nodes_standby, s_if_plural(nodes_standby));
	}
	if (nodes_maintenance > 0) {
	print_as(", %d maintenance node%s", nodes_maintenance, s_if_plural(nodes_maintenance));
	}
	print_as(", %d resource%s configured", nresources, s_if_plural(nresources));
	}

	print_as("\n");
	}

	/*!
	* \internal
	* \brief Print a [name]=[value][units] pair, optionally using time string
	*
	* \param[in] stream File stream to display output to
	* \param[in] name Name to display
	* \param[in] value Value to display (or NULL to convert time instead)
	* \param[in] units Units to display (or NULL for no units)
	* \param[in] epoch_time Epoch time to convert if value is NULL
	*/
	static void
	print_nvpair(FILE stream, const char name, const char *value,
	const char *units, time_t epoch_time)
	{
	/* print name= */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" %s=", name);
	break;

	case mon_output_html:
	case mon_output_cgi:
	case mon_output_xml:
	fprintf(stream, " %s=", name);
	break;

	default:
	break;
	}

	/* If we have a value (and optionally units), print it */
	if (value) {
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("%s%s", value, (units? units : ""));
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, "%s%s", value, (units? units : ""));
	break;

	case mon_output_xml:
	fprintf(stream, "\"%s%s\"", value, (units? units : ""));
	break;

	default:
	break;
	}

	/* Otherwise print user-friendly time string */
	} else {
	static char empty_str[] = "";
	char c, date_str = asctime(localtime(&epoch_time));

	for (c = (date_str != NULL) ? date_str : empty_str; *c != '\0'; ++c) {
	if (*c == '\n') {
	*c = '\0';
	break;
	}
	}
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("'%s'", date_str);
	break;

	case mon_output_html:
	case mon_output_cgi:
	case mon_output_xml:
	fprintf(stream, "\"%s\"", date_str);
	break;

	default:
	break;
	}
	}
	}

	/*!
	* \internal
	* \brief Print whatever is needed to start a node section
	*
	* \param[in] stream File stream to display output to
	* \param[in] node Node to print
	*/
	static void
	print_node_start(FILE stream, node_t node)
	{
	char *node_name;

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	node_name = get_node_display_name(node);
	print_as("* Node %s:\n", node_name);
	free(node_name);
	break;

	case mon_output_html:
	case mon_output_cgi:
	node_name = get_node_display_name(node);
	fprintf(stream, " <h3>Node: %s</h3>\n <ul>\n", node_name);
	free(node_name);
	break;

	case mon_output_xml:
	fprintf(stream, " <node name=\"%s\">\n", node->details->uname);
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print whatever is needed to end a node section
	*
	* \param[in] stream File stream to display output to
	*/
	static void
	print_node_end(FILE *stream)
	{
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </node>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print resources section heading appropriate to options
	*
	* \param[in] stream File stream to display output to
	*/
	static void
	print_resources_heading(FILE *stream)
	{
	const char *heading;

	if (group_by_node) {

	/* Active resources have already been printed by node */
	heading = (inactive_resources? "Inactive resources" : NULL);

	} else if (inactive_resources) {
	heading = "Full list of resources";

	} else {
	heading = "Active resources";
	}

	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\n%s:\n\n", heading);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>%s</h2>\n", heading);
	break;

	case mon_output_xml:
	fprintf(stream, " <resources>\n");
	break;

	default:
	break;
	}

	}

	/*!
	* \internal
	* \brief Print whatever resource section closing is appropriate
	*
	* \param[in] stream File stream to display output to
	*/
	static void
	print_resources_closing(FILE *stream, gboolean printed_heading)
	{
	const char *heading;

	/* What type of resources we did or did not display */
	if (group_by_node) {
	heading = "inactive ";
	} else if (inactive_resources) {
	heading = "";
	} else {
	heading = "active ";
	}

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	if (!printed_heading) {
	print_as("\nNo %sresources\n\n", heading);
	}
	break;

	case mon_output_html:
	case mon_output_cgi:
	if (!printed_heading) {
	fprintf(stream, " <hr />\n <h2>No %sresources</h2>\n", heading);
	}
	break;

	case mon_output_xml:
	fprintf(stream, " %s\n",
	(printed_heading? "</resources>" : "<resources/>"));
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print whatever resource section(s) are appropriate
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Cluster state to display
	* \param[in] print_opts Bitmask of pe_print_options
	*/
	static void
	print_resources(FILE stream, pe_working_set_t data_set, int print_opts)
	{
	GListPtr rsc_iter;
	const char *prefix = NULL;
	gboolean printed_heading = FALSE;
	gboolean brief_output = print_brief;

	/* If we already showed active resources by node, and
	* we're not showing inactive resources, we have nothing to do
	*/
	if (group_by_node && !inactive_resources) {
	return;
	}

	/* XML uses an indent, and ignores brief option for resources */
	if (output_format == mon_output_xml) {
	prefix = " ";
	brief_output = FALSE;
	}

	/* If we haven't already printed resources grouped by node,
	* and brief output was requested, print resource summary */
	if (brief_output && !group_by_node) {
	print_resources_heading(stream);
	printed_heading = TRUE;
	print_rscs_brief(data_set->resources, NULL, print_opts, stream,
	inactive_resources);
	}

	/* For each resource, display it if appropriate */
	for (rsc_iter = data_set->resources; rsc_iter != NULL; rsc_iter = rsc_iter->next) {
	resource_t rsc = (resource_t ) rsc_iter->data;

	/* Complex resources may have some sub-resources active and some inactive */
	gboolean is_active = rsc->fns->active(rsc, TRUE);
	gboolean partially_active = rsc->fns->active(rsc, FALSE);

	/* Skip inactive orphans (deleted but still in CIB) */
	if (is_set(rsc->flags, pe_rsc_orphan) && !is_active) {
	continue;

	/* Skip active resources if we already displayed them by node */
	} else if (group_by_node) {
	if (is_active) {
	continue;
	}

	/* Skip primitives already counted in a brief summary */
	} else if (brief_output && (rsc->variant == pe_native)) {
	continue;

	/* Skip resources that aren't at least partially active,
	* unless we're displaying inactive resources
	*/
	} else if (!partially_active && !inactive_resources) {
	continue;
	}

	/* Print this resource */
	if (printed_heading == FALSE) {
	print_resources_heading(stream);
	printed_heading = TRUE;
	}
	rsc->fns->print(rsc, prefix, print_opts, stream);
	}

	print_resources_closing(stream, printed_heading);
	}

	/*!
	* \internal
	* \brief Print heading for resource history
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Current state of CIB
	* \param[in] node Node that ran this resource
	* \param[in] rsc Resource to print
	* \param[in] rsc_id ID of resource to print
	* \param[in] all Whether to print every resource or just failed ones
	*/
	static void
	print_rsc_history_start(FILE stream, pe_working_set_t data_set, node_t *node,
	resource_t rsc, const char rsc_id, gboolean all)
	{
	time_t last_failure = 0;
	int failcount = rsc?
	pe_get_failcount(node, rsc, &last_failure, pe_fc_default,
	NULL, data_set)
	: 0;

	if (!all && !failcount && (last_failure <= 0)) {
	return;
	}

	/* Print resource ID */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" %s:", rsc_id);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <li>%s:", rsc_id);
	break;

	case mon_output_xml:
	fprintf(stream, " <resource_history id=\"%s\"", rsc_id);
	break;

	default:
	break;
	}

	/* If resource is an orphan, that's all we can say about it */
	if (rsc == NULL) {
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" orphan");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " orphan");
	break;

	case mon_output_xml:
	fprintf(stream, " orphan=\"true\"");
	break;

	default:
	break;
	}

	/* If resource is not an orphan, print some details */
	} else if (all \|\| failcount \|\| (last_failure > 0)) {

	/* Print migration threshold */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" migration-threshold=%d", rsc->migration_threshold);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " migration-threshold=%d", rsc->migration_threshold);
	break;

	case mon_output_xml:
	fprintf(stream, " orphan=\"false\" migration-threshold=\"%d\"",
	rsc->migration_threshold);
	break;

	default:
	break;
	}

	/* Print fail count if any */
	if (failcount > 0) {
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" " CRM_FAIL_COUNT_PREFIX "=%d", failcount);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " " CRM_FAIL_COUNT_PREFIX "=%d", failcount);
	break;

	case mon_output_xml:
	fprintf(stream, " " CRM_FAIL_COUNT_PREFIX "=\"%d\"",
	failcount);
	break;

	default:
	break;
	}
	}

	/* Print last failure time if any */
	if (last_failure > 0) {
	print_nvpair(stream, CRM_LAST_FAILURE_PREFIX, NULL, NULL,
	last_failure);
	}
	}

	/* End the heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, "\n <ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, ">\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print closing for resource history
	*
	* \param[in] stream File stream to display output to
	*/
	static void
	print_rsc_history_end(FILE *stream)
	{
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n </li>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </resource_history>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print operation history
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Current state of CIB
	* \param[in] node Node this operation is for
	* \param[in] xml_op Root of XML tree describing this operation
	* \param[in] task Task parsed from this operation's XML
	* \param[in] interval_ms_s Interval parsed from this operation's XML
	* \param[in] rc Return code parsed from this operation's XML
	*/
	static void
	print_op_history(FILE stream, pe_working_set_t data_set, node_t *node,
	xmlNode xml_op, const char task, const char *interval_ms_s,
	int rc)
	{
	const char *value = NULL;
	const char *call = crm_element_value(xml_op, XML_LRM_ATTR_CALLID);

	/* Begin the operation description */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" + (%s) %s:", call, task);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <li>(%s) %s:", call, task);
	break;

	case mon_output_xml:
	fprintf(stream, " <operation_history call=\"%s\" task=\"%s\"",
	call, task);
	break;

	default:
	break;
	}

	/* Add name=value pairs as appropriate */
	if (interval_ms_s && safe_str_neq(interval_ms_s, "0")) {
	print_nvpair(stream, "interval", interval_ms_s, "ms", 0);
	}
	if (print_timing) {
	int int_value;
	const char *attr;

	attr = XML_RSC_OP_LAST_CHANGE;
	value = crm_element_value(xml_op, attr);
	if (value) {
	int_value = crm_parse_int(value, NULL);
	if (int_value > 0) {
	print_nvpair(stream, attr, NULL, NULL, int_value);
	}
	}

	attr = XML_RSC_OP_LAST_RUN;
	value = crm_element_value(xml_op, attr);
	if (value) {
	int_value = crm_parse_int(value, NULL);
	if (int_value > 0) {
	print_nvpair(stream, attr, NULL, NULL, int_value);
	}
	}

	attr = XML_RSC_OP_T_EXEC;
	value = crm_element_value(xml_op, attr);
	if (value) {
	print_nvpair(stream, attr, value, "ms", 0);
	}

	attr = XML_RSC_OP_T_QUEUE;
	value = crm_element_value(xml_op, attr);
	if (value) {
	print_nvpair(stream, attr, value, "ms", 0);
	}
	}

	/* End the operation description */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" rc=%d (%s)\n", rc, services_ocf_exitcode_str(rc));
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " rc=%d (%s)</li>\n", rc, services_ocf_exitcode_str(rc));
	break;

	case mon_output_xml:
	fprintf(stream, " rc=\"%d\" rc_text=\"%s\" />\n", rc, services_ocf_exitcode_str(rc));
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print resource operation/failure history
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Current state of CIB
	* \param[in] node Node that ran this resource
	* \param[in] rsc_entry Root of XML tree describing resource status
	* \param[in] operations Whether to print operations or just failcounts
	*/
	static void
	print_rsc_history(FILE stream, pe_working_set_t data_set, node_t *node,
	xmlNode *rsc_entry, gboolean operations)
	{
	GListPtr gIter = NULL;
	GListPtr op_list = NULL;
	gboolean printed = FALSE;
	const char *rsc_id = crm_element_value(rsc_entry, XML_ATTR_ID);
	resource_t *rsc = pe_find_resource(data_set->resources, rsc_id);
	xmlNode *rsc_op = NULL;

	/* If we're not showing operations, just print the resource failure summary */
	if (operations == FALSE) {
	print_rsc_history_start(stream, data_set, node, rsc, rsc_id, FALSE);
	print_rsc_history_end(stream);
	return;
	}

	/* Create a list of this resource's operations */
	for (rsc_op = __xml_first_child(rsc_entry); rsc_op != NULL; rsc_op = __xml_next(rsc_op)) {
	if (crm_str_eq((const char *)rsc_op->name, XML_LRM_TAG_RSC_OP, TRUE)) {
	op_list = g_list_append(op_list, rsc_op);
	}
	}
	op_list = g_list_sort(op_list, sort_op_by_callid);

	/* Print each operation */
	for (gIter = op_list; gIter != NULL; gIter = gIter->next) {
	xmlNode xml_op = (xmlNode ) gIter->data;
	const char *task = crm_element_value(xml_op, XML_LRM_ATTR_TASK);
	const char *interval_ms_s = crm_element_value(xml_op,
	XML_LRM_ATTR_INTERVAL_MS);
	const char *op_rc = crm_element_value(xml_op, XML_LRM_ATTR_RC);
	int rc = crm_parse_int(op_rc, "0");

	/* Display 0-interval monitors as "probe" */
	if (safe_str_eq(task, CRMD_ACTION_STATUS)
	&& ((interval_ms_s == NULL) \|\| safe_str_eq(interval_ms_s, "0"))) {
	task = "probe";
	}

	/* Ignore notifies and some probes */
	if (safe_str_eq(task, CRMD_ACTION_NOTIFY) \|\| (safe_str_eq(task, "probe") && (rc == 7))) {
	continue;
	}

	/* If this is the first printed operation, print heading for resource */
	if (printed == FALSE) {
	printed = TRUE;
	print_rsc_history_start(stream, data_set, node, rsc, rsc_id, TRUE);
	}

	/* Print the operation */
	print_op_history(stream, data_set, node, xml_op, task, interval_ms_s,
	rc);
	}

	/* Free the list we created (no need to free the individual items) */
	g_list_free(op_list);

	/* If we printed anything, close the resource */
	if (printed) {
	print_rsc_history_end(stream);
	}
	}

	/*!
	* \internal
	* \brief Print node operation/failure history
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Current state of CIB
	* \param[in] node_state Root of XML tree describing node status
	* \param[in] operations Whether to print operations or just failcounts
	*/
	static void
	print_node_history(FILE stream, pe_working_set_t data_set,
	xmlNode *node_state, gboolean operations)
	{
	node_t *node = pe_find_node_id(data_set->nodes, ID(node_state));
	xmlNode *lrm_rsc = NULL;
	xmlNode *rsc_entry = NULL;

	if (node && node->details && node->details->online) {
	print_node_start(stream, node);

	lrm_rsc = find_xml_node(node_state, XML_CIB_TAG_LRM, FALSE);
	lrm_rsc = find_xml_node(lrm_rsc, XML_LRM_TAG_RESOURCES, FALSE);

	/* Print history of each of the node's resources */
	for (rsc_entry = __xml_first_child(lrm_rsc); rsc_entry != NULL;
	rsc_entry = __xml_next(rsc_entry)) {

	if (crm_str_eq((const char *)rsc_entry->name, XML_LRM_TAG_RESOURCE, TRUE)) {
	print_rsc_history(stream, data_set, node, rsc_entry, operations);
	}
	}

	print_node_end(stream);
	}
	}

	/*!
	* \internal
	* \brief Print extended information about an attribute if appropriate
	*
	* \param[in] data_set Working set of CIB state
	*
	* \return TRUE if extended information was printed, FALSE otherwise
	* \note Currently, extended information is only supported for ping/pingd
	* resources, for which a message will be printed if connectivity is lost
	* or degraded.
	*/
	static gboolean
	print_attr_msg(FILE stream, node_t node, GListPtr rsc_list, const char attrname, const char attrvalue)
	{
	GListPtr gIter = NULL;

	for (gIter = rsc_list; gIter != NULL; gIter = gIter->next) {
	resource_t rsc = (resource_t ) gIter->data;
	const char *type = g_hash_table_lookup(rsc->meta, "type");

	if (rsc->children != NULL) {
	if (print_attr_msg(stream, node, rsc->children, attrname, attrvalue)) {
	return TRUE;
	}
	}

	if (safe_str_eq(type, "ping") \|\| safe_str_eq(type, "pingd")) {
	const char *name = g_hash_table_lookup(rsc->parameters, "name");

	if (name == NULL) {
	name = "pingd";
	}

	/* To identify the resource with the attribute name. */
	if (safe_str_eq(name, attrname)) {
	int host_list_num = 0;
	int expected_score = 0;
	int value = crm_parse_int(attrvalue, "0");
	const char *hosts = g_hash_table_lookup(rsc->parameters, "host_list");
	const char *multiplier = g_hash_table_lookup(rsc->parameters, "multiplier");

	if(hosts) {
	char **host_list = g_strsplit(hosts, " ", 0);
	host_list_num = g_strv_length(host_list);
	g_strfreev(host_list);
	}

	/* pingd multiplier is the same as the default value. */
	expected_score = host_list_num * crm_parse_int(multiplier, "1");

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	if (value <= 0) {
	print_as("\t: Connectivity is lost");
	} else if (value < expected_score) {
	print_as("\t: Connectivity is degraded (Expected=%d)", expected_score);
	}
	break;

	case mon_output_html:
	case mon_output_cgi:
	if (value <= 0) {
	fprintf(stream, " <b>(connectivity is lost)</b>");
	} else if (value < expected_score) {
	fprintf(stream, " <b>(connectivity is degraded -- expected %d)</b>",
	expected_score);
	}
	break;

	case mon_output_xml:
	fprintf(stream, " expected=\"%d\"", expected_score);
	break;

	default:
	break;
	}
	return TRUE;
	}
	}
	}
	return FALSE;
	}

	static int
	compare_attribute(gconstpointer a, gconstpointer b)
	{
	int rc;

	rc = strcmp((const char )a, (const char )b);

	return rc;
	}

	static void
	create_attr_list(gpointer name, gpointer value, gpointer data)
	{
	int i;
	const char *filt_str[] = FILTER_STR;

	CRM_CHECK(name != NULL, return);

	/* filtering automatic attributes */
	for (i = 0; filt_str[i] != NULL; i++) {
	if (g_str_has_prefix(name, filt_str[i])) {
	return;
	}
	}

	attr_list = g_list_insert_sorted(attr_list, name, compare_attribute);
	}

	/* structure for passing multiple user data to g_list_foreach() */
	struct mon_attr_data {
	FILE *stream;
	node_t *node;
	};

	static void
	print_node_attribute(gpointer name, gpointer user_data)
	{
	const char *value = NULL;
	struct mon_attr_data data = (struct mon_attr_data ) user_data;

	value = pe_node_attribute_raw(data->node, name);

	/* Print attribute name and value */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(" + %-32s\t: %-10s", (char *)name, value);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(data->stream, " <li>%s: %s",
	(char *)name, value);
	break;

	case mon_output_xml:
	fprintf(data->stream,
	" <attribute name=\"%s\" value=\"%s\"",
	(char *)name, value);
	break;

	default:
	break;
	}

	/* Print extended information if appropriate */
	print_attr_msg(data->stream, data->node, data->node->details->running_rsc,
	name, value);

	/* Close out the attribute */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(data->stream, "</li>\n");
	break;

	case mon_output_xml:
	fprintf(data->stream, " />\n");
	break;

	default:
	break;
	}
	}

	static void
	print_node_summary(FILE stream, pe_working_set_t data_set, gboolean operations)
	{
	xmlNode *node_state = NULL;
	xmlNode *cib_status = get_object_root(XML_CIB_TAG_STATUS, data_set->input);

	/* Print heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	if (operations) {
	print_as("\nOperations:\n");
	} else {
	print_as("\nMigration Summary:\n");
	}
	break;

	case mon_output_html:
	case mon_output_cgi:
	if (operations) {
	fprintf(stream, " <hr />\n <h2>Operations</h2>\n");
	} else {
	fprintf(stream, " <hr />\n <h2>Migration Summary</h2>\n");
	}
	break;

	case mon_output_xml:
	fprintf(stream, " <node_history>\n");
	break;

	default:
	break;
	}

	/* Print each node in the CIB status */
	for (node_state = __xml_first_child(cib_status); node_state != NULL;
	node_state = __xml_next(node_state)) {
	if (crm_str_eq((const char *)node_state->name, XML_CIB_TAG_STATE, TRUE)) {
	print_node_history(stream, data_set, node_state, operations);
	}
	}

	/* Close section */
	switch (output_format) {
	case mon_output_xml:
	fprintf(stream, " </node_history>\n");
	break;

	default:
	break;
	}
	}

	static void
	print_ticket(gpointer name, gpointer value, gpointer data)
	{
	ticket_t ticket = (ticket_t ) value;
	FILE stream = (FILE ) data;

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("* %s:\t%s%s", ticket->id,
	(ticket->granted? "granted" : "revoked"),
	(ticket->standby? " [standby]" : ""));
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <li>%s: %s%s", ticket->id,
	(ticket->granted? "granted" : "revoked"),
	(ticket->standby? " [standby]" : ""));
	break;

	case mon_output_xml:
	fprintf(stream, " <ticket id=\"%s\" status=\"%s\" standby=\"%s\"",
	ticket->id, (ticket->granted? "granted" : "revoked"),
	(ticket->standby? "true" : "false"));
	break;

	default:
	break;
	}
	if (ticket->last_granted > -1) {
	print_nvpair(stdout, "last-granted", NULL, NULL, ticket->last_granted);
	}
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, "</li>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " />\n");
	break;

	default:
	break;
	}
	}

	static void
	print_cluster_tickets(FILE stream, pe_working_set_t data_set)
	{
	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\nTickets:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>Tickets</h2>\n <ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <tickets>\n");
	break;

	default:
	break;
	}

	/* Print each ticket */
	g_hash_table_foreach(data_set->tickets, print_ticket, stream);

	/* Close section */
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </tickets>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Return human-friendly string representing node name
	*
	* The returned string will be in the format
	* uname[@hostUname] [(nodeID)]
	* "@hostUname" will be printed if the node is a guest node.
	* "(nodeID)" will be printed if the node ID is different from the node uname,
	* and detailed output has been requested.
	*
	* \param[in] node Node to represent
	* \return Newly allocated string with representation of node name
	* \note It is the caller's responsibility to free the result with free().
	*/
	static char *
	get_node_display_name(node_t *node)
	{
	char *node_name;
	const char *node_host = NULL;
	const char *node_id = NULL;
	int name_len;

	CRM_ASSERT((node != NULL) && (node->details != NULL) && (node->details->uname != NULL));

	/* Host is displayed only if this is a guest node */
	if (pe__is_guest_node(node)) {
	node_t *host_node = pe__current_node(node->details->remote_rsc);

	if (host_node && host_node->details) {
	node_host = host_node->details->uname;
	}
	if (node_host == NULL) {
	node_host = ""; /* so we at least get "uname@" to indicate guest */
	}
	}

	/* Node ID is displayed if different from uname and detail is requested */
	if (print_clone_detail && safe_str_neq(node->details->uname, node->details->id)) {
	node_id = node->details->id;
	}

	/* Determine name length */
	name_len = strlen(node->details->uname) + 1;
	if (node_host) {
	name_len += strlen(node_host) + 1; /* "@node_host" */
	}
	if (node_id) {
	name_len += strlen(node_id) + 3; /* + " (node_id)" */
	}

	/* Allocate and populate display name */
	node_name = malloc(name_len);
	CRM_ASSERT(node_name != NULL);
	strcpy(node_name, node->details->uname);
	if (node_host) {
	strcat(node_name, "@");
	strcat(node_name, node_host);
	}
	if (node_id) {
	strcat(node_name, " (");
	strcat(node_name, node_id);
	strcat(node_name, ")");
	}
	return node_name;
	}

	/*!
	* \internal
	* \brief Print a negative location constraint
	*
	* \param[in] stream File stream to display output to
	* \param[in] node Node affected by constraint
	* \param[in] location Constraint to print
	*/
	static void
	print_ban(FILE stream, pe_node_t node, pe__location_t *location)
	{
	char *node_name = NULL;

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	node_name = get_node_display_name(node);
	print_as(" %s\tprevents %s from running %son %s\n",
	location->id, location->rsc_lh->id,
	((location->role_filter == RSC_ROLE_MASTER)? "as Master " : ""),
	node_name);
	break;

	case mon_output_html:
	case mon_output_cgi:
	node_name = get_node_display_name(node);
	fprintf(stream, " <li>%s prevents %s from running %son %s</li>\n",
	location->id, location->rsc_lh->id,
	((location->role_filter == RSC_ROLE_MASTER)? "as Master " : ""),
	node_name);
	break;

	case mon_output_xml:
	fprintf(stream,
	" <ban id=\"%s\" resource=\"%s\" node=\"%s\" weight=\"%d\" master_only=\"%s\" />\n",
	location->id, location->rsc_lh->id, node->details->uname, node->weight,
	((location->role_filter == RSC_ROLE_MASTER)? "true" : "false"));
	break;

	default:
	break;
	}
	free(node_name);
	}

	/*!
	* \internal
	* \brief Print section for negative location constraints
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set corresponding to CIB status to display
	*/
	static void
	print_neg_locations(FILE stream, pe_working_set_t data_set)
	{
	GListPtr gIter, gIter2;

	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\nNegative Location Constraints:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>Negative Location Constraints</h2>\n <ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <bans>\n");
	break;

	default:
	break;
	}

	/* Print each ban */
	for (gIter = data_set->placement_constraints; gIter != NULL; gIter = gIter->next) {
	pe__location_t *location = gIter->data;
	if (!g_str_has_prefix(location->id, print_neg_location_prefix))
	continue;
	for (gIter2 = location->node_list_rh; gIter2 != NULL; gIter2 = gIter2->next) {
	node_t node = (node_t ) gIter2->data;

	if (node->weight < 0) {
	print_ban(stream, node, location);
	}
	}
	}

	/* Close section */
	switch (output_format) {
	case mon_output_cgi:
	case mon_output_html:
	fprintf(stream, " </ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </bans>\n");
	break;

	default:
	break;
	}
	}

	static void
	crm_mon_get_parameters(resource_t rsc, pe_working_set_t data_set)
	{
	get_rsc_attributes(rsc->parameters, rsc, NULL, data_set);
	crm_trace("Beekhof: unpacked params for %s (%d)", rsc->id, g_hash_table_size(rsc->parameters));
	if(rsc->children) {
	GListPtr gIter = NULL;

	for (gIter = rsc->children; gIter != NULL; gIter = gIter->next) {
	crm_mon_get_parameters(gIter->data, data_set);
	}
	}
	}

	/*!
	* \internal
	* \brief Print node attributes section
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	*/
	static void
	print_node_attributes(FILE stream, pe_working_set_t data_set)
	{
	GListPtr gIter = NULL;

	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\nNode Attributes:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>Node Attributes</h2>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <node_attributes>\n");
	break;

	default:
	break;
	}

	/* Unpack all resource parameters (it would be more efficient to do this
	* only when needed for the first time in print_attr_msg())
	*/
	for (gIter = data_set->resources; gIter != NULL; gIter = gIter->next) {
	crm_mon_get_parameters(gIter->data, data_set);
	}

	/* Display each node's attributes */
	for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) {
	struct mon_attr_data data;

	data.stream = stream;
	data.node = (node_t *) gIter->data;

	if (data.node && data.node->details && data.node->details->online) {
	print_node_start(stream, data.node);
	g_hash_table_foreach(data.node->details->attrs, create_attr_list, NULL);
	g_list_foreach(attr_list, print_node_attribute, &data);
	g_list_free(attr_list);
	attr_list = NULL;
	print_node_end(stream);
	}
	}

	/* Print section footer */
	switch (output_format) {
	case mon_output_xml:
	fprintf(stream, " </node_attributes>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Return resource display options corresponding to command-line choices
	*
	* \return Bitmask of pe_print_options suitable for resource print functions
	*/
	static int
	get_resource_display_options(void)
	{
	int print_opts;

	/* Determine basic output format */
	switch (output_format) {
	case mon_output_console:
	print_opts = pe_print_ncurses;
	break;
	case mon_output_html:
	case mon_output_cgi:
	print_opts = pe_print_html;
	break;
	case mon_output_xml:
	print_opts = pe_print_xml;
	break;
	default:
	print_opts = pe_print_printf;
	break;
	}

	/* Add optional display elements */
	if (print_pending) {
	print_opts \|= pe_print_pending;
	}
	if (print_clone_detail) {
	print_opts \|= pe_print_clone_details\|pe_print_implicit;
	}
	if (!inactive_resources) {
	print_opts \|= pe_print_clone_active;
	}
	if (print_brief) {
	print_opts \|= pe_print_brief;
	}
	return print_opts;
	}


	/*!
	* \internal
	* \brief Print header for cluster summary if needed
	*
	* \param[in] stream File stream to display output to
	*/
	static void
	print_cluster_summary_header(FILE *stream)
	{
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <h2>Cluster Summary</h2>\n <p>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <summary>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print footer for cluster summary if needed
	*
	* \param[in] stream File stream to display output to
	*/
	static void
	print_cluster_summary_footer(FILE *stream)
	{
	switch (output_format) {
	case mon_output_cgi:
	case mon_output_html:
	fprintf(stream, " </p>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </summary>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print times the display was last updated and CIB last changed
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	*/
	static void
	print_cluster_times(FILE stream, pe_working_set_t data_set)
	{
	const char *last_written = crm_element_value(data_set->input, XML_CIB_ATTR_WRITTEN);
	const char *user = crm_element_value(data_set->input, XML_ATTR_UPDATE_USER);
	const char *client = crm_element_value(data_set->input, XML_ATTR_UPDATE_CLIENT);
	const char *origin = crm_element_value(data_set->input, XML_ATTR_UPDATE_ORIG);

	switch (output_format) {
	case mon_output_plain:
	- case mon_output_console:
	- print_as("Last updated: %s", crm_now_string());
	+ case mon_output_console: {
	+ const char *now_str = crm_now_string(NULL);
	+
	+ print_as("Last updated: %s", now_str ? now_str : "Could not determine current time");
	print_as((user \|\| client \|\| origin)? "\n" : "\t\t");
	print_as("Last change: %s", last_written ? last_written : "");
	if (user) {
	print_as(" by %s", user);
	}
	if (client) {
	print_as(" via %s", client);
	}
	if (origin) {
	print_as(" on %s", origin);
	}
	print_as("\n");
	break;
	+ }

	case mon_output_html:
	- case mon_output_cgi:
	- fprintf(stream, " <b>Last updated:</b> %s<br/>\n", crm_now_string());
	+ case mon_output_cgi: {
	+ const char *now_str = crm_now_string(NULL);
	+
	+ fprintf(stream, " <b>Last updated:</b> %s<br/>\n",
	+ now_str ? now_str : "Could not determine current time");
	fprintf(stream, " <b>Last change:</b> %s", last_written ? last_written : "");
	if (user) {
	fprintf(stream, " by %s", user);
	}
	if (client) {
	fprintf(stream, " via %s", client);
	}
	if (origin) {
	fprintf(stream, " on %s", origin);
	}
	fprintf(stream, "<br/>\n");
	break;
	+ }

	- case mon_output_xml:
	- fprintf(stream, " <last_update time=\"%s\" />\n", crm_now_string());
	+ case mon_output_xml: {
	+ const char *now_str = crm_now_string(NULL);
	+
	+ fprintf(stream, " <last_update time=\"%s\" />\n",
	+ now_str ? now_str : "Could not determine current time");
	fprintf(stream, " <last_change time=\"%s\" user=\"%s\" client=\"%s\" origin=\"%s\" />\n",
	last_written ? last_written : "", user ? user : "",
	client ? client : "", origin ? origin : "");
	break;
	+ }

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print cluster stack
	*
	* \param[in] stream File stream to display output to
	* \param[in] stack_s Stack name
	*/
	static void
	print_cluster_stack(FILE stream, const char stack_s)
	{
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("Stack: %s\n", stack_s);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <b>Stack:</b> %s<br/>\n", stack_s);
	break;

	case mon_output_xml:
	fprintf(stream, " <stack type=\"%s\" />\n", stack_s);
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print current DC and its version
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	*/
	static void
	print_cluster_dc(FILE stream, pe_working_set_t data_set)
	{
	node_t *dc = data_set->dc_node;
	xmlNode *dc_version = get_xpath_object("//nvpair[@name='dc-version']",
	data_set->input, LOG_DEBUG);
	const char *dc_version_s = dc_version?
	crm_element_value(dc_version, XML_NVPAIR_ATTR_VALUE)
	: NULL;
	const char *quorum = crm_element_value(data_set->input, XML_ATTR_HAVE_QUORUM);
	char *dc_name = dc? get_node_display_name(dc) : NULL;

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("Current DC: ");
	if (dc) {
	print_as("%s (version %s) - partition %s quorum\n",
	dc_name, (dc_version_s? dc_version_s : "unknown"),
	(crm_is_true(quorum) ? "with" : "WITHOUT"));
	} else {
	print_as("NONE\n");
	}
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <b>Current DC:</b> ");
	if (dc) {
	fprintf(stream, "%s (version %s) - partition %s quorum",
	dc_name, (dc_version_s? dc_version_s : "unknown"),
	(crm_is_true(quorum)? "with" : "<font color=\"red\"><b>WITHOUT</b></font>"));
	} else {
	fprintf(stream, "<font color=\"red\"><b>NONE</b></font>");
	}
	fprintf(stream, "<br/>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <current_dc ");
	if (dc) {
	fprintf(stream,
	"present=\"true\" version=\"%s\" name=\"%s\" id=\"%s\" with_quorum=\"%s\"",
	(dc_version_s? dc_version_s : ""), dc->details->uname, dc->details->id,
	(crm_is_true(quorum) ? "true" : "false"));
	} else {
	fprintf(stream, "present=\"false\"");
	}
	fprintf(stream, " />\n");
	break;

	default:
	break;
	}
	free(dc_name);
	}

	/*!
	* \internal
	* \brief Print counts of configured nodes and resources
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	* \param[in] stack_s Stack name
	*/
	static void
	print_cluster_counts(FILE stream, pe_working_set_t data_set, const char *stack_s)
	{
	int nnodes = g_list_length(data_set->nodes);
	int nresources = count_resources(data_set, NULL);

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:

	print_as("\n%d node%s configured\n", nnodes, s_if_plural(nnodes));

	print_as("%d resource%s configured",
	nresources, s_if_plural(nresources));
	if(data_set->disabled_resources \|\| data_set->blocked_resources) {
	print_as(" (");
	if (data_set->disabled_resources) {
	print_as("%d DISABLED", data_set->disabled_resources);
	}
	if (data_set->disabled_resources && data_set->blocked_resources) {
	print_as(", ");
	}
	if (data_set->blocked_resources) {
	print_as("%d BLOCKED from starting due to failure",
	data_set->blocked_resources);
	}
	print_as(")");
	}
	print_as("\n");

	break;

	case mon_output_html:
	case mon_output_cgi:

	fprintf(stream, " %d node%s configured<br/>\n",
	nnodes, s_if_plural(nnodes));

	fprintf(stream, " %d resource%s configured",
	nresources, s_if_plural(nresources));
	if (data_set->disabled_resources \|\| data_set->blocked_resources) {
	fprintf(stream, " (");
	if (data_set->disabled_resources) {
	fprintf(stream, "%d <strong>DISABLED</strong>",
	data_set->disabled_resources);
	}
	if (data_set->disabled_resources && data_set->blocked_resources) {
	fprintf(stream, ", ");
	}
	if (data_set->blocked_resources) {
	fprintf(stream,
	"%d <strong>BLOCKED</strong> from starting due to failure",
	data_set->blocked_resources);
	}
	fprintf(stream, ")");
	}
	fprintf(stream, "<br/>\n");
	break;

	case mon_output_xml:
	fprintf(stream,
	" <nodes_configured number=\"%d\" />\n",
	g_list_length(data_set->nodes));
	fprintf(stream,
	" <resources_configured number=\"%d\" disabled=\"%d\" blocked=\"%d\" />\n",
	count_resources(data_set, NULL),
	data_set->disabled_resources, data_set->blocked_resources);
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print cluster-wide options
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	*
	* \note Currently this is only implemented for HTML and XML output, and
	* prints only a few options. If there is demand, more could be added.
	*/
	static void
	print_cluster_options(FILE stream, pe_working_set_t data_set)
	{
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	if (is_set(data_set->flags, pe_flag_maintenance_mode)) {
	print_as("\n * Resource management is DISABLED *");
	print_as("\n The cluster will not attempt to start, stop or recover services");
	print_as("\n");
	}
	break;

	case mon_output_html:
	fprintf(stream, " </p>\n <h3>Config Options</h3>\n");
	fprintf(stream, " <table>\n");
	fprintf(stream, " <tr><th>STONITH of failed nodes</th><td>%s</td></tr>\n",
	is_set(data_set->flags, pe_flag_stonith_enabled)? "enabled" : "disabled");

	fprintf(stream, " <tr><th>Cluster is</th><td>%ssymmetric</td></tr>\n",
	is_set(data_set->flags, pe_flag_symmetric_cluster)? "" : "a");

	fprintf(stream, " <tr><th>No Quorum Policy</th><td>");
	switch (data_set->no_quorum_policy) {
	case no_quorum_freeze:
	fprintf(stream, "Freeze resources");
	break;
	case no_quorum_stop:
	fprintf(stream, "Stop ALL resources");
	break;
	case no_quorum_ignore:
	fprintf(stream, "Ignore");
	break;
	case no_quorum_suicide:
	fprintf(stream, "Suicide");
	break;
	}
	fprintf(stream, "</td></tr>\n");

	fprintf(stream, " <tr><th>Resource management</th><td>");
	if (is_set(data_set->flags, pe_flag_maintenance_mode)) {
	fprintf(stream, "<strong>DISABLED</strong> (the cluster will "
	"not attempt to start, stop or recover services)");
	} else {
	fprintf(stream, "enabled");
	}
	fprintf(stream, "</td></tr>\n");

	fprintf(stream, "</table>\n <p>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <cluster_options");
	fprintf(stream, " stonith-enabled=\"%s\"",
	is_set(data_set->flags, pe_flag_stonith_enabled)?
	"true" : "false");
	fprintf(stream, " symmetric-cluster=\"%s\"",
	is_set(data_set->flags, pe_flag_symmetric_cluster)?
	"true" : "false");
	fprintf(stream, " no-quorum-policy=\"");
	switch (data_set->no_quorum_policy) {
	case no_quorum_freeze:
	fprintf(stream, "freeze");
	break;
	case no_quorum_stop:
	fprintf(stream, "stop");
	break;
	case no_quorum_ignore:
	fprintf(stream, "ignore");
	break;
	case no_quorum_suicide:
	fprintf(stream, "suicide");
	break;
	}
	fprintf(stream, "\"");
	fprintf(stream, " maintenance-mode=\"%s\"",
	is_set(data_set->flags, pe_flag_maintenance_mode)?
	"true" : "false");
	fprintf(stream, " />\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Get the name of the stack in use (or "unknown" if not available)
	*
	* \param[in] data_set Working set of CIB state
	*
	* \return String representing stack name
	*/
	static const char *
	get_cluster_stack(pe_working_set_t *data_set)
	{
	xmlNode *stack = get_xpath_object("//nvpair[@name='cluster-infrastructure']",
	data_set->input, LOG_DEBUG);
	return stack? crm_element_value(stack, XML_NVPAIR_ATTR_VALUE) : "unknown";
	}

	/*!
	* \internal
	* \brief Print a summary of cluster-wide information
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	*/
	static void
	print_cluster_summary(FILE stream, pe_working_set_t data_set)
	{
	const char *stack_s = get_cluster_stack(data_set);
	gboolean header_printed = FALSE;

	if (show & mon_show_stack) {
	if (header_printed == FALSE) {
	print_cluster_summary_header(stream);
	header_printed = TRUE;
	}
	print_cluster_stack(stream, stack_s);
	}

	/* Always print DC if none, even if not requested */
	if ((data_set->dc_node == NULL) \|\| (show & mon_show_dc)) {
	if (header_printed == FALSE) {
	print_cluster_summary_header(stream);
	header_printed = TRUE;
	}
	print_cluster_dc(stream, data_set);
	}

	if (show & mon_show_times) {
	if (header_printed == FALSE) {
	print_cluster_summary_header(stream);
	header_printed = TRUE;
	}
	print_cluster_times(stream, data_set);
	}

	if (is_set(data_set->flags, pe_flag_maintenance_mode)
	\|\| data_set->disabled_resources
	\|\| data_set->blocked_resources
	\|\| is_set(show, mon_show_count)) {
	if (header_printed == FALSE) {
	print_cluster_summary_header(stream);
	header_printed = TRUE;
	}
	print_cluster_counts(stream, data_set, stack_s);
	}

	/* There is not a separate option for showing cluster options, so show with
	* stack for now; a separate option could be added if there is demand
	*/
	if (show & mon_show_stack) {
	print_cluster_options(stream, data_set);
	}

	if (header_printed) {
	print_cluster_summary_footer(stream);
	}
	}

	/*!
	* \internal
	* \brief Print a failed action
	*
	* \param[in] stream File stream to display output to
	* \param[in] xml_op Root of XML tree describing failed action
	*/
	static void
	print_failed_action(FILE stream, xmlNode xml_op)
	{
	const char *op_key = crm_element_value(xml_op, XML_LRM_ATTR_TASK_KEY);
	const char *op_key_attr = "op_key";
	const char *last = crm_element_value(xml_op, XML_RSC_OP_LAST_CHANGE);
	const char *node = crm_element_value(xml_op, XML_ATTR_UNAME);
	const char *call = crm_element_value(xml_op, XML_LRM_ATTR_CALLID);
	const char *exit_reason = crm_element_value(xml_op, XML_LRM_ATTR_EXIT_REASON);
	int rc = crm_parse_int(crm_element_value(xml_op, XML_LRM_ATTR_RC), "0");
	int status = crm_parse_int(crm_element_value(xml_op, XML_LRM_ATTR_OPSTATUS), "0");
	char *exit_reason_cleaned;

	/* If no op_key was given, use id instead */
	if (op_key == NULL) {
	op_key = ID(xml_op);
	op_key_attr = "id";
	}

	/* If no exit reason was given, use "none" */
	if (exit_reason == NULL) {
	exit_reason = "none";
	}

	/* Print common action information */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("* %s on %s '%s' (%d): call=%s, status=%s, exitreason='%s'",
	op_key, node, services_ocf_exitcode_str(rc), rc,
	call, services_lrm_status_str(status), exit_reason);
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <li>%s on %s '%s' (%d): call=%s, status=%s, exitreason='%s'",
	op_key, node, services_ocf_exitcode_str(rc), rc,
	call, services_lrm_status_str(status), exit_reason);
	break;

	case mon_output_xml:
	exit_reason_cleaned = crm_xml_escape(exit_reason);
	fprintf(stream, " <failure %s=\"%s\" node=\"%s\"",
	op_key_attr, op_key, node);
	fprintf(stream, " exitstatus=\"%s\" exitreason=\"%s\" exitcode=\"%d\"",
	services_ocf_exitcode_str(rc), exit_reason_cleaned, rc);
	fprintf(stream, " call=\"%s\" status=\"%s\"",
	call, services_lrm_status_str(status));
	free(exit_reason_cleaned);
	break;

	default:
	break;
	}

	/* If last change was given, print timing information as well */
	if (last) {
	time_t run_at = crm_parse_int(last, "0");
	char *run_at_s = ctime(&run_at);

	if (run_at_s) {
	run_at_s[24] = 0; /* Overwrite the newline */
	}

	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as(",\n last-rc-change='%s', queued=%sms, exec=%sms",
	run_at_s? run_at_s : "",
	crm_element_value(xml_op, XML_RSC_OP_T_QUEUE),
	crm_element_value(xml_op, XML_RSC_OP_T_EXEC));
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " last-rc-change='%s', queued=%sms, exec=%sms",
	run_at_s? run_at_s : "",
	crm_element_value(xml_op, XML_RSC_OP_T_QUEUE),
	crm_element_value(xml_op, XML_RSC_OP_T_EXEC));
	break;

	case mon_output_xml:
	fprintf(stream,
	" last-rc-change=\"%s\" queued=\"%s\" exec=\"%s\" interval=\"%u\" task=\"%s\"",
	run_at_s? run_at_s : "",
	crm_element_value(xml_op, XML_RSC_OP_T_QUEUE),
	crm_element_value(xml_op, XML_RSC_OP_T_EXEC),
	crm_parse_ms(crm_element_value(xml_op, XML_LRM_ATTR_INTERVAL_MS)),
	crm_element_value(xml_op, XML_LRM_ATTR_TASK));
	break;

	default:
	break;
	}
	}

	/* End the action listing */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, "</li>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " />\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print a section for failed actions
	*
	* \param[in] stream File stream to display output to
	* \param[in] data_set Working set of CIB state
	*/
	static void
	print_failed_actions(FILE stream, pe_working_set_t data_set)
	{
	xmlNode *xml_op = NULL;

	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\nFailed Resource Actions:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream,
	" <hr />\n <h2>Failed Resource Actions</h2>\n <ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <failures>\n");
	break;

	default:
	break;
	}

	/* Print each failed action */
	for (xml_op = __xml_first_child(data_set->failed); xml_op != NULL;
	xml_op = __xml_next(xml_op)) {
	print_failed_action(stream, xml_op);
	}

	/* End section */
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </failures>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Reduce the stonith-history
	* for successful actions we keep the last of every action-type & target
	* for failed actions we record as well who had failed
	* for actions in progress we keep full track
	*
	* \param[in] history List of stonith actions
	*
	*/
	static stonith_history_t *
	reduce_stonith_history(stonith_history_t *history)
	{
	stonith_history_t new = NULL, hp, np, tmp;

	for (hp = history; hp; ) {
	for (np = new; np; np = np->next) {
	if ((hp->state == st_done) \|\| (hp->state == st_failed)) {
	/* action not in progress */
	if (safe_str_eq(hp->target, np->target) &&
	safe_str_eq(hp->action, np->action) &&
	(hp->state == np->state)) {
	if ((hp->state == st_done) \|\|
	safe_str_eq(hp->delegate, np->delegate)) {
	/* replace or purge */
	if (hp->completed < np->completed) {
	/* purge older hp */
	tmp = hp->next;
	hp->next = NULL;
	stonith_history_free(hp);
	hp = tmp;
	break;
	}
	/* damn single linked list */
	free(hp->target);
	free(hp->action);
	free(np->origin);
	np->origin = hp->origin;
	free(np->delegate);
	np->delegate = hp->delegate;
	free(np->client);
	np->client = hp->client;
	np->completed = hp->completed;
	tmp = hp;
	hp = hp->next;
	free(tmp);
	break;
	}
	}
	if (np->next) {
	continue;
	}
	}
	np = 0; /* let outer loop progress hp */
	break;
	}
	/* simply move hp from history to new */
	if (np == NULL) {
	tmp = hp->next;
	hp->next = new;
	new = hp;
	hp = tmp;
	}
	}
	return new;
	}

	/*!
	* \internal
	* \brief Sort the stonith-history
	* sort by competed most current on the top
	* pending actions lacking a completed-stamp are gathered at the top
	*
	* \param[in] history List of stonith actions
	*
	*/
	static stonith_history_t *
	sort_stonith_history(stonith_history_t *history)
	{
	stonith_history_t new = NULL, pending = NULL, hp, np, *tmp;

	for (hp = history; hp; ) {
	tmp = hp->next;
	if ((hp->state == st_done) \|\| (hp->state == st_failed)) {
	/* sort into new */
	if ((!new) \|\| (hp->completed > new->completed)) {
	hp->next = new;
	new = hp;
	} else {
	np = new;
	do {
	if ((!np->next) \|\| (hp->completed > np->next->completed)) {
	hp->next = np->next;
	np->next = hp;
	break;
	}
	np = np->next;
	} while (1);
	}
	} else {
	/* put into pending */
	hp->next = pending;
	pending = hp;
	}
	hp = tmp;
	}

	/* pending actions don't have a completed-stamp so make them go front */
	if (pending) {
	stonith_history_t *last_pending = pending;

	while (last_pending->next) {
	last_pending = last_pending->next;
	}

	last_pending->next = new;
	new = pending;
	}
	return new;
	}

	/*!
	* \internal
	* \brief Print a stonith action
	*
	* \param[in] stream File stream to display output to
	* \param[in] event stonith event
	*/
	static void
	print_stonith_action(FILE stream, stonith_history_t event)
	{
	const char *action_s = stonith_action_str(event->action);
	char *run_at_s = ctime(&event->completed);

	if ((run_at_s) && (run_at_s[0] != 0)) {
	run_at_s[strlen(run_at_s)-1] = 0; /* Overwrite the newline */
	}

	switch(output_format) {
	case mon_output_xml:
	fprintf(stream, " <fence_event target=\"%s\" action=\"%s\"",
	event->target, event->action);
	switch(event->state) {
	case st_done:
	fprintf(stream, " state=\"success\"");
	break;
	case st_failed:
	fprintf(stream, " state=\"failed\"");
	break;
	default:
	fprintf(stream, " state=\"pending\"");
	}
	fprintf(stream, " origin=\"%s\" client=\"%s\"",
	event->origin, event->client);
	if (event->delegate) {
	fprintf(stream, " delegate=\"%s\"", event->delegate);
	}
	switch(event->state) {
	case st_done:
	case st_failed:
	fprintf(stream, " completed=\"%s\"", run_at_s?run_at_s:"");
	break;
	default:
	break;
	}
	fprintf(stream, " />\n");
	break;

	case mon_output_plain:
	case mon_output_console:
	switch(event->state) {
	case st_done:
	print_as("* %s of %s successful: delegate=%s, client=%s, origin=%s,\n"
	" %s='%s'\n",
	action_s, event->target,
	event->delegate ? event->delegate : "",
	event->client, event->origin,
	fence_full_history?"completed":"last-successful",
	run_at_s?run_at_s:"");
	break;
	case st_failed:
	print_as("* %s of %s failed: delegate=%s, client=%s, origin=%s,\n"
	" %s='%s'\n",
	action_s, event->target,
	event->delegate ? event->delegate : "",
	event->client, event->origin,
	fence_full_history?"completed":"last-failed",
	run_at_s?run_at_s:"");
	break;
	default:
	print_as("* %s of %s pending: client=%s, origin=%s\n",
	action_s, event->target,
	event->client, event->origin);
	}
	break;

	case mon_output_html:
	case mon_output_cgi:
	switch(event->state) {
	case st_done:
	fprintf(stream, " <li>%s of %s successful: delegate=%s, "
	"client=%s, origin=%s, %s='%s'</li>\n",
	action_s, event->target,
	event->delegate ? event->delegate : "",
	event->client, event->origin,
	fence_full_history?"completed":"last-successful",
	run_at_s?run_at_s:"");
	break;
	case st_failed:
	fprintf(stream, " <li>%s of %s failed: delegate=%s, "
	"client=%s, origin=%s, %s='%s'</li>\n",
	action_s, event->target,
	event->delegate ? event->delegate : "",
	event->client, event->origin,
	fence_full_history?"completed":"last-failed",
	run_at_s?run_at_s:"");
	break;
	default:
	fprintf(stream, " <li>%s of %s pending: client=%s, "
	"origin=%s</li>\n",
	action_s, event->target,
	event->client, event->origin);
	}
	break;

	default:
	/* no support for fence history for other formats so far */
	break;
	}
	}

	/*!
	* \internal
	* \brief Print a section for failed stonith actions
	*
	* \param[in] stream File stream to display output to
	* \param[in] history List of stonith actions
	*
	*/
	static void
	print_failed_stonith_actions(FILE stream, stonith_history_t history)
	{
	stonith_history_t *hp;

	for (hp = history; hp; hp = hp->next) {
	if (hp->state == st_failed) {
	break;
	}
	}
	if (!hp) {
	return;
	}

	/* Print section heading */
	switch (output_format) {
	/* no need to take care of xml in here as xml gets full
	* history anyway
	*/
	case mon_output_plain:
	case mon_output_console:
	print_as("\nFailed Fencing Actions:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>Failed Fencing Actions</h2>\n <ul>\n");
	break;

	default:
	break;
	}

	/* Print each failed stonith action */
	for (hp = history; hp; hp = hp->next) {
	if (hp->state == st_failed) {
	print_stonith_action(stream, hp);
	}
	}

	/* End section */
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print pending stonith actions
	*
	* \param[in] stream File stream to display output to
	* \param[in] history List of stonith actions
	*
	*/
	static void
	print_stonith_pending(FILE stream, stonith_history_t history)
	{
	/* xml-output always shows the full history
	* so we'll never have to show pending-actions
	* separately
	*/
	if (history && (history->state != st_failed) &&
	(history->state != st_done)) {
	stonith_history_t *hp;

	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\nPending Fencing Actions:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>Pending Fencing Actions</h2>\n <ul>\n");
	break;

	default:
	break;
	}

	for (hp = history; hp; hp = hp->next) {
	if ((hp->state == st_failed) \|\| (hp->state == st_done)) {
	break;
	}
	print_stonith_action(stream, hp);
	}

	/* End section */
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n");
	break;

	default:
	break;
	}
	}
	}

	/*!
	* \internal
	* \brief Print a section for stonith-history
	*
	* \param[in] stream File stream to display output to
	* \param[in] history List of stonith actions
	*
	*/
	static void
	print_stonith_history(FILE stream, stonith_history_t history)
	{
	stonith_history_t *hp;

	/* Print section heading */
	switch (output_format) {
	case mon_output_plain:
	case mon_output_console:
	print_as("\nFencing History:\n");
	break;

	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " <hr />\n <h2>Fencing History</h2>\n <ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " <fence_history>\n");
	break;

	default:
	break;
	}

	for (hp = history; hp; hp = hp->next) {
	if ((hp->state != st_failed) \|\| (output_format == mon_output_xml)) {
	print_stonith_action(stream, hp);
	}
	}

	/* End section */
	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	fprintf(stream, " </ul>\n");
	break;

	case mon_output_xml:
	fprintf(stream, " </fence_history>\n");
	break;

	default:
	break;
	}
	}

	/*!
	* \internal
	* \brief Print cluster status to screen
	*
	* This uses the global display preferences set by command-line options
	* to display cluster status in a human-friendly way.
	*
	* \param[in] data_set Working set of CIB state
	* \param[in] stonith_history List of stonith actions
	*/
	static void
	print_status(pe_working_set_t * data_set,
	stonith_history_t *stonith_history)
	{
	GListPtr gIter = NULL;
	int print_opts = get_resource_display_options();

	/* space-separated lists of node names */
	char *online_nodes = NULL;
	char *online_remote_nodes = NULL;
	char *online_guest_nodes = NULL;
	char *offline_nodes = NULL;
	char *offline_remote_nodes = NULL;

	if (output_format == mon_output_console) {
	blank_screen();
	}
	print_cluster_summary(stdout, data_set);
	print_as("\n");

	/* Gather node information (and print if in bad state or grouping by node) */
	for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) {
	node_t node = (node_t ) gIter->data;
	const char *node_mode = NULL;
	char *node_name = get_node_display_name(node);

	/* Get node mode */
	if (node->details->unclean) {
	if (node->details->online) {
	node_mode = "UNCLEAN (online)";

	} else if (node->details->pending) {
	node_mode = "UNCLEAN (pending)";

	} else {
	node_mode = "UNCLEAN (offline)";
	}

	} else if (node->details->pending) {
	node_mode = "pending";

	} else if (node->details->standby_onfail && node->details->online) {
	node_mode = "standby (on-fail)";

	} else if (node->details->standby) {
	if (node->details->online) {
	if (node->details->running_rsc) {
	node_mode = "standby (with active resources)";
	} else {
	node_mode = "standby";
	}
	} else {
	node_mode = "OFFLINE (standby)";
	}

	} else if (node->details->maintenance) {
	if (node->details->online) {
	node_mode = "maintenance";
	} else {
	node_mode = "OFFLINE (maintenance)";
	}

	} else if (node->details->online) {
	node_mode = "online";
	if (group_by_node == FALSE) {
	if (pe__is_guest_node(node)) {
	online_guest_nodes = add_list_element(online_guest_nodes, node_name);
	} else if (pe__is_remote_node(node)) {
	online_remote_nodes = add_list_element(online_remote_nodes, node_name);
	} else {
	online_nodes = add_list_element(online_nodes, node_name);
	}
	free(node_name);
	continue;
	}
	} else {
	node_mode = "OFFLINE";
	if (group_by_node == FALSE) {
	if (pe__is_remote_node(node)) {
	offline_remote_nodes = add_list_element(offline_remote_nodes, node_name);
	} else if (pe__is_guest_node(node)) {
	/* ignore offline guest nodes */
	} else {
	offline_nodes = add_list_element(offline_nodes, node_name);
	}
	free(node_name);
	continue;
	}
	}

	/* If we get here, node is in bad state, or we're grouping by node */

	/* Print the node name and status */
	if (pe__is_guest_node(node)) {
	print_as("Guest");
	} else if (pe__is_remote_node(node)) {
	print_as("Remote");
	}
	print_as("Node %s: %s\n", node_name, node_mode);

	/* If we're grouping by node, print its resources */
	if (group_by_node) {
	if (print_brief) {
	print_rscs_brief(node->details->running_rsc, "\t", print_opts \| pe_print_rsconly,
	stdout, FALSE);
	} else {
	GListPtr gIter2 = NULL;

	for (gIter2 = node->details->running_rsc; gIter2 != NULL; gIter2 = gIter2->next) {
	resource_t rsc = (resource_t ) gIter2->data;

	rsc->fns->print(rsc, "\t", print_opts \| pe_print_rsconly, stdout);
	}
	}
	}
	free(node_name);
	}

	/* If we're not grouping by node, summarize nodes by status */
	if (online_nodes) {
	print_as("Online: [%s ]\n", online_nodes);
	free(online_nodes);
	}
	if (offline_nodes) {
	print_as("OFFLINE: [%s ]\n", offline_nodes);
	free(offline_nodes);
	}
	if (online_remote_nodes) {
	print_as("RemoteOnline: [%s ]\n", online_remote_nodes);
	free(online_remote_nodes);
	}
	if (offline_remote_nodes) {
	print_as("RemoteOFFLINE: [%s ]\n", offline_remote_nodes);
	free(offline_remote_nodes);
	}
	if (online_guest_nodes) {
	print_as("GuestOnline: [%s ]\n", online_guest_nodes);
	free(online_guest_nodes);
	}

	/* Print resources section, if needed */
	print_resources(stdout, data_set, print_opts);

	/* print Node Attributes section if requested */
	if (show & mon_show_attributes) {
	print_node_attributes(stdout, data_set);
	}

	/* If requested, print resource operations (which includes failcounts)
	* or just failcounts
	*/
	if (show & (mon_show_operations \| mon_show_failcounts)) {
	print_node_summary(stdout, data_set,
	((show & mon_show_operations)? TRUE : FALSE));
	}

	/* If there were any failed actions, print them */
	if (xml_has_children(data_set->failed)) {
	print_failed_actions(stdout, data_set);
	}

	/* Print failed stonith actions */
	if (fence_history) {
	print_failed_stonith_actions(stdout, stonith_history);
	}

	/* Print tickets if requested */
	if (show & mon_show_tickets) {
	print_cluster_tickets(stdout, data_set);
	}

	/* Print negative location constraints if requested */
	if (show & mon_show_bans) {
	print_neg_locations(stdout, data_set);
	}

	/* Print stonith history */
	if (fence_history) {
	if (show & mon_show_fence_history) {
	print_stonith_history(stdout, stonith_history);
	} else {
	print_stonith_pending(stdout, stonith_history);
	}
	}

	#if CURSES_ENABLED
	if (output_format == mon_output_console) {
	refresh();
	}
	#endif
	}

	/*!
	* \internal
	* \brief Print cluster status in XML format
	*
	* \param[in] data_set Working set of CIB state
	*/
	static void
	print_xml_status(pe_working_set_t * data_set,
	stonith_history_t *stonith_history)
	{
	FILE *stream = stdout;
	GListPtr gIter = NULL;
	int print_opts = get_resource_display_options();

	fprintf(stream, "<?xml version=\"1.0\"?>\n");
	fprintf(stream, "<crm_mon version=\"%s\">\n", VERSION);

	print_cluster_summary(stream, data_set);

	/* NODES */
	fprintf(stream, " <nodes>\n");
	for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) {
	node_t node = (node_t ) gIter->data;
	const char *node_type = "unknown";

	switch (node->details->type) {
	case node_member:
	node_type = "member";
	break;
	case node_remote:
	node_type = "remote";
	break;
	case node_ping:
	node_type = "ping";
	break;
	}

	fprintf(stream, " <node name=\"%s\" ", node->details->uname);
	fprintf(stream, "id=\"%s\" ", node->details->id);
	fprintf(stream, "online=\"%s\" ", node->details->online ? "true" : "false");
	fprintf(stream, "standby=\"%s\" ", node->details->standby ? "true" : "false");
	fprintf(stream, "standby_onfail=\"%s\" ", node->details->standby_onfail ? "true" : "false");
	fprintf(stream, "maintenance=\"%s\" ", node->details->maintenance ? "true" : "false");
	fprintf(stream, "pending=\"%s\" ", node->details->pending ? "true" : "false");
	fprintf(stream, "unclean=\"%s\" ", node->details->unclean ? "true" : "false");
	fprintf(stream, "shutdown=\"%s\" ", node->details->shutdown ? "true" : "false");
	fprintf(stream, "expected_up=\"%s\" ", node->details->expected_up ? "true" : "false");
	fprintf(stream, "is_dc=\"%s\" ", node->details->is_dc ? "true" : "false");
	fprintf(stream, "resources_running=\"%d\" ", g_list_length(node->details->running_rsc));
	fprintf(stream, "type=\"%s\" ", node_type);
	if (pe__is_guest_node(node)) {
	fprintf(stream, "id_as_resource=\"%s\" ", node->details->remote_rsc->container->id);
	}

	if (group_by_node) {
	GListPtr lpc2 = NULL;

	fprintf(stream, ">\n");
	for (lpc2 = node->details->running_rsc; lpc2 != NULL; lpc2 = lpc2->next) {
	resource_t rsc = (resource_t ) lpc2->data;

	rsc->fns->print(rsc, " ", print_opts \| pe_print_rsconly, stream);
	}
	fprintf(stream, " </node>\n");
	} else {
	fprintf(stream, "/>\n");
	}
	}
	fprintf(stream, " </nodes>\n");

	/* Print resources section, if needed */
	print_resources(stream, data_set, print_opts);

	/* print Node Attributes section if requested */
	if (show & mon_show_attributes) {
	print_node_attributes(stream, data_set);
	}

	/* If requested, print resource operations (which includes failcounts)
	* or just failcounts
	*/
	if (show & (mon_show_operations \| mon_show_failcounts)) {
	print_node_summary(stream, data_set,
	((show & mon_show_operations)? TRUE : FALSE));
	}

	/* If there were any failed actions, print them */
	if (xml_has_children(data_set->failed)) {
	print_failed_actions(stream, data_set);
	}

	/* Print stonith history */
	if (fence_history) {
	print_stonith_history(stdout, stonith_history);
	}

	/* Print tickets if requested */
	if (show & mon_show_tickets) {
	print_cluster_tickets(stream, data_set);
	}

	/* Print negative location constraints if requested */
	if (show & mon_show_bans) {
	print_neg_locations(stream, data_set);
	}

	fprintf(stream, "</crm_mon>\n");
	fflush(stream);
	fclose(stream);
	}

	/*!
	* \internal
	* \brief Print cluster status in HTML format (with HTTP headers if CGI)
	*
	* \param[in] data_set Working set of CIB state
	* \param[in] filename Name of file to write HTML to (ignored if CGI)
	*
	* \return 0 on success, -1 on error
	*/
	static int
	print_html_status(pe_working_set_t * data_set,
	const char *filename,
	stonith_history_t *stonith_history)
	{
	FILE *stream;
	GListPtr gIter = NULL;
	char *filename_tmp = NULL;
	int print_opts = get_resource_display_options();

	if (output_format == mon_output_cgi) {
	stream = stdout;
	fprintf(stream, "Content-Type: text/html\n\n");

	} else {
	filename_tmp = crm_concat(filename, "tmp", '.');
	stream = fopen(filename_tmp, "w");
	if (stream == NULL) {
	crm_perror(LOG_ERR, "Cannot open %s for writing", filename_tmp);
	free(filename_tmp);
	return -1;
	}
	}

	fprintf(stream, "<html>\n");
	fprintf(stream, " <head>\n");
	fprintf(stream, " <title>Cluster status</title>\n");
	fprintf(stream, " <meta http-equiv=\"refresh\" content=\"%d\">\n", reconnect_msec / 1000);
	fprintf(stream, " </head>\n");
	fprintf(stream, "<body>\n");

	print_cluster_summary(stream, data_set);

	/* NODE LIST */

	fprintf(stream, " <hr />\n <h2>Node List</h2>\n");
	fprintf(stream, "<ul>\n");
	for (gIter = data_set->nodes; gIter != NULL; gIter = gIter->next) {
	node_t node = (node_t ) gIter->data;
	char *node_name = get_node_display_name(node);

	fprintf(stream, "<li>Node: %s: ", node_name);
	if (node->details->standby_onfail && node->details->online) {
	fprintf(stream, "<font color=\"orange\">standby (on-fail)</font>\n");
	} else if (node->details->standby && node->details->online) {

	fprintf(stream, "<font color=\"orange\">standby%s</font>\n",
	node->details->running_rsc?" (with active resources)":"");
	} else if (node->details->standby) {
	fprintf(stream, "<font color=\"red\">OFFLINE (standby)</font>\n");
	} else if (node->details->maintenance && node->details->online) {
	fprintf(stream, "<font color=\"blue\">maintenance</font>\n");
	} else if (node->details->maintenance) {
	fprintf(stream, "<font color=\"red\">OFFLINE (maintenance)</font>\n");
	} else if (node->details->online) {
	fprintf(stream, "<font color=\"green\">online</font>\n");
	} else {
	fprintf(stream, "<font color=\"red\">OFFLINE</font>\n");
	}
	if (print_brief && group_by_node) {
	fprintf(stream, "<ul>\n");
	print_rscs_brief(node->details->running_rsc, NULL, print_opts \| pe_print_rsconly,
	stream, FALSE);
	fprintf(stream, "</ul>\n");

	} else if (group_by_node) {
	GListPtr lpc2 = NULL;

	fprintf(stream, "<ul>\n");
	for (lpc2 = node->details->running_rsc; lpc2 != NULL; lpc2 = lpc2->next) {
	resource_t rsc = (resource_t ) lpc2->data;

	fprintf(stream, "<li>");
	rsc->fns->print(rsc, NULL, print_opts \| pe_print_rsconly, stream);
	fprintf(stream, "</li>\n");
	}
	fprintf(stream, "</ul>\n");
	}
	fprintf(stream, "</li>\n");
	free(node_name);
	}
	fprintf(stream, "</ul>\n");

	/* Print resources section, if needed */
	print_resources(stream, data_set, print_opts);

	/* print Node Attributes section if requested */
	if (show & mon_show_attributes) {
	print_node_attributes(stream, data_set);
	}

	/* If requested, print resource operations (which includes failcounts)
	* or just failcounts
	*/
	if (show & (mon_show_operations \| mon_show_failcounts)) {
	print_node_summary(stream, data_set,
	((show & mon_show_operations)? TRUE : FALSE));
	}

	/* If there were any failed actions, print them */
	if (xml_has_children(data_set->failed)) {
	print_failed_actions(stream, data_set);
	}

	/* Print failed stonith actions */
	if (fence_history) {
	print_failed_stonith_actions(stream, stonith_history);
	}

	/* Print stonith history */
	if (fence_history) {
	if (show & mon_show_fence_history) {
	print_stonith_history(stream, stonith_history);
	} else {
	print_stonith_pending(stdout, stonith_history);
	}
	}

	/* Print tickets if requested */
	if (show & mon_show_tickets) {
	print_cluster_tickets(stream, data_set);
	}

	/* Print negative location constraints if requested */
	if (show & mon_show_bans) {
	print_neg_locations(stream, data_set);
	}

	fprintf(stream, "</body>\n");
	fprintf(stream, "</html>\n");
	fflush(stream);
	fclose(stream);

	if (output_format != mon_output_cgi) {
	if (rename(filename_tmp, filename) != 0) {
	crm_perror(LOG_ERR, "Unable to rename %s->%s", filename_tmp, filename);
	}
	free(filename_tmp);
	}
	return 0;
	}

	static int
	send_custom_trap(const char node, const char rsc, const char *task, int target_rc, int rc,
	int status, const char *desc)
	{
	pid_t pid;

	/setenv needs chars, these are ints /
	char *rc_s = crm_itoa(rc);
	char *status_s = crm_itoa(status);
	char *target_rc_s = crm_itoa(target_rc);

	crm_debug("Sending external notification to '%s' via '%s'", external_recipient, external_agent);

	if(rsc) {
	setenv("CRM_notify_rsc", rsc, 1);
	}
	if (external_recipient) {
	setenv("CRM_notify_recipient", external_recipient, 1);
	}
	setenv("CRM_notify_node", node, 1);
	setenv("CRM_notify_task", task, 1);
	setenv("CRM_notify_desc", desc, 1);
	setenv("CRM_notify_rc", rc_s, 1);
	setenv("CRM_notify_target_rc", target_rc_s, 1);
	setenv("CRM_notify_status", status_s, 1);

	pid = fork();
	if (pid == -1) {
	crm_perror(LOG_ERR, "notification fork() failed.");
	}
	if (pid == 0) {
	/* crm_debug("notification: I am the child. Executing the nofitication program."); */
	execl(external_agent, external_agent, NULL);
	exit(CRM_EX_ERROR);
	}

	crm_trace("Finished running custom notification program '%s'.", external_agent);
	free(target_rc_s);
	free(status_s);
	free(rc_s);
	return 0;
	}

	static void
	handle_rsc_op(xmlNode * xml, const char *node_id)
	{
	int rc = -1;
	int status = -1;
	int target_rc = -1;
	gboolean notify = TRUE;

	char *rsc = NULL;
	char *task = NULL;
	const char *desc = NULL;
	const char *magic = NULL;
	const char *id = NULL;
	const char *node = NULL;

	xmlNode *n = xml;
	xmlNode * rsc_op = xml;

	if(strcmp((const char*)xml->name, XML_LRM_TAG_RSC_OP) != 0) {
	xmlNode *cIter;

	for(cIter = xml->children; cIter; cIter = cIter->next) {
	handle_rsc_op(cIter, node_id);
	}

	return;
	}

	id = crm_element_value(rsc_op, XML_LRM_ATTR_TASK_KEY);
	if (id == NULL) {
	/* Compatibility with <= 1.1.5 */
	id = ID(rsc_op);
	}

	magic = crm_element_value(rsc_op, XML_ATTR_TRANSITION_MAGIC);
	if (magic == NULL) {
	/* non-change */
	return;
	}

	if (!decode_transition_magic(magic, NULL, NULL, NULL, &status, &rc,
	&target_rc)) {
	crm_err("Invalid event %s detected for %s", magic, id);
	return;
	}

	if (parse_op_key(id, &rsc, &task, NULL) == FALSE) {
	crm_err("Invalid event detected for %s", id);
	goto bail;
	}

	node = crm_element_value(rsc_op, XML_LRM_ATTR_TARGET);

	while (n != NULL && safe_str_neq(XML_CIB_TAG_STATE, TYPE(n))) {
	n = n->parent;
	}

	if(node == NULL && n) {
	node = crm_element_value(n, XML_ATTR_UNAME);
	}

	if (node == NULL && n) {
	node = ID(n);
	}

	if (node == NULL) {
	node = node_id;
	}

	if (node == NULL) {
	crm_err("No node detected for event %s (%s)", magic, id);
	goto bail;
	}

	/* look up where we expected it to be? */
	desc = pcmk_strerror(pcmk_ok);
	if (status == PCMK_LRM_OP_DONE && target_rc == rc) {
	crm_notice("%s of %s on %s completed: %s", task, rsc, node, desc);
	if (rc == PCMK_OCF_NOT_RUNNING) {
	notify = FALSE;
	}

	} else if (status == PCMK_LRM_OP_DONE) {
	desc = services_ocf_exitcode_str(rc);
	crm_warn("%s of %s on %s failed: %s", task, rsc, node, desc);

	} else {
	desc = services_lrm_status_str(status);
	crm_warn("%s of %s on %s failed: %s", task, rsc, node, desc);
	}

	if (notify && external_agent) {
	send_custom_trap(node, rsc, task, target_rc, rc, status, desc);
	}
	bail:
	free(rsc);
	free(task);
	}

	static gboolean
	mon_trigger_refresh(gpointer user_data)
	{
	mainloop_set_trigger(refresh_trigger);
	return FALSE;
	}

	#define NODE_PATT "/lrm[@id="
	static char *
	get_node_from_xpath(const char *xpath)
	{
	char *nodeid = NULL;
	char *tmp = strstr(xpath, NODE_PATT);

	if(tmp) {
	tmp += strlen(NODE_PATT);
	tmp += 1;

	nodeid = strdup(tmp);
	tmp = strstr(nodeid, "\'");
	CRM_ASSERT(tmp);
	tmp[0] = 0;
	}
	return nodeid;
	}

	static void
	crm_diff_update_v2(const char event, xmlNode msg)
	{
	xmlNode *change = NULL;
	xmlNode *diff = get_message_xml(msg, F_CIB_UPDATE_RESULT);

	for (change = __xml_first_child(diff); change != NULL; change = __xml_next(change)) {
	const char *name = NULL;
	const char *op = crm_element_value(change, XML_DIFF_OP);
	const char *xpath = crm_element_value(change, XML_DIFF_PATH);
	xmlNode *match = NULL;
	const char *node = NULL;

	if(op == NULL) {
	continue;

	} else if(strcmp(op, "create") == 0) {
	match = change->children;

	} else if(strcmp(op, "move") == 0) {
	continue;

	} else if(strcmp(op, "delete") == 0) {
	continue;

	} else if(strcmp(op, "modify") == 0) {
	match = first_named_child(change, XML_DIFF_RESULT);
	if(match) {
	match = match->children;
	}
	}

	if(match) {
	name = (const char *)match->name;
	}

	crm_trace("Handling %s operation for %s %p, %s", op, xpath, match, name);
	if(xpath == NULL) {
	/* Version field, ignore */

	} else if(name == NULL) {
	crm_debug("No result for %s operation to %s", op, xpath);
	CRM_ASSERT(strcmp(op, "delete") == 0 \|\| strcmp(op, "move") == 0);

	} else if(strcmp(name, XML_TAG_CIB) == 0) {
	xmlNode *state = NULL;
	xmlNode *status = first_named_child(match, XML_CIB_TAG_STATUS);

	for (state = __xml_first_child(status); state != NULL; state = __xml_next(state)) {
	node = crm_element_value(state, XML_ATTR_UNAME);
	if (node == NULL) {
	node = ID(state);
	}
	handle_rsc_op(state, node);
	}

	} else if(strcmp(name, XML_CIB_TAG_STATUS) == 0) {
	xmlNode *state = NULL;

	for (state = __xml_first_child(match); state != NULL; state = __xml_next(state)) {
	node = crm_element_value(state, XML_ATTR_UNAME);
	if (node == NULL) {
	node = ID(state);
	}
	handle_rsc_op(state, node);
	}

	} else if(strcmp(name, XML_CIB_TAG_STATE) == 0) {
	node = crm_element_value(match, XML_ATTR_UNAME);
	if (node == NULL) {
	node = ID(match);
	}
	handle_rsc_op(match, node);

	} else if(strcmp(name, XML_CIB_TAG_LRM) == 0) {
	node = ID(match);
	handle_rsc_op(match, node);

	} else if(strcmp(name, XML_LRM_TAG_RESOURCES) == 0) {
	char *local_node = get_node_from_xpath(xpath);

	handle_rsc_op(match, local_node);
	free(local_node);

	} else if(strcmp(name, XML_LRM_TAG_RESOURCE) == 0) {
	char *local_node = get_node_from_xpath(xpath);

	handle_rsc_op(match, local_node);
	free(local_node);

	} else if(strcmp(name, XML_LRM_TAG_RSC_OP) == 0) {
	char *local_node = get_node_from_xpath(xpath);

	handle_rsc_op(match, local_node);
	free(local_node);

	} else {
	crm_trace("Ignoring %s operation for %s %p, %s", op, xpath, match, name);
	}
	}
	}

	static void
	crm_diff_update_v1(const char event, xmlNode msg)
	{
	/* Process operation updates */
	xmlXPathObject *xpathObj = xpath_search(msg,
	"//" F_CIB_UPDATE_RESULT "//" XML_TAG_DIFF_ADDED
	"//" XML_LRM_TAG_RSC_OP);
	int lpc = 0, max = numXpathResults(xpathObj);

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

	handle_rsc_op(rsc_op, NULL);
	}
	freeXpathObject(xpathObj);
	}

	static void
	crm_diff_update(const char event, xmlNode msg)
	{
	int rc = -1;
	static bool stale = FALSE;
	gboolean cib_updated = FALSE;
	xmlNode *diff = get_message_xml(msg, F_CIB_UPDATE_RESULT);

	print_dot();

	if (current_cib != NULL) {
	rc = xml_apply_patchset(current_cib, diff, TRUE);

	switch (rc) {
	case -pcmk_err_diff_resync:
	case -pcmk_err_diff_failed:
	crm_notice("[%s] Patch aborted: %s (%d)", event, pcmk_strerror(rc), rc);
	free_xml(current_cib); current_cib = NULL;
	break;
	case pcmk_ok:
	cib_updated = TRUE;
	break;
	default:
	crm_notice("[%s] ABORTED: %s (%d)", event, pcmk_strerror(rc), rc);
	free_xml(current_cib); current_cib = NULL;
	}
	}

	if (current_cib == NULL) {
	crm_trace("Re-requesting the full cib");
	cib->cmds->query(cib, NULL, &current_cib, cib_scope_local \| cib_sync_call);
	}

	if (external_agent) {
	int format = 0;
	crm_element_value_int(diff, "format", &format);
	switch(format) {
	case 1:
	crm_diff_update_v1(event, msg);
	break;
	case 2:
	crm_diff_update_v2(event, msg);
	break;
	default:
	crm_err("Unknown patch format: %d", format);
	}
	}

	if (current_cib == NULL) {
	if(!stale) {
	print_as("--- Stale data ---");
	}
	stale = TRUE;
	return;
	}

	stale = FALSE;
	kick_refresh(cib_updated);
	}

	static gboolean
	mon_refresh_display(gpointer user_data)
	{
	xmlNode *cib_copy = copy_xml(current_cib);
	stonith_history_t *stonith_history = NULL;

	last_refresh = time(NULL);

	if (cli_config_update(&cib_copy, NULL, FALSE) == FALSE) {
	if (cib) {
	cib->cmds->signoff(cib);
	}
	print_as("Upgrade failed: %s", pcmk_strerror(-pcmk_err_schema_validation));
	if (output_format == mon_output_console) {
	sleep(2);
	}
	clean_up(CRM_EX_CONFIG);
	return FALSE;
	}

	/* get the stonith-history if there is evidence we need it
	*/
	while (fence_history) {
	if (st != NULL) {
	if (st->cmds->history(st, st_opt_sync_call, NULL, &stonith_history, 120)) {
	fprintf(stderr, "Critical: Unable to get stonith-history\n");
	mon_cib_connection_destroy(NULL);
	} else {
	if ((!fence_full_history) && (output_format != mon_output_xml)) {
	stonith_history = reduce_stonith_history(stonith_history);
	}
	stonith_history = sort_stonith_history(stonith_history);
	break; /* all other cases are errors */
	}
	} else {
	fprintf(stderr, "Critical: No stonith-API\n");
	}
	free_xml(cib_copy);
	print_as("Reading stonith-history failed");
	if (output_format == mon_output_console) {
	sleep(2);
	}
	return FALSE;
	}

	if (mon_data_set == NULL) {
	mon_data_set = pe_new_working_set();
	CRM_ASSERT(mon_data_set != NULL);
	}

	mon_data_set->input = cib_copy;
	cluster_status(mon_data_set);

	/* Unpack constraints if any section will need them
	* (tickets may be referenced in constraints but not granted yet,
	* and bans need negative location constraints) */
	if (show & (mon_show_bans \| mon_show_tickets)) {
	xmlNode *cib_constraints = get_object_root(XML_CIB_TAG_CONSTRAINTS,
	mon_data_set->input);
	unpack_constraints(cib_constraints, mon_data_set);
	}

	switch (output_format) {
	case mon_output_html:
	case mon_output_cgi:
	if (print_html_status(mon_data_set, output_filename, stonith_history) != 0) {
	fprintf(stderr, "Critical: Unable to output html file\n");
	clean_up(CRM_EX_CANTCREAT);
	return FALSE;
	}
	break;

	case mon_output_xml:
	print_xml_status(mon_data_set, stonith_history);
	break;

	case mon_output_monitor:
	print_simple_status(mon_data_set, stonith_history);
	if (has_warnings) {
	clean_up(MON_STATUS_WARN);
	return FALSE;
	}
	break;

	case mon_output_plain:
	case mon_output_console:
	print_status(mon_data_set, stonith_history);
	break;

	case mon_output_none:
	break;
	}

	stonith_history_free(stonith_history);
	stonith_history = NULL;
	pe_reset_working_set(mon_data_set);
	return TRUE;
	}

	static void
	mon_st_callback_event(stonith_t * st, stonith_event_t * e)
	{
	if (st->state == stonith_disconnected) {
	/* disconnect cib as well and have everything reconnect */
	mon_cib_connection_destroy(NULL);
	} else if (external_agent) {
	char *desc = crm_strdup_printf("Operation %s requested by %s for peer %s: %s (ref=%s)",
	e->operation, e->origin, e->target, pcmk_strerror(e->result),
	e->id);
	send_custom_trap(e->target, NULL, e->operation, pcmk_ok, e->result, 0, desc);
	free(desc);
	}
	}

	static void
	kick_refresh(gboolean data_updated)
	{
	static int updates = 0;
	long now = time(NULL);

	if (data_updated) {
	updates++;
	}

	if(refresh_timer == NULL) {
	refresh_timer = mainloop_timer_add("refresh", 2000, FALSE, mon_trigger_refresh, NULL);
	}

	/* Refresh
	* - immediately if the last update was more than 5s ago
	* - every 10 cib-updates
	* - at most 2s after the last update
	*/
	if ((now - last_refresh) > (reconnect_msec / 1000)) {
	mainloop_set_trigger(refresh_trigger);
	mainloop_timer_stop(refresh_timer);
	updates = 0;

	} else if(updates >= 10) {
	mainloop_set_trigger(refresh_trigger);
	mainloop_timer_stop(refresh_timer);
	updates = 0;

	} else {
	mainloop_timer_start(refresh_timer);
	}
	}

	static void
	mon_st_callback_display(stonith_t * st, stonith_event_t * e)
	{
	if (st->state == stonith_disconnected) {
	/* disconnect cib as well and have everything reconnect */
	mon_cib_connection_destroy(NULL);
	} else {
	print_dot();
	kick_refresh(TRUE);
	}
	}

	static void
	clean_up_connections(void)
	{
	if (cib != NULL) {
	cib->cmds->signoff(cib);
	cib_delete(cib);
	cib = NULL;
	}

	if (st != NULL) {
	if (st->state != stonith_disconnected) {
	st->cmds->remove_notification(st, T_STONITH_NOTIFY_DISCONNECT);
	st->cmds->remove_notification(st, T_STONITH_NOTIFY_FENCE);
	st->cmds->remove_notification(st, T_STONITH_NOTIFY_HISTORY);
	st->cmds->disconnect(st);
	}
	stonith_api_delete(st);
	st = NULL;
	}
	}

	/*
	* De-init ncurses, disconnect from the CIB manager, disconnect fencing,
	* deallocate memory and show usage-message if requested.
	*
	* We don't actually return, but nominally returning crm_exit_t allows a usage
	* like "return clean_up(exit_code);" which helps static analysis understand the
	* code flow.
	*/
	static crm_exit_t
	clean_up(crm_exit_t exit_code)
	{
	#if CURSES_ENABLED
	if (curses_console_initialized) {
	output_format = mon_output_plain;
	echo();
	nocbreak();
	endwin();
	curses_console_initialized = FALSE;
	}
	#endif

	clean_up_connections();
	free(output_filename);
	free(pid_file);

	pe_free_working_set(mon_data_set);
	mon_data_set = NULL;

	if (exit_code == CRM_EX_USAGE) {
	if (output_format == mon_output_cgi) {
	fprintf(stdout, "Content-Type: text/plain\n"
	"Status: 500\n\n");
	} else {
	crm_help('?', CRM_EX_USAGE);
	}
	}
	crm_exit(exit_code);
	}

File Metadata

Mime Type: text/x-diff
Expires: Sat, Nov 23, 4:50 PM (14 h, 24 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 1018995
Default Alt Text: (336 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions