[mirror_ubuntu-artful-kernel.git] / lib / kstrtox.c

/*
 * Convert integer string representation to an integer.
 * If an integer doesn't fit into specified type, -E is returned.
 *
 * Integer starts with optional sign.
 * kstrtou*() functions do not accept sign "-".
 *
 * Radix 0 means autodetection: leading "0x" implies radix 16,
 * leading "0" implies radix 8, otherwise radix is 10.
 * Autodetection hints work after optional sign, but not before.
 *
 * If -E is returned, result is not touched.
 */
#include <linux/ctype.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/math64.h>
#include <linux/module.h>
#include <linux/types.h>
#include <asm/uaccess.h>
#include "kstrtox.h"

const char *_parse_integer_fixup_radix(const char *s, unsigned int *base)
{
	if (*base == 0) {
		if (s[0] == '0') {
			if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
				*base = 16;
			else
				*base = 8;
		} else
			*base = 10;
	}
	if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
		s += 2;
	return s;
}

/*
 * Convert non-negative integer string representation in explicitly given radix
 * to an integer.
 * Return number of characters consumed maybe or-ed with overflow bit.
 * If overflow occurs, result integer (incorrect) is still returned.
 *
 * Don't you dare use this function.
 */
unsigned int _parse_integer(const char *s, unsigned int base, unsigned long long *res)
{
	unsigned int rv;
	int overflow;

	*res = 0;
	rv = 0;
	overflow = 0;
	while (*s) {
		unsigned int val;

		if ('0' <= *s && *s <= '9')
			val = *s - '0';
		else if ('a' <= _tolower(*s) && _tolower(*s) <= 'f')
			val = _tolower(*s) - 'a' + 10;
		else
			break;

		if (val >= base)
			break;
		if (*res > div_u64(ULLONG_MAX - val, base))
			overflow = 1;
		*res = *res * base + val;
		rv++;
		s++;
	}
	if (overflow)
		rv |= KSTRTOX_OVERFLOW;
	return rv;
}

static int _kstrtoull(const char *s, unsigned int base, unsigned long long *res)
{
	unsigned long long _res;
	unsigned int rv;

	s = _parse_integer_fixup_radix(s, &base);
	rv = _parse_integer(s, base, &_res);
	if (rv & KSTRTOX_OVERFLOW)
		return -ERANGE;
	rv &= ~KSTRTOX_OVERFLOW;
	if (rv == 0)
		return -EINVAL;
	s += rv;
	if (*s == '\n')
		s++;
	if (*s)
		return -EINVAL;
	*res = _res;
	return 0;
}

int kstrtoull(const char *s, unsigned int base, unsigned long long *res)
{
	if (s[0] == '+')
		s++;
	return _kstrtoull(s, base, res);
}
EXPORT_SYMBOL(kstrtoull);

int kstrtoll(const char *s, unsigned int base, long long *res)
{
	unsigned long long tmp;
	int rv;

	if (s[0] == '-') {
		rv = _kstrtoull(s + 1, base, &tmp);
		if (rv < 0)
			return rv;
		if ((long long)(-tmp) >= 0)
			return -ERANGE;
		*res = -tmp;
	} else {
		rv = kstrtoull(s, base, &tmp);
		if (rv < 0)
			return rv;
		if ((long long)tmp < 0)
			return -ERANGE;
		*res = tmp;
	}
	return 0;
}
EXPORT_SYMBOL(kstrtoll);

/* Internal, do not use. */
int _kstrtoul(const char *s, unsigned int base, unsigned long *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (unsigned long long)(unsigned long)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(_kstrtoul);

/* Internal, do not use. */
int _kstrtol(const char *s, unsigned int base, long *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (long long)(long)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(_kstrtol);

int kstrtouint(const char *s, unsigned int base, unsigned int *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (unsigned long long)(unsigned int)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtouint);

int kstrtoint(const char *s, unsigned int base, int *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (long long)(int)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtoint);

int kstrtou16(const char *s, unsigned int base, u16 *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (unsigned long long)(u16)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtou16);

int kstrtos16(const char *s, unsigned int base, s16 *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (long long)(s16)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtos16);

int kstrtou8(const char *s, unsigned int base, u8 *res)
{
	unsigned long long tmp;
	int rv;

	rv = kstrtoull(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (unsigned long long)(u8)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtou8);

int kstrtos8(const char *s, unsigned int base, s8 *res)
{
	long long tmp;
	int rv;

	rv = kstrtoll(s, base, &tmp);
	if (rv < 0)
		return rv;
	if (tmp != (long long)(s8)tmp)
		return -ERANGE;
	*res = tmp;
	return 0;
}
EXPORT_SYMBOL(kstrtos8);

#define kstrto_from_user(f, g, type)					\
int f(const char __user *s, size_t count, unsigned int base, type *res)	\
{									\
	/* sign, base 2 representation, newline, terminator */		\
	char buf[1 + sizeof(type) * 8 + 1 + 1];				\
									\
	count = min(count, sizeof(buf) - 1);				\
	if (copy_from_user(buf, s, count))				\
		return -EFAULT;						\
	buf[count] = '\0';						\
	return g(buf, base, res);					\
}									\
EXPORT_SYMBOL(f)

kstrto_from_user(kstrtoull_from_user,	kstrtoull,	unsigned long long);
kstrto_from_user(kstrtoll_from_user,	kstrtoll,	long long);
kstrto_from_user(kstrtoul_from_user,	kstrtoul,	unsigned long);
kstrto_from_user(kstrtol_from_user,	kstrtol,	long);
kstrto_from_user(kstrtouint_from_user,	kstrtouint,	unsigned int);
kstrto_from_user(kstrtoint_from_user,	kstrtoint,	int);
kstrto_from_user(kstrtou16_from_user,	kstrtou16,	u16);
kstrto_from_user(kstrtos16_from_user,	kstrtos16,	s16);
kstrto_from_user(kstrtou8_from_user,	kstrtou8,	u8);
kstrto_from_user(kstrtos8_from_user,	kstrtos8,	s8);
Commit	Line	Data
33ee3b2e AD	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/module.h>
	19	#include <linux/types.h>
c196e32a	20	#include <asm/uaccess.h>
1dff46d6	21	#include "kstrtox.h"
33ee3b2e	22
1dff46d6	23	const char _parse_integer_fixup_radix(const char s, unsigned int *base)
33ee3b2e	24	{
1dff46d6	25	if (*base == 0) {
33ee3b2e AD	26	if (s[0] == '0') {
33ee3b2e AD	27	if (_tolower(s[1]) == 'x' && isxdigit(s[2]))
1dff46d6	28	*base = 16;
33ee3b2e	29	else
1dff46d6	30	*base = 8;
33ee3b2e	31	} else
1dff46d6	32	*base = 10;
33ee3b2e	33	}
1dff46d6	34	if (*base == 16 && s[0] == '0' && _tolower(s[1]) == 'x')
33ee3b2e	35	s += 2;
1dff46d6 AD	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 res)
	48	{
	49	unsigned int rv;
	50	int overflow;
33ee3b2e	51
1dff46d6 AD	52	*res = 0;
	53	rv = 0;
	54	overflow = 0;
33ee3b2e AD	55	while (*s) {
	56	unsigned int val;
	57
	58	if ('0' <= s && s <= '9')
	59	val = *s - '0';
	60	else if ('a' <= _tolower(s) && _tolower(s) <= 'f')
	61	val = _tolower(*s) - 'a' + 10;
78be959e	62	else
1dff46d6	63	break;
33ee3b2e AD	64
33ee3b2e AD	65	if (val >= base)
1dff46d6 AD	66	break;
	67	if (*res > div_u64(ULLONG_MAX - val, base))
	68	overflow = 1;
	69	res = res * base + val;
	70	rv++;
33ee3b2e AD	71	s++;
33ee3b2e AD	72	}
1dff46d6 AD	73	if (overflow)
	74	rv \|= KSTRTOX_OVERFLOW;
	75	return rv;
	76	}
	77
	78	static int _kstrtoull(const char s, unsigned int base, unsigned long long res)
	79	{
	80	unsigned long long _res;
	81	unsigned int rv;
	82
	83	s = _parse_integer_fixup_radix(s, &base);
	84	rv = _parse_integer(s, base, &_res);
	85	if (rv & KSTRTOX_OVERFLOW)
	86	return -ERANGE;
	87	rv &= ~KSTRTOX_OVERFLOW;
	88	if (rv == 0)
	89	return -EINVAL;
	90	s += rv;
	91	if (*s == '\n')
	92	s++;
	93	if (*s)
33ee3b2e	94	return -EINVAL;
1dff46d6	95	*res = _res;
33ee3b2e AD	96	return 0;
	97	}
	98
	99	int kstrtoull(const char s, unsigned int base, unsigned long long res)
	100	{
	101	if (s[0] == '+')
	102	s++;
	103	return _kstrtoull(s, base, res);
	104	}
	105	EXPORT_SYMBOL(kstrtoull);
	106
	107	int kstrtoll(const char s, unsigned int base, long long res)
	108	{
	109	unsigned long long tmp;
	110	int rv;
	111
	112	if (s[0] == '-') {
	113	rv = _kstrtoull(s + 1, base, &tmp);
	114	if (rv < 0)
	115	return rv;
	116	if ((long long)(-tmp) >= 0)
	117	return -ERANGE;
	118	*res = -tmp;
	119	} else {
	120	rv = kstrtoull(s, base, &tmp);
	121	if (rv < 0)
	122	return rv;
	123	if ((long long)tmp < 0)
	124	return -ERANGE;
	125	*res = tmp;
	126	}
	127	return 0;
	128	}
	129	EXPORT_SYMBOL(kstrtoll);
	130
	131	/* Internal, do not use. */
	132	int _kstrtoul(const char s, unsigned int base, unsigned long res)
	133	{
	134	unsigned long long tmp;
	135	int rv;
	136
	137	rv = kstrtoull(s, base, &tmp);
	138	if (rv < 0)
	139	return rv;
	140	if (tmp != (unsigned long long)(unsigned long)tmp)
	141	return -ERANGE;
	142	*res = tmp;
	143	return 0;
	144	}
	145	EXPORT_SYMBOL(_kstrtoul);
	146
	147	/* Internal, do not use. */
	148	int _kstrtol(const char s, unsigned int base, long res)
	149	{
	150	long long tmp;
	151	int rv;
	152
	153	rv = kstrtoll(s, base, &tmp);
	154	if (rv < 0)
	155	return rv;
	156	if (tmp != (long long)(long)tmp)
	157	return -ERANGE;
	158	*res = tmp;
	159	return 0;
160	}
161	EXPORT_SYMBOL(_kstrtol);
162
163	int kstrtouint(const char s, unsigned int base, unsigned int res)
164	{
165	unsigned long long tmp;
166	int rv;
167
168	rv = kstrtoull(s, base, &tmp);
169	if (rv < 0)
170	return rv;
171	if (tmp != (unsigned long long)(unsigned int)tmp)
172	return -ERANGE;
173	*res = tmp;
174	return 0;
175	}
176	EXPORT_SYMBOL(kstrtouint);
177
178	int kstrtoint(const char s, unsigned int base, int res)
179	{
180	long long tmp;
181	int rv;
182
183	rv = kstrtoll(s, base, &tmp);
184	if (rv < 0)
185	return rv;
186	if (tmp != (long long)(int)tmp)
187	return -ERANGE;
188	*res = tmp;
189	return 0;
190	}
191	EXPORT_SYMBOL(kstrtoint);
192
193	int kstrtou16(const char s, unsigned int base, u16 res)
194	{
195	unsigned long long tmp;
196	int rv;
197
198	rv = kstrtoull(s, base, &tmp);
199	if (rv < 0)
200	return rv;
201	if (tmp != (unsigned long long)(u16)tmp)
202	return -ERANGE;
203	*res = tmp;
204	return 0;
205	}
206	EXPORT_SYMBOL(kstrtou16);
207
208	int kstrtos16(const char s, unsigned int base, s16 res)
209	{
210	long long tmp;
211	int rv;
212
213	rv = kstrtoll(s, base, &tmp);
214	if (rv < 0)
215	return rv;
216	if (tmp != (long long)(s16)tmp)
217	return -ERANGE;
218	*res = tmp;
219	return 0;
220	}
221	EXPORT_SYMBOL(kstrtos16);
222
223	int kstrtou8(const char s, unsigned int base, u8 res)
224	{
225	unsigned long long tmp;
226	int rv;
227
228	rv = kstrtoull(s, base, &tmp);
229	if (rv < 0)
230	return rv;
231	if (tmp != (unsigned long long)(u8)tmp)
232	return -ERANGE;
233	*res = tmp;
234	return 0;
235	}
236	EXPORT_SYMBOL(kstrtou8);
237
238	int kstrtos8(const char s, unsigned int base, s8 res)
239	{
240	long long tmp;
241	int rv;
242
243	rv = kstrtoll(s, base, &tmp);
244	if (rv < 0)
245	return rv;
246	if (tmp != (long long)(s8)tmp)
247	return -ERANGE;
248	*res = tmp;
249	return 0;
250	}
251	EXPORT_SYMBOL(kstrtos8);
c196e32a AD	252
	253	#define kstrto_from_user(f, g, type) \
	254	int f(const char __user s, size_t count, unsigned int base, type res) \
	255	{ \
	256	/* sign, base 2 representation, newline, terminator */ \
	257	char buf[1 + sizeof(type) * 8 + 1 + 1]; \
	258	\
	259	count = min(count, sizeof(buf) - 1); \
	260	if (copy_from_user(buf, s, count)) \
	261	return -EFAULT; \
	262	buf[count] = '\0'; \
	263	return g(buf, base, res); \
	264	} \
	265	EXPORT_SYMBOL(f)
	266
	267	kstrto_from_user(kstrtoull_from_user, kstrtoull, unsigned long long);
	268	kstrto_from_user(kstrtoll_from_user, kstrtoll, long long);
	269	kstrto_from_user(kstrtoul_from_user, kstrtoul, unsigned long);
	270	kstrto_from_user(kstrtol_from_user, kstrtol, long);
	271	kstrto_from_user(kstrtouint_from_user, kstrtouint, unsigned int);
	272	kstrto_from_user(kstrtoint_from_user, kstrtoint, int);
	273	kstrto_from_user(kstrtou16_from_user, kstrtou16, u16);
	274	kstrto_from_user(kstrtos16_from_user, kstrtos16, s16);
	275	kstrto_from_user(kstrtou8_from_user, kstrtou8, u8);
	276	kstrto_from_user(kstrtos8_from_user, kstrtos8, s8);