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