[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>

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

	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;

	acc = 0;
	ok = 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 if (*s == '\n' && *(s + 1) == '\0')
			break;
		else
			return -EINVAL;

		if (val >= base)
			return -EINVAL;
		if (acc > div_u64(ULLONG_MAX - val, base))
			return -ERANGE;
		acc = acc * base + val;
		ok = 1;

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