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