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