1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 /*
23  * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #pragma ident	"%Z%%M%	%I%	%E% SMI"
28 
29 #include "libuutil_common.h"
30 
31 #include <limits.h>
32 #include <ctype.h>
33 
34 #define	MAX_BASE	36
35 
36 #define	IS_DIGIT(x)	((x) >= '0' && (x) <= '9')
37 
38 #define	CTOI(x) (((x) >= '0' && (x) <= '9') ? (x) - '0' : \
39 	    ((x) >= 'a' && (x) <= 'z') ? (x) + 10 - 'a' : (x) + 10 - 'A')
40 
41 static int
strtoint(const char * s_arg,uint64_t * out,uint32_t base,int sign)42 strtoint(const char *s_arg, uint64_t *out, uint32_t base, int sign)
43 {
44 	const unsigned char *s = (const unsigned char *)s_arg;
45 
46 	uint64_t val = 0;
47 	uint64_t multmax;
48 
49 	unsigned c, i;
50 
51 	int neg = 0;
52 
53 	int bad_digit = 0;
54 	int bad_char = 0;
55 	int overflow = 0;
56 
57 	if (s == NULL || base == 1 || base > MAX_BASE) {
58 		uu_set_error(UU_ERROR_INVALID_ARGUMENT);
59 		return (-1);
60 	}
61 
62 	while ((c = *s) != 0 && isspace(c))
63 		s++;
64 
65 	switch (c) {
66 	case '-':
67 		if (!sign)
68 			overflow = 1;		/* becomes underflow below */
69 		neg = 1;
70 		/*FALLTHRU*/
71 	case '+':
72 		c = *++s;
73 		break;
74 	default:
75 		break;
76 	}
77 
78 	if (c == '\0') {
79 		uu_set_error(UU_ERROR_EMPTY);
80 		return (-1);
81 	}
82 
83 	if (base == 0) {
84 		if (c != '0')
85 			base = 10;
86 		else if (s[1] == 'x' || s[1] == 'X')
87 			base = 16;
88 		else
89 			base = 8;
90 	}
91 
92 	if (base == 16 && c == '0' && (s[1] == 'x' || s[1] == 'X'))
93 		c = *(s += 2);
94 
95 	if ((val = CTOI(c)) >= base) {
96 		if (IS_DIGIT(c))
97 			bad_digit = 1;
98 		else
99 			bad_char = 1;
100 		val = 0;
101 	}
102 
103 	multmax = (uint64_t)UINT64_MAX / (uint64_t)base;
104 
105 	for (c = *++s; c != '\0'; c = *++s) {
106 		if ((i = CTOI(c)) >= base) {
107 			if (isspace(c))
108 				break;
109 			if (IS_DIGIT(c))
110 				bad_digit = 1;
111 			else
112 				bad_char = 1;
113 			i = 0;
114 		}
115 
116 		if (val > multmax)
117 			overflow = 1;
118 
119 		val *= base;
120 		if ((uint64_t)UINT64_MAX - val < (uint64_t)i)
121 			overflow = 1;
122 
123 		val += i;
124 	}
125 
126 	while ((c = *s) != 0) {
127 		if (!isspace(c))
128 			bad_char = 1;
129 		s++;
130 	}
131 
132 	if (sign) {
133 		if (neg) {
134 			if (val > -(uint64_t)INT64_MIN)
135 				overflow = 1;
136 		} else {
137 			if (val > INT64_MAX)
138 				overflow = 1;
139 		}
140 	}
141 
142 	if (neg)
143 		val = -val;
144 
145 	if (bad_char | bad_digit | overflow) {
146 		if (bad_char)
147 			uu_set_error(UU_ERROR_INVALID_CHAR);
148 		else if (bad_digit)
149 			uu_set_error(UU_ERROR_INVALID_DIGIT);
150 		else if (overflow) {
151 			if (neg)
152 				uu_set_error(UU_ERROR_UNDERFLOW);
153 			else
154 				uu_set_error(UU_ERROR_OVERFLOW);
155 		}
156 		return (-1);
157 	}
158 
159 	*out = val;
160 	return (0);
161 }
162 
163 int
uu_strtoint(const char * s,void * v,size_t sz,int base,int64_t min,int64_t max)164 uu_strtoint(const char *s, void *v, size_t sz, int base,
165     int64_t min, int64_t max)
166 {
167 	uint64_t val_u;
168 	int64_t val;
169 
170 	if (min > max)
171 		goto bad_argument;
172 
173 	switch (sz) {
174 	case 1:
175 		if (max > INT8_MAX || min < INT8_MIN)
176 			goto bad_argument;
177 		break;
178 	case 2:
179 		if (max > INT16_MAX || min < INT16_MIN)
180 			goto bad_argument;
181 		break;
182 	case 4:
183 		if (max > INT32_MAX || min < INT32_MIN)
184 			goto bad_argument;
185 		break;
186 	case 8:
187 		if (max > INT64_MAX || min < INT64_MIN)
188 			goto bad_argument;
189 		break;
190 	default:
191 		goto bad_argument;
192 	}
193 
194 	if (min == 0 && max == 0) {
195 		min = -(1ULL << (8 * sz - 1));
196 		max = (1ULL << (8 * sz - 1)) - 1;
197 	}
198 
199 	if (strtoint(s, &val_u, base, 1) == -1)
200 		return (-1);
201 
202 	val = (int64_t)val_u;
203 
204 	if (val < min) {
205 		uu_set_error(UU_ERROR_UNDERFLOW);
206 		return (-1);
207 	} else if (val > max) {
208 		uu_set_error(UU_ERROR_OVERFLOW);
209 		return (-1);
210 	}
211 
212 	switch (sz) {
213 	case 1:
214 		*(int8_t *)v = val;
215 		return (0);
216 	case 2:
217 		*(int16_t *)v = val;
218 		return (0);
219 	case 4:
220 		*(int32_t *)v = val;
221 		return (0);
222 	case 8:
223 		*(int64_t *)v = val;
224 		return (0);
225 	default:
226 		break;		/* fall through to bad_argument */
227 	}
228 
229 bad_argument:
230 	uu_set_error(UU_ERROR_INVALID_ARGUMENT);
231 	return (-1);
232 }
233 
234 int
uu_strtouint(const char * s,void * v,size_t sz,int base,uint64_t min,uint64_t max)235 uu_strtouint(const char *s, void *v, size_t sz, int base,
236     uint64_t min, uint64_t max)
237 {
238 	uint64_t val;
239 
240 	if (min > max)
241 		goto bad_argument;
242 
243 	switch (sz) {
244 	case 1:
245 		if (max > UINT8_MAX)
246 			goto bad_argument;
247 		break;
248 	case 2:
249 		if (max > UINT16_MAX)
250 			goto bad_argument;
251 		break;
252 	case 4:
253 		if (max > UINT32_MAX)
254 			goto bad_argument;
255 		break;
256 	case 8:
257 		if (max > UINT64_MAX)
258 			goto bad_argument;
259 		break;
260 	default:
261 		goto bad_argument;
262 	}
263 
264 	if (min == 0 && max == 0) {
265 		/* we have to be careful, since << can overflow */
266 		max = (1ULL << (8 * sz - 1)) * 2 - 1;
267 	}
268 
269 	if (strtoint(s, &val, base, 0) == -1)
270 		return (-1);
271 
272 	if (val < min) {
273 		uu_set_error(UU_ERROR_UNDERFLOW);
274 		return (-1);
275 	} else if (val > max) {
276 		uu_set_error(UU_ERROR_OVERFLOW);
277 		return (-1);
278 	}
279 
280 	switch (sz) {
281 	case 1:
282 		*(uint8_t *)v = val;
283 		return (0);
284 	case 2:
285 		*(uint16_t *)v = val;
286 		return (0);
287 	case 4:
288 		*(uint32_t *)v = val;
289 		return (0);
290 	case 8:
291 		*(uint64_t *)v = val;
292 		return (0);
293 	default:
294 		break;		/* shouldn't happen, fall through */
295 	}
296 
297 bad_argument:
298 	uu_set_error(UU_ERROR_INVALID_ARGUMENT);
299 	return (-1);
300 }
301