[thirdparty/util-linux.git] / text-utils / display.c

/*
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *	This product includes software developed by the University of
 *	California, Berkeley and its contributors.
 * 4. 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.
 */

#include <sys/param.h>
#include <sys/stat.h>
#include <unistd.h>
#include <errno.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "hexdump.h"

static void doskip(char *, int);
static u_char *get(void);

#ifndef MIN
#define MIN(a,b) ((a)<(b)?(a):(b))
#endif

enum _vflag vflag = FIRST;

static off_t address;			/* address/offset in stream */
static off_t eaddress;			/* end address */
static off_t savaddress;		/* saved address/offset in stream */

#define PRINT { \
	switch(pr->flags) { \
	case F_ADDRESS: \
		(void)printf(pr->fmt, address); \
		break; \
	case F_BPAD: \
		(void)printf(pr->fmt, ""); \
		break; \
	case F_C: \
		conv_c(pr, bp); \
		break; \
	case F_CHAR: \
		(void)printf(pr->fmt, *bp); \
		break; \
	case F_DBL: { \
		double dval; \
		float fval; \
		switch(pr->bcnt) { \
		case 4: \
			bcopy((char *)bp, (char *)&fval, sizeof(fval)); \
			(void)printf(pr->fmt, fval); \
			break; \
		case 8: \
			bcopy((char *)bp, (char *)&dval, sizeof(dval)); \
			(void)printf(pr->fmt, dval); \
			break; \
		} \
		break; \
	} \
	case F_INT: { \
		int ival; \
		short sval; \
		switch(pr->bcnt) { \
		case 1: \
			(void)printf(pr->fmt, (int)*bp); \
			break; \
		case 2: \
			bcopy((char *)bp, (char *)&sval, sizeof(sval)); \
			(void)printf(pr->fmt, (int)sval); \
			break; \
		case 4: \
			bcopy((char *)bp, (char *)&ival, sizeof(ival)); \
			(void)printf(pr->fmt, ival); \
			break; \
		} \
		break; \
	} \
	case F_P: \
		(void)printf(pr->fmt, isprint(*bp) ? *bp : '.'); \
		break; \
	case F_STR: \
		(void)printf(pr->fmt, (char *)bp); \
		break; \
	case F_TEXT: \
		(void)printf(pr->fmt); \
		break; \
	case F_U: \
		conv_u(pr, bp); \
		break; \
	case F_UINT: { \
		u_int ival; \
		u_short sval; \
		switch(pr->bcnt) { \
		case 1: \
			(void)printf(pr->fmt, (u_int)*bp); \
			break; \
		case 2: \
			bcopy((char *)bp, (char *)&sval, sizeof(sval)); \
			(void)printf(pr->fmt, (u_int)sval); \
			break; \
		case 4: \
			bcopy((char *)bp, (char *)&ival, sizeof(ival)); \
			(void)printf(pr->fmt, ival); \
			break; \
		} \
		break; \
	} \
	} \
}

static void bpad(PR *pr)
{
	static char *spec = " -0+#";
	register 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 && index(spec, *p1); ++p1);
	while ((*p2++ = *p1++) != 0) ;
}

void display(void)
{
	extern FU *endfu;
	register FS *fs;
	register FU *fu;
	register PR *pr;
	register int cnt;
	register u_char *bp;
	off_t saveaddress;
	u_char savech = 0, *savebp;

	while ((bp = get()) != NULL)
	    for (fs = 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;
				    if (cnt == 1 && pr->nospace)
					*pr->nospace = savech;
			    }
		    }
	if (endfu) {
		/*
		 * if eaddress not set, error or file size was multiple of
		 * 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, eaddress);
				break;
			case F_TEXT:
				(void)printf(pr->fmt);
				break;
			}
	}
}

static char **_argv;

static u_char *
get(void)
{
	extern int length;
	static int ateof = 1;
	static u_char *curp, *savp;
	register int n;
	int need, nread;
	u_char *tmpp;

	if (!curp) {
		curp = (u_char *)emalloc(blocksize);
		savp = (u_char *)emalloc(blocksize);
	} else {
		tmpp = curp;
		curp = savp;
		savp = tmpp;
		address = savaddress += blocksize;
	}
	for (need = 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 (!length || (ateof && !next((char **)NULL))) {
			if (need == blocksize)
				return((u_char *)NULL);
			if (vflag != ALL && !bcmp(curp, savp, nread)) {
				if (vflag != DUP)
					(void)printf("*\n");
				return((u_char *)NULL);
			}
			bzero((char *)curp + nread, need);
			eaddress = address + nread;
			return(curp);
		}
		n = fread((char *)curp + nread, sizeof(u_char),
		    length == -1 ? need : MIN(length, need), stdin);
		if (!n) {
			if (ferror(stdin))
				(void)fprintf(stderr, "hexdump: %s: %s\n",
				    _argv[-1], strerror(errno));
			ateof = 1;
			continue;
		}
		ateof = 0;
		if (length != -1)
			length -= n;
		if (!(need -= n)) {
			if (vflag == ALL || vflag == FIRST ||
			    bcmp(curp, savp, blocksize)) {
				if (vflag == DUP || vflag == FIRST)
					vflag = WAIT;
				return(curp);
			}
			if (vflag == WAIT)
				(void)printf("*\n");
			vflag = DUP;
			address = savaddress += blocksize;
			need = blocksize;
			nread = 0;
		}
		else
			nread += n;
	}
}

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

	if (argv) {
		_argv = argv;
		return(1);
	}
	for (;;) {
		if (*_argv) {
			if (!(freopen(*_argv, "r", stdin))) {
				(void)fprintf(stderr, "hexdump: %s: %s\n",
				    *_argv, strerror(errno));
				exitval = 1;
				++_argv;
				continue;
			}
			statok = done = 1;
		} else {
			if (done++)
				return(0);
			statok = 0;
		}
		if (skip)
			doskip(statok ? *_argv : "stdin", statok);
		if (*_argv)
			++_argv;
		if (!skip)
			return(1);
	}
	/* NOTREACHED */
}

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

	if (statok) {
		if (fstat(fileno(stdin), &sbuf)) {
			(void)fprintf(stderr, "hexdump: %s: %s.\n",
			    fname, strerror(errno));
			exit(1);
		}
		if ( ( ! (S_ISCHR(sbuf.st_mode) ||
 			  S_ISBLK(sbuf.st_mode) ||
 			  S_ISFIFO(sbuf.st_mode)) ) &&
		     skip >= sbuf.st_size) {
		  /* If size valid and skip >= size */
			skip -= sbuf.st_size;
			address += sbuf.st_size;
			return;
		}
	}
	if (fseek(stdin, skip, SEEK_SET)) {
		(void)fprintf(stderr, "hexdump: %s: %s.\n",
		    fname, strerror(errno));
		exit(1);
	}
	savaddress = address += skip;
	skip = 0;
}

char *
emalloc(int sz) {
	char *p;

	if (!(p = malloc((u_int)sz)))
		nomem();
	bzero(p, sz);
	return(p);
}

void nomem() {
	(void)fprintf(stderr, "hexdump: %s.\n", strerror(errno));
	exit(1);
}
Commit	Line	Data
6dbe3af9 KZ	1	/*
	2	* Copyright (c) 1989 The Regents of the University of California.
	3	* All rights reserved.
	4	*
	5	* Redistribution and use in source and binary forms, with or without
	6	* modification, are permitted provided that the following conditions
	7	* are met:
	8	* 1. Redistributions of source code must retain the above copyright
	9	* notice, this list of conditions and the following disclaimer.
	10	* 2. Redistributions in binary form must reproduce the above copyright
	11	* notice, this list of conditions and the following disclaimer in the
	12	* documentation and/or other materials provided with the distribution.
	13	* 3. All advertising materials mentioning features or use of this software
	14	* must display the following acknowledgement:
	15	* This product includes software developed by the University of
	16	* California, Berkeley and its contributors.
	17	* 4. Neither the name of the University nor the names of its contributors
	18	* may be used to endorse or promote products derived from this software
	19	* without specific prior written permission.
	20	*
	21	* THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
	22	* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	23	* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	24	* ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
	25	* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
	26	* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
	27	* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
	28	* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
	29	* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
	30	* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
	31	* SUCH DAMAGE.
	32	*/
	33
6dbe3af9 KZ	34	#include <sys/param.h>
	35	#include <sys/stat.h>
	36	#include <unistd.h>
	37	#include <errno.h>
	38	#include <ctype.h>
	39	#include <stdio.h>
	40	#include <stdlib.h>
	41	#include <string.h>
	42	#include "hexdump.h"
	43
fd6b7a7f	44	static void doskip(char *, int);
22853e4a	45	static u_char *get(void);
fd6b7a7f KZ	46
fd6b7a7f KZ	47	#ifndef MIN
6dbe3af9 KZ	48	#define MIN(a,b) ((a)<(b)?(a):(b))
	49	#endif
	50
	51	enum _vflag vflag = FIRST;
	52
	53	static off_t address; /* address/offset in stream */
	54	static off_t eaddress; /* end address */
	55	static off_t savaddress; /* saved address/offset in stream */
	56
	57	#define PRINT { \
	58	switch(pr->flags) { \
	59	case F_ADDRESS: \
	60	(void)printf(pr->fmt, address); \
	61	break; \
	62	case F_BPAD: \
	63	(void)printf(pr->fmt, ""); \
	64	break; \
	65	case F_C: \
	66	conv_c(pr, bp); \
	67	break; \
	68	case F_CHAR: \
	69	(void)printf(pr->fmt, *bp); \
	70	break; \
	71	case F_DBL: { \
	72	double dval; \
	73	float fval; \
	74	switch(pr->bcnt) { \
	75	case 4: \
	76	bcopy((char )bp, (char )&fval, sizeof(fval)); \
	77	(void)printf(pr->fmt, fval); \
	78	break; \
	79	case 8: \
	80	bcopy((char )bp, (char )&dval, sizeof(dval)); \
	81	(void)printf(pr->fmt, dval); \
	82	break; \
	83	} \
	84	break; \
	85	} \
	86	case F_INT: { \
	87	int ival; \
	88	short sval; \
	89	switch(pr->bcnt) { \
	90	case 1: \
	91	(void)printf(pr->fmt, (int)*bp); \
	92	break; \
	93	case 2: \
	94	bcopy((char )bp, (char )&sval, sizeof(sval)); \
	95	(void)printf(pr->fmt, (int)sval); \
	96	break; \
	97	case 4: \
	98	bcopy((char )bp, (char )&ival, sizeof(ival)); \
	99	(void)printf(pr->fmt, ival); \
	100	break; \
	101	} \
	102	break; \
	103	} \
	104	case F_P: \
	105	(void)printf(pr->fmt, isprint(bp) ? bp : '.'); \
	106	break; \
	107	case F_STR: \
	108	(void)printf(pr->fmt, (char *)bp); \
	109	break; \
	110	case F_TEXT: \
	111	(void)printf(pr->fmt); \
112	break; \
113	case F_U: \
114	conv_u(pr, bp); \
115	break; \
116	case F_UINT: { \
117	u_int ival; \
118	u_short sval; \
119	switch(pr->bcnt) { \
120	case 1: \
121	(void)printf(pr->fmt, (u_int)*bp); \
122	break; \
123	case 2: \
124	bcopy((char )bp, (char )&sval, sizeof(sval)); \
125	(void)printf(pr->fmt, (u_int)sval); \
126	break; \
127	case 4: \
128	bcopy((char )bp, (char )&ival, sizeof(ival)); \
129	(void)printf(pr->fmt, ival); \
130	break; \
131	} \
132	break; \
133	} \
134	} \
135	}
136
22853e4a	137	static void bpad(PR *pr)
fd6b7a7f KZ	138	{
	139	static char *spec = " -0+#";
	140	register char p1, p2;
	141
	142	/*
	143	* remove all conversion flags; '-' is the only one valid
	144	* with %s, and it's not useful here.
	145	*/
	146	pr->flags = F_BPAD;
	147	*pr->cchar = 's';
	148	for (p1 = pr->fmt; *p1 != '%'; ++p1);
	149	for (p2 = ++p1; p1 && index(spec, p1); ++p1);
	150	while ((p2++ = p1++) != 0) ;
	151	}
	152
22853e4a	153	void display(void)
6dbe3af9 KZ	154	{
	155	extern FU *endfu;
	156	register FS *fs;
	157	register FU *fu;
	158	register PR *pr;
	159	register int cnt;
	160	register u_char *bp;
	161	off_t saveaddress;
22853e4a	162	u_char savech = 0, *savebp;
6dbe3af9	163
fd6b7a7f	164	while ((bp = get()) != NULL)
6dbe3af9 KZ	165	for (fs = fshead, savebp = bp, saveaddress = address; fs;
	166	fs = fs->nextfs, bp = savebp, address = saveaddress)
	167	for (fu = fs->nextfu; fu; fu = fu->nextfu) {
	168	if (fu->flags&F_IGNORE)
	169	break;
	170	for (cnt = fu->reps; cnt; --cnt)
	171	for (pr = fu->nextpr; pr; address += pr->bcnt,
	172	bp += pr->bcnt, pr = pr->nextpr) {
	173	if (eaddress && address >= eaddress &&
	174	!(pr->flags&(F_TEXT\|F_BPAD)))
	175	bpad(pr);
	176	if (cnt == 1 && pr->nospace) {
	177	savech = *pr->nospace;
	178	*pr->nospace = '\0';
	179	}
	180	PRINT;
	181	if (cnt == 1 && pr->nospace)
	182	*pr->nospace = savech;
	183	}
	184	}
	185	if (endfu) {
	186	/*
	187	* if eaddress not set, error or file size was multiple of
	188	* blocksize, and no partial block ever found.
	189	*/
	190	if (!eaddress) {
	191	if (!address)
	192	return;
	193	eaddress = address;
	194	}
	195	for (pr = endfu->nextpr; pr; pr = pr->nextpr)
	196	switch(pr->flags) {
	197	case F_ADDRESS:
	198	(void)printf(pr->fmt, eaddress);
	199	break;
	200	case F_TEXT:
	201	(void)printf(pr->fmt);
	202	break;
	203	}
	204	}
	205	}
	206
6dbe3af9 KZ	207	static char **_argv;
6dbe3af9 KZ	208
22853e4a KZ	209	static u_char *
22853e4a KZ	210	get(void)
6dbe3af9	211	{
6dbe3af9 KZ	212	extern int length;
	213	static int ateof = 1;
	214	static u_char curp, savp;
	215	register int n;
	216	int need, nread;
	217	u_char *tmpp;
	218
	219	if (!curp) {
	220	curp = (u_char *)emalloc(blocksize);
	221	savp = (u_char *)emalloc(blocksize);
	222	} else {
	223	tmpp = curp;
	224	curp = savp;
	225	savp = tmpp;
	226	address = savaddress += blocksize;
	227	}
	228	for (need = blocksize, nread = 0;;) {
	229	/*
	230	* if read the right number of bytes, or at EOF for one file,
	231	* and no other files are available, zero-pad the rest of the
	232	* block and set the end flag.
	233	*/
fd6b7a7f	234	if (!length \|\| (ateof && !next((char **)NULL))) {
6dbe3af9 KZ	235	if (need == blocksize)
	236	return((u_char *)NULL);
	237	if (vflag != ALL && !bcmp(curp, savp, nread)) {
	238	if (vflag != DUP)
	239	(void)printf("*\n");
	240	return((u_char *)NULL);
	241	}
	242	bzero((char *)curp + nread, need);
	243	eaddress = address + nread;
	244	return(curp);
	245	}
	246	n = fread((char *)curp + nread, sizeof(u_char),
	247	length == -1 ? need : MIN(length, need), stdin);
	248	if (!n) {
	249	if (ferror(stdin))
	250	(void)fprintf(stderr, "hexdump: %s: %s\n",
	251	_argv[-1], strerror(errno));
	252	ateof = 1;
	253	continue;
	254	}
	255	ateof = 0;
	256	if (length != -1)
	257	length -= n;
	258	if (!(need -= n)) {
	259	if (vflag == ALL \|\| vflag == FIRST \|\|
	260	bcmp(curp, savp, blocksize)) {
	261	if (vflag == DUP \|\| vflag == FIRST)
	262	vflag = WAIT;
	263	return(curp);
	264	}
	265	if (vflag == WAIT)
	266	(void)printf("*\n");
	267	vflag = DUP;
	268	address = savaddress += blocksize;
	269	need = blocksize;
	270	nread = 0;
	271	}
	272	else
	273	nread += n;
	274	}
	275	}
	276
fd6b7a7f	277	int next(char **argv)
6dbe3af9	278	{
22853e4a	279	extern int exitval;
6dbe3af9 KZ	280	static int done;
	281	int statok;
	282
	283	if (argv) {
	284	_argv = argv;
	285	return(1);
	286	}
	287	for (;;) {
	288	if (*_argv) {
	289	if (!(freopen(*_argv, "r", stdin))) {
	290	(void)fprintf(stderr, "hexdump: %s: %s\n",
	291	*_argv, strerror(errno));
	292	exitval = 1;
	293	++_argv;
	294	continue;
	295	}
	296	statok = done = 1;
	297	} else {
	298	if (done++)
	299	return(0);
	300	statok = 0;
	301	}
	302	if (skip)
	303	doskip(statok ? *_argv : "stdin", statok);
	304	if (*_argv)
	305	++_argv;
	306	if (!skip)
	307	return(1);
	308	}
	309	/* NOTREACHED */
	310	}
	311
fd6b7a7f KZ	312	static void
fd6b7a7f KZ	313	doskip(char *fname, int statok)
6dbe3af9	314	{
6dbe3af9 KZ	315	struct stat sbuf;
	316
	317	if (statok) {
	318	if (fstat(fileno(stdin), &sbuf)) {
	319	(void)fprintf(stderr, "hexdump: %s: %s.\n",
	320	fname, strerror(errno));
	321	exit(1);
	322	}
fd6b7a7f KZ	323	if ( ( ! (S_ISCHR(sbuf.st_mode) \|\|
	324	S_ISBLK(sbuf.st_mode) \|\|
	325	S_ISFIFO(sbuf.st_mode)) ) &&
	326	skip >= sbuf.st_size) {
	327	/* If size valid and skip >= size */
6dbe3af9 KZ	328	skip -= sbuf.st_size;
	329	address += sbuf.st_size;
	330	return;
	331	}
	332	}
	333	if (fseek(stdin, skip, SEEK_SET)) {
	334	(void)fprintf(stderr, "hexdump: %s: %s.\n",
	335	fname, strerror(errno));
	336	exit(1);
	337	}
	338	savaddress = address += skip;
	339	skip = 0;
	340	}
	341
	342	char *
66ee8158	343	emalloc(int sz) {
6dbe3af9 KZ	344	char *p;
6dbe3af9 KZ	345
66ee8158	346	if (!(p = malloc((u_int)sz)))
6dbe3af9	347	nomem();
66ee8158	348	bzero(p, sz);
6dbe3af9 KZ	349	return(p);
	350	}
	351
66ee8158	352	void nomem() {
6dbe3af9 KZ	353	(void)fprintf(stderr, "hexdump: %s.\n", strerror(errno));
	354	exit(1);
	355	}