xref: /illumos-gate/usr/src/common/util/sscanf.c (revision ae115bc7)
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 (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright (c) 1990, 1993
24  *	The Regents of the University of California.  All rights reserved.
25  *
26  * This code is derived from software contributed to Berkeley by
27  * Chris Torek.
28  *
29  * Redistribution and use in source and binary forms, with or without
30  * modification, are permitted provided that the following conditions
31  * are met:
32  * 1. Redistributions of source code must retain the above copyright
33  *    notice, this list of conditions and the following disclaimer.
34  * 2. Redistributions in binary form must reproduce the above copyright
35  *    notice, this list of conditions and the following disclaimer in the
36  *    documentation and/or other materials provided with the distribution.
37  * 4. Neither the name of the University nor the names of its contributors
38  *    may be used to endorse or promote products derived from this software
39  *    without specific prior written permission.
40  *
41  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  *
53  * From: Id: vfscanf.c,v 1.13 1998/09/25 12:20:27 obrien Exp
54  * From: static char sccsid[] = "@(#)strtol.c	8.1 (Berkeley) 6/4/93";
55  * From: static char sccsid[] = "@(#)strtoul.c	8.1 (Berkeley) 6/4/93";
56  */
57 
58 
59 /*
60  * Copyright 2007 Sun Microsystems, Inc.  All rights reserved.
61  * Use is subject to license terms.
62  */
63 
64 #pragma ident	"%Z%%M%	%I%	%E% SMI"
65 
66 #include <sys/types.h>
67 #include <sys/systm.h>
68 #include <sys/ctype.h>
69 #include <sys/sunddi.h>
70 #include <util/sscanf.h>
71 
72 #define	BUF		32 	/* Maximum length of numeric string. */
73 
74 /*
75  * Flags used during conversion.
76  */
77 #define	LONG		0x01	/* l: long or double */
78 #define	SHORT		0x04	/* h: short */
79 #define	SUPPRESS	0x08	/* suppress assignment */
80 #define	POINTER		0x10	/* weird %p pointer (`fake hex') */
81 #define	NOSKIP		0x20	/* do not skip blanks */
82 
83 /*
84  * The following are used in numeric conversions only:
85  * SIGNOK, NDIGITS, DPTOK, and EXPOK are for floating point;
86  * SIGNOK, NDIGITS, PFXOK, and NZDIGITS are for integral.
87  */
88 #define	SIGNOK		0x40	/* +/- is (still) legal */
89 #define	NDIGITS		0x80	/* no digits detected */
90 
91 #define	DPTOK		0x100	/* (float) decimal point is still legal */
92 #define	EXPOK		0x200	/* (float) exponent (e+3, etc) still legal */
93 
94 #define	PFXOK		0x100	/* 0x prefix is (still) legal */
95 #define	NZDIGITS	0x200	/* no zero digits detected */
96 
97 /*
98  * Conversion types.
99  */
100 #define	CT_CHAR		0	/* %c conversion */
101 #define	CT_CCL		1	/* %[...] conversion */
102 #define	CT_STRING	2	/* %s conversion */
103 #define	CT_INT		3	/* integer, i.e., strtoq or strtouq */
104 
105 static const uchar_t *set_ccl(char *, const uchar_t *);
106 
107 #define	isspace(ch)	(((ch) == ' ') || ((ch) == '\r') || ((ch) == '\n') || \
108 			((ch) == '\t') || ((ch) == '\f'))
109 
110 int
vsscanf(const char * inp,char const * fmt0,va_list ap)111 vsscanf(const char *inp, char const *fmt0, va_list ap)
112 {
113 	int inr;
114 	const uchar_t *fmt = (const uchar_t *)fmt0;
115 	int c;			/* character from format, or conversion */
116 	size_t width;		/* field width, or 0 */
117 	char *p;		/* points into all kinds of strings */
118 	int n;			/* handy integer */
119 	int flags;		/* flags as defined above */
120 	char *p0;		/* saves original value of p when necessary */
121 	int nassigned;		/* number of fields assigned */
122 	int nconversions;	/* number of conversions */
123 	int nread;		/* number of characters consumed from fp */
124 	int base;		/* base argument to strtoq/strtouq */
125 	int sconv;		/* do signed conversion */
126 	char ccltab[256];	/* character class table for %[...] */
127 	char buf[BUF];		/* buffer for numeric conversions */
128 
129 	/* `basefix' is used to avoid `if' tests in the integer scanner */
130 	static short basefix[17] =
131 		{ 10, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16 };
132 
133 	inr = strlen(inp);
134 
135 	sconv = 0;
136 	nassigned = 0;
137 	nconversions = 0;
138 	nread = 0;
139 	base = 0;
140 	for (;;) {
141 		c = *fmt++;
142 		if (c == 0)
143 			return (nassigned);
144 		if (isspace(c)) {
145 			while (inr > 0 && isspace(*inp))
146 				nread++, inr--, inp++;
147 			continue;
148 		}
149 		if (c != '%')
150 			goto literal;
151 		width = 0;
152 		flags = 0;
153 		/*
154 		 * switch on the format.  continue if done;
155 		 * break once format type is derived.
156 		 */
157 again:		c = *fmt++;
158 		switch (c) {
159 		case '%':
160 literal:
161 			if (inr <= 0)
162 				goto input_failure;
163 			if (*inp != c)
164 				goto match_failure;
165 			inr--, inp++;
166 			nread++;
167 			continue;
168 
169 		case '*':
170 			flags |= SUPPRESS;
171 			goto again;
172 		case 'l':
173 			flags |= LONG;
174 			goto again;
175 		case 'h':
176 			flags |= SHORT;
177 			goto again;
178 
179 		case '0': case '1': case '2': case '3': case '4':
180 		case '5': case '6': case '7': case '8': case '9':
181 			width = width * 10 + c - '0';
182 			goto again;
183 
184 		/*
185 		 * Conversions.
186 		 *
187 		 */
188 		case 'd':
189 			c = CT_INT;
190 			sconv = 1;
191 			base = 10;
192 			break;
193 
194 		case 'i':
195 			c = CT_INT;
196 			sconv = 1;
197 			base = 0;
198 			break;
199 
200 		case 'o':
201 			c = CT_INT;
202 			base = 8;
203 			break;
204 
205 		case 'u':
206 			c = CT_INT;
207 			base = 10;
208 			break;
209 
210 		case 'x':
211 			flags |= PFXOK;	/* enable 0x prefixing */
212 			c = CT_INT;
213 			base = 16;
214 			break;
215 
216 		case 's':
217 			c = CT_STRING;
218 			break;
219 
220 		case '[':
221 			fmt = set_ccl(ccltab, fmt);
222 			flags |= NOSKIP;
223 			c = CT_CCL;
224 			break;
225 
226 		case 'c':
227 			flags |= NOSKIP;
228 			c = CT_CHAR;
229 			break;
230 
231 		case 'p':	/* pointer format is like hex */
232 			flags |= POINTER | PFXOK;
233 			c = CT_INT;
234 			base = 16;
235 			break;
236 
237 		case 'n':
238 			nconversions++;
239 			if (flags & SUPPRESS)	/* ??? */
240 				continue;
241 			if (flags & SHORT)
242 				*va_arg(ap, short *) = (short)nread;
243 			else if (flags & LONG)
244 				*va_arg(ap, long *) = (long)nread;
245 			else
246 				*va_arg(ap, int *) = nread;
247 			continue;
248 		}
249 
250 		/*
251 		 * We have a conversion that requires input.
252 		 */
253 		if (inr <= 0)
254 			goto input_failure;
255 
256 		/*
257 		 * Consume leading white space, except for formats
258 		 * that suppress this.
259 		 */
260 		if ((flags & NOSKIP) == 0) {
261 			while (isspace(*inp)) {
262 				nread++;
263 				if (--inr > 0)
264 					inp++;
265 				else
266 					goto input_failure;
267 			}
268 			/*
269 			 * Note that there is at least one character in
270 			 * the buffer, so conversions that do not set NOSKIP
271 			 * can no longer result in an input failure.
272 			 */
273 		}
274 
275 		/*
276 		 * Do the conversion.
277 		 */
278 		switch (c) {
279 
280 		case CT_CHAR:
281 			/* scan arbitrary characters (sets NOSKIP) */
282 			if (width == 0)
283 				width = 1;
284 			if (flags & SUPPRESS) {
285 				size_t sum = 0;
286 
287 				if ((n = inr) < width) {
288 					sum += n;
289 					width -= n;
290 					inp += n;
291 					if (sum == 0)
292 						goto input_failure;
293 				} else {
294 					sum += width;
295 					inr -= width;
296 					inp += width;
297 				}
298 				nread += sum;
299 			} else {
300 				bcopy(inp, va_arg(ap, char *), width);
301 				inr -= width;
302 				inp += width;
303 				nread += width;
304 				nassigned++;
305 			}
306 			nconversions++;
307 			break;
308 
309 		case CT_CCL:
310 			/* scan a (nonempty) character class (sets NOSKIP) */
311 			if (width == 0)
312 				width = (size_t)~0;	/* `infinity' */
313 			/* take only those things in the class */
314 			if (flags & SUPPRESS) {
315 				n = 0;
316 				while (ccltab[(unsigned char)*inp]) {
317 					n++, inr--, inp++;
318 					if (--width == 0)
319 						break;
320 					if (inr <= 0) {
321 						if (n == 0)
322 							goto input_failure;
323 						break;
324 					}
325 				}
326 				if (n == 0)
327 					goto match_failure;
328 			} else {
329 				p0 = p = va_arg(ap, char *);
330 				while (ccltab[(unsigned char)*inp]) {
331 					inr--;
332 					*p++ = *inp++;
333 					if (--width == 0)
334 						break;
335 					if (inr <= 0) {
336 						if (p == p0)
337 							goto input_failure;
338 						break;
339 					}
340 				}
341 				n = p - p0;
342 				if (n == 0)
343 					goto match_failure;
344 				*p = 0;
345 				nassigned++;
346 			}
347 			nread += n;
348 			nconversions++;
349 			break;
350 
351 		case CT_STRING:
352 			/* like CCL, but zero-length string OK, & no NOSKIP */
353 			if (width == 0)
354 				width = (size_t)~0;
355 			if (flags & SUPPRESS) {
356 				n = 0;
357 				while (!isspace(*inp)) {
358 					n++, inr--, inp++;
359 					if (--width == 0)
360 						break;
361 					if (inr <= 0)
362 						break;
363 				}
364 				nread += n;
365 			} else {
366 				p0 = p = va_arg(ap, char *);
367 				while (!isspace(*inp)) {
368 					inr--;
369 					*p++ = *inp++;
370 					if (--width == 0)
371 						break;
372 					if (inr <= 0)
373 						break;
374 				}
375 				*p = 0;
376 				nread += p - p0;
377 				nassigned++;
378 			}
379 			nconversions++;
380 			continue;
381 
382 		case CT_INT:
383 			/* scan an integer as if by strtoq/strtouq */
384 			/* size_t is unsigned, hence this optimisation */
385 			if (--width > sizeof (buf) - 2)
386 				width = sizeof (buf) - 2;
387 			width++;
388 			flags |= SIGNOK | NDIGITS | NZDIGITS;
389 			for (p = buf; width; width--) {
390 				c = *inp;
391 				/*
392 				 * Switch on the character; `goto ok'
393 				 * if we accept it as a part of number.
394 				 */
395 				switch (c) {
396 
397 				/*
398 				 * The digit 0 is always legal, but is
399 				 * special.  For %i conversions, if no
400 				 * digits (zero or nonzero) have been
401 				 * scanned (only signs), we will have
402 				 * base==0.  In that case, we should set
403 				 * it to 8 and enable 0x prefixing.
404 				 * Also, if we have not scanned zero digits
405 				 * before this, do not turn off prefixing
406 				 * (someone else will turn it off if we
407 				 * have scanned any nonzero digits).
408 				 */
409 				case '0':
410 					if (base == 0) {
411 						base = 8;
412 						flags |= PFXOK;
413 					}
414 					if (flags & NZDIGITS)
415 					    flags &= ~(SIGNOK|NZDIGITS|NDIGITS);
416 					else
417 					    flags &= ~(SIGNOK|PFXOK|NDIGITS);
418 					goto ok;
419 
420 				/* 1 through 7 always legal */
421 				case '1': case '2': case '3':
422 				case '4': case '5': case '6': case '7':
423 					base = basefix[base];
424 					flags &= ~(SIGNOK | PFXOK | NDIGITS);
425 					goto ok;
426 
427 				/* digits 8 and 9 ok iff decimal or hex */
428 				case '8': case '9':
429 					base = basefix[base];
430 					if (base <= 8)
431 						break;	/* not legal here */
432 					flags &= ~(SIGNOK | PFXOK | NDIGITS);
433 					goto ok;
434 
435 				/* letters ok iff hex */
436 				case 'A': case 'B': case 'C':
437 				case 'D': case 'E': case 'F':
438 				case 'a': case 'b': case 'c':
439 				case 'd': case 'e': case 'f':
440 					/* no need to fix base here */
441 					if (base <= 10)
442 						break;	/* not legal here */
443 					flags &= ~(SIGNOK | PFXOK | NDIGITS);
444 					goto ok;
445 
446 				/* sign ok only as first character */
447 				case '+': case '-':
448 					if (flags & SIGNOK) {
449 						flags &= ~SIGNOK;
450 						goto ok;
451 					}
452 					break;
453 
454 				/* x ok iff flag still set & 2nd char */
455 				case 'x': case 'X':
456 					if (flags & PFXOK && p == buf + 1) {
457 						base = 16;	/* if %i */
458 						flags &= ~PFXOK;
459 						goto ok;
460 					}
461 					break;
462 				}
463 
464 				/*
465 				 * If we got here, c is not a legal character
466 				 * for a number.  Stop accumulating digits.
467 				 */
468 				break;
469 		ok:
470 				/*
471 				 * c is legal: store it and look at the next.
472 				 */
473 				*p++ = c;
474 				if (--inr > 0)
475 					inp++;
476 				else
477 					break;		/* end of input */
478 			}
479 			/*
480 			 * If we had only a sign, it is no good; push
481 			 * back the sign.  If the number ends in `x',
482 			 * it was [sign] '0' 'x', so push back the x
483 			 * and treat it as [sign] '0'.
484 			 */
485 			if (flags & NDIGITS) {
486 				if (p > buf) {
487 					inp--;
488 					inr++;
489 				}
490 				goto match_failure;
491 			}
492 			c = ((uchar_t *)p)[-1];
493 			if (c == 'x' || c == 'X') {
494 				--p;
495 				inp--;
496 				inr++;
497 			}
498 			if ((flags & SUPPRESS) == 0) {
499 				ulong_t res;
500 
501 				*p = 0;
502 				if (sconv)
503 					(void) ddi_strtol(buf, (char **)NULL,
504 					    base, (long *)(&res));
505 				else
506 					(void) ddi_strtoul(buf, (char **)NULL,
507 					    base, &res);
508 				if (flags & POINTER)
509 					*va_arg(ap, void **) =
510 						(void *)(uintptr_t)res;
511 				else if (flags & SHORT)
512 					*va_arg(ap, short *) = (short)res;
513 				else if (flags & LONG)
514 					*va_arg(ap, long *) = (long)res;
515 				else
516 					*va_arg(ap, int *) = (int)res;
517 				nassigned++;
518 			}
519 			nread += p - buf;
520 			nconversions++;
521 			break;
522 
523 		}
524 	}
525 input_failure:
526 	return (nconversions != 0 ? nassigned : -1);
527 match_failure:
528 	return (nassigned);
529 }
530 
531 /*
532  * Fill in the given table from the scanset at the given format
533  * (just after `[').  Return a pointer to the character past the
534  * closing `]'.  The table has a 1 wherever characters should be
535  * considered part of the scanset.
536  */
537 static const uchar_t *
set_ccl(char * tab,const uchar_t * fmt)538 set_ccl(char *tab, const uchar_t *fmt)
539 {
540 	int c, n, v;
541 
542 	/* first `clear' the whole table */
543 	c = *fmt++;		/* first char hat => negated scanset */
544 	if (c == '^') {
545 		v = 1;		/* default => accept */
546 		c = *fmt++;	/* get new first char */
547 	} else
548 		v = 0;		/* default => reject */
549 
550 	/* XXX: Will not work if sizeof(tab*) > sizeof(char) */
551 	for (n = 0; n < 256; n++)
552 		tab[n] = v;	/* memset(tab, v, 256) */
553 
554 	if (c == 0)
555 		return (fmt - 1); /* format ended before closing ] */
556 
557 	/*
558 	 * Now set the entries corresponding to the actual scanset
559 	 * to the opposite of the above.
560 	 *
561 	 * The first character may be ']' (or '-') without being special;
562 	 * the last character may be '-'.
563 	 */
564 	v = 1 - v;
565 	for (;;) {
566 		tab[c] = v;		/* take character c */
567 doswitch:
568 		n = *fmt++;		/* and examine the next */
569 		switch (n) {
570 
571 		case 0:			/* format ended too soon */
572 			return (fmt - 1);
573 
574 		case '-':
575 			/*
576 			 * A scanset of the form
577 			 *	[01+-]
578 			 * is defined as `the digit 0, the digit 1,
579 			 * the character +, the character -', but
580 			 * the effect of a scanset such as
581 			 *	[a-zA-Z0-9]
582 			 * is implementation defined.  The V7 Unix
583 			 * scanf treats `a-z' as `the letters a through
584 			 * z', but treats `a-a' as `the letter a, the
585 			 * character -, and the letter a'.
586 			 *
587 			 * For compatibility, the `-' is not considerd
588 			 * to define a range if the character following
589 			 * it is either a close bracket (required by ANSI)
590 			 * or is not numerically greater than the character
591 			 * we just stored in the table (c).
592 			 */
593 			n = *fmt;
594 			if (n == ']' || n < c) {
595 				c = '-';
596 				break;	/* resume the for(;;) */
597 			}
598 			fmt++;
599 			/* fill in the range */
600 			do {
601 			    tab[++c] = v;
602 			} while (c < n);
603 			c = n;
604 			/*
605 			 * Alas, the V7 Unix scanf also treats formats
606 			 * such as [a-c-e] as `the letters a through e'.
607 			 * This too is permitted by the standard....
608 			 */
609 			goto doswitch;
610 			/* NOTREACHED */
611 
612 		case ']':		/* end of scanset */
613 			return (fmt);
614 
615 		default:		/* just another character */
616 			c = n;
617 			break;
618 		}
619 	}
620 	/* NOTREACHED */
621 }
622 
623 int
sscanf(const char * ibuf,const char * fmt,...)624 sscanf(const char *ibuf, const char *fmt, ...)
625 {
626 	va_list ap;
627 	int ret;
628 
629 	va_start(ap, fmt);
630 	ret = vsscanf(ibuf, fmt, ap);
631 	va_end(ap);
632 	return (ret);
633 }
634