LXR linux/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
  25const 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 */
  50unsigned 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
  88unsigned 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
  93static 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 */
 128int 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}
 134EXPORT_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 */
 151int 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}
 173EXPORT_SYMBOL(kstrtoll);
 174
 175/* Internal, do not use. */
 176int _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}
 189EXPORT_SYMBOL(_kstrtoul);
 190
 191/* Internal, do not use. */
 192int _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}
 205EXPORT_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 */
 222int 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}
 235EXPORT_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 */
 252int 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}
 265EXPORT_SYMBOL(kstrtoint);
 266
 267int 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}
 280EXPORT_SYMBOL(kstrtou16);
 281
 282int 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}
 295EXPORT_SYMBOL(kstrtos16);
 296
 297int 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}
 310EXPORT_SYMBOL(kstrtou8);
 311
 312int 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}
 325EXPORT_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 */
 336int 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}
 373EXPORT_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 */
 379int 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}
 390EXPORT_SYMBOL(kstrtobool_from_user);
 391
 392#define kstrto_from_user(f, g, type)                                    \
 393int 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}                                                                       \
 404EXPORT_SYMBOL(f)
 405
 406kstrto_from_user(kstrtoull_from_user,   kstrtoull,      unsigned long long);
 407kstrto_from_user(kstrtoll_from_user,    kstrtoll,       long long);
 408kstrto_from_user(kstrtoul_from_user,    kstrtoul,       unsigned long);
 409kstrto_from_user(kstrtol_from_user,     kstrtol,        long);
 410kstrto_from_user(kstrtouint_from_user,  kstrtouint,     unsigned int);
 411kstrto_from_user(kstrtoint_from_user,   kstrtoint,      int);
 412kstrto_from_user(kstrtou16_from_user,   kstrtou16,      u16);
 413kstrto_from_user(kstrtos16_from_user,   kstrtos16,      s16);
 414kstrto_from_user(kstrtou8_from_user,    kstrtou8,       u8);
 415kstrto_from_user(kstrtos8_from_user,    kstrtos8,       s8);
 416