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