busybox/libbb/dump.c

/* vi: set sw=4 ts=4: */
/*
 * Support code for the hexdump and od applets,
 * based on code from util-linux v 2.11l
 *
 * Copyright (c) 1989
 *	The Regents of the University of California.  All rights reserved.
 *
 * Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
 *
 * Original copyright notice is retained at the end of this file.
 */

#include "libbb.h"
#include "dump.h"

enum _vflag bb_dump_vflag = FIRST;
FS *bb_dump_fshead;				/* head of format strings */
static FU *endfu;
static char **_argv;
static off_t savaddress;	/* saved address/offset in stream */
static off_t eaddress;	/* end address */
static off_t address;	/* address/offset in stream */
off_t bb_dump_skip;				/* bytes to skip */
static int exitval;			/* final exit value */
int bb_dump_blocksize;			/* data block size */
int bb_dump_length = -1;		/* max bytes to read */

static const char index_str[] = ".#-+ 0123456789";

static const char size_conv_str[] =
"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";

static const char lcc[] = "diouxX";

int bb_dump_size(FS * fs)
{
	FU *fu;
	int bcnt, cur_size;
	char *fmt;
	const char *p;
	int prec;

	/* figure out the data block bb_dump_size needed for each format unit */
	for (cur_size = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
		if (fu->bcnt) {
			cur_size += fu->bcnt * fu->reps;
			continue;
		}
		for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
			if (*fmt != '%')
				continue;
			/*
			 * bb_dump_skip any special chars -- save precision in
			 * case it's a %s format.
			 */
			while (strchr(index_str + 1, *++fmt));
			if (*fmt == '.' && isdigit(*++fmt)) {
				prec = atoi(fmt);
				while (isdigit(*++fmt));
			}
			if (!(p = strchr(size_conv_str + 12, *fmt))) {
				if (*fmt == 's') {
					bcnt += prec;
				} else if (*fmt == '_') {
					++fmt;
					if ((*fmt == 'c') || (*fmt == 'p') || (*fmt == 'u')) {
						bcnt += 1;
					}
				}
			} else {
				bcnt += size_conv_str[p - (size_conv_str + 12)];
			}
		}
		cur_size += bcnt * fu->reps;
	}
	return cur_size;
}

static void rewrite(FS * fs)
{
	enum { NOTOKAY, USEBCNT, USEPREC } sokay;
	PR *pr, **nextpr = NULL;
	FU *fu;
	char *p1, *p2, *p3;
	char savech, *fmtp;
	const char *byte_count_str;
	int nconv, prec = 0;

	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
		/*
		 * break each format unit into print units; each
		 * conversion character gets its own.
		 */
		for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
			/* NOSTRICT */
			/* DBU:[dvae@cray.com] calloc so that forward ptrs start out NULL*/
			pr = xzalloc(sizeof(PR));
			if (!fu->nextpr)
				fu->nextpr = pr;
			/* ignore nextpr -- its unused inside the loop and is
			 * uninitialized 1st time thru.
			 */

			/* bb_dump_skip preceding text and up to the next % sign */
			for (p1 = fmtp; *p1 && *p1 != '%'; ++p1);

			/* only text in the string */
			if (!*p1) {
				pr->fmt = fmtp;
				pr->flags = F_TEXT;
				break;
			}

			/*
			 * get precision for %s -- if have a byte count, don't
			 * need it.
			 */
			if (fu->bcnt) {
				sokay = USEBCNT;
				/* bb_dump_skip to conversion character */
				for (++p1; strchr(index_str, *p1); ++p1);
			} else {
				/* bb_dump_skip any special chars, field width */
				while (strchr(index_str + 1, *++p1));
				if (*p1 == '.' && isdigit(*++p1)) {
					sokay = USEPREC;
					prec = atoi(p1);
					while (isdigit(*++p1));
				} else
					sokay = NOTOKAY;
			}

			p2 = p1 + 1;	/* set end pointer */

			/*
			 * figure out the byte count for each conversion;
			 * rewrite the format as necessary, set up blank-
			 * pbb_dump_adding for end of data.
			 */

			if (*p1 == 'c') {
				pr->flags = F_CHAR;
			DO_BYTE_COUNT_1:
				byte_count_str = "\001";
			DO_BYTE_COUNT:
				if (fu->bcnt) {
					do {
						if (fu->bcnt == *byte_count_str) {
							break;
						}
					} while (*++byte_count_str);
				}
				/* Unlike the original, output the remainder of the format string. */
				if (!*byte_count_str) {
					bb_error_msg_and_die("bad byte count for conversion character %s", p1);
				}
				pr->bcnt = *byte_count_str;
			} else if (*p1 == 'l') {
				++p2;
				++p1;
			DO_INT_CONV:
				{
					const char *e;
					if (!(e = strchr(lcc, *p1))) {
						goto DO_BAD_CONV_CHAR;
					}
					pr->flags = F_INT;
					if (e > lcc + 1) {
						pr->flags = F_UINT;
					}
					byte_count_str = "\004\002\001";
					goto DO_BYTE_COUNT;
				}
				/* NOTREACHED */
			} else if (strchr(lcc, *p1)) {
				goto DO_INT_CONV;
			} else if (strchr("eEfgG", *p1)) {
				pr->flags = F_DBL;
				byte_count_str = "\010\004";
				goto DO_BYTE_COUNT;
			} else if (*p1 == 's') {
				pr->flags = F_STR;
				if (sokay == USEBCNT) {
					pr->bcnt = fu->bcnt;
				} else if (sokay == USEPREC) {
					pr->bcnt = prec;
				} else {	/* NOTOKAY */
					bb_error_msg_and_die("%%s requires a precision or a byte count");
				}
			} else if (*p1 == '_') {
				++p2;
				switch (p1[1]) {
				case 'A':
					endfu = fu;
					fu->flags |= F_IGNORE;
					/* FALLTHROUGH */
				case 'a':
					pr->flags = F_ADDRESS;
					++p2;
					if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
						goto DO_BAD_CONV_CHAR;
					}
					*p1 = p1[2];
					break;
				case 'c':
					pr->flags = F_C;
					/* *p1 = 'c';   set in conv_c */
					goto DO_BYTE_COUNT_1;
				case 'p':
					pr->flags = F_P;
					*p1 = 'c';
					goto DO_BYTE_COUNT_1;
				case 'u':
					pr->flags = F_U;
					/* *p1 = 'c';   set in conv_u */
					goto DO_BYTE_COUNT_1;
				default:
					goto DO_BAD_CONV_CHAR;
				}
			} else {
			DO_BAD_CONV_CHAR:
				bb_error_msg_and_die("bad conversion character %%%s", p1);
			}

			/*
			 * copy to PR format string, set conversion character
			 * pointer, update original.
			 */
			savech = *p2;
			p1[1] = '\0';
			pr->fmt = xstrdup(fmtp);
			*p2 = savech;
			pr->cchar = pr->fmt + (p1 - fmtp);

			/* DBU:[dave@cray.com] w/o this, trailing fmt text, space is lost.
			 * Skip subsequent text and up to the next % sign and tack the
			 * additional text onto fmt: eg. if fmt is "%x is a HEX number",
			 * we lose the " is a HEX number" part of fmt.
			 */
			for (p3 = p2; *p3 && *p3 != '%'; p3++);
			if (p3 > p2)
			{
				savech = *p3;
				*p3 = '\0';
				pr->fmt = xrealloc(pr->fmt, strlen(pr->fmt)+(p3-p2)+1);
				strcat(pr->fmt, p2);
				*p3 = savech;
				p2 = p3;
			}

			fmtp = p2;

			/* only one conversion character if byte count */
			if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
				bb_error_msg_and_die("byte count with multiple conversion characters");
			}
		}
		/*
		 * if format unit byte count not specified, figure it out
		 * so can adjust rep count later.
		 */
		if (!fu->bcnt)
			for (pr = fu->nextpr; pr; pr = pr->nextpr)
				fu->bcnt += pr->bcnt;
	}
	/*
	 * if the format string interprets any data at all, and it's
	 * not the same as the bb_dump_blocksize, and its last format unit
	 * interprets any data at all, and has no iteration count,
	 * repeat it as necessary.
	 *
	 * if, rep count is greater than 1, no trailing whitespace
	 * gets output from the last iteration of the format unit.
	 */
	for (fu = fs->nextfu;; fu = fu->nextfu) {
		if (!fu->nextfu && fs->bcnt < bb_dump_blocksize &&
			!(fu->flags & F_SETREP) && fu->bcnt)
			fu->reps += (bb_dump_blocksize - fs->bcnt) / fu->bcnt;
		if (fu->reps > 1) {
			for (pr = fu->nextpr;; pr = pr->nextpr)
				if (!pr->nextpr)
					break;
			for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
				p2 = isspace(*p1) ? p1 : NULL;
			if (p2)
				pr->nospace = p2;
		}
		if (!fu->nextfu)
			break;
	}
}

static void do_skip(char *fname, int statok)
{
	struct stat sbuf;

	if (statok) {
		if (fstat(STDIN_FILENO, &sbuf)) {
			bb_perror_msg_and_die("%s", fname);
		}
		if ((!(S_ISCHR(sbuf.st_mode) ||
			   S_ISBLK(sbuf.st_mode) ||
			   S_ISFIFO(sbuf.st_mode))) && bb_dump_skip >= sbuf.st_size) {
			/* If bb_dump_size valid and bb_dump_skip >= size */
			bb_dump_skip -= sbuf.st_size;
			address += sbuf.st_size;
			return;
		}
	}
	if (fseek(stdin, bb_dump_skip, SEEK_SET)) {
		bb_perror_msg_and_die("%s", fname);
	}
	savaddress = address += bb_dump_skip;
	bb_dump_skip = 0;
}

static int next(char **argv)
{
	static int done;
	int statok;

	if (argv) {
		_argv = argv;
		return 1;
	}
	for (;;) {
		if (*_argv) {
			if (!(freopen(*_argv, "r", stdin))) {
				bb_perror_msg("%s", *_argv);
				exitval = 1;
				++_argv;
				continue;
			}
			statok = done = 1;
		} else {
			if (done++)
				return 0;
			statok = 0;
		}
		if (bb_dump_skip)
			do_skip(statok ? *_argv : "stdin", statok);
		if (*_argv)
			++_argv;
		if (!bb_dump_skip)
			return 1;
	}
	/* NOTREACHED */
}

static unsigned char *get(void)
{
	static int ateof = 1;
	static unsigned char *curp=NULL, *savp; /*DBU:[dave@cray.com]initialize curp */
	int n;
	int need, nread;
	unsigned char *tmpp;

	if (!curp) {
		address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/
		curp = xmalloc(bb_dump_blocksize);
		savp = xmalloc(bb_dump_blocksize);
	} else {
		tmpp = curp;
		curp = savp;
		savp = tmpp;
		address = savaddress += bb_dump_blocksize;
	}
	for (need = bb_dump_blocksize, nread = 0;;) {
		/*
		 * if read the right number of bytes, or at EOF for one file,
		 * and no other files are available, zero-pad the rest of the
		 * block and set the end flag.
		 */
		if (!bb_dump_length || (ateof && !next((char **) NULL))) {
			if (need == bb_dump_blocksize) {
				return NULL;
			}
			if (bb_dump_vflag != ALL && !memcmp(curp, savp, nread)) {
				if (bb_dump_vflag != DUP) {
					puts("*");
				}
				return NULL;
			}
			memset((char *) curp + nread, 0, need);
			eaddress = address + nread;
			return curp;
		}
		n = fread((char *) curp + nread, sizeof(unsigned char),
				  bb_dump_length == -1 ? need : MIN(bb_dump_length, need), stdin);
		if (!n) {
			if (ferror(stdin)) {
				bb_perror_msg("%s", _argv[-1]);
			}
			ateof = 1;
			continue;
		}
		ateof = 0;
		if (bb_dump_length != -1) {
			bb_dump_length -= n;
		}
		if (!(need -= n)) {
			if (bb_dump_vflag == ALL || bb_dump_vflag == FIRST
				|| memcmp(curp, savp, bb_dump_blocksize)) {
				if (bb_dump_vflag == DUP || bb_dump_vflag == FIRST) {
					bb_dump_vflag = WAIT;
				}
				return curp;
			}
			if (bb_dump_vflag == WAIT) {
				puts("*");
			}
			bb_dump_vflag = DUP;
			address = savaddress += bb_dump_blocksize;
			need = bb_dump_blocksize;
			nread = 0;
		} else {
			nread += n;
		}
	}
}

static void bpad(PR * pr)
{
	char *p1, *p2;

	/*
	 * remove all conversion flags; '-' is the only one valid
	 * with %s, and it's not useful here.
	 */
	pr->flags = F_BPAD;
	*pr->cchar = 's';
	for (p1 = pr->fmt; *p1 != '%'; ++p1);
	for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1)
		if (pr->nospace) pr->nospace--;
	while ((*p2++ = *p1++) != 0);
}

static const char conv_str[] =
	"\0\\0\0"
	"\007\\a\0"				/* \a */
	"\b\\b\0"
	"\f\\b\0"
	"\n\\n\0"
	"\r\\r\0"
	"\t\\t\0"
	"\v\\v\0"
	"\0";


static void conv_c(PR * pr, unsigned char * p)
{
	const char *str = conv_str;
	char buf[10];

	do {
		if (*p == *str) {
			++str;
			goto strpr;
		}
		str += 4;
	} while (*str);

	if (isprint(*p)) {
		*pr->cchar = 'c';
		(void) printf(pr->fmt, *p);
	} else {
		sprintf(buf, "%03o", (int) *p);
		str = buf;
	  strpr:
		*pr->cchar = 's';
		printf(pr->fmt, str);
	}
}

static void conv_u(PR * pr, unsigned char * p)
{
	static const char list[] =
		"nul\0soh\0stx\0etx\0eot\0enq\0ack\0bel\0"
		"bs\0_ht\0_lf\0_vt\0_ff\0_cr\0_so\0_si\0_"
		"dle\0dcl\0dc2\0dc3\0dc4\0nak\0syn\0etb\0"
		"can\0em\0_sub\0esc\0fs\0_gs\0_rs\0_us";

	/* od used nl, not lf */
	if (*p <= 0x1f) {
		*pr->cchar = 's';
		printf(pr->fmt, list + (4 * (int)*p));
	} else if (*p == 0x7f) {
		*pr->cchar = 's';
		printf(pr->fmt, "del");
	} else if (isprint(*p)) {
		*pr->cchar = 'c';
		printf(pr->fmt, *p);
	} else {
		*pr->cchar = 'x';
		printf(pr->fmt, (int) *p);
	}
}

static void display(void)
{
/*  extern FU *endfu; */
	FS *fs;
	FU *fu;
	PR *pr;
	int cnt;
	unsigned char *bp;

	off_t saveaddress;
	unsigned char savech = 0, *savebp;

	while ((bp = get()) != NULL) {
		for (fs = bb_dump_fshead, savebp = bp, saveaddress = address; fs;
			 fs = fs->nextfs, bp = savebp, address = saveaddress) {
			for (fu = fs->nextfu; fu; fu = fu->nextfu) {
				if (fu->flags & F_IGNORE) {
					break;
				}
				for (cnt = fu->reps; cnt; --cnt) {
					for (pr = fu->nextpr; pr; address += pr->bcnt,
						 bp += pr->bcnt, pr = pr->nextpr) {
						if (eaddress && address >= eaddress &&
							!(pr->flags & (F_TEXT | F_BPAD))) {
							bpad(pr);
						}
						if (cnt == 1 && pr->nospace) {
							savech = *pr->nospace;
							*pr->nospace = '\0';
						}
/*                      PRINT; */
						switch (pr->flags) {
						case F_ADDRESS:
							printf(pr->fmt, (unsigned int) address);
							break;
						case F_BPAD:
							printf(pr->fmt, "");
							break;
						case F_C:
							conv_c(pr, bp);
							break;
						case F_CHAR:
							printf(pr->fmt, *bp);
							break;
						case F_DBL:{
							double dval;
							float fval;

							switch (pr->bcnt) {
							case 4:
								memmove((char *) &fval, (char *) bp,
									  sizeof(fval));
								printf(pr->fmt, fval);
								break;
							case 8:
								memmove((char *) &dval, (char *) bp,
									  sizeof(dval));
								printf(pr->fmt, dval);
								break;
							}
							break;
						}
						case F_INT:{
							int ival;
							short sval;

							switch (pr->bcnt) {
							case 1:
								printf(pr->fmt, (int) *bp);
								break;
							case 2:
								memmove((char *) &sval, (char *) bp,
									  sizeof(sval));
								printf(pr->fmt, (int) sval);
								break;
							case 4:
								memmove((char *) &ival, (char *) bp,
									  sizeof(ival));
								printf(pr->fmt, ival);
								break;
							}
							break;
						}
						case F_P:
							printf(pr->fmt, isprint(*bp) ? *bp : '.');
							break;
						case F_STR:
							printf(pr->fmt, (char *) bp);
							break;
						case F_TEXT:
							printf(pr->fmt);
							break;
						case F_U:
							conv_u(pr, bp);
							break;
						case F_UINT:{
							unsigned int ival;
							unsigned short sval;

							switch (pr->bcnt) {
							case 1:
								printf(pr->fmt, (unsigned int) * bp);
								break;
							case 2:
								memmove((char *) &sval, (char *) bp,
									  sizeof(sval));
								printf(pr->fmt, (unsigned int) sval);
								break;
							case 4:
								memmove((char *) &ival, (char *) bp,
									  sizeof(ival));
								printf(pr->fmt, ival);
								break;
							}
							break;
						}
						}
						if (cnt == 1 && pr->nospace) {
							*pr->nospace = savech;
						}
					}
				}
			}
		}
	}
	if (endfu) {
		/*
		 * if eaddress not set, error or file bb_dump_size was multiple of
		 * bb_dump_blocksize, and no partial block ever found.
		 */
		if (!eaddress) {
			if (!address) {
				return;
			}
			eaddress = address;
		}
		for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
			switch (pr->flags) {
			case F_ADDRESS:
				(void) printf(pr->fmt, (unsigned int) eaddress);
				break;
			case F_TEXT:
				(void) printf(pr->fmt);
				break;
			}
		}
	}
}

int bb_dump_dump(char **argv)
{
	FS *tfs;

	/* figure out the data block bb_dump_size */
	for (bb_dump_blocksize = 0, tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
		tfs->bcnt = bb_dump_size(tfs);
		if (bb_dump_blocksize < tfs->bcnt) {
			bb_dump_blocksize = tfs->bcnt;
		}
	}
	/* rewrite the rules, do syntax checking */
	for (tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
		rewrite(tfs);
	}

	next(argv);
	display();

	return exitval;
}

void bb_dump_add(const char *fmt)
{
	const char *p;
	char *p1;
	char *p2;
	static FS **nextfs;
	FS *tfs;
	FU *tfu, **nextfu;
	const char *savep;

	/* start new linked list of format units */
	tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */
	if (!bb_dump_fshead) {
		bb_dump_fshead = tfs;
	} else {
		*nextfs = tfs;
	}
	nextfs = &tfs->nextfs;
	nextfu = &tfs->nextfu;

	/* take the format string and break it up into format units */
	for (p = fmt;;) {
		/* bb_dump_skip leading white space */
		p = skip_whitespace(p);
		if (!*p) {
			break;
		}

		/* allocate a new format unit and link it in */
		/* NOSTRICT */
		/* DBU:[dave@cray.com] calloc so that forward pointers start out NULL */
		tfu = xzalloc(sizeof(FU));
		*nextfu = tfu;
		nextfu = &tfu->nextfu;
		tfu->reps = 1;

		/* if leading digit, repetition count */
		if (isdigit(*p)) {
			for (savep = p; isdigit(*p); ++p);
			if (!isspace(*p) && *p != '/') {
				bb_error_msg_and_die("bad format {%s}", fmt);
			}
			/* may overwrite either white space or slash */
			tfu->reps = atoi(savep);
			tfu->flags = F_SETREP;
			/* bb_dump_skip trailing white space */
			p = skip_whitespace(++p);
		}

		/* bb_dump_skip slash and trailing white space */
		if (*p == '/') {
			p = skip_whitespace(++p);
		}

		/* byte count */
		if (isdigit(*p)) {
// TODO: use bb_strtou
			savep = p;
			do p++; while (isdigit(*p));
			if (!isspace(*p)) {
				bb_error_msg_and_die("bad format {%s}", fmt);
			}
			tfu->bcnt = atoi(savep);
			/* bb_dump_skip trailing white space */
			p = skip_whitespace(++p);
		}

		/* format */
		if (*p != '"') {
			bb_error_msg_and_die("bad format {%s}", fmt);
		}
		for (savep = ++p; *p != '"';) {
			if (*p++ == 0) {
				bb_error_msg_and_die("bad format {%s}", fmt);
			}
		}
		tfu->fmt = xmalloc(p - savep + 1);
		strncpy(tfu->fmt, savep, p - savep);
		tfu->fmt[p - savep] = '\0';
/*      escape(tfu->fmt); */

		p1 = tfu->fmt;

		/* alphabetic escape sequences have to be done in place */
		for (p2 = p1;; ++p1, ++p2) {
			if (!*p1) {
				*p2 = *p1;
				break;
			}
			if (*p1 == '\\') {
				const char *cs = conv_str + 4;
				++p1;
				*p2 = *p1;
				do {
					if (*p1 == cs[2]) {
						*p2 = cs[0];
						break;
					}
					cs += 4;
				} while (*cs);
			}
		}

		p++;
	}
}

/*
 * Copyright (c) 1989 The Regents of the University of California.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. Neither the name of the University nor the names of its contributors
 *    may be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */
1	/* vi: set sw=4 ts=4: */
2	/*
3	* Support code for the hexdump and od applets,
4	* based on code from util-linux v 2.11l
5	*
6	* Copyright (c) 1989
7	* The Regents of the University of California. All rights reserved.
8	*
9	* Licensed under GPLv2 or later, see file LICENSE in this tarball for details.
10	*
11	* Original copyright notice is retained at the end of this file.
12	*/
13
14	#include "libbb.h"
15	#include "dump.h"
16
17	enum _vflag bb_dump_vflag = FIRST;
18	FS bb_dump_fshead; / head of format strings */
19	static FU *endfu;
20	static char **_argv;
21	static off_t savaddress; /* saved address/offset in stream */
22	static off_t eaddress; /* end address */
23	static off_t address; /* address/offset in stream */
24	off_t bb_dump_skip; /* bytes to skip */
25	static int exitval; /* final exit value */
26	int bb_dump_blocksize; /* data block size */
27	int bb_dump_length = -1; /* max bytes to read */
28
29	static const char index_str[] = ".#-+ 0123456789";
30
31	static const char size_conv_str[] =
32	"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG";
33
34	static const char lcc[] = "diouxX";
35
36	int bb_dump_size(FS * fs)
37	{
38	FU *fu;
39	int bcnt, cur_size;
40	char *fmt;
41	const char *p;
42	int prec;
43
44	/* figure out the data block bb_dump_size needed for each format unit */
45	for (cur_size = 0, fu = fs->nextfu; fu; fu = fu->nextfu) {
46	if (fu->bcnt) {
47	cur_size += fu->bcnt * fu->reps;
48	continue;
49	}
50	for (bcnt = prec = 0, fmt = fu->fmt; *fmt; ++fmt) {
51	if (*fmt != '%')
52	continue;
53	/*
54	* bb_dump_skip any special chars -- save precision in
55	* case it's a %s format.
56	*/
57	while (strchr(index_str + 1, *++fmt));
58	if (fmt == '.' && isdigit(++fmt)) {
59	prec = atoi(fmt);
60	while (isdigit(*++fmt));
61	}
62	if (!(p = strchr(size_conv_str + 12, *fmt))) {
63	if (*fmt == 's') {
64	bcnt += prec;
65	} else if (*fmt == '_') {
66	++fmt;
67	if ((fmt == 'c') \|\| (fmt == 'p') \|\| (*fmt == 'u')) {
68	bcnt += 1;
69	}
70	}
71	} else {
72	bcnt += size_conv_str[p - (size_conv_str + 12)];
73	}
74	}
75	cur_size += bcnt * fu->reps;
76	}
77	return cur_size;
78	}
79
80	static void rewrite(FS * fs)
81	{
82	enum { NOTOKAY, USEBCNT, USEPREC } sokay;
83	PR pr, *nextpr = NULL;
84	FU *fu;
85	char p1, p2, *p3;
86	char savech, *fmtp;
87	const char *byte_count_str;
88	int nconv, prec = 0;
89
90	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
91	/*
92	* break each format unit into print units; each
93	* conversion character gets its own.
94	*/
95	for (nconv = 0, fmtp = fu->fmt; *fmtp; nextpr = &pr->nextpr) {
96	/* NOSTRICT */
97	/* DBU:[dvae@cray.com] calloc so that forward ptrs start out NULL*/
98	pr = xzalloc(sizeof(PR));
99	if (!fu->nextpr)
100	fu->nextpr = pr;
101	/* ignore nextpr -- its unused inside the loop and is
102	* uninitialized 1st time thru.
103	*/
104
105	/* bb_dump_skip preceding text and up to the next % sign */
106	for (p1 = fmtp; p1 && p1 != '%'; ++p1);
107
108	/* only text in the string */
109	if (!*p1) {
110	pr->fmt = fmtp;
111	pr->flags = F_TEXT;
112	break;
113	}
114
115	/*
116	* get precision for %s -- if have a byte count, don't
117	* need it.
118	*/
119	if (fu->bcnt) {
120	sokay = USEBCNT;
121	/* bb_dump_skip to conversion character */
122	for (++p1; strchr(index_str, *p1); ++p1);
123	} else {
124	/* bb_dump_skip any special chars, field width */
125	while (strchr(index_str + 1, *++p1));
126	if (p1 == '.' && isdigit(++p1)) {
127	sokay = USEPREC;
128	prec = atoi(p1);
129	while (isdigit(*++p1));
130	} else
131	sokay = NOTOKAY;
132	}
133
134	p2 = p1 + 1; /* set end pointer */
135
136	/*
137	* figure out the byte count for each conversion;
138	* rewrite the format as necessary, set up blank-
139	* pbb_dump_adding for end of data.
140	*/
141
142	if (*p1 == 'c') {
143	pr->flags = F_CHAR;
144	DO_BYTE_COUNT_1:
145	byte_count_str = "\001";
146	DO_BYTE_COUNT:
147	if (fu->bcnt) {
148	do {
149	if (fu->bcnt == *byte_count_str) {
150	break;
151	}
152	} while (*++byte_count_str);
153	}
154	/* Unlike the original, output the remainder of the format string. */
155	if (!*byte_count_str) {
156	bb_error_msg_and_die("bad byte count for conversion character %s", p1);
157	}
158	pr->bcnt = *byte_count_str;
159	} else if (*p1 == 'l') {
160	++p2;
161	++p1;
162	DO_INT_CONV:
163	{
164	const char *e;
165	if (!(e = strchr(lcc, *p1))) {
166	goto DO_BAD_CONV_CHAR;
167	}
168	pr->flags = F_INT;
169	if (e > lcc + 1) {
170	pr->flags = F_UINT;
171	}
172	byte_count_str = "\004\002\001";
173	goto DO_BYTE_COUNT;
174	}
175	/* NOTREACHED */
176	} else if (strchr(lcc, *p1)) {
177	goto DO_INT_CONV;
178	} else if (strchr("eEfgG", *p1)) {
179	pr->flags = F_DBL;
180	byte_count_str = "\010\004";
181	goto DO_BYTE_COUNT;
182	} else if (*p1 == 's') {
183	pr->flags = F_STR;
184	if (sokay == USEBCNT) {
185	pr->bcnt = fu->bcnt;
186	} else if (sokay == USEPREC) {
187	pr->bcnt = prec;
188	} else { /* NOTOKAY */
189	bb_error_msg_and_die("%%s requires a precision or a byte count");
190	}
191	} else if (*p1 == '_') {
192	++p2;
193	switch (p1[1]) {
194	case 'A':
195	endfu = fu;
196	fu->flags \|= F_IGNORE;
197	/* FALLTHROUGH */
198	case 'a':
199	pr->flags = F_ADDRESS;
200	++p2;
201	if ((p1[2] != 'd') && (p1[2] != 'o') && (p1[2] != 'x')) {
202	goto DO_BAD_CONV_CHAR;
203	}
204	*p1 = p1[2];
205	break;
206	case 'c':
207	pr->flags = F_C;
208	/* p1 = 'c'; set in conv_c /
209	goto DO_BYTE_COUNT_1;
210	case 'p':
211	pr->flags = F_P;
212	*p1 = 'c';
213	goto DO_BYTE_COUNT_1;
214	case 'u':
215	pr->flags = F_U;
216	/* p1 = 'c'; set in conv_u /
217	goto DO_BYTE_COUNT_1;
218	default:
219	goto DO_BAD_CONV_CHAR;
220	}
221	} else {
222	DO_BAD_CONV_CHAR:
223	bb_error_msg_and_die("bad conversion character %%%s", p1);
224	}
225
226	/*
227	* copy to PR format string, set conversion character
228	* pointer, update original.
229	*/
230	savech = *p2;
231	p1[1] = '\0';
232	pr->fmt = xstrdup(fmtp);
233	*p2 = savech;
234	pr->cchar = pr->fmt + (p1 - fmtp);
235
236	/* DBU:[dave@cray.com] w/o this, trailing fmt text, space is lost.
237	* Skip subsequent text and up to the next % sign and tack the
238	* additional text onto fmt: eg. if fmt is "%x is a HEX number",
239	* we lose the " is a HEX number" part of fmt.
240	*/
241	for (p3 = p2; p3 && p3 != '%'; p3++);
242	if (p3 > p2)
243	{
244	savech = *p3;
245	*p3 = '\0';
246	pr->fmt = xrealloc(pr->fmt, strlen(pr->fmt)+(p3-p2)+1);
247	strcat(pr->fmt, p2);
248	*p3 = savech;
249	p2 = p3;
250	}
251
252	fmtp = p2;
253
254	/* only one conversion character if byte count */
255	if (!(pr->flags & F_ADDRESS) && fu->bcnt && nconv++) {
256	bb_error_msg_and_die("byte count with multiple conversion characters");
257	}
258	}
259	/*
260	* if format unit byte count not specified, figure it out
261	* so can adjust rep count later.
262	*/
263	if (!fu->bcnt)
264	for (pr = fu->nextpr; pr; pr = pr->nextpr)
265	fu->bcnt += pr->bcnt;
266	}
267	/*
268	* if the format string interprets any data at all, and it's
269	* not the same as the bb_dump_blocksize, and its last format unit
270	* interprets any data at all, and has no iteration count,
271	* repeat it as necessary.
272	*
273	* if, rep count is greater than 1, no trailing whitespace
274	* gets output from the last iteration of the format unit.
275	*/
276	for (fu = fs->nextfu;; fu = fu->nextfu) {
277	if (!fu->nextfu && fs->bcnt < bb_dump_blocksize &&
278	!(fu->flags & F_SETREP) && fu->bcnt)
279	fu->reps += (bb_dump_blocksize - fs->bcnt) / fu->bcnt;
280	if (fu->reps > 1) {
281	for (pr = fu->nextpr;; pr = pr->nextpr)
282	if (!pr->nextpr)
283	break;
284	for (p1 = pr->fmt, p2 = NULL; *p1; ++p1)
285	p2 = isspace(*p1) ? p1 : NULL;
286	if (p2)
287	pr->nospace = p2;
288	}
289	if (!fu->nextfu)
290	break;
291	}
292	}
293
294	static void do_skip(char *fname, int statok)
295	{
296	struct stat sbuf;
297
298	if (statok) {
299	if (fstat(STDIN_FILENO, &sbuf)) {
300	bb_perror_msg_and_die("%s", fname);
301	}
302	if ((!(S_ISCHR(sbuf.st_mode) \|\|
303	S_ISBLK(sbuf.st_mode) \|\|
304	S_ISFIFO(sbuf.st_mode))) && bb_dump_skip >= sbuf.st_size) {
305	/* If bb_dump_size valid and bb_dump_skip >= size */
306	bb_dump_skip -= sbuf.st_size;
307	address += sbuf.st_size;
308	return;
309	}
310	}
311	if (fseek(stdin, bb_dump_skip, SEEK_SET)) {
312	bb_perror_msg_and_die("%s", fname);
313	}
314	savaddress = address += bb_dump_skip;
315	bb_dump_skip = 0;
316	}
317
318	static int next(char **argv)
319	{
320	static int done;
321	int statok;
322
323	if (argv) {
324	_argv = argv;
325	return 1;
326	}
327	for (;;) {
328	if (*_argv) {
329	if (!(freopen(*_argv, "r", stdin))) {
330	bb_perror_msg("%s", *_argv);
331	exitval = 1;
332	++_argv;
333	continue;
334	}
335	statok = done = 1;
336	} else {
337	if (done++)
338	return 0;
339	statok = 0;
340	}
341	if (bb_dump_skip)
342	do_skip(statok ? *_argv : "stdin", statok);
343	if (*_argv)
344	++_argv;
345	if (!bb_dump_skip)
346	return 1;
347	}
348	/* NOTREACHED */
349	}
350
351	static unsigned char *get(void)
352	{
353	static int ateof = 1;
354	static unsigned char curp=NULL, savp; /DBU:[dave@cray.com]initialize curp /
355	int n;
356	int need, nread;
357	unsigned char *tmpp;
358
359	if (!curp) {
360	address = (off_t)0; /DBU:[dave@cray.com] initialize,initialize../
361	curp = xmalloc(bb_dump_blocksize);
362	savp = xmalloc(bb_dump_blocksize);
363	} else {
364	tmpp = curp;
365	curp = savp;
366	savp = tmpp;
367	address = savaddress += bb_dump_blocksize;
368	}
369	for (need = bb_dump_blocksize, nread = 0;;) {
370	/*
371	* if read the right number of bytes, or at EOF for one file,
372	* and no other files are available, zero-pad the rest of the
373	* block and set the end flag.
374	*/
375	if (!bb_dump_length \|\| (ateof && !next((char **) NULL))) {
376	if (need == bb_dump_blocksize) {
377	return NULL;
378	}
379	if (bb_dump_vflag != ALL && !memcmp(curp, savp, nread)) {
380	if (bb_dump_vflag != DUP) {
381	puts("*");
382	}
383	return NULL;
384	}
385	memset((char *) curp + nread, 0, need);
386	eaddress = address + nread;
387	return curp;
388	}
389	n = fread((char *) curp + nread, sizeof(unsigned char),
390	bb_dump_length == -1 ? need : MIN(bb_dump_length, need), stdin);
391	if (!n) {
392	if (ferror(stdin)) {
393	bb_perror_msg("%s", _argv[-1]);
394	}
395	ateof = 1;
396	continue;
397	}
398	ateof = 0;
399	if (bb_dump_length != -1) {
400	bb_dump_length -= n;
401	}
402	if (!(need -= n)) {
403	if (bb_dump_vflag == ALL \|\| bb_dump_vflag == FIRST
404	\|\| memcmp(curp, savp, bb_dump_blocksize)) {
405	if (bb_dump_vflag == DUP \|\| bb_dump_vflag == FIRST) {
406	bb_dump_vflag = WAIT;
407	}
408	return curp;
409	}
410	if (bb_dump_vflag == WAIT) {
411	puts("*");
412	}
413	bb_dump_vflag = DUP;
414	address = savaddress += bb_dump_blocksize;
415	need = bb_dump_blocksize;
416	nread = 0;
417	} else {
418	nread += n;
419	}
420	}
421	}
422
423	static void bpad(PR * pr)
424	{
425	char p1, p2;
426
427	/*
428	* remove all conversion flags; '-' is the only one valid
429	* with %s, and it's not useful here.
430	*/
431	pr->flags = F_BPAD;
432	*pr->cchar = 's';
433	for (p1 = pr->fmt; *p1 != '%'; ++p1);
434	for (p2 = ++p1; p1 && strchr(" -0+#", p1); ++p1)
435	if (pr->nospace) pr->nospace--;
436	while ((p2++ = p1++) != 0);
437	}
438
439	static const char conv_str[] =
440	"\0\\0\0"
441	"\007\\a\0" /* \a */
442	"\b\\b\0"
443	"\f\\b\0"
444	"\n\\n\0"
445	"\r\\r\0"
446	"\t\\t\0"
447	"\v\\v\0"
448	"\0";
449
450
451	static void conv_c(PR * pr, unsigned char * p)
452	{
453	const char *str = conv_str;
454	char buf[10];
455
456	do {
457	if (p == str) {
458	++str;
459	goto strpr;
460	}
461	str += 4;
462	} while (*str);
463
464	if (isprint(*p)) {
465	*pr->cchar = 'c';
466	(void) printf(pr->fmt, *p);
467	} else {
468	sprintf(buf, "%03o", (int) *p);
469	str = buf;
470	strpr:
471	*pr->cchar = 's';
472	printf(pr->fmt, str);
473	}
474	}
475
476	static void conv_u(PR * pr, unsigned char * p)
477	{
478	static const char list[] =
479	"nul\0soh\0stx\0etx\0eot\0enq\0ack\0bel\0"
480	"bs\0_ht\0_lf\0_vt\0_ff\0_cr\0_so\0_si\0_"
481	"dle\0dcl\0dc2\0dc3\0dc4\0nak\0syn\0etb\0"
482	"can\0em\0_sub\0esc\0fs\0_gs\0_rs\0_us";
483
484	/* od used nl, not lf */
485	if (*p <= 0x1f) {
486	*pr->cchar = 's';
487	printf(pr->fmt, list + (4 * (int)*p));
488	} else if (*p == 0x7f) {
489	*pr->cchar = 's';
490	printf(pr->fmt, "del");
491	} else if (isprint(*p)) {
492	*pr->cchar = 'c';
493	printf(pr->fmt, *p);
494	} else {
495	*pr->cchar = 'x';
496	printf(pr->fmt, (int) *p);
497	}
498	}
499
500	static void display(void)
501	{
502	/* extern FU endfu; /
503	FS *fs;
504	FU *fu;
505	PR *pr;
506	int cnt;
507	unsigned char *bp;
508
509	off_t saveaddress;
510	unsigned char savech = 0, *savebp;
511
512	while ((bp = get()) != NULL) {
513	for (fs = bb_dump_fshead, savebp = bp, saveaddress = address; fs;
514	fs = fs->nextfs, bp = savebp, address = saveaddress) {
515	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
516	if (fu->flags & F_IGNORE) {
517	break;
518	}
519	for (cnt = fu->reps; cnt; --cnt) {
520	for (pr = fu->nextpr; pr; address += pr->bcnt,
521	bp += pr->bcnt, pr = pr->nextpr) {
522	if (eaddress && address >= eaddress &&
523	!(pr->flags & (F_TEXT \| F_BPAD))) {
524	bpad(pr);
525	}
526	if (cnt == 1 && pr->nospace) {
527	savech = *pr->nospace;
528	*pr->nospace = '\0';
529	}
530	/* PRINT; */
531	switch (pr->flags) {
532	case F_ADDRESS:
533	printf(pr->fmt, (unsigned int) address);
534	break;
535	case F_BPAD:
536	printf(pr->fmt, "");
537	break;
538	case F_C:
539	conv_c(pr, bp);
540	break;
541	case F_CHAR:
542	printf(pr->fmt, *bp);
543	break;
544	case F_DBL:{
545	double dval;
546	float fval;
547
548	switch (pr->bcnt) {
549	case 4:
550	memmove((char ) &fval, (char ) bp,
551	sizeof(fval));
552	printf(pr->fmt, fval);
553	break;
554	case 8:
555	memmove((char ) &dval, (char ) bp,
556	sizeof(dval));
557	printf(pr->fmt, dval);
558	break;
559	}
560	break;
561	}
562	case F_INT:{
563	int ival;
564	short sval;
565
566	switch (pr->bcnt) {
567	case 1:
568	printf(pr->fmt, (int) *bp);
569	break;
570	case 2:
571	memmove((char ) &sval, (char ) bp,
572	sizeof(sval));
573	printf(pr->fmt, (int) sval);
574	break;
575	case 4:
576	memmove((char ) &ival, (char ) bp,
577	sizeof(ival));
578	printf(pr->fmt, ival);
579	break;
580	}
581	break;
582	}
583	case F_P:
584	printf(pr->fmt, isprint(bp) ? bp : '.');
585	break;
586	case F_STR:
587	printf(pr->fmt, (char *) bp);
588	break;
589	case F_TEXT:
590	printf(pr->fmt);
591	break;
592	case F_U:
593	conv_u(pr, bp);
594	break;
595	case F_UINT:{
596	unsigned int ival;
597	unsigned short sval;
598
599	switch (pr->bcnt) {
600	case 1:
601	printf(pr->fmt, (unsigned int) * bp);
602	break;
603	case 2:
604	memmove((char ) &sval, (char ) bp,
605	sizeof(sval));
606	printf(pr->fmt, (unsigned int) sval);
607	break;
608	case 4:
609	memmove((char ) &ival, (char ) bp,
610	sizeof(ival));
611	printf(pr->fmt, ival);
612	break;
613	}
614	break;
615	}
616	}
617	if (cnt == 1 && pr->nospace) {
618	*pr->nospace = savech;
619	}
620	}
621	}
622	}
623	}
624	}
625	if (endfu) {
626	/*
627	* if eaddress not set, error or file bb_dump_size was multiple of
628	* bb_dump_blocksize, and no partial block ever found.
629	*/
630	if (!eaddress) {
631	if (!address) {
632	return;
633	}
634	eaddress = address;
635	}
636	for (pr = endfu->nextpr; pr; pr = pr->nextpr) {
637	switch (pr->flags) {
638	case F_ADDRESS:
639	(void) printf(pr->fmt, (unsigned int) eaddress);
640	break;
641	case F_TEXT:
642	(void) printf(pr->fmt);
643	break;
644	}
645	}
646	}
647	}
648
649	int bb_dump_dump(char **argv)
650	{
651	FS *tfs;
652
653	/* figure out the data block bb_dump_size */
654	for (bb_dump_blocksize = 0, tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
655	tfs->bcnt = bb_dump_size(tfs);
656	if (bb_dump_blocksize < tfs->bcnt) {
657	bb_dump_blocksize = tfs->bcnt;
658	}
659	}
660	/* rewrite the rules, do syntax checking */
661	for (tfs = bb_dump_fshead; tfs; tfs = tfs->nextfs) {
662	rewrite(tfs);
663	}
664
665	next(argv);
666	display();
667
668	return exitval;
669	}
670
671	void bb_dump_add(const char *fmt)
672	{
673	const char *p;
674	char *p1;
675	char *p2;
676	static FS **nextfs;
677	FS *tfs;
678	FU tfu, *nextfu;
679	const char *savep;
680
681	/* start new linked list of format units */
682	tfs = xzalloc(sizeof(FS)); /DBU:[dave@cray.com] start out NULL /
683	if (!bb_dump_fshead) {
684	bb_dump_fshead = tfs;
685	} else {
686	*nextfs = tfs;
687	}
688	nextfs = &tfs->nextfs;
689	nextfu = &tfs->nextfu;
690
691	/* take the format string and break it up into format units */
692	for (p = fmt;;) {
693	/* bb_dump_skip leading white space */
694	p = skip_whitespace(p);
695	if (!*p) {
696	break;
697	}
698
699	/* allocate a new format unit and link it in */
700	/* NOSTRICT */
701	/* DBU:[dave@cray.com] calloc so that forward pointers start out NULL */
702	tfu = xzalloc(sizeof(FU));
703	*nextfu = tfu;
704	nextfu = &tfu->nextfu;
705	tfu->reps = 1;
706
707	/* if leading digit, repetition count */
708	if (isdigit(*p)) {
709	for (savep = p; isdigit(*p); ++p);
710	if (!isspace(p) && p != '/') {
711	bb_error_msg_and_die("bad format {%s}", fmt);
712	}
713	/* may overwrite either white space or slash */
714	tfu->reps = atoi(savep);
715	tfu->flags = F_SETREP;
716	/* bb_dump_skip trailing white space */
717	p = skip_whitespace(++p);
718	}
719
720	/* bb_dump_skip slash and trailing white space */
721	if (*p == '/') {
722	p = skip_whitespace(++p);
723	}
724
725	/* byte count */
726	if (isdigit(*p)) {
727	// TODO: use bb_strtou
728	savep = p;
729	do p++; while (isdigit(*p));
730	if (!isspace(*p)) {
731	bb_error_msg_and_die("bad format {%s}", fmt);
732	}
733	tfu->bcnt = atoi(savep);
734	/* bb_dump_skip trailing white space */
735	p = skip_whitespace(++p);
736	}
737
738	/* format */
739	if (*p != '"') {
740	bb_error_msg_and_die("bad format {%s}", fmt);
741	}
742	for (savep = ++p; *p != '"';) {
743	if (*p++ == 0) {
744	bb_error_msg_and_die("bad format {%s}", fmt);
745	}
746	}
747	tfu->fmt = xmalloc(p - savep + 1);
748	strncpy(tfu->fmt, savep, p - savep);
749	tfu->fmt[p - savep] = '\0';
750	/* escape(tfu->fmt); */
751
752	p1 = tfu->fmt;
753
754	/* alphabetic escape sequences have to be done in place */
755	for (p2 = p1;; ++p1, ++p2) {
756	if (!*p1) {
757	p2 = p1;
758	break;
759	}
760	if (*p1 == '\\') {
761	const char *cs = conv_str + 4;
762	++p1;
763	p2 = p1;
764	do {
765	if (*p1 == cs[2]) {
766	*p2 = cs[0];
767	break;
768	}
769	cs += 4;
770	} while (*cs);
771	}
772	}
773
774	p++;
775	}
776	}
777
778	/*
779	* Copyright (c) 1989 The Regents of the University of California.
780	* All rights reserved.
781	*
782	* Redistribution and use in source and binary forms, with or without
783	* modification, are permitted provided that the following conditions
784	* are met:
785	* 1. Redistributions of source code must retain the above copyright
786	* notice, this list of conditions and the following disclaimer.
787	* 2. Redistributions in binary form must reproduce the above copyright
788	* notice, this list of conditions and the following disclaimer in the
789	* documentation and/or other materials provided with the distribution.
790	* 3. Neither the name of the University nor the names of its contributors
791	* may be used to endorse or promote products derived from this software
792	* without specific prior written permission.
793	*
794	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
795	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
796	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
797	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
798	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
799	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
800	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
801	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
802	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
803	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
804	* SUCH DAMAGE.
805	*/