diff --git a/include/crm/msg_xml.h b/include/crm/msg_xml.h
index 90945948a8..71e4e7f84e 100644
--- a/include/crm/msg_xml.h
+++ b/include/crm/msg_xml.h
@@ -1,297 +1,298 @@
 /*
  * 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_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_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 974ba72e24..f81d565396 100644
--- a/lib/common/options.c
+++ b/lib/common/options.c
@@ -1,589 +1,589 @@
 /*
  * 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
- *                        "shortdesc")
+ *                        \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, " lang=\"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, " 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, "shortdesc", desc_short, 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, "shortdesc", opt_desc_short, NULL, "      ");
+        add_desc(s, PCMK_XE_SHORTDESC, opt_desc_short, NULL, "      ");
 
         pcmk__g_strcat(s, "      <content 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");
             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/lib/fencing/st_lha.c b/lib/fencing/st_lha.c
index d02cafe102..c2a879e634 100644
--- a/lib/fencing/st_lha.c
+++ b/lib/fencing/st_lha.c
@@ -1,284 +1,284 @@
 /*
  * Copyright 2004-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 
 #include <stdio.h>
 #include <stdarg.h>
 #include <string.h>
 #include <errno.h>
 #include <glib.h>
 #include <dlfcn.h>
 
 #include <crm/crm.h>
 #include <crm/stonith-ng.h>
 #include <crm/fencing/internal.h>
 #include <crm/msg_xml.h>
 #include <crm/common/xml.h>
 
 #include <stonith/stonith.h>
 
 #include "fencing_private.h"
 
 #define LHA_STONITH_LIBRARY "libstonith.so.1"
 
 static void *lha_agents_lib = NULL;
 
 // @TODO Use XML string constants and maybe a real XML object
 static const char META_TEMPLATE[] =
     "<?xml " PCMK_XA_VERSION "=\"1.0\"?>\n"
     "<" PCMK_XE_RESOURCE_AGENT " " PCMK_XA_NAME "=\"%s\">\n"
     "  <" PCMK_XE_VERSION ">1.0</" PCMK_XE_VERSION ">\n"
     "  <" PCMK_XE_LONGDESC " lang=\"en\">\n"
         "%s\n"
     "  </" PCMK_XE_LONGDESC ">\n"
-    "  <shortdesc lang=\"en\">%s</shortdesc>\n"
+    "  <" PCMK_XE_SHORTDESC " lang=\"en\">%s</" PCMK_XE_SHORTDESC ">\n"
     "%s\n"
     "  <actions>\n"
     "    <action name=\"start\"   timeout=\"%s\" />\n"
     "    <action name=\"stop\"    timeout=\"15\" />\n"
     "    <action name=\"status\"  timeout=\"%s\" />\n"
     "    <action name=\"monitor\" timeout=\"%s\" interval=\"3600\"/>\n"
     "    <action name=\"meta-data\"  timeout=\"15\" />\n"
     "  </actions>\n"
     "  <special tag=\"heartbeat\">\n"
     "    <" PCMK_XE_VERSION ">2.0</" PCMK_XE_VERSION ">\n"
     "  </special>\n"
     "</" PCMK_XE_RESOURCE_AGENT ">\n";
 
 static void *
 find_library_function(void **handle, const char *lib, const char *fn)
 {
     void *a_function;
 
     if (*handle == NULL) {
         *handle = dlopen(lib, RTLD_LAZY);
         if ((*handle) == NULL) {
             crm_err("Could not open %s: %s", lib, dlerror());
             return NULL;
         }
     }
 
     a_function = dlsym(*handle, fn);
     if (a_function == NULL) {
         crm_err("Could not find %s in %s: %s", fn, lib, dlerror());
     }
 
     return a_function;
 }
 
 /*!
  * \internal
  * \brief Check whether a given fence agent is an LHA agent
  *
  * \param[in] agent        Fence agent type
  *
  * \return true if \p agent is an LHA agent, otherwise false
  */
 bool
 stonith__agent_is_lha(const char *agent)
 {
     Stonith *stonith_obj = NULL;
 
     static bool need_init = true;
     static Stonith *(*st_new_fn) (const char *) = NULL;
     static void (*st_del_fn) (Stonith *) = NULL;
 
     if (need_init) {
         need_init = false;
         st_new_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
                                           "stonith_new");
         st_del_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
                                           "stonith_delete");
     }
 
     if (lha_agents_lib && st_new_fn && st_del_fn) {
         stonith_obj = (*st_new_fn) (agent);
         if (stonith_obj) {
             (*st_del_fn) (stonith_obj);
             return true;
         }
     }
     return false;
 }
 
 int
 stonith__list_lha_agents(stonith_key_value_t **devices)
 {
     static gboolean need_init = TRUE;
 
     int count = 0;
     char **entry = NULL;
     char **type_list = NULL;
     static char **(*type_list_fn) (void) = NULL;
     static void (*type_free_fn) (char **) = NULL;
 
     if (need_init) {
         need_init = FALSE;
         type_list_fn = find_library_function(&lha_agents_lib,
                                              LHA_STONITH_LIBRARY,
                                              "stonith_types");
         type_free_fn = find_library_function(&lha_agents_lib,
                                              LHA_STONITH_LIBRARY,
                                              "stonith_free_hostlist");
     }
 
     if (type_list_fn) {
         type_list = (*type_list_fn) ();
     }
 
     for (entry = type_list; entry != NULL && *entry; ++entry) {
         crm_trace("Added: %s", *entry);
         *devices = stonith_key_value_add(*devices, NULL, *entry);
         count++;
     }
     if (type_list && type_free_fn) {
         (*type_free_fn) (type_list);
     }
     return count;
 }
 
 static void
 stonith_plugin(int priority, const char *fmt, ...) G_GNUC_PRINTF(2, 3);
 
 static void
 stonith_plugin(int priority, const char *format, ...)
 {
     int err = errno;
 
     va_list ap;
     int len = 0;
     char *string = NULL;
 
     va_start(ap, format);
 
     len = vasprintf (&string, format, ap);
     va_end(ap);
     CRM_ASSERT(len > 0);
 
     do_crm_log_alias(priority, __FILE__, __func__, __LINE__, "%s", string);
 
     free(string);
     errno = err;
 }
 
 int
 stonith__lha_metadata(const char *agent, int timeout, char **output)
 {
     int rc = 0;
     char *buffer = NULL;
     static const char *no_parameter_info = "<!-- no value -->";
 
     Stonith *stonith_obj = NULL;
 
     static gboolean need_init = TRUE;
     static Stonith *(*st_new_fn) (const char *) = NULL;
     static const char *(*st_info_fn) (Stonith *, int) = NULL;
     static void (*st_del_fn) (Stonith *) = NULL;
     static void (*st_log_fn) (Stonith *, PILLogFun) = NULL;
 
     if (need_init) {
         need_init = FALSE;
         st_new_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
                                           "stonith_new");
         st_del_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
                                           "stonith_delete");
         st_log_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
                                           "stonith_set_log");
         st_info_fn = find_library_function(&lha_agents_lib, LHA_STONITH_LIBRARY,
                                            "stonith_get_info");
     }
 
     if (lha_agents_lib && st_new_fn && st_del_fn && st_info_fn && st_log_fn) {
         char *xml_meta_longdesc = NULL;
         char *xml_meta_shortdesc = NULL;
 
         char *meta_param = NULL;
         char *meta_longdesc = NULL;
         char *meta_shortdesc = NULL;
         const char *timeout_str = NULL;
 
         stonith_obj = (*st_new_fn) (agent);
         if (stonith_obj) {
             (*st_log_fn) (stonith_obj, (PILLogFun) & stonith_plugin);
             pcmk__str_update(&meta_longdesc,
                              (*st_info_fn) (stonith_obj, ST_DEVICEDESCR));
             if (meta_longdesc == NULL) {
                 crm_warn("no long description in %s's metadata.", agent);
                 meta_longdesc = strdup(no_parameter_info);
             }
 
             pcmk__str_update(&meta_shortdesc,
                              (*st_info_fn) (stonith_obj, ST_DEVICEID));
             if (meta_shortdesc == NULL) {
                 crm_warn("no short description in %s's metadata.", agent);
                 meta_shortdesc = strdup(no_parameter_info);
             }
 
             pcmk__str_update(&meta_param,
                              (*st_info_fn) (stonith_obj, ST_CONF_XML));
             if (meta_param == NULL) {
                 crm_warn("no list of parameters in %s's metadata.", agent);
                 meta_param = strdup(no_parameter_info);
             }
             (*st_del_fn) (stonith_obj);
         } else {
             errno = EINVAL;
             crm_perror(LOG_ERR, "Agent %s not found", agent);
             return -EINVAL;
         }
 
         xml_meta_longdesc =
             (char *)xmlEncodeEntitiesReentrant(NULL, (const unsigned char *)meta_longdesc);
         xml_meta_shortdesc =
             (char *)xmlEncodeEntitiesReentrant(NULL, (const unsigned char *)meta_shortdesc);
 
         timeout_str = pcmk__readable_interval(PCMK_DEFAULT_ACTION_TIMEOUT_MS);
         buffer = crm_strdup_printf(META_TEMPLATE, agent, xml_meta_longdesc,
                                    xml_meta_shortdesc, meta_param,
                                    timeout_str, timeout_str, timeout_str);
 
         xmlFree(xml_meta_longdesc);
         xmlFree(xml_meta_shortdesc);
 
         free(meta_shortdesc);
         free(meta_longdesc);
         free(meta_param);
     }
     if (output) {
         *output = buffer;
     } else {
         free(buffer);
     }
     return rc;
 }
 
 /* Implement a dummy function that uses -lpils so that linkers don't drop the
  * reference.
  */
 
 #include <pils/plugin.h>
 
 const char *i_hate_pils(int rc);
 
 const char *
 i_hate_pils(int rc)
 {
     return PIL_strerror(rc);
 }
 
 int
 stonith__lha_validate(stonith_t *st, int call_options, const char *target,
                       const char *agent, GHashTable *params, int timeout,
                       char **output, char **error_output)
 {
     errno = EOPNOTSUPP;
     crm_perror(LOG_ERR, "Cannot validate Linux-HA fence agents");
     return -EOPNOTSUPP;
 }
diff --git a/lib/services/services_lsb.c b/lib/services/services_lsb.c
index 34b4caf46a..1971c93a31 100644
--- a/lib/services/services_lsb.c
+++ b/lib/services/services_lsb.c
@@ -1,344 +1,344 @@
 /*
  * Copyright 2010-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 
 #ifndef _GNU_SOURCE
 #  define _GNU_SOURCE
 #endif
 
 #include <stdio.h>
 #include <errno.h>
 #include <sys/stat.h>
 
 #include <crm/crm.h>
 #include <crm/msg_xml.h>
 #include <crm/services.h>
 #include "services_private.h"
 #include "services_lsb.h"
 
 // @TODO Use XML string constants and maybe a real XML object
 #define lsb_metadata_template  \
     "<?xml " PCMK_XA_VERSION "='1.0'?>\n"                               \
     "<" PCMK_XE_RESOURCE_AGENT " "                                      \
         PCMK_XA_NAME "='%s' "                                           \
         PCMK_XA_VERSION "='" PCMK_DEFAULT_AGENT_VERSION "'>\n"          \
     "  <" PCMK_XE_VERSION ">1.0</" PCMK_XE_VERSION ">\n"                \
     "  <" PCMK_XE_LONGDESC " lang='en'>\n"                              \
         "%s"                                                            \
     "  </" PCMK_XE_LONGDESC ">\n"                                       \
-    "  <shortdesc lang='en'>%s</shortdesc>\n"                           \
+    "  <" PCMK_XE_SHORTDESC " lang='en'>%s</" PCMK_XE_SHORTDESC">\n"    \
     "  <" PCMK_XE_PARAMETERS "/>\n"                                     \
     "  <actions>\n"                                                     \
     "    <action name='meta-data'    timeout='5' />\n"                  \
     "    <action name='start'        timeout='15' />\n"                 \
     "    <action name='stop'         timeout='15' />\n"                 \
     "    <action name='status'       timeout='15' />\n"                 \
     "    <action name='restart'      timeout='15' />\n"                 \
     "    <action name='force-reload' timeout='15' />\n"                 \
     "    <action name='monitor'      timeout='15' interval='15' />\n"   \
     "  </actions>\n"                                                    \
     "  <special tag='LSB'>\n"                                           \
     "    <Provides>%s</Provides>\n"                                     \
     "    <Required-Start>%s</Required-Start>\n"                         \
     "    <Required-Stop>%s</Required-Stop>\n"                           \
     "    <Should-Start>%s</Should-Start>\n"                             \
     "    <Should-Stop>%s</Should-Stop>\n"                               \
     "    <Default-Start>%s</Default-Start>\n"                           \
     "    <Default-Stop>%s</Default-Stop>\n"                             \
     "  </special>\n"                                                    \
     "</" PCMK_XE_RESOURCE_AGENT ">\n"
 
 /* See "Comment Conventions for Init Scripts" in the LSB core specification at:
  * http://refspecs.linuxfoundation.org/lsb.shtml
  */
 #define LSB_INITSCRIPT_INFOBEGIN_TAG    "### BEGIN INIT INFO"
 #define LSB_INITSCRIPT_INFOEND_TAG      "### END INIT INFO"
 #define PROVIDES                        "# Provides:"
 #define REQUIRED_START                  "# Required-Start:"
 #define REQUIRED_STOP                   "# Required-Stop:"
 #define SHOULD_START                    "# Should-Start:"
 #define SHOULD_STOP                     "# Should-Stop:"
 #define DEFAULT_START                   "# Default-Start:"
 #define DEFAULT_STOP                    "# Default-Stop:"
 #define SHORT_DESC                      "# Short-Description:"
 #define DESCRIPTION                     "# Description:"
 
 #define lsb_meta_helper_free_value(m)           \
     do {                                        \
         if ((m) != NULL) {                      \
             xmlFree(m);                         \
             (m) = NULL;                         \
         }                                       \
     } while(0)
 
 /*!
  * \internal
  * \brief Grab an LSB header value
  *
  * \param[in]     line    Line read from LSB init script
  * \param[in,out] value   If not set, will be set to XML-safe copy of value
  * \param[in]     prefix  Set value if line starts with this pattern
  *
  * \return TRUE if value was set, FALSE otherwise
  */
 static inline gboolean
 lsb_meta_helper_get_value(const char *line, char **value, const char *prefix)
 {
     if (!*value && pcmk__starts_with(line, prefix)) {
         *value = (char *)xmlEncodeEntitiesReentrant(NULL, BAD_CAST line+strlen(prefix));
         return TRUE;
     }
     return FALSE;
 }
 
 int
 services__get_lsb_metadata(const char *type, char **output)
 {
     char ra_pathname[PATH_MAX] = { 0, };
     FILE *fp = NULL;
     char buffer[1024] = { 0, };
     char *provides = NULL;
     char *required_start = NULL;
     char *required_stop = NULL;
     char *should_start = NULL;
     char *should_stop = NULL;
     char *default_start = NULL;
     char *default_stop = NULL;
     char *short_desc = NULL;
     char *long_desc = NULL;
     bool in_header = FALSE;
 
     if (type[0] == '/') {
         snprintf(ra_pathname, sizeof(ra_pathname), "%s", type);
     } else {
         snprintf(ra_pathname, sizeof(ra_pathname), "%s/%s",
                  PCMK__LSB_INIT_DIR, type);
     }
 
     crm_trace("Looking into %s", ra_pathname);
     fp = fopen(ra_pathname, "r");
     if (fp == NULL) {
         return -errno;
     }
 
     /* Enter into the LSB-compliant comment block */
     while (fgets(buffer, sizeof(buffer), fp)) {
 
         // Ignore lines up to and including the block delimiter
         if (pcmk__starts_with(buffer, LSB_INITSCRIPT_INFOBEGIN_TAG)) {
             in_header = TRUE;
             continue;
         }
         if (!in_header) {
             continue;
         }
 
         /* Assume each of the following eight arguments contain one line */
         if (lsb_meta_helper_get_value(buffer, &provides, PROVIDES)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &required_start,
                                       REQUIRED_START)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &required_stop, REQUIRED_STOP)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &should_start, SHOULD_START)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &should_stop, SHOULD_STOP)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &default_start, DEFAULT_START)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &default_stop, DEFAULT_STOP)) {
             continue;
         }
         if (lsb_meta_helper_get_value(buffer, &short_desc, SHORT_DESC)) {
             continue;
         }
 
         /* Long description may cross multiple lines */
         if ((long_desc == NULL)  // Haven't already found long description
             && pcmk__starts_with(buffer, DESCRIPTION)) {
             bool processed_line = TRUE;
             GString *desc = g_string_sized_new(2048);
 
             // Get remainder of description line itself
             g_string_append(desc, buffer + sizeof(DESCRIPTION) - 1);
 
             // Read any continuation lines of the description
             buffer[0] = '\0';
             while (fgets(buffer, sizeof(buffer), fp)) {
                 if (pcmk__starts_with(buffer, "#  ")
                     || pcmk__starts_with(buffer, "#\t")) {
                     /* '#' followed by a tab or more than one space indicates a
                      * continuation of the long description.
                      */
                     g_string_append(desc, buffer + 1);
                 } else {
                     /* This line is not part of the long description,
                      * so continue with normal processing.
                      */
                     processed_line = FALSE;
                     break;
                 }
             }
 
             // Make long description safe to use in XML
             long_desc =
                 (char *) xmlEncodeEntitiesReentrant(NULL,
                                                     (pcmkXmlStr) desc->str);
             g_string_free(desc, TRUE);
 
             if (processed_line) {
                 // We grabbed the line into the long description
                 continue;
             }
         }
 
         // Stop if we leave the header block
         if (pcmk__starts_with(buffer, LSB_INITSCRIPT_INFOEND_TAG)) {
             break;
         }
         if (buffer[0] != '#') {
             break;
         }
     }
     fclose(fp);
 
     *output = crm_strdup_printf(lsb_metadata_template, type,
                                 pcmk__s(long_desc, type),
                                 pcmk__s(short_desc, type),
                                 pcmk__s(provides, ""),
                                 pcmk__s(required_start, ""),
                                 pcmk__s(required_stop, ""),
                                 pcmk__s(should_start, ""),
                                 pcmk__s(should_stop, ""),
                                 pcmk__s(default_start, ""),
                                 pcmk__s(default_stop, ""));
 
     lsb_meta_helper_free_value(long_desc);
     lsb_meta_helper_free_value(short_desc);
     lsb_meta_helper_free_value(provides);
     lsb_meta_helper_free_value(required_start);
     lsb_meta_helper_free_value(required_stop);
     lsb_meta_helper_free_value(should_start);
     lsb_meta_helper_free_value(should_stop);
     lsb_meta_helper_free_value(default_start);
     lsb_meta_helper_free_value(default_stop);
 
     crm_trace("Created fake metadata: %zu", strlen(*output));
     return pcmk_ok;
 }
 
 GList *
 services__list_lsb_agents(void)
 {
     return services_os_get_directory_list(PCMK__LSB_INIT_DIR, TRUE, TRUE);
 }
 
 bool
 services__lsb_agent_exists(const char *agent)
 {
     bool rc = FALSE;
     struct stat st;
     char *path = pcmk__full_path(agent, PCMK__LSB_INIT_DIR);
 
     rc = (stat(path, &st) == 0);
     free(path);
     return rc;
 }
 
 /*!
  * \internal
  * \brief Prepare an LSB action
  *
  * \param[in,out] op  Action to prepare
  *
  * \return Standard Pacemaker return code
  */
 int
 services__lsb_prepare(svc_action_t *op)
 {
     op->opaque->exec = pcmk__full_path(op->agent, PCMK__LSB_INIT_DIR);
     op->opaque->args[0] = strdup(op->opaque->exec);
     op->opaque->args[1] = strdup(op->action);
     if ((op->opaque->args[0] == NULL) || (op->opaque->args[1] == NULL)) {
         return ENOMEM;
     }
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Map an LSB result to a standard OCF result
  *
  * \param[in] action       Action that result is for
  * \param[in] exit_status  LSB agent exit status
  *
  * \return Standard OCF result
  */
 enum ocf_exitcode
 services__lsb2ocf(const char *action, int exit_status)
 {
     // For non-status actions, LSB and OCF share error codes <= 7
     if (!pcmk__str_any_of(action, PCMK_ACTION_STATUS, PCMK_ACTION_MONITOR,
                           NULL)) {
         if ((exit_status < 0) || (exit_status > PCMK_LSB_NOT_RUNNING)) {
             return PCMK_OCF_UNKNOWN_ERROR;
         }
         return (enum ocf_exitcode) exit_status;
     }
 
     // LSB status actions have their own codes
     switch (exit_status) {
         case PCMK_LSB_STATUS_OK:
             return PCMK_OCF_OK;
 
         case PCMK_LSB_STATUS_NOT_INSTALLED:
             return PCMK_OCF_NOT_INSTALLED;
 
         case PCMK_LSB_STATUS_INSUFFICIENT_PRIV:
             return PCMK_OCF_INSUFFICIENT_PRIV;
 
         case PCMK_LSB_STATUS_VAR_PID:
         case PCMK_LSB_STATUS_VAR_LOCK:
         case PCMK_LSB_STATUS_NOT_RUNNING:
             return PCMK_OCF_NOT_RUNNING;
 
         default:
             return PCMK_OCF_UNKNOWN_ERROR;
     }
 }
 
 // Deprecated functions kept only for backward API compatibility
 // LCOV_EXCL_START
 
 #include <crm/services_compat.h>
 
 svc_action_t *
 services_action_create(const char *name, const char *action,
                        guint interval_ms, int timeout)
 {
     return resources_action_create(name, PCMK_RESOURCE_CLASS_LSB, NULL, name,
                                    action, interval_ms, timeout, NULL, 0);
 }
 
 GList *
 services_list(void)
 {
     return resources_list_agents(PCMK_RESOURCE_CLASS_LSB, NULL);
 }
 
 // LCOV_EXCL_STOP
 // End deprecated API
diff --git a/lib/services/systemd.c b/lib/services/systemd.c
index 1b9ab35b51..c899bc41ae 100644
--- a/lib/services/systemd.c
+++ b/lib/services/systemd.c
@@ -1,1113 +1,1114 @@
 /*
  * Copyright 2012-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 #include <crm/crm.h>
 #include <crm/msg_xml.h>
 #include <crm/services.h>
 #include <crm/services_internal.h>
 #include <crm/common/mainloop.h>
 
 #include <sys/stat.h>
 #include <gio/gio.h>
 #include <services_private.h>
 #include <systemd.h>
 #include <dbus/dbus.h>
 #include <pcmk-dbus.h>
 
 static void invoke_unit_by_path(svc_action_t *op, const char *unit);
 
 #define BUS_NAME         "org.freedesktop.systemd1"
 #define BUS_NAME_MANAGER BUS_NAME ".Manager"
 #define BUS_NAME_UNIT    BUS_NAME ".Unit"
 #define BUS_PATH         "/org/freedesktop/systemd1"
 
 /*!
  * \internal
  * \brief Prepare a systemd action
  *
  * \param[in,out] op  Action to prepare
  *
  * \return Standard Pacemaker return code
  */
 int
 services__systemd_prepare(svc_action_t *op)
 {
     op->opaque->exec = strdup("systemd-dbus");
     if (op->opaque->exec == NULL) {
         return ENOMEM;
     }
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Map a systemd result to a standard OCF result
  *
  * \param[in] exit_status  Systemd result
  *
  * \return Standard OCF result
  */
 enum ocf_exitcode
 services__systemd2ocf(int exit_status)
 {
     // This library uses OCF codes for systemd actions
     return (enum ocf_exitcode) exit_status;
 }
 
 static inline DBusMessage *
 systemd_new_method(const char *method)
 {
     crm_trace("Calling: %s on " BUS_NAME_MANAGER, method);
     return dbus_message_new_method_call(BUS_NAME, BUS_PATH, BUS_NAME_MANAGER,
                                         method);
 }
 
 /*
  * Functions to manage a static DBus connection
  */
 
 static DBusConnection* systemd_proxy = NULL;
 
 static inline DBusPendingCall *
 systemd_send(DBusMessage *msg,
              void(*done)(DBusPendingCall *pending, void *user_data),
              void *user_data, int timeout)
 {
     return pcmk_dbus_send(msg, systemd_proxy, done, user_data, timeout);
 }
 
 static inline DBusMessage *
 systemd_send_recv(DBusMessage *msg, DBusError *error, int timeout)
 {
     return pcmk_dbus_send_recv(msg, systemd_proxy, error, timeout);
 }
 
 /*!
  * \internal
  * \brief Send a method to systemd without arguments, and wait for reply
  *
  * \param[in] method  Method to send
  *
  * \return Systemd reply on success, NULL (and error will be logged) otherwise
  *
  * \note The caller must call dbus_message_unref() on the reply after
  *       handling it.
  */
 static DBusMessage *
 systemd_call_simple_method(const char *method)
 {
     DBusMessage *msg = systemd_new_method(method);
     DBusMessage *reply = NULL;
     DBusError error;
 
     /* Don't call systemd_init() here, because that calls this */
     CRM_CHECK(systemd_proxy, return NULL);
 
     if (msg == NULL) {
         crm_err("Could not create message to send %s to systemd", method);
         return NULL;
     }
 
     dbus_error_init(&error);
     reply = systemd_send_recv(msg, &error, DBUS_TIMEOUT_USE_DEFAULT);
     dbus_message_unref(msg);
 
     if (dbus_error_is_set(&error)) {
         crm_err("Could not send %s to systemd: %s (%s)",
                 method, error.message, error.name);
         dbus_error_free(&error);
         return NULL;
 
     } else if (reply == NULL) {
         crm_err("Could not send %s to systemd: no reply received", method);
         return NULL;
     }
 
     return reply;
 }
 
 static gboolean
 systemd_init(void)
 {
     static int need_init = 1;
     // https://dbus.freedesktop.org/doc/api/html/group__DBusConnection.html
 
     if (systemd_proxy
         && dbus_connection_get_is_connected(systemd_proxy) == FALSE) {
         crm_warn("Connection to System DBus is closed. Reconnecting...");
         pcmk_dbus_disconnect(systemd_proxy);
         systemd_proxy = NULL;
         need_init = 1;
     }
 
     if (need_init) {
         need_init = 0;
         systemd_proxy = pcmk_dbus_connect();
     }
     if (systemd_proxy == NULL) {
         return FALSE;
     }
     return TRUE;
 }
 
 static inline char *
 systemd_get_property(const char *unit, const char *name,
                      void (*callback)(const char *name, const char *value, void *userdata),
                      void *userdata, DBusPendingCall **pending, int timeout)
 {
     return systemd_proxy?
            pcmk_dbus_get_property(systemd_proxy, BUS_NAME, unit, BUS_NAME_UNIT,
                                   name, callback, userdata, pending, timeout)
            : NULL;
 }
 
 void
 systemd_cleanup(void)
 {
     if (systemd_proxy) {
         pcmk_dbus_disconnect(systemd_proxy);
         systemd_proxy = NULL;
     }
 }
 
 /*
  * end of systemd_proxy functions
  */
 
 /*!
  * \internal
  * \brief Check whether a file name represents a manageable systemd unit
  *
  * \param[in] name  File name to check
  *
  * \return Pointer to "dot" before filename extension if so, NULL otherwise
  */
 static const char *
 systemd_unit_extension(const char *name)
 {
     if (name) {
         const char *dot = strrchr(name, '.');
 
         if (dot && (!strcmp(dot, ".service")
                     || !strcmp(dot, ".socket")
                     || !strcmp(dot, ".mount")
                     || !strcmp(dot, ".timer")
                     || !strcmp(dot, ".path"))) {
             return dot;
         }
     }
     return NULL;
 }
 
 static char *
 systemd_service_name(const char *name, bool add_instance_name)
 {
     const char *dot = NULL;
 
     if (pcmk__str_empty(name)) {
         return NULL;
     }
 
     /* Services that end with an @ sign are systemd templates.  They expect an
      * instance name to follow the service name.  If no instance name was
      * provided, just add "pacemaker" to the string as the instance name.  It
      * doesn't seem to matter for purposes of looking up whether a service
      * exists or not.
      *
      * A template can be specified either with or without the unit extension,
      * so this block handles both cases.
      */
     dot = systemd_unit_extension(name);
 
     if (dot) {
         if (dot != name && *(dot-1) == '@') {
             char *s = NULL;
 
             if (asprintf(&s, "%.*spacemaker%s", (int) (dot-name), name, dot) == -1) {
                 /* If asprintf fails, just return name. */
                 return strdup(name);
             }
 
             return s;
         } else {
             return strdup(name);
         }
 
     } else if (add_instance_name && *(name+strlen(name)-1) == '@') {
         return crm_strdup_printf("%spacemaker.service", name);
 
     } else {
         return crm_strdup_printf("%s.service", name);
     }
 }
 
 static void
 systemd_daemon_reload_complete(DBusPendingCall *pending, void *user_data)
 {
     DBusError error;
     DBusMessage *reply = NULL;
     unsigned int reload_count = GPOINTER_TO_UINT(user_data);
 
     dbus_error_init(&error);
     if(pending) {
         reply = dbus_pending_call_steal_reply(pending);
     }
 
     if (pcmk_dbus_find_error(pending, reply, &error)) {
         crm_warn("Could not issue systemd reload %d: %s",
                  reload_count, error.message);
         dbus_error_free(&error);
 
     } else {
         crm_trace("Reload %d complete", reload_count);
     }
 
     if(pending) {
         dbus_pending_call_unref(pending);
     }
     if(reply) {
         dbus_message_unref(reply);
     }
 }
 
 static bool
 systemd_daemon_reload(int timeout)
 {
     static unsigned int reload_count = 0;
     DBusMessage *msg = systemd_new_method("Reload");
 
     reload_count++;
     CRM_ASSERT(msg != NULL);
     systemd_send(msg, systemd_daemon_reload_complete,
                  GUINT_TO_POINTER(reload_count), timeout);
     dbus_message_unref(msg);
 
     return TRUE;
 }
 
 /*!
  * \internal
  * \brief Set an action result based on a method error
  *
  * \param[in,out] op     Action to set result for
  * \param[in]     error  Method error
  */
 static void
 set_result_from_method_error(svc_action_t *op, const DBusError *error)
 {
     services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                          "Unable to invoke systemd DBus method");
 
     if (strstr(error->name, "org.freedesktop.systemd1.InvalidName")
         || strstr(error->name, "org.freedesktop.systemd1.LoadFailed")
         || strstr(error->name, "org.freedesktop.systemd1.NoSuchUnit")) {
 
         if (pcmk__str_eq(op->action, PCMK_ACTION_STOP, pcmk__str_casei)) {
             crm_trace("Masking systemd stop failure (%s) for %s "
                       "because unknown service can be considered stopped",
                       error->name, pcmk__s(op->rsc, "unknown resource"));
             services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
             return;
         }
 
         services__format_result(op, PCMK_OCF_NOT_INSTALLED,
                                PCMK_EXEC_NOT_INSTALLED,
                                "systemd unit %s not found", op->agent);
     }
 
     crm_info("DBus request for %s of systemd unit %s%s%s failed: %s",
              op->action, op->agent,
              ((op->rsc == NULL)? "" : " for resource "), pcmk__s(op->rsc, ""),
              error->message);
 }
 
 /*!
  * \internal
  * \brief Extract unit path from LoadUnit reply, and execute action
  *
  * \param[in]     reply  LoadUnit reply
  * \param[in,out] op     Action to execute (or NULL to just return path)
  *
  * \return DBus object path for specified unit if successful (only valid for
  *         lifetime of \p reply), otherwise NULL
  */
 static const char *
 execute_after_loadunit(DBusMessage *reply, svc_action_t *op)
 {
     const char *path = NULL;
     DBusError error;
 
     /* path here is not used other than as a non-NULL flag to indicate that a
      * request was indeed sent
      */
     if (pcmk_dbus_find_error((void *) &path, reply, &error)) {
         if (op != NULL) {
             set_result_from_method_error(op, &error);
         }
         dbus_error_free(&error);
 
     } else if (!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH,
                                      __func__, __LINE__)) {
         if (op != NULL) {
             services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                  "systemd DBus method had unexpected reply");
             crm_info("Could not load systemd unit %s for %s: "
                      "DBus reply has unexpected type", op->agent, op->id);
         } else {
             crm_info("Could not load systemd unit: "
                      "DBus reply has unexpected type");
         }
 
     } else {
         dbus_message_get_args (reply, NULL,
                                DBUS_TYPE_OBJECT_PATH, &path,
                                DBUS_TYPE_INVALID);
     }
 
     if (op != NULL) {
         if (path != NULL) {
             invoke_unit_by_path(op, path);
 
         } else if (!(op->synchronous)) {
             services__format_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                     "No DBus object found for systemd unit %s",
                                     op->agent);
             services__finalize_async_op(op);
         }
     }
 
     return path;
 }
 
 /*!
  * \internal
  * \brief Execute a systemd action after its LoadUnit completes
  *
  * \param[in,out] pending    If not NULL, DBus call associated with LoadUnit
  * \param[in,out] user_data  Action to execute
  */
 static void
 loadunit_completed(DBusPendingCall *pending, void *user_data)
 {
     DBusMessage *reply = NULL;
     svc_action_t *op = user_data;
 
     crm_trace("LoadUnit result for %s arrived", op->id);
 
     // Grab the reply
     if (pending != NULL) {
         reply = dbus_pending_call_steal_reply(pending);
     }
 
     // The call is no longer pending
     CRM_LOG_ASSERT(pending == op->opaque->pending);
     services_set_op_pending(op, NULL);
 
     // Execute the desired action based on the reply
     execute_after_loadunit(reply, user_data);
     if (reply != NULL) {
         dbus_message_unref(reply);
     }
 }
 
 /*!
  * \internal
  * \brief Execute a systemd action, given the unit name
  *
  * \param[in]     arg_name  Unit name (possibly without ".service" extension)
  * \param[in,out] op        Action to execute (if NULL, just get object path)
  * \param[out]    path      If non-NULL and \p op is NULL or synchronous, where
  *                          to store DBus object path for specified unit
  *
  * \return Standard Pacemaker return code (for NULL \p op, pcmk_rc_ok means unit
  *         was found; for synchronous actions, pcmk_rc_ok means unit was
  *         executed, with the actual result stored in \p op; for asynchronous
  *         actions, pcmk_rc_ok means action was initiated)
  * \note It is the caller's responsibility to free the path.
  */
 static int
 invoke_unit_by_name(const char *arg_name, svc_action_t *op, char **path)
 {
     DBusMessage *msg;
     DBusMessage *reply = NULL;
     DBusPendingCall *pending = NULL;
     char *name = NULL;
 
     if (!systemd_init()) {
         if (op != NULL) {
             services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                  "No DBus connection");
         }
         return ENOTCONN;
     }
 
     /* Create a LoadUnit DBus method (equivalent to GetUnit if already loaded),
      * which makes the unit usable via further DBus methods.
      *
      * <method name="LoadUnit">
      *  <arg name="name" type="s" direction="in"/>
      *  <arg name="unit" type="o" direction="out"/>
      * </method>
      */
     msg = systemd_new_method("LoadUnit");
     CRM_ASSERT(msg != NULL);
 
     // Add the (expanded) unit name as the argument
     name = systemd_service_name(arg_name,
                                 (op == NULL)
                                 || pcmk__str_eq(op->action,
                                                 PCMK_ACTION_META_DATA,
                                                 pcmk__str_none));
     CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_STRING, &name,
                                             DBUS_TYPE_INVALID));
     free(name);
 
     if ((op == NULL) || op->synchronous) {
         // For synchronous ops, wait for a reply and extract the result
         const char *unit = NULL;
         int rc = pcmk_rc_ok;
 
         reply = systemd_send_recv(msg, NULL,
                                   (op? op->timeout : DBUS_TIMEOUT_USE_DEFAULT));
         dbus_message_unref(msg);
 
         unit = execute_after_loadunit(reply, op);
         if (unit == NULL) {
             rc = ENOENT;
             if (path != NULL) {
                 *path = NULL;
             }
         } else if (path != NULL) {
             *path = strdup(unit);
             if (*path == NULL) {
                 rc = ENOMEM;
             }
         }
 
         if (reply != NULL) {
             dbus_message_unref(reply);
         }
         return rc;
     }
 
     // For asynchronous ops, initiate the LoadUnit call and return
     pending = systemd_send(msg, loadunit_completed, op, op->timeout);
     if (pending == NULL) {
         services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                              "Unable to send DBus message");
         dbus_message_unref(msg);
         return ECOMM;
     }
 
     // LoadUnit was successfully initiated
     services__set_result(op, PCMK_OCF_UNKNOWN, PCMK_EXEC_PENDING, NULL);
     services_set_op_pending(op, pending);
     dbus_message_unref(msg);
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Compare two strings alphabetically (case-insensitive)
  *
  * \param[in] a  First string to compare
  * \param[in] b  Second string to compare
  *
  * \return 0 if strings are equal, -1 if a < b, 1 if a > b
  *
  * \note Usable as a GCompareFunc with g_list_sort().
  *       NULL is considered less than non-NULL.
  */
 static gint
 sort_str(gconstpointer a, gconstpointer b)
 {
     if (!a && !b) {
         return 0;
     } else if (!a) {
         return -1;
     } else if (!b) {
         return 1;
     }
     return strcasecmp(a, b);
 }
 
 GList *
 systemd_unit_listall(void)
 {
     int nfiles = 0;
     GList *units = NULL;
     DBusMessageIter args;
     DBusMessageIter unit;
     DBusMessageIter elem;
     DBusMessage *reply = NULL;
 
     if (systemd_init() == FALSE) {
         return NULL;
     }
 
 /*
         "  <method name=\"ListUnitFiles\">\n"                               \
         "   <arg name=\"files\" type=\"a(ss)\" direction=\"out\"/>\n" \
         "  </method>\n"                                                 \
 */
 
     reply = systemd_call_simple_method("ListUnitFiles");
     if (reply == NULL) {
         return NULL;
     }
     if (!dbus_message_iter_init(reply, &args)) {
         crm_err("Could not list systemd unit files: systemd reply has no arguments");
         dbus_message_unref(reply);
         return NULL;
     }
     if (!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY,
                               __func__, __LINE__)) {
         crm_err("Could not list systemd unit files: systemd reply has invalid arguments");
         dbus_message_unref(reply);
         return NULL;
     }
 
     dbus_message_iter_recurse(&args, &unit);
     for (; dbus_message_iter_get_arg_type(&unit) != DBUS_TYPE_INVALID;
         dbus_message_iter_next(&unit)) {
 
         DBusBasicValue value;
         const char *match = NULL;
         char *unit_name = NULL;
         char *basename = NULL;
 
         if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_STRUCT, __func__, __LINE__)) {
             crm_warn("Skipping systemd reply argument with unexpected type");
             continue;
         }
 
         dbus_message_iter_recurse(&unit, &elem);
         if(!pcmk_dbus_type_check(reply, &elem, DBUS_TYPE_STRING, __func__, __LINE__)) {
             crm_warn("Skipping systemd reply argument with no string");
             continue;
         }
 
         dbus_message_iter_get_basic(&elem, &value);
         if (value.str == NULL) {
             crm_debug("ListUnitFiles reply did not provide a string");
             continue;
         }
         crm_trace("DBus ListUnitFiles listed: %s", value.str);
 
         match = systemd_unit_extension(value.str);
         if (match == NULL) {
             // This is not a unit file type we know how to manage
             crm_debug("ListUnitFiles entry '%s' is not supported as resource",
                       value.str);
             continue;
         }
 
         // ListUnitFiles returns full path names, we just want base name
         basename = strrchr(value.str, '/');
         if (basename) {
             basename = basename + 1;
         } else {
             basename = value.str;
         }
 
         if (!strcmp(match, ".service")) {
             // Service is the "default" unit type, so strip it
             unit_name = strndup(basename, match - basename);
         } else {
             unit_name = strdup(basename);
         }
 
         nfiles++;
         units = g_list_prepend(units, unit_name);
     }
 
     dbus_message_unref(reply);
 
     crm_trace("Found %d manageable systemd unit files", nfiles);
     units = g_list_sort(units, sort_str);
     return units;
 }
 
 gboolean
 systemd_unit_exists(const char *name)
 {
     char *path = NULL;
     char *state = NULL;
 
     /* Note: Makes a blocking dbus calls
      * Used by resources_find_service_class() when resource class=service
      */
     if ((invoke_unit_by_name(name, NULL, &path) != pcmk_rc_ok)
         || (path == NULL)) {
         return FALSE;
     }
 
     /* A successful LoadUnit is not sufficient to determine the unit's
      * existence; it merely means the LoadUnit request received a reply.
      * We must make another blocking call to check the LoadState property.
      */
     state = systemd_get_property(path, "LoadState", NULL, NULL, NULL,
                                  DBUS_TIMEOUT_USE_DEFAULT);
     free(path);
     if (pcmk__str_any_of(state, "loaded", "masked", NULL)) {
         free(state);
         return TRUE;
     }
     free(state);
     return FALSE;
 }
 
 // @TODO Use XML string constants and maybe a real XML object
 #define METADATA_FORMAT                                                     \
     "<?xml " PCMK_XA_VERSION "=\"1.0\"?>\n"                                 \
     "<" PCMK_XE_RESOURCE_AGENT " "                                          \
         PCMK_XA_NAME "='%s' "                                               \
         PCMK_XA_VERSION "='" PCMK_DEFAULT_AGENT_VERSION "'>\n"              \
     "  <" PCMK_XE_VERSION ">1.1</" PCMK_XE_VERSION ">\n"                    \
     "  <" PCMK_XE_LONGDESC " lang=\"en\">\n"                                \
     "    %s\n"                                                              \
     "  </" PCMK_XE_LONGDESC ">\n"                                           \
-    "  <shortdesc lang=\"en\">systemd unit file for %s</shortdesc>\n"       \
+    "  <" PCMK_XE_SHORTDESC " lang=\"en\">systemd unit file for %s"         \
+      "</" PCMK_XE_SHORTDESC ">\n"       \
     "  <" PCMK_XE_PARAMETERS "/>\n"                                         \
     "  <actions>\n"                                                         \
     "    <action name=\"start\"     timeout=\"100\" />\n"                   \
     "    <action name=\"stop\"      timeout=\"100\" />\n"                   \
     "    <action name=\"status\"    timeout=\"100\" />\n"                   \
     "    <action name=\"monitor\"   timeout=\"100\" interval=\"60\"/>\n"    \
     "    <action name=\"meta-data\" timeout=\"5\"   />\n"                   \
     "  </actions>\n"                                                        \
     "  <special tag=\"systemd\"/>\n"                                        \
     "</" PCMK_XE_RESOURCE_AGENT ">\n"
 
 static char *
 systemd_unit_metadata(const char *name, int timeout)
 {
     char *meta = NULL;
     char *desc = NULL;
     char *path = NULL;
 
     char *escaped = NULL;
 
     if (invoke_unit_by_name(name, NULL, &path) == pcmk_rc_ok) {
         /* TODO: Worth a making blocking call for? Probably not. Possibly if cached. */
         desc = systemd_get_property(path, "Description", NULL, NULL, NULL,
                                     timeout);
     } else {
         desc = crm_strdup_printf("Systemd unit file for %s", name);
     }
 
     escaped = crm_xml_escape(desc);
 
     meta = crm_strdup_printf(METADATA_FORMAT, name, escaped, name);
     free(desc);
     free(path);
     free(escaped);
     return meta;
 }
 
 /*!
  * \internal
  * \brief Determine result of method from reply
  *
  * \param[in]     reply  Reply to start, stop, or restart request
  * \param[in,out] op     Action that was executed
  */
 static void
 process_unit_method_reply(DBusMessage *reply, svc_action_t *op)
 {
     DBusError error;
 
     dbus_error_init(&error);
 
     /* The first use of error here is not used other than as a non-NULL flag to
      * indicate that a request was indeed sent
      */
     if (pcmk_dbus_find_error((void *) &error, reply, &error)) {
         set_result_from_method_error(op, &error);
         dbus_error_free(&error);
 
     } else if (!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH,
                                      __func__, __LINE__)) {
         crm_info("DBus request for %s of %s succeeded but "
                  "return type was unexpected",
                  op->action, pcmk__s(op->rsc, "unknown resource"));
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE,
                              "systemd DBus method had unexpected reply");
 
     } else {
         const char *path = NULL;
 
         dbus_message_get_args(reply, NULL,
                               DBUS_TYPE_OBJECT_PATH, &path,
                               DBUS_TYPE_INVALID);
         crm_debug("DBus request for %s of %s using %s succeeded",
                   op->action, pcmk__s(op->rsc, "unknown resource"), path);
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
     }
 }
 
 /*!
  * \internal
  * \brief Process the completion of an asynchronous unit start, stop, or restart
  *
  * \param[in,out] pending    If not NULL, DBus call associated with request
  * \param[in,out] user_data  Action that was executed
  */
 static void
 unit_method_complete(DBusPendingCall *pending, void *user_data)
 {
     DBusMessage *reply = NULL;
     svc_action_t *op = user_data;
 
     crm_trace("Result for %s arrived", op->id);
 
     // Grab the reply
     if (pending != NULL) {
         reply = dbus_pending_call_steal_reply(pending);
     }
 
     // The call is no longer pending
     CRM_LOG_ASSERT(pending == op->opaque->pending);
     services_set_op_pending(op, NULL);
 
     // Determine result and finalize action
     process_unit_method_reply(reply, op);
     services__finalize_async_op(op);
     if (reply != NULL) {
         dbus_message_unref(reply);
     }
 }
 
 #define SYSTEMD_OVERRIDE_ROOT "/run/systemd/system/"
 
 /* When the cluster manages a systemd resource, we create a unit file override
  * to order the service "before" pacemaker. The "before" relationship won't
  * actually be used, since systemd won't ever start the resource -- we're
  * interested in the reverse shutdown ordering it creates, to ensure that
  * systemd doesn't stop the resource at shutdown while pacemaker is still
  * running.
  *
  * @TODO Add start timeout
  */
 #define SYSTEMD_OVERRIDE_TEMPLATE                           \
     "[Unit]\n"                                              \
     "Description=Cluster Controlled %s\n"                   \
     "Before=pacemaker.service pacemaker_remote.service\n"   \
     "\n"                                                    \
     "[Service]\n"                                           \
     "Restart=no\n"
 
 // Temporarily use rwxr-xr-x umask when opening a file for writing
 static FILE *
 create_world_readable(const char *filename)
 {
     mode_t orig_umask = umask(S_IWGRP | S_IWOTH);
     FILE *fp = fopen(filename, "w");
 
     umask(orig_umask);
     return fp;
 }
 
 static void
 create_override_dir(const char *agent)
 {
     char *override_dir = crm_strdup_printf(SYSTEMD_OVERRIDE_ROOT
                                            "/%s.service.d", agent);
     int rc = pcmk__build_path(override_dir, 0755);
 
     if (rc != pcmk_rc_ok) {
         crm_warn("Could not create systemd override directory %s: %s",
                  override_dir, pcmk_rc_str(rc));
     }
     free(override_dir);
 }
 
 static char *
 get_override_filename(const char *agent)
 {
     return crm_strdup_printf(SYSTEMD_OVERRIDE_ROOT
                              "/%s.service.d/50-pacemaker.conf", agent);
 }
 
 static void
 systemd_create_override(const char *agent, int timeout)
 {
     FILE *file_strm = NULL;
     char *override_file = get_override_filename(agent);
 
     create_override_dir(agent);
 
     /* Ensure the override file is world-readable. This is not strictly
      * necessary, but it avoids a systemd warning in the logs.
      */
     file_strm = create_world_readable(override_file);
     if (file_strm == NULL) {
         crm_err("Cannot open systemd override file %s for writing",
                 override_file);
     } else {
         char *override = crm_strdup_printf(SYSTEMD_OVERRIDE_TEMPLATE, agent);
 
         int rc = fprintf(file_strm, "%s\n", override);
 
         free(override);
         if (rc < 0) {
             crm_perror(LOG_WARNING, "Cannot write to systemd override file %s",
                        override_file);
         }
         fflush(file_strm);
         fclose(file_strm);
         systemd_daemon_reload(timeout);
     }
 
     free(override_file);
 }
 
 static void
 systemd_remove_override(const char *agent, int timeout)
 {
     char *override_file = get_override_filename(agent);
     int rc = unlink(override_file);
 
     if (rc < 0) {
         // Stop may be called when already stopped, which is fine
         crm_perror(LOG_DEBUG, "Cannot remove systemd override file %s",
                    override_file);
     } else {
         systemd_daemon_reload(timeout);
     }
     free(override_file);
 }
 
 /*!
  * \internal
  * \brief Parse result of systemd status check
  *
  * Set a status action's exit status and execution status based on a DBus
  * property check result, and finalize the action if asynchronous.
  *
  * \param[in]     name      DBus interface name for property that was checked
  * \param[in]     state     Property value
  * \param[in,out] userdata  Status action that check was done for
  */
 static void
 parse_status_result(const char *name, const char *state, void *userdata)
 {
     svc_action_t *op = userdata;
 
     crm_trace("Resource %s has %s='%s'",
               pcmk__s(op->rsc, "(unspecified)"), name,
               pcmk__s(state, "<null>"));
 
     if (pcmk__str_eq(state, "active", pcmk__str_none)) {
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
 
     } else if (pcmk__str_eq(state, "reloading", pcmk__str_none)) {
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
 
     } else if (pcmk__str_eq(state, "activating", pcmk__str_none)) {
         services__set_result(op, PCMK_OCF_UNKNOWN, PCMK_EXEC_PENDING, NULL);
 
     } else if (pcmk__str_eq(state, "deactivating", pcmk__str_none)) {
         services__set_result(op, PCMK_OCF_UNKNOWN, PCMK_EXEC_PENDING, NULL);
 
     } else {
         services__set_result(op, PCMK_OCF_NOT_RUNNING, PCMK_EXEC_DONE, state);
     }
 
     if (!(op->synchronous)) {
         services_set_op_pending(op, NULL);
         services__finalize_async_op(op);
     }
 }
 
 /*!
  * \internal
  * \brief Invoke a systemd unit, given its DBus object path
  *
  * \param[in,out] op    Action to execute
  * \param[in]     unit  DBus object path of systemd unit to invoke
  */
 static void
 invoke_unit_by_path(svc_action_t *op, const char *unit)
 {
     const char *method = NULL;
     DBusMessage *msg = NULL;
     DBusMessage *reply = NULL;
 
     if (pcmk__str_any_of(op->action, PCMK_ACTION_MONITOR, PCMK_ACTION_STATUS,
                          NULL)) {
         DBusPendingCall *pending = NULL;
         char *state;
 
         state = systemd_get_property(unit, "ActiveState",
                                      (op->synchronous? NULL : parse_status_result),
                                      op, (op->synchronous? NULL : &pending),
                                      op->timeout);
         if (op->synchronous) {
             parse_status_result("ActiveState", state, op);
             free(state);
 
         } else if (pending == NULL) { // Could not get ActiveState property
             services__format_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                     "Could not get state for unit %s from DBus",
                                     op->agent);
             services__finalize_async_op(op);
 
         } else {
             services_set_op_pending(op, pending);
         }
         return;
 
     } else if (pcmk__str_eq(op->action, PCMK_ACTION_START, pcmk__str_none)) {
         method = "StartUnit";
         systemd_create_override(op->agent, op->timeout);
 
     } else if (pcmk__str_eq(op->action, PCMK_ACTION_STOP, pcmk__str_none)) {
         method = "StopUnit";
         systemd_remove_override(op->agent, op->timeout);
 
     } else if (pcmk__str_eq(op->action, "restart", pcmk__str_none)) {
         method = "RestartUnit";
 
     } else {
         services__format_result(op, PCMK_OCF_UNIMPLEMENT_FEATURE,
                                 PCMK_EXEC_ERROR,
                                 "Action %s not implemented "
                                 "for systemd resources",
                                 pcmk__s(op->action, "(unspecified)"));
         if (!(op->synchronous)) {
             services__finalize_async_op(op);
         }
         return;
     }
 
     crm_trace("Calling %s for unit path %s%s%s",
               method, unit,
               ((op->rsc == NULL)? "" : " for resource "), pcmk__s(op->rsc, ""));
 
     msg = systemd_new_method(method);
     CRM_ASSERT(msg != NULL);
 
     /* (ss) */
     {
         const char *replace_s = "replace";
         char *name = systemd_service_name(op->agent,
                                           pcmk__str_eq(op->action,
                                                        PCMK_ACTION_META_DATA,
                                                        pcmk__str_none));
 
         CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_STRING, &name, DBUS_TYPE_INVALID));
         CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_STRING, &replace_s, DBUS_TYPE_INVALID));
 
         free(name);
     }
 
     if (op->synchronous) {
         reply = systemd_send_recv(msg, NULL, op->timeout);
         dbus_message_unref(msg);
         process_unit_method_reply(reply, op);
         if (reply != NULL) {
             dbus_message_unref(reply);
         }
 
     } else {
         DBusPendingCall *pending = systemd_send(msg, unit_method_complete, op,
                                                 op->timeout);
 
         dbus_message_unref(msg);
         if (pending == NULL) {
             services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                  "Unable to send DBus message");
             services__finalize_async_op(op);
 
         } else {
             services_set_op_pending(op, pending);
         }
     }
 }
 
 static gboolean
 systemd_timeout_callback(gpointer p)
 {
     svc_action_t * op = p;
 
     op->opaque->timerid = 0;
     crm_info("%s action for systemd unit %s named '%s' timed out",
              op->action, op->agent, op->rsc);
     services__format_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_TIMEOUT,
                             "%s action for systemd unit %s "
                             "did not complete in time", op->action, op->agent);
     services__finalize_async_op(op);
     return FALSE;
 }
 
 /*!
  * \internal
  * \brief Execute a systemd action
  *
  * \param[in,out] op  Action to execute
  *
  * \return Standard Pacemaker return code
  * \retval EBUSY          Recurring operation could not be initiated
  * \retval pcmk_rc_error  Synchronous action failed
  * \retval pcmk_rc_ok     Synchronous action succeeded, or asynchronous action
  *                        should not be freed (because it's pending or because
  *                        it failed to execute and was already freed)
  *
  * \note If the return value for an asynchronous action is not pcmk_rc_ok, the
  *       caller is responsible for freeing the action.
  */
 int
 services__execute_systemd(svc_action_t *op)
 {
     CRM_ASSERT(op != NULL);
 
     if ((op->action == NULL) || (op->agent == NULL)) {
         services__set_result(op, PCMK_OCF_NOT_CONFIGURED, PCMK_EXEC_ERROR_FATAL,
                              "Bug in action caller");
         goto done;
     }
 
     if (!systemd_init()) {
         services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                              "No DBus connection");
         goto done;
     }
 
     crm_debug("Performing %ssynchronous %s op on systemd unit %s%s%s",
               (op->synchronous? "" : "a"), op->action, op->agent,
               ((op->rsc == NULL)? "" : " for resource "), pcmk__s(op->rsc, ""));
 
     if (pcmk__str_eq(op->action, PCMK_ACTION_META_DATA, pcmk__str_casei)) {
         op->stdout_data = systemd_unit_metadata(op->agent, op->timeout);
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
         goto done;
     }
 
     /* invoke_unit_by_name() should always override these values, which are here
      * just as a fail-safe in case there are any code paths that neglect to
      */
     services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                          "Bug in service library");
 
     if (invoke_unit_by_name(op->agent, op, NULL) == pcmk_rc_ok) {
         op->opaque->timerid = g_timeout_add(op->timeout + 5000,
                                             systemd_timeout_callback, op);
         services_add_inflight_op(op);
         return pcmk_rc_ok;
     }
 
 done:
     if (op->synchronous) {
         return (op->rc == PCMK_OCF_OK)? pcmk_rc_ok : pcmk_rc_error;
     } else {
         return services__finalize_async_op(op);
     }
 }
diff --git a/lib/services/upstart.c b/lib/services/upstart.c
index 7210f684fd..99c211a79f 100644
--- a/lib/services/upstart.c
+++ b/lib/services/upstart.c
@@ -1,705 +1,706 @@
 /*
  * Original copyright 2010 Senko Rasic <senko.rasic@dobarkod.hr>
  *                         and Ante Karamatic <ivoks@init.hr>
  * Later changes copyright 2012-2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU Lesser General Public License
  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 
 #include <stdio.h>
 
 #include <crm/crm.h>
 #include <crm/msg_xml.h>
 #include <crm/services.h>
 #include <crm/common/mainloop.h>
 
 #include <services_private.h>
 #include <upstart.h>
 #include <dbus/dbus.h>
 #include <pcmk-dbus.h>
 
 #include <glib.h>
 #include <gio/gio.h>
 
 #define BUS_NAME "com.ubuntu.Upstart"
 #define BUS_PATH "/com/ubuntu/Upstart"
 
 #define UPSTART_06_API     BUS_NAME"0_6"
 #define UPSTART_JOB_IFACE  UPSTART_06_API".Job"
 #define BUS_PROPERTY_IFACE "org.freedesktop.DBus.Properties"
 
 /*
   http://upstart.ubuntu.com/wiki/DBusInterface
 */
 static DBusConnection *upstart_proxy = NULL;
 
 /*!
  * \internal
  * \brief Prepare an Upstart action
  *
  * \param[in,out] op  Action to prepare
  *
  * \return Standard Pacemaker return code
  */
 int
 services__upstart_prepare(svc_action_t *op)
 {
     op->opaque->exec = strdup("upstart-dbus");
     if (op->opaque->exec == NULL) {
         return ENOMEM;
     }
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Map a Upstart result to a standard OCF result
  *
  * \param[in] exit_status  Upstart result
  *
  * \return Standard OCF result
  */
 enum ocf_exitcode
 services__upstart2ocf(int exit_status)
 {
     // This library uses OCF codes for Upstart actions
     return (enum ocf_exitcode) exit_status;
 }
 
 static gboolean
 upstart_init(void)
 {
     static int need_init = 1;
 
     if (need_init) {
         need_init = 0;
         upstart_proxy = pcmk_dbus_connect();
     }
     if (upstart_proxy == NULL) {
         return FALSE;
     }
     return TRUE;
 }
 
 void
 upstart_cleanup(void)
 {
     if (upstart_proxy) {
         pcmk_dbus_disconnect(upstart_proxy);
         upstart_proxy = NULL;
     }
 }
 
 /*!
  * \internal
  * \brief Get the DBus object path corresponding to a job name
  *
  * \param[in]  arg_name  Name of job to get path for
  * \param[out] path      If not NULL, where to store DBus object path
  * \param[in]  timeout   Give up after this many seconds
  *
  * \return true if object path was found, false otherwise
  * \note The caller is responsible for freeing *path if it is non-NULL.
  */
 static bool
 object_path_for_job(const gchar *arg_name, char **path, int timeout)
 {
     /*
         com.ubuntu.Upstart0_6.GetJobByName (in String name, out ObjectPath job)
     */
     DBusError error;
     DBusMessage *msg;
     DBusMessage *reply = NULL;
     bool rc = false;
 
     if (path != NULL) {
         *path = NULL;
     }
 
     if (!upstart_init()) {
         return false;
     }
     msg = dbus_message_new_method_call(BUS_NAME, // target for the method call
                                        BUS_PATH, // object to call on
                                        UPSTART_06_API,  // interface to call on
                                        "GetJobByName"); // method name
 
     dbus_error_init(&error);
     CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_STRING, &arg_name,
                                             DBUS_TYPE_INVALID));
     reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, timeout);
     dbus_message_unref(msg);
 
     if (dbus_error_is_set(&error)) {
         crm_err("Could not get DBus object path for %s: %s",
                 arg_name, error.message);
         dbus_error_free(&error);
 
     } else if (!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH,
                                      __func__, __LINE__)) {
         crm_err("Could not get DBus object path for %s: Invalid return type",
                 arg_name);
 
     } else {
         if (path != NULL) {
             dbus_message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH, path,
                                   DBUS_TYPE_INVALID);
             if (*path != NULL) {
                 *path = strdup(*path);
             }
         }
         rc = true;
     }
 
     if (reply != NULL) {
         dbus_message_unref(reply);
     }
     return rc;
 }
 
 static void
 fix(char *input, const char *search, char replace)
 {
     char *match = NULL;
     int shuffle = strlen(search) - 1;
 
     while (TRUE) {
         int len, lpc;
 
         match = strstr(input, search);
         if (match == NULL) {
             break;
         }
         crm_trace("Found: %s", match);
         match[0] = replace;
         len = strlen(match) - shuffle;
         for (lpc = 1; lpc <= len; lpc++) {
             match[lpc] = match[lpc + shuffle];
         }
     }
 }
 
 static char *
 fix_upstart_name(const char *input)
 {
     char *output = strdup(input);
 
     fix(output, "_2b", '+');
     fix(output, "_2c", ',');
     fix(output, "_2d", '-');
     fix(output, "_2e", '.');
     fix(output, "_40", '@');
     fix(output, "_5f", '_');
     return output;
 }
 
 GList *
 upstart_job_listall(void)
 {
     GList *units = NULL;
     DBusMessageIter args;
     DBusMessageIter unit;
     DBusMessage *msg = NULL;
     DBusMessage *reply = NULL;
     const char *method = "GetAllJobs";
     DBusError error;
     int lpc = 0;
 
     if (upstart_init() == FALSE) {
         return NULL;
     }
 
 /*
   com.ubuntu.Upstart0_6.GetAllJobs (out <Array of ObjectPath> jobs)
 */
 
     dbus_error_init(&error);
     msg = dbus_message_new_method_call(BUS_NAME, // target for the method call
                                        BUS_PATH, // object to call on
                                        UPSTART_06_API, // interface to call on
                                        method); // method name
     CRM_ASSERT(msg != NULL);
 
     reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, DBUS_TIMEOUT_USE_DEFAULT);
     dbus_message_unref(msg);
 
     if (dbus_error_is_set(&error)) {
         crm_err("Call to %s failed: %s", method, error.message);
         dbus_error_free(&error);
         return NULL;
 
     } else if (!dbus_message_iter_init(reply, &args)) {
         crm_err("Call to %s failed: Message has no arguments", method);
         dbus_message_unref(reply);
         return NULL;
     }
 
     if(!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __func__, __LINE__)) {
         crm_err("Call to %s failed: Message has invalid arguments", method);
         dbus_message_unref(reply);
         return NULL;
     }
 
     dbus_message_iter_recurse(&args, &unit);
     while (dbus_message_iter_get_arg_type (&unit) != DBUS_TYPE_INVALID) {
         DBusBasicValue value;
         const char *job = NULL;
         char *path = NULL;
 
         if(!pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_OBJECT_PATH, __func__, __LINE__)) {
             crm_warn("Skipping Upstart reply argument with unexpected type");
             continue;
         }
 
         dbus_message_iter_get_basic(&unit, &value);
 
         if(value.str) {
             int llpc = 0;
             path = value.str;
             job = value.str;
             while (path[llpc] != 0) {
                 if (path[llpc] == '/') {
                     job = path + llpc + 1;
                 }
                 llpc++;
             }
             lpc++;
             crm_trace("%s -> %s", path, job);
             units = g_list_append(units, fix_upstart_name(job));
         }
         dbus_message_iter_next (&unit);
     }
 
     dbus_message_unref(reply);
     crm_trace("Found %d upstart jobs", lpc);
     return units;
 }
 
 gboolean
 upstart_job_exists(const char *name)
 {
     return object_path_for_job(name, NULL, DBUS_TIMEOUT_USE_DEFAULT);
 }
 
 static char *
 get_first_instance(const gchar * job, int timeout)
 {
     char *instance = NULL;
     const char *method = "GetAllInstances";
     DBusError error;
     DBusMessage *msg;
     DBusMessage *reply;
     DBusMessageIter args;
     DBusMessageIter unit;
 
     dbus_error_init(&error);
     msg = dbus_message_new_method_call(BUS_NAME, // target for the method call
                                        job, // object to call on
                                        UPSTART_JOB_IFACE, // interface to call on
                                        method); // method name
     CRM_ASSERT(msg != NULL);
 
     dbus_message_append_args(msg, DBUS_TYPE_INVALID);
     reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, timeout);
     dbus_message_unref(msg);
 
     if (dbus_error_is_set(&error)) {
         crm_info("Call to %s failed: %s", method, error.message);
         dbus_error_free(&error);
         goto done;
 
     } else if(reply == NULL) {
         crm_info("Call to %s failed: no reply", method);
         goto done;
 
     } else if (!dbus_message_iter_init(reply, &args)) {
         crm_info("Call to %s failed: Message has no arguments", method);
         goto done;
     }
 
     if(!pcmk_dbus_type_check(reply, &args, DBUS_TYPE_ARRAY, __func__, __LINE__)) {
         crm_info("Call to %s failed: Message has invalid arguments", method);
         goto done;
     }
 
     dbus_message_iter_recurse(&args, &unit);
     if(pcmk_dbus_type_check(reply, &unit, DBUS_TYPE_OBJECT_PATH, __func__, __LINE__)) {
         DBusBasicValue value;
 
         dbus_message_iter_get_basic(&unit, &value);
 
         if(value.str) {
             instance = strdup(value.str);
             crm_trace("Result: %s", instance);
         }
     }
 
   done:
     if(reply) {
         dbus_message_unref(reply);
     }
     return instance;
 }
 
 /*!
  * \internal
  * \brief Parse result of Upstart status check
  *
  * \param[in] name          DBus interface name for property that was checked
  * \param[in] state         Property value
  * \param[in,out] userdata  Status action that check was done for
  */
 static void
 parse_status_result(const char *name, const char *state, void *userdata)
 {
     svc_action_t *op = userdata;
 
     if (pcmk__str_eq(state, "running", pcmk__str_none)) {
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
     } else {
         services__set_result(op, PCMK_OCF_NOT_RUNNING, PCMK_EXEC_DONE, state);
     }
 
     if (!(op->synchronous)) {
         services_set_op_pending(op, NULL);
         services__finalize_async_op(op);
     }
 }
 
 // @TODO Use XML string constants and maybe a real XML object
 #define METADATA_FORMAT                                                     \
     "<?xml " PCMK_XA_VERSION "=\"1.0\"?>\n"                                 \
     "<" PCMK_XE_RESOURCE_AGENT " "                                          \
         PCMK_XA_NAME "='%s' "                                               \
         PCMK_XA_VERSION "='" PCMK_DEFAULT_AGENT_VERSION "'>\n"              \
     "  <" PCMK_XE_VERSION ">1.1</" PCMK_XE_VERSION ">\n"                    \
     "  <" PCMK_XE_LONGDESC " lang=\"en\">\n"                                \
     "    Upstart agent for controlling the system %s service\n"             \
     "  </" PCMK_XE_LONGDESC ">\n"                                           \
-    "  <shortdesc lang=\"en\">Upstart job for %s</shortdesc>\n"             \
+    "  <" PCMK_XE_SHORTDESC " lang=\"en\">Upstart job for %s"               \
+      "</" PCMK_XE_SHORTDESC ">\n"             \
     "  <" PCMK_XE_PARAMETERS "/>\n"                                         \
     "  <actions>\n"                                                         \
     "    <action name=\"start\"     timeout=\"15\" />\n"                    \
     "    <action name=\"stop\"      timeout=\"15\" />\n"                    \
     "    <action name=\"status\"    timeout=\"15\" />\n"                    \
     "    <action name=\"restart\"   timeout=\"15\" />\n"                    \
     "    <action name=\"monitor\"   timeout=\"15\" interval=\"15\" start-delay=\"15\" />\n" \
     "    <action name=\"meta-data\" timeout=\"5\" />\n"                     \
     "  </actions>\n"                                                        \
     "  <special tag=\"upstart\"/>\n"                                        \
     "</" PCMK_XE_RESOURCE_AGENT ">\n"
 
 static char *
 upstart_job_metadata(const char *name)
 {
     return crm_strdup_printf(METADATA_FORMAT, name, name, name);
 }
 
 /*!
  * \internal
  * \brief Set an action result based on a method error
  *
  * \param[in,out] op     Action to set result for
  * \param[in]     error  Method error
  */
 static void
 set_result_from_method_error(svc_action_t *op, const DBusError *error)
 {
     services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                          "Unable to invoke Upstart DBus method");
 
     if (strstr(error->name, UPSTART_06_API ".Error.UnknownInstance")) {
 
         if (pcmk__str_eq(op->action, PCMK_ACTION_STOP, pcmk__str_casei)) {
             crm_trace("Masking stop failure (%s) for %s "
                       "because unknown service can be considered stopped",
                       error->name, pcmk__s(op->rsc, "unknown resource"));
             services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
             return;
         }
 
         services__set_result(op, PCMK_OCF_NOT_INSTALLED,
                              PCMK_EXEC_NOT_INSTALLED, "Upstart job not found");
 
     } else if (pcmk__str_eq(op->action, PCMK_ACTION_START, pcmk__str_casei)
                && strstr(error->name, UPSTART_06_API ".Error.AlreadyStarted")) {
         crm_trace("Masking start failure (%s) for %s "
                   "because already started resource is OK",
                   error->name, pcmk__s(op->rsc, "unknown resource"));
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
         return;
     }
 
     crm_info("DBus request for %s of Upstart job %s for resource %s failed: %s",
              op->action, op->agent, pcmk__s(op->rsc, "with unknown name"),
              error->message);
 }
 
 /*!
  * \internal
  * \brief Process the completion of an asynchronous job start, stop, or restart
  *
  * \param[in,out] pending    If not NULL, DBus call associated with request
  * \param[in,out] user_data  Action that was executed
  */
 static void
 job_method_complete(DBusPendingCall *pending, void *user_data)
 {
     DBusError error;
     DBusMessage *reply = NULL;
     svc_action_t *op = user_data;
 
     // Grab the reply
     if (pending != NULL) {
         reply = dbus_pending_call_steal_reply(pending);
     }
 
     // Determine result
     dbus_error_init(&error);
     if (pcmk_dbus_find_error(pending, reply, &error)) {
         set_result_from_method_error(op, &error);
         dbus_error_free(&error);
 
     } else if (pcmk__str_eq(op->action, PCMK_ACTION_STOP, pcmk__str_none)) {
         // Call has no return value
         crm_debug("DBus request for stop of %s succeeded",
                   pcmk__s(op->rsc, "unknown resource"));
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
 
     } else if (!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH,
                                      __func__, __LINE__)) {
         crm_info("DBus request for %s of %s succeeded but "
                  "return type was unexpected", op->action,
                  pcmk__s(op->rsc, "unknown resource"));
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
 
     } else {
         const char *path = NULL;
 
         dbus_message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH, &path,
                               DBUS_TYPE_INVALID);
         crm_debug("DBus request for %s of %s using %s succeeded",
                   op->action, pcmk__s(op->rsc, "unknown resource"), path);
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
     }
 
     // The call is no longer pending
     CRM_LOG_ASSERT(pending == op->opaque->pending);
     services_set_op_pending(op, NULL);
 
     // Finalize action
     services__finalize_async_op(op);
     if (reply != NULL) {
         dbus_message_unref(reply);
     }
 }
 
 /*!
  * \internal
  * \brief Execute an Upstart action
  *
  * \param[in,out] op  Action to execute
  *
  * \return Standard Pacemaker return code
  * \retval EBUSY          Recurring operation could not be initiated
  * \retval pcmk_rc_error  Synchronous action failed
  * \retval pcmk_rc_ok     Synchronous action succeeded, or asynchronous action
  *                        should not be freed (because it's pending or because
  *                        it failed to execute and was already freed)
  *
  * \note If the return value for an asynchronous action is not pcmk_rc_ok, the
  *       caller is responsible for freeing the action.
  */
 int
 services__execute_upstart(svc_action_t *op)
 {
     char *job = NULL;
     int arg_wait = TRUE;
     const char *arg_env = "pacemaker=1";
     const char *action = op->action;
 
     DBusError error;
     DBusMessage *msg = NULL;
     DBusMessage *reply = NULL;
     DBusMessageIter iter, array_iter;
 
     CRM_ASSERT(op != NULL);
 
     if ((op->action == NULL) || (op->agent == NULL)) {
         services__set_result(op, PCMK_OCF_NOT_CONFIGURED, PCMK_EXEC_ERROR_FATAL,
                              "Bug in action caller");
         goto cleanup;
     }
 
     if (!upstart_init()) {
         services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                              "No DBus connection");
         goto cleanup;
     }
 
     if (pcmk__str_eq(op->action, PCMK_ACTION_META_DATA, pcmk__str_casei)) {
         op->stdout_data = upstart_job_metadata(op->agent);
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
         goto cleanup;
     }
 
     if (!object_path_for_job(op->agent, &job, op->timeout)) {
         if (pcmk__str_eq(action, PCMK_ACTION_STOP, pcmk__str_none)) {
             services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
         } else {
             services__set_result(op, PCMK_OCF_NOT_INSTALLED,
                                  PCMK_EXEC_NOT_INSTALLED,
                                  "Upstart job not found");
         }
         goto cleanup;
     }
 
     if (job == NULL) {
         // Shouldn't normally be possible -- maybe a memory error
         op->rc = PCMK_OCF_UNKNOWN_ERROR;
         op->status = PCMK_EXEC_ERROR;
         goto cleanup;
     }
 
     if (pcmk__strcase_any_of(op->action, PCMK_ACTION_MONITOR,
                              PCMK_ACTION_STATUS, NULL)) {
         DBusPendingCall *pending = NULL;
         char *state = NULL;
         char *path = get_first_instance(job, op->timeout);
 
         services__set_result(op, PCMK_OCF_NOT_RUNNING, PCMK_EXEC_DONE,
                              "No Upstart job instances found");
         if (path == NULL) {
             goto cleanup;
         }
         state = pcmk_dbus_get_property(upstart_proxy, BUS_NAME, path,
                                        UPSTART_06_API ".Instance", "state",
                                        op->synchronous? NULL : parse_status_result,
                                        op,
                                        op->synchronous? NULL : &pending,
                                        op->timeout);
         free(path);
 
         if (op->synchronous) {
             parse_status_result("state", state, op);
             free(state);
 
         } else if (pending == NULL) {
             services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                  "Could not get job state from DBus");
 
         } else { // Successfully initiated async op
             free(job);
             services_set_op_pending(op, pending);
             services_add_inflight_op(op);
             return pcmk_rc_ok;
         }
 
         goto cleanup;
 
     } else if (pcmk__str_eq(action, PCMK_ACTION_START, pcmk__str_none)) {
         action = "Start";
 
     } else if (pcmk__str_eq(action, PCMK_ACTION_STOP, pcmk__str_none)) {
         action = "Stop";
 
     } else if (pcmk__str_eq(action, "restart", pcmk__str_none)) {
         action = "Restart";
 
     } else {
         services__set_result(op, PCMK_OCF_UNIMPLEMENT_FEATURE,
                              PCMK_EXEC_ERROR_HARD,
                              "Action not implemented for Upstart resources");
         goto cleanup;
     }
 
     // Initialize rc/status in case called functions don't set them
     services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_DONE,
                          "Bug in service library");
 
     crm_debug("Calling %s for %s on %s",
               action, pcmk__s(op->rsc, "unknown resource"), job);
 
     msg = dbus_message_new_method_call(BUS_NAME, // target for the method call
                                        job, // object to call on
                                        UPSTART_JOB_IFACE, // interface to call on
                                        action); // method name
     CRM_ASSERT(msg != NULL);
 
     dbus_message_iter_init_append (msg, &iter);
     CRM_LOG_ASSERT(dbus_message_iter_open_container(&iter,
                                                     DBUS_TYPE_ARRAY,
                                                     DBUS_TYPE_STRING_AS_STRING,
                                                     &array_iter));
     CRM_LOG_ASSERT(dbus_message_iter_append_basic(&array_iter,
                                                   DBUS_TYPE_STRING, &arg_env));
     CRM_LOG_ASSERT(dbus_message_iter_close_container(&iter, &array_iter));
     CRM_LOG_ASSERT(dbus_message_append_args(msg, DBUS_TYPE_BOOLEAN, &arg_wait,
                                             DBUS_TYPE_INVALID));
 
     if (!(op->synchronous)) {
         DBusPendingCall *pending = pcmk_dbus_send(msg, upstart_proxy,
                                                   job_method_complete, op,
                                                   op->timeout);
 
         if (pending == NULL) {
             services__set_result(op, PCMK_OCF_UNKNOWN_ERROR, PCMK_EXEC_ERROR,
                                  "Unable to send DBus message");
             goto cleanup;
 
         } else { // Successfully initiated async op
             free(job);
             services_set_op_pending(op, pending);
             services_add_inflight_op(op);
             return pcmk_rc_ok;
         }
     }
 
     // Synchronous call
 
     dbus_error_init(&error);
     reply = pcmk_dbus_send_recv(msg, upstart_proxy, &error, op->timeout);
 
     if (dbus_error_is_set(&error)) {
         set_result_from_method_error(op, &error);
         dbus_error_free(&error);
 
     } else if (pcmk__str_eq(op->action, PCMK_ACTION_STOP, pcmk__str_none)) {
         // DBus call does not return a value
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
 
     } else if (!pcmk_dbus_type_check(reply, NULL, DBUS_TYPE_OBJECT_PATH,
                                      __func__, __LINE__)) {
         crm_info("Call to %s passed but return type was unexpected",
                  op->action);
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
 
     } else {
         const char *path = NULL;
 
         dbus_message_get_args(reply, NULL, DBUS_TYPE_OBJECT_PATH, &path,
                               DBUS_TYPE_INVALID);
         crm_debug("Call to %s passed: %s", op->action, path);
         services__set_result(op, PCMK_OCF_OK, PCMK_EXEC_DONE, NULL);
     }
 
 cleanup:
     free(job);
     if (msg != NULL) {
         dbus_message_unref(msg);
     }
     if (reply != NULL) {
         dbus_message_unref(reply);
     }
 
     if (op->synchronous) {
         return (op->rc == PCMK_OCF_OK)? pcmk_rc_ok : pcmk_rc_error;
     } else {
         return services__finalize_async_op(op);
     }
 }