hexdump/conv.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  * 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 const char sccsid[] = "@(#)conv.c        8.1 (Berkeley) 6/6/93";
  36 #endif /* not lint */
  37 #include <sys/cdefs.h>
  38 __FBSDID("$FreeBSD: src/usr.bin/hexdump/conv.c,v 1.8 2004/07/16 11:07:07 johan Exp $");
  39
  40 #include <sys/types.h>
  41
  42 #include <assert.h>
  43 #include <ctype.h>
  44 #include <limits.h>
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <string.h>
  48 #include <wchar.h>
  49 #include <wctype.h>
  50 #include "hexdump.h"
  51
  52 void
  53 conv_c(PR *pr, u_char *p, size_t bufsize)
  54 {
  55         char buf[10];
  56         char const *str;
  57         wchar_t wc;
  58         size_t clen, oclen;
  59         int converr, pad, width;
  60         char peekbuf[MB_LEN_MAX];
  61
  62         if (pr->mbleft > 0) {
  63                 str = "**";
  64                 pr->mbleft--;
  65                 goto strpr;
  66         }
  67
  68         switch(*p) {
  69         case '\0':
  70                 str = "\\0";
  71                 goto strpr;
  72         /* case '\a': */
  73         case '\007':
  74                 str = "\\a";
  75                 goto strpr;
  76         case '\b':
  77                 str = "\\b";
  78                 goto strpr;
  79         case '\f':
  80                 str = "\\f";
  81                 goto strpr;
  82         case '\n':
  83                 str = "\\n";
  84                 goto strpr;
  85         case '\r':
  86                 str = "\\r";
  87                 goto strpr;
  88         case '\t':
  89                 str = "\\t";
  90                 goto strpr;
  91         case '\v':
  92                 str = "\\v";
  93                 goto strpr;
  94         default:
  95                 break;
  96         }
  97         /*
  98          * Multibyte characters are disabled for hexdump(1) for backwards
  99          * compatibility and consistency (none of its other output formats
 100          * recognize them correctly).
 101          */
 102         converr = 0;
 103         if (odmode && MB_CUR_MAX > 1) {
 104                 oclen = 0;
 105 retry:
 106                 clen = mbrtowc(&wc, (const char *)p, bufsize, &pr->mbstate);
 107                 if (clen == 0)
 108                         clen = 1;
 109                 else if (clen == (size_t)-1 || (clen == (size_t)-2 &&
 110                     buf == peekbuf)) {
 111                         memset(&pr->mbstate, 0, sizeof(pr->mbstate));
 112                         wc = *p;
 113                         clen = 1;
 114                         converr = 1;
 115                 } else if (clen == (size_t)-2) {
 116                         /*
 117                          * Incomplete character; peek ahead and see if we
 118                          * can complete it.
 119                          */
 120                         oclen = bufsize;
 121                         bufsize = peek(p = (u_char *)peekbuf, MB_CUR_MAX);
 122                         goto retry;
 123                 }
 124                 clen += oclen;
 125         } else {
 126                 wc = *p;
 127                 clen = 1;
 128         }
 129         if (!converr && iswprint(wc)) {
 130                 if (!odmode) {
 131                         *pr->cchar = 'c';
 132                         (void)printf(pr->fmt, (int)wc);
 133                 } else {
 134                         *pr->cchar = 'C';
 135                         assert(strcmp(pr->fmt, "%3C") == 0);
 136                         width = wcwidth(wc);
 137                         assert(width > 0);
 138                         pad = 3 - width;
 139                         if (pad < 0)
 140                                 pad = 0;
 141                         (void)printf("%*s%C", pad, "", wc);
 142                         pr->mbleft = clen - 1;
 143                 }
 144         } else {
 145                 (void)sprintf(buf, "%03o", (int)*p);
 146                 str = buf;
 147 strpr:          *pr->cchar = 's';
 148                 (void)printf(pr->fmt, str);
 149         }
 150 }
 151
 152 void
 153 conv_u(PR *pr, u_char *p)
 154 {
 155         static char const * list[] = {
 156                 "nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
 157                  "bs",  "ht",  "lf",  "vt",  "ff",  "cr",  "so",  "si",
 158                 "dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
 159                 "can",  "em", "sub", "esc",  "fs",  "gs",  "rs",  "us",
 160         };
 161
 162                                                 /* od used nl, not lf */
 163         if (*p <= 0x1f) {
 164                 *pr->cchar = 's';
 165                 if (odmode && *p == 0x0a)
 166                         (void)printf(pr->fmt, "nl");
 167                 else
 168                         (void)printf(pr->fmt, list[*p]);
 169         } else if (*p == 0x7f) {
 170                 *pr->cchar = 's';
 171                 (void)printf(pr->fmt, "del");
 172         } else if (odmode && *p == 0x20) {      /* od replaced space with sp */
 173                 *pr->cchar = 's';
 174                 (void)printf(pr->fmt, " sp");
 175         } else if (isprint(*p)) {
 176                 *pr->cchar = 'c';
 177                 (void)printf(pr->fmt, *p);
 178         } else {
 179                 *pr->cchar = 'x';
 180                 (void)printf(pr->fmt, (int)*p);
 181         }
 182 }