strings.c

Go to the documentation of this file.

/*
 * 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>

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;
}

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;
}

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;
}

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;
}

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;
}

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;
}

long long
crm_get_msec(const char *input)
{
    char *units = NULL; // Do not free; will point to part of input
    long long multiplier = 1000;
    long long divisor = 1;
    long long msec = PCMK__PARSE_INT_DEFAULT;

    if (input == NULL) {
        return PCMK__PARSE_INT_DEFAULT;
    }

    // Skip initial whitespace
    while (isspace(*input)) {
        input++;
    }

    // Reject negative and unparsable inputs
    scan_ll(input, &msec, -1, &units);
    if (msec < 0) {
        return PCMK__PARSE_INT_DEFAULT;
    }

    /* If the number is a decimal, scan_ll() reads only the integer part. Skip
     * any remaining digits or decimal characters.
     *
     * @COMPAT Well-formed and malformed decimals are both accepted inputs. For
     * example, "3.14 ms" and "3.1.4 ms" are treated the same as "3ms" and
     * parsed successfully. At a compatibility break, decide if this is still
     * desired.
     */
    while (isdigit(*units) || (*units == '.')) {
        units++;
    }

    // Skip any additional whitespace after the number
    while (isspace(*units)) {
        units++;
    }

    /* @COMPAT Use exact comparisons. Currently, we match too liberally, and the
     * second strncasecmp() in each case is redundant.
     */
    if ((*units == '\0')
        || (strncasecmp(units, "s", 1) == 0)
        || (strncasecmp(units, "sec", 3) == 0)) {
        multiplier = 1000;
        divisor = 1;

    } else if ((strncasecmp(units, "ms", 2) == 0)
               || (strncasecmp(units, "msec", 4) == 0)) {
        multiplier = 1;
        divisor = 1;

    } else if ((strncasecmp(units, "us", 2) == 0)
               || (strncasecmp(units, "usec", 4) == 0)) {
        multiplier = 1;
        divisor = 1000;

    } else if ((strncasecmp(units, "m", 1) == 0)
               || (strncasecmp(units, "min", 3) == 0)) {
        multiplier = 60 * 1000;
        divisor = 1;

    } else if ((strncasecmp(units, "h", 1) == 0)
               || (strncasecmp(units, "hr", 2) == 0)) {
        multiplier = 60 * 60 * 1000;
        divisor = 1;

    } else {
        // Invalid units
        return PCMK__PARSE_INT_DEFAULT;
    }

    // Apply units, capping at LLONG_MAX
    if (msec > (LLONG_MAX / multiplier)) {
        return LLONG_MAX;
    }
    return (msec * multiplier) / divisor;
}

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;
    }

    if (pcmk__strcase_any_of(s, PCMK_VALUE_TRUE, "on", "yes", "y", "1", NULL)) {
        if (ret != NULL) {
            *ret = TRUE;
        }
        return 1;
    }

    if (pcmk__strcase_any_of(s, PCMK_VALUE_FALSE, "off", "no", "n", "0",
                             NULL)) {
        if (ret != NULL) {
            *ret = FALSE;
        }
        return 1;
    }
    return -1;
}

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;
}

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));
    }
}

bool
pcmk__ends_with(const char *s, const char *match)
{
    return ends_with(s, match, false);
}

bool
pcmk__ends_with_ext(const char *s, const char *match)
{
    return ends_with(s, match, true);
}

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;
}

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);
}

void
pcmk__insert_dup(GHashTable *table, const char *name, const char *value)
{
    CRM_ASSERT((table != NULL) && (name != NULL));

    g_hash_table_insert(table, pcmk__str_copy(name), pcmk__str_copy(value));
}

/* 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;
}

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) {
        pcmk__insert_dup((GHashTable *) user_data,
                         (const char *) key, (const char *) value);
    }
}

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;
}

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);
}

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 = pcmk__assert_alloc((size_t) max, sizeof(char));

    *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;
}

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;
}

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;
}

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;
}

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;
}

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);
    }
}

char *
pcmk__str_copy_as(const char *file, const char *function, uint32_t line,
                  const char *str)
{
    if (str != NULL) {
        char *result = strdup(str);

        if (result == NULL) {
            crm_abort(file, function, line, "Out of memory", FALSE, TRUE);
            crm_exit(CRM_EX_OSERR);
        }
        return result;
    }
    return NULL;
}

void
pcmk__str_update(char **str, const char *value)
{
    if ((str != NULL) && !pcmk__str_eq(*str, value, pcmk__str_none)) {
        free(*str);
        *str = pcmk__str_copy(value);
    }
}

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