diff --git a/lib/common/options.c b/lib/common/options.c
index 1fd23f7fcd..8fbf1c5798 100644
--- a/lib/common/options.c
+++ b/lib/common/options.c
@@ -1,526 +1,524 @@
 /*
  * 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>
 
 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)
 {
-    int tmp;
-
-    return crm_str_to_boolean(value, &tmp) == 1;
+    return crm_str_to_boolean(value, NULL) == 1;
 }
 
 bool
 pcmk__valid_number(const char *value)
 {
     if (value == NULL) {
         return false;
 
     } else if (pcmk_str_is_minus_infinity(value) ||
                pcmk_str_is_infinity(value)) {
         return true;
     }
 
     return pcmk__scan_ll(value, NULL, 0LL) == pcmk_rc_ok;
 }
 
 bool
 pcmk__valid_positive_number(const char *value)
 {
     long long num = 0LL;
 
     return pcmk_str_is_infinity(value)
            || ((pcmk__scan_ll(value, &num, 0LL) == pcmk_rc_ok) && (num > 0));
 }
 
 bool
 pcmk__valid_quorum(const char *value)
 {
     return pcmk__strcase_any_of(value, "stop", "freeze", "ignore", "demote", "suicide", NULL);
 }
 
 bool
 pcmk__valid_script(const char *value)
 {
     struct stat st;
 
     if (pcmk__str_eq(value, "/dev/null", pcmk__str_casei)) {
         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;
 }
 
 bool
 pcmk__valid_percentage(const char *value)
 {
     char *end = NULL;
     long number = strtol(value, &end, 10);
 
     if (end && (end[0] != '%')) {
         return false;
     }
     return number >= 0;
 }
 
 /*!
  * \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 ("longdesc" or "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) {
         pcmk__g_strcat(s, "  Allowed values: ", values, NULL);
     }
     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 version=\"1.0\"?>\n"
                    "<resource-agent name=\"", name, "\" "
                                    "version=\"" PACEMAKER_VERSION "\">\n"
                    "  <version>" PCMK_OCF_VERSION "</version>\n", NULL);
 
     add_desc(s, "longdesc", desc_long, NULL, "  ");
     add_desc(s, "shortdesc", desc_short, NULL, "  ");
 
     g_string_append(s, "  <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, "    <parameter name=\"", opt_name, "\">\n", NULL);
 
         add_desc(s, "longdesc", opt_desc_long, opt_values, "      ");
         add_desc(s, "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, "    </parameter>\n");
     }
     g_string_append(s, "  </parameters>\n</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/common/strings.c b/lib/common/strings.c
index bf9fd56fd2..7f36149230 100644
--- a/lib/common/strings.c
+++ b/lib/common/strings.c
@@ -1,1415 +1,1421 @@
 /*
  * 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/common/results.h"
 #include <crm_internal.h>
 
 #ifndef _GNU_SOURCE
 #  define _GNU_SOURCE
 #endif
 
 #include <regex.h>
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <ctype.h>
 #include <float.h>  // DBL_MIN
 #include <limits.h>
 #include <bzlib.h>
 #include <sys/types.h>
 
 /*!
  * \internal
  * \brief Scan a long long integer from a string
  *
  * \param[in]  text           String to scan
  * \param[out] result         If not NULL, where to store scanned value
  * \param[in]  default_value  Value to use if text is NULL or invalid
  * \param[out] end_text       If not NULL, where to store pointer to first
  *                            non-integer character
  *
  * \return Standard Pacemaker return code (\c pcmk_rc_ok on success,
  *         \c EINVAL on failed string conversion due to invalid input,
  *         or \c EOVERFLOW on arithmetic overflow)
  * \note Sets \c errno on error
  */
 static int
 scan_ll(const char *text, long long *result, long long default_value,
         char **end_text)
 {
     long long local_result = default_value;
     char *local_end_text = NULL;
     int rc = pcmk_rc_ok;
 
     errno = 0;
     if (text != NULL) {
         local_result = strtoll(text, &local_end_text, 10);
         if (errno == ERANGE) {
             rc = EOVERFLOW;
             crm_warn("Integer parsed from '%s' was clipped to %lld",
                      text, local_result);
 
         } else if (errno != 0) {
             rc = errno;
             local_result = default_value;
             crm_warn("Could not parse integer from '%s' (using %lld instead): "
                      "%s", text, default_value, pcmk_rc_str(rc));
 
         } else if (local_end_text == text) {
             rc = EINVAL;
             local_result = default_value;
             crm_warn("Could not parse integer from '%s' (using %lld instead): "
                     "No digits found", text, default_value);
         }
 
         if ((end_text == NULL) && !pcmk__str_empty(local_end_text)) {
             crm_warn("Characters left over after parsing '%s': '%s'",
                      text, local_end_text);
         }
         errno = rc;
     }
     if (end_text != NULL) {
         *end_text = local_end_text;
     }
     if (result != NULL) {
         *result = local_result;
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Scan a long long integer value from a string
  *
  * \param[in]  text           The string to scan (may be NULL)
  * \param[out] result         Where to store result (or NULL to ignore)
  * \param[in]  default_value  Value to use if text is NULL or invalid
  *
  * \return Standard Pacemaker return code
  */
 int
 pcmk__scan_ll(const char *text, long long *result, long long default_value)
 {
     long long local_result = default_value;
     int rc = pcmk_rc_ok;
 
     if (text != NULL) {
         rc = scan_ll(text, &local_result, default_value, NULL);
         if (rc != pcmk_rc_ok) {
             local_result = default_value;
         }
     }
     if (result != NULL) {
         *result = local_result;
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Scan an integer value from a string, constrained to a minimum
  *
  * \param[in]  text           The string to scan (may be NULL)
  * \param[out] result         Where to store result (or NULL to ignore)
  * \param[in]  minimum        Value to use as default and minimum
  *
  * \return Standard Pacemaker return code
  * \note If the value is larger than the maximum integer, EOVERFLOW will be
  *       returned and \p result will be set to the maximum integer.
  */
 int
 pcmk__scan_min_int(const char *text, int *result, int minimum)
 {
     int rc;
     long long result_ll;
 
     rc = pcmk__scan_ll(text, &result_ll, (long long) minimum);
 
     if (result_ll < (long long) minimum) {
         crm_warn("Clipped '%s' to minimum acceptable value %d", text, minimum);
         result_ll = (long long) minimum;
 
     } else if (result_ll > INT_MAX) {
         crm_warn("Clipped '%s' to maximum integer %d", text, INT_MAX);
         result_ll = (long long) INT_MAX;
         rc = EOVERFLOW;
     }
 
     if (result != NULL) {
         *result = (int) result_ll;
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Scan a TCP port number from a string
  *
  * \param[in]  text  The string to scan
  * \param[out] port  Where to store result (or NULL to ignore)
  *
  * \return Standard Pacemaker return code
  * \note \p port will be -1 if \p text is NULL or invalid
  */
 int
 pcmk__scan_port(const char *text, int *port)
 {
     long long port_ll;
     int rc = pcmk__scan_ll(text, &port_ll, -1LL);
 
     if ((text != NULL) && (rc == pcmk_rc_ok) // wasn't default or invalid
         && ((port_ll < 0LL) || (port_ll > 65535LL))) {
         crm_warn("Ignoring port specification '%s' "
                  "not in valid range (0-65535)", text);
         rc = (port_ll < 0LL)? pcmk_rc_before_range : pcmk_rc_after_range;
         port_ll = -1LL;
     }
     if (port != NULL) {
         *port = (int) port_ll;
     }
     return rc;
 }
 
 /*!
  * \internal
  * \brief Scan a double-precision floating-point value from a string
  *
  * \param[in]      text         The string to parse
  * \param[out]     result       Parsed value on success, or
  *                              \c PCMK__PARSE_DBL_DEFAULT on error
  * \param[in]      default_text Default string to parse if \p text is
  *                              \c NULL
  * \param[out]     end_text     If not \c NULL, where to store a pointer
  *                              to the position immediately after the
  *                              value
  *
  * \return Standard Pacemaker return code (\c pcmk_rc_ok on success,
  *         \c EINVAL on failed string conversion due to invalid input,
  *         \c EOVERFLOW on arithmetic overflow, \c pcmk_rc_underflow
  *         on arithmetic underflow, or \c errno from \c strtod() on
  *         other parse errors)
  */
 int
 pcmk__scan_double(const char *text, double *result, const char *default_text,
                   char **end_text)
 {
     int rc = pcmk_rc_ok;
     char *local_end_text = NULL;
 
     CRM_ASSERT(result != NULL);
     *result = PCMK__PARSE_DBL_DEFAULT;
 
     text = (text != NULL) ? text : default_text;
 
     if (text == NULL) {
         rc = EINVAL;
         crm_debug("No text and no default conversion value supplied");
 
     } else {
         errno = 0;
         *result = strtod(text, &local_end_text);
 
         if (errno == ERANGE) {
             /*
              * Overflow: strtod() returns +/- HUGE_VAL and sets errno to
              *           ERANGE
              *
              * Underflow: strtod() returns "a value whose magnitude is
              *            no greater than the smallest normalized
              *            positive" double. Whether ERANGE is set is
              *            implementation-defined.
              */
             const char *over_under;
 
             if (QB_ABS(*result) > DBL_MIN) {
                 rc = EOVERFLOW;
                 over_under = "over";
             } else {
                 rc = pcmk_rc_underflow;
                 over_under = "under";
             }
 
             crm_debug("Floating-point value parsed from '%s' would %sflow "
                       "(using %g instead)", text, over_under, *result);
 
         } else if (errno != 0) {
             rc = errno;
             // strtod() set *result = 0 on parse failure
             *result = PCMK__PARSE_DBL_DEFAULT;
 
             crm_debug("Could not parse floating-point value from '%s' (using "
                       "%.1f instead): %s", text, PCMK__PARSE_DBL_DEFAULT,
                       pcmk_rc_str(rc));
 
         } else if (local_end_text == text) {
             // errno == 0, but nothing was parsed
             rc = EINVAL;
             *result = PCMK__PARSE_DBL_DEFAULT;
 
             crm_debug("Could not parse floating-point value from '%s' (using "
                       "%.1f instead): No digits found", text,
                       PCMK__PARSE_DBL_DEFAULT);
 
         } else if (QB_ABS(*result) <= DBL_MIN) {
             /*
              * errno == 0 and text was parsed, but value might have
              * underflowed.
              *
              * ERANGE might not be set for underflow. Check magnitude
              * of *result, but also make sure the input number is not
              * actually zero (0 <= DBL_MIN is not underflow).
              *
              * This check must come last. A parse failure in strtod()
              * also sets *result == 0, so a parse failure would match
              * this test condition prematurely.
              */
             for (const char *p = text; p != local_end_text; p++) {
                 if (strchr("0.eE", *p) == NULL) {
                     rc = pcmk_rc_underflow;
                     crm_debug("Floating-point value parsed from '%s' would "
                               "underflow (using %g instead)", text, *result);
                     break;
                 }
             }
 
         } else {
             crm_trace("Floating-point value parsed successfully from "
                       "'%s': %g", text, *result);
         }
 
         if ((end_text == NULL) && !pcmk__str_empty(local_end_text)) {
             crm_debug("Characters left over after parsing '%s': '%s'",
                       text, local_end_text);
         }
     }
 
     if (end_text != NULL) {
         *end_text = local_end_text;
     }
 
     return rc;
 }
 
 /*!
  * \internal
  * \brief Parse a guint from a string stored in a hash table
  *
  * \param[in]     table        Hash table to search
  * \param[in]     key          Hash table key to use to retrieve string
  * \param[in]     default_val  What to use if key has no entry in table
  * \param[out]    result       If not NULL, where to store parsed integer
  *
  * \return Standard Pacemaker return code
  */
 int
 pcmk__guint_from_hash(GHashTable *table, const char *key, guint default_val,
                       guint *result)
 {
     const char *value;
     long long value_ll;
     int rc = pcmk_rc_ok;
 
     CRM_CHECK((table != NULL) && (key != NULL), return EINVAL);
 
     if (result != NULL) {
         *result = default_val;
     }
 
     value = g_hash_table_lookup(table, key);
     if (value == NULL) {
         return pcmk_rc_ok;
     }
 
     rc = pcmk__scan_ll(value, &value_ll, 0LL);
     if (rc != pcmk_rc_ok) {
         return rc;
     }
 
     if ((value_ll < 0) || (value_ll > G_MAXUINT)) {
         crm_warn("Could not parse non-negative integer from %s", value);
         return ERANGE;
     }
 
     if (result != NULL) {
         *result = (guint) value_ll;
     }
     return pcmk_rc_ok;
 }
 
 #ifndef NUMCHARS
 #  define	NUMCHARS	"0123456789."
 #endif
 
 #ifndef WHITESPACE
 #  define	WHITESPACE	" \t\n\r\f"
 #endif
 
 /*!
  * \brief Parse a time+units string and return milliseconds equivalent
  *
  * \param[in] input  String with a nonnegative number and optional unit
  *                   (optionally with whitespace before and/or after the
  *                   number). If missing, the unit defaults to seconds.
  *
  * \return Milliseconds corresponding to string expression, or
  *         \c PCMK__PARSE_INT_DEFAULT on error
  */
 long long
 crm_get_msec(const char *input)
 {
     const char *num_start = NULL;
     const char *units;
     long long multiplier = 1000;
     long long divisor = 1;
     long long msec = PCMK__PARSE_INT_DEFAULT;
     size_t num_len = 0;
     char *end_text = NULL;
 
     if (input == NULL) {
         return PCMK__PARSE_INT_DEFAULT;
     }
 
     num_start = input + strspn(input, WHITESPACE);
     num_len = strspn(num_start, NUMCHARS);
     if (num_len < 1) {
         return PCMK__PARSE_INT_DEFAULT;
     }
     units = num_start + num_len;
     units += strspn(units, WHITESPACE);
 
     if (!strncasecmp(units, "ms", 2) || !strncasecmp(units, "msec", 4)) {
         multiplier = 1;
         divisor = 1;
     } else if (!strncasecmp(units, "us", 2) || !strncasecmp(units, "usec", 4)) {
         multiplier = 1;
         divisor = 1000;
     } else if (!strncasecmp(units, "s", 1) || !strncasecmp(units, "sec", 3)) {
         multiplier = 1000;
         divisor = 1;
     } else if (!strncasecmp(units, "m", 1) || !strncasecmp(units, "min", 3)) {
         multiplier = 60 * 1000;
         divisor = 1;
     } else if (!strncasecmp(units, "h", 1) || !strncasecmp(units, "hr", 2)) {
         multiplier = 60 * 60 * 1000;
         divisor = 1;
     } else if ((*units != '\0') && (*units != '\n') && (*units != '\r')) {
         return PCMK__PARSE_INT_DEFAULT;
     }
 
     scan_ll(num_start, &msec, PCMK__PARSE_INT_DEFAULT, &end_text);
     if (msec > (LLONG_MAX / multiplier)) {
         // Arithmetics overflow while multiplier/divisor mutually exclusive
         return LLONG_MAX;
     }
     msec *= multiplier;
     msec /= divisor;
     return msec;
 }
 
 /*!
  * \internal
  * \brief Parse milliseconds from a Pacemaker interval specification
  *
  * \param[in]  input      Pacemaker time interval specification (a bare number
  *                        of seconds; a number with a unit, optionally with
  *                        whitespace before and/or after the number; or an ISO
  *                        8601 duration)
  * \param[out] result_ms  Where to store milliseconds equivalent of \p input on
  *                        success (limited to the range of an unsigned integer),
  *                        or 0 if \p input is \c NULL or invalid
  *
  * \return Standard Pacemaker return code (specifically, \c pcmk_rc_ok if
  *         \p input is valid or \c NULL, and \c EINVAL otherwise)
  */
 int
 pcmk__parse_interval_spec(const char *input, guint *result_ms)
 {
     long long msec = PCMK__PARSE_INT_DEFAULT;
     int rc = pcmk_rc_ok;
 
     if (input == NULL) {
         msec = 0;
         goto done;
     }
 
     if (input[0] == 'P') {
         crm_time_t *period_s = crm_time_parse_duration(input);
 
         if (period_s != NULL) {
             msec = 1000 * crm_time_get_seconds(period_s);
             crm_time_free(period_s);
         }
 
     } else {
         msec = crm_get_msec(input);
     }
 
     if (msec == PCMK__PARSE_INT_DEFAULT) {
         crm_warn("Using 0 instead of invalid interval specification '%s'",
                  input);
         msec = 0;
         rc = EINVAL;
     }
 
 done:
     if (result_ms != NULL) {
         *result_ms = (msec >= G_MAXUINT)? G_MAXUINT : (guint) msec;
     }
     return rc;
 }
 
 gboolean
 crm_is_true(const char *s)
 {
     gboolean ret = FALSE;
 
     return (crm_str_to_boolean(s, &ret) < 0)? FALSE : ret;
 }
 
 int
 crm_str_to_boolean(const char *s, int *ret)
 {
     if (s == NULL) {
         return -1;
 
     } else if (strcasecmp(s, "true") == 0
                || strcasecmp(s, "on") == 0
                || strcasecmp(s, "yes") == 0 || strcasecmp(s, "y") == 0 || strcasecmp(s, "1") == 0) {
-        *ret = TRUE;
+
+        if (ret != NULL) {
+            *ret = TRUE;
+        }
         return 1;
 
     } else if (strcasecmp(s, "false") == 0
                || strcasecmp(s, "off") == 0
                || strcasecmp(s, "no") == 0 || strcasecmp(s, "n") == 0 || strcasecmp(s, "0") == 0) {
-        *ret = FALSE;
+
+        if (ret != NULL) {
+            *ret = FALSE;
+        }
         return 1;
     }
     return -1;
 }
 
 /*!
  * \internal
  * \brief Replace any trailing newlines in a string with \0's
  *
  * \param[in,out] str  String to trim
  *
  * \return \p str
  */
 char *
 pcmk__trim(char *str)
 {
     int len;
 
     if (str == NULL) {
         return str;
     }
 
     for (len = strlen(str) - 1; len >= 0 && str[len] == '\n'; len--) {
         str[len] = '\0';
     }
 
     return str;
 }
 
 /*!
  * \brief Check whether a string starts with a certain sequence
  *
  * \param[in] str    String to check
  * \param[in] prefix Sequence to match against beginning of \p str
  *
  * \return \c true if \p str begins with match, \c false otherwise
  * \note This is equivalent to !strncmp(s, prefix, strlen(prefix))
  *       but is likely less efficient when prefix is a string literal
  *       if the compiler optimizes away the strlen() at compile time,
  *       and more efficient otherwise.
  */
 bool
 pcmk__starts_with(const char *str, const char *prefix)
 {
     const char *s = str;
     const char *p = prefix;
 
     if (!s || !p) {
         return false;
     }
     while (*s && *p) {
         if (*s++ != *p++) {
             return false;
         }
     }
     return (*p == 0);
 }
 
 static inline bool
 ends_with(const char *s, const char *match, bool as_extension)
 {
     if (pcmk__str_empty(match)) {
         return true;
     } else if (s == NULL) {
         return false;
     } else {
         size_t slen, mlen;
 
         /* Besides as_extension, we could also check
            !strchr(&match[1], match[0]) but that would be inefficient.
          */
         if (as_extension) {
             s = strrchr(s, match[0]);
             return (s == NULL)? false : !strcmp(s, match);
         }
 
         mlen = strlen(match);
         slen = strlen(s);
         return ((slen >= mlen) && !strcmp(s + slen - mlen, match));
     }
 }
 
 /*!
  * \internal
  * \brief Check whether a string ends with a certain sequence
  *
  * \param[in] s      String to check
  * \param[in] match  Sequence to match against end of \p s
  *
  * \return \c true if \p s ends case-sensitively with match, \c false otherwise
  * \note pcmk__ends_with_ext() can be used if the first character of match
  *       does not recur in match.
  */
 bool
 pcmk__ends_with(const char *s, const char *match)
 {
     return ends_with(s, match, false);
 }
 
 /*!
  * \internal
  * \brief Check whether a string ends with a certain "extension"
  *
  * \param[in] s      String to check
  * \param[in] match  Extension to match against end of \p s, that is,
  *                   its first character must not occur anywhere
  *                   in the rest of that very sequence (example: file
  *                   extension where the last dot is its delimiter,
  *                   e.g., ".html"); incorrect results may be
  *                   returned otherwise.
  *
  * \return \c true if \p s ends (verbatim, i.e., case sensitively)
  *         with "extension" designated as \p match (including empty
  *         string), \c false otherwise
  *
  * \note Main incentive to prefer this function over \c pcmk__ends_with()
  *       where possible is the efficiency (at the cost of added
  *       restriction on \p match as stated; the complexity class
  *       remains the same, though: BigO(M+N) vs. BigO(M+2N)).
  */
 bool
 pcmk__ends_with_ext(const char *s, const char *match)
 {
     return ends_with(s, match, true);
 }
 
 /*!
  * \internal
  * \brief Create a hash of a string suitable for use with GHashTable
  *
  * \param[in] v  String to hash
  *
  * \return A hash of \p v compatible with g_str_hash() before glib 2.28
  * \note glib changed their hash implementation:
  *
  * https://gitlab.gnome.org/GNOME/glib/commit/354d655ba8a54b754cb5a3efb42767327775696c
  *
  * Note that the new g_str_hash is presumably a *better* hash (it's actually
  * a correct implementation of DJB's hash), but we need to preserve existing
  * behaviour, because the hash key ultimately determines the "sort" order
  * when iterating through GHashTables, which affects allocation of scores to
  * clone instances when iterating through rsc->allowed_nodes.  It (somehow)
  * also appears to have some minor impact on the ordering of a few
  * pseudo_event IDs in the transition graph.
  */
 static guint
 pcmk__str_hash(gconstpointer v)
 {
     const signed char *p;
     guint32 h = 0;
 
     for (p = v; *p != '\0'; p++)
         h = (h << 5) - h + *p;
 
     return h;
 }
 
 /*!
  * \internal
  * \brief Create a hash table with case-sensitive strings as keys
  *
  * \param[in] key_destroy_func    Function to free a key
  * \param[in] value_destroy_func  Function to free a value
  *
  * \return Newly allocated hash table
  * \note It is the caller's responsibility to free the result, using
  *       g_hash_table_destroy().
  */
 GHashTable *
 pcmk__strkey_table(GDestroyNotify key_destroy_func,
                    GDestroyNotify value_destroy_func)
 {
     return g_hash_table_new_full(pcmk__str_hash, g_str_equal,
                                  key_destroy_func, value_destroy_func);
 }
 
 /* used with hash tables where case does not matter */
 static gboolean
 pcmk__strcase_equal(gconstpointer a, gconstpointer b)
 {
     return pcmk__str_eq((const char *)a, (const char *)b, pcmk__str_casei);
 }
 
 static guint
 pcmk__strcase_hash(gconstpointer v)
 {
     const signed char *p;
     guint32 h = 0;
 
     for (p = v; *p != '\0'; p++)
         h = (h << 5) - h + g_ascii_tolower(*p);
 
     return h;
 }
 
 /*!
  * \internal
  * \brief Create a hash table with case-insensitive strings as keys
  *
  * \param[in] key_destroy_func    Function to free a key
  * \param[in] value_destroy_func  Function to free a value
  *
  * \return Newly allocated hash table
  * \note It is the caller's responsibility to free the result, using
  *       g_hash_table_destroy().
  */
 GHashTable *
 pcmk__strikey_table(GDestroyNotify key_destroy_func,
                     GDestroyNotify value_destroy_func)
 {
     return g_hash_table_new_full(pcmk__strcase_hash, pcmk__strcase_equal,
                                  key_destroy_func, value_destroy_func);
 }
 
 static void
 copy_str_table_entry(gpointer key, gpointer value, gpointer user_data)
 {
     if (key && value && user_data) {
         g_hash_table_insert((GHashTable*)user_data, strdup(key), strdup(value));
     }
 }
 
 /*!
  * \internal
  * \brief Copy a hash table that uses dynamically allocated strings
  *
  * \param[in,out] old_table  Hash table to duplicate
  *
  * \return New hash table with copies of everything in \p old_table
  * \note This assumes the hash table uses dynamically allocated strings -- that
  *       is, both the key and value free functions are free().
  */
 GHashTable *
 pcmk__str_table_dup(GHashTable *old_table)
 {
     GHashTable *new_table = NULL;
 
     if (old_table) {
         new_table = pcmk__strkey_table(free, free);
         g_hash_table_foreach(old_table, copy_str_table_entry, new_table);
     }
     return new_table;
 }
 
 /*!
  * \internal
  * \brief Add a word to a string list of words
  *
  * \param[in,out] list       Pointer to current string list (may not be \p NULL)
  * \param[in]     init_size  \p list will be initialized to at least this size,
  *                           if it needs initialization (if 0, use GLib's default
  *                           initial string size)
  * \param[in]     word       String to add to \p list (\p list will be
  *                           unchanged if this is \p NULL or the empty string)
  * \param[in]     separator  String to separate words in \p list
  *                           (a space will be used if this is NULL)
  *
  * \note \p word may contain \p separator, though that would be a bad idea if
  *       the string needs to be parsed later.
  */
 void
 pcmk__add_separated_word(GString **list, size_t init_size, const char *word,
                          const char *separator)
 {
     CRM_ASSERT(list != NULL);
 
     if (pcmk__str_empty(word)) {
         return;
     }
 
     if (*list == NULL) {
         if (init_size > 0) {
             *list = g_string_sized_new(init_size);
         } else {
             *list = g_string_new(NULL);
         }
     }
 
     if ((*list)->len == 0) {
         // Don't add a separator before the first word in the list
         separator = "";
 
     } else if (separator == NULL) {
         // Default to space-separated
         separator = " ";
     }
 
     g_string_append(*list, separator);
     g_string_append(*list, word);
 }
 
 /*!
  * \internal
  * \brief Compress data
  *
  * \param[in]  data        Data to compress
  * \param[in]  length      Number of characters of data to compress
  * \param[in]  max         Maximum size of compressed data (or 0 to estimate)
  * \param[out] result      Where to store newly allocated compressed result
  * \param[out] result_len  Where to store actual compressed length of result
  *
  * \return Standard Pacemaker return code
  */
 int
 pcmk__compress(const char *data, unsigned int length, unsigned int max,
                char **result, unsigned int *result_len)
 {
     int rc;
     char *compressed = NULL;
     char *uncompressed = strdup(data);
 #ifdef CLOCK_MONOTONIC
     struct timespec after_t;
     struct timespec before_t;
 #endif
 
     if (max == 0) {
         max = (length * 1.01) + 601; // Size guaranteed to hold result
     }
 
 #ifdef CLOCK_MONOTONIC
     clock_gettime(CLOCK_MONOTONIC, &before_t);
 #endif
 
     compressed = calloc((size_t) max, sizeof(char));
     CRM_ASSERT(compressed);
 
     *result_len = max;
     rc = BZ2_bzBuffToBuffCompress(compressed, result_len, uncompressed, length,
                                   CRM_BZ2_BLOCKS, 0, CRM_BZ2_WORK);
     rc = pcmk__bzlib2rc(rc);
 
     free(uncompressed);
 
     if (rc != pcmk_rc_ok) {
         crm_err("Compression of %d bytes failed: %s " CRM_XS " rc=%d",
                 length, pcmk_rc_str(rc), rc);
         free(compressed);
         return rc;
     }
 
 #ifdef CLOCK_MONOTONIC
     clock_gettime(CLOCK_MONOTONIC, &after_t);
 
     crm_trace("Compressed %d bytes into %d (ratio %d:1) in %.0fms",
              length, *result_len, length / (*result_len),
              (after_t.tv_sec - before_t.tv_sec) * 1000 +
              (after_t.tv_nsec - before_t.tv_nsec) / 1e6);
 #else
     crm_trace("Compressed %d bytes into %d (ratio %d:1)",
              length, *result_len, length / (*result_len));
 #endif
 
     *result = compressed;
     return pcmk_rc_ok;
 }
 
 char *
 crm_strdup_printf(char const *format, ...)
 {
     va_list ap;
     int len = 0;
     char *string = NULL;
 
     va_start(ap, format);
     len = vasprintf (&string, format, ap);
     CRM_ASSERT(len > 0);
     va_end(ap);
     return string;
 }
 
 int
 pcmk__parse_ll_range(const char *srcstring, long long *start, long long *end)
 {
     char *remainder = NULL;
     int rc = pcmk_rc_ok;
 
     CRM_ASSERT(start != NULL && end != NULL);
 
     *start = PCMK__PARSE_INT_DEFAULT;
     *end = PCMK__PARSE_INT_DEFAULT;
 
     crm_trace("Attempting to decode: [%s]", srcstring);
     if (pcmk__str_eq(srcstring, "", pcmk__str_null_matches)) {
         return ENODATA;
     } else if (pcmk__str_eq(srcstring, "-", pcmk__str_none)) {
         return pcmk_rc_bad_input;
     }
 
     /* String starts with a dash, so this is either a range with
      * no beginning or garbage.
      * */
     if (*srcstring == '-') {
         int rc = scan_ll(srcstring+1, end, PCMK__PARSE_INT_DEFAULT, &remainder);
 
         if (rc != pcmk_rc_ok || *remainder != '\0') {
             return pcmk_rc_bad_input;
         } else {
             return pcmk_rc_ok;
         }
     }
 
     rc = scan_ll(srcstring, start, PCMK__PARSE_INT_DEFAULT, &remainder);
     if (rc != pcmk_rc_ok) {
         return rc;
     }
 
     if (*remainder && *remainder == '-') {
         if (*(remainder+1)) {
             char *more_remainder = NULL;
             int rc = scan_ll(remainder+1, end, PCMK__PARSE_INT_DEFAULT,
                              &more_remainder);
 
             if (rc != pcmk_rc_ok) {
                 return rc;
             } else if (*more_remainder != '\0') {
                 return pcmk_rc_bad_input;
             }
         }
     } else if (*remainder && *remainder != '-') {
         *start = PCMK__PARSE_INT_DEFAULT;
         return pcmk_rc_bad_input;
     } else {
         /* The input string contained only one number.  Set start and end
          * to the same value and return pcmk_rc_ok.  This gives the caller
          * a way to tell this condition apart from a range with no end.
          */
         *end = *start;
     }
 
     return pcmk_rc_ok;
 }
 
 /*!
  * \internal
  * \brief Find a string in a list of strings
  *
  * \note This function takes the same flags and has the same behavior as
  *       pcmk__str_eq().
  *
  * \note No matter what input string or flags are provided, an empty
  *       list will always return FALSE.
  *
  * \param[in] s      String to search for
  * \param[in] lst    List to search
  * \param[in] flags  A bitfield of pcmk__str_flags to modify operation
  *
  * \return \c TRUE if \p s is in \p lst, or \c FALSE otherwise
  */
 gboolean
 pcmk__str_in_list(const gchar *s, const GList *lst, uint32_t flags)
 {
     for (const GList *ele = lst; ele != NULL; ele = ele->next) {
         if (pcmk__str_eq(s, ele->data, flags)) {
             return TRUE;
         }
     }
 
     return FALSE;
 }
 
 static bool
 str_any_of(const char *s, va_list args, uint32_t flags)
 {
     if (s == NULL) {
         return pcmk_is_set(flags, pcmk__str_null_matches);
     }
 
     while (1) {
         const char *ele = va_arg(args, const char *);
 
         if (ele == NULL) {
             break;
         } else if (pcmk__str_eq(s, ele, flags)) {
             return true;
         }
     }
 
     return false;
 }
 
 /*!
  * \internal
  * \brief Is a string a member of a list of strings?
  *
  * \param[in]  s    String to search for in \p ...
  * \param[in]  ...  Strings to compare \p s against.  The final string
  *                  must be NULL.
  *
  * \note The comparison is done case-insensitively.  The function name is
  *       meant to be reminiscent of strcasecmp.
  *
  * \return \c true if \p s is in \p ..., or \c false otherwise
  */
 bool
 pcmk__strcase_any_of(const char *s, ...)
 {
     va_list ap;
     bool rc;
 
     va_start(ap, s);
     rc = str_any_of(s, ap, pcmk__str_casei);
     va_end(ap);
     return rc;
 }
 
 /*!
  * \internal
  * \brief Is a string a member of a list of strings?
  *
  * \param[in]  s    String to search for in \p ...
  * \param[in]  ...  Strings to compare \p s against.  The final string
  *                  must be NULL.
  *
  * \note The comparison is done taking case into account.
  *
  * \return \c true if \p s is in \p ..., or \c false otherwise
  */
 bool
 pcmk__str_any_of(const char *s, ...)
 {
     va_list ap;
     bool rc;
 
     va_start(ap, s);
     rc = str_any_of(s, ap, pcmk__str_none);
     va_end(ap);
     return rc;
 }
 
 /*!
  * \internal
  * \brief Check whether a character is in any of a list of strings
  *
  * \param[in]   ch      Character (ASCII) to search for
  * \param[in]   ...     Strings to search. Final argument must be
  *                      \c NULL.
  *
  * \return  \c true if any of \p ... contain \p ch, \c false otherwise
  * \note    \p ... must contain at least one argument (\c NULL).
  */
 bool
 pcmk__char_in_any_str(int ch, ...)
 {
     bool rc = false;
     va_list ap;
 
     /*
      * Passing a char to va_start() can generate compiler warnings,
      * so ch is declared as an int.
      */
     va_start(ap, ch);
 
     while (1) {
         const char *ele = va_arg(ap, const char *);
 
         if (ele == NULL) {
             break;
         } else if (strchr(ele, ch) != NULL) {
             rc = true;
             break;
         }
     }
 
     va_end(ap);
     return rc;
 }
 
 /*!
  * \internal
  * \brief Sort strings, with numeric portions sorted numerically
  *
  * Sort two strings case-insensitively like strcasecmp(), but with any numeric
  * portions of the string sorted numerically. This is particularly useful for
  * node names (for example, "node10" will sort higher than "node9" but lower
  * than "remotenode9").
  *
  * \param[in] s1  First string to compare (must not be NULL)
  * \param[in] s2  Second string to compare (must not be NULL)
  *
  * \retval -1 \p s1 comes before \p s2
  * \retval  0 \p s1 and \p s2 are equal
  * \retval  1 \p s1 comes after \p s2
  */
 int
 pcmk__numeric_strcasecmp(const char *s1, const char *s2)
 {
     CRM_ASSERT((s1 != NULL) && (s2 != NULL));
 
     while (*s1 && *s2) {
         if (isdigit(*s1) && isdigit(*s2)) {
             // If node names contain a number, sort numerically
 
             char *end1 = NULL;
             char *end2 = NULL;
             long num1 = strtol(s1, &end1, 10);
             long num2 = strtol(s2, &end2, 10);
 
             // allow ordering e.g. 007 > 7
             size_t len1 = end1 - s1;
             size_t len2 = end2 - s2;
 
             if (num1 < num2) {
                 return -1;
             } else if (num1 > num2) {
                 return 1;
             } else if (len1 < len2) {
                 return -1;
             } else if (len1 > len2) {
                 return 1;
             }
             s1 = end1;
             s2 = end2;
         } else {
             // Compare non-digits case-insensitively
             int lower1 = tolower(*s1);
             int lower2 = tolower(*s2);
 
             if (lower1 < lower2) {
                 return -1;
             } else if (lower1 > lower2) {
                 return 1;
             }
             ++s1;
             ++s2;
         }
     }
     if (!*s1 && *s2) {
         return -1;
     } else if (*s1 && !*s2) {
         return 1;
     }
     return 0;
 }
 
 /*!
  * \internal
  * \brief Sort strings.
  *
  * This is your one-stop function for string comparison. By default, this
  * function works like \p g_strcmp0. That is, like \p strcmp but a \p NULL
  * string sorts before a non-<tt>NULL</tt> string.
  *
  * The \p pcmk__str_none flag produces the default behavior. Behavior can be
  * changed with various flags:
  *
  * - \p pcmk__str_regex - The second string is a regular expression that the
  *                        first string will be matched against.
  * - \p pcmk__str_casei - By default, comparisons are done taking case into
  *                        account. This flag makes comparisons case-
  *                        insensitive. This can be combined with
  *                        \p pcmk__str_regex.
  * - \p pcmk__str_null_matches - If one string is \p NULL and the other is not,
  *                               still return \p 0.
  * - \p pcmk__str_star_matches - If one string is \p "*" and the other is not,
  *                               still return \p 0.
  *
  * \param[in] s1     First string to compare
  * \param[in] s2     Second string to compare, or a regular expression to
  *                   match if \p pcmk__str_regex is set
  * \param[in] flags  A bitfield of \p pcmk__str_flags to modify operation
  *
  * \retval  negative \p s1 is \p NULL or comes before \p s2
  * \retval  0        \p s1 and \p s2 are equal, or \p s1 is found in \p s2 if
  *                   \c pcmk__str_regex is set
  * \retval  positive \p s2 is \p NULL or \p s1 comes after \p s2, or \p s2
  *                   is an invalid regular expression, or \p s1 was not found
  *                   in \p s2 if \p pcmk__str_regex is set.
  */
 int
 pcmk__strcmp(const char *s1, const char *s2, uint32_t flags)
 {
     /* If this flag is set, the second string is a regex. */
     if (pcmk_is_set(flags, pcmk__str_regex)) {
         regex_t r_patt;
         int reg_flags = REG_EXTENDED | REG_NOSUB;
         int regcomp_rc = 0;
         int rc = 0;
 
         if (s1 == NULL || s2 == NULL) {
             return 1;
         }
 
         if (pcmk_is_set(flags, pcmk__str_casei)) {
             reg_flags |= REG_ICASE;
         }
         regcomp_rc = regcomp(&r_patt, s2, reg_flags);
         if (regcomp_rc != 0) {
             rc = 1;
             crm_err("Bad regex '%s' for update: %s", s2, strerror(regcomp_rc));
         } else {
             rc = regexec(&r_patt, s1, 0, NULL, 0);
             regfree(&r_patt);
             if (rc != 0) {
                 rc = 1;
             }
         }
         return rc;
     }
 
     /* If the strings are the same pointer, return 0 immediately. */
     if (s1 == s2) {
         return 0;
     }
 
     /* If this flag is set, return 0 if either (or both) of the input strings
      * are NULL.  If neither one is NULL, we need to continue and compare
      * them normally.
      */
     if (pcmk_is_set(flags, pcmk__str_null_matches)) {
         if (s1 == NULL || s2 == NULL) {
             return 0;
         }
     }
 
     /* Handle the cases where one is NULL and the str_null_matches flag is not set.
      * A NULL string always sorts to the beginning.
      */
     if (s1 == NULL) {
         return -1;
     } else if (s2 == NULL) {
         return 1;
     }
 
     /* If this flag is set, return 0 if either (or both) of the input strings
      * are "*".  If neither one is, we need to continue and compare them
      * normally.
      */
     if (pcmk_is_set(flags, pcmk__str_star_matches)) {
         if (strcmp(s1, "*") == 0 || strcmp(s2, "*") == 0) {
             return 0;
         }
     }
 
     if (pcmk_is_set(flags, pcmk__str_casei)) {
         return strcasecmp(s1, s2);
     } else {
         return strcmp(s1, s2);
     }
 }
 
 /*!
  * \internal
  * \brief Update a dynamically allocated string with a new value
  *
  * Given a dynamically allocated string and a new value for it, if the string
  * is different from the new value, free the string and replace it with either a
  * newly allocated duplicate of the value or NULL as appropriate.
  *
  * \param[in,out] str    Pointer to dynamically allocated string
  * \param[in]     value  New value to duplicate (or NULL)
  *
  * \note The caller remains responsibile for freeing \p *str.
  */
 void
 pcmk__str_update(char **str, const char *value)
 {
     if ((str != NULL) && !pcmk__str_eq(*str, value, pcmk__str_none)) {
         free(*str);
         if (value == NULL) {
             *str = NULL;
         } else {
             *str = strdup(value);
             CRM_ASSERT(*str != NULL);
         }
     }
 }
 
 /*!
  * \internal
  * \brief Append a list of strings to a destination \p GString
  *
  * \param[in,out] buffer  Where to append the strings (must not be \p NULL)
  * \param[in]     ...     A <tt>NULL</tt>-terminated list of strings
  *
  * \note This tends to be more efficient than a single call to
  *       \p g_string_append_printf().
  */
 void
 pcmk__g_strcat(GString *buffer, ...)
 {
     va_list ap;
 
     CRM_ASSERT(buffer != NULL);
     va_start(ap, buffer);
 
     while (true) {
         const char *ele = va_arg(ap, const char *);
 
         if (ele == NULL) {
             break;
         }
         g_string_append(buffer, ele);
     }
     va_end(ap);
 }
 
 // Deprecated functions kept only for backward API compatibility
 // LCOV_EXCL_START
 
 #include <crm/common/util_compat.h>
 
 gboolean
 safe_str_neq(const char *a, const char *b)
 {
     if (a == b) {
         return FALSE;
 
     } else if (a == NULL || b == NULL) {
         return TRUE;
 
     } else if (strcasecmp(a, b) == 0) {
         return FALSE;
     }
     return TRUE;
 }
 
 gboolean
 crm_str_eq(const char *a, const char *b, gboolean use_case)
 {
     if (use_case) {
         return g_strcmp0(a, b) == 0;
 
         /* TODO - Figure out which calls, if any, really need to be case independent */
     } else if (a == b) {
         return TRUE;
 
     } else if (a == NULL || b == NULL) {
         /* shouldn't be comparing NULLs */
         return FALSE;
 
     } else if (strcasecmp(a, b) == 0) {
         return TRUE;
     }
     return FALSE;
 }
 
 char *
 crm_itoa_stack(int an_int, char *buffer, size_t len)
 {
     if (buffer != NULL) {
         snprintf(buffer, len, "%d", an_int);
     }
     return buffer;
 }
 
 guint
 g_str_hash_traditional(gconstpointer v)
 {
     return pcmk__str_hash(v);
 }
 
 gboolean
 crm_strcase_equal(gconstpointer a, gconstpointer b)
 {
     return pcmk__strcase_equal(a, b);
 }
 
 guint
 crm_strcase_hash(gconstpointer v)
 {
     return pcmk__strcase_hash(v);
 }
 
 GHashTable *
 crm_str_table_dup(GHashTable *old_table)
 {
     return pcmk__str_table_dup(old_table);
 }
 
 long long
 crm_parse_ll(const char *text, const char *default_text)
 {
     long long result;
 
     if (text == NULL) {
         text = default_text;
         if (text == NULL) {
             crm_err("No default conversion value supplied");
             errno = EINVAL;
             return PCMK__PARSE_INT_DEFAULT;
         }
     }
     scan_ll(text, &result, PCMK__PARSE_INT_DEFAULT, NULL);
     return result;
 }
 
 int
 crm_parse_int(const char *text, const char *default_text)
 {
     long long result = crm_parse_ll(text, default_text);
 
     if (result < INT_MIN) {
         // If errno is ERANGE, crm_parse_ll() has already logged a message
         if (errno != ERANGE) {
             crm_err("Conversion of %s was clipped: %lld", text, result);
             errno = ERANGE;
         }
         return INT_MIN;
 
     } else if (result > INT_MAX) {
         // If errno is ERANGE, crm_parse_ll() has already logged a message
         if (errno != ERANGE) {
             crm_err("Conversion of %s was clipped: %lld", text, result);
             errno = ERANGE;
         }
         return INT_MAX;
     }
 
     return (int) result;
 }
 
 char *
 crm_strip_trailing_newline(char *str)
 {
     return pcmk__trim(str);
 }
 
 int
 pcmk_numeric_strcasecmp(const char *s1, const char *s2)
 {
     return pcmk__numeric_strcasecmp(s1, s2);
 }
 
 // LCOV_EXCL_STOP
 // End deprecated API
diff --git a/lib/common/tests/strings/crm_str_to_boolean_test.c b/lib/common/tests/strings/crm_str_to_boolean_test.c
index 3bd2e5d990..0c30d8ac11 100644
--- a/lib/common/tests/strings/crm_str_to_boolean_test.c
+++ b/lib/common/tests/strings/crm_str_to_boolean_test.c
@@ -1,92 +1,106 @@
 /*
- * Copyright 2021 the Pacemaker project contributors
+ * Copyright 2024 the Pacemaker project contributors
  *
  * The version control history for this file may have further details.
  *
  * This source code is licensed under the GNU General Public License version 2
  * or later (GPLv2+) WITHOUT ANY WARRANTY.
  */
 
 #include <crm_internal.h>
 
 #include <crm/common/unittest_internal.h>
 
 static void
 bad_input(void **state) {
     assert_int_equal(crm_str_to_boolean(NULL, NULL), -1);
     assert_int_equal(crm_str_to_boolean("", NULL), -1);
     assert_int_equal(crm_str_to_boolean("blahblah", NULL), -1);
 }
 
 static void
 is_true(void **state) {
     int ret;
 
     assert_int_equal(crm_str_to_boolean("true", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("TrUe", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("on", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("ON", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("yes", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("yES", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("y", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("Y", &ret), 1);
     assert_true(ret);
     assert_int_equal(crm_str_to_boolean("1", &ret), 1);
     assert_true(ret);
+
+    // Ensure it still validates the string with a NULL result argument
+    assert_int_equal(crm_str_to_boolean("true", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("on", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("yes", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("y", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("1", NULL), 1);
 }
 
 static void
 is_not_true(void **state) {
     assert_int_equal(crm_str_to_boolean("truedat", NULL), -1);
     assert_int_equal(crm_str_to_boolean("onnn", NULL), -1);
     assert_int_equal(crm_str_to_boolean("yep", NULL), -1);
     assert_int_equal(crm_str_to_boolean("Y!", NULL), -1);
     assert_int_equal(crm_str_to_boolean("100", NULL), -1);
 }
 
 static void
 is_false(void **state) {
     int ret;
 
     assert_int_equal(crm_str_to_boolean("false", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("fAlSe", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("off", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("OFF", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("no", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("No", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("n", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("N", &ret), 1);
     assert_false(ret);
     assert_int_equal(crm_str_to_boolean("0", &ret), 1);
     assert_false(ret);
+
+    // Ensure it still validates the string with a NULL result argument
+    assert_int_equal(crm_str_to_boolean("false", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("off", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("no", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("n", NULL), 1);
+    assert_int_equal(crm_str_to_boolean("0", NULL), 1);
 }
 
 static void
 is_not_false(void **state) {
     assert_int_equal(crm_str_to_boolean("falseee", NULL), -1);
     assert_int_equal(crm_str_to_boolean("of", NULL), -1);
     assert_int_equal(crm_str_to_boolean("nope", NULL), -1);
     assert_int_equal(crm_str_to_boolean("N!", NULL), -1);
     assert_int_equal(crm_str_to_boolean("000", NULL), -1);
 }
 
 PCMK__UNIT_TEST(NULL, NULL,
                 cmocka_unit_test(bad_input),
                 cmocka_unit_test(is_true),
                 cmocka_unit_test(is_not_true),
                 cmocka_unit_test(is_false),
                 cmocka_unit_test(is_not_false))