No OneTemporary
Actions

Size

90 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/include/crm/common/nvpair_internal.h b/include/crm/common/nvpair_internal.h
	index 8b2f4441ac..cc30d39d9c 100644
	--- a/include/crm/common/nvpair_internal.h
	+++ b/include/crm/common/nvpair_internal.h
	@@ -1,38 +1,40 @@
	/*
	* 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.
	*/

	#ifndef PCMK__CRM_COMMON_NVPAIR_INTERNAL__H
	#define PCMK__CRM_COMMON_NVPAIR_INTERNAL__H

	#include <crm/common/strings_internal.h> // pcmk__str_eq(), etc.

	#ifdef __cplusplus
	extern "C" {
	#endif

	/*!
	* \internal
	* \brief Insert a meta-attribute into a hash table
	*
	* \param[in] obj Resource (pe_resource_t) or action (pe_action_t) to add to
	* \param[in] name Meta-attribute name
	* \param[in] value Value to add
	*/
	#define pcmk__insert_meta(obj, name, value) do { \
	if (!pcmk__str_eq((value), "#default", \
	pcmk__str_casei\|pcmk__str_null_matches)) { \
	pcmk__insert_dup((obj)->meta, (name), (value)); \
	} \
	} while (0)

	+int pcmk__xe_get_datetime(const xmlNode xml, const char attr, crm_time_t **t);
	+
	#ifdef __cplusplus
	}
	#endif

	#endif // PCMK__CRM_COMMON_NVPAIR_INTERNAL__H
	diff --git a/lib/common/nvpair.c b/lib/common/nvpair.c
	index 234876557b..ddcf2a720d 100644
	--- a/lib/common/nvpair.c
	+++ b/lib/common/nvpair.c
	@@ -1,1043 +1,1074 @@
	/*
	* 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 <sys/types.h>
	#include <string.h>
	#include <ctype.h>
	#include <glib.h>
	#include <libxml/tree.h>

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

	/*
	* This file isolates handling of various kinds of name/value pairs:
	*
	* - pcmk_nvpair_t data type
	* - XML attributes (<TAG ... NAME=VALUE ...>)
	* - XML nvpair elements (<nvpair id=ID name=NAME value=VALUE>)
	* - Meta-attributes (for resources and actions)
	*/

	// pcmk_nvpair_t handling

	/*!
	* \internal
	* \brief Allocate a new name/value pair
	*
	* \param[in] name New name (required)
	* \param[in] value New value
	*
	* \return Newly allocated name/value pair
	* \note The caller is responsible for freeing the result with
	* \c pcmk__free_nvpair().
	*/
	static pcmk_nvpair_t *
	pcmk__new_nvpair(const char name, const char value)
	{
	pcmk_nvpair_t *nvpair = NULL;

	CRM_ASSERT(name);

	nvpair = calloc(1, sizeof(pcmk_nvpair_t));
	CRM_ASSERT(nvpair);

	pcmk__str_update(&nvpair->name, name);
	pcmk__str_update(&nvpair->value, value);
	return nvpair;
	}

	/*!
	* \internal
	* \brief Free a name/value pair
	*
	* \param[in,out] nvpair Name/value pair to free
	*/
	static void
	pcmk__free_nvpair(gpointer data)
	{
	if (data) {
	pcmk_nvpair_t *nvpair = data;

	free(nvpair->name);
	free(nvpair->value);
	free(nvpair);
	}
	}

	/*!
	* \brief Prepend a name/value pair to a list
	*
	* \param[in,out] nvpairs List to modify
	* \param[in] name New entry's name
	* \param[in] value New entry's value
	*
	* \return New head of list
	* \note The caller is responsible for freeing the list with
	* \c pcmk_free_nvpairs().
	*/
	GSList *
	pcmk_prepend_nvpair(GSList nvpairs, const char name, const char *value)
	{
	return g_slist_prepend(nvpairs, pcmk__new_nvpair(name, value));
	}

	/*!
	* \brief Free a list of name/value pairs
	*
	* \param[in,out] list List to free
	*/
	void
	pcmk_free_nvpairs(GSList *nvpairs)
	{
	g_slist_free_full(nvpairs, pcmk__free_nvpair);
	}

	/*!
	* \internal
	* \brief Compare two name/value pairs
	*
	* \param[in] a First name/value pair to compare
	* \param[in] b Second name/value pair to compare
	*
	* \return 0 if a == b, 1 if a > b, -1 if a < b
	*/
	static gint
	pcmk__compare_nvpair(gconstpointer a, gconstpointer b)
	{
	int rc = 0;
	const pcmk_nvpair_t *pair_a = a;
	const pcmk_nvpair_t *pair_b = b;

	CRM_ASSERT(a != NULL);
	CRM_ASSERT(pair_a->name != NULL);

	CRM_ASSERT(b != NULL);
	CRM_ASSERT(pair_b->name != NULL);

	rc = strcmp(pair_a->name, pair_b->name);
	if (rc < 0) {
	return -1;
	} else if (rc > 0) {
	return 1;
	}
	return 0;
	}

	/*!
	* \brief Sort a list of name/value pairs
	*
	* \param[in,out] list List to sort
	*
	* \return New head of list
	*/
	GSList *
	pcmk_sort_nvpairs(GSList *list)
	{
	return g_slist_sort(list, pcmk__compare_nvpair);
	}

	/*!
	* \brief Create a list of name/value pairs from an XML node's attributes
	*
	* \param[in] XML to parse
	*
	* \return New list of name/value pairs
	* \note It is the caller's responsibility to free the list with
	* \c pcmk_free_nvpairs().
	*/
	GSList *
	pcmk_xml_attrs2nvpairs(const xmlNode *xml)
	{
	GSList *result = NULL;

	for (xmlAttrPtr iter = pcmk__xe_first_attr(xml); iter != NULL;
	iter = iter->next) {

	result = pcmk_prepend_nvpair(result,
	(const char *) iter->name,
	(const char *) pcmk__xml_attr_value(iter));
	}
	return result;
	}

	/*!
	* \internal
	* \brief Add an XML attribute corresponding to a name/value pair
	*
	* Suitable for glib list iterators, this function adds a NAME=VALUE
	* XML attribute based on a given name/value pair.
	*
	* \param[in] data Name/value pair
	* \param[out] user_data XML node to add attributes to
	*/
	static void
	pcmk__nvpair_add_xml_attr(gpointer data, gpointer user_data)
	{
	pcmk_nvpair_t *pair = data;
	xmlNode *parent = user_data;

	crm_xml_add(parent, pair->name, pair->value);
	}

	/*!
	* \brief Add XML attributes based on a list of name/value pairs
	*
	* \param[in,out] list List of name/value pairs
	* \param[in,out] xml XML node to add attributes to
	*/
	void
	pcmk_nvpairs2xml_attrs(GSList list, xmlNode xml)
	{
	g_slist_foreach(list, pcmk__nvpair_add_xml_attr, xml);
	}

	// convenience function for name=value strings

	/*!
	* \internal
	* \brief Extract the name and value from an input string formatted as "name=value".
	* If unable to extract them, they are returned as NULL.
	*
	* \param[in] input The input string, likely from the command line
	* \param[out] name Everything before the first '=' in the input string
	* \param[out] value Everything after the first '=' in the input string
	*
	* \return 2 if both name and value could be extracted, 1 if only one could, and
	* and error code otherwise
	*/
	int
	pcmk__scan_nvpair(const char input, char name, char *value)
	{
	#ifdef HAVE_SSCANF_M
	*name = NULL;
	*value = NULL;
	if (sscanf(input, "%m[^=]=%m[^\n]", name, value) <= 0) {
	return -pcmk_err_bad_nvpair;
	}
	#else
	char *sep = NULL;
	*name = NULL;
	*value = NULL;

	sep = strstr(optarg, "=");
	if (sep == NULL) {
	return -pcmk_err_bad_nvpair;
	}

	*name = strndup(input, sep-input);

	if (*name == NULL) {
	return -ENOMEM;
	}

	/* If the last char in optarg is =, the user gave no
	* value for the option. Leave it as NULL.
	*/
	if (*(sep+1) != '\0') {
	*value = strdup(sep+1);

	if (*value == NULL) {
	return -ENOMEM;
	}
	}
	#endif

	if (name != NULL && value != NULL) {
	return 2;
	} else if (name != NULL \|\| value != NULL) {
	return 1;
	} else {
	return -pcmk_err_bad_nvpair;
	}
	}

	/*!
	* \internal
	* \brief Format a name/value pair.
	*
	* Units can optionally be provided for the value. Note that unlike most
	* formatting functions, this one returns the formatted string. It is
	* assumed that the most common use of this function will be to build up
	* a string to be output as part of other functions.
	*
	* \note The caller is responsible for freeing the return value after use.
	*
	* \param[in] name The name of the nvpair.
	* \param[in] value The value of the nvpair.
	* \param[in] units Optional units for the value, or NULL.
	*
	* \return Newly allocated string with name/value pair
	*/
	char *
	pcmk__format_nvpair(const char name, const char value, const char *units)
	{
	return crm_strdup_printf("%s=\"%s%s\"", name, value, units ? units : "");
	}

	// XML attribute handling

	/*!
	* \brief Create an XML attribute with specified name and value
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] value Attribute value to set
	*
	* \return New value on success, \c NULL otherwise
	* \note This does nothing if node, name, or value are \c NULL or empty.
	*/
	const char *
	crm_xml_add(xmlNode node, const char name, const char *value)
	{
	bool dirty = FALSE;
	xmlAttr *attr = NULL;

	CRM_CHECK(node != NULL, return NULL);
	CRM_CHECK(name != NULL, return NULL);

	if (value == NULL) {
	return NULL;
	}

	if (pcmk__tracking_xml_changes(node, FALSE)) {
	const char *old = crm_element_value(node, name);

	if (old == NULL \|\| value == NULL \|\| strcmp(old, value) != 0) {
	dirty = TRUE;
	}
	}

	if (dirty && (pcmk__check_acl(node, name, pcmk__xf_acl_create) == FALSE)) {
	crm_trace("Cannot add %s=%s to %s", name, value, node->name);
	return NULL;
	}

	attr = xmlSetProp(node, (pcmkXmlStr) name, (pcmkXmlStr) value);
	if (dirty) {
	pcmk__mark_xml_attr_dirty(attr);
	}

	CRM_CHECK(attr && attr->children && attr->children->content, return NULL);
	return (char *)attr->children->content;
	}

	/*!
	* \brief Create an XML attribute with specified name and integer value
	*
	* This is like \c crm_xml_add() but taking an integer value.
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] value Attribute value to set
	*
	* \return New value as string on success, \c NULL otherwise
	* \note This does nothing if node or name are \c NULL or empty.
	*/
	const char *
	crm_xml_add_int(xmlNode node, const char name, int value)
	{
	char *number = pcmk__itoa(value);
	const char *added = crm_xml_add(node, name, number);

	free(number);
	return added;
	}

	/*!
	* \brief Create an XML attribute with specified name and unsigned value
	*
	* This is like \c crm_xml_add() but taking a guint value.
	*
	* \param[in,out] node XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] ms Attribute value to set
	*
	* \return New value as string on success, \c NULL otherwise
	* \note This does nothing if node or name are \c NULL or empty.
	*/
	const char *
	crm_xml_add_ms(xmlNode node, const char name, guint ms)
	{
	char *number = crm_strdup_printf("%u", ms);
	const char *added = crm_xml_add(node, name, number);

	free(number);
	return added;
	}

	// Maximum size of null-terminated string representation of 64-bit integer
	// -9223372036854775808
	#define LLSTRSIZE 21

	/*!
	* \brief Create an XML attribute with specified name and long long int value
	*
	* This is like \c crm_xml_add() but taking a long long int value. It is a
	* useful equivalent for defined types like time_t, etc.
	*
	* \param[in,out] xml XML node to modify
	* \param[in] name Attribute name to set
	* \param[in] value Attribute value to set
	*
	* \return New value as string on success, \c NULL otherwise
	* \note This does nothing if xml or name are \c NULL or empty.
	* This does not support greater than 64-bit values.
	*/
	const char *
	crm_xml_add_ll(xmlNode xml, const char name, long long value)
	{
	char s[LLSTRSIZE] = { '\0', };

	if (snprintf(s, LLSTRSIZE, "%lld", (long long) value) == LLSTRSIZE) {
	return NULL;
	}
	return crm_xml_add(xml, name, s);
	}

	/*!
	* \brief Create XML attributes for seconds and microseconds
	*
	* This is like \c crm_xml_add() but taking a struct timeval.
	*
	* \param[in,out] xml XML node to modify
	* \param[in] name_sec Name of XML attribute for seconds
	* \param[in] name_usec Name of XML attribute for microseconds (or NULL)
	* \param[in] value Time value to set
	*
	* \return New seconds value as string on success, \c NULL otherwise
	* \note This does nothing if xml, name_sec, or value is \c NULL.
	*/
	const char *
	crm_xml_add_timeval(xmlNode xml, const char name_sec, const char *name_usec,
	const struct timeval *value)
	{
	const char *added = NULL;

	if (xml && name_sec && value) {
	added = crm_xml_add_ll(xml, name_sec, (long long) value->tv_sec);
	if (added && name_usec) {
	// Any error is ignored (we successfully added seconds)
	crm_xml_add_ll(xml, name_usec, (long long) value->tv_usec);
	}
	}
	return added;
	}

	/*!
	* \brief Retrieve the value of an XML attribute
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	*
	* \return Value of specified attribute (may be \c NULL)
	*/
	const char *
	crm_element_value(const xmlNode data, const char name)
	{
	xmlAttr *attr = NULL;

	if (data == NULL) {
	crm_err("Couldn't find %s in NULL", name ? name : "<null>");
	CRM_LOG_ASSERT(data != NULL);
	return NULL;

	} else if (name == NULL) {
	crm_err("Couldn't find NULL in %s", data->name);
	return NULL;
	}

	/* The first argument to xmlHasProp() has always been const,
	* but libxml2 <2.9.2 didn't declare that, so cast it
	*/
	attr = xmlHasProp((xmlNode *) data, (pcmkXmlStr) name);
	if (!attr \|\| !attr->children) {
	return NULL;
	}
	return (const char *) attr->children->content;
	}

	/*!
	* \brief Retrieve the integer value of an XML attribute
	*
	* This is like \c crm_element_value() but getting the value as an integer.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	* \param[out] dest Where to store element value
	*
	* \return 0 on success, -1 otherwise
	*/
	int
	crm_element_value_int(const xmlNode data, const char name, int *dest)
	{
	const char *value = NULL;

	CRM_CHECK(dest != NULL, return -1);
	value = crm_element_value(data, name);
	if (value) {
	long long value_ll;

	if ((pcmk__scan_ll(value, &value_ll, 0LL) != pcmk_rc_ok)
	\|\| (value_ll < INT_MIN) \|\| (value_ll > INT_MAX)) {
	*dest = PCMK__PARSE_INT_DEFAULT;
	} else {
	*dest = (int) value_ll;
	return 0;
	}
	}
	return -1;
	}

	/*!
	* \brief Retrieve the long long integer value of an XML attribute
	*
	* This is like \c crm_element_value() but getting the value as a long long int.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	* \param[out] dest Where to store element value
	*
	* \return 0 on success, -1 otherwise
	*/
	int
	crm_element_value_ll(const xmlNode data, const char name, long long *dest)
	{
	const char *value = NULL;

	CRM_CHECK(dest != NULL, return -1);
	value = crm_element_value(data, name);
	if ((value != NULL)
	&& (pcmk__scan_ll(value, dest, PCMK__PARSE_INT_DEFAULT) == pcmk_rc_ok)) {
	return 0;
	}
	return -1;
	}

	/*!
	* \brief Retrieve the millisecond value of an XML attribute
	*
	* This is like \c crm_element_value() but returning the value as a guint.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	* \param[out] dest Where to store attribute value
	*
	* \return \c pcmk_ok on success, -1 otherwise
	*/
	int
	crm_element_value_ms(const xmlNode data, const char name, guint *dest)
	{
	const char *value = NULL;
	long long value_ll;

	CRM_CHECK(dest != NULL, return -1);
	*dest = 0;
	value = crm_element_value(data, name);
	if ((pcmk__scan_ll(value, &value_ll, 0LL) != pcmk_rc_ok)
	\|\| (value_ll < 0) \|\| (value_ll > G_MAXUINT)) {
	return -1;
	}
	*dest = (guint) value_ll;
	return pcmk_ok;
	}

	/*!
	* \brief Retrieve the seconds-since-epoch value of an XML attribute
	*
	* This is like \c crm_element_value() but returning the value as a time_t.
	*
	* \param[in] xml XML node to check
	* \param[in] name Attribute name to check
	* \param[out] dest Where to store attribute value
	*
	* \return \c pcmk_ok on success, -1 otherwise
	*/
	int
	crm_element_value_epoch(const xmlNode xml, const char name, time_t *dest)
	{
	long long value_ll = 0;

	if (crm_element_value_ll(xml, name, &value_ll) < 0) {
	return -1;
	}

	/* Unfortunately, we can't do any bounds checking, since time_t has neither
	* standardized bounds nor constants defined for them.
	*/
	*dest = (time_t) value_ll;
	return pcmk_ok;
	}

	/*!
	* \brief Retrieve the value of XML second/microsecond attributes as time
	*
	* This is like \c crm_element_value() but returning value as a struct timeval.
	*
	* \param[in] xml XML to parse
	* \param[in] name_sec Name of XML attribute for seconds
	* \param[in] name_usec Name of XML attribute for microseconds
	* \param[out] dest Where to store result
	*
	* \return \c pcmk_ok on success, -errno on error
	* \note Values default to 0 if XML or XML attribute does not exist
	*/
	int
	crm_element_value_timeval(const xmlNode xml, const char name_sec,
	const char name_usec, struct timeval dest)
	{
	long long value_i = 0;

	CRM_CHECK(dest != NULL, return -EINVAL);
	dest->tv_sec = 0;
	dest->tv_usec = 0;

	if (xml == NULL) {
	return pcmk_ok;
	}

	/* Unfortunately, we can't do any bounds checking, since there are no
	* constants provided for the bounds of time_t and suseconds_t, and
	* calculating them isn't worth the effort. If there are XML values
	* beyond the native sizes, there will probably be worse problems anyway.
	*/

	// Parse seconds
	errno = 0;
	if (crm_element_value_ll(xml, name_sec, &value_i) < 0) {
	return -errno;
	}
	dest->tv_sec = (time_t) value_i;

	// Parse microseconds
	if (crm_element_value_ll(xml, name_usec, &value_i) < 0) {
	return -errno;
	}
	dest->tv_usec = (suseconds_t) value_i;

	return pcmk_ok;
	}

	+/*!
	+ * \internal
	+ * \brief Get a date/time object from an XML attribute value
	+ *
	+ * \param[in] xml XML with attribute to parse (from CIB)
	+ * \param[in] attr Name of attribute to parse
	+ * \param[out] t Where to create date/time object
	+ * (\p *t must be NULL initially)
	+ *
	+ * \return Standard Pacemaker return code
	+ * \note The caller is responsible for freeing \p *t using crm_time_free().
	+ */
	+int
	+pcmk__xe_get_datetime(const xmlNode xml, const char attr, crm_time_t **t)
	+{
	+ const char *value = NULL;
	+
	+ if ((t == NULL) \|\| (*t != NULL) \|\| (xml == NULL) \|\| (attr == NULL)) {
	+ return EINVAL;
	+ }
	+
	+ value = crm_element_value(xml, attr);
	+ if (value != NULL) {
	+ *t = crm_time_new(value);
	+ if (*t == NULL) {
	+ return pcmk_rc_unpack_error;
	+ }
	+ }
	+ return pcmk_rc_ok;
	+}
	+
	/*!
	* \brief Retrieve a copy of the value of an XML attribute
	*
	* This is like \c crm_element_value() but allocating new memory for the result.
	*
	* \param[in] data XML node to check
	* \param[in] name Attribute name to check
	*
	* \return Value of specified attribute (may be \c NULL)
	* \note The caller is responsible for freeing the result.
	*/
	char *
	crm_element_value_copy(const xmlNode data, const char name)
	{
	char *value_copy = NULL;

	pcmk__str_update(&value_copy, crm_element_value(data, name));
	return value_copy;
	}

	/*!
	* \brief Safely add hash table entry to XML as attribute or name-value pair
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as user data, and adds an XML attribute
	* with the specified name and value if it does not already exist. If the key
	* name starts with a digit, then it's not a valid XML attribute name. In that
	* case, this will instead add a <tt><param name=NAME value=VALUE/></tt> child
	* to the XML.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in,out] user_data XML node
	*/
	void
	hash2smartfield(gpointer key, gpointer value, gpointer user_data)
	{
	/* @TODO Generate PCMK__XE_PARAM nodes for all keys that aren't valid XML
	* attribute names (not just those that start with digits), or possibly for
	* all keys to simplify parsing.
	*
	* Consider either deprecating as public API or exposing PCMK__XE_PARAM.
	* PCMK__XE_PARAM is currently private because it doesn't appear in any
	* output that Pacemaker generates.
	*/
	const char *name = key;
	const char *s_value = value;

	xmlNode *xml_node = user_data;

	if (isdigit(name[0])) {
	xmlNode *tmp = create_xml_node(xml_node, PCMK__XE_PARAM);

	crm_xml_add(tmp, PCMK_XA_NAME, name);
	crm_xml_add(tmp, PCMK_XA_VALUE, s_value);

	} else if (crm_element_value(xml_node, name) == NULL) {
	crm_xml_add(xml_node, name, s_value);
	crm_trace("dumped: %s=%s", name, s_value);

	} else {
	crm_trace("duplicate: %s=%s", name, s_value);
	}
	}

	/*!
	* \brief Set XML attribute based on hash table entry
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as user data, and adds an XML attribute
	* with the specified name and value if it does not already exist.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in,out] user_data XML node
	*/
	void
	hash2field(gpointer key, gpointer value, gpointer user_data)
	{
	const char *name = key;
	const char *s_value = value;

	xmlNode *xml_node = user_data;

	if (crm_element_value(xml_node, name) == NULL) {
	crm_xml_add(xml_node, name, s_value);

	} else {
	crm_trace("duplicate: %s=%s", name, s_value);
	}
	}

	/*!
	* \brief Set XML attribute based on hash table entry, as meta-attribute name
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as user data, and adds an XML attribute
	* with the meta-attribute version of the specified name and value if it does
	* not already exist and if the name does not appear to be cluster-internal.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in,out] user_data XML node
	*/
	void
	hash2metafield(gpointer key, gpointer value, gpointer user_data)
	{
	char *crm_name = NULL;

	if (key == NULL \|\| value == NULL) {
	return;
	}

	/* Filter out cluster-generated attributes that contain a '#' or ':'
	* (like fail-count and last-failure).
	*/
	for (crm_name = key; *crm_name; ++crm_name) {
	if ((crm_name == '#') \|\| (crm_name == ':')) {
	return;
	}
	}

	crm_name = crm_meta_name(key);
	hash2field(crm_name, value, user_data);
	free(crm_name);
	}

	// nvpair handling

	/*!
	* \brief Create an XML name/value pair
	*
	* \param[in,out] parent If not \c NULL, make new XML node a child of this one
	* \param[in] id Set this as XML ID (or NULL to auto-generate)
	* \param[in] name Name to use
	* \param[in] value Value to use
	*
	* \return New XML object on success, \c NULL otherwise
	*/
	xmlNode *
	crm_create_nvpair_xml(xmlNode parent, const char id, const char *name,
	const char *value)
	{
	xmlNode *nvp;

	/* id can be NULL so we auto-generate one, and name can be NULL if this
	* will be used to delete a name/value pair by ID, but both can't be NULL
	*/
	CRM_CHECK(id \|\| name, return NULL);

	nvp = create_xml_node(parent, PCMK_XE_NVPAIR);
	CRM_CHECK(nvp, return NULL);

	if (id) {
	crm_xml_add(nvp, PCMK_XA_ID, id);
	} else {
	crm_xml_set_id(nvp, "%s-%s",
	pcmk__s(pcmk__xe_id(parent), PCMK_XE_NVPAIR), name);
	}
	crm_xml_add(nvp, PCMK_XA_NAME, name);
	crm_xml_add(nvp, PCMK_XA_VALUE, value);
	return nvp;
	}

	/*!
	* \brief Add XML nvpair element based on hash table entry
	*
	* Suitable for \c g_hash_table_foreach(), this function takes a hash table key
	* and value, with an XML node passed as the user data, and adds an \c nvpair
	* XML element with the specified name and value.
	*
	* \param[in] key Key of hash table entry
	* \param[in] value Value of hash table entry
	* \param[in,out] user_data XML node
	*/
	void
	hash2nvpair(gpointer key, gpointer value, gpointer user_data)
	{
	const char *name = key;
	const char *s_value = value;
	xmlNode *xml_node = user_data;

	crm_create_nvpair_xml(xml_node, name, name, s_value);
	crm_trace("dumped: name=%s value=%s", name, s_value);
	}

	/*!
	* \brief Retrieve XML attributes as a hash table
	*
	* Given an XML element, this will look for any \<attributes> element child,
	* creating a hash table of (newly allocated string) name/value pairs taken
	* first from the attributes element's NAME=VALUE XML attributes, and then
	* from any \<param name=NAME value=VALUE> children of attributes.
	*
	* \param[in] XML node to parse
	*
	* \return Hash table with name/value pairs
	* \note It is the caller's responsibility to free the result using
	* \c g_hash_table_destroy().
	*/
	GHashTable *
	xml2list(const xmlNode *parent)
	{
	xmlNode *child = NULL;
	xmlAttrPtr pIter = NULL;
	xmlNode *nvpair_list = NULL;
	GHashTable *nvpair_hash = pcmk__strkey_table(free, free);

	CRM_CHECK(parent != NULL, return nvpair_hash);

	nvpair_list = find_xml_node(parent, PCMK__XE_ATTRIBUTES, FALSE);
	if (nvpair_list == NULL) {
	crm_trace("No attributes in %s", parent->name);
	crm_log_xml_trace(parent, "No attributes for resource op");
	}

	crm_log_xml_trace(nvpair_list, "Unpacking");

	for (pIter = pcmk__xe_first_attr(nvpair_list); pIter != NULL;
	pIter = pIter->next) {

	const char p_name = (const char )pIter->name;
	const char *p_value = pcmk__xml_attr_value(pIter);

	crm_trace("Added %s=%s", p_name, p_value);

	pcmk__insert_dup(nvpair_hash, p_name, p_value);
	}

	for (child = pcmk__xml_first_child(nvpair_list); child != NULL;
	child = pcmk__xml_next(child)) {

	if (strcmp((const char *) child->name, PCMK__XE_PARAM) == 0) {
	const char *key = crm_element_value(child, PCMK_XA_NAME);
	const char *value = crm_element_value(child, PCMK_XA_VALUE);

	crm_trace("Added %s=%s", key, value);
	if (key != NULL && value != NULL) {
	pcmk__insert_dup(nvpair_hash, key, value);
	}
	}
	}

	return nvpair_hash;
	}

	void
	pcmk__xe_set_bool_attr(xmlNodePtr node, const char *name, bool value)
	{
	crm_xml_add(node, name, pcmk__btoa(value));
	}

	int
	pcmk__xe_get_bool_attr(const xmlNode node, const char name, bool *value)
	{
	const char *xml_value = NULL;
	int ret, rc;

	if (node == NULL) {
	return ENODATA;
	} else if (name == NULL \|\| value == NULL) {
	return EINVAL;
	}

	xml_value = crm_element_value(node, name);

	if (xml_value == NULL) {
	return ENODATA;
	}

	rc = crm_str_to_boolean(xml_value, &ret);
	if (rc == 1) {
	*value = ret;
	return pcmk_rc_ok;
	} else {
	return pcmk_rc_bad_input;
	}
	}

	bool
	pcmk__xe_attr_is_true(const xmlNode node, const char name)
	{
	bool value = false;
	int rc;

	rc = pcmk__xe_get_bool_attr(node, name, &value);
	return rc == pcmk_rc_ok && value == true;
	}

	// Meta-attribute handling

	/*!
	* \brief Get the environment variable equivalent of a meta-attribute name
	*
	* \param[in] attr_name Name of meta-attribute
	*
	* \return Newly allocated string for \p attr_name with "CRM_meta_" prefix and
	* underbars instead of dashes
	* \note This asserts on an invalid argument or memory allocation error, so
	* callers can assume the result is non-NULL. The caller is responsible
	* for freeing the result using free().
	*/
	char *
	crm_meta_name(const char *attr_name)
	{
	char *env_name = NULL;

	CRM_ASSERT(!pcmk__str_empty(attr_name));

	env_name = crm_strdup_printf(CRM_META "_%s", attr_name);
	for (char c = env_name; c != '\0'; ++c) {
	if (*c == '-') {
	*c = '_';
	}
	}
	return env_name;
	}

	/*!
	* \brief Get the value of a meta-attribute
	*
	* Get the value of a meta-attribute from a hash table whose keys are
	* meta-attribute environment variable names (as crm_meta_name() would
	* create, like pcmk__graph_action_t:params, not pcmk_resource_t:meta).
	*
	* \param[in] meta Hash table of meta-attributes
	* \param[in] attr_name Name of meta-attribute to get
	*
	* \return Value of given meta-attribute
	*/
	const char *
	crm_meta_value(GHashTable meta, const char attr_name)
	{
	if ((meta != NULL) && (attr_name != NULL)) {
	char *key = crm_meta_name(attr_name);
	const char *value = g_hash_table_lookup(meta, key);

	free(key);
	return value;
	}
	return NULL;
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/common/util_compat.h>

	int
	pcmk_scan_nvpair(const char input, char name, char *value)
	{
	return pcmk__scan_nvpair(input, name, value);
	}

	char *
	pcmk_format_nvpair(const char name, const char value,
	const char *units)
	{
	return pcmk__format_nvpair(name, value, units);
	}

	char *
	pcmk_format_named_time(const char *name, time_t epoch_time)
	{
	char *now_s = pcmk__epoch2str(&epoch_time, 0);
	char *result = crm_strdup_printf("%s=\"%s\"", name, pcmk__s(now_s, ""));

	free(now_s);
	return result;
	}

	const char *
	crm_xml_replace(xmlNode node, const char name, const char *value)
	{
	bool dirty = FALSE;
	xmlAttr *attr = NULL;
	const char *old_value = NULL;

	CRM_CHECK(node != NULL, return NULL);
	CRM_CHECK(name != NULL && name[0] != 0, return NULL);

	old_value = crm_element_value(node, name);

	/* Could be re-setting the same value */
	CRM_CHECK(old_value != value, return value);

	if (pcmk__check_acl(node, name, pcmk__xf_acl_write) == FALSE) {
	/* Create a fake object linked to doc->_private instead? */
	crm_trace("Cannot replace %s=%s to %s", name, value, node->name);
	return NULL;

	} else if (old_value && !value) {
	xml_remove_prop(node, name);
	return NULL;
	}

	if (pcmk__tracking_xml_changes(node, FALSE)) {
	if (!old_value \|\| !value \|\| !strcmp(old_value, value)) {
	dirty = TRUE;
	}
	}

	attr = xmlSetProp(node, (pcmkXmlStr) name, (pcmkXmlStr) value);
	if (dirty) {
	pcmk__mark_xml_attr_dirty(attr);
	}
	CRM_CHECK(attr && attr->children && attr->children->content, return NULL);
	return (char *) attr->children->content;
	}

	// LCOV_EXCL_STOP
	// End deprecated API
	diff --git a/lib/common/tests/nvpair/Makefile.am b/lib/common/tests/nvpair/Makefile.am
	index 837fba053e..9f762d4853 100644
	--- a/lib/common/tests/nvpair/Makefile.am
	+++ b/lib/common/tests/nvpair/Makefile.am
	@@ -1,20 +1,21 @@
	#
	# Copyright 2021-2024 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 $(top_srcdir)/mk/tap.mk
	include $(top_srcdir)/mk/unittest.mk

	# Add "_test" to the end of all test program names to simplify .gitignore.
	check_PROGRAMS = crm_meta_name_test \
	crm_meta_value_test \
	pcmk__xe_attr_is_true_test \
	+ pcmk__xe_get_datetime_test \
	pcmk__xe_get_bool_attr_test \
	pcmk__xe_set_bool_attr_test

	TESTS = $(check_PROGRAMS)
	diff --git a/lib/common/tests/nvpair/pcmk__xe_get_datetime_test.c b/lib/common/tests/nvpair/pcmk__xe_get_datetime_test.c
	new file mode 100644
	index 0000000000..9542306b42
	--- /dev/null
	+++ b/lib/common/tests/nvpair/pcmk__xe_get_datetime_test.c
	@@ -0,0 +1,108 @@
	+/*
	+ * Copyright 2024 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 <errno.h>
	+#include <libxml/tree.h>
	+
	+#include <crm/common/unittest_internal.h>
	+
	+#include <crm/common/iso8601.h>
	+#include <crm/common/xml.h>
	+#include <crm/common/nvpair_internal.h>
	+
	+#define REFERENCE_ISO8601 "2024-001"
	+#define ATTR_PRESENT "start"
	+#define ATTR_MISSING "end"
	+#define REFERENCE_XML "<date_expression id=\"id1\" " \
	+ ATTR_PRESENT "=\"" REFERENCE_ISO8601 "\"" \
	+ " operation=\"gt\">"
	+#define BAD_XML "<date_expression id=\"id1\" " \
	+ ATTR_PRESENT "=\"not_a_time\"" \
	+ " operation=\"gt\">"
	+
	+static void
	+null_invalid(void **state)
	+{
	+ xmlNode *xml = string2xml(REFERENCE_XML);
	+ crm_time_t *t = NULL;
	+
	+ assert_int_equal(pcmk__xe_get_datetime(NULL, NULL, NULL), EINVAL);
	+ assert_int_equal(pcmk__xe_get_datetime(xml, NULL, NULL), EINVAL);
	+ assert_int_equal(pcmk__xe_get_datetime(xml, ATTR_PRESENT, NULL), EINVAL);
	+ assert_int_equal(pcmk__xe_get_datetime(xml, NULL, &t), EINVAL);
	+ assert_null(t);
	+ assert_int_equal(pcmk__xe_get_datetime(NULL, ATTR_PRESENT, NULL), EINVAL);
	+ assert_int_equal(pcmk__xe_get_datetime(NULL, ATTR_PRESENT, &t), EINVAL);
	+ assert_null(t);
	+ assert_int_equal(pcmk__xe_get_datetime(NULL, NULL, &t), EINVAL);
	+ assert_null(t);
	+
	+ free_xml(xml);
	+}
	+
	+static void
	+nonnull_time_invalid(void **state)
	+{
	+ xmlNode *xml = string2xml(REFERENCE_XML);
	+ crm_time_t *t = crm_time_new_undefined();
	+
	+ assert_int_equal(pcmk__xe_get_datetime(xml, ATTR_PRESENT, &t), EINVAL);
	+
	+ crm_time_free(t);
	+ free_xml(xml);
	+}
	+
	+static void
	+attr_missing(void **state)
	+{
	+ xmlNode *xml = string2xml(REFERENCE_XML);
	+ crm_time_t *t = NULL;
	+
	+ assert_int_equal(pcmk__xe_get_datetime(xml, ATTR_MISSING, &t), pcmk_rc_ok);
	+ assert_null(t);
	+
	+ free_xml(xml);
	+}
	+
	+static void
	+attr_valid(void **state)
	+{
	+ xmlNode *xml = string2xml(REFERENCE_XML);
	+ crm_time_t *t = NULL;
	+ crm_time_t *reference = crm_time_new(REFERENCE_ISO8601);
	+
	+ assert_int_equal(pcmk__xe_get_datetime(xml, ATTR_PRESENT, &t), pcmk_rc_ok);
	+ assert_int_equal(crm_time_compare(t, reference), 0);
	+
	+ crm_time_free(t);
	+ crm_time_free(reference);
	+ free_xml(xml);
	+}
	+
	+static void
	+attr_invalid(void **state)
	+{
	+ xmlNode *xml = string2xml(BAD_XML);
	+ crm_time_t *t = NULL;
	+
	+ assert_int_equal(pcmk__xe_get_datetime(xml, ATTR_PRESENT, &t),
	+ pcmk_rc_unpack_error);
	+ assert_null(t);
	+
	+ free_xml(xml);
	+}
	+
	+PCMK__UNIT_TEST(NULL, NULL,
	+ cmocka_unit_test(null_invalid),
	+ cmocka_unit_test(nonnull_time_invalid),
	+ cmocka_unit_test(attr_missing),
	+ cmocka_unit_test(attr_valid),
	+ cmocka_unit_test(attr_invalid))
	diff --git a/lib/pengine/rules.c b/lib/pengine/rules.c
	index 05c27e06b7..5f862dee29 100644
	--- a/lib/pengine/rules.c
	+++ b/lib/pengine/rules.c
	@@ -1,1091 +1,1085 @@
	/*
	* 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 <glib.h>

	#include <crm/crm.h>
	#include <crm/common/xml.h>
	#include <crm/pengine/rules.h>

	#include <crm/common/iso8601_internal.h>
	+#include <crm/common/nvpair_internal.h>
	#include <crm/common/xml_internal.h>
	#include <crm/pengine/internal.h>
	#include <crm/pengine/rules_internal.h>

	#include <sys/types.h>
	#include <regex.h>
	#include <ctype.h>

	CRM_TRACE_INIT_DATA(pe_rules);

	/*!
	* \brief Evaluate any rules contained by given XML element
	*
	* \param[in,out] xml XML element to check for rules
	* \param[in] node_hash Node attributes to use to evaluate expressions
	* \param[in] now Time to use when evaluating expressions
	* \param[out] next_change If not NULL, set to when evaluation will change
	*
	* \return TRUE if no rules, or any of rules present is in effect, else FALSE
	*/
	gboolean
	pe_evaluate_rules(xmlNode ruleset, GHashTable node_hash, crm_time_t *now,
	crm_time_t *next_change)
	{
	pe_rule_eval_data_t rule_data = {
	.node_hash = node_hash,
	.now = now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	return pe_eval_rules(ruleset, &rule_data, next_change);
	}

	gboolean
	pe_test_rule(xmlNode rule, GHashTable node_hash, enum rsc_role_e role,
	crm_time_t now, crm_time_t next_change,
	pe_match_data_t *match_data)
	{
	pe_rule_eval_data_t rule_data = {
	.node_hash = node_hash,
	.now = now,
	.match_data = match_data,
	.rsc_data = NULL,
	.op_data = NULL
	};

	return pe_eval_expr(rule, &rule_data, next_change);
	}

	/*!
	* \brief Evaluate one rule subelement (pass/fail)
	*
	* A rule element may contain another rule, a node attribute expression, or a
	* date expression. Given any one of those, evaluate it and return whether it
	* passed.
	*
	* \param[in,out] expr Rule subelement XML
	* \param[in] node_hash Node attributes to use when evaluating expression
	* \param[in] role Ignored (deprecated)
	* \param[in] now Time to use when evaluating expression
	* \param[out] next_change If not NULL, set to when evaluation will change
	* \param[in] match_data If not NULL, resource back-references and params
	*
	* \return TRUE if expression is in effect under given conditions, else FALSE
	*/
	gboolean
	pe_test_expression(xmlNode expr, GHashTable node_hash, enum rsc_role_e role,
	crm_time_t now, crm_time_t next_change,
	pe_match_data_t *match_data)
	{
	pe_rule_eval_data_t rule_data = {
	.node_hash = node_hash,
	.now = now,
	.match_data = match_data,
	.rsc_data = NULL,
	.op_data = NULL
	};

	return pe_eval_subexpr(expr, &rule_data, next_change);
	}

	static crm_time_t *
	parse_xml_duration(const crm_time_t start, const xmlNode duration_spec)
	{
	crm_time_t *end = pcmk_copy_time(start);

	pcmk__add_time_from_xml(end, pcmk__time_years, duration_spec);
	pcmk__add_time_from_xml(end, pcmk__time_months, duration_spec);
	pcmk__add_time_from_xml(end, pcmk__time_weeks, duration_spec);
	pcmk__add_time_from_xml(end, pcmk__time_days, duration_spec);
	pcmk__add_time_from_xml(end, pcmk__time_hours, duration_spec);
	pcmk__add_time_from_xml(end, pcmk__time_minutes, duration_spec);
	pcmk__add_time_from_xml(end, pcmk__time_seconds, duration_spec);
	return end;
	}

	// Information about a block of nvpair elements
	typedef struct sorted_set_s {
	int score; // This block's score for sorting
	const char *name; // This block's ID
	const char *special_name; // ID that should sort first
	xmlNode *attr_set; // This block
	gboolean overwrite; // Whether existing values will be overwritten
	} sorted_set_t;

	static gint
	sort_pairs(gconstpointer a, gconstpointer b)
	{
	const sorted_set_t *pair_a = a;
	const sorted_set_t *pair_b = b;

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

	if (pcmk__str_eq(pair_a->name, pair_a->special_name, pcmk__str_casei)) {
	return -1;

	} else if (pcmk__str_eq(pair_b->name, pair_a->special_name, pcmk__str_casei)) {
	return 1;
	}

	/* If we're overwriting values, we want lowest score first, so the highest
	* score is processed last; if we're not overwriting values, we want highest
	* score first, so nothing else overwrites it.
	*/
	if (pair_a->score < pair_b->score) {
	return pair_a->overwrite? -1 : 1;
	} else if (pair_a->score > pair_b->score) {
	return pair_a->overwrite? 1 : -1;
	}
	return 0;
	}

	static void
	populate_hash(xmlNode * nvpair_list, GHashTable * hash, gboolean overwrite, xmlNode * top)
	{
	const char *name = NULL;
	const char *value = NULL;
	const char *old_value = NULL;
	xmlNode *list = nvpair_list;
	xmlNode *an_attr = NULL;

	if (pcmk__xe_is(list->children, PCMK__XE_ATTRIBUTES)) {
	list = list->children;
	}

	for (an_attr = pcmk__xe_first_child(list); an_attr != NULL;
	an_attr = pcmk__xe_next(an_attr)) {

	if (pcmk__xe_is(an_attr, PCMK_XE_NVPAIR)) {
	xmlNode *ref_nvpair = expand_idref(an_attr, top);

	name = crm_element_value(an_attr, PCMK_XA_NAME);
	if ((name == NULL) && (ref_nvpair != NULL)) {
	name = crm_element_value(ref_nvpair, PCMK_XA_NAME);
	}

	value = crm_element_value(an_attr, PCMK_XA_VALUE);
	if ((value == NULL) && (ref_nvpair != NULL)) {
	value = crm_element_value(ref_nvpair, PCMK_XA_VALUE);
	}

	if (name == NULL \|\| value == NULL) {
	continue;
	}

	old_value = g_hash_table_lookup(hash, name);

	if (pcmk__str_eq(value, "#default", pcmk__str_casei)) {
	if (old_value) {
	crm_trace("Letting %s default (removing explicit value \"%s\")",
	name, value);
	g_hash_table_remove(hash, name);
	}
	continue;

	} else if (old_value == NULL) {
	crm_trace("Setting %s=\"%s\"", name, value);
	pcmk__insert_dup(hash, name, value);

	} else if (overwrite) {
	crm_trace("Setting %s=\"%s\" (overwriting old value \"%s\")",
	name, value, old_value);
	pcmk__insert_dup(hash, name, value);
	}
	}
	}
	}

	typedef struct unpack_data_s {
	gboolean overwrite;
	void *hash;
	crm_time_t *next_change;
	const pe_rule_eval_data_t *rule_data;
	xmlNode *top;
	} unpack_data_t;

	static void
	unpack_attr_set(gpointer data, gpointer user_data)
	{
	sorted_set_t *pair = data;
	unpack_data_t *unpack_data = user_data;

	if (!pe_eval_rules(pair->attr_set, unpack_data->rule_data,
	unpack_data->next_change)) {
	return;
	}

	crm_trace("Adding attributes from %s (score %d) %s overwrite",
	pair->name, pair->score,
	(unpack_data->overwrite? "with" : "without"));
	populate_hash(pair->attr_set, unpack_data->hash, unpack_data->overwrite, unpack_data->top);
	}

	/*!
	* \internal
	* \brief Create a sorted list of nvpair blocks
	*
	* \param[in,out] top XML document root (used to expand id-ref's)
	* \param[in] xml_obj XML element containing blocks of nvpair elements
	* \param[in] set_name If not NULL, only get blocks of this element
	* \param[in] always_first If not NULL, sort block with this ID as first
	*
	* \return List of sorted_set_t entries for nvpair blocks
	*/
	static GList *
	make_pairs(xmlNode top, const xmlNode xml_obj, const char *set_name,
	const char *always_first, gboolean overwrite)
	{
	GList *unsorted = NULL;

	if (xml_obj == NULL) {
	return NULL;
	}
	for (xmlNode *attr_set = pcmk__xe_first_child(xml_obj); attr_set != NULL;
	attr_set = pcmk__xe_next(attr_set)) {

	if ((set_name == NULL) \|\| pcmk__xe_is(attr_set, set_name)) {
	const char *score = NULL;
	sorted_set_t *pair = NULL;
	xmlNode *expanded_attr_set = expand_idref(attr_set, top);

	if (expanded_attr_set == NULL) {
	continue; // Not possible with schema validation enabled
	}

	pair = calloc(1, sizeof(sorted_set_t));
	pair->name = pcmk__xe_id(expanded_attr_set);
	pair->special_name = always_first;
	pair->attr_set = expanded_attr_set;
	pair->overwrite = overwrite;

	score = crm_element_value(expanded_attr_set, PCMK_XA_SCORE);
	pair->score = char2score(score);

	unsorted = g_list_prepend(unsorted, pair);
	}
	}
	return g_list_sort(unsorted, sort_pairs);
	}

	/*!
	* \brief Extract nvpair blocks contained by an XML element into a hash table
	*
	* \param[in,out] top XML document root (used to expand id-ref's)
	* \param[in] xml_obj XML element containing blocks of nvpair elements
	* \param[in] set_name If not NULL, only use blocks of this element
	* \param[in] rule_data Matching parameters to use when unpacking
	* \param[out] hash Where to store extracted name/value pairs
	* \param[in] always_first If not NULL, process block with this ID first
	* \param[in] overwrite Whether to replace existing values with same name
	* \param[out] next_change If not NULL, set to when evaluation will change
	*/
	void
	pe_eval_nvpairs(xmlNode top, const xmlNode xml_obj, const char *set_name,
	const pe_rule_eval_data_t rule_data, GHashTable hash,
	const char *always_first, gboolean overwrite,
	crm_time_t *next_change)
	{
	GList *pairs = make_pairs(top, xml_obj, set_name, always_first, overwrite);

	if (pairs) {
	unpack_data_t data = {
	.hash = hash,
	.overwrite = overwrite,
	.next_change = next_change,
	.top = top,
	.rule_data = rule_data
	};

	g_list_foreach(pairs, unpack_attr_set, &data);
	g_list_free_full(pairs, free);
	}
	}

	/*!
	* \brief Extract nvpair blocks contained by an XML element into a hash table
	*
	* \param[in,out] top XML document root (used to expand id-ref's)
	* \param[in] xml_obj XML element containing blocks of nvpair elements
	* \param[in] set_name Element name to identify nvpair blocks
	* \param[in] node_hash Node attributes to use when evaluating rules
	* \param[out] hash Where to store extracted name/value pairs
	* \param[in] always_first If not NULL, process block with this ID first
	* \param[in] overwrite Whether to replace existing values with same name
	* \param[in] now Time to use when evaluating rules
	* \param[out] next_change If not NULL, set to when evaluation will change
	*/
	void
	pe_unpack_nvpairs(xmlNode top, const xmlNode xml_obj, const char *set_name,
	GHashTable node_hash, GHashTable hash,
	const char *always_first, gboolean overwrite,
	crm_time_t now, crm_time_t next_change)
	{
	pe_rule_eval_data_t rule_data = {
	.node_hash = node_hash,
	.now = now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	pe_eval_nvpairs(top, xml_obj, set_name, &rule_data, hash,
	always_first, overwrite, next_change);
	}

	/*!
	* \brief Expand any regular expression submatches (%0-%9) in a string
	*
	* \param[in] string String possibly containing submatch variables
	* \param[in] match_data If not NULL, regular expression matches
	*
	* \return Newly allocated string identical to \p string with submatches
	* expanded, or NULL if there were no matches
	*/
	char *
	pe_expand_re_matches(const char string, const pe_re_match_data_t match_data)
	{
	size_t len = 0;
	int i;
	const char p, last_match_index;
	char p_dst, result = NULL;

	if (pcmk__str_empty(string) \|\| !match_data) {
	return NULL;
	}

	p = last_match_index = string;

	while (*p) {
	if (p == '%' && (p + 1) && isdigit(*(p + 1))) {
	i = *(p + 1) - '0';
	if (match_data->nregs >= i && match_data->pmatch[i].rm_so != -1 &&
	match_data->pmatch[i].rm_eo > match_data->pmatch[i].rm_so) {
	len += p - last_match_index + (match_data->pmatch[i].rm_eo - match_data->pmatch[i].rm_so);
	last_match_index = p + 2;
	}
	p++;
	}
	p++;
	}
	len += p - last_match_index + 1;

	/* FIXME: Excessive? */
	if (len - 1 <= 0) {
	return NULL;
	}

	p_dst = result = calloc(1, len);
	p = string;

	while (*p) {
	if (p == '%' && (p + 1) && isdigit(*(p + 1))) {
	i = *(p + 1) - '0';
	if (match_data->nregs >= i && match_data->pmatch[i].rm_so != -1 &&
	match_data->pmatch[i].rm_eo > match_data->pmatch[i].rm_so) {
	/* rm_eo can be equal to rm_so, but then there is nothing to do */
	int match_len = match_data->pmatch[i].rm_eo - match_data->pmatch[i].rm_so;
	memcpy(p_dst, match_data->string + match_data->pmatch[i].rm_so, match_len);
	p_dst += match_len;
	}
	p++;
	} else {
	(p_dst) = (p);
	p_dst++;
	}
	p++;
	}

	return result;
	}

	/*!
	* \brief Evaluate rules
	*
	* \param[in,out] ruleset XML possibly containing rule sub-elements
	* \param[in] rule_data
	* \param[out] next_change If not NULL, set to when evaluation will change
	*
	* \return TRUE if there are no rules or
	*/
	gboolean
	pe_eval_rules(xmlNode ruleset, const pe_rule_eval_data_t rule_data,
	crm_time_t *next_change)
	{
	// If there are no rules, pass by default
	gboolean ruleset_default = TRUE;

	for (xmlNode *rule = first_named_child(ruleset, PCMK_XE_RULE);
	rule != NULL; rule = crm_next_same_xml(rule)) {

	ruleset_default = FALSE;
	if (pe_eval_expr(rule, rule_data, next_change)) {
	/* Only the deprecated PCMK__XE_LIFETIME element of location
	* constraints may contain more than one rule at the top level --
	* the schema limits a block of nvpairs to a single top-level rule.
	* So, this effectively means that a lifetime is active if any rule
	* it contains is active.
	*/
	return TRUE;
	}
	}

	return ruleset_default;
	}

	/*!
	* \brief Evaluate all of a rule's expressions
	*
	* \param[in,out] rule XML containing a rule definition or its id-ref
	* \param[in] rule_data Matching parameters to check against rule
	* \param[out] next_change If not NULL, set to when evaluation will change
	*
	* \return TRUE if \p rule_data passes \p rule, otherwise FALSE
	*/
	gboolean
	pe_eval_expr(xmlNode rule, const pe_rule_eval_data_t rule_data,
	crm_time_t *next_change)
	{
	xmlNode *expr = NULL;
	gboolean test = TRUE;
	gboolean empty = TRUE;
	gboolean passed = TRUE;
	gboolean do_and = TRUE;
	const char *value = NULL;

	rule = expand_idref(rule, NULL);
	if (rule == NULL) {
	return FALSE; // Not possible with schema validation enabled
	}

	value = crm_element_value(rule, PCMK_XA_BOOLEAN_OP);
	if (pcmk__str_eq(value, PCMK_VALUE_OR, pcmk__str_casei)) {
	do_and = FALSE;
	passed = FALSE;

	} else if (!pcmk__str_eq(value, PCMK_VALUE_AND,
	pcmk__str_null_matches\|pcmk__str_casei)) {
	pcmk__config_warn("Rule %s has invalid " PCMK_XA_BOOLEAN_OP
	" value '%s', using default ('" PCMK_VALUE_AND "')",
	pcmk__xe_id(rule), value);
	}

	crm_trace("Testing rule %s", pcmk__xe_id(rule));
	for (expr = pcmk__xe_first_child(rule); expr != NULL;
	expr = pcmk__xe_next(expr)) {

	test = pe_eval_subexpr(expr, rule_data, next_change);
	empty = FALSE;

	if (test && do_and == FALSE) {
	crm_trace("Expression %s/%s passed",
	pcmk__xe_id(rule), pcmk__xe_id(expr));
	return TRUE;

	} else if (test == FALSE && do_and) {
	crm_trace("Expression %s/%s failed",
	pcmk__xe_id(rule), pcmk__xe_id(expr));
	return FALSE;
	}
	}

	if (empty) {
	pcmk__config_err("Ignoring rule %s because it contains no expressions",
	pcmk__xe_id(rule));
	}

	crm_trace("Rule %s %s", pcmk__xe_id(rule), passed ? "passed" : "failed");
	return passed;
	}

	/*!
	* \brief Evaluate a single rule expression, including any subexpressions
	*
	* \param[in,out] expr XML containing a rule expression
	* \param[in] rule_data Matching parameters to check against expression
	* \param[out] next_change If not NULL, set to when evaluation will change
	*
	* \return TRUE if \p rule_data passes \p expr, otherwise FALSE
	*/
	gboolean
	pe_eval_subexpr(xmlNode expr, const pe_rule_eval_data_t rule_data,
	crm_time_t *next_change)
	{
	gboolean accept = FALSE;
	const char *uname = NULL;

	switch (pcmk__expression_type(expr)) {
	case pcmk__subexpr_rule:
	accept = pe_eval_expr(expr, rule_data, next_change);
	break;
	case pcmk__subexpr_attribute:
	case pcmk__subexpr_location:
	/* these expressions can never succeed if there is
	* no node to compare with
	*/
	if (rule_data->node_hash != NULL) {
	accept = pe__eval_attr_expr(expr, rule_data);
	}
	break;

	case pcmk__subexpr_datetime:
	switch (pe__eval_date_expr(expr, rule_data->now, next_change)) {
	case pcmk_rc_within_range:
	case pcmk_rc_ok:
	accept = TRUE;
	break;

	default:
	accept = FALSE;
	break;
	}
	break;

	case pcmk__subexpr_resource:
	accept = pe__eval_rsc_expr(expr, rule_data);
	break;

	case pcmk__subexpr_operation:
	accept = pe__eval_op_expr(expr, rule_data);
	break;

	default:
	CRM_CHECK(FALSE /* bad type */ , return FALSE);
	accept = FALSE;
	}
	if (rule_data->node_hash) {
	uname = g_hash_table_lookup(rule_data->node_hash, CRM_ATTR_UNAME);
	}

	crm_trace("Expression %s %s on %s",
	pcmk__xe_id(expr), (accept? "passed" : "failed"),
	pcmk__s(uname, "all nodes"));
	return accept;
	}

	/*!
	* \internal
	* \brief Compare two values in a rule's node attribute expression
	*
	* \param[in] l_val Value on left-hand side of comparison
	* \param[in] r_val Value on right-hand side of comparison
	* \param[in] type How to interpret the values (allowed values:
	* \c PCMK_VALUE_STRING, \c PCMK_VALUE_INTEGER,
	* \c PCMK_VALUE_NUMBER, \c PCMK_VALUE_VERSION, \c NULL)
	* \param[in] op Type of comparison
	*
	* \return -1 if <tt>(l_val < r_val)</tt>,
	* 0 if <tt>(l_val == r_val)</tt>,
	* 1 if <tt>(l_val > r_val)</tt>
	*/
	static int
	compare_attr_expr_vals(const char l_val, const char r_val, const char *type,
	const char *op)
	{
	int cmp = 0;

	if (l_val != NULL && r_val != NULL) {
	if (type == NULL) {
	if (pcmk__strcase_any_of(op,
	PCMK_VALUE_LT, PCMK_VALUE_LTE,
	PCMK_VALUE_GT, PCMK_VALUE_GTE, NULL)) {
	if (pcmk__char_in_any_str('.', l_val, r_val, NULL)) {
	type = PCMK_VALUE_NUMBER;
	} else {
	type = PCMK_VALUE_INTEGER;
	}

	} else {
	type = PCMK_VALUE_STRING;
	}
	crm_trace("Defaulting to %s based comparison for '%s' op", type, op);
	}

	if (pcmk__str_eq(type, PCMK_VALUE_STRING, pcmk__str_casei)) {
	cmp = strcasecmp(l_val, r_val);

	} else if (pcmk__str_eq(type, PCMK_VALUE_INTEGER, pcmk__str_casei)) {
	long long l_val_num;
	int rc1 = pcmk__scan_ll(l_val, &l_val_num, 0LL);

	long long r_val_num;
	int rc2 = pcmk__scan_ll(r_val, &r_val_num, 0LL);

	if ((rc1 == pcmk_rc_ok) && (rc2 == pcmk_rc_ok)) {
	if (l_val_num < r_val_num) {
	cmp = -1;
	} else if (l_val_num > r_val_num) {
	cmp = 1;
	} else {
	cmp = 0;
	}

	} else {
	crm_debug("Integer parse error. Comparing %s and %s as strings",
	l_val, r_val);
	cmp = compare_attr_expr_vals(l_val, r_val, PCMK_VALUE_STRING,
	op);
	}

	} else if (pcmk__str_eq(type, PCMK_VALUE_NUMBER, pcmk__str_casei)) {
	double l_val_num;
	double r_val_num;

	int rc1 = pcmk__scan_double(l_val, &l_val_num, NULL, NULL);
	int rc2 = pcmk__scan_double(r_val, &r_val_num, NULL, NULL);

	if (rc1 == pcmk_rc_ok && rc2 == pcmk_rc_ok) {
	if (l_val_num < r_val_num) {
	cmp = -1;
	} else if (l_val_num > r_val_num) {
	cmp = 1;
	} else {
	cmp = 0;
	}

	} else {
	crm_debug("Floating-point parse error. Comparing %s and %s as "
	"strings", l_val, r_val);
	cmp = compare_attr_expr_vals(l_val, r_val, PCMK_VALUE_STRING,
	op);
	}

	} else if (pcmk__str_eq(type, PCMK_VALUE_VERSION, pcmk__str_casei)) {
	cmp = compare_version(l_val, r_val);

	}

	} else if (l_val == NULL && r_val == NULL) {
	cmp = 0;
	} else if (r_val == NULL) {
	cmp = 1;
	} else { // l_val == NULL && r_val != NULL
	cmp = -1;
	}

	return cmp;
	}

	/*!
	* \internal
	* \brief Check whether an attribute expression evaluates to \c true
	*
	* \param[in] l_val Value on left-hand side of comparison
	* \param[in] r_val Value on right-hand side of comparison
	* \param[in] type How to interpret the values (allowed values:
	* \c PCMK_VALUE_STRING, \c PCMK_VALUE_INTEGER,
	* \c PCMK_VALUE_NUMBER, \c PCMK_VALUE_VERSION, \c NULL)
	* \param[in] op Type of comparison.
	*
	* \return \c true if expression evaluates to \c true, \c false
	* otherwise
	*/
	static bool
	accept_attr_expr(const char l_val, const char r_val, const char *type,
	const char *op)
	{
	int cmp;

	if (pcmk__str_eq(op, PCMK_VALUE_DEFINED, pcmk__str_casei)) {
	return (l_val != NULL);

	} else if (pcmk__str_eq(op, PCMK_VALUE_NOT_DEFINED, pcmk__str_casei)) {
	return (l_val == NULL);

	}

	cmp = compare_attr_expr_vals(l_val, r_val, type, op);

	if (pcmk__str_eq(op, PCMK_VALUE_EQ, pcmk__str_casei)) {
	return (cmp == 0);

	} else if (pcmk__str_eq(op, PCMK_VALUE_NE, pcmk__str_casei)) {
	return (cmp != 0);

	} else if (l_val == NULL \|\| r_val == NULL) {
	// The comparison is meaningless from this point on
	return false;

	} else if (pcmk__str_eq(op, PCMK_VALUE_LT, pcmk__str_casei)) {
	return (cmp < 0);

	} else if (pcmk__str_eq(op, PCMK_VALUE_LTE, pcmk__str_casei)) {
	return (cmp <= 0);

	} else if (pcmk__str_eq(op, PCMK_VALUE_GT, pcmk__str_casei)) {
	return (cmp > 0);

	} else if (pcmk__str_eq(op, PCMK_VALUE_GTE, pcmk__str_casei)) {
	return (cmp >= 0);
	}

	return false; // Should never reach this point
	}

	/*!
	* \internal
	* \brief Get correct value according to \c PCMK_XA_VALUE_SOURCE
	*
	* \param[in] expr_id Rule expression ID (for logging only)
	* \param[in] value value given in rule expression
	* \param[in] value_source \c PCMK_XA_VALUE_SOURCE given in rule expressions
	* \param[in] match_data If not NULL, resource back-references and params
	*/
	static const char *
	expand_value_source(const char expr_id, const char value,
	const char value_source, const pe_match_data_t match_data)
	{
	GHashTable *table = NULL;

	if (pcmk__str_empty(value)) {
	return NULL; // value_source is irrelevant

	} else if (pcmk__str_eq(value_source, PCMK_VALUE_PARAM, pcmk__str_casei)) {
	table = match_data->params;

	} else if (pcmk__str_eq(value_source, PCMK_VALUE_META, pcmk__str_casei)) {
	table = match_data->meta;

	} else { // literal
	if (!pcmk__str_eq(value_source, PCMK_VALUE_LITERAL,
	pcmk__str_null_matches\|pcmk__str_casei)) {

	pcmk__config_warn("Expression %s has invalid " PCMK_XA_VALUE_SOURCE
	" value '%s', using default "
	"('" PCMK_VALUE_LITERAL "')",
	pcmk__s(expr_id, "without ID"), value_source);
	}
	return value;
	}

	if (table == NULL) {
	return NULL;
	}
	return (const char *) g_hash_table_lookup(table, value);
	}

	/*!
	* \internal
	* \brief Evaluate a node attribute expression based on #uname, #id, #kind,
	* or a generic node attribute
	*
	* \param[in] expr XML of rule expression
	* \param[in] rule_data The match_data and node_hash members are used
	*
	* \return TRUE if rule_data satisfies the expression, FALSE otherwise
	*/
	gboolean
	pe__eval_attr_expr(const xmlNode expr, const pe_rule_eval_data_t rule_data)
	{
	gboolean attr_allocated = FALSE;
	const char *h_val = NULL;

	const char *id = pcmk__xe_id(expr);
	const char *attr = crm_element_value(expr, PCMK_XA_ATTRIBUTE);
	const char *op = crm_element_value(expr, PCMK_XA_OPERATION);
	const char *type = crm_element_value(expr, PCMK_XA_TYPE);
	const char *value = crm_element_value(expr, PCMK_XA_VALUE);
	const char *value_source = crm_element_value(expr, PCMK_XA_VALUE_SOURCE);

	if (attr == NULL) {
	pcmk__config_err("Expression %s invalid: " PCMK_XA_ATTRIBUTE
	" not specified", pcmk__s(id, "without ID"));
	return FALSE;
	} else if (op == NULL) {
	pcmk__config_err("Expression %s invalid: " PCMK_XA_OPERATION
	" not specified", pcmk__s(id, "without ID"));
	return FALSE;
	}

	if (rule_data->match_data != NULL) {
	// Expand any regular expression submatches (%0-%9) in attribute name
	if (rule_data->match_data->re != NULL) {
	char *resolved_attr = pe_expand_re_matches(attr, rule_data->match_data->re);

	if (resolved_attr != NULL) {
	attr = (const char *) resolved_attr;
	attr_allocated = TRUE;
	}
	}

	// Get value appropriate to PCMK_XA_VALUE_SOURCE
	value = expand_value_source(id, value, value_source,
	rule_data->match_data);
	}

	if (rule_data->node_hash != NULL) {
	h_val = (const char *)g_hash_table_lookup(rule_data->node_hash, attr);
	}

	if (attr_allocated) {
	free((char *)attr);
	attr = NULL;
	}

	return accept_attr_expr(h_val, value, type, op);
	}

	/*!
	* \internal
	* \brief Evaluate a date_expression
	*
	* \param[in] expr XML of rule expression
	* \param[in] now Time to use for evaluation
	* \param[out] next_change If not NULL, set to when evaluation will change
	*
	* \return Standard Pacemaker return code
	*/
	int
	pe__eval_date_expr(const xmlNode expr, const crm_time_t now,
	crm_time_t *next_change)
	{
	- crm_time_t *start = NULL;
	- crm_time_t *end = NULL;
	- const char *value = NULL;
	const char *op = crm_element_value(expr, PCMK_XA_OPERATION);

	+ crm_time_t *start = NULL;
	+ crm_time_t *end = NULL;
	xmlNode *duration_spec = NULL;
	xmlNode *date_spec = NULL;

	// "undetermined" will also be returned for parsing errors
	int rc = pcmk_rc_undetermined;

	crm_trace("Testing expression: %s", pcmk__xe_id(expr));

	duration_spec = first_named_child(expr, PCMK_XE_DURATION);
	date_spec = first_named_child(expr, PCMK_XE_DATE_SPEC);

	- value = crm_element_value(expr, PCMK_XA_START);
	- if (value != NULL) {
	- start = crm_time_new(value);
	- }
	- value = crm_element_value(expr, PCMK_XA_END);
	- if (value != NULL) {
	- end = crm_time_new(value);
	- }
	+ pcmk__xe_get_datetime(expr, PCMK_XA_START, &start);
	+ pcmk__xe_get_datetime(expr, PCMK_XA_END, &end);

	if (start != NULL && end == NULL && duration_spec != NULL) {
	end = parse_xml_duration(start, duration_spec);
	}

	if (pcmk__str_eq(op, "in_range", pcmk__str_null_matches \| pcmk__str_casei)) {
	if ((start == NULL) && (end == NULL)) {
	// in_range requires at least one of start or end
	} else if ((start != NULL) && (crm_time_compare(now, start) < 0)) {
	rc = pcmk_rc_before_range;
	pcmk__set_time_if_earlier(next_change, start);
	} else if ((end != NULL) && (crm_time_compare(now, end) > 0)) {
	rc = pcmk_rc_after_range;
	} else {
	rc = pcmk_rc_within_range;
	if (end && next_change) {
	// Evaluation doesn't change until second after end
	crm_time_add_seconds(end, 1);
	pcmk__set_time_if_earlier(next_change, end);
	}
	}

	} else if (pcmk__str_eq(op, PCMK_VALUE_DATE_SPEC, pcmk__str_casei)) {
	rc = pcmk__evaluate_date_spec(date_spec, now);
	// @TODO set next_change appropriately

	} else if (pcmk__str_eq(op, PCMK_VALUE_GT, pcmk__str_casei)) {
	if (start == NULL) {
	// gt requires start
	} else if (crm_time_compare(now, start) > 0) {
	rc = pcmk_rc_within_range;
	} else {
	rc = pcmk_rc_before_range;

	// Evaluation doesn't change until second after start
	crm_time_add_seconds(start, 1);
	pcmk__set_time_if_earlier(next_change, start);
	}

	} else if (pcmk__str_eq(op, PCMK_VALUE_LT, pcmk__str_casei)) {
	if (end == NULL) {
	// lt requires end
	} else if (crm_time_compare(now, end) < 0) {
	rc = pcmk_rc_within_range;
	pcmk__set_time_if_earlier(next_change, end);
	} else {
	rc = pcmk_rc_after_range;
	}
	}

	crm_time_free(start);
	crm_time_free(end);
	return rc;
	}

	gboolean
	pe__eval_op_expr(const xmlNode expr, const pe_rule_eval_data_t rule_data)
	{
	const char *name = crm_element_value(expr, PCMK_XA_NAME);
	const char *interval_s = crm_element_value(expr, PCMK_META_INTERVAL);
	guint interval_ms = 0U;

	crm_trace("Testing op_defaults expression: %s", pcmk__xe_id(expr));

	if (rule_data->op_data == NULL) {
	crm_trace("No operations data provided");
	return FALSE;
	}

	if (pcmk_parse_interval_spec(interval_s, &interval_ms) != pcmk_rc_ok) {
	crm_trace("Could not parse interval: %s", interval_s);
	return FALSE;
	}

	if ((interval_s != NULL) && (interval_ms != rule_data->op_data->interval)) {
	crm_trace("Interval doesn't match: %d != %d",
	interval_ms, rule_data->op_data->interval);
	return FALSE;
	}

	if (!pcmk__str_eq(name, rule_data->op_data->op_name, pcmk__str_none)) {
	crm_trace("Name doesn't match: %s != %s", name, rule_data->op_data->op_name);
	return FALSE;
	}

	return TRUE;
	}

	gboolean
	pe__eval_rsc_expr(const xmlNode expr, const pe_rule_eval_data_t rule_data)
	{
	const char *class = crm_element_value(expr, PCMK_XA_CLASS);
	const char *provider = crm_element_value(expr, PCMK_XA_PROVIDER);
	const char *type = crm_element_value(expr, PCMK_XA_TYPE);

	crm_trace("Testing rsc_defaults expression: %s", pcmk__xe_id(expr));

	if (rule_data->rsc_data == NULL) {
	crm_trace("No resource data provided");
	return FALSE;
	}

	if (class != NULL &&
	!pcmk__str_eq(class, rule_data->rsc_data->standard, pcmk__str_none)) {
	crm_trace("Class doesn't match: %s != %s", class, rule_data->rsc_data->standard);
	return FALSE;
	}

	if ((provider == NULL && rule_data->rsc_data->provider != NULL) \|\|
	(provider != NULL && rule_data->rsc_data->provider == NULL) \|\|
	!pcmk__str_eq(provider, rule_data->rsc_data->provider, pcmk__str_none)) {
	crm_trace("Provider doesn't match: %s != %s", provider, rule_data->rsc_data->provider);
	return FALSE;
	}

	if (type != NULL &&
	!pcmk__str_eq(type, rule_data->rsc_data->agent, pcmk__str_none)) {
	crm_trace("Agent doesn't match: %s != %s", type, rule_data->rsc_data->agent);
	return FALSE;
	}

	return TRUE;
	}

	// Deprecated functions kept only for backward API compatibility
	// LCOV_EXCL_START

	#include <crm/pengine/rules_compat.h>

	gboolean
	test_ruleset(xmlNode ruleset, GHashTable node_hash, crm_time_t *now)
	{
	return pe_evaluate_rules(ruleset, node_hash, now, NULL);
	}

	gboolean
	test_rule(xmlNode * rule, GHashTable * node_hash, enum rsc_role_e role, crm_time_t * now)
	{
	return pe_test_rule(rule, node_hash, role, now, NULL, NULL);
	}

	gboolean
	pe_test_rule_re(xmlNode * rule, GHashTable * node_hash, enum rsc_role_e role, crm_time_t * now, pe_re_match_data_t * re_match_data)
	{
	pe_match_data_t match_data = {
	.re = re_match_data,
	.params = NULL,
	.meta = NULL,
	};
	return pe_test_rule(rule, node_hash, role, now, NULL, &match_data);
	}

	gboolean
	pe_test_rule_full(xmlNode rule, GHashTable node_hash, enum rsc_role_e role,
	crm_time_t now, pe_match_data_t match_data)
	{
	return pe_test_rule(rule, node_hash, role, now, NULL, match_data);
	}

	gboolean
	test_expression(xmlNode * expr, GHashTable * node_hash, enum rsc_role_e role, crm_time_t * now)
	{
	return pe_test_expression(expr, node_hash, role, now, NULL, NULL);
	}

	gboolean
	pe_test_expression_re(xmlNode * expr, GHashTable * node_hash, enum rsc_role_e role, crm_time_t * now, pe_re_match_data_t * re_match_data)
	{
	pe_match_data_t match_data = {
	.re = re_match_data,
	.params = NULL,
	.meta = NULL,
	};
	return pe_test_expression(expr, node_hash, role, now, NULL, &match_data);
	}

	gboolean
	pe_test_expression_full(xmlNode expr, GHashTable node_hash,
	enum rsc_role_e role, crm_time_t *now,
	pe_match_data_t *match_data)
	{
	return pe_test_expression(expr, node_hash, role, now, NULL, match_data);
	}

	void
	unpack_instance_attributes(xmlNode top, xmlNode xml_obj, const char *set_name,
	GHashTable node_hash, GHashTable hash,
	const char *always_first, gboolean overwrite,
	crm_time_t *now)
	{
	pe_rule_eval_data_t rule_data = {
	.node_hash = node_hash,
	.now = now,
	.match_data = NULL,
	.rsc_data = NULL,
	.op_data = NULL
	};

	pe_eval_nvpairs(top, xml_obj, set_name, &rule_data, hash, always_first,
	overwrite, NULL);
	}

	enum expression_type
	find_expression_type(xmlNode *expr)
	{
	return pcmk__expression_type(expr);
	}

	// LCOV_EXCL_STOP
	// End deprecated API
	diff --git a/tools/crm_resource_ban.c b/tools/crm_resource_ban.c
	index 7cc5674463..19e9529ee2 100644
	--- a/tools/crm_resource_ban.c
	+++ b/tools/crm_resource_ban.c
	@@ -1,502 +1,504 @@
	/*
	* 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 General Public License version 2
	* or later (GPLv2+) WITHOUT ANY WARRANTY.
	*/

	#include <crm_internal.h>

	#include <crm_resource.h>

	static char *
	parse_cli_lifetime(pcmk__output_t out, const char move_lifetime)
	{
	char *later_s = NULL;
	crm_time_t *now = NULL;
	crm_time_t *later = NULL;
	crm_time_t *duration = NULL;

	if (move_lifetime == NULL) {
	return NULL;
	}

	duration = crm_time_parse_duration(move_lifetime);
	if (duration == NULL) {
	out->err(out, "Invalid duration specified: %s\n"
	"Please refer to https://en.wikipedia.org/wiki/ISO_8601#Durations "
	"for examples of valid durations", move_lifetime);
	return NULL;
	}

	now = crm_time_new(NULL);
	later = crm_time_add(now, duration);
	if (later == NULL) {
	out->err(out, "Unable to add %s to current time\n"
	"Please report to " PACKAGE_BUGREPORT " as possible bug",
	move_lifetime);
	crm_time_free(now);
	crm_time_free(duration);
	return NULL;
	}

	crm_time_log(LOG_INFO, "now ", now,
	crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	crm_time_log(LOG_INFO, "later ", later,
	crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	crm_time_log(LOG_INFO, "duration", duration, crm_time_log_date \| crm_time_log_timeofday);
	later_s = crm_time_as_string(later, crm_time_log_date \| crm_time_log_timeofday \| crm_time_log_with_timezone);
	out->info(out, "Migration will take effect until: %s", later_s);

	crm_time_free(duration);
	crm_time_free(later);
	crm_time_free(now);
	return later_s;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_ban(pcmk__output_t out, const char rsc_id, const char *host,
	const char move_lifetime, cib_t cib_conn, int cib_options,
	gboolean promoted_role_only, const char *promoted_role)
	{
	char *later_s = NULL;
	int rc = pcmk_rc_ok;
	xmlNode *fragment = NULL;
	xmlNode *location = NULL;

	later_s = parse_cli_lifetime(out, move_lifetime);
	if(move_lifetime && later_s == NULL) {
	return EINVAL;
	}

	fragment = create_xml_node(NULL, PCMK_XE_CONSTRAINTS);

	location = create_xml_node(fragment, PCMK_XE_RSC_LOCATION);
	crm_xml_set_id(location, "cli-ban-%s-on-%s", rsc_id, host);

	out->info(out,
	"WARNING: Creating " PCMK_XE_RSC_LOCATION " constraint '%s' with "
	"a score of " PCMK_VALUE_MINUS_INFINITY " for resource %s on %s."
	"\n\tThis will prevent %s from %s on %s until the constraint is "
	"removed using the clear option or by editing the CIB with an "
	"appropriate tool.\n"
	"\tThis will be the case even if %s is the last node in the "
	"cluster",
	pcmk__xe_id(location), rsc_id, host, rsc_id,
	(promoted_role_only? "being promoted" : "running"), host, host);

	crm_xml_add(location, PCMK_XA_RSC, rsc_id);
	if(promoted_role_only) {
	crm_xml_add(location, PCMK_XA_ROLE, promoted_role);
	} else {
	crm_xml_add(location, PCMK_XA_ROLE, PCMK__ROLE_STARTED);
	}

	if (later_s == NULL) {
	/* Short form */
	crm_xml_add(location, PCMK_XE_NODE, host);
	crm_xml_add(location, PCMK_XA_SCORE, PCMK_VALUE_MINUS_INFINITY);

	} else {
	xmlNode *rule = create_xml_node(location, PCMK_XE_RULE);
	xmlNode *expr = create_xml_node(rule, PCMK_XE_EXPRESSION);

	crm_xml_set_id(rule, "cli-ban-%s-on-%s-rule", rsc_id, host);
	crm_xml_add(rule, PCMK_XA_SCORE, PCMK_VALUE_MINUS_INFINITY);
	crm_xml_add(rule, PCMK_XA_BOOLEAN_OP, PCMK_VALUE_AND);

	crm_xml_set_id(expr, "cli-ban-%s-on-%s-expr", rsc_id, host);
	crm_xml_add(expr, PCMK_XA_ATTRIBUTE, CRM_ATTR_UNAME);
	crm_xml_add(expr, PCMK_XA_OPERATION, PCMK_VALUE_EQ);
	crm_xml_add(expr, PCMK_XA_VALUE, host);
	crm_xml_add(expr, PCMK_XA_TYPE, PCMK_VALUE_STRING);

	expr = create_xml_node(rule, PCMK_XE_DATE_EXPRESSION);
	crm_xml_set_id(expr, "cli-ban-%s-on-%s-lifetime", rsc_id, host);
	crm_xml_add(expr, PCMK_XA_OPERATION, PCMK_VALUE_LT);
	crm_xml_add(expr, PCMK_XA_END, later_s);
	}

	crm_log_xml_notice(fragment, "Modify");
	rc = cib_conn->cmds->modify(cib_conn, PCMK_XE_CONSTRAINTS, fragment,
	cib_options);
	rc = pcmk_legacy2rc(rc);

	free_xml(fragment);
	free(later_s);

	if (rc != pcmk_rc_ok && promoted_role_only && strcmp(promoted_role, PCMK__ROLE_PROMOTED) == 0) {
	int banrc = cli_resource_ban(out, rsc_id, host, move_lifetime,
	cib_conn, cib_options, promoted_role_only,
	PCMK__ROLE_PROMOTED_LEGACY);
	if (banrc == pcmk_rc_ok) {
	rc = banrc;
	}
	}

	return rc;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_prefer(pcmk__output_t out,const char rsc_id, const char *host,
	const char move_lifetime, cib_t cib_conn, int cib_options,
	gboolean promoted_role_only, const char *promoted_role)
	{
	char *later_s = parse_cli_lifetime(out, move_lifetime);
	int rc = pcmk_rc_ok;
	xmlNode *location = NULL;
	xmlNode *fragment = NULL;

	if(move_lifetime && later_s == NULL) {
	return EINVAL;
	}

	if(cib_conn == NULL) {
	free(later_s);
	return ENOTCONN;
	}

	fragment = create_xml_node(NULL, PCMK_XE_CONSTRAINTS);

	location = create_xml_node(fragment, PCMK_XE_RSC_LOCATION);
	crm_xml_set_id(location, "cli-prefer-%s", rsc_id);

	crm_xml_add(location, PCMK_XA_RSC, rsc_id);
	if(promoted_role_only) {
	crm_xml_add(location, PCMK_XA_ROLE, promoted_role);
	} else {
	crm_xml_add(location, PCMK_XA_ROLE, PCMK__ROLE_STARTED);
	}

	if (later_s == NULL) {
	/* Short form */
	crm_xml_add(location, PCMK_XE_NODE, host);
	crm_xml_add(location, PCMK_XA_SCORE, PCMK_VALUE_INFINITY);

	} else {
	xmlNode *rule = create_xml_node(location, PCMK_XE_RULE);
	xmlNode *expr = create_xml_node(rule, PCMK_XE_EXPRESSION);

	crm_xml_set_id(rule, "cli-prefer-rule-%s", rsc_id);
	crm_xml_add(rule, PCMK_XA_SCORE, PCMK_VALUE_INFINITY);
	crm_xml_add(rule, PCMK_XA_BOOLEAN_OP, PCMK_VALUE_AND);

	crm_xml_set_id(expr, "cli-prefer-expr-%s", rsc_id);
	crm_xml_add(expr, PCMK_XA_ATTRIBUTE, CRM_ATTR_UNAME);
	crm_xml_add(expr, PCMK_XA_OPERATION, PCMK_VALUE_EQ);
	crm_xml_add(expr, PCMK_XA_VALUE, host);
	crm_xml_add(expr, PCMK_XA_TYPE, PCMK_VALUE_STRING);

	expr = create_xml_node(rule, PCMK_XE_DATE_EXPRESSION);
	crm_xml_set_id(expr, "cli-prefer-lifetime-end-%s", rsc_id);
	crm_xml_add(expr, PCMK_XA_OPERATION, PCMK_VALUE_LT);
	crm_xml_add(expr, PCMK_XA_END, later_s);
	}

	crm_log_xml_info(fragment, "Modify");
	rc = cib_conn->cmds->modify(cib_conn, PCMK_XE_CONSTRAINTS, fragment,
	cib_options);
	rc = pcmk_legacy2rc(rc);

	free_xml(fragment);
	free(later_s);

	if (rc != pcmk_rc_ok && promoted_role_only && strcmp(promoted_role, PCMK__ROLE_PROMOTED) == 0) {
	int preferrc = cli_resource_prefer(out, rsc_id, host, move_lifetime,
	cib_conn, cib_options, promoted_role_only,
	PCMK__ROLE_PROMOTED_LEGACY);
	if (preferrc == pcmk_rc_ok) {
	rc = preferrc;
	}
	}

	return rc;
	}

	/* Nodes can be specified two different ways in the CIB, so we have two different
	* functions to try clearing out any constraints on them:
	*
	* (1) The node could be given by attribute=/value= in an expression XML node.
	* That's what resource_clear_node_in_expr handles. That XML looks like this:
	*
	* <rsc_location id="cli-prefer-dummy" rsc="dummy" role="Started">
	* <rule id="cli-prefer-rule-dummy" score="INFINITY" boolean-op="and">
	* <expression id="cli-prefer-expr-dummy" attribute="#uname" operation="eq" value="test02" type="string"/>
	* <date_expression id="cli-prefer-lifetime-end-dummy" operation="lt" end="2018-12-12 14:05:37 -05:00"/>
	* </rule>
	* </rsc_location>
	*
	* (2) The node could be given by node= in a PCMK_XE_RSC_LOCATION XML node.
	* That's what resource_clear_node_in_location handles. That XML looks like
	* this:
	*
	* <rsc_location id="cli-prefer-dummy" rsc="dummy" role="Started" node="node1" score="INFINITY"/>
	*
	* \return Standard Pacemaker return code
	*/
	static int
	resource_clear_node_in_expr(const char rsc_id, const char host, cib_t * cib_conn,
	int cib_options)
	{
	int rc = pcmk_rc_ok;
	char *xpath_string = NULL;

	#define XPATH_FMT \
	"//" PCMK_XE_RSC_LOCATION "[@" PCMK_XA_ID "='cli-prefer-%s']" \
	"[" PCMK_XE_RULE \
	"[@" PCMK_XA_ID "='cli-prefer-rule-%s']" \
	"/" PCMK_XE_EXPRESSION \
	"[@" PCMK_XA_ATTRIBUTE "='" CRM_ATTR_UNAME "' " \
	"and @" PCMK_XA_VALUE "='%s']" \
	"]"

	xpath_string = crm_strdup_printf(XPATH_FMT, rsc_id, rsc_id, host);

	rc = cib_conn->cmds->remove(cib_conn, xpath_string, NULL, cib_xpath \| cib_options);
	if (rc == -ENXIO) {
	rc = pcmk_rc_ok;
	} else {
	rc = pcmk_legacy2rc(rc);
	}

	free(xpath_string);
	return rc;
	}

	// \return Standard Pacemaker return code
	static int
	resource_clear_node_in_location(const char rsc_id, const char host, cib_t * cib_conn,
	int cib_options, bool clear_ban_constraints, gboolean force)
	{
	int rc = pcmk_rc_ok;
	xmlNode *fragment = NULL;
	xmlNode *location = NULL;

	fragment = create_xml_node(NULL, PCMK_XE_CONSTRAINTS);

	if (clear_ban_constraints == TRUE) {
	location = create_xml_node(fragment, PCMK_XE_RSC_LOCATION);
	crm_xml_set_id(location, "cli-ban-%s-on-%s", rsc_id, host);
	}

	location = create_xml_node(fragment, PCMK_XE_RSC_LOCATION);
	crm_xml_set_id(location, "cli-prefer-%s", rsc_id);
	if (force == FALSE) {
	crm_xml_add(location, PCMK_XE_NODE, host);
	}

	crm_log_xml_info(fragment, "Delete");
	rc = cib_conn->cmds->remove(cib_conn, PCMK_XE_CONSTRAINTS, fragment,
	cib_options);
	if (rc == -ENXIO) {
	rc = pcmk_rc_ok;
	} else {
	rc = pcmk_legacy2rc(rc);
	}

	free_xml(fragment);
	return rc;
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_clear(const char rsc_id, const char host, GList allnodes, cib_t cib_conn,
	int cib_options, bool clear_ban_constraints, gboolean force)
	{
	int rc = pcmk_rc_ok;

	if(cib_conn == NULL) {
	return ENOTCONN;
	}

	if (host) {
	rc = resource_clear_node_in_expr(rsc_id, host, cib_conn, cib_options);

	/* rc does not tell us whether the previous operation did anything, only
	* whether it failed or not. Thus, as long as it did not fail, we need
	* to try the second clear method.
	*/
	if (rc == pcmk_rc_ok) {
	rc = resource_clear_node_in_location(rsc_id, host, cib_conn,
	cib_options, clear_ban_constraints,
	force);
	}

	} else {
	GList *n = allnodes;

	/* Iterate over all nodes, attempting to clear the constraint from each.
	* On the first error, abort.
	*/
	for(; n; n = n->next) {
	pcmk_node_t *target = n->data;

	rc = cli_resource_clear(rsc_id, target->details->uname, NULL,
	cib_conn, cib_options, clear_ban_constraints,
	force);
	if (rc != pcmk_rc_ok) {
	break;
	}
	}
	}

	return rc;
	}

	static void
	build_clear_xpath_string(GString buf, const xmlNode constraint_node,
	const char rsc, const char node,
	bool promoted_role_only)
	{
	const char *cons_id = pcmk__xe_id(constraint_node);
	const char *cons_rsc = crm_element_value(constraint_node, PCMK_XA_RSC);
	GString *rsc_role_substr = NULL;
	const char *promoted_role_rule = "@" PCMK_XA_ROLE "='" PCMK__ROLE_PROMOTED
	"' or @" PCMK_XA_ROLE "='"
	PCMK__ROLE_PROMOTED_LEGACY "'";

	CRM_ASSERT(buf != NULL);
	g_string_truncate(buf, 0);

	if (!pcmk__starts_with(cons_id, "cli-ban-")
	&& !pcmk__starts_with(cons_id, "cli-prefer-")) {
	return;
	}

	g_string_append(buf, "//" PCMK_XE_RSC_LOCATION);

	if ((node != NULL) \|\| (rsc != NULL) \|\| promoted_role_only) {
	g_string_append_c(buf, '[');

	if (node != NULL) {
	pcmk__g_strcat(buf, "@" PCMK_XE_NODE "='", node, "'", NULL);

	if (promoted_role_only \|\| (rsc != NULL)) {
	g_string_append(buf, " and ");
	}
	}

	if ((rsc != NULL) && promoted_role_only) {
	rsc_role_substr = g_string_sized_new(64);
	pcmk__g_strcat(rsc_role_substr,
	"@" PCMK_XA_RSC "='", rsc, "' "
	"and (" , promoted_role_rule, ")", NULL);

	} else if (rsc != NULL) {
	rsc_role_substr = g_string_sized_new(64);
	pcmk__g_strcat(rsc_role_substr,
	"@" PCMK_XA_RSC "='", rsc, "'", NULL);

	} else if (promoted_role_only) {
	rsc_role_substr = g_string_sized_new(64);
	g_string_append(rsc_role_substr, promoted_role_rule);
	}

	if (rsc_role_substr != NULL) {
	g_string_append(buf, rsc_role_substr->str);
	}
	g_string_append_c(buf, ']');
	}

	if (node != NULL) {
	g_string_append(buf, "\|//" PCMK_XE_RSC_LOCATION);

	if (rsc_role_substr != NULL) {
	pcmk__g_strcat(buf, "[", rsc_role_substr, "]", NULL);
	}
	pcmk__g_strcat(buf,
	"/" PCMK_XE_RULE "[" PCMK_XE_EXPRESSION
	"[@" PCMK_XA_ATTRIBUTE "='" CRM_ATTR_UNAME "' "
	"and @" PCMK_XA_VALUE "='", node, "']]", NULL);
	}

	g_string_append(buf, "//" PCMK_XE_DATE_EXPRESSION "[@" PCMK_XA_ID "='");
	if (pcmk__starts_with(cons_id, "cli-ban-")) {
	pcmk__g_strcat(buf, cons_id, "-lifetime']", NULL);

	} else { // starts with "cli-prefer-"
	pcmk__g_strcat(buf,
	"cli-prefer-lifetime-end-", cons_rsc, "']", NULL);
	}

	if (rsc_role_substr != NULL) {
	g_string_free(rsc_role_substr, TRUE);
	}
	}

	// \return Standard Pacemaker return code
	int
	cli_resource_clear_all_expired(xmlNode root, cib_t cib_conn, int cib_options,
	const char rsc, const char node, gboolean promoted_role_only)
	{
	GString *buf = NULL;
	xmlXPathObject *xpathObj = NULL;
	xmlNode *cib_constraints = NULL;
	crm_time_t *now = crm_time_new(NULL);
	int i;
	int rc = pcmk_rc_ok;

	cib_constraints = pcmk_find_cib_element(root, PCMK_XE_CONSTRAINTS);
	xpathObj = xpath_search(cib_constraints, "//" PCMK_XE_RSC_LOCATION);

	for (i = 0; i < numXpathResults(xpathObj); i++) {
	xmlNode *constraint_node = getXpathResult(xpathObj, i);
	xmlNode *date_expr_node = NULL;
	crm_time_t *end = NULL;

	if (buf == NULL) {
	buf = g_string_sized_new(1024);
	}

	build_clear_xpath_string(buf, constraint_node, rsc, node,
	promoted_role_only);
	if (buf->len == 0) {
	continue;
	}

	date_expr_node = get_xpath_object((const char *) buf->str,
	constraint_node, LOG_DEBUG);
	if (date_expr_node == NULL) {
	continue;
	}

	/* And then finally, see if the date expression is expired. If so,
	* clear the constraint.
	+ *
	+ * @COMPAT Check for error once we are rejecting rules with invalid end
	*/
	- end = crm_time_new(crm_element_value(date_expr_node, PCMK_XA_END));
	+ pcmk__xe_get_datetime(date_expr_node, PCMK_XA_END, &end);

	if (crm_time_compare(now, end) == 1) {
	xmlNode *fragment = NULL;
	xmlNode *location = NULL;

	fragment = create_xml_node(NULL, PCMK_XE_CONSTRAINTS);
	location = create_xml_node(fragment, PCMK_XE_RSC_LOCATION);
	crm_xml_set_id(location, "%s", pcmk__xe_id(constraint_node));
	crm_log_xml_info(fragment, "Delete");

	rc = cib_conn->cmds->remove(cib_conn, PCMK_XE_CONSTRAINTS, fragment,
	cib_options);
	rc = pcmk_legacy2rc(rc);

	if (rc != pcmk_rc_ok) {
	goto done;
	}

	free_xml(fragment);
	}

	crm_time_free(end);
	}

	done:
	if (buf != NULL) {
	g_string_free(buf, TRUE);
	}
	freeXpathObject(xpathObj);
	crm_time_free(now);
	return rc;
	}

File Metadata

Mime Type: text/x-diff
Expires: Tue, Oct 29, 8:54 PM (1 d, 16 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 942626
Default Alt Text: (90 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions