lib/kstrtox.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Convert integer string representation to an integer.
   4  * If an integer doesn't fit into specified type, -E is returned.
   5  *
   6  * Integer starts with optional sign.
   7  * kstrtou*() functions do not accept sign "-".
   8  *
   9  * Radix 0 means autodetection: leading "0x" implies radix 16,
  10  * leading "0" implies radix 8, otherwise radix is 10.
  11  * Autodetection hints work after optional sign, but not before.
  12  *
  13  * If -E is returned, result is not touched.
  14  */
  15 #include <linux/ctype.h>
  16 #include <linux/errno.h>
  17 #include <linux/kernel.h>
  18 #include <linux/math64.h>
  19 #include <linux/export.h>
  20 #include <linux/types.h>
  21 #include <linux/uaccess.h>
  22 #include "kstrtox.h"
  23
  24 const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
  25 {
  26         if (*base == 0) {
  27                 if (s[0] == '0') {
  28                         if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
  29                                 *base = 16;
  30                         else
  31                                 *base = 8;
  32                 } else
  33                         *base = 10;
  34         }
  35         if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
  36                 s += 2;
  37         return s;
  38 }
  39
  40 /*
  41  * Convert non-negative integer string representation in explicitly given radix
  42  * to an integer.
  43  * Return number of characters consumed maybe or-ed with overflow bit.
  44  * If overflow occurs, result integer (incorrect) is still returned.
  45  *
  46  * Don't you dare use this function.
  47  */
  48 unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *p)
  49 {
  50         unsigned long long res;
  51         unsigned int rv;
  52
  53         res = 0;
  54         rv = 0;
  55         while (1) {
  56                 unsigned int c = *s;
  57                 unsigned int lc = c | 0x20; /* don't tolower() this line */
  58                 unsigned int val;
  59
  60                 if ('0' <= c && c <= '9')
  61                         val = c - '0';
  62                 else if ('a' <= lc && lc <= 'f')
  63                         val = lc - 'a' + 10;
  64                 else
  65                         break;
  66
  67                 if (val >= base)
  68                         break;
  69                 /*
  70                  * Check for overflow only if we are within range of
  71                  * it in the max base we support (16)
  72                  */
  73                 if (unlikely(res & (~0ull << 60))) {
  74                         if (res > div_u64(ULLONG_MAX - val, base))
  75                                 rv |= KSTRTOX_OVERFLOW;
  76                 }
  77                 res = res * base + val;
  78                 rv++;
  79                 s++;
  80         }
  81         *p = res;
  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  * Preferred over simple_strtoull(). Return code must be checked.
 119  */
 120 int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
 121 {
 122         if (s[0] == '+')
 123                 s++;
 124         return _kstrtoull(s, base, res);
 125 }
 126 EXPORT_SYMBOL(kstrtoull);
 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  * Preferred over simple_strtoll(). Return code must be checked.
 142  */
 143 int kstrtoll(const char *s, unsigned int base, long long *res)
 144 {
 145         unsigned long long tmp;
 146         int rv;
 147
 148         if (s[0] == '-') {
 149                 rv = _kstrtoull(s + 1, base, &tmp);
 150                 if (rv < 0)
 151                         return rv;
 152                 if ((long long)-tmp > 0)
 153                         return -ERANGE;
 154                 *res = -tmp;
 155         } else {
 156                 rv = kstrtoull(s, base, &tmp);
 157                 if (rv < 0)
 158                         return rv;
 159                 if ((long long)tmp < 0)
 160                         return -ERANGE;
 161                 *res = tmp;
 162         }
 163         return 0;
 164 }
 165 EXPORT_SYMBOL(kstrtoll);
 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)tmp)
 177                 return -ERANGE;
 178         *res = tmp;
 179         return 0;
 180 }
 181 EXPORT_SYMBOL(_kstrtoul);
 182
 183 /* Internal, do not use. */
 184 int _kstrtol(const char *s, unsigned int base, long *res)
 185 {
 186         long long tmp;
 187         int rv;
 188
 189         rv = kstrtoll(s, base, &tmp);
 190         if (rv < 0)
 191                 return rv;
 192         if (tmp != (long)tmp)
 193                 return -ERANGE;
 194         *res = tmp;
 195         return 0;
 196 }
 197 EXPORT_SYMBOL(_kstrtol);
 198
 199 /**
 200  * kstrtouint - convert a string to an unsigned int
 201  * @s: The start of the string. The string must be null-terminated, and may also
 202  *  include a single newline before its terminating null. The first character
 203  *  may also be a plus sign, but not a minus sign.
 204  * @base: The number base to use. The maximum supported base is 16. If base is
 205  *  given as 0, then the base of the string is automatically detected with the
 206  *  conventional semantics - If it begins with 0x the number will be parsed as a
 207  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 208  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 209  * @res: Where to write the result of the conversion on success.
 210  *
 211  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 212  * Preferred over simple_strtoul(). Return code must be checked.
 213  */
 214 int kstrtouint(const char *s, unsigned int base, unsigned int *res)
 215 {
 216         unsigned long long tmp;
 217         int rv;
 218
 219         rv = kstrtoull(s, base, &tmp);
 220         if (rv < 0)
 221                 return rv;
 222         if (tmp != (unsigned int)tmp)
 223                 return -ERANGE;
 224         *res = tmp;
 225         return 0;
 226 }
 227 EXPORT_SYMBOL(kstrtouint);
 228
 229 /**
 230  * kstrtoint - convert a string to an int
 231  * @s: The start of the string. The string must be null-terminated, and may also
 232  *  include a single newline before its terminating null. The first character
 233  *  may also be a plus sign or a minus sign.
 234  * @base: The number base to use. The maximum supported base is 16. If base is
 235  *  given as 0, then the base of the string is automatically detected with the
 236  *  conventional semantics - If it begins with 0x the number will be parsed as a
 237  *  hexadecimal (case insensitive), if it otherwise begins with 0, it will be
 238  *  parsed as an octal number. Otherwise it will be parsed as a decimal.
 239  * @res: Where to write the result of the conversion on success.
 240  *
 241  * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
 242  * Preferred over simple_strtol(). Return code must be checked.
 243  */
 244 int kstrtoint(const char *s, unsigned int base, int *res)
 245 {
 246         long long tmp;
 247         int rv;
 248
 249         rv = kstrtoll(s, base, &tmp);
 250         if (rv < 0)
 251                 return rv;
 252         if (tmp != (int)tmp)
 253                 return -ERANGE;
 254         *res = tmp;
 255         return 0;
 256 }
 257 EXPORT_SYMBOL(kstrtoint);
 258
 259 int kstrtou16(const char *s, unsigned int base, u16 *res)
 260 {
 261         unsigned long long tmp;
 262         int rv;
 263
 264         rv = kstrtoull(s, base, &tmp);
 265         if (rv < 0)
 266                 return rv;
 267         if (tmp != (u16)tmp)
 268                 return -ERANGE;
 269         *res = tmp;
 270         return 0;
 271 }
 272 EXPORT_SYMBOL(kstrtou16);
 273
 274 int kstrtos16(const char *s, unsigned int base, s16 *res)
 275 {
 276         long long tmp;
 277         int rv;
 278
 279         rv = kstrtoll(s, base, &tmp);
 280         if (rv < 0)
 281                 return rv;
 282         if (tmp != (s16)tmp)
 283                 return -ERANGE;
 284         *res = tmp;
 285         return 0;
 286 }
 287 EXPORT_SYMBOL(kstrtos16);
 288
 289 int kstrtou8(const char *s, unsigned int base, u8 *res)
 290 {
 291         unsigned long long tmp;
 292         int rv;
 293
 294         rv = kstrtoull(s, base, &tmp);
 295         if (rv < 0)
 296                 return rv;
 297         if (tmp != (u8)tmp)
 298                 return -ERANGE;
 299         *res = tmp;
 300         return 0;
 301 }
 302 EXPORT_SYMBOL(kstrtou8);
 303
 304 int kstrtos8(const char *s, unsigned int base, s8 *res)
 305 {
 306         long long tmp;
 307         int rv;
 308
 309         rv = kstrtoll(s, base, &tmp);
 310         if (rv < 0)
 311                 return rv;
 312         if (tmp != (s8)tmp)
 313                 return -ERANGE;
 314         *res = tmp;
 315         return 0;
 316 }
 317 EXPORT_SYMBOL(kstrtos8);
 318
 319 /**
 320  * kstrtobool - convert common user inputs into boolean values
 321  * @s: input string
 322  * @res: result
 323  *
 324  * This routine returns 0 iff the first character is one of 'Yy1Nn0', or
 325  * [oO][NnFf] for "on" and "off". Otherwise it will return -EINVAL.  Value
 326  * pointed to by res is updated upon finding a match.
 327  */
 328 int kstrtobool(const char *s, bool *res)
 329 {
 330         if (!s)
 331                 return -EINVAL;
 332
 333         switch (s[0]) {
 334         case 'y':
 335         case 'Y':
 336         case '1':
 337                 *res = true;
 338                 return 0;
 339         case 'n':
 340         case 'N':
 341         case '0':
 342                 *res = false;
 343                 return 0;
 344         case 'o':
 345         case 'O':
 346                 switch (s[1]) {
 347                 case 'n':
 348                 case 'N':
 349                         *res = true;
 350                         return 0;
 351                 case 'f':
 352                 case 'F':
 353                         *res = false;
 354                         return 0;
 355                 default:
 356                         break;
 357                 }
 358                 break;
 359         default:
 360                 break;
 361         }
 362
 363         return -EINVAL;
 364 }
 365 EXPORT_SYMBOL(kstrtobool);
 366
 367 /*
 368  * Since "base" would be a nonsense argument, this open-codes the
 369  * _from_user helper instead of using the helper macro below.
 370  */
 371 int kstrtobool_from_user(const char __user *s, size_t count, bool *res)
 372 {
 373         /* Longest string needed to differentiate, newline, terminator */
 374         char buf[4];
 375
 376         count = min(count, sizeof(buf) - 1);
 377         if (copy_from_user(buf, s, count))
 378                 return -EFAULT;
 379         buf[count] = '\0';
 380         return kstrtobool(buf, res);
 381 }
 382 EXPORT_SYMBOL(kstrtobool_from_user);
 383
 384 #define kstrto_from_user(f, g, type)                                    \
 385 int f(const char __user *s, size_t count, unsigned int base, type *res) \
 386 {                                                                       \
 387         /* sign, base 2 representation, newline, terminator */          \
 388         char buf[1 + sizeof(type) * 8 + 1 + 1];                         \
 389                                                                         \
 390         count = min(count, sizeof(buf) - 1);                            \
 391         if (copy_from_user(buf, s, count))                              \
 392                 return -EFAULT;                                         \
 393         buf[count] = '\0';                                              \
 394         return g(buf, base, res);                                       \
 395 }                                                                       \
 396 EXPORT_SYMBOL(f)
 397
 398 kstrto_from_user(kstrtoull_from_user,   kstrtoull,      unsigned long long);
 399 kstrto_from_user(kstrtoll_from_user,    kstrtoll,       long long);
 400 kstrto_from_user(kstrtoul_from_user,    kstrtoul,       unsigned long);
 401 kstrto_from_user(kstrtol_from_user,     kstrtol,        long);
 402 kstrto_from_user(kstrtouint_from_user,  kstrtouint,     unsigned int);
 403 kstrto_from_user(kstrtoint_from_user,   kstrtoint,      int);
 404 kstrto_from_user(kstrtou16_from_user,   kstrtou16,      u16);
 405 kstrto_from_user(kstrtos16_from_user,   kstrtos16,      s16);
 406 kstrto_from_user(kstrtou8_from_user,    kstrtou8,       u8);
 407 kstrto_from_user(kstrtos8_from_user,    kstrtos8,       s8);