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