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