mirror of
https://github.com/sheumann/hush.git
synced 2024-09-05 16:28:59 +00:00
1595 lines
40 KiB
C
1595 lines
40 KiB
C
/* od -- dump files in octal and other formats
|
|
Copyright (C) 92, 1995-2004 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 2, 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, write to the Free Software Foundation,
|
|
Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
|
|
|
|
/* Written by Jim Meyering. */
|
|
|
|
/* Busyboxed by Denis Vlasenko
|
|
** Based on od.c from coreutils-5.2.1
|
|
** Top bloat sources:
|
|
** get_lcm 111
|
|
** print_ascii 145
|
|
** format_address_std 159
|
|
** check_and_close 160
|
|
** open_next_file 170
|
|
** write_block 368
|
|
** decode_format_string 1169
|
|
** od_main 2623
|
|
** TODO: get rid of getopt()
|
|
*/
|
|
|
|
#include "busybox.h"
|
|
#include <getopt.h>
|
|
|
|
#define assert(a) ((void)0)
|
|
#define ISPRINT(c) ((c)>=' ')
|
|
|
|
typedef long double longdouble_t;
|
|
typedef unsigned long long ulonglong_t;
|
|
#define xstrtoumax_sfx xstrtoul_sfx
|
|
#define xstrtoumax_range_sfx xstrtoul_range_sfx
|
|
|
|
/* The default number of input bytes per output line. */
|
|
#define DEFAULT_BYTES_PER_BLOCK 16
|
|
|
|
/* The number of decimal digits of precision in a float. */
|
|
#ifndef FLT_DIG
|
|
# define FLT_DIG 7
|
|
#endif
|
|
|
|
/* The number of decimal digits of precision in a double. */
|
|
#ifndef DBL_DIG
|
|
# define DBL_DIG 15
|
|
#endif
|
|
|
|
/* The number of decimal digits of precision in a long double. */
|
|
#ifndef LDBL_DIG
|
|
# define LDBL_DIG DBL_DIG
|
|
#endif
|
|
|
|
enum size_spec {
|
|
NO_SIZE,
|
|
CHAR,
|
|
SHORT,
|
|
INT,
|
|
LONG,
|
|
LONG_LONG,
|
|
/* FIXME: add INTMAX support, too */
|
|
FLOAT_SINGLE,
|
|
FLOAT_DOUBLE,
|
|
FLOAT_LONG_DOUBLE,
|
|
N_SIZE_SPECS
|
|
};
|
|
|
|
enum output_format {
|
|
SIGNED_DECIMAL,
|
|
UNSIGNED_DECIMAL,
|
|
OCTAL,
|
|
HEXADECIMAL,
|
|
FLOATING_POINT,
|
|
NAMED_CHARACTER,
|
|
CHARACTER
|
|
};
|
|
|
|
/* Each output format specification (from '-t spec' or from
|
|
old-style options) is represented by one of these structures. */
|
|
struct tspec {
|
|
enum output_format fmt;
|
|
enum size_spec size;
|
|
void (*print_function) (size_t, const char *, const char *);
|
|
char *fmt_string;
|
|
int hexl_mode_trailer;
|
|
int field_width;
|
|
};
|
|
|
|
/* Convert the number of 8-bit bytes of a binary representation to
|
|
the number of characters (digits + sign if the type is signed)
|
|
required to represent the same quantity in the specified base/type.
|
|
For example, a 32-bit (4-byte) quantity may require a field width
|
|
as wide as the following for these types:
|
|
11 unsigned octal
|
|
11 signed decimal
|
|
10 unsigned decimal
|
|
8 unsigned hexadecimal */
|
|
|
|
static const unsigned char bytes_to_oct_digits[] =
|
|
{0, 3, 6, 8, 11, 14, 16, 19, 22, 25, 27, 30, 32, 35, 38, 41, 43};
|
|
|
|
static const unsigned char bytes_to_signed_dec_digits[] =
|
|
{1, 4, 6, 8, 11, 13, 16, 18, 20, 23, 25, 28, 30, 33, 35, 37, 40};
|
|
|
|
static const unsigned char bytes_to_unsigned_dec_digits[] =
|
|
{0, 3, 5, 8, 10, 13, 15, 17, 20, 22, 25, 27, 29, 32, 34, 37, 39};
|
|
|
|
static const unsigned char bytes_to_hex_digits[] =
|
|
{0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32};
|
|
|
|
/* Convert enum size_spec to the size of the named type. */
|
|
static const signed char width_bytes[] = {
|
|
-1,
|
|
sizeof(char),
|
|
sizeof(short),
|
|
sizeof(int),
|
|
sizeof(long),
|
|
sizeof(ulonglong_t),
|
|
sizeof(float),
|
|
sizeof(double),
|
|
sizeof(longdouble_t)
|
|
};
|
|
|
|
/* Ensure that for each member of 'enum size_spec' there is an
|
|
initializer in the width_bytes array. */
|
|
struct dummy {
|
|
int assert_width_bytes_matches_size_spec_decl
|
|
[sizeof width_bytes / sizeof width_bytes[0] == N_SIZE_SPECS ? 1 : -1];
|
|
};
|
|
|
|
/* Names for some non-printing characters. */
|
|
static const char charname[33][4] = {
|
|
"nul", "soh", "stx", "etx", "eot", "enq", "ack", "bel",
|
|
"bs", "ht", "nl", "vt", "ff", "cr", "so", "si",
|
|
"dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
|
|
"can", "em", "sub", "esc", "fs", "gs", "rs", "us",
|
|
"sp"
|
|
};
|
|
|
|
/* Address base (8, 10 or 16). */
|
|
static int address_base;
|
|
|
|
/* The number of octal digits required to represent the largest
|
|
address value. */
|
|
#define MAX_ADDRESS_LENGTH \
|
|
((sizeof(uintmax_t) * CHAR_BIT + CHAR_BIT - 1) / 3)
|
|
|
|
/* Width of a normal address. */
|
|
static int address_pad_len;
|
|
|
|
static size_t string_min;
|
|
static int flag_dump_strings;
|
|
|
|
/* Non-zero if we should recognize the older non-option arguments
|
|
that specified at most one file and optional arguments specifying
|
|
offset and pseudo-start address. */
|
|
static int traditional;
|
|
|
|
/* Non-zero if an old-style 'pseudo-address' was specified. */
|
|
static int flag_pseudo_start;
|
|
|
|
/* The difference between the old-style pseudo starting address and
|
|
the number of bytes to skip. */
|
|
static uintmax_t pseudo_offset;
|
|
|
|
/* Function that accepts an address and an optional following char,
|
|
and prints the address and char to stdout. */
|
|
static void (*format_address) (uintmax_t, char);
|
|
|
|
/* The number of input bytes to skip before formatting and writing. */
|
|
static uintmax_t n_bytes_to_skip; // = 0;
|
|
|
|
/* When zero, MAX_BYTES_TO_FORMAT and END_OFFSET are ignored, and all
|
|
input is formatted. */
|
|
static int limit_bytes_to_format; // = 0;
|
|
|
|
/* The maximum number of bytes that will be formatted. */
|
|
static uintmax_t max_bytes_to_format;
|
|
|
|
/* The offset of the first byte after the last byte to be formatted. */
|
|
static uintmax_t end_offset;
|
|
|
|
/* When nonzero and two or more consecutive blocks are equal, format
|
|
only the first block and output an asterisk alone on the following
|
|
line to indicate that identical blocks have been elided. */
|
|
static int abbreviate_duplicate_blocks = 1;
|
|
|
|
/* An array of specs describing how to format each input block. */
|
|
static struct tspec *spec;
|
|
|
|
/* The number of format specs. */
|
|
static size_t n_specs;
|
|
|
|
/* The number of input bytes formatted per output line. It must be
|
|
a multiple of the least common multiple of the sizes associated with
|
|
the specified output types. It should be as large as possible, but
|
|
no larger than 16 -- unless specified with the -w option. */
|
|
static size_t bytes_per_block;
|
|
|
|
/* Human-readable representation of *file_list (for error messages).
|
|
It differs from *file_list only when *file_list is "-". */
|
|
static char const *input_filename;
|
|
|
|
/* A NULL-terminated list of the file-arguments from the command line. */
|
|
static char const *const *file_list;
|
|
|
|
/* Initializer for file_list if no file-arguments
|
|
were specified on the command line. */
|
|
static char const *const default_file_list[] = {"-", NULL};
|
|
|
|
/* The input stream associated with the current file. */
|
|
static FILE *in_stream;
|
|
|
|
/* If nonzero, at least one of the files we read was standard input. */
|
|
static int have_read_stdin;
|
|
|
|
#define MAX_INTEGRAL_TYPE_SIZE sizeof(ulonglong_t)
|
|
static unsigned char integral_type_size[MAX_INTEGRAL_TYPE_SIZE + 1];
|
|
|
|
#define MAX_FP_TYPE_SIZE sizeof(longdouble_t)
|
|
static unsigned char fp_type_size[MAX_FP_TYPE_SIZE + 1];
|
|
|
|
|
|
/* For long options that have no equivalent short option, use a
|
|
non-character as a pseudo short option, starting with CHAR_MAX + 1. */
|
|
enum {
|
|
TRADITIONAL_OPTION = CHAR_MAX + 1
|
|
};
|
|
|
|
|
|
static unsigned
|
|
gcd(unsigned u, unsigned v)
|
|
{
|
|
unsigned t;
|
|
while (v != 0) {
|
|
t = u % v;
|
|
u = v;
|
|
v = t;
|
|
}
|
|
return u;
|
|
}
|
|
|
|
/* Compute the least common multiple of U and V. */
|
|
static unsigned
|
|
lcm(unsigned u, unsigned v) {
|
|
unsigned t = gcd(u, v);
|
|
if (t == 0)
|
|
return 0;
|
|
return u * v / t;
|
|
}
|
|
|
|
static void
|
|
print_s_char(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes; i > 0; i--) {
|
|
int tmp = (unsigned) *(unsigned char *) block;
|
|
if (tmp > SCHAR_MAX)
|
|
tmp -= SCHAR_MAX - SCHAR_MIN + 1;
|
|
assert(tmp <= SCHAR_MAX);
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(unsigned char);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_char(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes; i > 0; i--) {
|
|
unsigned tmp = *(unsigned char *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(unsigned char);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_s_short(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(unsigned short); i > 0; i--) {
|
|
int tmp = (unsigned) *(unsigned short *) block;
|
|
if (tmp > SHRT_MAX)
|
|
tmp -= SHRT_MAX - SHRT_MIN + 1;
|
|
assert(tmp <= SHRT_MAX);
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(unsigned short);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_short(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(unsigned short); i > 0; i--) {
|
|
unsigned tmp = *(unsigned short *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(unsigned short);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_int(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(unsigned); i > 0; i--) {
|
|
unsigned tmp = *(unsigned *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(unsigned);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_long(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(unsigned long); i > 0; i--) {
|
|
unsigned long tmp = *(unsigned long *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(unsigned long);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_long_long(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(ulonglong_t); i > 0; i--) {
|
|
ulonglong_t tmp = *(ulonglong_t *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(ulonglong_t);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_float(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(float); i > 0; i--) {
|
|
float tmp = *(float *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(float);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_double(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(double); i > 0; i--) {
|
|
double tmp = *(double *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(double);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_long_double(size_t n_bytes, const char *block, const char *fmt_string)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes / sizeof(longdouble_t); i > 0; i--) {
|
|
longdouble_t tmp = *(longdouble_t *) block;
|
|
printf(fmt_string, tmp);
|
|
block += sizeof(longdouble_t);
|
|
}
|
|
}
|
|
|
|
static void
|
|
dump_hexl_mode_trailer(size_t n_bytes, const char *block)
|
|
{
|
|
size_t i;
|
|
fputs(" >", stdout);
|
|
for (i = n_bytes; i > 0; i--) {
|
|
unsigned c = *(unsigned char *) block;
|
|
unsigned c2 = (ISPRINT(c) ? c : '.');
|
|
putchar(c2);
|
|
block += sizeof(unsigned char);
|
|
}
|
|
putchar('<');
|
|
}
|
|
|
|
static void
|
|
print_named_ascii(size_t n_bytes, const char *block,
|
|
const char *unused_fmt_string ATTRIBUTE_UNUSED)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes; i > 0; i--) {
|
|
unsigned c = *(unsigned char *) block;
|
|
unsigned masked_c = (0x7f & c);
|
|
const char *s;
|
|
char buf[5];
|
|
|
|
if (masked_c == 127)
|
|
s = "del";
|
|
else if (masked_c <= 040)
|
|
s = charname[masked_c];
|
|
else {
|
|
sprintf(buf, " %c", masked_c);
|
|
s = buf;
|
|
}
|
|
|
|
printf(" %3s", s);
|
|
block += sizeof(unsigned char);
|
|
}
|
|
}
|
|
|
|
static void
|
|
print_ascii(size_t n_bytes, const char *block,
|
|
const char *unused_fmt_string ATTRIBUTE_UNUSED)
|
|
{
|
|
size_t i;
|
|
for (i = n_bytes; i > 0; i--) {
|
|
unsigned c = *(unsigned char *) block;
|
|
const char *s;
|
|
char buf[5];
|
|
|
|
switch (c) {
|
|
case '\0':
|
|
s = " \\0";
|
|
break;
|
|
case '\007':
|
|
s = " \\a";
|
|
break;
|
|
case '\b':
|
|
s = " \\b";
|
|
break;
|
|
case '\f':
|
|
s = " \\f";
|
|
break;
|
|
case '\n':
|
|
s = " \\n";
|
|
break;
|
|
case '\r':
|
|
s = " \\r";
|
|
break;
|
|
case '\t':
|
|
s = " \\t";
|
|
break;
|
|
case '\v':
|
|
s = " \\v";
|
|
break;
|
|
default:
|
|
sprintf(buf, (ISPRINT(c) ? " %c" : "%03o"), c);
|
|
s = (const char *) buf;
|
|
}
|
|
|
|
printf(" %3s", s);
|
|
block += sizeof(unsigned char);
|
|
}
|
|
}
|
|
|
|
/* If S points to a single valid modern od format string, put
|
|
a description of that format in *TSPEC, make *NEXT point at the
|
|
character following the just-decoded format (if *NEXT is non-NULL),
|
|
and return zero. If S is not valid, don't modify *NEXT or *TSPEC,
|
|
give a diagnostic, and return nonzero. For example, if S were
|
|
"d4afL" *NEXT would be set to "afL" and *TSPEC would be
|
|
{
|
|
fmt = SIGNED_DECIMAL;
|
|
size = INT or LONG; (whichever integral_type_size[4] resolves to)
|
|
print_function = print_int; (assuming size == INT)
|
|
fmt_string = "%011d%c";
|
|
}
|
|
S_ORIG is solely for reporting errors. It should be the full format
|
|
string argument.
|
|
*/
|
|
|
|
static int
|
|
decode_one_format(const char *s_orig, const char *s, const char **next,
|
|
struct tspec *tspec)
|
|
{
|
|
enum size_spec size_spec;
|
|
unsigned long size;
|
|
enum output_format fmt;
|
|
const char *pre_fmt_string;
|
|
char *end;
|
|
char *fmt_string;
|
|
void (*print_function) (size_t, const char *, const char *);
|
|
unsigned c;
|
|
unsigned field_width = 0;
|
|
|
|
assert(tspec != NULL);
|
|
|
|
switch (*s) {
|
|
case 'd':
|
|
case 'o':
|
|
case 'u':
|
|
case 'x':
|
|
c = *s;
|
|
++s;
|
|
switch (*s) {
|
|
case 'C':
|
|
++s;
|
|
size = sizeof(char);
|
|
break;
|
|
case 'S':
|
|
++s;
|
|
size = sizeof(short);
|
|
break;
|
|
case 'I':
|
|
++s;
|
|
size = sizeof(int);
|
|
break;
|
|
case 'L':
|
|
++s;
|
|
size = sizeof(long);
|
|
break;
|
|
default:
|
|
size = sizeof(int);
|
|
if (isdigit(s[0])) {
|
|
size = strtoul(s, &end, 0);
|
|
if (end[0] || MAX_INTEGRAL_TYPE_SIZE < size
|
|
|| integral_type_size[size] == NO_SIZE
|
|
) {
|
|
bb_error_msg("invalid type string '%s'; "
|
|
"%lu-byte integral type is not spported", s_orig, size);
|
|
return 1;
|
|
}
|
|
s = end;
|
|
}
|
|
break;
|
|
}
|
|
|
|
#define ISPEC_TO_FORMAT(Spec, Min_format, Long_format, Max_format) \
|
|
((Spec) == LONG_LONG ? (Max_format) \
|
|
: ((Spec) == LONG ? (Long_format) : (Min_format)))
|
|
|
|
#define FMT_BYTES_ALLOCATED 9
|
|
fmt_string = xmalloc(FMT_BYTES_ALLOCATED);
|
|
|
|
size_spec = integral_type_size[size];
|
|
|
|
switch (c) {
|
|
case 'd':
|
|
fmt = SIGNED_DECIMAL;
|
|
sprintf(fmt_string, " %%%u%s",
|
|
(field_width = bytes_to_signed_dec_digits[size]),
|
|
ISPEC_TO_FORMAT(size_spec, "d", "ld", PRIdMAX));
|
|
break;
|
|
case 'o':
|
|
fmt = OCTAL;
|
|
sprintf(fmt_string, " %%0%u%s",
|
|
(field_width = bytes_to_oct_digits[size]),
|
|
ISPEC_TO_FORMAT(size_spec, "o", "lo", PRIoMAX));
|
|
break;
|
|
case 'u':
|
|
fmt = UNSIGNED_DECIMAL;
|
|
sprintf(fmt_string, " %%%u%s",
|
|
(field_width = bytes_to_unsigned_dec_digits[size]),
|
|
ISPEC_TO_FORMAT(size_spec, "u", "lu", PRIuMAX));
|
|
break;
|
|
case 'x':
|
|
fmt = HEXADECIMAL;
|
|
sprintf(fmt_string, " %%0%u%s",
|
|
(field_width = bytes_to_hex_digits[size]),
|
|
ISPEC_TO_FORMAT(size_spec, "x", "lx", PRIxMAX));
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
|
|
assert(strlen(fmt_string) < FMT_BYTES_ALLOCATED);
|
|
|
|
switch (size_spec) {
|
|
case CHAR:
|
|
print_function = (fmt == SIGNED_DECIMAL
|
|
? print_s_char
|
|
: print_char);
|
|
break;
|
|
case SHORT:
|
|
print_function = (fmt == SIGNED_DECIMAL
|
|
? print_s_short
|
|
: print_short);
|
|
break;
|
|
case INT:
|
|
print_function = print_int;
|
|
break;
|
|
case LONG:
|
|
print_function = print_long;
|
|
break;
|
|
case LONG_LONG:
|
|
print_function = print_long_long;
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
break;
|
|
|
|
case 'f':
|
|
fmt = FLOATING_POINT;
|
|
++s;
|
|
switch (*s) {
|
|
case 'F':
|
|
++s;
|
|
size = sizeof(float);
|
|
break;
|
|
case 'D':
|
|
++s;
|
|
size = sizeof(double);
|
|
break;
|
|
case 'L':
|
|
++s;
|
|
size = sizeof(longdouble_t);
|
|
break;
|
|
default:
|
|
size = sizeof(double);
|
|
if (isdigit(s[0])) {
|
|
size = strtoul(s, &end, 0);
|
|
if (end[0] || size > MAX_FP_TYPE_SIZE
|
|
|| fp_type_size[size] == NO_SIZE
|
|
) {
|
|
bb_error_msg("invalid type string '%s'; "
|
|
"%lu-byte floating point type is not supported", s_orig, size);
|
|
return 1;
|
|
}
|
|
s = end;
|
|
}
|
|
break;
|
|
}
|
|
size_spec = fp_type_size[size];
|
|
|
|
switch (size_spec) {
|
|
case FLOAT_SINGLE:
|
|
print_function = print_float;
|
|
/* Don't use %#e; not all systems support it. */
|
|
pre_fmt_string = " %%%d.%de";
|
|
fmt_string = xmalloc(strlen(pre_fmt_string));
|
|
sprintf(fmt_string, pre_fmt_string,
|
|
(field_width = FLT_DIG + 8), FLT_DIG);
|
|
break;
|
|
case FLOAT_DOUBLE:
|
|
print_function = print_double;
|
|
pre_fmt_string = " %%%d.%de";
|
|
fmt_string = xmalloc(strlen(pre_fmt_string));
|
|
sprintf(fmt_string, pre_fmt_string,
|
|
(field_width = DBL_DIG + 8), DBL_DIG);
|
|
break;
|
|
case FLOAT_LONG_DOUBLE:
|
|
print_function = print_long_double;
|
|
pre_fmt_string = " %%%d.%dLe";
|
|
fmt_string = xmalloc(strlen(pre_fmt_string));
|
|
sprintf(fmt_string, pre_fmt_string,
|
|
(field_width = LDBL_DIG + 8), LDBL_DIG);
|
|
break;
|
|
default:
|
|
abort();
|
|
}
|
|
break;
|
|
|
|
case 'a':
|
|
++s;
|
|
fmt = NAMED_CHARACTER;
|
|
size_spec = CHAR;
|
|
fmt_string = NULL;
|
|
print_function = print_named_ascii;
|
|
field_width = 3;
|
|
break;
|
|
case 'c':
|
|
++s;
|
|
fmt = CHARACTER;
|
|
size_spec = CHAR;
|
|
fmt_string = NULL;
|
|
print_function = print_ascii;
|
|
field_width = 3;
|
|
break;
|
|
default:
|
|
bb_error_msg("invalid character '%c' in type string '%s'", *s, s_orig);
|
|
return 1;
|
|
}
|
|
|
|
tspec->size = size_spec;
|
|
tspec->fmt = fmt;
|
|
tspec->print_function = print_function;
|
|
tspec->fmt_string = fmt_string;
|
|
|
|
tspec->field_width = field_width;
|
|
tspec->hexl_mode_trailer = (*s == 'z');
|
|
if (tspec->hexl_mode_trailer)
|
|
s++;
|
|
|
|
if (next != NULL)
|
|
*next = s;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Given a list of one or more input filenames FILE_LIST, set the global
|
|
file pointer IN_STREAM and the global string INPUT_FILENAME to the
|
|
first one that can be successfully opened. Modify FILE_LIST to
|
|
reference the next filename in the list. A file name of "-" is
|
|
interpreted as standard input. If any file open fails, give an error
|
|
message and return nonzero. */
|
|
|
|
static int
|
|
open_next_file(void)
|
|
{
|
|
int err = 0;
|
|
|
|
do {
|
|
input_filename = *file_list;
|
|
if (input_filename == NULL)
|
|
return err;
|
|
++file_list;
|
|
|
|
if (input_filename[0] == '-' && !input_filename[1]) {
|
|
input_filename = "standard input";
|
|
in_stream = stdin;
|
|
have_read_stdin = 1;
|
|
} else {
|
|
in_stream = fopen(input_filename, "r");
|
|
if (in_stream == NULL) {
|
|
bb_perror_msg("%s", input_filename);
|
|
err = 1;
|
|
}
|
|
}
|
|
} while (in_stream == NULL);
|
|
|
|
if (limit_bytes_to_format && !flag_dump_strings)
|
|
setbuf(in_stream, NULL);
|
|
|
|
return err;
|
|
}
|
|
|
|
/* Test whether there have been errors on in_stream, and close it if
|
|
it is not standard input. Return nonzero if there has been an error
|
|
on in_stream or stdout; return zero otherwise. This function will
|
|
report more than one error only if both a read and a write error
|
|
have occurred. IN_ERRNO, if nonzero, is the error number
|
|
corresponding to the most recent action for IN_STREAM. */
|
|
|
|
static int
|
|
check_and_close(int in_errno)
|
|
{
|
|
int err = 0;
|
|
|
|
if (in_stream != NULL) {
|
|
if (ferror(in_stream)) {
|
|
bb_error_msg("%s: read error", input_filename);
|
|
if (in_stream != stdin)
|
|
fclose(in_stream);
|
|
err = 1;
|
|
} else if (in_stream != stdin && fclose(in_stream) == EOF) {
|
|
bb_perror_msg("%s", input_filename);
|
|
err = 1;
|
|
}
|
|
in_stream = NULL;
|
|
}
|
|
|
|
if (ferror(stdout)) {
|
|
bb_error_msg("write error");
|
|
err = 1;
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/* Decode the modern od format string S. Append the decoded
|
|
representation to the global array SPEC, reallocating SPEC if
|
|
necessary. Return zero if S is valid, nonzero otherwise. */
|
|
|
|
static int
|
|
decode_format_string(const char *s)
|
|
{
|
|
const char *s_orig = s;
|
|
assert(s != NULL);
|
|
|
|
while (*s != '\0') {
|
|
struct tspec tspec;
|
|
const char *next;
|
|
|
|
if (decode_one_format(s_orig, s, &next, &tspec))
|
|
return 1;
|
|
|
|
assert(s != next);
|
|
s = next;
|
|
n_specs++;
|
|
spec = xrealloc(spec, n_specs * sizeof(*spec));
|
|
memcpy(&spec[n_specs-1], &tspec, sizeof *spec);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/* Given a list of one or more input filenames FILE_LIST, set the global
|
|
file pointer IN_STREAM to position N_SKIP in the concatenation of
|
|
those files. If any file operation fails or if there are fewer than
|
|
N_SKIP bytes in the combined input, give an error message and return
|
|
nonzero. When possible, use seek rather than read operations to
|
|
advance IN_STREAM. */
|
|
|
|
static int
|
|
skip(uintmax_t n_skip)
|
|
{
|
|
int err = 0;
|
|
int in_errno = 0;
|
|
|
|
if (n_skip == 0)
|
|
return 0;
|
|
|
|
while (in_stream != NULL) { /* EOF */
|
|
struct stat file_stats;
|
|
|
|
/* First try seeking. For large offsets, this extra work is
|
|
worthwhile. If the offset is below some threshold it may be
|
|
more efficient to move the pointer by reading. There are two
|
|
issues when trying to seek:
|
|
- the file must be seekable.
|
|
- before seeking to the specified position, make sure
|
|
that the new position is in the current file.
|
|
Try to do that by getting file's size using fstat.
|
|
But that will work only for regular files. */
|
|
|
|
if (fstat(fileno(in_stream), &file_stats) == 0) {
|
|
/* The st_size field is valid only for regular files
|
|
(and for symbolic links, which cannot occur here).
|
|
If the number of bytes left to skip is at least
|
|
as large as the size of the current file, we can
|
|
decrement n_skip and go on to the next file. */
|
|
|
|
if (S_ISREG(file_stats.st_mode) && 0 <= file_stats.st_size) {
|
|
if ((uintmax_t) file_stats.st_size <= n_skip)
|
|
n_skip -= file_stats.st_size;
|
|
else {
|
|
if (fseeko(in_stream, n_skip, SEEK_CUR) != 0) {
|
|
in_errno = errno;
|
|
err = 1;
|
|
}
|
|
n_skip = 0;
|
|
}
|
|
} else {
|
|
|
|
/* If it's not a regular file with nonnegative size,
|
|
position the file pointer by reading. */
|
|
char buf[BUFSIZ];
|
|
size_t n_bytes_read, n_bytes_to_read = BUFSIZ;
|
|
|
|
while (0 < n_skip) {
|
|
if (n_skip < n_bytes_to_read)
|
|
n_bytes_to_read = n_skip;
|
|
n_bytes_read = fread(buf, 1, n_bytes_to_read, in_stream);
|
|
n_skip -= n_bytes_read;
|
|
if (n_bytes_read != n_bytes_to_read) {
|
|
in_errno = errno;
|
|
err = 1;
|
|
n_skip = 0;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (n_skip == 0)
|
|
break;
|
|
} else { /* cannot fstat() file */
|
|
bb_perror_msg("%s", input_filename);
|
|
err = 1;
|
|
}
|
|
|
|
err |= check_and_close(in_errno);
|
|
err |= open_next_file();
|
|
}
|
|
|
|
if (n_skip != 0)
|
|
bb_error_msg_and_die("cannot skip past end of combined input");
|
|
return err;
|
|
}
|
|
|
|
static void
|
|
format_address_none(uintmax_t address ATTRIBUTE_UNUSED, char c ATTRIBUTE_UNUSED)
|
|
{
|
|
}
|
|
|
|
static void
|
|
format_address_std(uintmax_t address, char c)
|
|
{
|
|
char buf[MAX_ADDRESS_LENGTH + 2];
|
|
char *p = buf + sizeof(buf)-1;
|
|
char const *pbound;
|
|
|
|
*p = '\0';
|
|
*--p = c;
|
|
pbound = p - address_pad_len;
|
|
|
|
do {
|
|
*--p = "0123456789abcdef"[address % address_base];
|
|
address /= address_base;
|
|
} while (address);
|
|
|
|
while (pbound < p)
|
|
*--p = '0';
|
|
fputs(p, stdout);
|
|
}
|
|
|
|
static void
|
|
format_address_paren(uintmax_t address, char c)
|
|
{
|
|
putchar('(');
|
|
format_address_std(address, ')');
|
|
putchar(c);
|
|
}
|
|
|
|
static void
|
|
format_address_label(uintmax_t address, char c)
|
|
{
|
|
format_address_std(address, ' ');
|
|
format_address_paren(address + pseudo_offset, c);
|
|
}
|
|
|
|
/* Write N_BYTES bytes from CURR_BLOCK to standard output once for each
|
|
of the N_SPEC format specs. CURRENT_OFFSET is the byte address of
|
|
CURR_BLOCK in the concatenation of input files, and it is printed
|
|
(optionally) only before the output line associated with the first
|
|
format spec. When duplicate blocks are being abbreviated, the output
|
|
for a sequence of identical input blocks is the output for the first
|
|
block followed by an asterisk alone on a line. It is valid to compare
|
|
the blocks PREV_BLOCK and CURR_BLOCK only when N_BYTES == BYTES_PER_BLOCK.
|
|
That condition may be false only for the last input block -- and then
|
|
only when it has not been padded to length BYTES_PER_BLOCK. */
|
|
|
|
static void
|
|
write_block(uintmax_t current_offset, size_t n_bytes,
|
|
const char *prev_block, const char *curr_block)
|
|
{
|
|
static int first = 1;
|
|
static int prev_pair_equal = 0;
|
|
|
|
if (abbreviate_duplicate_blocks
|
|
&& !first
|
|
&& n_bytes == bytes_per_block
|
|
&& memcmp(prev_block, curr_block, bytes_per_block) == 0
|
|
) {
|
|
if (prev_pair_equal) {
|
|
/* The two preceding blocks were equal, and the current
|
|
block is the same as the last one, so print nothing. */
|
|
} else {
|
|
puts("*");
|
|
prev_pair_equal = 1;
|
|
}
|
|
} else {
|
|
size_t i;
|
|
|
|
prev_pair_equal = 0;
|
|
for (i = 0; i < n_specs; i++) {
|
|
if (i == 0)
|
|
format_address(current_offset, '\0');
|
|
else
|
|
printf("%*s", address_pad_len, "");
|
|
(*spec[i].print_function) (n_bytes, curr_block, spec[i].fmt_string);
|
|
if (spec[i].hexl_mode_trailer) {
|
|
/* space-pad out to full line width, then dump the trailer */
|
|
int datum_width = width_bytes[spec[i].size];
|
|
int blank_fields = (bytes_per_block - n_bytes) / datum_width;
|
|
int field_width = spec[i].field_width + 1;
|
|
printf("%*s", blank_fields * field_width, "");
|
|
dump_hexl_mode_trailer(n_bytes, curr_block);
|
|
}
|
|
putchar('\n');
|
|
}
|
|
}
|
|
first = 0;
|
|
}
|
|
|
|
/* Read a single byte into *C from the concatenation of the input files
|
|
named in the global array FILE_LIST. On the first call to this
|
|
function, the global variable IN_STREAM is expected to be an open
|
|
stream associated with the input file INPUT_FILENAME. If IN_STREAM
|
|
is at end-of-file, close it and update the global variables IN_STREAM
|
|
and INPUT_FILENAME so they correspond to the next file in the list.
|
|
Then try to read a byte from the newly opened file. Repeat if
|
|
necessary until EOF is reached for the last file in FILE_LIST, then
|
|
set *C to EOF and return. Subsequent calls do likewise. The return
|
|
value is nonzero if any errors occured, zero otherwise. */
|
|
|
|
static int
|
|
read_char(int *c)
|
|
{
|
|
int err = 0;
|
|
|
|
*c = EOF;
|
|
|
|
while (in_stream != NULL) { /* EOF. */
|
|
*c = fgetc(in_stream);
|
|
if (*c != EOF)
|
|
break;
|
|
err |= check_and_close(errno);
|
|
err |= open_next_file();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/* Read N bytes into BLOCK from the concatenation of the input files
|
|
named in the global array FILE_LIST. On the first call to this
|
|
function, the global variable IN_STREAM is expected to be an open
|
|
stream associated with the input file INPUT_FILENAME. If all N
|
|
bytes cannot be read from IN_STREAM, close IN_STREAM and update
|
|
the global variables IN_STREAM and INPUT_FILENAME. Then try to
|
|
read the remaining bytes from the newly opened file. Repeat if
|
|
necessary until EOF is reached for the last file in FILE_LIST.
|
|
On subsequent calls, don't modify BLOCK and return zero. Set
|
|
*N_BYTES_IN_BUFFER to the number of bytes read. If an error occurs,
|
|
it will be detected through ferror when the stream is about to be
|
|
closed. If there is an error, give a message but continue reading
|
|
as usual and return nonzero. Otherwise return zero. */
|
|
|
|
static int
|
|
read_block(size_t n, char *block, size_t *n_bytes_in_buffer)
|
|
{
|
|
int err = 0;
|
|
|
|
assert(0 < n && n <= bytes_per_block);
|
|
|
|
*n_bytes_in_buffer = 0;
|
|
|
|
if (n == 0)
|
|
return 0;
|
|
|
|
while (in_stream != NULL) { /* EOF. */
|
|
size_t n_needed;
|
|
size_t n_read;
|
|
|
|
n_needed = n - *n_bytes_in_buffer;
|
|
n_read = fread(block + *n_bytes_in_buffer, 1, n_needed, in_stream);
|
|
*n_bytes_in_buffer += n_read;
|
|
if (n_read == n_needed)
|
|
break;
|
|
err |= check_and_close(errno);
|
|
err |= open_next_file();
|
|
}
|
|
|
|
return err;
|
|
}
|
|
|
|
/* Return the least common multiple of the sizes associated
|
|
with the format specs. */
|
|
|
|
static int
|
|
get_lcm(void)
|
|
{
|
|
size_t i;
|
|
int l_c_m = 1;
|
|
|
|
for (i = 0; i < n_specs; i++)
|
|
l_c_m = lcm(l_c_m, width_bytes[(int) spec[i].size]);
|
|
return l_c_m;
|
|
}
|
|
|
|
/* If S is a valid traditional offset specification with an optional
|
|
leading '+' return nonzero and set *OFFSET to the offset it denotes. */
|
|
|
|
static int
|
|
parse_old_offset(const char *s, uintmax_t *offset)
|
|
{
|
|
static const struct suffix_mult Bb[] = {
|
|
{ "B", 1024 },
|
|
{ "b", 512 },
|
|
{ NULL, 0 }
|
|
};
|
|
|
|
int radix;
|
|
|
|
if (*s == '\0')
|
|
return 0;
|
|
|
|
/* Skip over any leading '+'. */
|
|
if (s[0] == '+')
|
|
++s;
|
|
|
|
/* Determine the radix we'll use to interpret S. If there is a '.',
|
|
it's decimal, otherwise, if the string begins with '0X'or '0x',
|
|
it's hexadecimal, else octal. */
|
|
if (strchr(s, '.') != NULL)
|
|
radix = 10;
|
|
else {
|
|
if (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))
|
|
radix = 16;
|
|
else
|
|
radix = 8;
|
|
}
|
|
|
|
*offset = xstrtoumax_sfx(s, radix, Bb);
|
|
return 1;
|
|
}
|
|
|
|
/* Read a chunk of size BYTES_PER_BLOCK from the input files, write the
|
|
formatted block to standard output, and repeat until the specified
|
|
maximum number of bytes has been read or until all input has been
|
|
processed. If the last block read is smaller than BYTES_PER_BLOCK
|
|
and its size is not a multiple of the size associated with a format
|
|
spec, extend the input block with zero bytes until its length is a
|
|
multiple of all format spec sizes. Write the final block. Finally,
|
|
write on a line by itself the offset of the byte after the last byte
|
|
read. Accumulate return values from calls to read_block and
|
|
check_and_close, and if any was nonzero, return nonzero.
|
|
Otherwise, return zero. */
|
|
|
|
static int
|
|
dump(void)
|
|
{
|
|
char *block[2];
|
|
uintmax_t current_offset;
|
|
int idx;
|
|
int err;
|
|
size_t n_bytes_read;
|
|
|
|
block[0] = xmalloc(2*bytes_per_block);
|
|
block[1] = block[0] + bytes_per_block;
|
|
|
|
current_offset = n_bytes_to_skip;
|
|
|
|
idx = 0;
|
|
err = 0;
|
|
if (limit_bytes_to_format) {
|
|
while (1) {
|
|
size_t n_needed;
|
|
if (current_offset >= end_offset) {
|
|
n_bytes_read = 0;
|
|
break;
|
|
}
|
|
n_needed = MIN(end_offset - current_offset,
|
|
(uintmax_t) bytes_per_block);
|
|
err |= read_block(n_needed, block[idx], &n_bytes_read);
|
|
if (n_bytes_read < bytes_per_block)
|
|
break;
|
|
assert(n_bytes_read == bytes_per_block);
|
|
write_block(current_offset, n_bytes_read,
|
|
block[!idx], block[idx]);
|
|
current_offset += n_bytes_read;
|
|
idx = !idx;
|
|
}
|
|
} else {
|
|
while (1) {
|
|
err |= read_block(bytes_per_block, block[idx], &n_bytes_read);
|
|
if (n_bytes_read < bytes_per_block)
|
|
break;
|
|
assert(n_bytes_read == bytes_per_block);
|
|
write_block(current_offset, n_bytes_read,
|
|
block[!idx], block[idx]);
|
|
current_offset += n_bytes_read;
|
|
idx = !idx;
|
|
}
|
|
}
|
|
|
|
if (n_bytes_read > 0) {
|
|
int l_c_m;
|
|
size_t bytes_to_write;
|
|
|
|
l_c_m = get_lcm();
|
|
|
|
/* Make bytes_to_write the smallest multiple of l_c_m that
|
|
is at least as large as n_bytes_read. */
|
|
bytes_to_write = l_c_m * ((n_bytes_read + l_c_m - 1) / l_c_m);
|
|
|
|
memset(block[idx] + n_bytes_read, 0, bytes_to_write - n_bytes_read);
|
|
write_block(current_offset, bytes_to_write,
|
|
block[!idx], block[idx]);
|
|
current_offset += n_bytes_read;
|
|
}
|
|
|
|
format_address(current_offset, '\n');
|
|
|
|
if (limit_bytes_to_format && current_offset >= end_offset)
|
|
err |= check_and_close(0);
|
|
|
|
free(block[0]);
|
|
|
|
return err;
|
|
}
|
|
|
|
/* STRINGS mode. Find each "string constant" in the input.
|
|
A string constant is a run of at least 'string_min' ASCII
|
|
graphic (or formatting) characters terminated by a null.
|
|
Based on a function written by Richard Stallman for a
|
|
traditional version of od. Return nonzero if an error
|
|
occurs. Otherwise, return zero. */
|
|
|
|
static int
|
|
dump_strings(void)
|
|
{
|
|
size_t bufsize = MAX(100, string_min);
|
|
char *buf = xmalloc(bufsize);
|
|
uintmax_t address = n_bytes_to_skip;
|
|
int err;
|
|
|
|
err = 0;
|
|
while (1) {
|
|
size_t i;
|
|
int c;
|
|
|
|
/* See if the next 'string_min' chars are all printing chars. */
|
|
tryline:
|
|
|
|
if (limit_bytes_to_format
|
|
&& (end_offset < string_min || end_offset - string_min <= address)
|
|
) {
|
|
break;
|
|
}
|
|
|
|
for (i = 0; i < string_min; i++) {
|
|
err |= read_char(&c);
|
|
address++;
|
|
if (c < 0) {
|
|
free(buf);
|
|
return err;
|
|
}
|
|
if (!ISPRINT(c))
|
|
/* Found a non-printing. Try again starting with next char. */
|
|
goto tryline;
|
|
buf[i] = c;
|
|
}
|
|
|
|
/* We found a run of 'string_min' printable characters.
|
|
Now see if it is terminated with a null byte. */
|
|
while (!limit_bytes_to_format || address < end_offset) {
|
|
if (i == bufsize) {
|
|
bufsize *= 2;
|
|
buf = xrealloc(buf, bufsize * sizeof(*buf));
|
|
}
|
|
err |= read_char(&c);
|
|
address++;
|
|
if (c < 0) {
|
|
free(buf);
|
|
return err;
|
|
}
|
|
if (c == '\0')
|
|
break; /* It is; print this string. */
|
|
if (!ISPRINT(c))
|
|
goto tryline; /* It isn't; give up on this string. */
|
|
buf[i++] = c; /* String continues; store it all. */
|
|
}
|
|
|
|
/* If we get here, the string is all printable and null-terminated,
|
|
so print it. It is all in 'buf' and 'i' is its length. */
|
|
buf[i] = 0;
|
|
format_address(address - i - 1, ' ');
|
|
|
|
for (i = 0; (c = buf[i]); i++) {
|
|
switch (c) {
|
|
case '\007':
|
|
fputs("\\a", stdout);
|
|
break;
|
|
|
|
case '\b':
|
|
fputs("\\b", stdout);
|
|
break;
|
|
|
|
case '\f':
|
|
fputs("\\f", stdout);
|
|
break;
|
|
|
|
case '\n':
|
|
fputs("\\n", stdout);
|
|
break;
|
|
|
|
case '\r':
|
|
fputs("\\r", stdout);
|
|
break;
|
|
|
|
case '\t':
|
|
fputs("\\t", stdout);
|
|
break;
|
|
|
|
case '\v':
|
|
fputs("\\v", stdout);
|
|
break;
|
|
|
|
default:
|
|
putc(c, stdout);
|
|
}
|
|
}
|
|
putchar('\n');
|
|
}
|
|
|
|
/* We reach this point only if we search through
|
|
(max_bytes_to_format - string_min) bytes before reaching EOF. */
|
|
|
|
free(buf);
|
|
|
|
err |= check_and_close(0);
|
|
return err;
|
|
}
|
|
|
|
int
|
|
od_main(int argc, char **argv)
|
|
{
|
|
static const struct suffix_mult bkm[] = {
|
|
{ "b", 512 },
|
|
{ "k", 1024 },
|
|
{ "m", 1024*1024 },
|
|
{ NULL, 0 }
|
|
};
|
|
static const struct option long_options[] = {
|
|
{ "skip-bytes", required_argument, NULL, 'j' },
|
|
{ "address-radix", required_argument, NULL, 'A' },
|
|
{ "read-bytes", required_argument, NULL, 'N' },
|
|
{ "format", required_argument, NULL, 't' },
|
|
{ "output-duplicates", no_argument, NULL, 'v' },
|
|
{ "strings", optional_argument, NULL, 's' },
|
|
{ "traditional", no_argument, NULL, TRADITIONAL_OPTION },
|
|
{ "width", optional_argument, NULL, 'w' },
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
|
|
int c;
|
|
int n_files;
|
|
int l_c_m;
|
|
size_t desired_width = 0; // only for gcc
|
|
int width_specified = 0;
|
|
int n_failed_decodes = 0;
|
|
int err;
|
|
|
|
/* The old-style 'pseudo starting address' to be printed in parentheses
|
|
after any true address. */
|
|
uintmax_t pseudo_start = 0; // only for gcc
|
|
|
|
err = 0;
|
|
|
|
integral_type_size[sizeof(char)] = CHAR;
|
|
integral_type_size[sizeof(short)] = SHORT;
|
|
integral_type_size[sizeof(int)] = INT;
|
|
integral_type_size[sizeof(long)] = LONG;
|
|
/* If 'long' and 'long long' have the same size, it's fine
|
|
to overwrite the entry for 'long' with this one. */
|
|
integral_type_size[sizeof(ulonglong_t)] = LONG_LONG;
|
|
|
|
fp_type_size[sizeof(float)] = FLOAT_SINGLE;
|
|
/* The array entry for 'double' is filled in after that for longdouble_t
|
|
so that if 'long double' is the same type or if long double isn't
|
|
supported FLOAT_LONG_DOUBLE will never be used. */
|
|
fp_type_size[sizeof(longdouble_t)] = FLOAT_LONG_DOUBLE;
|
|
fp_type_size[sizeof(double)] = FLOAT_DOUBLE;
|
|
|
|
spec = NULL;
|
|
|
|
format_address = format_address_std;
|
|
address_base = 8;
|
|
address_pad_len = 7;
|
|
flag_dump_strings = 0;
|
|
|
|
while ((c = getopt_long(argc, argv, "A:N:abcdfhij:lot:vxs:w:", long_options, NULL)) != -1) {
|
|
switch (c) {
|
|
case 0:
|
|
break;
|
|
case 'A':
|
|
switch (optarg[0]) {
|
|
case 'd':
|
|
format_address = format_address_std;
|
|
address_base = 10;
|
|
address_pad_len = 7;
|
|
break;
|
|
case 'o':
|
|
format_address = format_address_std;
|
|
address_base = 8;
|
|
address_pad_len = 7;
|
|
break;
|
|
case 'x':
|
|
format_address = format_address_std;
|
|
address_base = 16;
|
|
address_pad_len = 6;
|
|
break;
|
|
case 'n':
|
|
format_address = format_address_none;
|
|
address_pad_len = 0;
|
|
break;
|
|
default:
|
|
bb_error_msg_and_die("bad output address radix '%c' "
|
|
"(must be [doxn])", optarg[0]);
|
|
break;
|
|
}
|
|
break;
|
|
|
|
case 'j':
|
|
n_bytes_to_skip = xstrtoumax_sfx(optarg, 0, bkm);
|
|
break;
|
|
case 'N':
|
|
limit_bytes_to_format = 1;
|
|
|
|
max_bytes_to_format = xstrtoumax_sfx(optarg, 0, bkm);
|
|
break;
|
|
case 's':
|
|
if (optarg == NULL)
|
|
string_min = 3;
|
|
else {
|
|
string_min = xstrtoumax_range_sfx(optarg, 0, 0, SIZE_MAX, bkm);
|
|
}
|
|
flag_dump_strings = 1;
|
|
break;
|
|
case 't':
|
|
if (decode_format_string(optarg))
|
|
++n_failed_decodes;
|
|
break;
|
|
case 'v':
|
|
abbreviate_duplicate_blocks = 0;
|
|
break;
|
|
case TRADITIONAL_OPTION:
|
|
traditional = 1;
|
|
break;
|
|
|
|
/* The next several cases map the traditional format
|
|
specification options to the corresponding modern format
|
|
specs. GNU od accepts any combination of old- and
|
|
new-style options. Format specification options accumulate. */
|
|
|
|
#define CASE_OLD_ARG(old_char,new_string) \
|
|
case old_char: \
|
|
if (decode_format_string(new_string)) \
|
|
++n_failed_decodes; \
|
|
break
|
|
|
|
CASE_OLD_ARG('a', "a");
|
|
CASE_OLD_ARG('b', "oC");
|
|
CASE_OLD_ARG('c', "c");
|
|
CASE_OLD_ARG('d', "u2");
|
|
CASE_OLD_ARG('f', "fF");
|
|
CASE_OLD_ARG('h', "x2");
|
|
CASE_OLD_ARG('i', "d2");
|
|
CASE_OLD_ARG('l', "d4");
|
|
CASE_OLD_ARG('o', "o2");
|
|
CASE_OLD_ARG('x', "x2");
|
|
|
|
/* FIXME: POSIX 1003.1-2001 with XSI requires this:
|
|
CASE_OLD_ARG('s', "d2");
|
|
for the traditional syntax, but this conflicts with case
|
|
's' above. */
|
|
|
|
#undef CASE_OLD_ARG
|
|
|
|
case 'w':
|
|
width_specified = 1;
|
|
desired_width = 32;
|
|
if (optarg)
|
|
desired_width = xatoul_range(optarg, 0, SIZE_MAX);
|
|
break;
|
|
default:
|
|
bb_show_usage();
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (n_failed_decodes > 0)
|
|
exit(EXIT_FAILURE);
|
|
|
|
if (flag_dump_strings && n_specs > 0)
|
|
bb_error_msg_and_die("no type may be specified when dumping strings");
|
|
|
|
n_files = argc - optind;
|
|
|
|
/* If the --traditional option is used, there may be from
|
|
0 to 3 remaining command line arguments; handle each case
|
|
separately.
|
|
od [file] [[+]offset[.][b] [[+]label[.][b]]]
|
|
The offset and pseudo_start have the same syntax.
|
|
|
|
FIXME: POSIX 1003.1-2001 with XSI requires support for the
|
|
traditional syntax even if --traditional is not given. */
|
|
|
|
if (traditional) {
|
|
uintmax_t offset;
|
|
|
|
if (n_files == 1) {
|
|
if (parse_old_offset(argv[optind], &offset)) {
|
|
n_bytes_to_skip = offset;
|
|
--n_files;
|
|
++argv;
|
|
}
|
|
} else if (n_files == 2) {
|
|
uintmax_t o1, o2;
|
|
|
|
if (parse_old_offset(argv[optind], &o1)
|
|
&& parse_old_offset(argv[optind + 1], &o2)
|
|
) {
|
|
n_bytes_to_skip = o1;
|
|
flag_pseudo_start = 1;
|
|
pseudo_start = o2;
|
|
argv += 2;
|
|
n_files -= 2;
|
|
} else if (parse_old_offset(argv[optind + 1], &o2)) {
|
|
n_bytes_to_skip = o2;
|
|
--n_files;
|
|
argv[optind + 1] = argv[optind];
|
|
++argv;
|
|
} else {
|
|
bb_error_msg_and_die("invalid second operand "
|
|
"in compatibility mode '%s'", argv[optind + 1]);
|
|
}
|
|
} else if (n_files == 3) {
|
|
uintmax_t o1, o2;
|
|
if (parse_old_offset(argv[optind + 1], &o1)
|
|
&& parse_old_offset(argv[optind + 2], &o2)
|
|
) {
|
|
n_bytes_to_skip = o1;
|
|
flag_pseudo_start = 1;
|
|
pseudo_start = o2;
|
|
argv[optind + 2] = argv[optind];
|
|
argv += 2;
|
|
n_files -= 2;
|
|
} else {
|
|
bb_error_msg_and_die("in compatibility mode "
|
|
"the last two arguments must be offsets");
|
|
}
|
|
} else if (n_files > 3) {
|
|
bb_error_msg_and_die("compatibility mode supports "
|
|
"at most three arguments");
|
|
}
|
|
|
|
if (flag_pseudo_start) {
|
|
if (format_address == format_address_none) {
|
|
address_base = 8;
|
|
address_pad_len = 7;
|
|
format_address = format_address_paren;
|
|
} else
|
|
format_address = format_address_label;
|
|
}
|
|
}
|
|
|
|
if (limit_bytes_to_format) {
|
|
end_offset = n_bytes_to_skip + max_bytes_to_format;
|
|
if (end_offset < n_bytes_to_skip)
|
|
bb_error_msg_and_die("skip-bytes + read-bytes is too large");
|
|
}
|
|
|
|
if (n_specs == 0) {
|
|
if (decode_format_string("o2")) {
|
|
/* This happens on Cray systems that don't have a 2-byte
|
|
integral type. */
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
n_specs = 1;
|
|
}
|
|
|
|
if (n_files > 0) {
|
|
/* Set the global pointer FILE_LIST so that it
|
|
references the first file-argument on the command-line. */
|
|
file_list = (char const *const *) &argv[optind];
|
|
} else {
|
|
/* No files were listed on the command line.
|
|
Set the global pointer FILE_LIST so that it
|
|
references the null-terminated list of one name: "-". */
|
|
file_list = default_file_list;
|
|
}
|
|
|
|
/* open the first input file */
|
|
err |= open_next_file();
|
|
if (in_stream == NULL)
|
|
goto cleanup;
|
|
|
|
/* skip over any unwanted header bytes */
|
|
err |= skip(n_bytes_to_skip);
|
|
if (in_stream == NULL)
|
|
goto cleanup;
|
|
|
|
pseudo_offset = (flag_pseudo_start ? pseudo_start - n_bytes_to_skip : 0);
|
|
|
|
/* Compute output block length. */
|
|
l_c_m = get_lcm();
|
|
|
|
if (width_specified) {
|
|
if (desired_width != 0 && desired_width % l_c_m == 0)
|
|
bytes_per_block = desired_width;
|
|
else {
|
|
bb_error_msg("warning: invalid width %lu; using %d instead",
|
|
(unsigned long) desired_width, l_c_m);
|
|
bytes_per_block = l_c_m;
|
|
}
|
|
} else {
|
|
if (l_c_m < DEFAULT_BYTES_PER_BLOCK)
|
|
bytes_per_block = l_c_m * (DEFAULT_BYTES_PER_BLOCK / l_c_m);
|
|
else
|
|
bytes_per_block = l_c_m;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
for (i = 0; i < n_specs; i++) {
|
|
printf("%d: fmt=\"%s\" width=%d\n",
|
|
i, spec[i].fmt_string, width_bytes[spec[i].size]);
|
|
}
|
|
#endif
|
|
|
|
err |= (flag_dump_strings ? dump_strings() : dump());
|
|
|
|
cleanup:
|
|
|
|
if (have_read_stdin && fclose(stdin) == EOF)
|
|
bb_perror_msg_and_die("standard input");
|
|
|
|
exit(err == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
|
|
}
|