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