lib/common/scores.c

/* */
This source file includes following definitions.
pcmk_parse_score
pcmk_readable_score
pcmk_str_is_infinity
pcmk_str_is_minus_infinity
pcmk__add_scores
char2score
   1 /*
   2  * Copyright 2004-2024 the Pacemaker project contributors
   3  *
   4  * The version control history for this file may have further details.
   5  *
   6  * This source code is licensed under the GNU Lesser General Public License
   7  * version 2.1 or later (LGPLv2.1+) WITHOUT ANY WARRANTY.
   8  */
   9 
  10 #include <crm_internal.h>
  11 
  12 #include <stdio.h>      // snprintf(), NULL
  13 #include <string.h>     // strcpy(), strdup()
  14 #include <sys/types.h>  // size_t
  15 
  16 int pcmk__score_red = 0;
  17 int pcmk__score_green = 0;
  18 int pcmk__score_yellow = 0;
  19 
  20 /*!
  21  * \brief Parse an integer score from a string
  22  *
  23  * Parse an integer score from a string. This accepts infinity strings as well
  24  * as red, yellow, and green, and bounds the result to +/-INFINITY.
  25  *
  26  * \param[in]  score_s        Score as string
  27  * \param[out] score          Where to store integer value corresponding to
  28  *                            \p score_s (may be NULL to only check validity)
  29  * \param[in]  default_score  Value to use if \p score_s is NULL or invalid
  30  *
  31  * \return Standard Pacemaker return code
  32  */
  33 int
  34 pcmk_parse_score(const char *score_s, int *score, int default_score)
     /*  */
  35 {
  36     int rc = pcmk_rc_ok;
  37     int local_score = 0;
  38 
  39     // Ensure default score is in bounds
  40     default_score = QB_MIN(default_score, PCMK_SCORE_INFINITY);
  41     default_score = QB_MAX(default_score, -PCMK_SCORE_INFINITY);
  42     local_score = default_score;
  43 
  44     if (score_s == NULL) {
  45 
  46     } else if (pcmk_str_is_minus_infinity(score_s)) {
  47         local_score = -PCMK_SCORE_INFINITY;
  48 
  49     } else if (pcmk_str_is_infinity(score_s)) {
  50         local_score = PCMK_SCORE_INFINITY;
  51 
  52     } else if (pcmk__str_eq(score_s, PCMK_VALUE_RED, pcmk__str_casei)) {
  53         local_score = pcmk__score_red;
  54 
  55     } else if (pcmk__str_eq(score_s, PCMK_VALUE_YELLOW, pcmk__str_casei)) {
  56         local_score = pcmk__score_yellow;
  57 
  58     } else if (pcmk__str_eq(score_s, PCMK_VALUE_GREEN, pcmk__str_casei)) {
  59         local_score = pcmk__score_green;
  60 
  61     } else {
  62         long long score_ll = 0LL;
  63 
  64         rc = pcmk__scan_ll(score_s, &score_ll, default_score);
  65         if (rc == ERANGE) {
  66             rc = pcmk_rc_ok;
  67         }
  68         if (rc != pcmk_rc_ok) {
  69             local_score = default_score;
  70 
  71         } else if (score_ll > PCMK_SCORE_INFINITY) {
  72             local_score = PCMK_SCORE_INFINITY;
  73 
  74         } else if (score_ll < -PCMK_SCORE_INFINITY) {
  75             local_score = -PCMK_SCORE_INFINITY;
  76 
  77         } else {
  78             local_score = (int) score_ll;
  79         }
  80     }
  81 
  82     if (score != NULL) {
  83         *score = local_score;
  84     }
  85     return rc;
  86 }
  87 
  88 /*!
  89  * \brief Return a displayable static string for a score value
  90  *
  91  * Given a score value, return a pointer to a static string representation of
  92  * the score suitable for log messages, output, etc.
  93  *
  94  * \param[in] score  Score to display
  95  *
  96  * \return Pointer to static memory containing string representation of \p score
  97  * \note Subsequent calls to this function will overwrite the returned value, so
  98  *       it should be used only in a local context such as a printf()-style
  99  *       statement.
 100  */
 101 const char *
 102 pcmk_readable_score(int score)
     /*  */
 103 {
 104     // The longest possible result is "-INFINITY"
 105     static char score_s[sizeof(PCMK_VALUE_MINUS_INFINITY)];
 106 
 107     if (score >= PCMK_SCORE_INFINITY) {
 108         strcpy(score_s, PCMK_VALUE_INFINITY);
 109 
 110     } else if (score <= -PCMK_SCORE_INFINITY) {
 111         strcpy(score_s, PCMK_VALUE_MINUS_INFINITY);
 112 
 113     } else {
 114         // Range is limited to +/-1000000, so no chance of overflow
 115         snprintf(score_s, sizeof(score_s), "%d", score);
 116     }
 117 
 118     return score_s;
 119 }
 120 
 121 /*!
 122  * \internal
 123  * \brief Check whether a string represents an infinite value
 124  *
 125  * \param[in] s  String to check
 126  *
 127  * \return \c true if \p s is "INFINITY" or "+INFINITY", otherwise \c false
 128  */
 129 bool
 130 pcmk_str_is_infinity(const char *s) {
     /*  */
 131     return pcmk__str_any_of(s, PCMK_VALUE_INFINITY, PCMK_VALUE_PLUS_INFINITY,
 132                             NULL);
 133 }
 134 
 135 /*!
 136  * \internal
 137  * \brief Check whether a string represents an negatively infinite value
 138  *
 139  * \param[in] s  String to check
 140  *
 141  * \return \c true if \p s is "-INFINITY", otherwise \c false
 142  */
 143 bool
 144 pcmk_str_is_minus_infinity(const char *s) {
     /*  */
 145     return pcmk__str_eq(s, PCMK_VALUE_MINUS_INFINITY, pcmk__str_none);
 146 }
 147 
 148 /*!
 149  * \internal
 150  * \brief Add two scores, bounding to +/-INFINITY
 151  *
 152  * \param[in] score1  First score to add
 153  * \param[in] score2  Second score to add
 154  *
 155  * \note This function does not have context about what the scores mean, so it
 156  *       does not log any messages.
 157  */
 158 int
 159 pcmk__add_scores(int score1, int score2)
     /*  */
 160 {
 161     /* As long as PCMK_SCORE_INFINITY is less than half of the maximum integer,
 162      * we can ignore the possibility of integer overflow.
 163      */
 164     int result = score1 + score2;
 165 
 166     // First handle the cases where one or both is infinite
 167     if ((score1 <= -PCMK_SCORE_INFINITY) || (score2 <= -PCMK_SCORE_INFINITY)) {
 168         return -PCMK_SCORE_INFINITY;
 169     }
 170     if ((score1 >= PCMK_SCORE_INFINITY) || (score2 >= PCMK_SCORE_INFINITY)) {
 171         return PCMK_SCORE_INFINITY;
 172     }
 173 
 174     // Bound result to infinity.
 175     if (result >= PCMK_SCORE_INFINITY) {
 176         return PCMK_SCORE_INFINITY;
 177     }
 178     if (result <= -PCMK_SCORE_INFINITY) {
 179         return -PCMK_SCORE_INFINITY;
 180     }
 181 
 182     return result;
 183 }
 184 
 185 // Deprecated functions kept only for backward API compatibility
 186 // LCOV_EXCL_START
 187 
 188 #include <crm/common/scores_compat.h>
 189 
 190 int
 191 char2score(const char *score)
     /*  */
 192 {
 193     int result = 0;
 194 
 195     (void) pcmk_parse_score(score, &result, 0);
 196     return result;
 197 }
 198 
 199 // LCOV_EXCL_STOP
 200 // End deprecated API
/* */
root/lib/common/scores.c

DEFINITIONS
