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