No OneTemporary
Actions

Size

64 KB

Referenced Files

None

Subscribers

None

View Options

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

	#ifndef PCMK__XML_INTERNAL__H
	# define PCMK__XML_INTERNAL__H

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

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

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

	# include <libxml/relaxng.h>

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

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

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

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

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

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

	// @COMPAT Can we start including text nodes unconditionally?
	//! Include XML text nodes
	pcmk__xml_fmt_text = (1 << 6),

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

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

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

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

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

	/* search string to find CIB resources entries for cluster nodes */
	#define PCMK__XP_MEMBER_NODE_CONFIG \
	"//" PCMK_XE_CIB "/" PCMK_XE_CONFIGURATION "/" PCMK_XE_NODES \
	"/" PCMK_XE_NODE "[not(@type) or @type='member']"

	/* search string to find CIB resources entries for guest nodes */
	#define PCMK__XP_GUEST_NODE_CONFIG \
	"//" PCMK_XE_CIB "//" PCMK_XE_CONFIGURATION "//" PCMK_XE_PRIMITIVE \
	"//" PCMK_XE_META_ATTRIBUTES "//" PCMK_XE_NVPAIR \
	"[@name='" PCMK_META_REMOTE_NODE "']"

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

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

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

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

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


	void pcmk__xe_remove_attr(xmlNode element, const char name);
	bool pcmk__xe_remove_attr_cb(xmlNode xml, void user_data);
	void pcmk__xe_remove_matching_attrs(xmlNode *element,
	bool (match)(xmlAttrPtr, void ),
	void *user_data);
	int pcmk__xe_delete_match(xmlNode xml, xmlNode search);
	int pcmk__xe_replace_match(xmlNode xml, xmlNode replace);
	int pcmk__xe_update_match(xmlNode xml, xmlNode update);

	GString pcmk__element_xpath(const xmlNode xml);

	/*!
	* \internal
	* \enum pcmk__xml_escape_type
	* \brief Indicators of which XML characters to escape
	*
	* XML allows the escaping of special characters by replacing them with entity
	* references (for example, <tt>"""</tt>) or character references (for
	* example, <tt>" "</tt>).
	*
	* The special characters <tt>'&'</tt> (except as the beginning of an entity
	* reference) and <tt>'<'</tt> are not allowed in their literal forms in XML
	* character data. Character data is non-markup text (for example, the content
	* of a text node). <tt>'>'</tt> is allowed under most circumstances; we escape
	* it for safety and symmetry.
	*
	* For more details, see the "Character Data and Markup" section of the XML
	* spec, currently section 2.4:
	* https://www.w3.org/TR/xml/#dt-markup
	*
	* Attribute values are handled specially.
	* * If an attribute value is delimited by single quotes, then single quotes
	* must be escaped within the value.
	* * Similarly, if an attribute value is delimited by double quotes, then double
	* quotes must be escaped within the value.
	* * A conformant XML processor replaces a literal whitespace character (tab,
	* newline, carriage return, space) in an attribute value with a space
	* (\c '#x20') character. However, a reference to a whitespace character (for
	* example, \c " " for \c '\n') does not get replaced.
	* * For more details, see the "Attribute-Value Normalization" section of the
	* XML spec, currently section 3.3.3. Note that the default attribute type
	* is CDATA; we don't deal with NMTOKENS, etc.:
	* https://www.w3.org/TR/xml/#AVNormalize
	*
	* Pacemaker always delimits attribute values with double quotes, so there's no
	* need to escape single quotes.
	*
	* Newlines and tabs should be escaped in attribute values when XML is
	* serialized to text, so that future parsing preserves them rather than
	* normalizing them to spaces.
	*
	* We always escape carriage returns, so that they're not converted to spaces
	* during attribute-value normalization and because displaying them as literals
	* is messy.
	*/
	enum pcmk__xml_escape_type {
	/*!
	* For text nodes.
	* * Escape \c '<', \c '>', and \c '&' using entity references.
	* * Do not escape \c '\n' and \c '\t'.
	* * Escape other non-printing characters using character references.
	*/
	pcmk__xml_escape_text,

	/*!
	* For attribute values.
	* * Escape \c '<', \c '>', \c '&', and \c '"' using entity references.
	* * Escape \c '\n', \c '\t', and other non-printing characters using
	* character references.
	*/
	pcmk__xml_escape_attr,

	/* @COMPAT Drop escaping of at least '\n' and '\t' for
	* pcmk__xml_escape_attr_pretty when openstack-info, openstack-floating-ip,
	* and openstack-virtual-ip resource agents no longer depend on it.
	*
	* At time of writing, openstack-info may set a multiline value for the
	* openstack_ports node attribute. The other two agents query the value and
	* require it to be on one line with no spaces.
	*/
	/*!
	* For attribute values displayed in text output delimited by double quotes.
	* * Escape \c '\n' as \c "\\n"
	* * Escape \c '\r' as \c "\\r"
	* * Escape \c '\t' as \c "\\t"
	* * Escape \c '"' as \c "\\""
	*/
	pcmk__xml_escape_attr_pretty,
	};

	bool pcmk__xml_needs_escape(const char *text, enum pcmk__xml_escape_type type);
	char pcmk__xml_escape(const char text, enum pcmk__xml_escape_type type);

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

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

	/*!
	* \internal
	* \brief Retrieve the value of the \c PCMK_XA_ID XML attribute
	*
	* \param[in] xml XML element to check
	*
	* \return Value of the \c PCMK_XA_ID attribute (may be \c NULL)
	*/
	static inline const char *
	pcmk__xe_id(const xmlNode *xml)
	{
	return crm_element_value(xml, PCMK_XA_ID);
	}

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

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

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

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

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

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

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

	xmlNode pcmk__xe_create(xmlNode parent, const char *name);
	xmlNode pcmk__xml_copy(xmlNode parent, xmlNode *src);
	xmlNode pcmk__xe_next_same(const xmlNode node);

	void pcmk__xe_set_content(xmlNode node, const char format, ...)
	G_GNUC_PRINTF(2, 3);

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

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

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

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

	/*!
	* \internal
	* \brief Print an informational message if an xpath query returned multiple
	* items with the same ID.
	*
	* \param[in,out] out The output object
	* \param[in] search The xpath search result, most typically the result of
	* calling cib->cmds->query().
	* \param[in] name The name searched for
	*/
	void
	pcmk__warn_multiple_name_matches(pcmk__output_t out, xmlNode search,
	const char *name);

	/* internal XML-related utilities */

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

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

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

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

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

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

	+bool pcmk__xml_tree_foreach(xmlNode xml, bool (fn)(xmlNode , void ),
	+ void *user_data);
	+
	static inline const char *
	pcmk__xml_attr_value(const xmlAttr *attr)
	{
	return ((attr == NULL) \|\| (attr->children == NULL))? NULL
	: (const char *) attr->children->content;
	}


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

	void pcmk__log_known_schemas(void);
	const char *pcmk__remote_schema_dir(void);
	void pcmk__sort_schemas(void);

	// @COMPAT Remove when v1 patchsets are removed
	xmlNode pcmk__diff_v1_xml_object(xmlNode left, xmlNode *right, bool suppress);

	// @COMPAT Drop when PCMK__XE_PROMOTABLE_LEGACY is removed
	static inline const char *
	pcmk__map_element_name(const xmlNode *xml)
	{
	if (xml == NULL) {
	return NULL;
	} else if (pcmk__xe_is(xml, PCMK__XE_PROMOTABLE_LEGACY)) {
	return PCMK_XE_CLONE;
	} else {
	return (const char *) xml->name;
	}
	}

	#endif // PCMK__XML_INTERNAL__H
	diff --git a/lib/cib/cib_ops.c b/lib/cib/cib_ops.c
	index 7a32e3d3d8..cbe82f8101 100644
	--- a/lib/cib/cib_ops.c
	+++ b/lib/cib/cib_ops.c
	@@ -1,967 +1,903 @@
	/*
	* Copyright 2004-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

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

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

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

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

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

	// @TODO: Free this via crm_exit() when libcib gets merged with libcrmcommon
	static GHashTable *operation_table = NULL;

	static const cib__operation_t cib_ops[] = {
	{
	PCMK__CIB_REQUEST_ABS_DELETE, cib__op_abs_delete,
	cib__op_attr_modifies\|cib__op_attr_privileged
	},
	{
	PCMK__CIB_REQUEST_APPLY_PATCH, cib__op_apply_patch,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_BUMP, cib__op_bump,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_COMMIT_TRANSACT, cib__op_commit_transact,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_replaces
	\|cib__op_attr_writes_through
	},
	{
	PCMK__CIB_REQUEST_CREATE, cib__op_create,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_DELETE, cib__op_delete,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_ERASE, cib__op_erase,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_replaces
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_IS_PRIMARY, cib__op_is_primary,
	cib__op_attr_privileged
	},
	{
	PCMK__CIB_REQUEST_MODIFY, cib__op_modify,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_NOOP, cib__op_noop, cib__op_attr_none
	},
	{
	CRM_OP_PING, cib__op_ping, cib__op_attr_none
	},
	{
	// @COMPAT: Drop cib__op_attr_modifies when we drop legacy mode support
	PCMK__CIB_REQUEST_PRIMARY, cib__op_primary,
	cib__op_attr_modifies\|cib__op_attr_privileged\|cib__op_attr_local
	},
	{
	PCMK__CIB_REQUEST_QUERY, cib__op_query, cib__op_attr_none
	},
	{
	PCMK__CIB_REQUEST_REPLACE, cib__op_replace,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_replaces
	\|cib__op_attr_writes_through
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_SECONDARY, cib__op_secondary,
	cib__op_attr_privileged\|cib__op_attr_local
	},
	{
	PCMK__CIB_REQUEST_SHUTDOWN, cib__op_shutdown, cib__op_attr_privileged
	},
	{
	PCMK__CIB_REQUEST_SYNC_TO_ALL, cib__op_sync_all, cib__op_attr_privileged
	},
	{
	PCMK__CIB_REQUEST_SYNC_TO_ONE, cib__op_sync_one, cib__op_attr_privileged
	},
	{
	PCMK__CIB_REQUEST_UPGRADE, cib__op_upgrade,
	cib__op_attr_modifies
	\|cib__op_attr_privileged
	\|cib__op_attr_writes_through
	\|cib__op_attr_transaction
	},
	{
	PCMK__CIB_REQUEST_SCHEMAS, cib__op_schemas, cib__op_attr_local
	}
	};

	/*!
	* \internal
	* \brief Get the \c cib__operation_t object for a given CIB operation name
	*
	* \param[in] op CIB operation name
	* \param[out] operation Where to store CIB operation object
	*
	* \return Standard Pacemaker return code
	*/
	int
	cib__get_operation(const char op, const cib__operation_t *operation)
	{
	CRM_ASSERT((op != NULL) && (operation != NULL));

	if (operation_table == NULL) {
	operation_table = pcmk__strkey_table(NULL, NULL);

	for (int lpc = 0; lpc < PCMK__NELEM(cib_ops); lpc++) {
	const cib__operation_t *oper = &(cib_ops[lpc]);

	g_hash_table_insert(operation_table, (gpointer) oper->name,
	(gpointer) oper);
	}
	}

	*operation = g_hash_table_lookup(operation_table, op);
	if (*operation == NULL) {
	crm_err("Operation %s is invalid", op);
	return EINVAL;
	}
	return pcmk_rc_ok;
	}

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

	crm_trace("Processing %s for %s section",
	op, pcmk__s(section, "unspecified"));

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

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

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

	obj_root = pcmk_find_cib_element(existing_cib, section);

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

	} else if (options & cib_no_children) {
	xmlNode shallow = pcmk__xe_create(answer,
	(const char *) obj_root->name);

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

	} else {
	*answer = obj_root;
	}

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

	return result;
	}

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

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

	crm_trace("Update %s from %s to %s",
	field, pcmk__s(old_value, "unset"), new_value);
	crm_xml_add(xml_obj, field, new_value);

	free(new_value);
	free(old_value);

	return pcmk_ok;
	}

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

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

	if (*result_cib != existing_cib) {
	free_xml(*result_cib);
	}
	*result_cib = createEmptyCib(0);
	copy_in_properties(*result_cib, existing_cib);
	update_counter(*result_cib, PCMK_XA_ADMIN_EPOCH, false);
	*answer = NULL;

	return result;
	}

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

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

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

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

	rc = update_validation(result_cib, &new_version, max_version, TRUE,
	!(options & cib_verbose));
	if (new_version > current_version) {
	update_counter(*result_cib, PCMK_XA_ADMIN_EPOCH, false);
	update_counter(*result_cib, PCMK_XA_EPOCH, true);
	update_counter(*result_cib, PCMK_XA_NUM_UPDATES, true);
	return pcmk_ok;
	}

	return rc;
	}

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

	crm_trace("Processing %s for epoch='%s'", op,
	pcmk__s(crm_element_value(existing_cib, PCMK_XA_EPOCH), ""));

	*answer = NULL;
	update_counter(*result_cib, PCMK_XA_EPOCH, false);

	return result;
	}

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

	crm_trace("Processing %s for %s section",
	op, pcmk__s(section, "unspecified"));

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

	*answer = NULL;

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

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

	} else if (pcmk__xe_is(input, section)) {
	section = NULL;
	}

	if (pcmk__xe_is(input, PCMK_XE_CIB)) {
	int updates = 0;
	int epoch = 0;
	int admin_epoch = 0;

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

	const char *reason = NULL;
	const char *peer = crm_element_value(req, PCMK__XA_SRC);
	const char *digest = crm_element_value(req, PCMK__XA_DIGEST);

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

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

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

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

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

	if (replace_admin_epoch < admin_epoch) {
	reason = PCMK_XA_ADMIN_EPOCH;

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

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

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

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

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

	if (*result_cib != existing_cib) {
	free_xml(*result_cib);
	}
	*result_cib = pcmk__xml_copy(NULL, input);

	} else {
	xmlNode *obj_root = NULL;

	obj_root = pcmk_find_cib_element(*result_cib, section);
	result = pcmk__xe_replace_match(obj_root, input);
	result = pcmk_rc2legacy(result);
	if (result != pcmk_ok) {
	crm_trace("No matching object to replace");
	}
	}

	return result;
	}

	static int
	delete_child(xmlNode child, void userdata)
	{
	xmlNode *obj_root = userdata;

	if (pcmk__xe_delete_match(obj_root, child) != pcmk_rc_ok) {
	crm_trace("No matching object to delete: %s=%s",
	child->name, pcmk__xe_id(child));
	}

	return pcmk_rc_ok;
	}

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

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

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

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

	obj_root = pcmk_find_cib_element(*result_cib, section);
	if (pcmk__xe_is(input, section)) {
	pcmk__xe_foreach_child(input, NULL, delete_child, obj_root);
	} else {
	delete_child(input, obj_root);
	}

	return pcmk_ok;
	}

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

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

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

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

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

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

	tmp_section = pcmk__xe_create(NULL, section);
	cib_process_xpath(PCMK__CIB_REQUEST_CREATE, 0, path, NULL, tmp_section,
	NULL, result_cib, answer);
	free_xml(tmp_section);

	obj_root = pcmk_find_cib_element(*result_cib, section);
	}

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

	if (pcmk__xe_update_match(obj_root, input) != pcmk_rc_ok) {
	if (options & cib_can_create) {
	pcmk__xml_copy(obj_root, input);
	} else {
	return -ENXIO;
	}
	}

	// @COMPAT cib_mixed_update is deprecated as of 2.1.7
	if (pcmk_is_set(options, cib_mixed_update)) {
	int max = 0, lpc;
	xmlXPathObjectPtr xpathObj = xpath_search(*result_cib, "//@__delete__");

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

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

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

	freeXpathObject(xpathObj);
	}
	return pcmk_ok;
	}

	-static int
	-update_cib_object(xmlNode parent, xmlNode update)
	-{
	- int result = pcmk_ok;
	- const char *update_id = pcmk__xe_id(update);
	-
	- xmlNode target = pcmk__xe_create(parent, (const char ) update->name);
	-
	- if (update_id != NULL) {
	- crm_trace("Processing update for <%s " PCMK_XA_ID "='%s'>",
	- update->name, update_id);
	- } else {
	- crm_trace("Processing update for <%s>", update->name);
	- }
	-
	- /* @COMPAT PCMK__XA_REPLACE is deprecated since 2.1.6. When we can break
	- * behavioral backward compatibility, drop this and drop the definition of
	- * PCMK__XA_REPLACE.
	- */
	- pcmk__xe_remove_attr(update, PCMK__XA_REPLACE);
	-
	- copy_in_properties(target, update);
	-
	- if (xml_acl_denied(target)) {
	- crm_notice("Cannot update <%s " PCMK_XA_ID "=%s>",
	- update->name, pcmk__s(update_id, "<null>"));
	- return -EACCES;
	- }
	-
	- if (update_id != NULL) {
	- crm_trace("Processing children of <%s " PCMK_XA_ID "='%s'>",
	- update->name, update_id);
	- } else {
	- crm_trace("Processing children of <%s>", update->name);
	- }
	-
	- for (xmlNode *child = pcmk__xml_first_child(update); child != NULL;
	- child = pcmk__xml_next(child)) {
	-
	- const char *child_id = pcmk__xe_id(child);
	- int tmp_result = 0;
	-
	- if (child_id != NULL) {
	- crm_trace("Updating child <%s " PCMK_XA_ID "='%s'>",
	- child->name, child_id);
	- } else {
	- crm_trace("Updating child <%s>", child->name);
	- }
	-
	- tmp_result = update_cib_object(target, child);
	-
	- /* only the first error is likely to be interesting */
	- if (tmp_result != pcmk_ok) {
	- if (child_id != NULL) {
	- crm_err("Error updating child <%s " PCMK_XA_ID "='%s'>",
	- child->name, child_id);
	- } else {
	- crm_err("Error updating child <%s>", child->name);
	- }
	-
	- if (result == pcmk_ok) {
	- result = tmp_result;
	- }
	- }
	- }
	-
	- if (update_id != NULL) {
	- crm_trace("Finished handling update for <%s " PCMK_XA_ID "='%s'>",
	- update->name, update_id);
	- } else {
	- crm_trace("Finished handling update for <%s>", update->name);
	- }
	-
	- return result;
	-}
	-
	static int
	add_cib_object(xmlNode * parent, xmlNode * new_obj)
	{
	const char *object_name = NULL;
	const char *object_id = NULL;

	if ((parent == NULL) \|\| (new_obj == NULL)) {
	return -EINVAL;
	}

	object_name = (const char *) new_obj->name;
	if (object_name == NULL) {
	return -EINVAL;
	}

	object_id = pcmk__xe_id(new_obj);
	if (pcmk__xe_first_child(parent, object_name,
	((object_id != NULL)? PCMK_XA_ID : NULL),
	object_id)) {
	return -EEXIST;
	}

	if (object_id != NULL) {
	crm_trace("Processing creation of <%s " PCMK_XA_ID "='%s'>",
	object_name, object_id);
	} else {
	crm_trace("Processing creation of <%s>", object_name);
	}

	- return update_cib_object(parent, new_obj);
	+ /* @COMPAT PCMK__XA_REPLACE is deprecated since 2.1.6. Due to a legacy use
	+ * case, PCMK__XA_REPLACE has special meaning and should not be included in
	+ * the newly created object until we can break behavioral backward
	+ * compatibility.
	+ *
	+ * At a compatibility break, drop this and drop the definition of
	+ * PCMK__XA_REPLACE. Treat it like any other attribute.
	+ */
	+ pcmk__xml_tree_foreach(new_obj, pcmk__xe_remove_attr_cb,
	+ (void *) PCMK__XA_REPLACE);
	+
	+ pcmk__xml_copy(parent, new_obj);
	+ return pcmk_ok;
	}

	static bool
	update_results(xmlNode failed, xmlNode target, const char *operation,
	int return_code)
	{
	xmlNode *xml_node = NULL;
	bool was_error = false;
	const char *error_msg = NULL;

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

	was_error = true;
	xml_node = pcmk__xe_create(failed, PCMK__XE_FAILED_UPDATE);
	pcmk__xml_copy(xml_node, target);

	crm_xml_add(xml_node, PCMK_XA_ID, pcmk__xe_id(target));
	crm_xml_add(xml_node, PCMK_XA_OBJECT_TYPE, (const char *) target->name);
	crm_xml_add(xml_node, PCMK_XA_OPERATION, operation);
	crm_xml_add(xml_node, PCMK_XA_REASON, error_msg);

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

	return was_error;
	}

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

	crm_trace("Processing %s for %s section",
	op, pcmk__s(section, "unspecified"));
	if (pcmk__str_eq(PCMK__XE_ALL, section, pcmk__str_casei)) {
	section = NULL;

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

	} else if (pcmk__xe_is(input, PCMK_XE_CIB)) {
	section = NULL;
	}

	CRM_CHECK(strcmp(op, PCMK__CIB_REQUEST_CREATE) == 0, return -EINVAL);

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

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

	failed = pcmk__xe_create(NULL, PCMK__XE_FAILED);

	update_section = pcmk_find_cib_element(*result_cib, section);
	if (pcmk__xe_is(input, section)) {
	xmlNode *a_child = NULL;

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

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

	if ((result == pcmk_ok) && (failed->children != NULL)) {
	result = -EINVAL;
	}

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

	} else {
	free_xml(failed);
	}

	return result;
	}

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

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

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

	if (*result_cib != existing_cib) {
	free_xml(*result_cib);
	}
	*result_cib = pcmk__xml_copy(NULL, existing_cib);

	return xml_apply_patchset(*result_cib, input, TRUE);
	}

	// @COMPAT: v1-only
	bool
	cib__config_changed_v1(xmlNode last, xmlNode next, xmlNode **diff)
	{
	int lpc = 0, max = 0;
	bool config_changes = false;
	xmlXPathObject *xpathObj = NULL;
	int format = 1;

	CRM_ASSERT(diff != NULL);

	if (*diff == NULL && last != NULL && next != NULL) {
	*diff = pcmk__diff_v1_xml_object(last, next, false);
	}

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

	crm_element_value_int(*diff, PCMK_XA_FORMAT, &format);
	CRM_LOG_ASSERT(format == 1);

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

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

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

	if (crm_element_value(top, PCMK_XA_EPOCH) != NULL) {
	config_changes = true;
	goto done;
	}
	if (crm_element_value(top, PCMK_XA_ADMIN_EPOCH) != NULL) {
	config_changes = true;
	goto done;
	}

	if (crm_element_value(top, PCMK_XA_VALIDATE_WITH) != NULL) {
	config_changes = true;
	goto done;
	}
	if (crm_element_value(top, PCMK_XA_CRM_FEATURE_SET) != NULL) {
	config_changes = true;
	goto done;
	}
	if (crm_element_value(top, PCMK_XA_REMOTE_CLEAR_PORT) != NULL) {
	config_changes = true;
	goto done;
	}
	if (crm_element_value(top, PCMK_XA_REMOTE_TLS_PORT) != NULL) {
	config_changes = true;
	goto done;
	}
	}

	done:
	freeXpathObject(xpathObj);
	return config_changes;
	}

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

	xmlXPathObjectPtr xpathObj = NULL;

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

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

	max = numXpathResults(xpathObj);

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

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

	} else if (is_query) {
	if (max > 1) {
	*answer = pcmk__xe_create(NULL, PCMK__XE_XPATH_QUERY);
	}
	}

	if (pcmk_is_set(options, cib_multiple)
	&& pcmk__str_eq(op, PCMK__CIB_REQUEST_DELETE, pcmk__str_none)) {
	dedupXpathResults(xpathObj);
	}

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

	if (match == NULL) {
	continue;
	}

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

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

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

	} else if (pcmk__str_eq(op, PCMK__CIB_REQUEST_MODIFY, pcmk__str_none)) {
	if (pcmk__xe_update_match(match, input) != pcmk_rc_ok) {
	rc = -ENXIO;
	} else if ((options & cib_multiple) == 0) {
	break;
	}

	} else if (pcmk__str_eq(op, PCMK__CIB_REQUEST_CREATE, pcmk__str_none)) {
	pcmk__xml_copy(match, input);
	break;

	} else if (pcmk__str_eq(op, PCMK__CIB_REQUEST_QUERY, pcmk__str_none)) {

	if (options & cib_no_children) {
	xmlNode shallow = pcmk__xe_create(answer,
	(const char *) match->name);

	copy_in_properties(shallow, match);

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

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

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

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

	if (*answer == NULL) {
	*answer = pcmk__xe_create(NULL, PCMK__XE_XPATH_QUERY);
	}
	parent = pcmk__xe_create(*answer, PCMK__XE_XPATH_QUERY_PATH);
	crm_xml_add(parent, PCMK_XA_ID, path);
	free(path);

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

	} else {
	*answer = match;
	}

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

	free_xml(match);
	pcmk__xml_copy(parent, input);

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

	freeXpathObject(xpathObj);
	return rc;
	}
	diff --git a/lib/common/crmcommon_private.h b/lib/common/crmcommon_private.h
	index 4b344eb5db..daf48e18d3 100644
	--- a/lib/common/crmcommon_private.h
	+++ b/lib/common/crmcommon_private.h
	@@ -1,422 +1,418 @@
	/*
	* Copyright 2018-2024 the Pacemaker project contributors
	*
	* The version control history for this file may have further details.
	*
	* This source code is licensed under the GNU Lesser General Public License
	* version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
	*/

	#ifndef CRMCOMMON_PRIVATE__H
	# define CRMCOMMON_PRIVATE__H

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

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

	// Decent chunk size for processing large amounts of data
	#define PCMK__BUFFER_SIZE 4096

	#if defined(PCMK__UNIT_TESTING)
	#undef G_GNUC_INTERNAL
	#define G_GNUC_INTERNAL
	#endif

	/* When deleting portions of an XML tree, we keep a record so we can know later
	* (e.g. when checking differences) that something was deleted.
	*/
	typedef struct pcmk__deleted_xml_s {
	gchar *path;
	int position;
	} pcmk__deleted_xml_t;

	typedef struct xml_node_private_s {
	uint32_t check;
	uint32_t flags;
	} xml_node_private_t;

	typedef struct xml_doc_private_s {
	uint32_t check;
	uint32_t flags;
	char *user;
	GList *acls;
	GList *deleted_objs; // List of pcmk__deleted_xml_t
	} xml_doc_private_t;

	// XML entity references

	#define PCMK__XML_ENTITY_AMP "&"
	#define PCMK__XML_ENTITY_GT ">"
	#define PCMK__XML_ENTITY_LT "<"
	#define PCMK__XML_ENTITY_QUOT """

	//! libxml2 supports only XML version 1.0, at least as of libxml2-2.12.5
	#define PCMK__XML_VERSION ((pcmkXmlStr) "1.0")

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

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

	-G_GNUC_INTERNAL
	-bool pcmk__xml_tree_foreach(xmlNode xml, bool (fn)(xmlNode , void ),
	- void *user_data);
	-
	G_GNUC_INTERNAL
	bool pcmk__tracking_xml_changes(xmlNode *xml, bool lazy);

	G_GNUC_INTERNAL
	void pcmk__xml_mark_created(xmlNode *xml);

	G_GNUC_INTERNAL
	int pcmk__xml_position(const xmlNode *xml,
	enum xml_private_flags ignore_if_set);

	G_GNUC_INTERNAL
	xmlNode pcmk__xml_match(const xmlNode haystack, const xmlNode *needle,
	bool exact);

	G_GNUC_INTERNAL
	void pcmk__xml_update(xmlNode parent, xmlNode target, xmlNode *update,
	bool as_diff);

	G_GNUC_INTERNAL
	xmlNode pcmk__xc_match(const xmlNode root, const xmlNode *search_comment,
	bool exact);

	G_GNUC_INTERNAL
	void pcmk__xc_update(xmlNode parent, xmlNode target, xmlNode *update);

	G_GNUC_INTERNAL
	void pcmk__free_acls(GList *acls);

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

	G_GNUC_INTERNAL
	bool pcmk__is_user_in_group(const char user, const char group);

	G_GNUC_INTERNAL
	void pcmk__apply_acl(xmlNode *xml);

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

	G_GNUC_INTERNAL
	void pcmk__mark_xml_attr_dirty(xmlAttr *a);

	G_GNUC_INTERNAL
	bool pcmk__xa_filterable(const char *name);

	G_GNUC_INTERNAL
	void pcmk__log_xmllib_err(void ctx, const char fmt, ...)
	G_GNUC_PRINTF(2, 3);

	G_GNUC_INTERNAL
	void pcmk__mark_xml_node_dirty(xmlNode *xml);

	G_GNUC_INTERNAL
	bool pcmk__marked_as_deleted(xmlAttrPtr a, void *user_data);

	G_GNUC_INTERNAL
	void pcmk__dump_xml_attr(const xmlAttr attr, GString buffer);

	/*
	* Date/times
	*/

	// For use with pcmk__add_time_from_xml()
	enum pcmk__time_component {
	pcmk__time_unknown,
	pcmk__time_years,
	pcmk__time_months,
	pcmk__time_weeks,
	pcmk__time_days,
	pcmk__time_hours,
	pcmk__time_minutes,
	pcmk__time_seconds,
	};

	G_GNUC_INTERNAL
	const char *pcmk__time_component_attr(enum pcmk__time_component component);

	G_GNUC_INTERNAL
	int pcmk__add_time_from_xml(crm_time_t *t, enum pcmk__time_component component,
	const xmlNode *xml);

	G_GNUC_INTERNAL
	void pcmk__set_time_if_earlier(crm_time_t target, const crm_time_t source);


	/*
	* IPC
	*/

	#define PCMK__IPC_VERSION 1

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

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

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

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

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

	/*!
	* \internal
	* \brief Perform daemon-specific handling of an IPC message
	*
	* \param[in,out] api IPC API connection
	* \param[in,out] msg Message read from IPC connection
	*
	* \return true if more IPC reply messages should be expected
	*/
	bool (dispatch)(pcmk_ipc_api_t api, xmlNode *msg);

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

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

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

	G_GNUC_INTERNAL
	int pcmk__send_ipc_request(pcmk_ipc_api_t api, const xmlNode request);

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

	G_GNUC_INTERNAL
	unsigned int pcmk__ipc_buffer_size(unsigned int max);

	G_GNUC_INTERNAL
	bool pcmk__valid_ipc_header(const pcmk__ipc_header_t *header);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__attrd_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__controld_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__pacemakerd_api_methods(void);

	G_GNUC_INTERNAL
	pcmk__ipc_methods_t *pcmk__schedulerd_api_methods(void);


	/*
	* Logging
	*/

	//! XML is newly created
	#define PCMK__XML_PREFIX_CREATED "++"

	//! XML has been deleted
	#define PCMK__XML_PREFIX_DELETED "--"

	//! XML has been modified
	#define PCMK__XML_PREFIX_MODIFIED "+ "

	//! XML has been moved
	#define PCMK__XML_PREFIX_MOVED "+~"

	/*
	* Output
	*/
	G_GNUC_INTERNAL
	int pcmk__bare_output_new(pcmk__output_t *out, const char fmt_name,
	const char filename, char *argv);

	G_GNUC_INTERNAL
	void pcmk__register_option_messages(pcmk__output_t *out);

	G_GNUC_INTERNAL
	void pcmk__register_patchset_messages(pcmk__output_t *out);

	G_GNUC_INTERNAL
	bool pcmk__output_text_get_fancy(pcmk__output_t *out);

	/*
	* Rules
	*/

	// How node attribute values may be compared in rules
	enum pcmk__comparison {
	pcmk__comparison_unknown,
	pcmk__comparison_defined,
	pcmk__comparison_undefined,
	pcmk__comparison_eq,
	pcmk__comparison_ne,
	pcmk__comparison_lt,
	pcmk__comparison_lte,
	pcmk__comparison_gt,
	pcmk__comparison_gte,
	};

	// How node attribute values may be parsed in rules
	enum pcmk__type {
	pcmk__type_unknown,
	pcmk__type_string,
	pcmk__type_integer,
	pcmk__type_number,
	pcmk__type_version,
	};

	// Where to obtain reference value for a node attribute comparison
	enum pcmk__reference_source {
	pcmk__source_unknown,
	pcmk__source_literal,
	pcmk__source_instance_attrs,
	pcmk__source_meta_attrs,
	};

	G_GNUC_INTERNAL
	enum pcmk__comparison pcmk__parse_comparison(const char *op);

	G_GNUC_INTERNAL
	enum pcmk__type pcmk__parse_type(const char *type, enum pcmk__comparison op,
	const char value1, const char value2);

	G_GNUC_INTERNAL
	enum pcmk__reference_source pcmk__parse_source(const char *source);

	G_GNUC_INTERNAL
	int pcmk__cmp_by_type(const char value1, const char value2,
	enum pcmk__type type);

	G_GNUC_INTERNAL
	int pcmk__unpack_duration(const xmlNode duration, const crm_time_t start,
	crm_time_t **end);

	G_GNUC_INTERNAL
	int pcmk__evaluate_date_spec(const xmlNode date_spec, const crm_time_t now);

	G_GNUC_INTERNAL
	int pcmk__evaluate_attr_expression(const xmlNode *expression,
	const pcmk_rule_input_t *rule_input);

	G_GNUC_INTERNAL
	int pcmk__evaluate_rsc_expression(const xmlNode *expr,
	const pcmk_rule_input_t *rule_input);

	G_GNUC_INTERNAL
	int pcmk__evaluate_op_expression(const xmlNode *expr,
	const pcmk_rule_input_t *rule_input);


	/*
	* Utils
	*/
	#define PCMK__PW_BUFFER_LEN 500


	/*
	* Schemas
	*/
	typedef struct {
	unsigned char v[2];
	} pcmk__schema_version_t;

	enum pcmk__schema_validator {
	pcmk__schema_validator_none,
	pcmk__schema_validator_rng
	};

	typedef struct {
	char *name;
	char *transform;
	void *cache;
	enum pcmk__schema_validator validator;
	pcmk__schema_version_t version;
	char *transform_enter;
	bool transform_onleave;
	} pcmk__schema_t;

	G_GNUC_INTERNAL
	int pcmk__find_x_0_schema_index(GList *schemas);


	#endif // CRMCOMMON_PRIVATE__H

File Metadata

Mime Type: text/x-diff
Expires: Thu, Oct 16, 12:34 AM (16 h, 59 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 2530909
Default Alt Text: (64 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions