git.sesse.net Git - bcachefs-tools-debian/blob - linux/kstrtox.c

   1 /*
   2  * Convert integer string representation to an integer.
   3  * If an integer doesn't fit into specified type, -E is returned.
   4  *
   5  * Integer starts with optional sign.
   6  * kstrtou*() functions do not accept sign "-".
   7  *
   8  * Radix 0 means autodetection: leading "0x" implies radix 16,
   9  * leading "0" implies radix 8, otherwise radix is 10.
  10  * Autodetection hints work after optional sign, but not before.
  11  *
  12  * If -E is returned, result is not touched.
  13  */
  14 #include <errno.h>
  15 #include <ctype.h>
  16 #include <linux/kernel.h>
  17 #include <linux/types.h>
  18 #include "kstrtox.h"
  19
  20 #define KSTRTOX_OVERFLOW        (1U << 31)
  21
  22 const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
  23 {
  24         if (*base == 0) {
  25                 if (s[0] == '0') {
  26                         if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
  27                                 *base = 16;
  28                         else
  29                                 *base = 8;
  30                 } else
  31                         *base = 10;
  32         }
  33         if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
  34                 s += 2;
  35         return s;
  36 }
  37
  38 /*
  39  * Convert non-negative integer string representation in explicitly given radix
  40  * to an integer.
  41  * Return number of characters consumed maybe or-ed with overflow bit.
  42  * If overflow occurs, result integer (incorrect) is still returned.
  43  *
  44  * Don't you dare use this function.
  45  */
  46 unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)
  47 {
  48         unsigned long long res;
  49         unsigned int rv;
  50         int overflow;
  51
  52         res = 0;
  53         rv = 0;
  54         overflow = 0;
  55         while (*s) {
  56                 unsigned int val;
  57
  58                 if ('0' <= *s && *s <= '9')
  59                         val = *s - '0';
  60                 else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
  61                         val = _tolower(*s) - 'a' + 10;
  62                 else
  63                         break;
  64
  65                 if (val >= base)
  66                         break;
  67                 /*
  68                  * Check for overflow only if we are within range of
  69                  * it in the max base we support (16)
  70                  */
  71                 if (unlikely(res & (~0ull << 60))) {
  72                         if (res > ULLONG_MAX - val / base)
  73                                 overflow = 1;
  74                 }
  75                 res = res * base + val;
  76                 rv++;
  77                 s++;
  78         }
  79         *p = res;
  80         if (overflow)
  81                 rv |= KSTRTOX_OVERFLOW;
  82         return rv;
  83 }
  84
  85 static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
  86 {
  87         unsigned long long _res;
  88         unsigned int rv;
  89
  90         s = _parse_integer_fixup_radix(s, &base);
  91         rv = _parse_integer(s, base, &_res);
  92         if (rv & KSTRTOX_OVERFLOW)
  93                 return -ERANGE;
  94         if (rv == 0)
  95                 return -EINVAL;
  96         s += rv;
  97         if (*s == '\n')
  98                 s++;
  99         if (*s)
 100                 return -EINVAL;
 101         *res = _res;
 102         return 0;
 103 }
 104
 105 /**
 106  * kstrtoull - convert a string to an unsigned long long
 107  * @s: The start of the string. The string must be null-terminated, and may also
 108  *  include a single newline before its terminating null. The first character
 109  *  may also be a plus sign, but not a minus sign.
 110  * @base: The number base to use. The maximum supported base is 16. If base is
 111  *  given as 0, then the base of the string is automatically detected with the
 112  *  conventional semantics - If it begins with 0x the number will be parsed as a
 113  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 114  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 115  * @res: Where to write the result of the conversion on success.
 116  *
 117  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 118  * Used as a replacement for the obsolete simple_strtoull. Return code must
 119  * be checked.
 120  */
 121 int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
 122 {
 123         if (s[0] == '+')
 124                 s++;
 125         return _kstrtoull(s, base, res);
 126 }
 127
 128 /**
 129  * kstrtoll - convert a string to a long long
 130  * @s: The start of the string. The string must be null-terminated, and may also
 131  *  include a single newline before its terminating null. The first character
 132  *  may also be a plus sign or a minus sign.
 133  * @base: The number base to use. The maximum supported base is 16. If base is
 134  *  given as 0, then the base of the string is automatically detected with the
 135  *  conventional semantics - If it begins with 0x the number will be parsed as a
 136  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 137  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 138  * @res: Where to write the result of the conversion on success.
 139  *
 140  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 141  * Used as a replacement for the obsolete simple_strtoull. Return code must
 142  * be checked.
 143  */
 144 int kstrtoll(const char *s, unsigned int base, long long *res)
 145 {
 146         unsigned long long tmp;
 147         int rv;
 148
 149         if (s[0] == '-') {
 150                 rv = _kstrtoull(s + 1, base, &tmp);
 151                 if (rv < 0)
 152                         return rv;
 153                 if ((long long)-tmp > 0)
 154                         return -ERANGE;
 155                 *res = -tmp;
 156         } else {
 157                 rv = kstrtoull(s, base, &tmp);
 158                 if (rv < 0)
 159                         return rv;
 160                 if ((long long)tmp < 0)
 161                         return -ERANGE;
 162                 *res = tmp;
 163         }
 164         return 0;
 165 }
 166
 167 /* Internal, do not use. */
 168 int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
 169 {
 170         unsigned long long tmp;
 171         int rv;
 172
 173         rv = kstrtoull(s, base, &tmp);
 174         if (rv < 0)
 175                 return rv;
 176         if (tmp != (unsigned long long)(unsigned long)tmp)
 177                 return -ERANGE;
 178         *res = tmp;
 179         return 0;
 180 }
 181
 182 /* Internal, do not use. */
 183 int _kstrtol(const char *s, unsigned int base, long *res)
 184 {
 185         long long tmp;
 186         int rv;
 187
 188         rv = kstrtoll(s, base, &tmp);
 189         if (rv < 0)
 190                 return rv;
 191         if (tmp != (long long)(long)tmp)
 192                 return -ERANGE;
 193         *res = tmp;
 194         return 0;
 195 }
 196
 197 /**
 198  * kstrtouint - convert a string to an unsigned int
 199  * @s: The start of the string. The string must be null-terminated, and may also
 200  *  include a single newline before its terminating null. The first character
 201  *  may also be a plus sign, but not a minus sign.
 202  * @base: The number base to use. The maximum supported base is 16. If base is
 203  *  given as 0, then the base of the string is automatically detected with the
 204  *  conventional semantics - If it begins with 0x the number will be parsed as a
 205  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 206  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 207  * @res: Where to write the result of the conversion on success.
 208  *
 209  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 210  * Used as a replacement for the obsolete simple_strtoull. Return code must
 211  * be checked.
 212  */
 213 int kstrtouint(const char *s, unsigned int base, unsigned int *res)
 214 {
 215         unsigned long long tmp;
 216         int rv;
 217
 218         rv = kstrtoull(s, base, &tmp);
 219         if (rv < 0)
 220                 return rv;
 221         if (tmp != (unsigned long long)(unsigned int)tmp)
 222                 return -ERANGE;
 223         *res = tmp;
 224         return 0;
 225 }
 226
 227 /**
 228  * kstrtoint - convert a string to an int
 229  * @s: The start of the string. The string must be null-terminated, and may also
 230  *  include a single newline before its terminating null. The first character
 231  *  may also be a plus sign or a minus sign.
 232  * @base: The number base to use. The maximum supported base is 16. If base is
 233  *  given as 0, then the base of the string is automatically detected with the
 234  *  conventional semantics - If it begins with 0x the number will be parsed as a
 235  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 236  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 237  * @res: Where to write the result of the conversion on success.
 238  *
 239  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 240  * Used as a replacement for the obsolete simple_strtoull. Return code must
 241  * be checked.
 242  */
 243 int kstrtoint(const char *s, unsigned int base, int *res)
 244 {
 245         long long tmp;
 246         int rv;
 247
 248         rv = kstrtoll(s, base, &tmp);
 249         if (rv < 0)
 250                 return rv;
 251         if (tmp != (long long)(int)tmp)
 252                 return -ERANGE;
 253         *res = tmp;
 254         return 0;
 255 }
 256
 257 int kstrtou16(const char *s, unsigned int base, u16 *res)
 258 {
 259         unsigned long long tmp;
 260         int rv;
 261
 262         rv = kstrtoull(s, base, &tmp);
 263         if (rv < 0)
 264                 return rv;
 265         if (tmp != (unsigned long long)(u16)tmp)
 266                 return -ERANGE;
 267         *res = tmp;
 268         return 0;
 269 }
 270
 271 int kstrtos16(const char *s, unsigned int base, s16 *res)
 272 {
 273         long long tmp;
 274         int rv;
 275
 276         rv = kstrtoll(s, base, &tmp);
 277         if (rv < 0)
 278                 return rv;
 279         if (tmp != (long long)(s16)tmp)
 280                 return -ERANGE;
 281         *res = tmp;
 282         return 0;
 283 }
 284
 285 int kstrtou8(const char *s, unsigned int base, u8 *res)
 286 {
 287         unsigned long long tmp;
 288         int rv;
 289
 290         rv = kstrtoull(s, base, &tmp);
 291         if (rv < 0)
 292                 return rv;
 293         if (tmp != (unsigned long long)(u8)tmp)
 294                 return -ERANGE;
 295         *res = tmp;
 296         return 0;
 297 }
 298
 299 int kstrtos8(const char *s, unsigned int base, s8 *res)
 300 {
 301         long long tmp;
 302         int rv;
 303
 304         rv = kstrtoll(s, base, &tmp);
 305         if (rv < 0)
 306                 return rv;
 307         if (tmp != (long long)(s8)tmp)
 308                 return -ERANGE;
 309         *res = tmp;
 310         return 0;
 311 }
 312
 313 /**
 314  * kstrtobool - convert common user inputs into boolean values
 315  * @s: input string
 316  * @res: result
 317  *
 318  * This routine returns 0 iff the first character is one of 'Yy1Nn0', or
 319  * [oO][NnFf] for "on" and "off". Otherwise it will return -EINVAL.  Value
 320  * pointed to by res is updated upon finding a match.
 321  */
 322 int kstrtobool(const char *s, bool *res)
 323 {
 324         if (!s)
 325                 return -EINVAL;
 326
 327         switch (s[0]) {
 328         case 'y':
 329         case 'Y':
 330         case '1':
 331                 *res = true;
 332                 return 0;
 333         case 'n':
 334         case 'N':
 335         case '0':
 336                 *res = false;
 337                 return 0;
 338         case 'o':
 339         case 'O':
 340                 switch (s[1]) {
 341                 case 'n':
 342                 case 'N':
 343                         *res = true;
 344                         return 0;
 345                 case 'f':
 346                 case 'F':
 347                         *res = false;
 348                         return 0;
 349                 default:
 350                         break;
 351                 }
 352         default:
 353                 break;
 354         }
 355
 356         return -EINVAL;
 357 }