Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

Linux/lib/kstrtox.c

  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 <linux/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 
 52         res = 0;
 53         rv = 0;
 54         while (*s) {
 55                 unsigned int val;
 56 
 57                 if ('' <= *s && *s <= '9')
 58                         val = *s - '';
 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 '':
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 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us