Branch data Line data Source code
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 : 0 : const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
24 : : {
25 [ + ]: 212 : if (*base == 0) {
26 [ + + ]: 296 : if (s[0] == '0') {
27 [ - + ][ # # ]: 5 : if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
28 : 0 : *base = 16;
29 : : else
30 : 5 : *base = 8;
31 : : } else
32 : 79 : *base = 10;
33 : : }
34 [ # # ][ # # ]: 0 : if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
[ # # ]
35 : 0 : s += 2;
36 : 0 : 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 : 0 : 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 : : int overflow;
52 : :
53 : : res = 0;
54 : : rv = 0;
55 : : overflow = 0;
56 [ + + ]: 790 : while (*s) {
57 : : unsigned int val;
58 : :
59 [ + + ]: 706 : if ('0' <= *s && *s <= '9')
60 : 578 : val = *s - '0';
61 : : else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
62 : 0 : val = _tolower(*s) - 'a' + 10;
63 : : else
64 : : break;
65 : :
66 [ + ]: 578 : if (val >= base)
67 : : break;
68 : : /*
69 : : * Check for overflow only if we are within range of
70 : : * it in the max base we support (16)
71 : : */
72 [ + + ]: 790 : if (unlikely(res & (~0ull << 60))) {
73 [ # # ]: 0 : if (res > div_u64(ULLONG_MAX - val, base))
74 : : overflow = 1;
75 : : }
76 : 578 : res = res * base + val;
77 : 578 : rv++;
78 : 578 : s++;
79 : : }
80 : 0 : *p = res;
81 [ # # ]: 0 : if (overflow)
82 : 0 : rv |= KSTRTOX_OVERFLOW;
83 : 0 : return rv;
84 : : }
85 : :
86 : 0 : static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
87 : : {
88 : : unsigned long long _res;
89 : : unsigned int rv;
90 : :
91 : 1 : s = _parse_integer_fixup_radix(s, &base);
92 : 1 : rv = _parse_integer(s, base, &_res);
93 [ + - ]: 1 : if (rv & KSTRTOX_OVERFLOW)
94 : : return -ERANGE;
95 : 1 : rv &= ~KSTRTOX_OVERFLOW;
96 [ + - ]: 1 : if (rv == 0)
97 : : return -EINVAL;
98 : 1 : s += rv;
99 [ - + ]: 1 : if (*s == '\n')
100 : 0 : s++;
101 [ + ]: 1 : if (*s)
102 : : return -EINVAL;
103 : 1 : *res = _res;
104 : 1 : return 0;
105 : : }
106 : :
107 : : /**
108 : : * kstrtoull - convert a string to an unsigned long long
109 : : * @s: The start of the string. The string must be null-terminated, and may also
110 : : * include a single newline before its terminating null. The first character
111 : : * may also be a plus sign, but not a minus sign.
112 : : * @base: The number base to use. The maximum supported base is 16. If base is
113 : : * given as 0, then the base of the string is automatically detected with the
114 : : * conventional semantics - If it begins with 0x the number will be parsed as a
115 : : * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
116 : : * parsed as an octal number. Otherwise it will be parsed as a decimal.
117 : : * @res: Where to write the result of the conversion on success.
118 : : *
119 : : * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
120 : : * Used as a replacement for the obsolete simple_strtoull. Return code must
121 : : * be checked.
122 : : */
123 : 0 : int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
124 : : {
125 [ # # ][ # # ]: 1 : if (s[0] == '+')
[ # # ][ # # ]
[ # # ][ - + ]
[ # # ]
126 : 0 : s++;
127 : 1 : return _kstrtoull(s, base, res);
128 : : }
129 : : EXPORT_SYMBOL(kstrtoull);
130 : :
131 : : /**
132 : : * kstrtoll - convert a string to a long long
133 : : * @s: The start of the string. The string must be null-terminated, and may also
134 : : * include a single newline before its terminating null. The first character
135 : : * may also be a plus sign or a minus sign.
136 : : * @base: The number base to use. The maximum supported base is 16. If base is
137 : : * given as 0, then the base of the string is automatically detected with the
138 : : * conventional semantics - If it begins with 0x the number will be parsed as a
139 : : * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
140 : : * parsed as an octal number. Otherwise it will be parsed as a decimal.
141 : : * @res: Where to write the result of the conversion on success.
142 : : *
143 : : * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
144 : : * Used as a replacement for the obsolete simple_strtoull. Return code must
145 : : * be checked.
146 : : */
147 : 0 : int kstrtoll(const char *s, unsigned int base, long long *res)
148 : : {
149 : : unsigned long long tmp;
150 : : int rv;
151 : :
152 [ - + ]: 1 : if (s[0] == '-') {
153 : 0 : rv = _kstrtoull(s + 1, base, &tmp);
154 [ # # ]: 0 : if (rv < 0)
155 : : return rv;
156 [ # # ]: 0 : if ((long long)(-tmp) >= 0)
157 : : return -ERANGE;
158 : 0 : *res = -tmp;
159 : : } else {
160 : : rv = kstrtoull(s, base, &tmp);
161 [ + - ]: 1 : if (rv < 0)
162 : : return rv;
163 [ + - ]: 1 : if ((long long)tmp < 0)
164 : : return -ERANGE;
165 : 1 : *res = tmp;
166 : : }
167 : : return 0;
168 : : }
169 : : EXPORT_SYMBOL(kstrtoll);
170 : :
171 : : /* Internal, do not use. */
172 : 0 : int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
173 : : {
174 : : unsigned long long tmp;
175 : : int rv;
176 : :
177 : : rv = kstrtoull(s, base, &tmp);
178 [ # # ]: 0 : if (rv < 0)
179 : : return rv;
180 [ # # ]: 0 : if (tmp != (unsigned long long)(unsigned long)tmp)
181 : : return -ERANGE;
182 : 0 : *res = tmp;
183 : 0 : return 0;
184 : : }
185 : : EXPORT_SYMBOL(_kstrtoul);
186 : :
187 : : /* Internal, do not use. */
188 : 0 : int _kstrtol(const char *s, unsigned int base, long *res)
189 : : {
190 : : long long tmp;
191 : : int rv;
192 : :
193 : 0 : rv = kstrtoll(s, base, &tmp);
194 [ # # ]: 0 : if (rv < 0)
195 : : return rv;
196 [ # # ]: 0 : if (tmp != (long long)(long)tmp)
197 : : return -ERANGE;
198 : 0 : *res = tmp;
199 : 0 : return 0;
200 : : }
201 : : EXPORT_SYMBOL(_kstrtol);
202 : :
203 : : /**
204 : : * kstrtouint - convert a string to an unsigned int
205 : : * @s: The start of the string. The string must be null-terminated, and may also
206 : : * include a single newline before its terminating null. The first character
207 : : * may also be a plus sign, but not a minus sign.
208 : : * @base: The number base to use. The maximum supported base is 16. If base is
209 : : * given as 0, then the base of the string is automatically detected with the
210 : : * conventional semantics - If it begins with 0x the number will be parsed as a
211 : : * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
212 : : * parsed as an octal number. Otherwise it will be parsed as a decimal.
213 : : * @res: Where to write the result of the conversion on success.
214 : : *
215 : : * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
216 : : * Used as a replacement for the obsolete simple_strtoull. Return code must
217 : : * be checked.
218 : : */
219 : 0 : int kstrtouint(const char *s, unsigned int base, unsigned int *res)
220 : : {
221 : : unsigned long long tmp;
222 : : int rv;
223 : :
224 : : rv = kstrtoull(s, base, &tmp);
225 [ # # ]: 0 : if (rv < 0)
226 : : return rv;
227 [ # # ]: 0 : if (tmp != (unsigned long long)(unsigned int)tmp)
228 : : return -ERANGE;
229 : 0 : *res = tmp;
230 : 0 : return 0;
231 : : }
232 : : EXPORT_SYMBOL(kstrtouint);
233 : :
234 : : /**
235 : : * kstrtoint - convert a string to an int
236 : : * @s: The start of the string. The string must be null-terminated, and may also
237 : : * include a single newline before its terminating null. The first character
238 : : * may also be a plus sign or a minus sign.
239 : : * @base: The number base to use. The maximum supported base is 16. If base is
240 : : * given as 0, then the base of the string is automatically detected with the
241 : : * conventional semantics - If it begins with 0x the number will be parsed as a
242 : : * hexadecimal (case insensitive), if it otherwise begins with 0, it will be
243 : : * parsed as an octal number. Otherwise it will be parsed as a decimal.
244 : : * @res: Where to write the result of the conversion on success.
245 : : *
246 : : * Returns 0 on success, -ERANGE on overflow and -EINVAL on parsing error.
247 : : * Used as a replacement for the obsolete simple_strtoull. Return code must
248 : : * be checked.
249 : : */
250 : 0 : int kstrtoint(const char *s, unsigned int base, int *res)
251 : : {
252 : : long long tmp;
253 : : int rv;
254 : :
255 : 1 : rv = kstrtoll(s, base, &tmp);
256 [ + - ]: 1 : if (rv < 0)
257 : : return rv;
258 [ + - ]: 1 : if (tmp != (long long)(int)tmp)
259 : : return -ERANGE;
260 : 1 : *res = tmp;
261 : 1 : return 0;
262 : : }
263 : : EXPORT_SYMBOL(kstrtoint);
264 : :
265 : 0 : int kstrtou16(const char *s, unsigned int base, u16 *res)
266 : : {
267 : : unsigned long long tmp;
268 : : int rv;
269 : :
270 : : rv = kstrtoull(s, base, &tmp);
271 [ # # ]: 0 : if (rv < 0)
272 : : return rv;
273 [ # # ]: 0 : if (tmp != (unsigned long long)(u16)tmp)
274 : : return -ERANGE;
275 : 0 : *res = tmp;
276 : 0 : return 0;
277 : : }
278 : : EXPORT_SYMBOL(kstrtou16);
279 : :
280 : 0 : int kstrtos16(const char *s, unsigned int base, s16 *res)
281 : : {
282 : : long long tmp;
283 : : int rv;
284 : :
285 : 0 : rv = kstrtoll(s, base, &tmp);
286 [ # # ]: 0 : if (rv < 0)
287 : : return rv;
288 [ # # ]: 0 : if (tmp != (long long)(s16)tmp)
289 : : return -ERANGE;
290 : 0 : *res = tmp;
291 : 0 : return 0;
292 : : }
293 : : EXPORT_SYMBOL(kstrtos16);
294 : :
295 : 0 : int kstrtou8(const char *s, unsigned int base, u8 *res)
296 : : {
297 : : unsigned long long tmp;
298 : : int rv;
299 : :
300 : : rv = kstrtoull(s, base, &tmp);
301 [ # # ]: 0 : if (rv < 0)
302 : : return rv;
303 [ # # ]: 0 : if (tmp != (unsigned long long)(u8)tmp)
304 : : return -ERANGE;
305 : 0 : *res = tmp;
306 : 0 : return 0;
307 : : }
308 : : EXPORT_SYMBOL(kstrtou8);
309 : :
310 : 0 : int kstrtos8(const char *s, unsigned int base, s8 *res)
311 : : {
312 : : long long tmp;
313 : : int rv;
314 : :
315 : 0 : rv = kstrtoll(s, base, &tmp);
316 [ # # ]: 0 : if (rv < 0)
317 : : return rv;
318 [ # # ]: 0 : if (tmp != (long long)(s8)tmp)
319 : : return -ERANGE;
320 : 0 : *res = tmp;
321 : 0 : return 0;
322 : : }
323 : : EXPORT_SYMBOL(kstrtos8);
324 : :
325 : : #define kstrto_from_user(f, g, type) \
326 : : int f(const char __user *s, size_t count, unsigned int base, type *res) \
327 : : { \
328 : : /* sign, base 2 representation, newline, terminator */ \
329 : : char buf[1 + sizeof(type) * 8 + 1 + 1]; \
330 : : \
331 : : count = min(count, sizeof(buf) - 1); \
332 : : if (copy_from_user(buf, s, count)) \
333 : : return -EFAULT; \
334 : : buf[count] = '\0'; \
335 : : return g(buf, base, res); \
336 : : } \
337 : : EXPORT_SYMBOL(f)
338 : :
339 [ # # ]: 0 : kstrto_from_user(kstrtoull_from_user, kstrtoull, unsigned long long);
340 [ # # ]: 0 : kstrto_from_user(kstrtoll_from_user, kstrtoll, long long);
341 [ # # ]: 0 : kstrto_from_user(kstrtoul_from_user, kstrtoul, unsigned long);
342 [ # # ]: 0 : kstrto_from_user(kstrtol_from_user, kstrtol, long);
343 [ # # ]: 0 : kstrto_from_user(kstrtouint_from_user, kstrtouint, unsigned int);
344 [ # # ]: 0 : kstrto_from_user(kstrtoint_from_user, kstrtoint, int);
345 [ # # ]: 0 : kstrto_from_user(kstrtou16_from_user, kstrtou16, u16);
346 [ # # ]: 0 : kstrto_from_user(kstrtos16_from_user, kstrtos16, s16);
347 [ # # ]: 0 : kstrto_from_user(kstrtou8_from_user, kstrtou8, u8);
348 [ # # ]: 0 : kstrto_from_user(kstrtos8_from_user, kstrtos8, s8);
|
