diff options
Diffstat (limited to 'libbb/dump.c')
-rw-r--r-- | libbb/dump.c | 839 |
1 files changed, 839 insertions, 0 deletions
diff --git a/libbb/dump.c b/libbb/dump.c new file mode 100644 index 0000000..e7722de --- /dev/null +++ b/libbb/dump.c @@ -0,0 +1,839 @@ +/* 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" + +static const char index_str[] ALIGN1 = ".#-+ 0123456789"; + +static const char size_conv_str[] ALIGN1 = +"\x1\x4\x4\x4\x4\x4\x4\x8\x8\x8\x8\010cdiouxXeEfgG"; + +static const char lcc[] ALIGN1 = "diouxX"; + + +typedef struct priv_dumper_t { + dumper_t pub; + + char **argv; + FU *endfu; + off_t savaddress; /* saved address/offset in stream */ + off_t eaddress; /* end address */ + off_t address; /* address/offset in stream */ + int blocksize; + smallint exitval; /* final exit value */ + + /* former statics */ + smallint next__done; + smallint get__ateof; // = 1; + unsigned char *get__curp; + unsigned char *get__savp; +} priv_dumper_t; + +dumper_t* FAST_FUNC alloc_dumper(void) +{ + priv_dumper_t *dumper = xzalloc(sizeof(*dumper)); + dumper->pub.dump_length = -1; + dumper->pub.dump_vflag = FIRST; + dumper->get__ateof = 1; + return &dumper->pub; +} + + +static NOINLINE 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; + /* + * 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)) + continue; + } + p = strchr(size_conv_str + 12, *fmt); + if (!p) { + 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(priv_dumper_t *dumper, 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] zalloc 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 through. + */ + + /* skip preceding text and up to the next % sign */ + for (p1 = fmtp; *p1 && *p1 != '%'; ++p1) + continue; + + /* 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; + /* skip to conversion character */ + for (++p1; strchr(index_str, *p1); ++p1) + continue; + } else { + /* skip any special chars, field width */ + while (strchr(index_str + 1, *++p1)) + continue; + if (*p1 == '.' && isdigit(*++p1)) { + sokay = USEPREC; + prec = atoi(p1); + while (isdigit(*++p1)) + continue; + } 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; + e = strchr(lcc, *p1); + if (!e) { + 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': + dumper->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; + //Too early! xrealloc can move pr->fmt! + //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++) + continue; + 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; + } + + pr->cchar = pr->fmt + (p1 - fmtp); + 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 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 = fu->nextfu) { + if (!fu->nextfu && fs->bcnt < dumper->blocksize + && !(fu->flags & F_SETREP) && fu->bcnt + ) { + fu->reps += (dumper->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(priv_dumper_t *dumper, const char *fname, int statok) +{ + struct stat sbuf; + + if (statok) { + if (fstat(STDIN_FILENO, &sbuf)) { + bb_simple_perror_msg_and_die(fname); + } + if (!(S_ISCHR(sbuf.st_mode) || S_ISBLK(sbuf.st_mode) || S_ISFIFO(sbuf.st_mode)) + && dumper->pub.dump_skip >= sbuf.st_size + ) { + /* If bb_dump_size valid and pub.dump_skip >= size */ + dumper->pub.dump_skip -= sbuf.st_size; + dumper->address += sbuf.st_size; + return; + } + } + if (fseek(stdin, dumper->pub.dump_skip, SEEK_SET)) { + bb_simple_perror_msg_and_die(fname); + } + dumper->address += dumper->pub.dump_skip; + dumper->savaddress = dumper->address; + dumper->pub.dump_skip = 0; +} + +static NOINLINE int next(priv_dumper_t *dumper) +{ + int statok; + + for (;;) { + if (*dumper->argv) { + if (!(freopen(*dumper->argv, "r", stdin))) { + bb_simple_perror_msg(*dumper->argv); + dumper->exitval = 1; + ++dumper->argv; + continue; + } + dumper->next__done = statok = 1; + } else { + if (dumper->next__done) + return 0; + dumper->next__done = 1; + statok = 0; + } + if (dumper->pub.dump_skip) + do_skip(dumper, statok ? *dumper->argv : "stdin", statok); + if (*dumper->argv) + ++dumper->argv; + if (!dumper->pub.dump_skip) + return 1; + } + /* NOTREACHED */ +} + +static unsigned char *get(priv_dumper_t *dumper) +{ + int n; + int need, nread; + int blocksize = dumper->blocksize; + + if (!dumper->get__curp) { + dumper->address = (off_t)0; /*DBU:[dave@cray.com] initialize,initialize..*/ + dumper->get__curp = xmalloc(blocksize); + dumper->get__savp = xzalloc(blocksize); /* need to be initialized */ + } else { + unsigned char *tmp = dumper->get__curp; + dumper->get__curp = dumper->get__savp; + dumper->get__savp = tmp; + dumper->savaddress += blocksize; + dumper->address = dumper->savaddress; + } + need = blocksize; + nread = 0; + while (1) { + /* + * 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 (!dumper->pub.dump_length || (dumper->get__ateof && !next(dumper))) { + if (need == blocksize) { + return NULL; + } + if (dumper->pub.dump_vflag != ALL && !memcmp(dumper->get__curp, dumper->get__savp, nread)) { + if (dumper->pub.dump_vflag != DUP) { + puts("*"); + } + return NULL; + } + memset(dumper->get__curp + nread, 0, need); + dumper->eaddress = dumper->address + nread; + return dumper->get__curp; + } + n = fread(dumper->get__curp + nread, sizeof(unsigned char), + dumper->pub.dump_length == -1 ? need : MIN(dumper->pub.dump_length, need), stdin); + if (!n) { + if (ferror(stdin)) { + bb_simple_perror_msg(dumper->argv[-1]); + } + dumper->get__ateof = 1; + continue; + } + dumper->get__ateof = 0; + if (dumper->pub.dump_length != -1) { + dumper->pub.dump_length -= n; + } + need -= n; + if (!need) { + if (dumper->pub.dump_vflag == ALL || dumper->pub.dump_vflag == FIRST + || memcmp(dumper->get__curp, dumper->get__savp, blocksize) + ) { + if (dumper->pub.dump_vflag == DUP || dumper->pub.dump_vflag == FIRST) { + dumper->pub.dump_vflag = WAIT; + } + return dumper->get__curp; + } + if (dumper->pub.dump_vflag == WAIT) { + puts("*"); + } + dumper->pub.dump_vflag = DUP; + dumper->savaddress += blocksize; + dumper->address = dumper->savaddress; + need = 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) + continue; + for (p2 = ++p1; *p1 && strchr(" -0+#", *p1); ++p1) + if (pr->nospace) + pr->nospace--; + while ((*p2++ = *p1++) != 0) + continue; +} + +static const char conv_str[] ALIGN1 = + "\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" + ; + + +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'; + 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[] ALIGN1 = + "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(priv_dumper_t* dumper) +{ + FS *fs; + FU *fu; + PR *pr; + int cnt; + unsigned char *bp, *savebp; + off_t saveaddress; + unsigned char savech = '\0'; + + while ((bp = get(dumper)) != NULL) { + fs = dumper->pub.fshead; + savebp = bp; + saveaddress = dumper->address; + for (; fs; fs = fs->nextfs, bp = savebp, dumper->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; dumper->address += pr->bcnt, + bp += pr->bcnt, pr = pr->nextpr) { + if (dumper->eaddress && dumper->address >= dumper->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) dumper->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(&fval, bp, sizeof(fval)); + printf(pr->fmt, fval); + break; + case 8: + memmove(&dval, 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(&sval, bp, sizeof(sval)); + printf(pr->fmt, (int) sval); + break; + case 4: + memmove(&ival, 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 ival; + unsigned short sval; + + switch (pr->bcnt) { + case 1: + printf(pr->fmt, (unsigned) *bp); + break; + case 2: + memmove(&sval, bp, sizeof(sval)); + printf(pr->fmt, (unsigned) sval); + break; + case 4: + memmove(&ival, bp, sizeof(ival)); + printf(pr->fmt, ival); + break; + } + break; + } + } + if (cnt == 1 && pr->nospace) { + *pr->nospace = savech; + } + } + } + } + } + } + if (dumper->endfu) { + /* + * if eaddress not set, error or file size was multiple + * of blocksize, and no partial block ever found. + */ + if (!dumper->eaddress) { + if (!dumper->address) { + return; + } + dumper->eaddress = dumper->address; + } + for (pr = dumper->endfu->nextpr; pr; pr = pr->nextpr) { + switch (pr->flags) { + case F_ADDRESS: + printf(pr->fmt, (unsigned) dumper->eaddress); + break; + case F_TEXT: + printf(pr->fmt); + break; + } + } + } +} + +#define dumper ((priv_dumper_t*)pub_dumper) +int FAST_FUNC bb_dump_dump(dumper_t *pub_dumper, char **argv) +{ + FS *tfs; + int blocksize; + + /* figure out the data block bb_dump_size */ + blocksize = 0; + tfs = dumper->pub.fshead; + while (tfs) { + tfs->bcnt = bb_dump_size(tfs); + if (blocksize < tfs->bcnt) { + blocksize = tfs->bcnt; + } + tfs = tfs->nextfs; + } + dumper->blocksize = blocksize; + + /* rewrite the rules, do syntax checking */ + for (tfs = dumper->pub.fshead; tfs; tfs = tfs->nextfs) { + rewrite(dumper, tfs); + } + + dumper->argv = argv; + display(dumper); + + return dumper->exitval; +} + +void FAST_FUNC bb_dump_add(dumper_t* pub_dumper, const char *fmt) +{ + const char *p; + char *p1; + char *p2; + FS *tfs; + FU *tfu, **nextfupp; + const char *savep; + + /* start new linked list of format units */ + tfs = xzalloc(sizeof(FS)); /*DBU:[dave@cray.com] start out NULL */ + if (!dumper->pub.fshead) { + dumper->pub.fshead = tfs; + } else { + FS *fslast = dumper->pub.fshead; + while (fslast->nextfs) + fslast = fslast->nextfs; + fslast->nextfs = tfs; + } + nextfupp = &tfs->nextfu; + + /* take the format string and break it up into format units */ + p = fmt; + for (;;) { + p = skip_whitespace(p); + if (!*p) { + break; + } + + /* allocate a new format unit and link it in */ + /* NOSTRICT */ + /* DBU:[dave@cray.com] zalloc so that forward pointers start out NULL */ + tfu = xzalloc(sizeof(FU)); + *nextfupp = tfu; + nextfupp = &tfu->nextfu; + tfu->reps = 1; + + /* if leading digit, repetition count */ + if (isdigit(*p)) { + for (savep = p; isdigit(*p); ++p) + continue; + 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; + /* skip trailing white space */ + p = skip_whitespace(++p); + } + + /* skip slash and trailing white space */ + if (*p == '/') { + p = skip_whitespace(++p); + } + + /* byte count */ + if (isdigit(*p)) { +// TODO: use bb_strtou + savep = p; + while (isdigit(*++p)) + continue; + if (!isspace(*p)) { + bb_error_msg_and_die("bad format {%s}", fmt); + } + tfu->bcnt = atoi(savep); + /* 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 = xstrndup(savep, p - savep); +/* 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. + */ |