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
  23 const 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  */
  47 unsigned 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
  82 static 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  */
 118 int 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 }
 124 EXPORT_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  */
 142 int 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 }
 164 EXPORT_SYMBOL(kstrtoll);
 165
 166 /* Internal, do not use. */
 167 int _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 }
 180 EXPORT_SYMBOL(_kstrtoul);
 181
 182 /* Internal, do not use. */
 183 int _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 }
 196 EXPORT_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  */
 214 int 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 }
 227 EXPORT_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  */
 245 int 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 }
 258 EXPORT_SYMBOL(kstrtoint);
 259
 260 int 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 }
 273 EXPORT_SYMBOL(kstrtou16);
 274
 275 int 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 }
 288 EXPORT_SYMBOL(kstrtos16);
 289
 290 int 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 }
 303 EXPORT_SYMBOL(kstrtou8);
 304
 305 int 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 }
 318 EXPORT_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  */
 329 int 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 }
 365 EXPORT_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  */
 371 int 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 }
 382 EXPORT_SYMBOL(kstrtobool_from_user);
 383
 384 #define kstrto_from_user(f, g, type)                                    \
 385 int 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 }                                                                       \
 396 EXPORT_SYMBOL(f)
 397
 398 kstrto_from_user(kstrtoull_from_user,   kstrtoull,      unsigned long long);
 399 kstrto_from_user(kstrtoll_from_user,    kstrtoll,       long long);
 400 kstrto_from_user(kstrtoul_from_user,    kstrtoul,       unsigned long);
 401 kstrto_from_user(kstrtol_from_user,     kstrtol,        long);
 402 kstrto_from_user(kstrtouint_from_user,  kstrtouint,     unsigned int);
 403 kstrto_from_user(kstrtoint_from_user,   kstrtoint,      int);
 404 kstrto_from_user(kstrtou16_from_user,   kstrtou16,      u16);
 405 kstrto_from_user(kstrtos16_from_user,   kstrtos16,      s16);
 406 kstrto_from_user(kstrtou8_from_user,    kstrtou8,       u8);
 407 kstrto_from_user(kstrtos8_from_user,    kstrtos8,       s8);