diff --git a/include/crm/msg_xml.h b/include/crm/msg_xml.h
index 5556cac9e6..5c4d42dada 100644
--- a/include/crm/msg_xml.h
+++ b/include/crm/msg_xml.h
@@ -1,299 +1,300 @@
 /*
  * 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_MSG_XML__H
 #  define PCMK__CRM_MSG_XML__H
 
 #  include <crm/common/xml.h>
 
 #if !defined(PCMK_ALLOW_DEPRECATED) || (PCMK_ALLOW_DEPRECATED == 1)
 #include <crm/msg_xml_compat.h>
 #endif
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
 /* This file defines constants for various XML syntax (mainly element and
  * attribute names).
  *
  * For consistency, new constants should start with "PCMK_", followed by:
  * * "XE" for XML element names
  * * "XA" for XML attribute names
  * * "OPT" for cluster option (property) names
  * * "META" for meta-attribute names
  * * "VALUE" for enumerated values for various options
  *
  * Old names that don't follow this policy should eventually be deprecated and
  * replaced with names that do.
  *
  * Symbols should be public if the user may specify them somewhere (especially
  * the CIB) or if they're part of a well-defined structure that a user may need
  * to parse. They should be internal if they're used only internally to
  * Pacemaker (such as daemon IPC/CPG message XML).
  *
  * Constants belong in the following locations:
  * * Public "XE" and "XA": msg_xml.h
  * * Internal "XE" and "XA": crm_internal.h
  * * Public "OPT", "META", and "VALUE": options.h
  * * Internal "OPT", "META", and "VALUE": options_internal.h
  *
  * For meta-attributes that can be specified as either XML attributes or nvpair
  * names, use "META" unless using both "XA" and "META" constants adds clarity.
  * An example is operation attributes, which can be specified either as
  * attributes of the PCMK_XE_OP element or as nvpairs in a meta-attribute set
  * beneath the PCMK_XE_OP element.
  */
 
 /*
  * XML elements
  */
 
+#define PCMK_XE_CONTENT                     "content"
 #define PCMK_XE_DATE_EXPRESSION             "date_expression"
 #define PCMK_XE_LONGDESC                    "longdesc"
 #define PCMK_XE_OP                          "op"
 #define PCMK_XE_OPERATION                   "operation"
 #define PCMK_XE_OP_EXPRESSION               "op_expression"
 #define PCMK_XE_ROLE                        "role"
 #define PCMK_XE_PARAMETER                   "parameter"
 #define PCMK_XE_PARAMETERS                  "parameters"
 #define PCMK_XE_RESOURCE_AGENT              "resource-agent"
 #define PCMK_XE_RSC_EXPRESSION              "rsc_expression"
 #define PCMK_XE_SHORTDESC                   "shortdesc"
 #define PCMK_XE_VERSION                     "version"
 
 
 /*
  * XML attributes
  */
 
 #define PCMK_XA_ADMIN_EPOCH                 "admin_epoch"
 #define PCMK_XA_ATTRIBUTE                   "attribute"
 #define PCMK_XA_BOOLEAN_OP                  "boolean-op"
 #define PCMK_XA_CIB_LAST_WRITTEN            "cib-last-written"
 #define PCMK_XA_CLASS                       "class"
 #define PCMK_XA_CRM_DEBUG_ORIGIN            "crm-debug-origin"
 #define PCMK_XA_CRM_FEATURE_SET             "crm_feature_set"
 #define PCMK_XA_CRM_TIMESTAMP               "crm-timestamp"
 #define PCMK_XA_DC_UUID                     "dc-uuid"
 #define PCMK_XA_DESCRIPTION                 "description"
 #define PCMK_XA_DEVICES                     "devices"
 #define PCMK_XA_EPOCH                       "epoch"
 #define PCMK_XA_EXEC_TIME                   "exec-time"
 #define PCMK_XA_EXIT_REASON                 "exit-reason"
 #define PCMK_XA_FORMAT                      "format"
 #define PCMK_XA_HAVE_QUORUM                 "have-quorum"
 #define PCMK_XA_ID                          "id"
 #define PCMK_XA_ID_REF                      "id-ref"
 #define PCMK_XA_INDEX                       "index"
 #define PCMK_XA_LAST_RC_CHANGE              "last-rc-change"
 #define PCMK_XA_LANG                        "lang"
 #define PCMK_XA_NAME                        "name"
 #define PCMK_XA_NO_QUORUM_PANIC             "no-quorum-panic"
 #define PCMK_XA_NUM_UPDATES                 "num_updates"
 #define PCMK_XA_OP                          "op"
 #define PCMK_XA_OPERATION                   "operation"
 #define PCMK_XA_ORIGIN                      "origin"
 #define PCMK_XA_PATH                        "path"
 #define PCMK_XA_PROVIDER                    "provider"
 #define PCMK_XA_QUEUE_TIME                  "queue-time"
 #define PCMK_XA_REASON                      "reason"
 #define PCMK_XA_REFERENCE                   "reference"
 #define PCMK_XA_REQUEST                     "request"
 #define PCMK_XA_RESOURCE_DISCOVERY          "resource-discovery"
 #define PCMK_XA_RESULT                      "result"
 #define PCMK_XA_ROLE                        "role"
 #define PCMK_XA_SCORE                       "score"
 #define PCMK_XA_SCORE_ATTRIBUTE             "score-attribute"
 #define PCMK_XA_SYMMETRICAL                 "symmetrical"
 #define PCMK_XA_TARGET                      "target"
 #define PCMK_XA_TARGET_ATTRIBUTE            "target-attribute"
 #define PCMK_XA_TARGET_PATTERN              "target-pattern"
 #define PCMK_XA_TARGET_VALUE                "target-value"
 #define PCMK_XA_TYPE                        "type"
 #define PCMK_XA_UNAME                       "uname"
 #define PCMK_XA_UPDATE_CLIENT               "update-client"
 #define PCMK_XA_UPDATE_ORIGIN               "update-origin"
 #define PCMK_XA_UPDATE_USER                 "update-user"
 #define PCMK_XA_VALIDATE_WITH               "validate-with"
 #define PCMK_XA_VALUE                       "value"
 #define PCMK_XA_VALUE_SOURCE                "value-source"
 #define PCMK_XA_VERSION                     "version"
 
 
 /*
  * Older constants that don't follow current naming
  */
 
 #  ifndef T_CRM
 #    define T_CRM     "crmd"
 #  endif
 
 #  ifndef T_ATTRD
 #    define T_ATTRD     "attrd"
 #  endif
 
 #  define CIB_OPTIONS_FIRST "cib-bootstrap-options"
 
 #  define F_CRM_DATA			"crm_xml"
 
 /*---- Common tags/attrs */
 #  define XML_DIFF_MARKER		"__crm_diff_marker__"
 #  define XML_TAG_CIB			"cib"
 #  define XML_TAG_FAILED		"failed"
 
 #  define XML_TAG_OPTIONS		"options"
 
 /*---- top level tags/attrs */
 #  define XML_CRM_TAG_PING		"ping_response"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_INIT "init"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_STARTINGDAEMONS "starting_daemons"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_WAITPING "wait_for_ping"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_RUNNING "running"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_SHUTTINGDOWN "shutting_down"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_SHUTDOWNCOMPLETE "shutdown_complete"
 #  define XML_PING_ATTR_PACEMAKERDSTATE_REMOTE "remote"
 
 #  define XML_FAIL_TAG_CIB		"failed_update"
 
 /*---- CIB specific tags/attrs */
 #  define XML_CIB_TAG_SECTION_ALL	"all"
 #  define XML_CIB_TAG_CONFIGURATION	"configuration"
 #  define XML_CIB_TAG_STATUS       	"status"
 #  define XML_CIB_TAG_RESOURCES		"resources"
 #  define XML_CIB_TAG_NODES         	"nodes"
 #  define XML_CIB_TAG_CONSTRAINTS   	"constraints"
 #  define XML_CIB_TAG_CRMCONFIG   	"crm_config"
 #  define XML_CIB_TAG_OPCONFIG		"op_defaults"
 #  define XML_CIB_TAG_RSCCONFIG   	"rsc_defaults"
 #  define XML_CIB_TAG_ACLS   		"acls"
 #  define XML_CIB_TAG_ALERTS    	"alerts"
 #  define XML_CIB_TAG_ALERT   		"alert"
 #  define XML_CIB_TAG_ALERT_RECIPIENT	"recipient"
 #  define XML_CIB_TAG_ALERT_SELECT      "select"
 #  define XML_CIB_TAG_ALERT_ATTRIBUTES  "select_attributes"
 #  define XML_CIB_TAG_ALERT_FENCING     "select_fencing"
 #  define XML_CIB_TAG_ALERT_NODES       "select_nodes"
 #  define XML_CIB_TAG_ALERT_RESOURCES   "select_resources"
 #  define XML_CIB_TAG_ALERT_ATTR        "attribute"
 
 #  define XML_CIB_TAG_STATE         	"node_state"
 #  define XML_CIB_TAG_NODE          	"node"
 #  define XML_CIB_TAG_NVPAIR        	"nvpair"
 
 #  define XML_CIB_TAG_PROPSET	   	"cluster_property_set"
 #  define XML_TAG_ATTR_SETS	   	"instance_attributes"
 #  define XML_TAG_META_SETS	   	"meta_attributes"
 #  define XML_TAG_ATTRS			"attributes"
 #  define XML_TAG_PARAM			"param"
 #  define XML_TAG_UTILIZATION		"utilization"
 
 #  define XML_TAG_RESOURCE_REF		"resource_ref"
 #  define XML_CIB_TAG_RESOURCE	  	"primitive"
 #  define XML_CIB_TAG_GROUP	  	"group"
 #  define XML_CIB_TAG_INCARNATION	"clone"
 #  define XML_CIB_TAG_CONTAINER		"bundle"
 
 #  define XML_CIB_TAG_RSC_TEMPLATE	"template"
 
 #  define XML_CIB_TAG_LRM		"lrm"
 #  define XML_LRM_TAG_RESOURCES     	"lrm_resources"
 #  define XML_LRM_TAG_RESOURCE     	"lrm_resource"
 #  define XML_LRM_TAG_RSC_OP		"lrm_rsc_op"
 
 #  define XML_NODE_IS_REMOTE    	"remote_node"
 #  define XML_NODE_IS_FENCED		"node_fenced"
 #  define XML_NODE_IS_MAINTENANCE   "node_in_maintenance"
 
 #  define XML_CIB_ATTR_SHUTDOWN       	"shutdown"
 
 #  define XML_TAG_GRAPH			"transition_graph"
 #  define XML_GRAPH_TAG_RSC_OP		"rsc_op"
 #  define XML_GRAPH_TAG_PSEUDO_EVENT	"pseudo_event"
 #  define XML_GRAPH_TAG_CRM_EVENT	"crm_event"
 #  define XML_GRAPH_TAG_DOWNED            "downed"
 #  define XML_GRAPH_TAG_MAINTENANCE       "maintenance"
 
 #  define XML_TAG_RULE			"rule"
 
 #  define XML_TAG_EXPRESSION		"expression"
 
 #  define XML_CONS_TAG_RSC_DEPEND	"rsc_colocation"
 #  define XML_CONS_TAG_RSC_ORDER	"rsc_order"
 #  define XML_CONS_TAG_RSC_LOCATION	"rsc_location"
 #  define XML_CONS_TAG_RSC_TICKET	"rsc_ticket"
 #  define XML_CONS_TAG_RSC_SET		"resource_set"
 
 #  define XML_COLOC_ATTR_SOURCE		"rsc"
 #  define XML_COLOC_ATTR_SOURCE_ROLE	"rsc-role"
 #  define XML_COLOC_ATTR_TARGET		"with-rsc"
 #  define XML_COLOC_ATTR_TARGET_ROLE	"with-rsc-role"
 #  define XML_COLOC_ATTR_NODE_ATTR	"node-attribute"
 #  define XML_COLOC_ATTR_INFLUENCE          "influence"
 
 #  define XML_LOC_ATTR_SOURCE           "rsc"
 #  define XML_LOC_ATTR_SOURCE_PATTERN   "rsc-pattern"
 
 #  define XML_ORDER_ATTR_FIRST		"first"
 #  define XML_ORDER_ATTR_THEN		"then"
 #  define XML_ORDER_ATTR_FIRST_ACTION	"first-action"
 #  define XML_ORDER_ATTR_THEN_ACTION	"then-action"
 #  define XML_ORDER_ATTR_KIND		"kind"
 
 #  define XML_TICKET_ATTR_TICKET	"ticket"
 #  define XML_TICKET_ATTR_LOSS_POLICY	"loss-policy"
 
 #  define XML_NODE_ATTR_RSC_DISCOVERY   "resource-discovery-enabled"
 
 #  define XML_CIB_TAG_GENERATION_TUPPLE	"generation_tuple"
 
 #  define XML_TAG_TRANSIENT_NODEATTRS	"transient_attributes"
 
 #  define XML_ACL_TAG_USER		"acl_target"
 #  define XML_ACL_TAG_USERv1		"acl_user"
 #  define XML_ACL_TAG_GROUP		"acl_group"
 #  define XML_ACL_TAG_ROLE		"acl_role"
 #  define XML_ACL_TAG_PERMISSION	"acl_permission"
 #  define XML_ACL_TAG_ROLE_REFv1	"role_ref"
 #  define XML_ACL_ATTR_KIND		"kind"
 #  define XML_ACL_TAG_READ		"read"
 #  define XML_ACL_TAG_WRITE		"write"
 #  define XML_ACL_TAG_DENY		"deny"
 #  define XML_ACL_ATTR_REFv1		"ref"
 #  define XML_ACL_ATTR_TAG		"object-type"
 #  define XML_ACL_ATTR_TAGv1		"tag"
 #  define XML_ACL_ATTR_XPATH		"xpath"
 
 #  define XML_CIB_TAG_TICKETS		"tickets"
 #  define XML_CIB_TAG_TICKET_STATE	"ticket_state"
 
 #  define XML_CIB_TAG_TAGS   		"tags"
 #  define XML_CIB_TAG_TAG   		"tag"
 #  define XML_CIB_TAG_OBJ_REF 		"obj_ref"
 
 #  define XML_TAG_FENCING_TOPOLOGY      "fencing-topology"
 #  define XML_TAG_FENCING_LEVEL         "fencing-level"
 
 #  define XML_TAG_DIFF                  "diff"
 #  define XML_DIFF_VERSION              PCMK_XE_VERSION
 #  define XML_DIFF_VSOURCE              "source"
 #  define XML_DIFF_VTARGET              "target"
 #  define XML_DIFF_CHANGE               "change"
 #  define XML_DIFF_LIST                 "change-list"
 #  define XML_DIFF_ATTR                 "change-attr"
 #  define XML_DIFF_RESULT               "change-result"
 #  define XML_DIFF_POSITION             "position"
 
 #  define ID(x) crm_element_value(x, PCMK_XA_ID)
 
 #ifdef __cplusplus
 }
 #endif
 
 #endif
diff --git a/lib/common/options.c b/lib/common/options.c
index 62fcc8ca7b..598e4e7b05 100644
--- a/lib/common/options.c
+++ b/lib/common/options.c
@@ -1,592 +1,593 @@
 /*
  * 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 _GNU_SOURCE
 #  define _GNU_SOURCE
 #endif
 
 #include <crm_internal.h>
 
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
 #include <crm/crm.h>
 #include <crm/msg_xml.h>
 
 void
 pcmk__cli_help(char cmd)
 {
     if (cmd == 'v' || cmd == '$') {
         printf("Pacemaker %s\n", PACEMAKER_VERSION);
         printf("Written by Andrew Beekhof and "
                "the Pacemaker project contributors\n");
 
     } else if (cmd == '!') {
         printf("Pacemaker %s (Build: %s): %s\n", PACEMAKER_VERSION, BUILD_VERSION, CRM_FEATURES);
     }
 
     crm_exit(CRM_EX_OK);
     while(1); // above does not return
 }
 
 
 /*
  * Environment variable option handling
  */
 
 /*!
  * \internal
  * \brief Get the value of a Pacemaker environment variable option
  *
  * If an environment variable option is set, with either a PCMK_ or (for
  * backward compatibility) HA_ prefix, log and return the value.
  *
  * \param[in] option  Environment variable name (without prefix)
  *
  * \return Value of environment variable option, or NULL in case of
  *         option name too long or value not found
  */
 const char *
 pcmk__env_option(const char *option)
 {
     const char *const prefixes[] = {"PCMK_", "HA_"};
     char env_name[NAME_MAX];
     const char *value = NULL;
 
     CRM_CHECK(!pcmk__str_empty(option), return NULL);
 
     for (int i = 0; i < PCMK__NELEM(prefixes); i++) {
         int rv = snprintf(env_name, NAME_MAX, "%s%s", prefixes[i], option);
 
         if (rv < 0) {
             crm_err("Failed to write %s%s to buffer: %s", prefixes[i], option,
                     strerror(errno));
             return NULL;
         }
 
         if (rv >= sizeof(env_name)) {
             crm_trace("\"%s%s\" is too long", prefixes[i], option);
             continue;
         }
 
         value = getenv(env_name);
         if (value != NULL) {
             crm_trace("Found %s = %s", env_name, value);
             return value;
         }
     }
 
     crm_trace("Nothing found for %s", option);
     return NULL;
 }
 
 /*!
  * \brief Set or unset a Pacemaker environment variable option
  *
  * Set an environment variable option with a \c "PCMK_" prefix and optionally
  * an \c "HA_" prefix for backward compatibility.
  *
  * \param[in] option  Environment variable name (without prefix)
  * \param[in] value   New value (or NULL to unset)
  * \param[in] compat  If false and \p value is not \c NULL, set only
  *                    \c "PCMK_<option>"; otherwise, set (or unset) both
  *                    \c "PCMK_<option>" and \c "HA_<option>"
  *
  * \note \p compat is ignored when \p value is \c NULL. A \c NULL \p value
  *       means we're unsetting \p option. \c pcmk__get_env_option() checks for
  *       both prefixes, so we want to clear them both.
  */
 void
 pcmk__set_env_option(const char *option, const char *value, bool compat)
 {
     // @COMPAT Drop support for "HA_" options eventually
     const char *const prefixes[] = {"PCMK_", "HA_"};
     char env_name[NAME_MAX];
 
     CRM_CHECK(!pcmk__str_empty(option) && (strchr(option, '=') == NULL),
               return);
 
     for (int i = 0; i < PCMK__NELEM(prefixes); i++) {
         int rv = snprintf(env_name, NAME_MAX, "%s%s", prefixes[i], option);
 
         if (rv < 0) {
             crm_err("Failed to write %s%s to buffer: %s", prefixes[i], option,
                     strerror(errno));
             return;
         }
 
         if (rv >= sizeof(env_name)) {
             crm_trace("\"%s%s\" is too long", prefixes[i], option);
             continue;
         }
 
         if (value != NULL) {
             crm_trace("Setting %s to %s", env_name, value);
             rv = setenv(env_name, value, 1);
         } else {
             crm_trace("Unsetting %s", env_name);
             rv = unsetenv(env_name);
         }
 
         if (rv < 0) {
             crm_err("Failed to %sset %s: %s", (value != NULL)? "" : "un",
                     env_name, strerror(errno));
         }
 
         if (!compat && (value != NULL)) {
             // For set, don't proceed to HA_<option> unless compat is enabled
             break;
         }
     }
 }
 
 /*!
  * \internal
  * \brief Check whether Pacemaker environment variable option is enabled
  *
  * Given a Pacemaker environment variable option that can either be boolean
  * or a list of daemon names, return true if the option is enabled for a given
  * daemon.
  *
  * \param[in] daemon   Daemon name (can be NULL)
  * \param[in] option   Pacemaker environment variable name
  *
  * \return true if variable is enabled for daemon, otherwise false
  */
 bool
 pcmk__env_option_enabled(const char *daemon, const char *option)
 {
     const char *value = pcmk__env_option(option);
 
     return (value != NULL)
         && (crm_is_true(value)
             || ((daemon != NULL) && (strstr(value, daemon) != NULL)));
 }
 
 
 /*
  * Cluster option handling
  */
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid interval specification
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid interval specification, or \c false
  *         otherwise
  */
 bool
 pcmk__valid_interval_spec(const char *value)
 {
     return pcmk_parse_interval_spec(value, NULL) == pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid boolean value
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid boolean value, or \c false otherwise
  */
 bool
 pcmk__valid_boolean(const char *value)
 {
     return crm_str_to_boolean(value, NULL) == 1;
 }
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid integer
  *
  * Valid values include \c INFINITY, \c -INFINITY, and all 64-bit integers.
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid integer, or \c false otherwise
  */
 bool
 pcmk__valid_int(const char *value)
 {
     return (value != NULL)
            && (pcmk_str_is_infinity(value)
                || pcmk_str_is_minus_infinity(value)
                || (pcmk__scan_ll(value, NULL, 0LL) == pcmk_rc_ok));
 }
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid positive integer
  *
  * Valid values include \c INFINITY and all 64-bit positive integers.
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid positive integer, or \c false
  *         otherwise
  */
 bool
 pcmk__valid_positive_int(const char *value)
 {
     long long num = 0LL;
 
     return pcmk_str_is_infinity(value)
            || ((pcmk__scan_ll(value, &num, 0LL) == pcmk_rc_ok)
                && (num > 0));
 }
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid
  *        \c PCMK__OPT_NO_QUORUM_POLICY value
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid \c PCMK__OPT_NO_QUORUM_POLICY value,
  *         or \c false otherwise
  */
 bool
 pcmk__valid_no_quorum_policy(const char *value)
 {
     return pcmk__strcase_any_of(value,
                                 "stop", "freeze", "ignore", "demote", "suicide",
                                 NULL);
 }
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid percentage
  *
  * Valid values include long integers, with an optional trailing string
  * beginning with '%'.
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid percentage value, or \c false
  *         otherwise
  */
 bool
 pcmk__valid_percentage(const char *value)
 {
     char *end = NULL;
     float number = strtof(value, &end);
 
     return ((end == NULL) || (end[0] == '%')) && (number >= 0);
 }
 
 /*!
  * \internal
  * \brief Check whether a string represents a valid script
  *
  * Valid values include \c /dev/null and paths of executable regular files
  *
  * \param[in] value  String to validate
  *
  * \return \c true if \p value is a valid script, or \c false otherwise
  */
 bool
 pcmk__valid_script(const char *value)
 {
     struct stat st;
 
     if (pcmk__str_eq(value, "/dev/null", pcmk__str_none)) {
         return true;
     }
 
     if (stat(value, &st) != 0) {
         crm_err("Script %s does not exist", value);
         return false;
     }
 
     if (S_ISREG(st.st_mode) == 0) {
         crm_err("Script %s is not a regular file", value);
         return false;
     }
 
     if ((st.st_mode & (S_IXUSR | S_IXGRP)) == 0) {
         crm_err("Script %s is not executable", value);
         return false;
     }
 
     return true;
 }
 
 /*!
  * \internal
  * \brief Check a table of configured options for a particular option
  *
  * \param[in,out] options    Name/value pairs for configured options
  * \param[in]     validate   If not NULL, validator function for option value
  * \param[in]     name       Option name to look for
  * \param[in]     old_name   Alternative option name to look for
  * \param[in]     def_value  Default to use if option not configured
  *
  * \return Option value (from supplied options table or default value)
  */
 static const char *
 cluster_option_value(GHashTable *options, bool (*validate)(const char *),
                      const char *name, const char *old_name,
                      const char *def_value)
 {
     const char *value = NULL;
     char *new_value = NULL;
 
     CRM_ASSERT(name != NULL);
 
     if (options) {
         value = g_hash_table_lookup(options, name);
 
         if ((value == NULL) && old_name) {
             value = g_hash_table_lookup(options, old_name);
             if (value != NULL) {
                 pcmk__config_warn("Support for legacy name '%s' for cluster "
                                   "option '%s' is deprecated and will be "
                                   "removed in a future release",
                                   old_name, name);
 
                 // Inserting copy with current name ensures we only warn once
                 new_value = strdup(value);
                 g_hash_table_insert(options, strdup(name), new_value);
                 value = new_value;
             }
         }
 
         if (value && validate && (validate(value) == FALSE)) {
             pcmk__config_err("Using default value for cluster option '%s' "
                              "because '%s' is invalid", name, value);
             value = NULL;
         }
 
         if (value) {
             return value;
         }
     }
 
     // No value found, use default
     value = def_value;
 
     if (value == NULL) {
         crm_trace("No value or default provided for cluster option '%s'",
                   name);
         return NULL;
     }
 
     if (validate) {
         CRM_CHECK(validate(value) != FALSE,
                   crm_err("Bug: default value for cluster option '%s' is invalid", name);
                   return NULL);
     }
 
     crm_trace("Using default value '%s' for cluster option '%s'",
               value, name);
     if (options) {
         new_value = strdup(value);
         g_hash_table_insert(options, strdup(name), new_value);
         value = new_value;
     }
     return value;
 }
 
 /*!
  * \internal
  * \brief Get the value of a cluster option
  *
  * \param[in,out] options      Name/value pairs for configured options
  * \param[in]     option_list  Possible cluster options
  * \param[in]     len          Length of \p option_list
  * \param[in]     name         (Primary) option name to look for
  *
  * \return Option value
  */
 const char *
 pcmk__cluster_option(GHashTable *options,
                      const pcmk__cluster_option_t *option_list,
                      int len, const char *name)
 {
     const char *value = NULL;
 
     for (int lpc = 0; lpc < len; lpc++) {
         if (pcmk__str_eq(name, option_list[lpc].name, pcmk__str_casei)) {
             value = cluster_option_value(options, option_list[lpc].is_valid,
                                          option_list[lpc].name,
                                          option_list[lpc].alt_name,
                                          option_list[lpc].default_value);
             return value;
         }
     }
     CRM_CHECK(FALSE, crm_err("Bug: looking for unknown option '%s'", name));
     return NULL;
 }
 
 /*!
  * \internal
  * \brief Add a description element to a meta-data string
  *
  * \param[in,out] s       Meta-data string to add to
  * \param[in]     tag     Name of element to add (\c PCMK_XE_LONGDESC or
  *                        \c PCMK_XE_SHORTDESC)
  * \param[in]     desc    Textual description to add
  * \param[in]     values  If not \p NULL, the allowed values for the parameter
  * \param[in]     spaces  If not \p NULL, spaces to insert at the beginning of
  *                        each line
  */
 static void
 add_desc(GString *s, const char *tag, const char *desc, const char *values,
          const char *spaces)
 {
     char *escaped_en = crm_xml_escape(desc);
 
     if (spaces != NULL) {
         g_string_append(s, spaces);
     }
     pcmk__g_strcat(s,
                    "<", tag, " " PCMK_XA_LANG "=\"" PCMK__VALUE_EN "\">",
                    escaped_en, NULL);
 
     if (values != NULL) {
         // Append a period if desc doesn't end in "." or ".)"
         if (!pcmk__str_empty(escaped_en)
             && (s->str[s->len - 1] != '.')
             && ((s->str[s->len - 2] != '.') || (s->str[s->len - 1] != ')'))) {
 
             g_string_append_c(s, '.');
         }
         pcmk__g_strcat(s, " Allowed values: ", values, NULL);
         g_string_append_c(s, '.');
     }
     pcmk__g_strcat(s, "</", tag, ">\n", NULL);
 
 #ifdef ENABLE_NLS
     {
         static const char *locale = NULL;
 
         char *localized = crm_xml_escape(_(desc));
 
         if (strcmp(escaped_en, localized) != 0) {
             if (locale == NULL) {
                 locale = strtok(setlocale(LC_ALL, NULL), "_");
             }
 
             if (spaces != NULL) {
                 g_string_append(s, spaces);
             }
             pcmk__g_strcat(s,
                            "<", tag, " " PCMK_XA_LANG "=\"", locale, "\">",
                            localized, NULL);
 
             if (values != NULL) {
                 pcmk__g_strcat(s, _("  Allowed values: "), _(values), NULL);
             }
             pcmk__g_strcat(s, "</", tag, ">\n", NULL);
         }
         free(localized);
     }
 #endif
 
     free(escaped_en);
 }
 
 gchar *
 pcmk__format_option_metadata(const char *name, const char *desc_short,
                              const char *desc_long,
                              pcmk__cluster_option_t *option_list, int len)
 {
     /* big enough to hold "pacemaker-schedulerd metadata" output */
     GString *s = g_string_sized_new(13000);
 
     pcmk__g_strcat(s,
                    "<?xml " PCMK_XA_VERSION "=\"1.0\"?>\n"
                    "<" PCMK_XE_RESOURCE_AGENT " "
                        PCMK_XA_NAME "=\"", name, "\" "
                        PCMK_XA_VERSION "=\"" PACEMAKER_VERSION "\">\n"
 
                    "  <" PCMK_XE_VERSION ">" PCMK_OCF_VERSION
                      "</" PCMK_XE_VERSION ">\n", NULL);
 
     add_desc(s, PCMK_XE_LONGDESC, desc_long, NULL, "  ");
     add_desc(s, PCMK_XE_SHORTDESC, desc_short, NULL, "  ");
 
     g_string_append(s, "  <" PCMK_XE_PARAMETERS ">\n");
 
     for (int lpc = 0; lpc < len; lpc++) {
         const char *opt_name = option_list[lpc].name;
         const char *opt_type = option_list[lpc].type;
         const char *opt_values = option_list[lpc].values;
         const char *opt_default = option_list[lpc].default_value;
         const char *opt_desc_short = option_list[lpc].description_short;
         const char *opt_desc_long = option_list[lpc].description_long;
 
         // The standard requires long and short parameter descriptions
         CRM_ASSERT((opt_desc_short != NULL) || (opt_desc_long != NULL));
 
         if (opt_desc_short == NULL) {
             opt_desc_short = opt_desc_long;
         } else if (opt_desc_long == NULL) {
             opt_desc_long = opt_desc_short;
         }
 
         // The standard requires a parameter type
         CRM_ASSERT(opt_type != NULL);
 
         pcmk__g_strcat(s,
                        "    <" PCMK_XE_PARAMETER " "
                                PCMK_XA_NAME "=\"", opt_name, "\">\n", NULL);
 
         add_desc(s, PCMK_XE_LONGDESC, opt_desc_long, opt_values, "      ");
         add_desc(s, PCMK_XE_SHORTDESC, opt_desc_short, NULL, "      ");
 
-        pcmk__g_strcat(s, "      <content type=\"", opt_type, "\"", NULL);
+        pcmk__g_strcat(s, "      <" PCMK_XE_CONTENT " "
+                                    PCMK_XA_TYPE "=\"", opt_type, "\"", NULL);
         if (opt_default != NULL) {
             pcmk__g_strcat(s, " default=\"", opt_default, "\"", NULL);
         }
 
         if ((opt_values != NULL) && (strcmp(opt_type, "select") == 0)) {
             char *str = strdup(opt_values);
             const char *delim = ", ";
             char *ptr = strtok(str, delim);
 
             g_string_append(s, ">\n");
 
             while (ptr != NULL) {
                 pcmk__g_strcat(s, "        <option value=\"", ptr, "\" />\n",
                                NULL);
                 ptr = strtok(NULL, delim);
             }
-            g_string_append_printf(s, "      </content>\n");
+            g_string_append(s, "      </" PCMK_XE_CONTENT ">\n");
             free(str);
 
         } else {
             g_string_append(s, "/>\n");
         }
 
         g_string_append(s, "    </" PCMK_XE_PARAMETER ">\n");
     }
     g_string_append(s,
                     "  </" PCMK_XE_PARAMETERS ">\n"
                     "</" PCMK_XE_RESOURCE_AGENT ">\n");
 
     return g_string_free(s, FALSE);
 }
 
 void
 pcmk__validate_cluster_options(GHashTable *options,
                                pcmk__cluster_option_t *option_list, int len)
 {
     for (int lpc = 0; lpc < len; lpc++) {
         cluster_option_value(options, option_list[lpc].is_valid,
                              option_list[lpc].name,
                              option_list[lpc].alt_name,
                              option_list[lpc].default_value);
     }
 }
diff --git a/tools/crm_shadow.c b/tools/crm_shadow.c
index fea66d6e19..92a478037f 100644
--- a/tools/crm_shadow.c
+++ b/tools/crm_shadow.c
@@ -1,1309 +1,1309 @@
 /*
  * 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 <stdio.h>
 #include <unistd.h>
 
 #include <sys/param.h>
 #include <crm/crm.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <crm/msg_xml.h>
 
 #include <crm/common/cmdline_internal.h>
 #include <crm/common/ipc.h>
 #include <crm/common/output_internal.h>
 #include <crm/common/xml.h>
 
 #include <crm/cib.h>
 #include <crm/cib/internal.h>
 
 #define SUMMARY "perform Pacemaker configuration changes in a sandbox\n\n"  \
                 "This command sets up an environment in which "             \
                 "configuration tools (cibadmin,\n"                          \
                 "crm_resource, etc.) work offline instead of against a "    \
                 "live cluster, allowing\n"                                  \
                 "changes to be previewed and tested for side effects."
 
 #define INDENT "                              "
 
 enum shadow_command {
     shadow_cmd_none = 0,
     shadow_cmd_which,
     shadow_cmd_display,
     shadow_cmd_diff,
     shadow_cmd_file,
     shadow_cmd_create,
     shadow_cmd_create_empty,
     shadow_cmd_commit,
     shadow_cmd_delete,
     shadow_cmd_edit,
     shadow_cmd_reset,
     shadow_cmd_switch,
 };
 
 /*!
  * \internal
  * \enum shadow_disp_flags
  * \brief Bit flags to control which fields of shadow CIB info are displayed
  *
  * \note Ignored for XML output.
  */
 enum shadow_disp_flags {
     shadow_disp_instance = (1 << 0),
     shadow_disp_file     = (1 << 1),
     shadow_disp_content  = (1 << 2),
     shadow_disp_diff     = (1 << 3),
 };
 
 static crm_exit_t exit_code = CRM_EX_OK;
 
 static struct {
     enum shadow_command cmd;
     int cmd_options;
     char *instance;
     gboolean force;
     gboolean batch;
     gboolean full_upload;
     gchar *validate_with;
 } options = {
     .cmd_options = cib_sync_call,
 };
 
 /*!
  * \internal
  * \brief Display an instruction to the user
  *
  * \param[in,out] out  Output object
  * \param[in]     ...  Message arguments
  *
  * \return Standard Pacemaker return code
  *
  * \note The variadic message arguments are of the following format:
  *       -# Instructional message
  */
 PCMK__OUTPUT_ARGS("instruction", "const char *")
 static int
 instruction_default(pcmk__output_t *out, va_list args)
 {
     const char *msg = va_arg(args, const char *);
 
     if (msg == NULL) {
         return pcmk_rc_no_output;
     }
     return out->info(out, "%s", msg);
 }
 
 /*!
  * \internal
  * \brief Display an instruction to the user
  *
  * \param[in,out] out  Output object
  * \param[in]     ...  Message arguments
  *
  * \return Standard Pacemaker return code
  *
  * \note The variadic message arguments are of the following format:
  *       -# Instructional message
  */
 PCMK__OUTPUT_ARGS("instruction", "const char *")
 static int
 instruction_xml(pcmk__output_t *out, va_list args)
 {
     const char *msg = va_arg(args, const char *);
 
     if (msg == NULL) {
         return pcmk_rc_no_output;
     }
     pcmk__output_create_xml_text_node(out, "instruction", msg);
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Display information about a shadow CIB instance
  *
  * \param[in,out] out  Output object
  * \param[in]     ...  Message arguments
  *
  * \return Standard Pacemaker return code
  *
  * \note The variadic message arguments are of the following format:
  *       -# Instance name (can be \p NULL)
  *       -# Shadow file name (can be \p NULL)
  *       -# Shadow file content (can be \p NULL)
  *       -# Patchset containing the changes in the shadow CIB (can be \p NULL)
  *       -# Group of \p shadow_disp_flags indicating which fields to display
  */
 PCMK__OUTPUT_ARGS("shadow", "const char *", "const char *", "const xmlNode *",
                   "const xmlNode *", "enum shadow_disp_flags")
 static int
 shadow_default(pcmk__output_t *out, va_list args)
 {
     const char *instance = va_arg(args, const char *);
     const char *filename = va_arg(args, const char *);
     const xmlNode *content = va_arg(args, const xmlNode *);
     const xmlNode *diff = va_arg(args, const xmlNode *);
     enum shadow_disp_flags flags = (enum shadow_disp_flags) va_arg(args, int);
 
     int rc = pcmk_rc_no_output;
 
     if (pcmk_is_set(flags, shadow_disp_instance)) {
         rc = out->info(out, "Instance: %s", pcmk__s(instance, "<unknown>"));
     }
     if (pcmk_is_set(flags, shadow_disp_file)) {
         rc = out->info(out, "File name: %s", pcmk__s(filename, "<unknown>"));
     }
     if (pcmk_is_set(flags, shadow_disp_content)) {
         rc = out->info(out, "Content:");
 
         if (content != NULL) {
             char *buf = pcmk__trim(dump_xml_formatted_with_text(content));
 
             if (!pcmk__str_empty(buf)) {
                 out->info(out, "%s", buf);
             }
             free(buf);
 
         } else {
             out->info(out, "<unknown>");
         }
     }
     if (pcmk_is_set(flags, shadow_disp_diff)) {
         rc = out->info(out, "Diff:");
 
         if (diff != NULL) {
             out->message(out, "xml-patchset", diff);
         } else {
             out->info(out, "<empty>");
         }
     }
 
     return rc;
 }
 
 /*!
  * \internal
  * \brief Display information about a shadow CIB instance
  *
  * \param[in,out] out  Output object
  * \param[in]     ...  Message arguments
  *
  * \return Standard Pacemaker return code
  *
  * \note The variadic message arguments are of the following format:
  *       -# Instance name (can be \p NULL)
  *       -# Shadow file name (can be \p NULL)
  *       -# Shadow file content (can be \p NULL)
  *       -# Patchset containing the changes in the shadow CIB (can be \p NULL)
  *       -# Group of \p shadow_disp_flags indicating which fields to display
  */
 PCMK__OUTPUT_ARGS("shadow", "const char *", "const char *", "const xmlNode *",
                   "const xmlNode *", "enum shadow_disp_flags")
 static int
 shadow_text(pcmk__output_t *out, va_list args)
 {
     if (!out->is_quiet(out)) {
         return shadow_default(out, args);
 
     } else {
         const char *instance = va_arg(args, const char *);
         const char *filename = va_arg(args, const char *);
         const xmlNode *content = va_arg(args, const xmlNode *);
         const xmlNode *diff = va_arg(args, const xmlNode *);
         enum shadow_disp_flags flags = (enum shadow_disp_flags) va_arg(args, int);
 
         int rc = pcmk_rc_no_output;
         bool quiet_orig = out->quiet;
 
         /* We have to disable quiet mode for the "xml-patchset" message if we
          * call it, so we might as well do so for this whole section.
          */
         out->quiet = false;
 
         if (pcmk_is_set(flags, shadow_disp_instance) && (instance != NULL)) {
             rc = out->info(out, "%s", instance);
         }
         if (pcmk_is_set(flags, shadow_disp_file) && (filename != NULL)) {
             rc = out->info(out, "%s", filename);
         }
         if (pcmk_is_set(flags, shadow_disp_content) && (content != NULL)) {
             char *buf = pcmk__trim(dump_xml_formatted_with_text(content));
 
             rc = out->info(out, "%s", pcmk__trim(buf));
             free(buf);
         }
         if (pcmk_is_set(flags, shadow_disp_diff) && (diff != NULL)) {
             rc = out->message(out, "xml-patchset", diff);
         }
 
         out->quiet = quiet_orig;
         return rc;
     }
 }
 
 /*!
  * \internal
  * \brief Display information about a shadow CIB instance
  *
  * \param[in,out] out  Output object
  * \param[in]     ...  Message arguments
  *
  * \return Standard Pacemaker return code
  *
  * \note The variadic message arguments are of the following format:
  *       -# Instance name (can be \p NULL)
  *       -# Shadow file name (can be \p NULL)
  *       -# Shadow file content (can be \p NULL)
  *       -# Patchset containing the changes in the shadow CIB (can be \p NULL)
  *       -# Group of \p shadow_disp_flags indicating which fields to display
  *          (ignored)
  */
 PCMK__OUTPUT_ARGS("shadow", "const char *", "const char *", "const xmlNode *",
                   "const xmlNode *", "enum shadow_disp_flags")
 static int
 shadow_xml(pcmk__output_t *out, va_list args)
 {
     const char *instance = va_arg(args, const char *);
     const char *filename = va_arg(args, const char *);
     const xmlNode *content = va_arg(args, const xmlNode *);
     const xmlNode *diff = va_arg(args, const xmlNode *);
     enum shadow_disp_flags flags G_GNUC_UNUSED =
         (enum shadow_disp_flags) va_arg(args, int);
 
     pcmk__output_xml_create_parent(out, "shadow",
                                    "instance", instance,
                                    "file", filename,
                                    NULL);
 
     if (content != NULL) {
         char *buf = dump_xml_formatted_with_text(content);
 
-        out->output_xml(out, "content", buf);
+        out->output_xml(out, PCMK_XE_CONTENT, buf);
         free(buf);
     }
 
     if (diff != NULL) {
         out->message(out, "xml-patchset", diff);
     }
 
     pcmk__output_xml_pop_parent(out);
     return pcmk_rc_ok;
 }
 
 static const pcmk__supported_format_t formats[] = {
     PCMK__SUPPORTED_FORMAT_NONE,
     PCMK__SUPPORTED_FORMAT_TEXT,
     PCMK__SUPPORTED_FORMAT_XML,
     { NULL, NULL, NULL }
 };
 
 static const pcmk__message_entry_t fmt_functions[] = {
     { "instruction", "default", instruction_default },
     { "instruction", "xml", instruction_xml },
     { "shadow", "default", shadow_default },
     { "shadow", "text", shadow_text },
     { "shadow", "xml", shadow_xml },
 
     { NULL, NULL, NULL }
 };
 
 /*!
  * \internal
  * \brief Set the error when \p --force is not passed with a dangerous command
  *
  * \param[in]  reason         Why command is dangerous
  * \param[in]  for_shadow     If true, command is dangerous to the shadow file.
  *                            Otherwise, command is dangerous to the active
  *                            cluster.
  * \param[in]  show_mismatch  If true and the supplied shadow instance is not
  *                            the same as the active shadow instance, report
  *                            this
  * \param[out] error          Where to store error
  */
 static void
 set_danger_error(const char *reason, bool for_shadow, bool show_mismatch,
                  GError **error)
 {
     const char *active = getenv("CIB_shadow");
     char *full = NULL;
 
     if (show_mismatch
         && !pcmk__str_eq(active, options.instance, pcmk__str_null_matches)) {
 
         full = crm_strdup_printf("%s.\nAdditionally, the supplied shadow "
                                  "instance (%s) is not the same as the active "
                                  "one (%s)",
                                 reason, options.instance, active);
         reason = full;
     }
 
     g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                 "%s%sTo prevent accidental destruction of the %s, the --force "
                 "flag is required in order to proceed.",
                 pcmk__s(reason, ""), ((reason != NULL)? ".\n" : ""),
                 (for_shadow? "shadow file" : "cluster"));
     free(full);
 }
 
 /*!
  * \internal
  * \brief Get the active shadow instance from the environment
  *
  * This sets \p options.instance to the value of the \p CIB_shadow env variable.
  *
  * \param[out] error  Where to store error
  */
 static int
 get_instance_from_env(GError **error)
 {
     int rc = pcmk_rc_ok;
 
     pcmk__str_update(&options.instance, getenv("CIB_shadow"));
     if (options.instance == NULL) {
         rc = ENXIO;
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "No active shadow configuration defined");
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Validate that the shadow file does or does not exist, as appropriate
  *
  * \param[in]  filename      Absolute path of shadow file
  * \param[in]  should_exist  Whether the shadow file is expected to exist
  * \param[out] error         Where to store error
  *
  * \return Standard Pacemaker return code
  */
 static int
 check_file_exists(const char *filename, bool should_exist, GError **error)
 {
     struct stat buf;
 
     if (!should_exist && (stat(filename, &buf) == 0)) {
         char *reason = crm_strdup_printf("A shadow instance '%s' already "
                                          "exists", options.instance);
 
         exit_code = CRM_EX_CANTCREAT;
         set_danger_error(reason, true, false, error);
         free(reason);
         return EEXIST;
     }
 
     if (should_exist && (stat(filename, &buf) < 0)) {
         // @COMPAT: Use pcmk_rc2exitc(errno)?
         exit_code = CRM_EX_NOSUCH;
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not access shadow instance '%s': %s",
                     options.instance, strerror(errno));
         return errno;
     }
 
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Connect to the "real" (non-shadow) CIB
  *
  * \param[out] real_cib  Where to store CIB connection
  * \param[out] error     Where to store error
  *
  * \return Standard Pacemaker return code
  */
 static int
 connect_real_cib(cib_t **real_cib, GError **error)
 {
     int rc = pcmk_rc_ok;
 
     *real_cib = cib_new_no_shadow();
     if (*real_cib == NULL) {
         rc = ENOMEM;
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not create a CIB connection object");
         return rc;
     }
 
     rc = (*real_cib)->cmds->signon(*real_cib, crm_system_name, cib_command);
     rc = pcmk_legacy2rc(rc);
     if (rc != pcmk_rc_ok) {
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not connect to CIB: %s", pcmk_rc_str(rc));
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Query the "real" (non-shadow) CIB and store the result
  *
  * \param[out]    output    Where to store query output
  * \param[out]    error     Where to store error
  *
  * \return Standard Pacemaker return code
  */
 static int
 query_real_cib(xmlNode **output, GError **error)
 {
     cib_t *real_cib = NULL;
     int rc = connect_real_cib(&real_cib, error);
 
     if (rc != pcmk_rc_ok) {
         goto done;
     }
 
     rc = real_cib->cmds->query(real_cib, NULL, output, options.cmd_options);
     rc = pcmk_legacy2rc(rc);
     if (rc != pcmk_rc_ok) {
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not query the non-shadow CIB: %s", pcmk_rc_str(rc));
     }
 
 done:
     cib_delete(real_cib);
     return rc;
 }
 
 /*!
  * \internal
  * \brief Read XML from the given file
  *
  * \param[in]  filename  Path of input file
  * \param[out] output    Where to store XML read from \p filename
  * \param[out] error     Where to store error
  *
  * \return Standard Pacemaker return code
  */
 static int
 read_xml(const char *filename, xmlNode **output, GError **error)
 {
     int rc = pcmk_rc_ok;
 
     *output = filename2xml(filename);
     if (*output == NULL) {
         rc = pcmk_rc_no_input;
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not parse XML from input file '%s'", filename);
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Write the shadow XML to a file
  *
  * \param[in]  xml       Shadow XML
  * \param[in]  filename  Name of destination file
  * \param[in]  reset     Whether the write is a reset (for logging only)
  * \param[out] error     Where to store error
  */
 static int
 write_shadow_file(const xmlNode *xml, const char *filename, bool reset,
                   GError **error)
 {
     int rc = write_xml_file(xml, filename, FALSE);
 
     if (rc < 0) {
         rc = pcmk_legacy2rc(rc);
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not %s the shadow instance '%s': %s",
                     reset? "reset" : "create", options.instance,
                     pcmk_rc_str(rc));
         return rc;
     }
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Create a shell prompt based on the given shadow instance name
  *
  * \return Newly created prompt
  *
  * \note The caller is responsible for freeing the return value using \p free().
  */
 static inline char *
 get_shadow_prompt(void)
 {
     return crm_strdup_printf("shadow[%.40s] # ", options.instance);
 }
 
 /*!
  * \internal
  * \brief Set up environment variables for a shadow instance
  *
  * \param[in,out] out      Output object
  * \param[in]     do_switch  If true, switch to an existing instance (logging
  *                           only)
  * \param[out]    error      Where to store error
  */
 static void
 shadow_setup(pcmk__output_t *out, bool do_switch, GError **error)
 {
     const char *active = getenv("CIB_shadow");
     const char *prompt = getenv("PS1");
     const char *shell = getenv("SHELL");
     char *new_prompt = get_shadow_prompt();
 
     if (pcmk__str_eq(active, options.instance, pcmk__str_none)
         && pcmk__str_eq(new_prompt, prompt, pcmk__str_none)) {
         // CIB_shadow and prompt environment variables are already set up
         goto done;
     }
 
     if (!options.batch && (shell != NULL)) {
         out->info(out, "Setting up shadow instance");
         setenv("PS1", new_prompt, 1);
         setenv("CIB_shadow", options.instance, 1);
 
         out->message(out, "instruction",
                      "Press Ctrl+D to exit the crm_shadow shell");
 
         if (pcmk__str_eq(shell, "(^|/)bash$", pcmk__str_regex)) {
             execl(shell, shell, "--norc", "--noprofile", NULL);
         } else {
             execl(shell, shell, NULL);
         }
 
         exit_code = pcmk_rc2exitc(errno);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Failed to launch shell '%s': %s",
                     shell, pcmk_rc_str(errno));
 
     } else {
         char *msg = NULL;
         const char *prefix = "A new shadow instance was created. To begin "
                              "using it";
 
         if (do_switch) {
             prefix = "To switch to the named shadow instance";
         }
 
         msg = crm_strdup_printf("%s, enter the following into your shell:\n"
                                 "\texport CIB_shadow=%s",
                                 prefix, options.instance);
         out->message(out, "instruction", msg);
         free(msg);
     }
 
 done:
     free(new_prompt);
 }
 
 /*!
  * \internal
  * \brief Remind the user to clean up the shadow environment
  *
  * \param[in,out] out  Output object
  */
 static void
 shadow_teardown(pcmk__output_t *out)
 {
     const char *active = getenv("CIB_shadow");
     const char *prompt = getenv("PS1");
 
     if (pcmk__str_eq(active, options.instance, pcmk__str_none)) {
         char *our_prompt = get_shadow_prompt();
 
         if (pcmk__str_eq(prompt, our_prompt, pcmk__str_none)) {
             out->message(out, "instruction",
                          "Press Ctrl+D to exit the crm_shadow shell");
 
         } else {
             out->message(out, "instruction",
                          "Remember to unset the CIB_shadow variable by "
                          "entering the following into your shell:\n"
                          "\tunset CIB_shadow");
         }
         free(our_prompt);
     }
 }
 
 /*!
  * \internal
  * \brief Commit the shadow file contents to the active cluster
  *
  * \param[out] error  Where to store error
  */
 static void
 commit_shadow_file(GError **error)
 {
     char *filename = NULL;
     cib_t *real_cib = NULL;
 
     xmlNodePtr input = NULL;
     xmlNodePtr section_xml = NULL;
     const char *section = NULL;
 
     int rc = pcmk_rc_ok;
 
     if (!options.force) {
         const char *reason = "The commit command overwrites the active cluster "
                              "configuration";
 
         exit_code = CRM_EX_USAGE;
         set_danger_error(reason, false, true, error);
         return;
     }
 
     filename = get_shadow_file(options.instance);
     if (check_file_exists(filename, true, error) != pcmk_rc_ok) {
         goto done;
     }
 
     if (connect_real_cib(&real_cib, error) != pcmk_rc_ok) {
         goto done;
     }
 
     if (read_xml(filename, &input, error) != pcmk_rc_ok) {
         goto done;
     }
 
     section_xml = input;
 
     if (!options.full_upload) {
         section = XML_CIB_TAG_CONFIGURATION;
         section_xml = first_named_child(input, section);
     }
 
     rc = real_cib->cmds->replace(real_cib, section, section_xml,
                                  options.cmd_options);
     rc = pcmk_legacy2rc(rc);
 
     if (rc != pcmk_rc_ok) {
         exit_code = pcmk_rc2exitc(rc);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not commit shadow instance '%s' to the CIB: %s",
                     options.instance, pcmk_rc_str(rc));
     }
 
 done:
     free(filename);
     cib_delete(real_cib);
     free_xml(input);
 }
 
 /*!
  * \internal
  * \brief Create a new empty shadow instance
  *
  * \param[in,out] out    Output object
  * \param[out]    error  Where to store error
  *
  * \note If \p --force is given, we try to write the file regardless of whether
  *       it already exists.
  */
 static void
 create_shadow_empty(pcmk__output_t *out, GError **error)
 {
     char *filename = get_shadow_file(options.instance);
     xmlNode *output = NULL;
 
     if (!options.force
         && (check_file_exists(filename, false, error) != pcmk_rc_ok)) {
         goto done;
     }
 
     output = createEmptyCib(0);
     crm_xml_add(output, PCMK_XA_VALIDATE_WITH, options.validate_with);
     out->info(out, "Created new %s configuration",
               crm_element_value(output, PCMK_XA_VALIDATE_WITH));
 
     if (write_shadow_file(output, filename, false, error) != pcmk_rc_ok) {
         goto done;
     }
     shadow_setup(out, false, error);
 
 done:
     free(filename);
     free_xml(output);
 }
 
 /*!
  * \internal
  * \brief Create a shadow instance based on the active CIB
  *
  * \param[in,out] out    Output object
  * \param[in]     reset  If true, overwrite the given existing shadow instance.
  *                       Otherwise, create a new shadow instance with the given
  *                       name.
  * \param[out]    error  Where to store error
  *
  * \note If \p --force is given, we try to write the file regardless of whether
  *       it already exists.
  */
 static void
 create_shadow_from_cib(pcmk__output_t *out, bool reset, GError **error)
 {
     char *filename = get_shadow_file(options.instance);
     xmlNode *output = NULL;
 
     if (!options.force) {
         if (reset) {
             /* @COMPAT: Reset is dangerous to the shadow file, but to preserve
              * compatibility we can't require --force unless there's a mismatch.
              * At a compatibility break, call set_danger_error() with for_shadow
              * and show_mismatch set to true.
              */
             const char *local = getenv("CIB_shadow");
 
             if (!pcmk__str_eq(local, options.instance, pcmk__str_null_matches)) {
                 exit_code = CRM_EX_USAGE;
                 g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                             "The supplied shadow instance (%s) is not the same "
                             "as the active one (%s).\n"
                             "To prevent accidental destruction of the shadow "
                             "file, the --force flag is required in order to "
                             "proceed.",
                             options.instance, local);
                 goto done;
             }
         }
 
         if (check_file_exists(filename, reset, error) != pcmk_rc_ok) {
             goto done;
         }
     }
 
     if (query_real_cib(&output, error) != pcmk_rc_ok) {
         goto done;
     }
 
     if (write_shadow_file(output, filename, reset, error) != pcmk_rc_ok) {
         goto done;
     }
     shadow_setup(out, false, error);
 
 done:
     free(filename);
     free_xml(output);
 }
 
 /*!
  * \internal
  * \brief Delete the shadow file
  *
  * \param[in,out] out  Output object
  * \param[out]    error  Where to store error
  */
 static void
 delete_shadow_file(pcmk__output_t *out, GError **error)
 {
     char *filename = NULL;
 
     if (!options.force) {
         const char *reason = "The delete command removes the specified shadow "
                              "file";
 
         exit_code = CRM_EX_USAGE;
         set_danger_error(reason, true, true, error);
         return;
     }
 
     filename = get_shadow_file(options.instance);
 
     if ((unlink(filename) < 0) && (errno != ENOENT)) {
         exit_code = pcmk_rc2exitc(errno);
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "Could not remove shadow instance '%s': %s",
                     options.instance, strerror(errno));
     } else {
         shadow_teardown(out);
     }
     free(filename);
 }
 
 /*!
  * \internal
  * \brief Open the shadow file in a text editor
  *
  * \param[out] error  Where to store error
  *
  * \note The \p EDITOR environment variable must be set.
  */
 static void
 edit_shadow_file(GError **error)
 {
     char *filename = NULL;
     const char *editor = NULL;
 
     if (get_instance_from_env(error) != pcmk_rc_ok) {
         return;
     }
 
     filename = get_shadow_file(options.instance);
     if (check_file_exists(filename, true, error) != pcmk_rc_ok) {
         goto done;
     }
 
     editor = getenv("EDITOR");
     if (editor == NULL) {
         exit_code = CRM_EX_NOT_CONFIGURED;
         g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                     "No value for EDITOR defined");
         goto done;
     }
 
     execlp(editor, "--", filename, NULL);
     exit_code = CRM_EX_OSFILE;
     g_set_error(error, PCMK__EXITC_ERROR, exit_code,
                 "Could not invoke EDITOR (%s %s): %s",
                 editor, filename, strerror(errno));
 
 done:
     free(filename);
 }
 
 /*!
  * \internal
  * \brief Show the contents of the active shadow instance
  *
  * \param[in,out] out    Output object
  * \param[out]    error  Where to store error
  */
 static void
 show_shadow_contents(pcmk__output_t *out, GError **error)
 {
     char *filename = NULL;
 
     if (get_instance_from_env(error) != pcmk_rc_ok) {
         return;
     }
 
     filename = get_shadow_file(options.instance);
 
     if (check_file_exists(filename, true, error) == pcmk_rc_ok) {
         xmlNode *output = NULL;
         bool quiet_orig = out->quiet;
 
         if (read_xml(filename, &output, error) != pcmk_rc_ok) {
             goto done;
         }
 
         out->quiet = true;
         out->message(out, "shadow",
                      options.instance, NULL, output, NULL, shadow_disp_content);
         out->quiet = quiet_orig;
 
         free_xml(output);
     }
 
 done:
     free(filename);
 }
 
 /*!
  * \internal
  * \brief Show the changes in the active shadow instance
  *
  * \param[in,out] out    Output object
  * \param[out]    error  Where to store error
  */
 static void
 show_shadow_diff(pcmk__output_t *out, GError **error)
 {
     char *filename = NULL;
     xmlNodePtr old_config = NULL;
     xmlNodePtr new_config = NULL;
     xmlNodePtr diff = NULL;
     bool quiet_orig = out->quiet;
 
     if (get_instance_from_env(error) != pcmk_rc_ok) {
         return;
     }
 
     filename = get_shadow_file(options.instance);
     if (check_file_exists(filename, true, error) != pcmk_rc_ok) {
         goto done;
     }
 
     if (query_real_cib(&old_config, error) != pcmk_rc_ok) {
         goto done;
     }
 
     if (read_xml(filename, &new_config, error) != pcmk_rc_ok) {
         goto done;
     }
     xml_track_changes(new_config, NULL, new_config, false);
     xml_calculate_changes(old_config, new_config);
     diff = xml_create_patchset(0, old_config, new_config, NULL, false);
 
     pcmk__log_xml_changes(LOG_INFO, new_config);
     xml_accept_changes(new_config);
 
     out->quiet = true;
     out->message(out, "shadow",
                  options.instance, NULL, NULL, diff, shadow_disp_diff);
     out->quiet = quiet_orig;
 
     if (diff != NULL) {
         /* @COMPAT: Exit with CRM_EX_DIGEST? This is not really an error; we
          * just want to indicate that there are differences (as the diff command
          * does).
          */
         exit_code = CRM_EX_ERROR;
     }
 
 done:
     free(filename);
     free_xml(old_config);
     free_xml(new_config);
     free_xml(diff);
 }
 
 /*!
  * \internal
  * \brief Show the absolute path of the active shadow instance
  *
  * \param[in,out] out    Output object
  * \param[out]    error  Where to store error
  */
 static void
 show_shadow_filename(pcmk__output_t *out, GError **error)
 {
     if (get_instance_from_env(error) == pcmk_rc_ok) {
         char *filename = get_shadow_file(options.instance);
         bool quiet_orig = out->quiet;
 
         out->quiet = true;
         out->message(out, "shadow",
                      options.instance, filename, NULL, NULL, shadow_disp_file);
         out->quiet = quiet_orig;
 
         free(filename);
     }
 }
 
 /*!
  * \internal
  * \brief Show the active shadow instance
  *
  * \param[in,out] out    Output object
  * \param[out]    error  Where to store error
  */
 static void
 show_shadow_instance(pcmk__output_t *out, GError **error)
 {
     if (get_instance_from_env(error) == pcmk_rc_ok) {
         bool quiet_orig = out->quiet;
 
         out->quiet = true;
         out->message(out, "shadow",
                      options.instance, NULL, NULL, NULL, shadow_disp_instance);
         out->quiet = quiet_orig;
     }
 }
 
 /*!
  * \internal
  * \brief Switch to the given shadow instance
  *
  * \param[in,out] out    Output object
  * \param[out]    error  Where to store error
  */
 static void
 switch_shadow_instance(pcmk__output_t *out, GError **error)
 {
     char *filename = NULL;
 
     filename = get_shadow_file(options.instance);
     if (check_file_exists(filename, true, error) == pcmk_rc_ok) {
         shadow_setup(out, true, error);
     }
     free(filename);
 }
 
 static gboolean
 command_cb(const gchar *option_name, const gchar *optarg, gpointer data,
            GError **error)
 {
     if (pcmk__str_any_of(option_name, "-w", "--which", NULL)) {
         options.cmd = shadow_cmd_which;
 
     } else if (pcmk__str_any_of(option_name, "-p", "--display", NULL)) {
         options.cmd = shadow_cmd_display;
 
     } else if (pcmk__str_any_of(option_name, "-d", "--diff", NULL)) {
         options.cmd = shadow_cmd_diff;
 
     } else if (pcmk__str_any_of(option_name, "-F", "--file", NULL)) {
         options.cmd = shadow_cmd_file;
 
     } else if (pcmk__str_any_of(option_name, "-c", "--create", NULL)) {
         options.cmd = shadow_cmd_create;
 
     } else if (pcmk__str_any_of(option_name, "-e", "--create-empty", NULL)) {
         options.cmd = shadow_cmd_create_empty;
 
     } else if (pcmk__str_any_of(option_name, "-C", "--commit", NULL)) {
         options.cmd = shadow_cmd_commit;
 
     } else if (pcmk__str_any_of(option_name, "-D", "--delete", NULL)) {
         options.cmd = shadow_cmd_delete;
 
     } else if (pcmk__str_any_of(option_name, "-E", "--edit", NULL)) {
         options.cmd = shadow_cmd_edit;
 
     } else if (pcmk__str_any_of(option_name, "-r", "--reset", NULL)) {
         options.cmd = shadow_cmd_reset;
 
     } else if (pcmk__str_any_of(option_name, "-s", "--switch", NULL)) {
         options.cmd = shadow_cmd_switch;
 
     } else {
         // Should be impossible
         return FALSE;
     }
 
     // optarg may be NULL and that's okay
     pcmk__str_update(&options.instance, optarg);
     return TRUE;
 }
 
 static GOptionEntry query_entries[] = {
     { "which", 'w', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
       "Indicate the active shadow copy", NULL },
 
     { "display", 'p', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
       "Display the contents of the active shadow copy", NULL },
 
     { "diff", 'd', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
       "Display the changes in the active shadow copy", NULL },
 
     { "file", 'F', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
       "Display the location of the active shadow copy file", NULL },
 
     { NULL }
 };
 
 static GOptionEntry command_entries[] = {
     { "create", 'c', G_OPTION_FLAG_NONE, G_OPTION_ARG_CALLBACK, command_cb,
       "Create the named shadow copy of the active cluster configuration",
       "name" },
 
     { "create-empty", 'e', G_OPTION_FLAG_NONE, G_OPTION_ARG_CALLBACK,
       command_cb,
       "Create the named shadow copy with an empty cluster configuration.\n"
       INDENT "Optional: --validate-with", "name" },
 
     { "commit", 'C', G_OPTION_FLAG_NONE, G_OPTION_ARG_CALLBACK, command_cb,
       "Upload the contents of the named shadow copy to the cluster", "name" },
 
     { "delete", 'D', G_OPTION_FLAG_NONE, G_OPTION_ARG_CALLBACK, command_cb,
       "Delete the contents of the named shadow copy", "name" },
 
     { "edit", 'E', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK, command_cb,
       "Edit the contents of the active shadow copy with your favorite $EDITOR",
       NULL },
 
     { "reset", 'r', G_OPTION_FLAG_NONE, G_OPTION_ARG_CALLBACK, command_cb,
       "Recreate named shadow copy from the active cluster configuration",
       "name" },
 
     { "switch", 's', G_OPTION_FLAG_NONE, G_OPTION_ARG_CALLBACK, command_cb,
       "(Advanced) Switch to the named shadow copy", "name" },
 
     { NULL }
 };
 
 static GOptionEntry addl_entries[] = {
     { "force", 'f', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, &options.force,
       "(Advanced) Force the action to be performed", NULL },
 
     { "batch", 'b', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, &options.batch,
       "(Advanced) Don't spawn a new shell", NULL },
 
     { "all", 'a', G_OPTION_FLAG_NONE, G_OPTION_ARG_NONE, &options.full_upload,
       "(Advanced) Upload entire CIB, including status, with --commit", NULL },
 
     { "validate-with", 'v', G_OPTION_FLAG_NONE, G_OPTION_ARG_STRING,
       &options.validate_with,
       "(Advanced) Create an older configuration version", NULL },
 
     { NULL }
 };
 
 static GOptionContext *
 build_arg_context(pcmk__common_args_t *args, GOptionGroup **group)
 {
     const char *desc = NULL;
     GOptionContext *context = NULL;
 
     desc = "Examples:\n\n"
            "Create a blank shadow configuration:\n\n"
            "\t# crm_shadow --create-empty myShadow\n\n"
            "Create a shadow configuration from the running cluster\n\n"
            "\t# crm_shadow --create myShadow\n\n"
            "Display the current shadow configuration:\n\n"
            "\t# crm_shadow --display\n\n"
            "Discard the current shadow configuration (named myShadow):\n\n"
            "\t# crm_shadow --delete myShadow --force\n\n"
            "Upload current shadow configuration (named myShadow) to running "
            "cluster:\n\n"
            "\t# crm_shadow --commit myShadow\n\n";
 
     context = pcmk__build_arg_context(args, "text (default), xml", group,
                                       "<query>|<command>");
     g_option_context_set_description(context, desc);
 
     pcmk__add_arg_group(context, "queries", "Queries:",
                         "Show query help", query_entries);
     pcmk__add_arg_group(context, "commands", "Commands:",
                         "Show command help", command_entries);
     pcmk__add_arg_group(context, "additional", "Additional Options:",
                         "Show additional options", addl_entries);
     return context;
 }
 
 int
 main(int argc, char **argv)
 {
     int rc = pcmk_rc_ok;
     pcmk__output_t *out = NULL;
 
     GError *error = NULL;
 
     GOptionGroup *output_group = NULL;
     pcmk__common_args_t *args = pcmk__new_common_args(SUMMARY);
     gchar **processed_args = pcmk__cmdline_preproc(argv, "CDcersv");
     GOptionContext *context = build_arg_context(args, &output_group);
 
     crm_log_preinit(NULL, argc, argv);
 
     pcmk__register_formats(output_group, formats);
 
     if (!g_option_context_parse_strv(context, &processed_args, &error)) {
         exit_code = CRM_EX_USAGE;
         goto done;
     }
 
     rc = pcmk__output_new(&out, args->output_ty, args->output_dest, argv);
     if (rc != pcmk_rc_ok) {
         exit_code = CRM_EX_ERROR;
         g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
                     "Error creating output format %s: %s", args->output_ty,
                     pcmk_rc_str(rc));
         goto done;
     }
 
     if (g_strv_length(processed_args) > 1) {
         gchar *help = g_option_context_get_help(context, TRUE, NULL);
         GString *extra = g_string_sized_new(128);
 
         for (int lpc = 1; processed_args[lpc] != NULL; lpc++) {
             if (extra->len > 0) {
                 g_string_append_c(extra, ' ');
             }
             g_string_append(extra, processed_args[lpc]);
         }
 
         exit_code = CRM_EX_USAGE;
         g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
                     "non-option ARGV-elements: %s\n\n%s", extra->str, help);
         g_free(help);
         g_string_free(extra, TRUE);
         goto done;
     }
 
     if (args->version) {
         out->version(out, false);
         goto done;
     }
 
     pcmk__register_messages(out, fmt_functions);
 
     if (options.cmd == shadow_cmd_none) {
         // @COMPAT: Create a default command if other tools have one
         gchar *help = g_option_context_get_help(context, TRUE, NULL);
 
         exit_code = CRM_EX_USAGE;
         g_set_error(&error, PCMK__EXITC_ERROR, exit_code,
                     "Must specify a query or command option\n\n%s", help);
         g_free(help);
         goto done;
     }
 
     pcmk__cli_init_logging("crm_shadow", args->verbosity);
 
     if (args->verbosity > 0) {
         cib__set_call_options(options.cmd_options, crm_system_name,
                               cib_verbose);
     }
 
     // Run the command
     switch (options.cmd) {
         case shadow_cmd_commit:
             commit_shadow_file(&error);
             break;
         case shadow_cmd_create:
             create_shadow_from_cib(out, false, &error);
             break;
         case shadow_cmd_create_empty:
             create_shadow_empty(out, &error);
             break;
         case shadow_cmd_reset:
             create_shadow_from_cib(out, true, &error);
             break;
         case shadow_cmd_delete:
             delete_shadow_file(out, &error);
             break;
         case shadow_cmd_diff:
             show_shadow_diff(out, &error);
             break;
         case shadow_cmd_display:
             show_shadow_contents(out, &error);
             break;
         case shadow_cmd_edit:
             edit_shadow_file(&error);
             break;
         case shadow_cmd_file:
             show_shadow_filename(out, &error);
             break;
         case shadow_cmd_switch:
             switch_shadow_instance(out, &error);
             break;
         case shadow_cmd_which:
             show_shadow_instance(out, &error);
             break;
         default:
             // Should never reach this point
             break;
     }
 
 done:
     g_strfreev(processed_args);
     pcmk__free_arg_context(context);
 
     pcmk__output_and_clear_error(&error, out);
 
     free(options.instance);
     g_free(options.validate_with);
 
     if (out != NULL) {
         out->finish(out, exit_code, true, NULL);
         pcmk__output_free(out);
     }
 
     crm_exit(exit_code);
 }