GNU Linux-libre 4.19.211-gnu1
[releases.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/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
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  */
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
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
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  */
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  */
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. */
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. */
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  */
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  */
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
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
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
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
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  */
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  */
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);