blob: b8e2080c1a47a24a14c9618cd0dac5e4da0c0c67
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 <asm/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 |