Merging upstream version 2.1.8~rc1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1512 insertions, 0 deletions

diff --git a/lib/common/rules.c b/lib/common/rules.c
new file mode 100644
index 0000000..32af835
--- /dev/null
+++ b/lib/common/rules.c
@@ -0,0 +1,1512 @@
+/*
+ * 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>                          // NULL, size_t
+#include <stdbool.h>                        // bool
+#include <ctype.h>                          // isdigit()
+#include <regex.h>                          // regmatch_t
+#include <stdint.h>                         // uint32_t
+#include <inttypes.h>                       // PRIu32
+#include <glib.h>                           // gboolean, FALSE
+#include <libxml/tree.h>                    // xmlNode
+
+#include <crm/common/scheduler.h>
+
+#include <crm/common/iso8601_internal.h>
+#include <crm/common/nvpair_internal.h>
+#include <crm/common/scheduler_internal.h>
+#include "crmcommon_private.h"
+
+/*!
+ * \internal
+ * \brief Get the condition type corresponding to given condition XML
+ *
+ * \param[in] condition  Rule condition XML
+ *
+ * \return Condition type corresponding to \p condition
+ */
+enum expression_type
+pcmk__condition_type(const xmlNode *condition)
+{
+    const char *name = NULL;
+
+    // Expression types based on element name
+
+    if (pcmk__xe_is(condition, PCMK_XE_DATE_EXPRESSION)) {
+        return pcmk__condition_datetime;
+
+    } else if (pcmk__xe_is(condition, PCMK_XE_RSC_EXPRESSION)) {
+        return pcmk__condition_resource;
+
+    } else if (pcmk__xe_is(condition, PCMK_XE_OP_EXPRESSION)) {
+        return pcmk__condition_operation;
+
+    } else if (pcmk__xe_is(condition, PCMK_XE_RULE)) {
+        return pcmk__condition_rule;
+
+    } else if (!pcmk__xe_is(condition, PCMK_XE_EXPRESSION)) {
+        return pcmk__condition_unknown;
+    }
+
+    // Expression types based on node attribute name
+
+    name = crm_element_value(condition, PCMK_XA_ATTRIBUTE);
+
+    if (pcmk__str_any_of(name, CRM_ATTR_UNAME, CRM_ATTR_KIND, CRM_ATTR_ID,
+                         NULL)) {
+        return pcmk__condition_location;
+    }
+
+    return pcmk__condition_attribute;
+}
+
+/*!
+ * \internal
+ * \brief Get parent XML element's ID for logging purposes
+ *
+ * \param[in] xml  XML of a subelement
+ *
+ * \return ID of \p xml's parent for logging purposes (guaranteed non-NULL)
+ */
+static const char *
+loggable_parent_id(const xmlNode *xml)
+{
+    // Default if called without parent (likely for unit testing)
+    const char *parent_id = "implied";
+
+    if ((xml != NULL) && (xml->parent != NULL)) {
+        parent_id = pcmk__xe_id(xml->parent);
+        if (parent_id == NULL) { // Not possible with schema validation enabled
+            parent_id = "without ID";
+        }
+    }
+    return parent_id;
+}
+
+/*!
+ * \internal
+ * \brief Get the moon phase corresponding to a given date/time
+ *
+ * \param[in] now  Date/time to get moon phase for
+ *
+ * \return Phase of the moon corresponding to \p now, where 0 is the new moon
+ *         and 7 is the full moon
+ * \deprecated This feature has been deprecated since 2.1.6.
+ */
+static int
+phase_of_the_moon(const crm_time_t *now)
+{
+    /* As per the nethack rules:
+     * - A moon period is 29.53058 days ~= 30
+     * - A year is 365.2422 days
+     * - Number of days moon phase advances on first day of year compared to
+     *   preceding year is (365.2422 - 12 * 29.53058) ~= 11
+     * - Number of years until same phases fall on the same days of the month
+     *   is 18.6 ~= 19
+     * - Moon phase on first day of year (epact) ~= (11 * (year%19) + 29) % 30
+     *   (29 as initial condition)
+     * - Current phase in days = first day phase + days elapsed in year
+     * - 6 moons ~= 177 days ~= 8 reported phases * 22 (+ 11/22 for rounding)
+     */
+    uint32_t epact, diy, goldn;
+    uint32_t y;
+
+    crm_time_get_ordinal(now, &y, &diy);
+    goldn = (y % 19) + 1;
+    epact = (11 * goldn + 18) % 30;
+    if (((epact == 25) && (goldn > 11)) || (epact == 24)) {
+        epact++;
+    }
+    return (((((diy + epact) * 6) + 11) % 177) / 22) & 7;
+}
+
+/*!
+ * \internal
+ * \brief Check an integer value against a range from a date specification
+ *
+ * \param[in] date_spec  XML of PCMK_XE_DATE_SPEC element to check
+ * \param[in] id         XML ID for logging purposes
+ * \param[in] attr       Name of XML attribute with range to check against
+ * \param[in] value      Value to compare against range
+ *
+ * \return Standard Pacemaker return code (specifically, pcmk_rc_before_range,
+ *         pcmk_rc_after_range, or pcmk_rc_ok to indicate that result is either
+ *         within range or undetermined)
+ * \note We return pcmk_rc_ok for an undetermined result so we can continue
+ *       checking the next range attribute.
+ */
+static int
+check_range(const xmlNode *date_spec, const char *id, const char *attr,
+            uint32_t value)
+{
+    int rc = pcmk_rc_ok;
+    const char *range = crm_element_value(date_spec, attr);
+    long long low, high;
+
+    if (range == NULL) { // Attribute not present
+        goto bail;
+    }
+
+    if (pcmk__parse_ll_range(range, &low, &high) != pcmk_rc_ok) {
+        // Invalid range
+        /* @COMPAT When we can break behavioral backward compatibility, treat
+         * the entire rule as not passing.
+         */
+        pcmk__config_err("Ignoring " PCMK_XE_DATE_SPEC
+                         " %s attribute %s because '%s' is not a valid range",
+                         id, attr, range);
+
+    } else if ((low != -1) && (value < low)) {
+        rc = pcmk_rc_before_range;
+
+    } else if ((high != -1) && (value > high)) {
+        rc = pcmk_rc_after_range;
+    }
+
+bail:
+    crm_trace("Checked " PCMK_XE_DATE_SPEC " %s %s='%s' for %" PRIu32 ": %s",
+              id, attr, pcmk__s(range, ""), value, pcmk_rc_str(rc));
+    return rc;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a date specification for a given date/time
+ *
+ * \param[in] date_spec  XML of PCMK_XE_DATE_SPEC element to evaluate
+ * \param[in] now        Time to check
+ *
+ * \return Standard Pacemaker return code (specifically, EINVAL for NULL
+ *         arguments, pcmk_rc_ok if time matches specification, or
+ *         pcmk_rc_before_range, pcmk_rc_after_range, or pcmk_rc_op_unsatisfied
+ *         as appropriate to how time relates to specification)
+ */
+int
+pcmk__evaluate_date_spec(const xmlNode *date_spec, const crm_time_t *now)
+{
+    const char *id = NULL;
+    const char *parent_id = loggable_parent_id(date_spec);
+
+    // Range attributes that can be specified for a PCMK_XE_DATE_SPEC element
+    struct range {
+        const char *attr;
+        uint32_t value;
+    } ranges[] = {
+        { PCMK_XA_YEARS, 0U },
+        { PCMK_XA_MONTHS, 0U },
+        { PCMK_XA_MONTHDAYS, 0U },
+        { PCMK_XA_HOURS, 0U },
+        { PCMK_XA_MINUTES, 0U },
+        { PCMK_XA_SECONDS, 0U },
+        { PCMK_XA_YEARDAYS, 0U },
+        { PCMK_XA_WEEKYEARS, 0U },
+        { PCMK_XA_WEEKS, 0U },
+        { PCMK_XA_WEEKDAYS, 0U },
+        { PCMK__XA_MOON, 0U },
+    };
+
+    if ((date_spec == NULL) || (now == NULL)) {
+        return EINVAL;
+    }
+
+    // Get specification ID (for logging)
+    id = pcmk__xe_id(date_spec);
+    if (pcmk__str_empty(id)) { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * fail the specification
+         */
+        pcmk__config_warn(PCMK_XE_DATE_SPEC " subelement of "
+                          PCMK_XE_DATE_EXPRESSION " %s has no " PCMK_XA_ID,
+                          parent_id);
+        id = "without ID"; // for logging
+    }
+
+    // Year, month, day
+    crm_time_get_gregorian(now, &(ranges[0].value), &(ranges[1].value),
+                           &(ranges[2].value));
+
+    // Hour, minute, second
+    crm_time_get_timeofday(now, &(ranges[3].value), &(ranges[4].value),
+                           &(ranges[5].value));
+
+    // Year (redundant) and day of year
+    crm_time_get_ordinal(now, &(ranges[0].value), &(ranges[6].value));
+
+    // Week year, week of week year, day of week
+    crm_time_get_isoweek(now, &(ranges[7].value), &(ranges[8].value),
+                         &(ranges[9].value));
+
+    // Moon phase (deprecated)
+    ranges[10].value = phase_of_the_moon(now);
+    if (crm_element_value(date_spec, PCMK__XA_MOON) != NULL) {
+        pcmk__config_warn("Support for '" PCMK__XA_MOON "' in "
+                          PCMK_XE_DATE_SPEC " elements (such as %s) is "
+                          "deprecated and will be removed in a future release "
+                          "of Pacemaker", id);
+    }
+
+    for (int i = 0; i < PCMK__NELEM(ranges); ++i) {
+        int rc = check_range(date_spec, id, ranges[i].attr, ranges[i].value);
+
+        if (rc != pcmk_rc_ok) {
+            return rc;
+        }
+    }
+
+    // All specified ranges passed, or none were given (also considered a pass)
+    return pcmk_rc_ok;
+}
+
+#define ADD_COMPONENT(component) do {                                       \
+        int sub_rc = pcmk__add_time_from_xml(*end, component, duration);    \
+        if (sub_rc != pcmk_rc_ok) {                                         \
+            /* @COMPAT return sub_rc when we can break compatibility */     \
+            pcmk__config_warn("Ignoring %s in " PCMK_XE_DURATION " %s "     \
+                              "because it is invalid",                      \
+                              pcmk__time_component_attr(component), id);    \
+            rc = sub_rc;                                                    \
+        }                                                                   \
+    } while (0)
+
+/*!
+ * \internal
+ * \brief Given a duration and a start time, calculate the end time
+ *
+ * \param[in]  duration  XML of PCMK_XE_DURATION element
+ * \param[in]  start     Start time
+ * \param[out] end       Where to store end time (\p *end must be NULL
+ *                       initially)
+ *
+ * \return Standard Pacemaker return code
+ * \note The caller is responsible for freeing \p *end using crm_time_free().
+ */
+int
+pcmk__unpack_duration(const xmlNode *duration, const crm_time_t *start,
+                      crm_time_t **end)
+{
+    int rc = pcmk_rc_ok;
+    const char *id = NULL;
+    const char *parent_id = loggable_parent_id(duration);
+
+    if ((start == NULL) || (duration == NULL)
+        || (end == NULL) || (*end != NULL)) {
+        return EINVAL;
+    }
+
+    // Get duration ID (for logging)
+    id = pcmk__xe_id(duration);
+    if (pcmk__str_empty(id)) { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error instead
+         */
+        pcmk__config_warn(PCMK_XE_DURATION " subelement of "
+                          PCMK_XE_DATE_EXPRESSION " %s has no " PCMK_XA_ID,
+                          parent_id);
+        id = "without ID";
+    }
+
+    *end = pcmk_copy_time(start);
+
+    ADD_COMPONENT(pcmk__time_years);
+    ADD_COMPONENT(pcmk__time_months);
+    ADD_COMPONENT(pcmk__time_weeks);
+    ADD_COMPONENT(pcmk__time_days);
+    ADD_COMPONENT(pcmk__time_hours);
+    ADD_COMPONENT(pcmk__time_minutes);
+    ADD_COMPONENT(pcmk__time_seconds);
+
+    return rc;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a range check for a given date/time
+ *
+ * \param[in]     date_expression  XML of PCMK_XE_DATE_EXPRESSION element
+ * \param[in]     id               Expression ID for logging purposes
+ * \param[in]     now              Date/time to compare
+ * \param[in,out] next_change      If not NULL, set this to when the evaluation
+ *                                 will change, if known and earlier than the
+ *                                 original value
+ *
+ * \return Standard Pacemaker return code
+ */
+static int
+evaluate_in_range(const xmlNode *date_expression, const char *id,
+                  const crm_time_t *now, crm_time_t *next_change)
+{
+    crm_time_t *start = NULL;
+    crm_time_t *end = NULL;
+
+    if (pcmk__xe_get_datetime(date_expression, PCMK_XA_START,
+                              &start) != pcmk_rc_ok) {
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Ignoring " PCMK_XA_START " in "
+                          PCMK_XE_DATE_EXPRESSION " %s because it is invalid",
+                          id);
+    }
+
+    if (pcmk__xe_get_datetime(date_expression, PCMK_XA_END,
+                              &end) != pcmk_rc_ok) {
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Ignoring " PCMK_XA_END " in "
+                          PCMK_XE_DATE_EXPRESSION " %s because it is invalid",
+                          id);
+    }
+
+    if ((start == NULL) && (end == NULL)) {
+        // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION " %s as not "
+                          "passing because in_range requires at least one of "
+                          PCMK_XA_START " or " PCMK_XA_END, id);
+        return pcmk_rc_undetermined;
+    }
+
+    if (end == NULL) {
+        xmlNode *duration = pcmk__xe_first_child(date_expression,
+                                                 PCMK_XE_DURATION, NULL, NULL);
+
+        if (duration != NULL) {
+            /* @COMPAT When we can break behavioral backward compatibility,
+             * return the result of this if not OK
+             */
+            pcmk__unpack_duration(duration, start, &end);
+        }
+    }
+
+    if ((start != NULL) && (crm_time_compare(now, start) < 0)) {
+        pcmk__set_time_if_earlier(next_change, start);
+        crm_time_free(start);
+        crm_time_free(end);
+        return pcmk_rc_before_range;
+    }
+
+    if (end != NULL) {
+        if (crm_time_compare(now, end) > 0) {
+            crm_time_free(start);
+            crm_time_free(end);
+            return pcmk_rc_after_range;
+        }
+
+        // Evaluation doesn't change until second after end
+        if (next_change != NULL) {
+            crm_time_add_seconds(end, 1);
+            pcmk__set_time_if_earlier(next_change, end);
+        }
+    }
+
+    crm_time_free(start);
+    crm_time_free(end);
+    return pcmk_rc_within_range;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a greater-than check for a given date/time
+ *
+ * \param[in]     date_expression  XML of PCMK_XE_DATE_EXPRESSION element
+ * \param[in]     id               Expression ID for logging purposes
+ * \param[in]     now              Date/time to compare
+ * \param[in,out] next_change      If not NULL, set this to when the evaluation
+ *                                 will change, if known and earlier than the
+ *                                 original value
+ *
+ * \return Standard Pacemaker return code
+ */
+static int
+evaluate_gt(const xmlNode *date_expression, const char *id,
+            const crm_time_t *now, crm_time_t *next_change)
+{
+    crm_time_t *start = NULL;
+
+    if (pcmk__xe_get_datetime(date_expression, PCMK_XA_START,
+                              &start) != pcmk_rc_ok) {
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION " %s as not "
+                          "passing because " PCMK_XA_START " is invalid",
+                          id);
+        return pcmk_rc_undetermined;
+    }
+
+    if (start == NULL) { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION " %s as not "
+                          "passing because " PCMK_VALUE_GT " requires "
+                          PCMK_XA_START, id);
+        return pcmk_rc_undetermined;
+    }
+
+    if (crm_time_compare(now, start) > 0) {
+        crm_time_free(start);
+        return pcmk_rc_within_range;
+    }
+
+    // Evaluation doesn't change until second after start time
+    crm_time_add_seconds(start, 1);
+    pcmk__set_time_if_earlier(next_change, start);
+    crm_time_free(start);
+    return pcmk_rc_before_range;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a less-than check for a given date/time
+ *
+ * \param[in]     date_expression  XML of PCMK_XE_DATE_EXPRESSION element
+ * \param[in]     id               Expression ID for logging purposes
+ * \param[in]     now              Date/time to compare
+ * \param[in,out] next_change      If not NULL, set this to when the evaluation
+ *                                 will change, if known and earlier than the
+ *                                 original value
+ *
+ * \return Standard Pacemaker return code
+ */
+static int
+evaluate_lt(const xmlNode *date_expression, const char *id,
+            const crm_time_t *now, crm_time_t *next_change)
+{
+    crm_time_t *end = NULL;
+
+    if (pcmk__xe_get_datetime(date_expression, PCMK_XA_END,
+                              &end) != pcmk_rc_ok) {
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION " %s as not "
+                          "passing because " PCMK_XA_END " is invalid", id);
+        return pcmk_rc_undetermined;
+    }
+
+    if (end == NULL) { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION " %s as not "
+                          "passing because " PCMK_VALUE_GT " requires "
+                          PCMK_XA_END, id);
+        return pcmk_rc_undetermined;
+    }
+
+    if (crm_time_compare(now, end) < 0) {
+        pcmk__set_time_if_earlier(next_change, end);
+        crm_time_free(end);
+        return pcmk_rc_within_range;
+    }
+
+    crm_time_free(end);
+    return pcmk_rc_after_range;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a rule's date expression for a given date/time
+ *
+ * \param[in]     date_expression  XML of a PCMK_XE_DATE_EXPRESSION element
+ * \param[in]     now              Time to use for evaluation
+ * \param[in,out] next_change      If not NULL, set this to when the evaluation
+ *                                 will change, if known and earlier than the
+ *                                 original value
+ *
+ * \return Standard Pacemaker return code (unlike most other evaluation
+ *         functions, this can return either pcmk_rc_ok or pcmk_rc_within_range
+ *         on success)
+ */
+int
+pcmk__evaluate_date_expression(const xmlNode *date_expression,
+                               const crm_time_t *now, crm_time_t *next_change)
+{
+    const char *id = NULL;
+    const char *op = NULL;
+    int rc = pcmk_rc_undetermined;
+
+    if ((date_expression == NULL) || (now == NULL)) {
+        return EINVAL;
+    }
+
+    // Get expression ID (for logging)
+    id = pcmk__xe_id(date_expression);
+    if (pcmk__str_empty(id)) { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn(PCMK_XE_DATE_EXPRESSION " element has no "
+                          PCMK_XA_ID);
+        id = "without ID"; // for logging
+    }
+
+    op = crm_element_value(date_expression, PCMK_XA_OPERATION);
+    if (pcmk__str_eq(op, PCMK_VALUE_IN_RANGE,
+                     pcmk__str_null_matches|pcmk__str_casei)) {
+        rc = evaluate_in_range(date_expression, id, now, next_change);
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_DATE_SPEC, pcmk__str_casei)) {
+        xmlNode *date_spec = pcmk__xe_first_child(date_expression,
+                                                  PCMK_XE_DATE_SPEC, NULL,
+                                                  NULL);
+
+        if (date_spec == NULL) { // Not possible with schema validation enabled
+            /* @COMPAT When we can break behavioral backward compatibility,
+             * return pcmk_rc_unpack_error
+             */
+            pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION " %s "
+                              "as not passing because " PCMK_VALUE_DATE_SPEC
+                              " operations require a " PCMK_XE_DATE_SPEC
+                              " subelement", id);
+        } else {
+            // @TODO set next_change appropriately
+            rc = pcmk__evaluate_date_spec(date_spec, now);
+        }
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_GT, pcmk__str_casei)) {
+        rc = evaluate_gt(date_expression, id, now, next_change);
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_LT, pcmk__str_casei)) {
+        rc = evaluate_lt(date_expression, id, now, next_change);
+
+    } else { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_unpack_error
+         */
+        pcmk__config_warn("Treating " PCMK_XE_DATE_EXPRESSION
+                          " %s as not passing because '%s' is not a valid "
+                          PCMK_XE_OPERATION, op);
+    }
+
+    crm_trace(PCMK_XE_DATE_EXPRESSION " %s (%s): %s (%d)",
+              id, op, pcmk_rc_str(rc), rc);
+    return rc;
+}
+
+/*!
+ * \internal
+ * \brief Go through submatches in a string, either counting how many bytes
+ *        would be needed for the expansion, or performing the expansion,
+ *        as requested
+ *
+ * \param[in]  string      String possibly containing submatch variables
+ * \param[in]  match       String that matched the regular expression
+ * \param[in]  submatches  Regular expression submatches (as set by regexec())
+ * \param[in]  nmatches    Number of entries in \p submatches[]
+ * \param[out] expansion   If not NULL, expand string here (must be
+ *                         pre-allocated to appropriate size)
+ * \param[out] nbytes      If not NULL, set to size needed for expansion
+ *
+ * \return true if any expansion is needed, otherwise false
+ */
+static bool
+process_submatches(const char *string, const char *match,
+                   const regmatch_t submatches[], int nmatches,
+                   char *expansion, size_t *nbytes)
+{
+    bool expanded = false;
+    const char *src = string;
+
+    if (nbytes != NULL) {
+        *nbytes = 1; // Include space for terminator
+    }
+
+    while (*src != '\0') {
+        int submatch = 0;
+        size_t match_len = 0;
+
+        if ((src[0] != '%') || !isdigit(src[1])) {
+            /* src does not point to the first character of a %N sequence,
+             * so expand this character as-is
+             */
+            if (expansion != NULL) {
+                *expansion++ = *src;
+            }
+            if (nbytes != NULL) {
+                ++(*nbytes);
+            }
+            ++src;
+            continue;
+        }
+
+        submatch = src[1] - '0';
+        src += 2; // Skip over %N sequence in source string
+        expanded = true; // Expansion will be different from source
+
+        // Omit sequence from expansion unless it has a non-empty match
+        if ((nmatches <= submatch)                // Not enough submatches
+            || (submatches[submatch].rm_so < 0)   // Pattern did not match
+            || (submatches[submatch].rm_eo
+                <= submatches[submatch].rm_so)) { // Match was empty
+            continue;
+        }
+
+        match_len = submatches[submatch].rm_eo - submatches[submatch].rm_so;
+        if (nbytes != NULL) {
+            *nbytes += match_len;
+        }
+        if (expansion != NULL) {
+            memcpy(expansion, match + submatches[submatch].rm_so,
+                   match_len);
+            expansion += match_len;
+        }
+    }
+
+    return expanded;
+}
+
+/*!
+ * \internal
+ * \brief Expand any regular expression submatches (%0-%9) in a string
+ *
+ * \param[in] string      String possibly containing submatch variables
+ * \param[in] match       String that matched the regular expression
+ * \param[in] submatches  Regular expression submatches (as set by regexec())
+ * \param[in] nmatches    Number of entries in \p submatches[]
+ *
+ * \return Newly allocated string identical to \p string with submatches
+ *         expanded on success, or NULL if no expansions were needed
+ * \note The caller is responsible for freeing the result with free()
+ */
+char *
+pcmk__replace_submatches(const char *string, const char *match,
+                         const regmatch_t submatches[], int nmatches)
+{
+    size_t nbytes = 0;
+    char *result = NULL;
+
+    if (pcmk__str_empty(string) || pcmk__str_empty(match)) {
+        return NULL; // Nothing to expand
+    }
+
+    // Calculate how much space will be needed for expanded string
+    if (!process_submatches(string, match, submatches, nmatches, NULL,
+                            &nbytes)) {
+        return NULL; // No expansions needed
+    }
+
+    // Allocate enough space for expanded string
+    result = pcmk__assert_alloc(nbytes, sizeof(char));
+
+    // Expand submatches
+    (void) process_submatches(string, match, submatches, nmatches, result,
+                              NULL);
+    return result;
+}
+
+/*!
+ * \internal
+ * \brief Parse a comparison type from a string
+ *
+ * \param[in] op  String with comparison type (valid values are
+ *                \c PCMK_VALUE_DEFINED, \c PCMK_VALUE_NOT_DEFINED,
+ *                \c PCMK_VALUE_EQ, \c PCMK_VALUE_NE,
+ *                \c PCMK_VALUE_LT, \c PCMK_VALUE_LTE,
+ *                \c PCMK_VALUE_GT, or \c PCMK_VALUE_GTE)
+ *
+ * \return Comparison type corresponding to \p op
+ */
+enum pcmk__comparison
+pcmk__parse_comparison(const char *op)
+{
+    if (pcmk__str_eq(op, PCMK_VALUE_DEFINED, pcmk__str_casei)) {
+        return pcmk__comparison_defined;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_NOT_DEFINED, pcmk__str_casei)) {
+        return pcmk__comparison_undefined;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_EQ, pcmk__str_casei)) {
+        return pcmk__comparison_eq;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_NE, pcmk__str_casei)) {
+        return pcmk__comparison_ne;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_LT, pcmk__str_casei)) {
+        return pcmk__comparison_lt;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_LTE, pcmk__str_casei)) {
+        return pcmk__comparison_lte;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_GT, pcmk__str_casei)) {
+        return pcmk__comparison_gt;
+
+    } else if (pcmk__str_eq(op, PCMK_VALUE_GTE, pcmk__str_casei)) {
+        return pcmk__comparison_gte;
+    }
+
+    return pcmk__comparison_unknown;
+}
+
+/*!
+ * \internal
+ * \brief Parse a value type from a string
+ *
+ * \param[in] type    String with value type (valid values are NULL,
+ *                    \c PCMK_VALUE_STRING, \c PCMK_VALUE_INTEGER,
+ *                    \c PCMK_VALUE_NUMBER, and \c PCMK_VALUE_VERSION)
+ * \param[in] op      Operation type (used only to select default)
+ * \param[in] value1  First value being compared (used only to select default)
+ * \param[in] value2  Second value being compared (used only to select default)
+ */
+enum pcmk__type
+pcmk__parse_type(const char *type, enum pcmk__comparison op,
+                 const char *value1, const char *value2)
+{
+    if (type == NULL) {
+        switch (op) {
+            case pcmk__comparison_lt:
+            case pcmk__comparison_lte:
+            case pcmk__comparison_gt:
+            case pcmk__comparison_gte:
+                if (((value1 != NULL) && (strchr(value1, '.') != NULL))
+                    || ((value2 != NULL) && (strchr(value2, '.') != NULL))) {
+                    return pcmk__type_number;
+                }
+                return pcmk__type_integer;
+
+            default:
+                return pcmk__type_string;
+        }
+    }
+
+    if (pcmk__str_eq(type, PCMK_VALUE_STRING, pcmk__str_casei)) {
+        return pcmk__type_string;
+
+    } else if (pcmk__str_eq(type, PCMK_VALUE_INTEGER, pcmk__str_casei)) {
+        return pcmk__type_integer;
+
+    } else if (pcmk__str_eq(type, PCMK_VALUE_NUMBER, pcmk__str_casei)) {
+        return pcmk__type_number;
+
+    } else if (pcmk__str_eq(type, PCMK_VALUE_VERSION, pcmk__str_casei)) {
+        return pcmk__type_version;
+    }
+
+    return pcmk__type_unknown;
+}
+
+/*!
+ * \internal
+ * \brief Compare two strings according to a given type
+ *
+ * \param[in] value1  String with first value to compare
+ * \param[in] value2  String with second value to compare
+ * \param[in] type    How to interpret the values
+ *
+ * \return Standard comparison result (a negative integer if \p value1 is
+ *         lesser, 0 if the values are equal, and a positive integer if
+ *         \p value1 is greater)
+ */
+int
+pcmk__cmp_by_type(const char *value1, const char *value2, enum pcmk__type type)
+{
+    //  NULL compares as less than non-NULL
+    if (value2 == NULL) {
+        return (value1 == NULL)? 0 : 1;
+    }
+    if (value1 == NULL) {
+        return -1;
+    }
+
+    switch (type) {
+        case pcmk__type_string:
+            return strcasecmp(value1, value2);
+
+        case pcmk__type_integer:
+            {
+                long long integer1;
+                long long integer2;
+
+                if ((pcmk__scan_ll(value1, &integer1, 0LL) != pcmk_rc_ok)
+                    || (pcmk__scan_ll(value2, &integer2, 0LL) != pcmk_rc_ok)) {
+                    crm_warn("Comparing '%s' and '%s' as strings because "
+                             "invalid as integers", value1, value2);
+                    return strcasecmp(value1, value2);
+                }
+                return (integer1 < integer2)? -1 : (integer1 > integer2)? 1 : 0;
+            }
+            break;
+
+        case pcmk__type_number:
+            {
+                double num1;
+                double num2;
+
+                if ((pcmk__scan_double(value1, &num1, NULL, NULL) != pcmk_rc_ok)
+                    || (pcmk__scan_double(value2, &num2, NULL,
+                                          NULL) != pcmk_rc_ok)) {
+                    crm_warn("Comparing '%s' and '%s' as strings because invalid as "
+                             "numbers", value1, value2);
+                    return strcasecmp(value1, value2);
+                }
+                return (num1 < num2)? -1 : (num1 > num2)? 1 : 0;
+            }
+            break;
+
+        case pcmk__type_version:
+            return compare_version(value1, value2);
+
+        default: // Invalid type
+            return 0;
+    }
+}
+
+/*!
+ * \internal
+ * \brief Parse a reference value source from a string
+ *
+ * \param[in] source  String indicating reference value source
+ *
+ * \return Reference value source corresponding to \p source
+ */
+enum pcmk__reference_source
+pcmk__parse_source(const char *source)
+{
+    if (pcmk__str_eq(source, PCMK_VALUE_LITERAL,
+                     pcmk__str_casei|pcmk__str_null_matches)) {
+        return pcmk__source_literal;
+
+    } else if (pcmk__str_eq(source, PCMK_VALUE_PARAM, pcmk__str_casei)) {
+        return pcmk__source_instance_attrs;
+
+    } else if (pcmk__str_eq(source, PCMK_VALUE_META, pcmk__str_casei)) {
+        return pcmk__source_meta_attrs;
+
+    } else {
+        return pcmk__source_unknown;
+    }
+}
+
+/*!
+ * \internal
+ * \brief Parse a boolean operator from a string
+ *
+ * \param[in] combine  String indicating boolean operator
+ *
+ * \return Enumeration value corresponding to \p combine
+ */
+enum pcmk__combine
+pcmk__parse_combine(const char *combine)
+{
+    if (pcmk__str_eq(combine, PCMK_VALUE_AND,
+                     pcmk__str_null_matches|pcmk__str_casei)) {
+        return pcmk__combine_and;
+
+    } else if (pcmk__str_eq(combine, PCMK_VALUE_OR, pcmk__str_casei)) {
+        return pcmk__combine_or;
+
+    } else {
+        return pcmk__combine_unknown;
+    }
+}
+
+/*!
+ * \internal
+ * \brief Get the result of a node attribute comparison for rule evaluation
+ *
+ * \param[in] actual      Actual node attribute value
+ * \param[in] reference   Node attribute value from rule (ignored for
+ *                        \p comparison of \c pcmk__comparison_defined or
+ *                        \c pcmk__comparison_undefined)
+ * \param[in] type        How to interpret the values
+ * \param[in] comparison  How to compare the values
+ *
+ * \return Standard Pacemaker return code (specifically, \c pcmk_rc_ok if the
+ *         comparison passes, and some other value if it does not)
+ */
+static int
+evaluate_attr_comparison(const char *actual, const char *reference,
+                         enum pcmk__type type, enum pcmk__comparison comparison)
+{
+    int cmp = 0;
+
+    switch (comparison) {
+        case pcmk__comparison_defined:
+            return (actual != NULL)? pcmk_rc_ok : pcmk_rc_op_unsatisfied;
+
+        case pcmk__comparison_undefined:
+            return (actual == NULL)? pcmk_rc_ok : pcmk_rc_op_unsatisfied;
+
+        default:
+            break;
+    }
+
+    cmp = pcmk__cmp_by_type(actual, reference, type);
+
+    switch (comparison) {
+        case pcmk__comparison_eq:
+            return (cmp == 0)? pcmk_rc_ok : pcmk_rc_op_unsatisfied;
+
+        case pcmk__comparison_ne:
+            return (cmp != 0)? pcmk_rc_ok : pcmk_rc_op_unsatisfied;
+
+        default:
+            break;
+    }
+
+    if ((actual == NULL) || (reference == NULL)) {
+        return pcmk_rc_op_unsatisfied; // Comparison would be meaningless
+    }
+
+    switch (comparison) {
+        case pcmk__comparison_lt:
+            return (cmp < 0)? pcmk_rc_ok : pcmk_rc_after_range;
+
+        case pcmk__comparison_lte:
+            return (cmp <= 0)? pcmk_rc_ok : pcmk_rc_after_range;
+
+        case pcmk__comparison_gt:
+            return (cmp > 0)? pcmk_rc_ok : pcmk_rc_before_range;
+
+        case pcmk__comparison_gte:
+            return (cmp >= 0)? pcmk_rc_ok : pcmk_rc_before_range;
+
+        default: // Not possible with schema validation enabled
+            return pcmk_rc_op_unsatisfied;
+    }
+}
+
+/*!
+ * \internal
+ * \brief Get a reference value from a configured source
+ *
+ * \param[in] value       Value given in rule expression
+ * \param[in] source      Reference value source
+ * \param[in] rule_input  Values used to evaluate rule criteria
+ */
+static const char *
+value_from_source(const char *value, enum pcmk__reference_source source,
+                  const pcmk_rule_input_t *rule_input)
+{
+    GHashTable *table = NULL;
+
+    if (pcmk__str_empty(value)) {
+        /* @COMPAT When we can break backward compatibility, drop this block so
+         * empty strings are treated as such (there should never be an empty
+         * string as an instance attribute or meta-attribute name, so those will
+         * get NULL anyway, but it could matter for literal comparisons)
+         */
+        return NULL;
+    }
+
+    switch (source) {
+        case pcmk__source_literal:
+            return value;
+
+        case pcmk__source_instance_attrs:
+            table = rule_input->rsc_params;
+            break;
+
+        case pcmk__source_meta_attrs:
+            table = rule_input->rsc_meta;
+            break;
+
+        default:
+            return NULL; // Not possible
+    }
+
+    if (table == NULL) {
+        return NULL;
+    }
+    return (const char *) g_hash_table_lookup(table, value);
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a node attribute rule expression
+ *
+ * \param[in] expression  XML of a rule's PCMK_XE_EXPRESSION subelement
+ * \param[in] rule_input  Values used to evaluate rule criteria
+ *
+ * \return Standard Pacemaker return code (\c pcmk_rc_ok if the expression
+ *         passes, some other value if it does not)
+ */
+int
+pcmk__evaluate_attr_expression(const xmlNode *expression,
+                               const pcmk_rule_input_t *rule_input)
+{
+    const char *id = NULL;
+    const char *op = NULL;
+    const char *attr = NULL;
+    const char *type_s = NULL;
+    const char *value = NULL;
+    const char *actual = NULL;
+    const char *source_s = NULL;
+    const char *reference = NULL;
+    char *expanded_attr = NULL;
+    int rc = pcmk_rc_ok;
+
+    enum pcmk__type type = pcmk__type_unknown;
+    enum pcmk__reference_source source = pcmk__source_unknown;
+    enum pcmk__comparison comparison = pcmk__comparison_unknown;
+
+    if ((expression == NULL) || (rule_input == NULL)) {
+        return EINVAL;
+    }
+
+    // Get expression ID (for logging)
+    id = pcmk__xe_id(expression);
+    if (pcmk__str_empty(id)) {
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * fail the expression
+         */
+        pcmk__config_warn(PCMK_XE_EXPRESSION " element has no " PCMK_XA_ID);
+        id = "without ID"; // for logging
+    }
+
+    /* Get name of node attribute to compare (expanding any %0-%9 to
+     * regular expression submatches)
+     */
+    attr = crm_element_value(expression, PCMK_XA_ATTRIBUTE);
+    if (attr == NULL) {
+        pcmk__config_err("Treating " PCMK_XE_EXPRESSION " %s as not passing "
+                         "because " PCMK_XA_ATTRIBUTE " was not specified", id);
+        return pcmk_rc_unpack_error;
+    }
+    expanded_attr = pcmk__replace_submatches(attr, rule_input->rsc_id,
+                                             rule_input->rsc_id_submatches,
+                                             rule_input->rsc_id_nmatches);
+    if (expanded_attr != NULL) {
+        attr = expanded_attr;
+    }
+
+    // Get and validate operation
+    op = crm_element_value(expression, PCMK_XA_OPERATION);
+    comparison = pcmk__parse_comparison(op);
+    if (comparison == pcmk__comparison_unknown) {
+        // Not possible with schema validation enabled
+        if (op == NULL) {
+            pcmk__config_err("Treating " PCMK_XE_EXPRESSION " %s as not "
+                             "passing because it has no " PCMK_XA_OPERATION,
+                             id);
+        } else {
+            pcmk__config_err("Treating " PCMK_XE_EXPRESSION " %s as not "
+                             "passing because '%s' is not a valid "
+                             PCMK_XA_OPERATION, id, op);
+        }
+        rc = pcmk_rc_unpack_error;
+        goto done;
+    }
+
+    // How reference value is obtained (literal, resource meta-attribute, etc.)
+    source_s = crm_element_value(expression, PCMK_XA_VALUE_SOURCE);
+    source = pcmk__parse_source(source_s);
+    if (source == pcmk__source_unknown) {
+        // Not possible with schema validation enabled
+        // @COMPAT Fail expression once we can break backward compatibility
+        pcmk__config_warn("Expression %s has invalid " PCMK_XA_VALUE_SOURCE
+                          " value '%s', using default "
+                          "('" PCMK_VALUE_LITERAL "')", id, source_s);
+        source = pcmk__source_literal;
+    }
+
+    // Get and validate reference value
+    value = crm_element_value(expression, PCMK_XA_VALUE);
+    switch (comparison) {
+        case pcmk__comparison_defined:
+        case pcmk__comparison_undefined:
+            if (value != NULL) {
+                pcmk__config_warn("Ignoring " PCMK_XA_VALUE " in "
+                                  PCMK_XE_EXPRESSION " %s because it is unused "
+                                  "when " PCMK_XA_BOOLEAN_OP " is %s", id, op);
+            }
+            break;
+
+        default:
+            if (value == NULL) {
+                pcmk__config_warn(PCMK_XE_EXPRESSION " %s has no "
+                                  PCMK_XA_VALUE, id);
+            }
+            break;
+    }
+    reference = value_from_source(value, source, rule_input);
+
+    // Get actual value of node attribute
+    if (rule_input->node_attrs != NULL) {
+        actual = g_hash_table_lookup(rule_input->node_attrs, attr);
+    }
+
+    // Get and validate value type (after expanding reference value)
+    type_s = crm_element_value(expression, PCMK_XA_TYPE);
+    type = pcmk__parse_type(type_s, comparison, actual, reference);
+    if (type == pcmk__type_unknown) {
+        /* Not possible with schema validation enabled
+         *
+         * @COMPAT When we can break behavioral backward compatibility, treat
+         * the expression as not passing.
+         */
+        pcmk__config_warn("Non-empty node attribute values will be treated as "
+                          "equal for " PCMK_XE_EXPRESSION " %s because '%s' "
+                          "is not a valid type", id, type);
+    }
+
+    rc = evaluate_attr_comparison(actual, reference, type, comparison);
+    switch (comparison) {
+        case pcmk__comparison_defined:
+        case pcmk__comparison_undefined:
+            crm_trace(PCMK_XE_EXPRESSION " %s result: %s (for attribute %s %s)",
+                      id, pcmk_rc_str(rc), attr, op);
+            break;
+
+        default:
+            crm_trace(PCMK_XE_EXPRESSION " %s result: "
+                      "%s (attribute %s %s '%s' via %s source as %s type)",
+                      id, pcmk_rc_str(rc), attr, op, pcmk__s(reference, ""),
+                      pcmk__s(source_s, "default"), pcmk__s(type_s, "default"));
+            break;
+    }
+
+done:
+    free(expanded_attr);
+    return rc;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a resource rule expression
+ *
+ * \param[in] rsc_expression  XML of rule's \c PCMK_XE_RSC_EXPRESSION subelement
+ * \param[in] rule_input      Values used to evaluate rule criteria
+ *
+ * \return Standard Pacemaker return code (\c pcmk_rc_ok if the expression
+ *         passes, some other value if it does not)
+ */
+int
+pcmk__evaluate_rsc_expression(const xmlNode *rsc_expression,
+                              const pcmk_rule_input_t *rule_input)
+{
+    const char *id = NULL;
+    const char *standard = NULL;
+    const char *provider = NULL;
+    const char *type = NULL;
+
+    if ((rsc_expression == NULL) || (rule_input == NULL)) {
+        return EINVAL;
+    }
+
+    // Validate XML ID
+    id = pcmk__xe_id(rsc_expression);
+    if (pcmk__str_empty(id)) {
+        // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * fail the expression
+         */
+        pcmk__config_warn(PCMK_XE_RSC_EXPRESSION " has no " PCMK_XA_ID);
+        id = "without ID"; // for logging
+    }
+
+    // Compare resource standard
+    standard = crm_element_value(rsc_expression, PCMK_XA_CLASS);
+    if ((standard != NULL)
+        && !pcmk__str_eq(standard, rule_input->rsc_standard, pcmk__str_none)) {
+        crm_trace(PCMK_XE_RSC_EXPRESSION " %s is unsatisfied because "
+                  "actual standard '%s' doesn't match '%s'",
+                  id, pcmk__s(rule_input->rsc_standard, ""), standard);
+        return pcmk_rc_op_unsatisfied;
+    }
+
+    // Compare resource provider
+    provider = crm_element_value(rsc_expression, PCMK_XA_PROVIDER);
+    if ((provider != NULL)
+        && !pcmk__str_eq(provider, rule_input->rsc_provider, pcmk__str_none)) {
+        crm_trace(PCMK_XE_RSC_EXPRESSION " %s is unsatisfied because "
+                  "actual provider '%s' doesn't match '%s'",
+                  id, pcmk__s(rule_input->rsc_provider, ""), provider);
+        return pcmk_rc_op_unsatisfied;
+    }
+
+    // Compare resource agent type
+    type = crm_element_value(rsc_expression, PCMK_XA_TYPE);
+    if ((type != NULL)
+        && !pcmk__str_eq(type, rule_input->rsc_agent, pcmk__str_none)) {
+        crm_trace(PCMK_XE_RSC_EXPRESSION " %s is unsatisfied because "
+                  "actual agent '%s' doesn't match '%s'",
+                  id, pcmk__s(rule_input->rsc_agent, ""), type);
+        return pcmk_rc_op_unsatisfied;
+    }
+
+    crm_trace(PCMK_XE_RSC_EXPRESSION " %s is satisfied by %s%s%s:%s",
+              id, pcmk__s(standard, ""),
+              ((provider == NULL)? "" : ":"), pcmk__s(provider, ""),
+              pcmk__s(type, ""));
+    return pcmk_rc_ok;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate an operation rule expression
+ *
+ * \param[in] op_expression  XML of a rule's \c PCMK_XE_OP_EXPRESSION subelement
+ * \param[in] rule_input     Values used to evaluate rule criteria
+ *
+ * \return Standard Pacemaker return code (\c pcmk_rc_ok if the expression
+ *         is satisfied, some other value if it is not)
+ */
+int
+pcmk__evaluate_op_expression(const xmlNode *op_expression,
+                             const pcmk_rule_input_t *rule_input)
+{
+    const char *id = NULL;
+    const char *name = NULL;
+    const char *interval_s = NULL;
+    guint interval_ms = 0U;
+
+    if ((op_expression == NULL) || (rule_input == NULL)) {
+        return EINVAL;
+    }
+
+    // Get operation expression ID (for logging)
+    id = pcmk__xe_id(op_expression);
+    if (pcmk__str_empty(id)) { // Not possible with schema validation enabled
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * return pcmk_rc_op_unsatisfied
+         */
+        pcmk__config_warn(PCMK_XE_OP_EXPRESSION " element has no " PCMK_XA_ID);
+        id = "without ID"; // for logging
+    }
+
+    // Validate operation name
+    name = crm_element_value(op_expression, PCMK_XA_NAME);
+    if (name == NULL) { // Not possible with schema validation enabled
+        pcmk__config_warn("Treating " PCMK_XE_OP_EXPRESSION " %s as not "
+                          "passing because it has no " PCMK_XA_NAME, id);
+        return pcmk_rc_unpack_error;
+    }
+
+    // Validate operation interval
+    interval_s = crm_element_value(op_expression, PCMK_META_INTERVAL);
+    if (pcmk_parse_interval_spec(interval_s, &interval_ms) != pcmk_rc_ok) {
+        pcmk__config_warn("Treating " PCMK_XE_OP_EXPRESSION " %s as not "
+                          "passing because '%s' is not a valid interval",
+                          id, interval_s);
+        return pcmk_rc_unpack_error;
+    }
+
+    // Compare operation name
+    if (!pcmk__str_eq(name, rule_input->op_name, pcmk__str_none)) {
+        crm_trace(PCMK_XE_OP_EXPRESSION " %s is unsatisfied because "
+                  "actual name '%s' doesn't match '%s'",
+                  id, pcmk__s(rule_input->op_name, ""), name);
+        return pcmk_rc_op_unsatisfied;
+    }
+
+    // Compare operation interval (unspecified interval matches all)
+    if ((interval_s != NULL) && (interval_ms != rule_input->op_interval_ms)) {
+        crm_trace(PCMK_XE_OP_EXPRESSION " %s is unsatisfied because "
+                  "actual interval %s doesn't match %s",
+                  id, pcmk__readable_interval(rule_input->op_interval_ms),
+                  pcmk__readable_interval(interval_ms));
+        return pcmk_rc_op_unsatisfied;
+    }
+
+    crm_trace(PCMK_XE_OP_EXPRESSION " %s is satisfied (name %s, interval %s)",
+              id, name, pcmk__readable_interval(rule_input->op_interval_ms));
+    return pcmk_rc_ok;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate a rule condition
+ *
+ * \param[in,out] condition    XML containing a rule condition (a subrule, or an
+ *                             expression of any type)
+ * \param[in]     rule_input   Values used to evaluate rule criteria
+ * \param[out]    next_change  If not NULL, set to when evaluation will change
+ *
+ * \return Standard Pacemaker return code (\c pcmk_rc_ok if the condition
+ *         passes, some other value if it does not)
+ */
+int
+pcmk__evaluate_condition(xmlNode *condition,
+                         const pcmk_rule_input_t *rule_input,
+                         crm_time_t *next_change)
+{
+
+    if ((condition == NULL) || (rule_input == NULL)) {
+        return EINVAL;
+    }
+
+    switch (pcmk__condition_type(condition)) {
+        case pcmk__condition_rule:
+            return pcmk_evaluate_rule(condition, rule_input, next_change);
+
+        case pcmk__condition_attribute:
+        case pcmk__condition_location:
+            return pcmk__evaluate_attr_expression(condition, rule_input);
+
+        case pcmk__condition_datetime:
+            {
+                int rc = pcmk__evaluate_date_expression(condition,
+                                                        rule_input->now,
+                                                        next_change);
+
+                return (rc == pcmk_rc_within_range)? pcmk_rc_ok : rc;
+            }
+
+        case pcmk__condition_resource:
+            return pcmk__evaluate_rsc_expression(condition, rule_input);
+
+        case pcmk__condition_operation:
+            return pcmk__evaluate_op_expression(condition, rule_input);
+
+        default: // Not possible with schema validation enabled
+            pcmk__config_err("Treating rule condition %s as not passing "
+                             "because %s is not a valid condition type",
+                             pcmk__s(pcmk__xe_id(condition), "without ID"),
+                             (const char *) condition->name);
+            return pcmk_rc_unpack_error;
+    }
+}
+
+/*!
+ * \brief Evaluate a single rule, including all its conditions
+ *
+ * \param[in,out] rule         XML containing a rule definition or its id-ref
+ * \param[in]     rule_input   Values used to evaluate rule criteria
+ * \param[out]    next_change  If not NULL, set to when evaluation will change
+ *
+ * \return Standard Pacemaker return code (\c pcmk_rc_ok if the rule is
+ *         satisfied, some other value if it is not)
+ */
+int
+pcmk_evaluate_rule(xmlNode *rule, const pcmk_rule_input_t *rule_input,
+                   crm_time_t *next_change)
+{
+    bool empty = true;
+    int rc = pcmk_rc_ok;
+    const char *id = NULL;
+    const char *value = NULL;
+    enum pcmk__combine combine = pcmk__combine_unknown;
+
+    if ((rule == NULL) || (rule_input == NULL)) {
+        return EINVAL;
+    }
+
+    rule = expand_idref(rule, NULL);
+    if (rule == NULL) {
+        // Not possible with schema validation enabled; message already logged
+        return pcmk_rc_unpack_error;
+    }
+
+    // Validate XML ID
+    id = pcmk__xe_id(rule);
+    if (pcmk__str_empty(id)) {
+        /* @COMPAT When we can break behavioral backward compatibility,
+         * fail the rule
+         */
+        pcmk__config_warn(PCMK_XE_RULE " has no " PCMK_XA_ID);
+        id = "without ID"; // for logging
+    }
+
+    value = crm_element_value(rule, PCMK_XA_BOOLEAN_OP);
+    combine = pcmk__parse_combine(value);
+    switch (combine) {
+        case pcmk__combine_and:
+            // For "and", rc defaults to success (reset on failure below)
+            break;
+
+        case pcmk__combine_or:
+            // For "or", rc defaults to failure (reset on success below)
+            rc = pcmk_rc_op_unsatisfied;
+            break;
+
+        default:
+            /* @COMPAT When we can break behavioral backward compatibility,
+             * return pcmk_rc_unpack_error
+             */
+            pcmk__config_warn("Rule %s has invalid " PCMK_XA_BOOLEAN_OP
+                              " value '%s', using default '" PCMK_VALUE_AND "'",
+                              pcmk__xe_id(rule), value);
+            combine = pcmk__combine_and;
+            break;
+    }
+
+    // Evaluate each condition
+    for (xmlNode *condition = pcmk__xe_first_child(rule, NULL, NULL, NULL);
+         condition != NULL; condition = pcmk__xe_next(condition)) {
+
+        empty = false;
+        if (pcmk__evaluate_condition(condition, rule_input,
+                                     next_change) == pcmk_rc_ok) {
+            if (combine == pcmk__combine_or) {
+                rc = pcmk_rc_ok; // Any pass is final for "or"
+                break;
+            }
+        } else if (combine == pcmk__combine_and) {
+            rc = pcmk_rc_op_unsatisfied; // Any failure is final for "and"
+            break;
+        }
+    }
+
+    if (empty) { // Not possible with schema validation enabled
+        /* @COMPAT Currently, we don't actually ignore "or" rules because
+         * rc is initialized to failure above in that case. When we can break
+         * backward compatibility, reset rc to pcmk_rc_ok here.
+         */
+        pcmk__config_warn("Ignoring rule %s because it contains no conditions",
+                          id);
+    }
+
+    crm_trace("Rule %s is %ssatisfied", id, ((rc == pcmk_rc_ok)? "" : "not "));
+    return rc;
+}
+
+/*!
+ * \internal
+ * \brief Evaluate all rules contained within an element
+ *
+ * \param[in,out] xml          XML element possibly containing rule subelements
+ * \param[in]     rule_input   Values used to evaluate rule criteria
+ * \param[out]    next_change  If not NULL, set to when evaluation will change
+ *
+ * \return Standard Pacemaker return code (pcmk_rc_ok if there are no contained
+ *         rules or any contained rule passes, otherwise the result of the last
+ *         rule)
+ * \deprecated On code paths leading to this function, the schema allows
+ *             multiple top-level rules only in the deprecated lifetime element
+ *             of location constraints. The code also allows multiple top-level
+ *             rules when unpacking attribute sets, but this is deprecated and
+ *             already prevented by schema validation. This function can be
+ *             dropped when support for those is dropped.
+ */
+int
+pcmk__evaluate_rules(xmlNode *xml, const pcmk_rule_input_t *rule_input,
+                     crm_time_t *next_change)
+{
+    // If there are no rules, pass by default
+    int rc = pcmk_rc_ok;
+    bool have_rule = false;
+
+    for (xmlNode *rule = pcmk__xe_first_child(xml, PCMK_XE_RULE, NULL, NULL);
+         rule != NULL; rule = pcmk__xe_next_same(rule)) {
+
+        if (have_rule) {
+            pcmk__warn_once(pcmk__wo_multiple_rules,
+                            "Support for multiple top-level rules is "
+                            "deprecated (replace with a single rule containing "
+                            "the existing rules with " PCMK_XA_BOOLEAN_OP
+                            "set to " PCMK_VALUE_OR " instead)");
+        } else {
+            have_rule = true;
+        }
+
+        rc = pcmk_evaluate_rule(rule, rule_input, next_change);
+        if (rc == pcmk_rc_ok) {
+            break;
+        }
+    }
+    return rc;
+}