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
105static 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
110int
111vsscanf(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		 */
157again:		c = *fmt++;
158		switch (c) {
159		case '%':
160literal:
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	}
525input_failure:
526	return (nconversions != 0 ? nassigned : -1);
527match_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 */
537static const uchar_t *
538set_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 */
567doswitch:
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
623int
624sscanf(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