| /* dumpsexp.c - Dump S-expressions. |
| * Copyright (C) 2007, 2010 Free Software Foundation, Inc. |
| * |
| * This program is free software; you can redistribute it and/or modify |
| * it under the terms of the GNU General Public License as published |
| * by the Free Software Foundation; either version 3 of the License, |
| * or (at your option) any later version. |
| * |
| * This program is distributed in the hope that it will be useful, but |
| * WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * General Public License for more details. |
| * |
| * You should have received a copy of the GNU General Public License |
| * along with this program; if not, see <http://www.gnu.org/licenses/>. |
| */ |
| |
| #include <config.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <stdlib.h> |
| #include <assert.h> |
| #include <stdarg.h> |
| #include <errno.h> |
| /* For a native WindowsCE binary we need to include gpg-error.h to |
| provide a replacement for strerror. */ |
| #ifdef __MINGW32CE__ |
| # include <gpg-error.h> |
| #endif |
| |
| #define PGM "dumpsexp" |
| #define MYVERSION_LINE PGM " (Libgcrypt) " VERSION |
| #define BUGREPORT_LINE "\nReport bugs to <bug-libgcrypt@gnupg.org>.\n" |
| |
| |
| static int verbose; /* Verbose mode. */ |
| static int decimal; /* Print addresses in decimal. */ |
| static int assume_hex; /* Assume input is hexencoded. */ |
| static int advanced; /* Advanced format output. */ |
| |
| static void |
| print_version (int with_help) |
| { |
| fputs (MYVERSION_LINE "\n" |
| "Copyright (C) 2010 Free Software Foundation, Inc.\n" |
| "License GPLv3+: GNU GPL version 3 or later " |
| "<http://gnu.org/licenses/gpl.html>\n" |
| "This is free software: you are free to change and redistribute it.\n" |
| "There is NO WARRANTY, to the extent permitted by law.\n", |
| stdout); |
| |
| if (with_help) |
| fputs ("\n" |
| "Usage: " PGM " [OPTIONS] [file]\n" |
| "Debug tool for S-expressions\n" |
| "\n" |
| " --decimal Print offsets using decimal notation\n" |
| " --assume-hex Assume input is a hex dump\n" |
| " --advanced Print file in advanced format\n" |
| " --verbose Show what we are doing\n" |
| " --version Print version of the program and exit\n" |
| " --help Display this help and exit\n" |
| BUGREPORT_LINE, stdout ); |
| |
| exit (0); |
| } |
| |
| static int |
| print_usage (void) |
| { |
| fputs ("usage: " PGM " [OPTIONS] NBYTES\n", stderr); |
| fputs (" (use --help to display options)\n", stderr); |
| exit (1); |
| } |
| |
| |
| #define space_p(a) ((a)==' ' || (a)=='\n' || (a)=='\r' || (a)=='\t') |
| #define digit_p(a) ((a) >= '0' && (a) <= '9') |
| #define octdigit_p(a) ((a) >= '0' && (a) <= '7') |
| #define alpha_p(a) ( ((a) >= 'A' && (a) <= 'Z') \ |
| || ((a) >= 'a' && (a) <= 'z')) |
| #define hexdigit_p(a) (digit_p (a) \ |
| || ((a) >= 'A' && (a) <= 'F') \ |
| || ((a) >= 'a' && (a) <= 'f')) |
| #define xtoi_1(a) ((a) <= '9'? ((a)- '0'): \ |
| (a) <= 'F'? ((a)-'A'+10):((a)-'a'+10)) |
| |
| |
| /* Return true if P points to a byte containing a whitespace according |
| to the S-expressions definition. */ |
| static inline int |
| whitespace_p (int c) |
| { |
| switch (c) |
| { |
| case ' ': case '\t': case '\v': case '\f': case '\r': case '\n': return 1; |
| default: return 0; |
| } |
| } |
| |
| static void |
| logit (const char *format, ...) |
| { |
| va_list arg_ptr; |
| |
| va_start (arg_ptr, format) ; |
| fputs (PGM ": ", stderr); |
| vfprintf (stderr, format, arg_ptr); |
| putc ('\n', stderr); |
| va_end (arg_ptr); |
| } |
| |
| /* The raw data buffer and its current length */ |
| static unsigned char databuffer[16]; |
| static int databufferlen; |
| /* The number of bytes in databuffer which should be skipped at a flush. */ |
| static int skipdatabufferlen; |
| /* The number of raw bytes printed on the last line. */ |
| static int nbytesprinted; |
| /* The file offset of the current data buffer . */ |
| static unsigned long databufferoffset; |
| |
| |
| |
| static int |
| my_getc (FILE *fp) |
| { |
| int c1, c2; |
| |
| if (!assume_hex) |
| return getc (fp); |
| |
| while ( (c1=getc (fp)) != EOF && space_p (c1) ) |
| ; |
| if (c1 == EOF) |
| return EOF; |
| |
| if (!hexdigit_p (c1)) |
| { |
| logit ("non hex-digit encountered\n"); |
| return EOF; |
| } |
| |
| while ( (c2=getc (fp)) != EOF && space_p (c2) ) |
| ; |
| if (c2 == EOF) |
| { |
| logit ("error reading second hex nibble\n"); |
| return EOF; |
| } |
| if (!hexdigit_p (c2)) |
| { |
| logit ("second hex nibble is not a hex-digit\n"); |
| return EOF; |
| } |
| return xtoi_1 (c1) * 16 + xtoi_1 (c2); |
| } |
| |
| |
| |
| |
| |
| /* Flush the raw data buffer. */ |
| static void |
| flushdatabuffer (void) |
| { |
| int i; |
| |
| if (!databufferlen) |
| return; |
| nbytesprinted = 0; |
| if (decimal) |
| printf ("%08lu ", databufferoffset); |
| else |
| printf ("%08lx ", databufferoffset); |
| for (i=0; i < databufferlen; i++) |
| { |
| if (i == 8) |
| putchar (' '); |
| if (i < skipdatabufferlen) |
| fputs (" ", stdout); |
| else |
| { |
| printf (" %02x", databuffer[i]); |
| databufferoffset++; |
| } |
| nbytesprinted++; |
| } |
| for (; i < sizeof (databuffer); i++) |
| { |
| if (i == 8) |
| putchar (' '); |
| fputs (" ", stdout); |
| } |
| fputs (" |", stdout); |
| for (i=0; i < databufferlen; i++) |
| { |
| if (i < skipdatabufferlen) |
| putchar (' '); |
| else if (databuffer[i] >= ' ' && databuffer[i] <= '~' |
| && databuffer[i] != '|') |
| putchar (databuffer[i]); |
| else |
| putchar ('.'); |
| } |
| putchar ('|'); |
| putchar ('\n'); |
| databufferlen = 0; |
| skipdatabufferlen = 0; |
| } |
| |
| |
| /* Add C to the raw data buffer and flush as needed. */ |
| static void |
| addrawdata (int c) |
| { |
| if ( databufferlen >= sizeof databuffer ) |
| flushdatabuffer (); |
| databuffer[databufferlen++] = c; |
| } |
| |
| |
| static void |
| printcursor (int both) |
| { |
| int i; |
| |
| flushdatabuffer (); |
| printf ("%8s ", ""); |
| for (i=0; i < sizeof (databuffer); i++) |
| { |
| if (i == 8) |
| putchar (' '); |
| if (i+1 == nbytesprinted) |
| { |
| fputs (" ^ ", stdout); |
| if (!both) |
| break; |
| } |
| else |
| fputs (" ", stdout); |
| } |
| if (both) |
| { |
| fputs (" ", stdout); |
| for (i=0; i < nbytesprinted-1; i++) |
| putchar (' '); |
| putchar ('^'); |
| } |
| databufferlen = skipdatabufferlen = nbytesprinted; |
| } |
| |
| static void |
| printerr (const char *text) |
| { |
| printcursor (1); |
| printf ("\n Error: %s\n", text); |
| } |
| |
| static void |
| printctl (const char *text) |
| { |
| if (verbose && !advanced) |
| { |
| printcursor (0); |
| printf ("%s\n", text); |
| } |
| } |
| |
| static void |
| printchr (int c) |
| { |
| putchar (c); |
| } |
| |
| /* static void */ |
| /* printhex (int c) */ |
| /* { */ |
| /* printf ("\\x%02x", c); */ |
| /* } */ |
| |
| |
| #if 0 |
| /**************** |
| * Print SEXP to buffer using the MODE. Returns the length of the |
| * SEXP in buffer or 0 if the buffer is too short (We have at least an |
| * empty list consisting of 2 bytes). If a buffer of NULL is provided, |
| * the required length is returned. |
| */ |
| size_t |
| gcry_sexp_sprint (const gcry_sexp_t list, |
| void *buffer, size_t maxlength ) |
| { |
| static unsigned char empty[3] = { ST_OPEN, ST_CLOSE, ST_STOP }; |
| const unsigned char *s; |
| char *d; |
| DATALEN n; |
| char numbuf[20]; |
| int i, indent = 0; |
| |
| s = list? list->d : empty; |
| d = buffer; |
| while ( *s != ST_STOP ) |
| { |
| switch ( *s ) |
| { |
| case ST_OPEN: |
| s++; |
| if (indent) |
| putchar ('\n'); |
| for (i=0; i < indent; i++) |
| putchar (' '); |
| putchar ('('); |
| indent++; |
| break; |
| case ST_CLOSE: |
| s++; |
| putchar (')'); |
| indent--; |
| if (*s != ST_OPEN && *s != ST_STOP) |
| { |
| putchar ('\n'); |
| for (i=0; i < indent; i++) |
| putchar (' '); |
| } |
| break; |
| case ST_DATA: |
| s++; |
| memcpy (&n, s, sizeof n); |
| s += sizeof n; |
| { |
| int type; |
| size_t nn; |
| |
| switch ( (type=suitable_encoding (s, n))) |
| { |
| case 1: nn = convert_to_string (s, n, NULL); break; |
| case 2: nn = convert_to_token (s, n, NULL); break; |
| default: nn = convert_to_hex (s, n, NULL); break; |
| } |
| switch (type) |
| { |
| case 1: convert_to_string (s, n, d); break; |
| case 2: convert_to_token (s, n, d); break; |
| default: convert_to_hex (s, n, d); break; |
| } |
| d += nn; |
| if (s[n] != ST_CLOSE) |
| putchar (' '); |
| } |
| else |
| { |
| snprintf (numbuf, sizeof numbuf, "%u:", (unsigned int)n ); |
| d = stpcpy (d, numbuf); |
| memcpy (d, s, n); |
| d += n; |
| } |
| s += n; |
| break; |
| default: |
| BUG (); |
| } |
| } |
| putchar ('\n'); |
| return len; |
| } |
| #endif |
| |
| |
| /* Prepare for saving a chunk of data. */ |
| static void |
| init_data (void) |
| { |
| |
| } |
| |
| /* Push C on the current data chunk. */ |
| static void |
| push_data (int c) |
| { |
| (void)c; |
| } |
| |
| /* Flush and thus print the current data chunk. */ |
| static void |
| flush_data (void) |
| { |
| |
| } |
| |
| |
| /* Returns 0 on success. */ |
| static int |
| parse_and_print (FILE *fp) |
| { |
| static const char tokenchars[] = |
| "abcdefghijklmnopqrstuvwxyz" |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZ" |
| "0123456789-./_:*+="; |
| int c; |
| int level = 0; |
| int tokenc = 0; |
| int hexcount = 0; |
| int disphint = 0; |
| unsigned long datalen = 0; |
| char quote_buf[10]; |
| int quote_idx = 0; |
| enum |
| { |
| INIT_STATE = 0, IN_NUMBER, PRE_DATA, IN_DATA, IN_STRING, |
| IN_ESCAPE, IN_OCT_ESC, IN_HEX_ESC, |
| CR_ESC, LF_ESC, IN_HEXFMT, IN_BASE64 |
| } |
| state = INIT_STATE; |
| |
| |
| while ((c = my_getc (fp)) != EOF ) |
| { |
| addrawdata (c); |
| switch (state) |
| { |
| case INIT_STATE: |
| if (tokenc) |
| { |
| if (strchr (tokenchars, c)) |
| { |
| printchr (c); |
| continue; |
| } |
| tokenc = 0; |
| } |
| parse_init_state: |
| if (c == '(') |
| { |
| if (disphint) |
| { |
| printerr ("unmatched display hint"); |
| disphint = 0; |
| } |
| printctl ("open"); |
| level++; |
| } |
| else if (c == ')') |
| { |
| if (disphint) |
| { |
| printerr ("unmatched display hint"); |
| disphint = 0; |
| } |
| printctl ("close"); |
| level--; |
| } |
| else if (c == '\"') |
| { |
| state = IN_STRING; |
| printctl ("beginstring"); |
| init_data (); |
| } |
| else if (c == '#') |
| { |
| state = IN_HEXFMT; |
| hexcount = 0; |
| printctl ("beginhex"); |
| init_data (); |
| } |
| else if (c == '|') |
| { |
| state = IN_BASE64; |
| printctl ("beginbase64"); |
| init_data (); |
| } |
| else if (c == '[') |
| { |
| if (disphint) |
| printerr ("nested display hint"); |
| disphint = c; |
| } |
| else if (c == ']') |
| { |
| if (!disphint) |
| printerr ("no open display hint"); |
| disphint = 0; |
| } |
| else if (c >= '0' && c <= '9') |
| { |
| if (c == '0') |
| printerr ("zero prefixed length"); |
| state = IN_NUMBER; |
| datalen = (c - '0'); |
| } |
| else if (strchr (tokenchars, c)) |
| { |
| printchr (c); |
| tokenc = c; |
| } |
| else if (whitespace_p (c)) |
| ; |
| else if (c == '{') |
| { |
| printerr ("rescanning is not supported"); |
| } |
| else if (c == '&' || c == '\\') |
| { |
| printerr ("reserved punctuation detected"); |
| } |
| else |
| { |
| printerr ("bad character detected"); |
| } |
| break; |
| |
| case IN_NUMBER: |
| if (digit_p (c)) |
| { |
| unsigned long tmp = datalen * 10 + (c - '0'); |
| if (tmp < datalen) |
| { |
| printerr ("overflow in data length"); |
| state = INIT_STATE; |
| datalen = 0; |
| } |
| else |
| datalen = tmp; |
| } |
| else if (c == ':') |
| { |
| if (!datalen) |
| { |
| printerr ("no data length"); |
| state = INIT_STATE; |
| } |
| else |
| state = PRE_DATA; |
| } |
| else if (c == '\"' || c == '#' || c == '|' ) |
| { |
| /* We ignore the optional length and divert to the init |
| state parser code. */ |
| goto parse_init_state; |
| } |
| else |
| printerr ("invalid length specification"); |
| break; |
| |
| case PRE_DATA: |
| state = IN_DATA; |
| printctl ("begindata"); |
| init_data (); |
| case IN_DATA: |
| if (datalen) |
| { |
| push_data (c); |
| datalen--; |
| } |
| if (!datalen) |
| { |
| state = INIT_STATE; |
| printctl ("enddata"); |
| flush_data (); |
| } |
| break; |
| |
| case IN_STRING: |
| if (c == '\"') |
| { |
| printctl ("endstring"); |
| flush_data (); |
| state = INIT_STATE; |
| } |
| else if (c == '\\') |
| state = IN_ESCAPE; |
| else |
| push_data (c); |
| break; |
| |
| case IN_ESCAPE: |
| switch (c) |
| { |
| case 'b': push_data ('\b'); state = IN_STRING; break; |
| case 't': push_data ('\t'); state = IN_STRING; break; |
| case 'v': push_data ('\v'); state = IN_STRING; break; |
| case 'n': push_data ('\n'); state = IN_STRING; break; |
| case 'f': push_data ('\f'); state = IN_STRING; break; |
| case 'r': push_data ('\r'); state = IN_STRING; break; |
| case '"': push_data ('"'); state = IN_STRING; break; |
| case '\'': push_data ('\''); state = IN_STRING; break; |
| case '\\': push_data ('\\'); state = IN_STRING; break; |
| |
| case '0': case '1': case '2': case '3': case '4': |
| case '5': case '6': case '7': |
| state = IN_OCT_ESC; |
| quote_idx = 0; |
| quote_buf[quote_idx++] = c; |
| break; |
| |
| case 'x': |
| state = IN_HEX_ESC; |
| quote_idx = 0; |
| break; |
| |
| case '\r': |
| state = CR_ESC; |
| break; |
| |
| case '\n': |
| state = LF_ESC; |
| break; |
| |
| default: |
| printerr ("invalid escape sequence"); |
| state = IN_STRING; |
| break; |
| } |
| break; |
| |
| case IN_OCT_ESC: |
| if (quote_idx < 3 && strchr ("01234567", c)) |
| { |
| quote_buf[quote_idx++] = c; |
| if (quote_idx == 3) |
| { |
| push_data ((unsigned int)quote_buf[0] * 8 * 8 |
| + (unsigned int)quote_buf[1] * 8 |
| + (unsigned int)quote_buf[2]); |
| state = IN_STRING; |
| } |
| } |
| else |
| state = IN_STRING; |
| break; |
| case IN_HEX_ESC: |
| if (quote_idx < 2 && strchr ("0123456789abcdefABCDEF", c)) |
| { |
| quote_buf[quote_idx++] = c; |
| if (quote_idx == 2) |
| { |
| push_data (xtoi_1 (quote_buf[0]) * 16 |
| + xtoi_1 (quote_buf[1])); |
| state = IN_STRING; |
| } |
| } |
| else |
| state = IN_STRING; |
| break; |
| case CR_ESC: |
| state = IN_STRING; |
| break; |
| case LF_ESC: |
| state = IN_STRING; |
| break; |
| |
| case IN_HEXFMT: |
| if (hexdigit_p (c)) |
| { |
| push_data (c); |
| hexcount++; |
| } |
| else if (c == '#') |
| { |
| if ((hexcount & 1)) |
| printerr ("odd number of hex digits"); |
| printctl ("endhex"); |
| flush_data (); |
| state = INIT_STATE; |
| } |
| else if (!whitespace_p (c)) |
| printerr ("bad hex character"); |
| break; |
| |
| case IN_BASE64: |
| if (c == '|') |
| { |
| printctl ("endbase64"); |
| flush_data (); |
| state = INIT_STATE; |
| } |
| else |
| push_data (c); |
| break; |
| |
| default: |
| logit ("invalid state %d detected", state); |
| exit (1); |
| } |
| } |
| flushdatabuffer (); |
| if (ferror (fp)) |
| { |
| logit ("error reading input: %s\n", strerror (errno)); |
| return -1; |
| } |
| return 0; |
| } |
| |
| |
| |
| int |
| main (int argc, char **argv) |
| { |
| int rc; |
| |
| if (argc) |
| { |
| argc--; argv++; |
| } |
| while (argc && **argv == '-' && (*argv)[1] == '-') |
| { |
| if (!(*argv)[2]) |
| { |
| argc--; argv++; |
| break; |
| } |
| else if (!strcmp (*argv, "--version")) |
| print_version (0); |
| else if (!strcmp (*argv, "--help")) |
| print_version (1); |
| else if (!strcmp (*argv, "--verbose")) |
| { |
| argc--; argv++; |
| verbose = 1; |
| } |
| else if (!strcmp (*argv, "--decimal")) |
| { |
| argc--; argv++; |
| decimal = 1; |
| } |
| else if (!strcmp (*argv, "--assume-hex")) |
| { |
| argc--; argv++; |
| assume_hex = 1; |
| } |
| else if (!strcmp (*argv, "--advanced")) |
| { |
| argc--; argv++; |
| advanced = 1; |
| } |
| else |
| print_usage (); |
| } |
| |
| if (!argc) |
| { |
| rc = parse_and_print (stdin); |
| } |
| else |
| { |
| rc = 0; |
| for (; argc; argv++, argc--) |
| { |
| FILE *fp = fopen (*argv, "rb"); |
| if (!fp) |
| { |
| logit ("can't open `%s': %s\n", *argv, strerror (errno)); |
| rc = 1; |
| } |
| else |
| { |
| if (parse_and_print (fp)) |
| rc = 1; |
| fclose (fp); |
| } |
| } |
| } |
| |
| return !!rc; |
| } |
