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 #include "libuutil_common.h"
28
29 #include <limits.h>
30 #include <ctype.h>
31
32 #define MAX_BASE 36
33
34 #define IS_DIGIT(x) ((x) >= '0' && (x) <= '9')
35
36 #define CTOI(x) (((x) >= '0' && (x) <= '9') ? (x) - '0' : \
37 ((x) >= 'a' && (x) <= 'z') ? (x) + 10 - 'a' : (x) + 10 - 'A')
38
39 static int
strtoint(const char * s_arg,uint64_t * out,uint32_t base,int sign)40 strtoint(const char *s_arg, uint64_t *out, uint32_t base, int sign)
41 {
42 const unsigned char *s = (const unsigned char *)s_arg;
43
44 uint64_t val = 0;
45 uint64_t multmax;
46
47 unsigned c, i;
48
49 int neg = 0;
50
51 int bad_digit = 0;
52 int bad_char = 0;
53 int overflow = 0;
54
55 if (s == NULL || base == 1 || base > MAX_BASE) {
56 uu_set_error(UU_ERROR_INVALID_ARGUMENT);
57 return (-1);
58 }
59
60 while ((c = *s) != 0 && isspace(c))
61 s++;
62
63 switch (c) {
64 case '-':
65 if (!sign)
66 overflow = 1; /* becomes underflow below */
67 neg = 1;
68 /*FALLTHRU*/
69 case '+':
70 c = *++s;
71 break;
72 default:
73 break;
74 }
75
76 if (c == '\0') {
77 uu_set_error(UU_ERROR_EMPTY);
78 return (-1);
79 }
80
81 if (base == 0) {
82 if (c != '0')
83 base = 10;
84 else if (s[1] == 'x' || s[1] == 'X')
85 base = 16;
86 else
87 base = 8;
88 }
89
90 if (base == 16 && c == '0' && (s[1] == 'x' || s[1] == 'X'))
91 c = *(s += 2);
92
93 if ((val = CTOI(c)) >= base) {
94 if (IS_DIGIT(c))
95 bad_digit = 1;
96 else
97 bad_char = 1;
98 val = 0;
99 }
100
101 multmax = (uint64_t)UINT64_MAX / (uint64_t)base;
102
103 for (c = *++s; c != '\0'; c = *++s) {
104 if ((i = CTOI(c)) >= base) {
105 if (isspace(c))
106 break;
107 if (IS_DIGIT(c))
108 bad_digit = 1;
109 else
110 bad_char = 1;
111 i = 0;
112 }
113
114 if (val > multmax)
115 overflow = 1;
116
117 val *= base;
118 if ((uint64_t)UINT64_MAX - val < (uint64_t)i)
119 overflow = 1;
120
121 val += i;
122 }
123
124 while ((c = *s) != 0) {
125 if (!isspace(c))
126 bad_char = 1;
127 s++;
128 }
129
130 if (sign) {
131 if (neg) {
132 if (val > -(uint64_t)INT64_MIN)
133 overflow = 1;
134 } else {
135 if (val > INT64_MAX)
136 overflow = 1;
137 }
138 }
139
140 if (neg)
141 val = -val;
142
143 if (bad_char | bad_digit | overflow) {
144 if (bad_char)
145 uu_set_error(UU_ERROR_INVALID_CHAR);
146 else if (bad_digit)
147 uu_set_error(UU_ERROR_INVALID_DIGIT);
148 else if (overflow) {
149 if (neg)
150 uu_set_error(UU_ERROR_UNDERFLOW);
151 else
152 uu_set_error(UU_ERROR_OVERFLOW);
153 }
154 return (-1);
155 }
156
157 *out = val;
158 return (0);
159 }
160
161 int
uu_strtoint(const char * s,void * v,size_t sz,int base,int64_t min,int64_t max)162 uu_strtoint(const char *s, void *v, size_t sz, int base,
163 int64_t min, int64_t max)
164 {
165 uint64_t val_u;
166 int64_t val;
167
168 if (min > max)
169 goto bad_argument;
170
171 switch (sz) {
172 case 1:
173 if (max > INT8_MAX || min < INT8_MIN)
174 goto bad_argument;
175 break;
176 case 2:
177 if (max > INT16_MAX || min < INT16_MIN)
178 goto bad_argument;
179 break;
180 case 4:
181 if (max > INT32_MAX || min < INT32_MIN)
182 goto bad_argument;
183 break;
184 case 8:
185 if (max > INT64_MAX || min < INT64_MIN)
186 goto bad_argument;
187 break;
188 default:
189 goto bad_argument;
190 }
191
192 if (min == 0 && max == 0) {
193 min = -(1ULL << (8 * sz - 1));
194 max = (1ULL << (8 * sz - 1)) - 1;
195 }
196
197 if (strtoint(s, &val_u, base, 1) == -1)
198 return (-1);
199
200 val = (int64_t)val_u;
201
202 if (val < min) {
203 uu_set_error(UU_ERROR_UNDERFLOW);
204 return (-1);
205 } else if (val > max) {
206 uu_set_error(UU_ERROR_OVERFLOW);
207 return (-1);
208 }
209
210 switch (sz) {
211 case 1:
212 *(int8_t *)v = val;
213 return (0);
214 case 2:
215 *(int16_t *)v = val;
216 return (0);
217 case 4:
218 *(int32_t *)v = val;
219 return (0);
220 case 8:
221 *(int64_t *)v = val;
222 return (0);
223 default:
224 break; /* fall through to bad_argument */
225 }
226
227 bad_argument:
228 uu_set_error(UU_ERROR_INVALID_ARGUMENT);
229 return (-1);
230 }
231
232 int
uu_strtouint(const char * s,void * v,size_t sz,int base,uint64_t min,uint64_t max)233 uu_strtouint(const char *s, void *v, size_t sz, int base,
234 uint64_t min, uint64_t max)
235 {
236 uint64_t val;
237
238 if (min > max)
239 goto bad_argument;
240
241 switch (sz) {
242 case 1:
243 if (max > UINT8_MAX)
244 goto bad_argument;
245 break;
246 case 2:
247 if (max > UINT16_MAX)
248 goto bad_argument;
249 break;
250 case 4:
251 if (max > UINT32_MAX)
252 goto bad_argument;
253 break;
254 case 8:
255 if (max > UINT64_MAX)
256 goto bad_argument;
257 break;
258 default:
259 goto bad_argument;
260 }
261
262 if (min == 0 && max == 0) {
263 /* we have to be careful, since << can overflow */
264 max = (1ULL << (8 * sz - 1)) * 2 - 1;
265 }
266
267 if (strtoint(s, &val, base, 0) == -1)
268 return (-1);
269
270 if (val < min) {
271 uu_set_error(UU_ERROR_UNDERFLOW);
272 return (-1);
273 } else if (val > max) {
274 uu_set_error(UU_ERROR_OVERFLOW);
275 return (-1);
276 }
277
278 switch (sz) {
279 case 1:
280 *(uint8_t *)v = val;
281 return (0);
282 case 2:
283 *(uint16_t *)v = val;
284 return (0);
285 case 4:
286 *(uint32_t *)v = val;
287 return (0);
288 case 8:
289 *(uint64_t *)v = val;
290 return (0);
291 default:
292 break; /* shouldn't happen, fall through */
293 }
294
295 bad_argument:
296 uu_set_error(UU_ERROR_INVALID_ARGUMENT);
297 return (-1);
298 }
299