usr.bin/hexdump/display.c

   1 /*
   2  * Copyright (c) 1989, 1993
   3  *      The Regents of the University of California.  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  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  */
  29
  30 #ifndef lint
  31 #if 0
  32 static char sccsid[] = "@(#)display.c   8.1 (Berkeley) 6/6/93";
  33 #endif
  34 #endif /* not lint */
  35 #include <sys/cdefs.h>
  36 __FBSDID("$FreeBSD$");
  37
  38 #include <sys/param.h>
  39 #include <sys/conf.h>
  40 #include <sys/ioctl.h>
  41 #include <sys/stat.h>
  42
  43 #include <ctype.h>
  44 #include <err.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <unistd.h>
  49 #include "hexdump.h"
  50
  51 enum _vflag vflag = FIRST;
  52
  53 static off_t address;                   /* address/offset in stream */
  54 static off_t eaddress;                  /* end address */
  55
  56 static void print(PR *, u_char *);
  57 static void noseek(void);
  58
  59 void
  60 display(void)
  61 {
  62         FS *fs;
  63         FU *fu;
  64         PR *pr;
  65         int cnt;
  66         u_char *bp;
  67         off_t saveaddress;
  68         u_char savech, *savebp;
  69
  70         savech = 0;
  71         while ((bp = get()))
  72             for (fs = fshead, savebp = bp, saveaddress = address; fs;
  73                 fs = fs->nextfs, bp = savebp, address = saveaddress)
  74                     for (fu = fs->nextfu; fu; fu = fu->nextfu) {
  75                         if (fu->flags&F_IGNORE)
  76                                 break;
  77                         for (cnt = fu->reps; cnt; --cnt)
  78                             for (pr = fu->nextpr; pr; address += pr->bcnt,
  79                                 bp += pr->bcnt, pr = pr->nextpr) {
  80                                     if (eaddress && address >= eaddress &&
  81                                         !(pr->flags & (F_TEXT|F_BPAD)))
  82                                             bpad(pr);
  83                                     if (cnt == 1 && pr->nospace) {
  84                                         savech = *pr->nospace;
  85                                         *pr->nospace = '\0';
  86                                     }
  87                                     print(pr, bp);
  88                                     if (cnt == 1 && pr->nospace)
  89                                         *pr->nospace = savech;
  90                             }
  91                     }
  92         if (endfu) {
  93                 /*
  94                  * If eaddress not set, error or file size was multiple of
  95                  * blocksize, and no partial block ever found.
  96                  */
  97                 if (!eaddress) {
  98                         if (!address)
  99                                 return;
 100                         eaddress = address;
 101                 }
 102                 for (pr = endfu->nextpr; pr; pr = pr->nextpr)
 103                         switch(pr->flags) {
 104                         case F_ADDRESS:
 105                                 (void)printf(pr->fmt, (quad_t)eaddress);
 106                                 break;
 107                         case F_TEXT:
 108                                 (void)printf("%s", pr->fmt);
 109                                 break;
 110                         }
 111         }
 112 }
 113
 114 static void
 115 print(PR *pr, u_char *bp)
 116 {
 117         long double ldbl;
 118            double f8;
 119             float f4;
 120           int16_t s2;
 121            int8_t s8;
 122           int32_t s4;
 123         u_int16_t u2;
 124         u_int32_t u4;
 125         u_int64_t u8;
 126
 127         switch(pr->flags) {
 128         case F_ADDRESS:
 129                 (void)printf(pr->fmt, (quad_t)address);
 130                 break;
 131         case F_BPAD:
 132                 (void)printf(pr->fmt, "");
 133                 break;
 134         case F_C:
 135                 conv_c(pr, bp, eaddress ? eaddress - address :
 136                     blocksize - address % blocksize);
 137                 break;
 138         case F_CHAR:
 139                 (void)printf(pr->fmt, *bp);
 140                 break;
 141         case F_DBL:
 142                 switch(pr->bcnt) {
 143                 case 4:
 144                         bcopy(bp, &f4, sizeof(f4));
 145                         (void)printf(pr->fmt, f4);
 146                         break;
 147                 case 8:
 148                         bcopy(bp, &f8, sizeof(f8));
 149                         (void)printf(pr->fmt, f8);
 150                         break;
 151                 default:
 152                         if (pr->bcnt == sizeof(long double)) {
 153                                 bcopy(bp, &ldbl, sizeof(ldbl));
 154                                 (void)printf(pr->fmt, ldbl);
 155                         }
 156                         break;
 157                 }
 158                 break;
 159         case F_INT:
 160                 switch(pr->bcnt) {
 161                 case 1:
 162                         (void)printf(pr->fmt, (quad_t)(signed char)*bp);
 163                         break;
 164                 case 2:
 165                         bcopy(bp, &s2, sizeof(s2));
 166                         (void)printf(pr->fmt, (quad_t)s2);
 167                         break;
 168                 case 4:
 169                         bcopy(bp, &s4, sizeof(s4));
 170                         (void)printf(pr->fmt, (quad_t)s4);
 171                         break;
 172                 case 8:
 173                         bcopy(bp, &s8, sizeof(s8));
 174                         (void)printf(pr->fmt, s8);
 175                         break;
 176                 }
 177                 break;
 178         case F_P:
 179                 (void)printf(pr->fmt, isprint(*bp) ? *bp : '.');
 180                 break;
 181         case F_STR:
 182                 (void)printf(pr->fmt, (char *)bp);
 183                 break;
 184         case F_TEXT:
 185                 (void)printf("%s", pr->fmt);
 186                 break;
 187         case F_U:
 188                 conv_u(pr, bp);
 189                 break;
 190         case F_UINT:
 191                 switch(pr->bcnt) {
 192                 case 1:
 193                         (void)printf(pr->fmt, (u_quad_t)*bp);
 194                         break;
 195                 case 2:
 196                         bcopy(bp, &u2, sizeof(u2));
 197                         (void)printf(pr->fmt, (u_quad_t)u2);
 198                         break;
 199                 case 4:
 200                         bcopy(bp, &u4, sizeof(u4));
 201                         (void)printf(pr->fmt, (u_quad_t)u4);
 202                         break;
 203                 case 8:
 204                         bcopy(bp, &u8, sizeof(u8));
 205                         (void)printf(pr->fmt, u8);
 206                         break;
 207                 }
 208                 break;
 209         }
 210 }
 211
 212 void
 213 bpad(PR *pr)
 214 {
 215         static char const *spec = " -0+#";
 216         char *p1, *p2;
 217
 218         /*
 219          * Remove all conversion flags; '-' is the only one valid
 220          * with %s, and it's not useful here.
 221          */
 222         pr->flags = F_BPAD;
 223         pr->cchar[0] = 's';
 224         pr->cchar[1] = '\0';
 225         for (p1 = pr->fmt; *p1 != '%'; ++p1);
 226         for (p2 = ++p1; *p1 && strchr(spec, *p1); ++p1);
 227         while ((*p2++ = *p1++));
 228 }
 229
 230 static char **_argv;
 231
 232 u_char *
 233 get(void)
 234 {
 235         static int ateof = 1;
 236         static u_char *curp, *savp;
 237         int n;
 238         int need, nread;
 239         int valid_save = 0;
 240         u_char *tmpp;
 241
 242         if (!curp) {
 243                 if ((curp = calloc(1, blocksize)) == NULL)
 244                         err(1, NULL);
 245                 if ((savp = calloc(1, blocksize)) == NULL)
 246                         err(1, NULL);
 247         } else {
 248                 tmpp = curp;
 249                 curp = savp;
 250                 savp = tmpp;
 251                 address += blocksize;
 252                 valid_save = 1;
 253         }
 254         for (need = blocksize, nread = 0;;) {
 255                 /*
 256                  * if read the right number of bytes, or at EOF for one file,
 257                  * and no other files are available, zero-pad the rest of the
 258                  * block and set the end flag.
 259                  */
 260                 if (!length || (ateof && !next((char **)NULL))) {
 261                         if (odmode && address < skip)
 262                                 errx(1, "cannot skip past end of input");
 263                         if (need == blocksize)
 264                                 return((u_char *)NULL);
 265                         /*
 266                          * XXX bcmp() is not quite right in the presence
 267                          * of multibyte characters.
 268                          */
 269                         if (vflag != ALL &&
 270                             valid_save &&
 271                             bcmp(curp, savp, nread) == 0) {
 272                                 if (vflag != DUP)
 273                                         (void)printf("*\n");
 274                                 return((u_char *)NULL);
 275                         }
 276                         bzero((char *)curp + nread, need);
 277                         eaddress = address + nread;
 278                         return(curp);
 279                 }
 280                 n = fread((char *)curp + nread, sizeof(u_char),
 281                     length == -1 ? need : MIN(length, need), stdin);
 282                 if (!n) {
 283                         if (ferror(stdin))
 284                                 warn("%s", _argv[-1]);
 285                         ateof = 1;
 286                         continue;
 287                 }
 288                 ateof = 0;
 289                 if (length != -1)
 290                         length -= n;
 291                 if (!(need -= n)) {
 292                         /*
 293                          * XXX bcmp() is not quite right in the presence
 294                          * of multibyte characters.
 295                          */
 296                         if (vflag == ALL || vflag == FIRST ||
 297                             valid_save == 0 ||
 298                             bcmp(curp, savp, blocksize) != 0) {
 299                                 if (vflag == DUP || vflag == FIRST)
 300                                         vflag = WAIT;
 301                                 return(curp);
 302                         }
 303                         if (vflag == WAIT)
 304                                 (void)printf("*\n");
 305                         vflag = DUP;
 306                         address += blocksize;
 307                         need = blocksize;
 308                         nread = 0;
 309                 }
 310                 else
 311                         nread += n;
 312         }
 313 }
 314
 315 size_t
 316 peek(u_char *buf, size_t nbytes)
 317 {
 318         size_t n, nread;
 319         int c;
 320
 321         if (length != -1 && nbytes > (unsigned int)length)
 322                 nbytes = length;
 323         nread = 0;
 324         while (nread < nbytes && (c = getchar()) != EOF) {
 325                 *buf++ = c;
 326                 nread++;
 327         }
 328         n = nread;
 329         while (n-- > 0) {
 330                 c = *--buf;
 331                 ungetc(c, stdin);
 332         }
 333         return (nread);
 334 }
 335
 336 int
 337 next(char **argv)
 338 {
 339         static int done;
 340         int statok;
 341
 342         if (argv) {
 343                 _argv = argv;
 344                 return(1);
 345         }
 346         for (;;) {
 347                 if (*_argv) {
 348                         done = 1;
 349                         if (!(freopen(*_argv, "r", stdin))) {
 350                                 warn("%s", *_argv);
 351                                 exitval = 1;
 352                                 ++_argv;
 353                                 continue;
 354                         }
 355                         statok = 1;
 356                 } else {
 357                         if (done++)
 358                                 return(0);
 359                         statok = 0;
 360                 }
 361                 if (skip)
 362                         doskip(statok ? *_argv : "stdin", statok);
 363                 if (*_argv)
 364                         ++_argv;
 365                 if (!skip)
 366                         return(1);
 367         }
 368         /* NOTREACHED */
 369 }
 370
 371 void
 372 doskip(const char *fname, int statok)
 373 {
 374         int type;
 375         struct stat sb;
 376
 377         if (statok) {
 378                 if (fstat(fileno(stdin), &sb))
 379                         err(1, "%s", fname);
 380                 if (S_ISREG(sb.st_mode) && skip > sb.st_size) {
 381                         address += sb.st_size;
 382                         skip -= sb.st_size;
 383                         return;
 384                 }
 385         }
 386         if (!statok || S_ISFIFO(sb.st_mode) || S_ISSOCK(sb.st_mode)) {
 387                 noseek();
 388                 return;
 389         }
 390         if (S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) {
 391                 if (ioctl(fileno(stdin), FIODTYPE, &type))
 392                         err(1, "%s", fname);
 393                 /*
 394                  * Most tape drives don't support seeking,
 395                  * yet fseek() would succeed.
 396                  */
 397                 if (type & D_TAPE) {
 398                         noseek();
 399                         return;
 400                 }
 401         }
 402         if (fseeko(stdin, skip, SEEK_SET)) {
 403                 noseek();
 404                 return;
 405         }
 406         address += skip;
 407         skip = 0;
 408 }
 409
 410 static void
 411 noseek(void)
 412 {
 413         int count;
 414         for (count = 0; count < skip; ++count)
 415                 if (getchar() == EOF)
 416                         break;
 417         address += count;
 418         skip -= count;
 419 }