![[BACK]](/icons/back.gif){kind=icon}
Return to display.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / hexdump|
Return to display.c CVS log | Up to [local] / src / usr.bin / hexdump |
1.1 ! deraadt 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:
! 34: #ifndef lint
! 35: /*static char sccsid[] = "from: @(#)display.c 5.11 (Berkeley) 3/9/91";*/
! 36: static char rcsid[] = "$Id: display.c,v 1.2 1993/08/01 18:14:49 mycroft Exp $";
! 37: #endif /* not lint */
! 38:
! 39: #include <sys/param.h>
! 40: #include <sys/stat.h>
! 41: #include <unistd.h>
! 42: #include <errno.h>
! 43: #include <ctype.h>
! 44: #include <stdio.h>
! 45: #include <stdlib.h>
! 46: #include <string.h>
! 47: #include "hexdump.h"
! 48:
! 49: enum _vflag vflag = FIRST;
! 50:
! 51: static off_t address; /* address/offset in stream */
! 52: static off_t eaddress; /* end address */
! 53: static off_t savaddress; /* saved address/offset in stream */
! 54:
! 55: #define PRINT { \
! 56: switch(pr->flags) { \
! 57: case F_ADDRESS: \
! 58: (void)printf(pr->fmt, address); \
! 59: break; \
! 60: case F_BPAD: \
! 61: (void)printf(pr->fmt, ""); \
! 62: break; \
! 63: case F_C: \
! 64: conv_c(pr, bp); \
! 65: break; \
! 66: case F_CHAR: \
! 67: (void)printf(pr->fmt, *bp); \
! 68: break; \
! 69: case F_DBL: { \
! 70: double dval; \
! 71: float fval; \
! 72: switch(pr->bcnt) { \
! 73: case 4: \
! 74: bcopy((char *)bp, (char *)&fval, sizeof(fval)); \
! 75: (void)printf(pr->fmt, fval); \
! 76: break; \
! 77: case 8: \
! 78: bcopy((char *)bp, (char *)&dval, sizeof(dval)); \
! 79: (void)printf(pr->fmt, dval); \
! 80: break; \
! 81: } \
! 82: break; \
! 83: } \
! 84: case F_INT: { \
! 85: int ival; \
! 86: short sval; \
! 87: switch(pr->bcnt) { \
! 88: case 1: \
! 89: (void)printf(pr->fmt, (int)*bp); \
! 90: break; \
! 91: case 2: \
! 92: bcopy((char *)bp, (char *)&sval, sizeof(sval)); \
! 93: (void)printf(pr->fmt, (int)sval); \
! 94: break; \
! 95: case 4: \
! 96: bcopy((char *)bp, (char *)&ival, sizeof(ival)); \
! 97: (void)printf(pr->fmt, ival); \
! 98: break; \
! 99: } \
! 100: break; \
! 101: } \
! 102: case F_P: \
! 103: (void)printf(pr->fmt, isprint(*bp) ? *bp : '.'); \
! 104: break; \
! 105: case F_STR: \
! 106: (void)printf(pr->fmt, (char *)bp); \
! 107: break; \
! 108: case F_TEXT: \
! 109: (void)printf(pr->fmt); \
! 110: break; \
! 111: case F_U: \
! 112: conv_u(pr, bp); \
! 113: break; \
! 114: case F_UINT: { \
! 115: u_int ival; \
! 116: u_short sval; \
! 117: switch(pr->bcnt) { \
! 118: case 1: \
! 119: (void)printf(pr->fmt, (u_int)*bp); \
! 120: break; \
! 121: case 2: \
! 122: bcopy((char *)bp, (char *)&sval, sizeof(sval)); \
! 123: (void)printf(pr->fmt, (u_int)sval); \
! 124: break; \
! 125: case 4: \
! 126: bcopy((char *)bp, (char *)&ival, sizeof(ival)); \
! 127: (void)printf(pr->fmt, ival); \
! 128: break; \
! 129: } \
! 130: break; \
! 131: } \
! 132: } \
! 133: }
! 134:
! 135: display()
! 136: {
! 137: extern FU *endfu;
! 138: register FS *fs;
! 139: register FU *fu;
! 140: register PR *pr;
! 141: register int cnt;
! 142: register u_char *bp;
! 143: off_t saveaddress;
! 144: u_char savech, *savebp, *get();
! 145:
! 146: while (bp = get())
! 147: for (fs = fshead, savebp = bp, saveaddress = address; fs;
! 148: fs = fs->nextfs, bp = savebp, address = saveaddress)
! 149: for (fu = fs->nextfu; fu; fu = fu->nextfu) {
! 150: if (fu->flags&F_IGNORE)
! 151: break;
! 152: for (cnt = fu->reps; cnt; --cnt)
! 153: for (pr = fu->nextpr; pr; address += pr->bcnt,
! 154: bp += pr->bcnt, pr = pr->nextpr) {
! 155: if (eaddress && address >= eaddress &&
! 156: !(pr->flags&(F_TEXT|F_BPAD)))
! 157: bpad(pr);
! 158: if (cnt == 1 && pr->nospace) {
! 159: savech = *pr->nospace;
! 160: *pr->nospace = '\0';
! 161: }
! 162: PRINT;
! 163: if (cnt == 1 && pr->nospace)
! 164: *pr->nospace = savech;
! 165: }
! 166: }
! 167: if (endfu) {
! 168: /*
! 169: * if eaddress not set, error or file size was multiple of
! 170: * blocksize, and no partial block ever found.
! 171: */
! 172: if (!eaddress) {
! 173: if (!address)
! 174: return;
! 175: eaddress = address;
! 176: }
! 177: for (pr = endfu->nextpr; pr; pr = pr->nextpr)
! 178: switch(pr->flags) {
! 179: case F_ADDRESS:
! 180: (void)printf(pr->fmt, eaddress);
! 181: break;
! 182: case F_TEXT:
! 183: (void)printf(pr->fmt);
! 184: break;
! 185: }
! 186: }
! 187: }
! 188:
! 189: bpad(pr)
! 190: PR *pr;
! 191: {
! 192: static char *spec = " -0+#";
! 193: register char *p1, *p2;
! 194:
! 195: /*
! 196: * remove all conversion flags; '-' is the only one valid
! 197: * with %s, and it's not useful here.
! 198: */
! 199: pr->flags = F_BPAD;
! 200: *pr->cchar = 's';
! 201: for (p1 = pr->fmt; *p1 != '%'; ++p1);
! 202: for (p2 = ++p1; *p1 && index(spec, *p1); ++p1);
! 203: while (*p2++ = *p1++);
! 204: }
! 205:
! 206: static char **_argv;
! 207:
! 208: u_char *
! 209: get()
! 210: {
! 211: extern enum _vflag vflag;
! 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: */
! 234: if (!length || ateof && !next((char **)NULL)) {
! 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:
! 277: extern off_t skip; /* bytes to skip */
! 278:
! 279: next(argv)
! 280: char **argv;
! 281: {
! 282: extern int errno, exitval;
! 283: static int done;
! 284: int statok;
! 285:
! 286: if (argv) {
! 287: _argv = argv;
! 288: return(1);
! 289: }
! 290: for (;;) {
! 291: if (*_argv) {
! 292: if (!(freopen(*_argv, "r", stdin))) {
! 293: (void)fprintf(stderr, "hexdump: %s: %s\n",
! 294: *_argv, strerror(errno));
! 295: exitval = 1;
! 296: ++_argv;
! 297: continue;
! 298: }
! 299: statok = done = 1;
! 300: } else {
! 301: if (done++)
! 302: return(0);
! 303: statok = 0;
! 304: }
! 305: if (skip)
! 306: doskip(statok ? *_argv : "stdin", statok);
! 307: if (*_argv)
! 308: ++_argv;
! 309: if (!skip)
! 310: return(1);
! 311: }
! 312: /* NOTREACHED */
! 313: }
! 314:
! 315: doskip(fname, statok)
! 316: char *fname;
! 317: int statok;
! 318: {
! 319: extern int errno;
! 320: struct stat sbuf;
! 321:
! 322: if (statok) {
! 323: if (fstat(fileno(stdin), &sbuf)) {
! 324: (void)fprintf(stderr, "hexdump: %s: %s.\n",
! 325: fname, strerror(errno));
! 326: exit(1);
! 327: }
! 328: if (skip >= sbuf.st_size) {
! 329: skip -= sbuf.st_size;
! 330: address += sbuf.st_size;
! 331: return;
! 332: }
! 333: }
! 334: if (fseek(stdin, skip, SEEK_SET)) {
! 335: (void)fprintf(stderr, "hexdump: %s: %s.\n",
! 336: fname, strerror(errno));
! 337: exit(1);
! 338: }
! 339: savaddress = address += skip;
! 340: skip = 0;
! 341: }
! 342:
! 343: char *
! 344: emalloc(size)
! 345: int size;
! 346: {
! 347: char *p;
! 348:
! 349: if (!(p = malloc((u_int)size)))
! 350: nomem();
! 351: bzero(p, size);
! 352: return(p);
! 353: }
! 354:
! 355: nomem()
! 356: {
! 357: extern int errno;
! 358:
! 359: (void)fprintf(stderr, "hexdump: %s.\n", strerror(errno));
! 360: exit(1);
! 361: }