~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/lib/kstrtox.c

Version: ~ [ linux-5.4-rc3 ] ~ [ linux-5.3.6 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.79 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.149 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.196 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.196 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.75 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp