/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2010 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * Copyright 2019 Joyent, Inc.
 */

/*
 * od - octal dump.  Not really just octal anymore; read the POSIX
 * specification for it -- its more complex than you think!
 *
 * NB: We followed the POSIX semantics fairly strictly, where the
 * legacy code's behavior was in conflict.  In many cases the legacy
 * Solaris code was so completely broken as to be completely unusable.
 * (For example, the long double support was broken beyond
 * imagination!)  Note that GNU coreutils violates POSIX in a few
 * interesting ways, such as changing the numbering of the addresses
 * when skipping.  (Address starts should always be at 0, according to
 * the sample output in the Open Group man page.)
 */

#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <string.h>
#include <err.h>
#include <wchar.h>
#include <locale.h>
#include <unistd.h>
#include <sys/stat.h>

#define	_(x)	gettext(x)


#ifndef TEXT_DOMAIN
#define	TEXT_DOMAIN	"SYS_TEST"
#endif

/* address format */
static char *afmt  =	"%07llo";
static char *cfmt  =    "       ";

static FILE *input = NULL;
static size_t lcm = 1;
static size_t blocksize = 16;
static int numfiles = 0;
static int curfile = 0;
static char **files = NULL;
static off_t limit = -1;

/*
 * This structure describes our ring buffer.  Its always a power of 2
 * in size to make wrap around calculations fast using a mask instead
 * of doing modulo.
 *
 * The size is calculated thusly: We need three "blocks" of data, as
 * we process a block at a time (one block == one line of od output.)
 *
 * We need lookahead of an extra block to support multibyte chars.  We
 * also have a look behind so that we can avoid printing lines that
 * are identical to what we've already printed.  Finally, we need the
 * current block.
 *
 * The block size is determined by the least common multiple of the
 * data items being displayed.  Usually it will be 16, but sometimes
 * it is 24 (when 12-byte long doubles are presented.)
 *
 * The data buffer is allocaed via memalign to make sure it is
 * properly aligned.
 */
typedef struct buffer {
	char	*data;		/* data buffer */
	int	prod;		/* producer index */
	int	cons;		/* consumer index */
	int	mask;		/* buffer size - 1, wraparound index */
	int	navail;		/* total bytes avail */
} buffer_t;

/*
 * This structure is used to provide information on a specific output
 * format.  We link them together in a list representing the output
 * formats that the user has selected.
 */
typedef struct output {
	int	width;				/* bytes consumed per call */
	void	(*func)(buffer_t *, int);	/* output function */
	struct output	*next;			/* link node */
} output_t;

/*
 * Specifiers
 */

typedef unsigned char		u8;
typedef unsigned short		u16;
typedef unsigned int		u32;
typedef unsigned long long	u64;
typedef char			s8;
typedef short			s16;
typedef int			s32;
typedef long long		s64;
typedef float			fF;
typedef	double			fD;
typedef long double		fL;

static void
usage(void)
{
	(void) fprintf(stderr, _("usage: od [-bcCdDfFoOsSvxX] "
	    "[-t types ]... [-A base] [-j skip] [-N count] [file]...\n"));
	exit(1);
}

#define	DECL_GET(typ)							\
static typ								\
get_ ## typ(buffer_t *b, int index)					\
{									\
	typ val = *(typ *)(void *)(b->data + index);			\
	return (val);							\
}
DECL_GET(u8)
DECL_GET(u16)
DECL_GET(u32)
DECL_GET(u64)
DECL_GET(s8)
DECL_GET(s16)
DECL_GET(s32)
DECL_GET(s64)
DECL_GET(fF)
DECL_GET(fD)
DECL_GET(fL)

#define	DECL_OUT(nm, typ, fmt)					\
static void							\
do_ ## nm(buffer_t *buf, int index)				\
{								\
	typ v = get_ ## typ(buf, index);			\
	(void) printf(fmt, v);					\
}								\
								\
static output_t output_ ## nm =  {				\
	sizeof (typ), do_ ## nm					\
};

DECL_OUT(oct_b, u8, " %03o")
DECL_OUT(oct_w, u16, " %06ho")
DECL_OUT(oct_d, u32, " %011o")
DECL_OUT(oct_q, u64, " %022llo")
DECL_OUT(dec_b, u8, " %03u")
DECL_OUT(dec_w, u16, " %05hu")
DECL_OUT(dec_d, u32, " %010u")
DECL_OUT(dec_q, u64, " %020llu")
DECL_OUT(sig_b, s8, " %03d")
DECL_OUT(sig_w, s16, " %6.05hd")
DECL_OUT(sig_d, s32, " %11.010d")
DECL_OUT(sig_q, s64, " %20.019lld")
DECL_OUT(hex_b, u8, " %02x")
DECL_OUT(hex_w, u16, " %04hx")
DECL_OUT(hex_d, s32, " %08x")
DECL_OUT(hex_q, s64, " %016llx")
DECL_OUT(float, fF, " %14.7e")
DECL_OUT(double, fD, " %21.14e")
DECL_OUT(ldouble, fL, " %24.14Le")

static char *ascii[] = {
	"nul", "soh", "stx", "etx", "eot", "enq", "ack", " be",
	" bs", " ht", " lf", " vt", " ff", " cr", " so", " si",
	"dle", "dc1", "dc2", "dc3", "dc4", "nak", "syn", "etb",
	"can", " em", "sub", "esc", " fs", " gs", " rs", " us",
	" sp", "  !", "  \"", "  #", "  $", "  %", "  &", "  '",
	"  (", "  )", "  *", "  +", "  ,", "  -", "  .", "  /",
	"  0", "  1", "  2", "  3", "  4", "  5", "  6", "  7",
	"  8", "  9", "  :", "  ;", "  <", "  =", "  >", "  ?",
	"  @", "  A", "  B", "  C", "  D", "  E", "  F", "  G",
	"  H", "  I", "  J", "  K", "  L", "  M", "  N", "  O",
	"  P", "  Q", "  R", "  S", "  T", "  U", "  V", "  W",
	"  X", "  Y", "  Z", "  [", "  \\", "  ]", "  ^", "  _",
	"  `", "  a", "  b", "  c", "  d", "  e", "  f", "  g",
	"  h", "  i", "  j", "  k", "  l", "  m", "  n", "  o",
	"  p", "  q", "  r", "  s", "  t", "  u", "  v", "  w",
	"  x", "  y", "  z", "  {", "  |", "  }", "  ~", "del"
};

static void
do_ascii(buffer_t *buf, int index)
{
	uint8_t v = get_u8(buf, index);

	(void) fputc(' ', stdout);
	(void) fputs(ascii[v & 0x7f], stdout);
}

static output_t output_ascii = {
	1, do_ascii,
};

static void
do_char(buffer_t *buf, int index)
{
	static int	nresid = 0;
	static int	printable = 0;
	int		cnt;
	int		avail;
	int		nb;
	char		scratch[10];
	wchar_t		wc;
	int		which;

	uint8_t v = get_u8(buf, index);

	/*
	 * If there were residual bytes from an earlier
	 * character, then just display the ** continuation
	 * indication.
	 */
	if (nresid) {
		if (printable) {
			(void) fputs("  **", stdout);
		} else {
			(void) printf(" %03o", v);
		}
		nresid--;
		return;
	}

	/*
	 * Peek ahead up to MB_CUR_MAX characters.  This has to be
	 * done carefully because we might need to look into the next
	 * block to really know for sure.
	 */
	scratch[0] = v;
	avail = buf->navail;
	if (avail > MB_CUR_MAX)
		avail = MB_CUR_MAX;
	for (cnt = 1, which = index + 1; cnt < avail; cnt++, which++) {
		scratch[cnt] = buf->data[which & buf->mask];
	}

	/* now see if the value is a real character */
	nresid = 0;
	wc = 0;
	nb = mbtowc(&wc, scratch, avail);
	if (nb < 0) {
		(void) printf(" %03o", v);
		return;
	}
	if (nb == 0) {
		(void) fputs("  \\0", stdout);
		return;
	}
	nresid = nb - 1;
	if (nb && iswprint(wc)) {
		scratch[nb] = 0;
		(void) fputs("   ", stdout);
		(void) fputs(scratch, stdout);
		printable = 1;
		return;
	}
	printable = 0;
	if (wc == 0) {
		(void) fputs("  \\0", stdout);
	} else if (wc == '\b') {
		(void) fputs("  \\b", stdout);
	} else if (wc == '\f') {
		(void) fputs("  \\f", stdout);
	} else if (wc == '\n') {
		(void) fputs("  \\n", stdout);
	} else if (wc == '\r') {
		(void) fputs("  \\r", stdout);
	} else if (wc == '\t') {
		(void) fputs("  \\t", stdout);
	} else {
		(void) printf(" %03o", v);
	}
}

static output_t output_char = {
	1, do_char,
};

/*
 * List of output formatting structures.
 */
static output_t *head = NULL;
static output_t **tailp = &head;

static void
add_out(output_t *src)
{
	output_t	*out;
	int		m;

	if ((out = calloc(1, sizeof (*src))) == NULL) {
		err(1, "malloc");
	}

	m = lcm;
	while ((m % src->width) != 0) {
		m += lcm;
	}
	lcm = m;
	blocksize = lcm;
	while (blocksize < 16)
		blocksize *= 2;

	(void) memcpy(out, src, sizeof (*src));
	*tailp = out;
	tailp = &out->next;
}

static FILE *
next_input(void)
{
	for (;;) {
		if (curfile >= numfiles)
			return (NULL);

		if (input != NULL) {
			if ((input = freopen(files[curfile], "r", input)) !=
			    NULL) {
				curfile++;
				return (input);
			}
		} else {
			if ((input = fopen(files[curfile], "r")) != NULL) {
				curfile++;
				return (input);
			}
		}
		warn("open: %s", files[curfile]);
		curfile++;
	}
}

static void
refill(buffer_t *b)
{
	int	n;
	int	want;
	int	zero;

	/*
	 * If we have 2 blocks of bytes available, we're done.  Note
	 * that each iteration usually loads up 16 bytes, unless we
	 * run out of data.
	 */
	while ((input != NULL) && (b->navail < (2 * blocksize))) {

		/* we preload the next one in advance */

		if (limit == 0) {
			(void) fclose(input);
			input = NULL;
			continue;
		}

		/* we want to read a whole block if possible */
		want = blocksize;
		if ((limit >= 0) && (want > limit)) {
			want = limit;
		}
		zero = blocksize;

		while (want && input) {
			int	c;
			b->prod &= b->mask;
			c = (b->prod + want > (b->mask + 1)) ?
			    b->mask - b->prod :
			    want;

			n = fread(b->data + b->prod, 1, c, input);
			if (n < 0) {
				warn("read: %s",
				    files ? files[curfile-1] : "stdin");
				input = next_input();
				continue;
			}
			if (n == 0) {
				input = next_input();
				continue;
			}
			if (limit >= 0)
				limit -= n;
			b->navail += n;
			b->prod += n;
			want -= n;
			zero -= n;
		}

		while (zero) {
			b->data[b->prod & b->mask] = 0;
			b->prod++;
			b->prod &= b->mask;
			zero--;
		}
	}
}

#define	STR1	"C1"
#define	STR2	"S2"
#ifdef	_LP64
#define	STR8	"L8"
#define	STR4	"I4"
#else
#define	STR8	"8"
#define	STR4	"IL4"
#endif

static void
do_type_string(char *typestr)
{
	if (*typestr == 0) {
		errx(1, _("missing type string"));
	}
	while (*typestr) {
		switch (*typestr) {
		case 'a':
			typestr++;
			add_out(&output_ascii);
			break;
		case 'c':
			add_out(&output_char);
			typestr++;
			break;
		case 'f':
			typestr++;
			switch (*typestr) {
			case 'F':
			case '4':
				add_out(&output_float);
				typestr++;
				break;
			case '8':
			case 'D':
				add_out(&output_double);
				typestr++;
				break;
			case 'L':
				add_out(&output_ldouble);
				typestr++;
				break;
			default:
				add_out(&output_float);
				break;
			}
			break;


		case 'd':
			typestr++;
			if (strchr(STR1, *typestr)) {
				typestr++;
				add_out(&output_sig_b);
			} else if (strchr(STR2, *typestr)) {
				typestr++;
				add_out(&output_sig_w);
			} else if (strchr(STR4, *typestr)) {
				typestr++;
				add_out(&output_sig_d);
			} else if (strchr(STR8, *typestr)) {
				typestr++;
				add_out(&output_sig_q);
			} else {
				add_out(&output_sig_d);
			}
			break;

		case 'u':
			typestr++;
			if (strchr(STR1, *typestr)) {
				typestr++;
				add_out(&output_dec_b);
			} else if (strchr(STR2, *typestr)) {
				typestr++;
				add_out(&output_dec_w);
			} else if (strchr(STR4, *typestr)) {
				typestr++;
				add_out(&output_dec_d);
			} else if (strchr(STR8, *typestr)) {
				typestr++;
				add_out(&output_dec_q);
			} else {
				add_out(&output_dec_d);
			}
			break;

		case 'o':
			typestr++;
			if (strchr(STR1, *typestr)) {
				typestr++;
				add_out(&output_oct_b);
			} else if (strchr(STR2, *typestr)) {
				typestr++;
				add_out(&output_oct_w);
			} else if (strchr(STR4, *typestr)) {
				typestr++;
				add_out(&output_oct_d);
			} else if (strchr(STR8, *typestr)) {
				typestr++;
				add_out(&output_oct_q);
			} else {
				add_out(&output_oct_d);
			}
			break;

		case 'x':
			typestr++;
			if (strchr(STR1, *typestr)) {
				typestr++;
				add_out(&output_hex_b);
			} else if (strchr(STR2, *typestr)) {
				typestr++;
				add_out(&output_hex_w);
			} else if (strchr(STR4, *typestr)) {
				typestr++;
				add_out(&output_hex_d);
			} else if (strchr(STR8, *typestr)) {
				typestr++;
				add_out(&output_hex_q);
			} else {
				add_out(&output_hex_d);
			}
			break;

		default:
			errx(1, _("unrecognized type string character: %c"),
			    *typestr);
		}
	}
}

int
main(int argc, char **argv)
{
	int		c;
	int		i;
	buffer_t	buffer;
	boolean_t	first = B_TRUE;
	boolean_t	doall = B_FALSE;
	boolean_t	same = B_FALSE;
	boolean_t	newarg = B_FALSE;
	off_t		offset = 0;
	off_t		skip = 0;
	char		*eptr;
	char		*offstr = 0;

	input = stdin;

	(void) setlocale(LC_ALL, "");
	(void) textdomain(TEXT_DOMAIN);

	while ((c = getopt(argc, argv, "A:bCcdDfFj:N:oOsSxXvt:")) != EOF) {
		switch (c) {
		case 'A':
			newarg = B_TRUE;
			if (strlen(optarg) > 1) {
				afmt = NULL;
			}
			switch (*optarg) {
			case 'o':
				afmt = "%07llo";
				cfmt = "       ";
				break;
			case 'd':
				afmt = "%07lld";
				cfmt = "       ";
				break;
			case 'x':
				afmt = "%07llx";
				cfmt = "       ";
				break;
			case 'n':
				/*
				 * You could argue that the code should
				 * use the same 7 spaces.  Legacy uses 8
				 * though.  Oh well.  Better to avoid
				 * gratuitous change.
				 */
				afmt = "        ";
				cfmt = "        ";
				break;
			default:
				afmt = NULL;
				break;
			}
			if (strlen(optarg) != 1) {
				afmt = NULL;
			}
			if (afmt == NULL)
				warnx(_("invalid address base, "
				    "must be o, d, x, or n"));
			break;

		case 'b':
			add_out(&output_oct_b);
			break;

		case 'c':
		case 'C':
			add_out(&output_char);
			break;

		case 'f':
			add_out(&output_float);
			break;

		case 'F':
			add_out(&output_double);
			break;

		case 'd':
			add_out(&output_dec_w);
			break;

		case 'D':
			add_out(&output_dec_d);
			break;

		case 't':
			newarg = B_TRUE;
			do_type_string(optarg);
			break;

		case 'o':
			add_out(&output_oct_w);
			break;

		case 'O':
			add_out(&output_oct_d);
			break;

		case 's':
			add_out(&output_sig_w);
			break;

		case 'S':
			add_out(&output_sig_d);
			break;

		case 'x':
			add_out(&output_hex_w);
			break;

		case 'X':
			add_out(&output_hex_d);
			break;

		case 'v':
			doall = B_TRUE;
			break;

		case 'j':
			newarg = B_TRUE;
			skip = strtoll(optarg, &eptr, 0);
			if (*eptr == 'b') {
				skip <<= 9;	/* 512 bytes */
				eptr++;
			} else if (*eptr == 'k') {
				skip <<= 10;	/* 1k */
				eptr++;
			} else if (*eptr == 'm') {
				skip <<= 20;	/* 1m */
				eptr++;
			} else if (*eptr == 'g') {
				skip <<= 30;	/* 1g */
				eptr++;
			}
			if ((skip < 0) || (eptr[0] != 0)) {
				warnx(_("invalid skip count '%s' specified"),
				    optarg);
				exit(1);
			}
			break;

		case 'N':
			newarg = B_TRUE;
			limit = strtoll(optarg, &eptr, 0);
			/*
			 * POSIX doesn't specify this, but I think these
			 * may be helpful.
			 */
			if (*eptr == 'b') {
				limit <<= 9;
				eptr++;
			} else if (*eptr == 'k') {
				limit <<= 10;
				eptr++;
			} else if (*eptr == 'm') {
				limit <<= 20;
				eptr++;
			} else if (*eptr == 'g') {
				limit <<= 30;
				eptr++;
			}
			if ((limit < 0) || (eptr[0] != 0)) {
				warnx(_("invalid byte count '%s' specified"),
				    optarg);
				exit(1);
			}
			break;

		default:
			usage();
			break;
		}
	}

	/* this finds the smallest power of two size we can use */
	buffer.mask = (1 << (ffs(blocksize * 3) + 1)) - 1;
	buffer.data = memalign(16, buffer.mask + 1);
	if (buffer.data == NULL) {
		err(1, "memalign");
	}


	/*
	 * Wow.  This option parsing is hideous.
	 *
	 * If the we've not seen a new option, and there is just one
	 * operand, if it starts with a "+", then treat it as an
	 * offset.  Otherwise if two operands, and the second operand
	 * starts with + or a digit, then it is an offset.
	 */
	if (!newarg) {
		if (((argc - optind) == 1) && (argv[optind][0] == '+')) {
			offstr = argv[optind];
			argc--;
		} else if (((argc - optind) == 2) &&
		    (strchr("+0123456789", (argv[optind + 1][0])) != NULL)) {
			offstr = argv[optind + 1];
			argc--;
		}
	}
	if (offstr) {
		int base = 0;
		int mult = 1;
		int l;
		if (*offstr == '+') {
			offstr++;
		}
		l = strlen(offstr);
		if ((strncmp(offstr, "0x", 2) == 0)) {
			afmt = "%07llx";
			base = 16;
			offstr += 2;
			if (offstr[l - 1] == 'B') {
				offstr[l - 1] = 0;
				l--;
				mult = 512;
			}
		} else {
			base = 8;
			afmt = "%07llo";
			if ((offstr[l - 1] == 'B') || (offstr[l - 1] == 'b')) {
				offstr[l - 1] = 0;
				l--;
				mult = 512;
			}
			if (offstr[l - 1] == '.') {
				offstr[l - 1] = 0;
				base = 10;
				afmt = "%07lld";
			}
		}
		skip = strtoll(offstr, &eptr, base);
		if (*eptr != '\0') {
			errx(1, _("invalid offset string specified"));
		}
		skip *= mult;
		offset += skip;
	}

	/*
	 * Allocate an array for all the input files.
	 */
	if (argc > optind) {
		files = calloc(sizeof (char *), argc - optind);
		for (i = 0; i < argc - optind; i++) {
			files[i] = argv[optind + i];
			numfiles++;
		}
		input = next_input();
	} else {
		input = stdin;
	}

	/*
	 * We need to seek ahead.  fseek would be faster.
	 */
	while (skip && (input != NULL)) {
		struct stat sbuf;

		/*
		 * Only fseek() on regular files.  (Others
		 * we have to read().
		 */
		if (fstat(fileno(input), &sbuf) < 0) {
			warn("fstat: %s", files[curfile-1]);
			input = next_input();
			continue;
		}
		if (S_ISREG(sbuf.st_mode)) {
			/*
			 * No point in seeking a file that is too
			 * short to begin with.
			 */
			if (sbuf.st_size < skip) {
				skip -= sbuf.st_size;
				input = next_input();
				continue;
			}
			if (fseeko(input, skip, SEEK_SET) < 0) {
				err(1, "fseek:%s", files[curfile-1]);
			}
			/* Done seeking. */
			skip = 0;
			break;
		}

		/*
		 * fgetc seems like it would be slow, but it uses
		 * buffered I/O, so it should be fast enough.
		 */
		flockfile(input);
		while (skip) {
			if (getc_unlocked(input) == EOF) {
				funlockfile(input);
				if (ferror(input)) {
					warn("read: %s", files[curfile-1]);
				}
				input = next_input();
				if (input != NULL) {
					flockfile(input);
				}
				break;
			}
			skip--;
		}
		if (input != NULL)
			funlockfile(input);
	}

	if (head == NULL) {
		add_out(&output_oct_w);
	}

	buffer.navail = 0;
	buffer.prod = 0;
	buffer.cons = 0;

	for (refill(&buffer); buffer.navail > 0; refill(&buffer)) {
		output_t *out;
		int	mx;
		int	j, k;

		/*
		 * If this buffer was the same as last, then just
		 * dump an asterisk.
		 */
		if ((!first) && (buffer.navail >= blocksize) && (!doall)) {
			j = buffer.cons;
			k = j - blocksize;
			for (i = 0; i < blocksize; i++) {
				if (buffer.data[j & buffer.mask] !=
				    buffer.data[k & buffer.mask]) {
					break;
				}
				j++;
				k++;
			}
			if (i == blocksize) {
				if (!same) {
					(void) fputs("*\n", stdout);
					same = B_TRUE;
				}
				buffer.navail -= blocksize;
				offset += blocksize;
				buffer.cons += blocksize;
				buffer.cons &= buffer.mask;
				continue;
			}
		}

		first = B_FALSE;
		same = B_FALSE;
		mx = (buffer.navail > blocksize) ? blocksize : buffer.navail;

		for (out = head; out != NULL; out = out->next) {

			if (out == head) {
				/*LINTED E_SEC_PRINTF_VAR_FMT*/
				(void) printf(afmt, offset);
			} else {
				(void) fputs(cfmt, stdout);
			}
			for (i = 0, j = buffer.cons; i < mx; i += out->width) {
				out->func(&buffer, j);
				j += out->width;
				j &= buffer.mask;
			}
			(void) fputs("\n", stdout);
		}
		buffer.cons += mx;
		buffer.cons &= buffer.mask;
		offset += mx;
		buffer.navail -= mx;
	}
	/*LINTED E_SEC_PRINTF_VAR_FMT*/
	(void) printf(afmt, offset);
	(void) fputs("\n", stdout);
	return (0);
}