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 <linux/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); 408