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