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