From 08ce507927ff497b0e8f125050f67d59c74d674c Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Thu, 19 Nov 2020 15:52:14 -0600

Subject: [PATCH 01/12] Refactor: libpe_rules: functionize value-source

 expansion

... for readability

---

 lib/pengine/rules.c | 61 +++++++++++++++++++++++++++++++----------------------

 1 file changed, 36 insertions(+), 25 deletions(-)

diff --git a/lib/pengine/rules.c b/lib/pengine/rules.c

index e5d452f..aa5d6ab 100644

--- a/lib/pengine/rules.c

+++ b/lib/pengine/rules.c

@@ -1027,6 +1027,36 @@ accept_attr_expr(const char *l_val, const char *r_val, const char *type,

 /*!

  * \internal

+ * \brief Get correct value according to value-source

+ *

+ * \param[in] value         value given in rule expression

+ * \param[in] value_source  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 *value, const char *value_source,

+                    pe_match_data_t *match_data)

+{

+    GHashTable *table = NULL;

+

+    if (pcmk__str_eq(value_source, "param", pcmk__str_casei)) {

+        table = match_data->params;

+

+    } else if (pcmk__str_eq(value_source, "meta", pcmk__str_casei)) {

+        table = match_data->meta;

+

+    } else { // literal

+        return value;

+    }

+

+    if ((table == NULL) || pcmk__str_empty(value)) {

+        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

  *

@@ -1040,8 +1070,6 @@ pe__eval_attr_expr(xmlNodePtr expr, pe_rule_eval_data_t *rule_data)

 {

     gboolean attr_allocated = FALSE;

     const char *h_val = NULL;

-    GHashTable *table = NULL;

-    bool literal = true;

     const char *op = NULL;

     const char *type = NULL;

@@ -1061,36 +1089,19 @@ pe__eval_attr_expr(xmlNodePtr expr, pe_rule_eval_data_t *rule_data)

         return FALSE;

     }

-    if (rule_data->match_data) {

-        if (rule_data->match_data->re) {

+    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) {

+            if (resolved_attr != NULL) {

                 attr = (const char *) resolved_attr;

                 attr_allocated = TRUE;

             }

         }

-        if (pcmk__str_eq(value_source, "param", pcmk__str_casei)) {

-            literal = false;

-            table = rule_data->match_data->params;

-        } else if (pcmk__str_eq(value_source, "meta", pcmk__str_casei)) {

-            literal = false;

-            table = rule_data->match_data->meta;

-        }

-    }

-

-    if (!literal) {

-        const char *param_name = value;

-        const char *param_value = NULL;

-

-        value = NULL;

-        if ((table != NULL) && !pcmk__str_empty(param_name)) {

-            param_value = (const char *)g_hash_table_lookup(table, param_name);

-            if (param_value != NULL) {

-                value = param_value;

-            }

-        }

+        // Get value appropriate to value-source

+        value = expand_value_source(value, value_source, rule_data->match_data);

     }

     if (rule_data->node_hash != NULL) {

-- 

1.8.3.1

From 8864e8596cc44fa275f68d58fea9b7d3d5236106 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Thu, 19 Nov 2020 11:59:05 -0600

Subject: [PATCH 02/12] Refactor: libcrmcommon: expose "first XML attribute"

 function

... for future reuse. Also, rename to reflect that only XML element nodes may

have attributes.

---

 include/crm/common/xml_internal.h | 14 +++++++

 lib/common/crmcommon_private.h    |  6 ---

 lib/common/nvpair.c               |  4 +-

 lib/common/patchset.c             | 20 +++++-----

 lib/common/xml.c                  | 81 +++++++++++++++++----------------------

 5 files changed, 61 insertions(+), 64 deletions(-)

diff --git a/include/crm/common/xml_internal.h b/include/crm/common/xml_internal.h

index 13157c6..b2ff529 100644

--- a/include/crm/common/xml_internal.h

+++ b/include/crm/common/xml_internal.h

@@ -255,4 +255,18 @@ void

 pcmk__xe_set_props(xmlNodePtr node, ...)

 G_GNUC_NULL_TERMINATED;

+/*!

+ * \internal

+ * \brief Get first attribute of an XML element

+ *

+ * \param[in] xe  XML element to check

+ *

+ * \return First attribute of \p xe (or NULL if \p xe is NULL or has none)

+ */

+static inline xmlAttr *

+pcmk__xe_first_attr(const xmlNode *xe)

+{

+    return (xe == NULL)? NULL : xe->properties;

+}

+

 #endif // PCMK__XML_INTERNAL__H

diff --git a/lib/common/crmcommon_private.h b/lib/common/crmcommon_private.h

index 1654cba..c2f334d 100644

--- a/lib/common/crmcommon_private.h

+++ b/lib/common/crmcommon_private.h

@@ -141,12 +141,6 @@ void pcmk__mark_xml_attr_dirty(xmlAttr *a);

 G_GNUC_INTERNAL

 bool pcmk__xa_filterable(const char *name);

-static inline xmlAttr *

-pcmk__first_xml_attr(const xmlNode *xml)

-{

-    return xml? xml->properties : NULL;

-}

-

 static inline const char *

 pcmk__xml_attr_value(const xmlAttr *attr)

 {

diff --git a/lib/common/nvpair.c b/lib/common/nvpair.c

index 0ed7a7d..9bd87af 100644

--- a/lib/common/nvpair.c

+++ b/lib/common/nvpair.c

@@ -163,7 +163,7 @@ pcmk_xml_attrs2nvpairs(xmlNode *xml)

 {

     GSList *result = NULL;

-    for (xmlAttrPtr iter = pcmk__first_xml_attr(xml); iter != NULL;

+    for (xmlAttrPtr iter = pcmk__xe_first_attr(xml); iter != NULL;

          iter = iter->next) {

         result = pcmk_prepend_nvpair(result,

@@ -925,7 +925,7 @@ xml2list(xmlNode *parent)

     crm_log_xml_trace(nvpair_list, "Unpacking");

-    for (pIter = pcmk__first_xml_attr(nvpair_list); pIter != NULL;

+    for (pIter = pcmk__xe_first_attr(nvpair_list); pIter != NULL;

          pIter = pIter->next) {

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

diff --git a/lib/common/patchset.c b/lib/common/patchset.c

index f3dab03..15cbe07 100644

--- a/lib/common/patchset.c

+++ b/lib/common/patchset.c

@@ -112,7 +112,7 @@ add_xml_changes_to_patchset(xmlNode *xml, xmlNode *patchset)

     }

     // Check each of the XML node's attributes for changes

-    for (pIter = pcmk__first_xml_attr(xml); pIter != NULL;

+    for (pIter = pcmk__xe_first_attr(xml); pIter != NULL;

          pIter = pIter->next) {

         xmlNode *attr = NULL;

@@ -156,7 +156,7 @@ add_xml_changes_to_patchset(xmlNode *xml, xmlNode *patchset)

         change = create_xml_node(change->parent, XML_DIFF_RESULT);

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

-        for (pIter = pcmk__first_xml_attr(xml); pIter != NULL;

+        for (pIter = pcmk__xe_first_attr(xml); pIter != NULL;

              pIter = pIter->next) {

             p = pIter->_private;

             if (!pcmk_is_set(p->flags, xpf_deleted)) {

@@ -677,7 +677,7 @@ process_v1_removals(xmlNode *target, xmlNode *patch)

         return;

     }

-    for (xIter = pcmk__first_xml_attr(patch); xIter != NULL;

+    for (xIter = pcmk__xe_first_attr(patch); xIter != NULL;

          xIter = xIter->next) {

         const char *p_name = (const char *)xIter->name;

@@ -745,7 +745,7 @@ process_v1_additions(xmlNode *parent, xmlNode *target, xmlNode *patch)

               return);

     CRM_CHECK(pcmk__str_eq(ID(target), ID(patch), pcmk__str_casei), return);

-    for (xIter = pcmk__first_xml_attr(patch); xIter != NULL;

+    for (xIter = pcmk__xe_first_attr(patch); xIter != NULL;

          xIter = xIter->next) {

         const char *p_name = (const char *) xIter->name;

         const char *p_value = crm_element_value(patch, p_name);

@@ -1204,7 +1204,7 @@ apply_v2_patchset(xmlNode *xml, xmlNode *patchset)

             free_xml(match);

         } else if (strcmp(op, "modify") == 0) {

-            xmlAttr *pIter = pcmk__first_xml_attr(match);

+            xmlAttr *pIter = pcmk__xe_first_attr(match);

             xmlNode *attrs = NULL;

             attrs = pcmk__xml_first_child(first_named_child(change,

@@ -1220,7 +1220,7 @@ apply_v2_patchset(xmlNode *xml, xmlNode *patchset)

                 xml_remove_prop(match, name);

             }

-            for (pIter = pcmk__first_xml_attr(attrs); pIter != NULL;

+            for (pIter = pcmk__xe_first_attr(attrs); pIter != NULL;

                  pIter = pIter->next) {

                 const char *name = (const char *) pIter->name;

                 const char *value = crm_element_value(attrs, name);

@@ -1553,7 +1553,7 @@ subtract_xml_object(xmlNode *parent, xmlNode *left, xmlNode *right,

     } else if (full) {

         xmlAttrPtr pIter = NULL;

-        for (pIter = pcmk__first_xml_attr(left); pIter != NULL;

+        for (pIter = pcmk__xe_first_attr(left); pIter != NULL;

              pIter = pIter->next) {

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

             const char *p_value = pcmk__xml_attr_value(pIter);

@@ -1566,7 +1566,7 @@ subtract_xml_object(xmlNode *parent, xmlNode *left, xmlNode *right,

     }

     // Changes to name/value pairs

-    for (xIter = pcmk__first_xml_attr(left); xIter != NULL;

+    for (xIter = pcmk__xe_first_attr(left); xIter != NULL;

          xIter = xIter->next) {

         const char *prop_name = (const char *) xIter->name;

         xmlAttrPtr right_attr = NULL;

@@ -1594,7 +1594,7 @@ subtract_xml_object(xmlNode *parent, xmlNode *left, xmlNode *right,

             if (full) {

                 xmlAttrPtr pIter = NULL;

-                for (pIter = pcmk__first_xml_attr(left); pIter != NULL;

+                for (pIter = pcmk__xe_first_attr(left); pIter != NULL;

                      pIter = pIter->next) {

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

                     const char *p_value = pcmk__xml_attr_value(pIter);

@@ -1624,7 +1624,7 @@ subtract_xml_object(xmlNode *parent, xmlNode *left, xmlNode *right,

                     crm_trace("Changes detected to %s in <%s id=%s>", prop_name,

                               crm_element_name(left), id);

-                    for (pIter = pcmk__first_xml_attr(left); pIter != NULL;

+                    for (pIter = pcmk__xe_first_attr(left); pIter != NULL;

                          pIter = pIter->next) {

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

                         const char *p_value = pcmk__xml_attr_value(pIter);

diff --git a/lib/common/xml.c b/lib/common/xml.c

index abb120c..f2f48e9 100644

--- a/lib/common/xml.c

+++ b/lib/common/xml.c

@@ -337,7 +337,7 @@ accept_attr_deletions(xmlNode *xml)

     xml_private_t *p = xml->_private;

     p->flags = xpf_none;

-    pIter = pcmk__first_xml_attr(xml);

+    pIter = pcmk__xe_first_attr(xml);

     while (pIter != NULL) {

         const xmlChar *name = pIter->name;

@@ -528,11 +528,9 @@ copy_in_properties(xmlNode * target, xmlNode * src)

         crm_err("No node to copy properties into");

     } else {

-        xmlAttrPtr pIter = NULL;

-

-        for (pIter = pcmk__first_xml_attr(src); pIter != NULL; pIter = pIter->next) {

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

-            const char *p_value = pcmk__xml_attr_value(pIter);

+        for (xmlAttrPtr a = pcmk__xe_first_attr(src); a != NULL; a = a->next) {

+            const char *p_name = (const char *) a->name;

+            const char *p_value = pcmk__xml_attr_value(a);

             expand_plus_plus(target, p_name, p_value);

         }

@@ -546,11 +544,10 @@ fix_plus_plus_recursive(xmlNode * target)

 {

     /* TODO: Remove recursion and use xpath searches for value++ */

     xmlNode *child = NULL;

-    xmlAttrPtr pIter = NULL;

-    for (pIter = pcmk__first_xml_attr(target); pIter != NULL; pIter = pIter->next) {

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

-        const char *p_value = pcmk__xml_attr_value(pIter);

+    for (xmlAttrPtr a = pcmk__xe_first_attr(target); a != NULL; a = a->next) {

+        const char *p_name = (const char *) a->name;

+        const char *p_value = pcmk__xml_attr_value(a);

         expand_plus_plus(target, p_name, p_value);

     }

@@ -1429,7 +1426,6 @@ pcmk__xe_log(int log_level, const char *file, const char *function, int line,

     const char *hidden = NULL;

     xmlNode *child = NULL;

-    xmlAttrPtr pIter = NULL;

     if ((data == NULL) || (log_level == LOG_NEVER)) {

         return;

@@ -1449,10 +1445,12 @@ pcmk__xe_log(int log_level, const char *file, const char *function, int line,

             buffer_print(buffer, max, offset, "<%s", name);

             hidden = crm_element_value(data, "hidden");

-            for (pIter = pcmk__first_xml_attr(data); pIter != NULL; pIter = pIter->next) {

-                xml_private_t *p = pIter->_private;

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

-                const char *p_value = pcmk__xml_attr_value(pIter);

+            for (xmlAttrPtr a = pcmk__xe_first_attr(data); a != NULL;

+                 a = a->next) {

+

+                xml_private_t *p = a->_private;

+                const char *p_name = (const char *) a->name;

+                const char *p_value = pcmk__xml_attr_value(a);

                 char *p_copy = NULL;

                 if (pcmk_is_set(p->flags, xpf_deleted)) {

@@ -1526,7 +1524,6 @@ log_xml_changes(int log_level, const char *file, const char *function, int line,

     xml_private_t *p;

     char *prefix_m = NULL;

     xmlNode *child = NULL;

-    xmlAttrPtr pIter = NULL;

     if ((data == NULL) || (log_level == LOG_NEVER)) {

         return;

@@ -1566,10 +1563,10 @@ log_xml_changes(int log_level, const char *file, const char *function, int line,

         pcmk__xe_log(log_level, file, function, line, flags, data, depth,

                      options|xml_log_option_open);

-        for (pIter = pcmk__first_xml_attr(data); pIter != NULL; pIter = pIter->next) {

-            const char *aname = (const char*)pIter->name;

+        for (xmlAttrPtr a = pcmk__xe_first_attr(data); a != NULL; a = a->next) {

+            const char *aname = (const char*) a->name;

-            p = pIter->_private;

+            p = a->_private;

             if (pcmk_is_set(p->flags, xpf_deleted)) {

                 const char *value = crm_element_value(data, aname);

                 flags = prefix_del;

@@ -1684,11 +1681,9 @@ log_data_element(int log_level, const char *file, const char *function, int line

 static void

 dump_filtered_xml(xmlNode * data, int options, char **buffer, int *offset, int *max)

 {

-    xmlAttrPtr xIter = NULL;

-

-    for (xIter = pcmk__first_xml_attr(data); xIter != NULL; xIter = xIter->next) {

-        if (!pcmk__xa_filterable((const char *) (xIter->name))) {

-            dump_xml_attr(xIter, options, buffer, offset, max);

+    for (xmlAttrPtr a = pcmk__xe_first_attr(data); a != NULL; a = a->next) {

+        if (!pcmk__xa_filterable((const char *) (a->name))) {

+            dump_xml_attr(a, options, buffer, offset, max);

         }

     }

 }

@@ -1722,10 +1717,8 @@ dump_xml_element(xmlNode * data, int options, char **buffer, int *offset, int *m

         dump_filtered_xml(data, options, buffer, offset, max);

     } else {

-        xmlAttrPtr xIter = NULL;

-

-        for (xIter = pcmk__first_xml_attr(data); xIter != NULL; xIter = xIter->next) {

-            dump_xml_attr(xIter, options, buffer, offset, max);

+        for (xmlAttrPtr a = pcmk__xe_first_attr(data); a != NULL; a = a->next) {

+            dump_xml_attr(a, options, buffer, offset, max);

         }

     }

@@ -2062,7 +2055,7 @@ save_xml_to_file(xmlNode * xml, const char *desc, const char *filename)

 static void

 set_attrs_flag(xmlNode *xml, enum xml_private_flags flag)

 {

-    for (xmlAttr *attr = pcmk__first_xml_attr(xml); attr; attr = attr->next) {

+    for (xmlAttr *attr = pcmk__xe_first_attr(xml); attr; attr = attr->next) {

         pcmk__set_xml_flags((xml_private_t *) (attr->_private), flag);

     }

 }

@@ -2152,7 +2145,7 @@ mark_attr_moved(xmlNode *new_xml, const char *element, xmlAttr *old_attr,

 static void

 xml_diff_old_attrs(xmlNode *old_xml, xmlNode *new_xml)

 {

-    xmlAttr *attr_iter = pcmk__first_xml_attr(old_xml);

+    xmlAttr *attr_iter = pcmk__xe_first_attr(old_xml);

     while (attr_iter != NULL) {

         xmlAttr *old_attr = attr_iter;

@@ -2194,7 +2187,7 @@ xml_diff_old_attrs(xmlNode *old_xml, xmlNode *new_xml)

 static void

 mark_created_attrs(xmlNode *new_xml)

 {

-    xmlAttr *attr_iter = pcmk__first_xml_attr(new_xml);

+    xmlAttr *attr_iter = pcmk__xe_first_attr(new_xml);

     while (attr_iter != NULL) {

         xmlAttr *new_attr = attr_iter;

@@ -2371,7 +2364,6 @@ gboolean

 can_prune_leaf(xmlNode * xml_node)

 {

     xmlNode *cIter = NULL;

-    xmlAttrPtr pIter = NULL;

     gboolean can_prune = TRUE;

     const char *name = crm_element_name(xml_node);

@@ -2380,8 +2372,8 @@ can_prune_leaf(xmlNode * xml_node)

         return FALSE;

     }

-    for (pIter = pcmk__first_xml_attr(xml_node); pIter != NULL; pIter = pIter->next) {

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

+    for (xmlAttrPtr a = pcmk__xe_first_attr(xml_node); a != NULL; a = a->next) {

+        const char *p_name = (const char *) a->name;

         if (strcmp(p_name, XML_ATTR_ID) == 0) {

             continue;

@@ -2558,15 +2550,13 @@ pcmk__xml_update(xmlNode *parent, xmlNode *target, xmlNode *update,

     } else {

         /* No need for expand_plus_plus(), just raw speed */

-        xmlAttrPtr pIter = NULL;

-

-        for (pIter = pcmk__first_xml_attr(update); pIter != NULL; pIter = pIter->next) {

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

-            const char *p_value = pcmk__xml_attr_value(pIter);

+        for (xmlAttrPtr a = pcmk__xe_first_attr(update); a != NULL;

+             a = a->next) {

+            const char *p_value = pcmk__xml_attr_value(a);

             /* Remove it first so the ordering of the update is preserved */

-            xmlUnsetProp(target, (pcmkXmlStr) p_name);

-            xmlSetProp(target, (pcmkXmlStr) p_name, (pcmkXmlStr) p_value);

+            xmlUnsetProp(target, a->name);

+            xmlSetProp(target, a->name, (pcmkXmlStr) p_value);

         }

     }

@@ -2681,11 +2671,10 @@ replace_xml_child(xmlNode * parent, xmlNode * child, xmlNode * update, gboolean

         can_delete = FALSE;

     }

     if (can_delete && delete_only) {

-        xmlAttrPtr pIter = NULL;

-

-        for (pIter = pcmk__first_xml_attr(update); pIter != NULL; pIter = pIter->next) {

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

-            const char *p_value = pcmk__xml_attr_value(pIter);

+        for (xmlAttrPtr a = pcmk__xe_first_attr(update); a != NULL;

+             a = a->next) {

+            const char *p_name = (const char *) a->name;

+            const char *p_value = pcmk__xml_attr_value(a);

             right_val = crm_element_value(child, p_name);

             if (!pcmk__str_eq(p_value, right_val, pcmk__str_casei)) {

-- 

1.8.3.1

From 68e35a6f715f26a8a3b033cc91875f6f7001f106 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Thu, 19 Nov 2020 10:31:36 -0600

Subject: [PATCH 03/12] Refactor: libcrmcommon: new internal function for

 removing XML attributes

---

 include/crm/common/xml_internal.h |  4 ++++

 lib/common/xml.c                  | 34 ++++++++++++++++++++++++++++++++++

 2 files changed, 38 insertions(+)

diff --git a/include/crm/common/xml_internal.h b/include/crm/common/xml_internal.h

index b2ff529..1e80bc6 100644

--- a/include/crm/common/xml_internal.h

+++ b/include/crm/common/xml_internal.h

@@ -136,6 +136,10 @@ const char *pcmk__xe_add_last_written(xmlNode *xe);

 xmlNode *pcmk__xe_match(xmlNode *parent, const char *node_name,

                         const char *attr_n, const char *attr_v);

+void pcmk__xe_remove_matching_attrs(xmlNode *element,

+                                    bool (*match)(xmlAttrPtr, void *),

+                                    void *user_data);

+

 /*!

  * \internal

  * \brief Get the root directory to scan XML artefacts of given kind for

diff --git a/lib/common/xml.c b/lib/common/xml.c

index f2f48e9..39c5e53 100644

--- a/lib/common/xml.c

+++ b/lib/common/xml.c

@@ -618,6 +618,40 @@ expand_plus_plus(xmlNode * target, const char *name, const char *value)

     return;

 }

+/*!

+ * \internal

+ * \brief Remove an XML element's attributes that match some criteria

+ *

+ * \param[in,out] element    XML element to modify

+ * \param[in]     match      If not NULL, only remove attributes for which

+ *                           this function returns true

+ * \param[in]     user_data  Data to pass to \p match

+ */

+void

+pcmk__xe_remove_matching_attrs(xmlNode *element,

+                               bool (*match)(xmlAttrPtr, void *),

+                               void *user_data)

+{

+    xmlAttrPtr next = NULL;

+

+    for (xmlAttrPtr a = pcmk__xe_first_attr(element); a != NULL; a = next) {

+        next = a->next; // Grab now because attribute might get removed

+        if ((match == NULL) || match(a, user_data)) {

+            if (!pcmk__check_acl(element, NULL, xpf_acl_write)) {

+                crm_trace("ACLs prevent removal of %s attribute from %s element",

+                          (const char *) a->name, (const char *) element->name);

+

+            } else if (pcmk__tracking_xml_changes(element, false)) {

+                // Leave (marked for removal) until after diff is calculated

+                set_parent_flag(element, xpf_dirty);

+                pcmk__set_xml_flags((xml_private_t *) a->_private, xpf_deleted);

+            } else {

+                xmlRemoveProp(a);

+            }

+        }

+    }

+}

+

 xmlDoc *

 getDocPtr(xmlNode * node)

 {

-- 

1.8.3.1

From a6e1804156dfd1f6c3bc1ffbf888fbd6421aa464 Mon Sep 17 00:00:00 2001

From: Ken Gaillot <kgaillot@redhat.com>

Date: Thu, 19 Nov 2020 11:10:52 -0600

Subject: [PATCH 04/12] Refactor: libcrmcommon,libpe_status: use new attribute

 removing function

... where appropriate, for readability and efficiency

---

 lib/common/operations.c | 64 ++++++++++++++++++-------------------

 lib/common/patchset.c   | 29 +++++++----------

 lib/common/xml.c        | 39 +++++++++++------------

 lib/pengine/pe_digest.c | 84 ++++++++++++++++++++++++++-----------------------

 4 files changed, 105 insertions(+), 111 deletions(-)

diff --git a/lib/common/operations.c b/lib/common/operations.c

index 7e6bf5a..f3a11be 100644

--- a/lib/common/operations.c

+++ b/lib/common/operations.c

@@ -24,6 +24,7 @@

 #include <crm/lrmd.h>

 #include <crm/msg_xml.h>

 #include <crm/common/xml.h>

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

 #include <crm/common/util.h>

 static regex_t *notify_migrate_re = NULL;

@@ -361,6 +362,24 @@ decode_transition_key(const char *key, char **uuid, int *transition_id, int *act

     return TRUE;

 }

+#define CRM_META_LEN (sizeof(CRM_META) - 1)

+

+// Return true if a is an attribute that should be filtered

+static bool

+should_filter_for_digest(xmlAttrPtr a, void *user_data)

+{

+    // @TODO CRM_META check should be case-sensitive

+    return (strncasecmp((const char *) a->name, CRM_META, CRM_META_LEN) == 0)

+           || pcmk__str_any_of((const char *) a->name,

+                               XML_ATTR_ID,

+                               XML_ATTR_CRM_VERSION,

+                               XML_LRM_ATTR_OP_DIGEST,

+                               XML_LRM_ATTR_TARGET,

+                               XML_LRM_ATTR_TARGET_UUID,

+                               "pcmk_external_ip",

+                               NULL);

+}

+

 /*!

  * \internal

  * \brief Remove XML attributes not needed for operation digest

@@ -374,52 +393,31 @@ pcmk__filter_op_for_digest(xmlNode *param_set)

     char *timeout = NULL;

     guint interval_ms = 0;

-    const char *attr_filter[] = {

-        XML_ATTR_ID,

-        XML_ATTR_CRM_VERSION,

-        XML_LRM_ATTR_OP_DIGEST,

-        XML_LRM_ATTR_TARGET,

-        XML_LRM_ATTR_TARGET_UUID,

-        "pcmk_external_ip"

-    };

-

-    const int meta_len = strlen(CRM_META);

-

     if (param_set == NULL) {

         return;

     }

-    // Remove the specific attributes listed in attr_filter

-    for (int lpc = 0; lpc < DIMOF(attr_filter); lpc++) {

-        xml_remove_prop(param_set, attr_filter[lpc]);

-    }

-

+    /* Timeout is useful for recurring operation digests, so grab it before

+     * removing meta-attributes

+     */

     key = crm_meta_name(XML_LRM_ATTR_INTERVAL_MS);

     if (crm_element_value_ms(param_set, key, &interval_ms) != pcmk_ok) {

         interval_ms = 0;

     }

     free(key);

-

-    key = crm_meta_name(XML_ATTR_TIMEOUT);

-    timeout = crm_element_value_copy(param_set, key);

-

-    // Remove all CRM_meta_* attributes

-    for (xmlAttrPtr xIter = param_set->properties; xIter != NULL; ) {

-        const char *prop_name = (const char *) (xIter->name);

-

-        xIter = xIter->next;

-

-        // @TODO Why is this case-insensitive?

-        if (strncasecmp(prop_name, CRM_META, meta_len) == 0) {

-            xml_remove_prop(param_set, prop_name);

-        }

+    key = NULL;

+    if (interval_ms != 0) {

+        key = crm_meta_name(XML_ATTR_TIMEOUT);

+        timeout = crm_element_value_copy(param_set, key);

     }

-    if ((interval_ms != 0) && (timeout != NULL)) {

-        // Add the timeout back, it's useful for recurring operation digests

+    // Remove all CRM_meta_* attributes and certain other attributes

+    pcmk__xe_remove_matching_attrs(param_set, should_filter_for_digest, NULL);

+

+    // Add timeout back for recurring operation digests

+    if (timeout != NULL) {

         crm_xml_add(param_set, key, timeout);

     }

-

     free(timeout);

     free(key);

 }

diff --git a/lib/common/patchset.c b/lib/common/patchset.c

index 15cbe07..fae7046 100644

--- a/lib/common/patchset.c

+++ b/lib/common/patchset.c

@@ -638,13 +638,19 @@ xml_log_patchset(uint8_t log_level, const char *function, xmlNode *patchset)

     }

 }

+// Return true if attribute name is not "id"

+static bool

+not_id(xmlAttrPtr attr, void *user_data)

+{

+    return strcmp((const char *) attr->name, XML_ATTR_ID) != 0;

+}

+

 // Apply the removals section of an v1 patchset to an XML node

 static void

 process_v1_removals(xmlNode *target, xmlNode *patch)

 {

     xmlNode *patch_child = NULL;

     xmlNode *cIter = NULL;

-    xmlAttrPtr xIter = NULL;

     char *id = NULL;

     const char *name = NULL;

@@ -677,15 +683,8 @@ process_v1_removals(xmlNode *target, xmlNode *patch)

         return;

     }

-    for (xIter = pcmk__xe_first_attr(patch); xIter != NULL;

-         xIter = xIter->next) {

-        const char *p_name = (const char *)xIter->name;

-

-        // Removing then restoring id would change ordering of properties

-        if (!pcmk__str_eq(p_name, XML_ATTR_ID, pcmk__str_casei)) {

-            xml_remove_prop(target, p_name);

-        }

-    }

+    // Removing then restoring id would change ordering of properties

+    pcmk__xe_remove_matching_attrs(patch, not_id, NULL);

     // Changes to child objects

     cIter = pcmk__xml_first_child(target);