/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License, Version 1.0 only
 * (the "License").  You may not use this file except in compliance
 * with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 * Copyright 2012, Josef 'Jeff' Sipek <jeffpc@31bits.net>. All rights reserved.
 * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
 * Copyright (c) 2014 by Delphix. All rights reserved.
 * Copyright 2021 Oxide Computer Company
 */

/*      Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */
/*              All Rights Reserved     */

/*
 *      convert and copy
 */

#include        <stdio.h>
#include        <signal.h>
#include        <fcntl.h>
#include        <sys/param.h>
#include        <sys/types.h>
#include        <sys/sysmacros.h>
#include        <sys/stat.h>
#include        <unistd.h>
#include        <stdlib.h>
#include        <locale.h>
#include        <string.h>
#include        <sys/time.h>
#include        <errno.h>
#include        <strings.h>
#include        <libcmdutils.h>

/* The BIG parameter is machine dependent.  It should be a long integer */
/* constant that can be used by the number parser to check the validity */
/* of numeric parameters.  On 16-bit machines, it should probably be    */
/* the maximum unsigned integer, 0177777L.  On 32-bit machines where    */
/* longs are the same size as ints, the maximum signed integer is more  */
/* appropriate.  This value is 017777777777L. In 64 bit environments,   */
/* the maximum signed integer value is 0777777777777777777777LL         */

#define BIG     0777777777777777777777LL

#define BSIZE   512

/* Option parameters */

#define COPY            0       /* file copy, preserve input block size */
#define REBLOCK         1       /* file copy, change block size */
#define LCREBLOCK       2       /* file copy, convert to lower case */
#define UCREBLOCK       3       /* file copy, convert to upper case */
#define NBASCII         4       /* file copy, convert from EBCDIC to ASCII */
#define LCNBASCII       5       /* file copy, EBCDIC to lower case ASCII */
#define UCNBASCII       6       /* file copy, EBCDIC to upper case ASCII */
#define NBEBCDIC        7       /* file copy, convert from ASCII to EBCDIC */
#define LCNBEBCDIC      8       /* file copy, ASCII to lower case EBCDIC */
#define UCNBEBCDIC      9       /* file copy, ASCII to upper case EBCDIC */
#define NBIBM           10      /* file copy, convert from ASCII to IBM */
#define LCNBIBM         11      /* file copy, ASCII to lower case IBM */
#define UCNBIBM         12      /* file copy, ASCII to upper case IBM */
#define UNBLOCK         13      /* convert blocked ASCII to ASCII */
#define LCUNBLOCK       14      /* convert blocked ASCII to lower case ASCII */
#define UCUNBLOCK       15      /* convert blocked ASCII to upper case ASCII */
#define ASCII           16      /* convert blocked EBCDIC to ASCII */
#define LCASCII         17      /* convert blocked EBCDIC to lower case ASCII */
#define UCASCII         18      /* convert blocked EBCDIC to upper case ASCII */
#define BLOCK           19      /* convert ASCII to blocked ASCII */
#define LCBLOCK         20      /* convert ASCII to lower case blocked ASCII */
#define UCBLOCK         21      /* convert ASCII to upper case blocked ASCII */
#define EBCDIC          22      /* convert ASCII to blocked EBCDIC */
#define LCEBCDIC        23      /* convert ASCII to lower case blocked EBCDIC */
#define UCEBCDIC        24      /* convert ASCII to upper case blocked EBCDIC */
#define IBM             25      /* convert ASCII to blocked IBM */
#define LCIBM           26      /* convert ASCII to lower case blocked IBM */
#define UCIBM           27      /* convert ASCII to upper case blocked IBM */
#define LCASE           01      /* flag - convert to lower case */
#define UCASE           02      /* flag - convert to upper case */
#define SWAB            04      /* flag - swap bytes before conversion */
#define NERR            010     /* flag - proceed on input errors */
#define SYNC            020     /* flag - pad short input blocks with nulls */
#define FULLBLOCK       040     /* flag - accumulate full blocks of input */
#define BADLIMIT        5       /* give up if no progress after BADLIMIT trys */
#define SVR4XLATE       0       /* use default EBCDIC translation */
#define BSDXLATE        1       /* use BSD-compatible EBCDIC translation */

#define USAGE\
        "usage: dd [if=file] [of=file] [ibs=n|nk|nb|nxm] [obs=n|nk|nb|nxm]\n"\
        "          [bs=n|nk|nb|nxm] [cbs=n|nk|nb|nxm] [files=n] [skip=n]\n"\
        "          [iseek=n] [oseek=n] [seek=n] [stride=n] [istride=n]\n"\
        "          [ostride=n] [count=n] [conv=[ascii][,ebcdic][,ibm]\n"\
        "          [,asciib][,ebcdicb][,ibmb][,block|unblock][,lcase|ucase]\n"\
        "          [,swab][,noerror][,notrunc][,sync]]\n"\
        "          [iflag=[fullblock]] [oflag=[dsync][sync]]\n"

/* Global references */

/* Local routine declarations */

static int      match(char *);
static void             term(int);
static unsigned long long       number(long long);
static unsigned char    *flsh(void);
static void             stats(boolean_t);

/* Local data definitions */

static unsigned ibs;    /* input buffer size */
static unsigned obs;    /* output buffer size */
static unsigned bs;     /* buffer size, overrules ibs and obs */
static unsigned cbs;    /* conversion buffer size, used for block conversions */
static unsigned ibc;    /* number of bytes still in the input buffer */
static unsigned obc;    /* number of bytes in the output buffer */
static unsigned cbc;    /* number of bytes in the conversion buffer */

static int      ibf;    /* input file descriptor */
static int      obf;    /* output file descriptor */
static int      cflag;  /* conversion option flags */
static int      iflag;  /* input flag options */
static int      oflag;  /* output flag options */
static int      skipf;  /* if skipf == 1, skip rest of input line */
static unsigned long long       nifr;   /* count of full input records */
static unsigned long long       nipr;   /* count of partial input records */
static unsigned long long       nofr;   /* count of full output records */
static unsigned long long       nopr;   /* count of partial output records */
static unsigned long long       ntrunc; /* count of truncated input lines */
static unsigned long long       nbad;   /* count of bad records since last */
                                        /* good one */
static int      files;  /* number of input files to concatenate (tape only) */
static off_t    skip;   /* number of input records to skip */
static off_t    iseekn; /* number of input records to seek past */
static off_t    oseekn; /* number of output records to seek past */
static unsigned long long       count;  /* number of input records to copy */
                        /* (0 = all) */
static boolean_t ecount;        /* explicit count given */
static off_t    ostriden;       /* number of output blocks to skip between */
                                /* records */
static off_t    istriden;       /* number of input blocks to skip between */
                                /* records */

static int      trantype; /* BSD or SVr4 compatible EBCDIC */

static char             *string;        /* command arg pointer */
static char             *ifile;         /* input file name pointer */
static char             *ofile;         /* output file name pointer */
static unsigned char    *ibuf;          /* input buffer pointer */
static unsigned char    *obuf;          /* output buffer pointer */

static hrtime_t         startt;         /* hrtime copy started */
static uint64_t         prog_secs;      /* number of seconds of progress */
static unsigned long long       obytes; /* output bytes */
static sig_atomic_t     nstats;         /* do we need to output stats */

typedef enum dd_status {
        DD_STATUS_DEFAULT       = 0,
        DD_STATUS_NONE          = 1 << 0,
        DD_STATUS_PROGRESS      = 1 << 1,
        DD_STATUS_NOXFER        = 1 << 2
} dd_status_t;

static dd_status_t      status_arg = DD_STATUS_DEFAULT;
static boolean_t        stderr_tty = B_FALSE;
static boolean_t        progress_printed = B_FALSE;

/* This is an EBCDIC to ASCII conversion table  */
/* from a proposed BTL standard April 16, 1979  */

static unsigned char svr4_etoa[] =
{
        0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177,
        0227, 0215, 0216, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207,
        0030, 0031, 0222, 0217, 0034, 0035, 0036, 0037,
        0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033,
        0210, 0211, 0212, 0213, 0214, 0005, 0006, 0007,
        0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004,
        0230, 0231, 0232, 0233, 0024, 0025, 0236, 0032,
        0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
        0247, 0250, 0325, 0056, 0074, 0050, 0053, 0174,
        0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0041, 0044, 0052, 0051, 0073, 0176,
        0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0313, 0054, 0045, 0137, 0076, 0077,
        0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
        0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
        0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
        0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
        0161, 0162, 0136, 0314, 0315, 0316, 0317, 0320,
        0321, 0345, 0163, 0164, 0165, 0166, 0167, 0170,
        0171, 0172, 0322, 0323, 0324, 0133, 0326, 0327,
        0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
        0340, 0341, 0342, 0343, 0344, 0135, 0346, 0347,
        0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
        0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
        0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
        0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
        0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
        0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
        0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
        0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* This is an ASCII to EBCDIC conversion table  */
/* from a proposed BTL standard April 16, 1979  */

static unsigned char svr4_atoe[] =
{
        0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
        0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
        0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
        0100, 0132, 0177, 0173, 0133, 0154, 0120, 0175,
        0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
        0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
        0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
        0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
        0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
        0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
        0347, 0350, 0351, 0255, 0340, 0275, 0232, 0155,
        0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
        0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
        0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
        0247, 0250, 0251, 0300, 0117, 0320, 0137, 0007,
        0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
        0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
        0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
        0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
        0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
        0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
        0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
        0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
        0216, 0217, 0220, 0152, 0233, 0234, 0235, 0236,
        0237, 0240, 0252, 0253, 0254, 0112, 0256, 0257,
        0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0272, 0273, 0274, 0241, 0276, 0277,
        0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
        0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
        0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* Table for ASCII to IBM (alternate EBCDIC) code conversion    */

static unsigned char svr4_atoibm[] =
{
        0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
        0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
        0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
        0100, 0132, 0177, 0173, 0133, 0154, 0120, 0175,
        0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
        0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
        0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
        0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
        0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
        0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
        0347, 0350, 0351, 0255, 0340, 0275, 0137, 0155,
        0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
        0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
        0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
        0247, 0250, 0251, 0300, 0117, 0320, 0241, 0007,
        0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
        0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
        0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
        0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
        0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
        0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
        0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
        0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
        0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236,
        0237, 0240, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
        0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
        0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
        0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* Table for conversion of ASCII to lower case ASCII    */

static unsigned char utol[] =
{
        0000, 0001, 0002, 0003, 0004, 0005, 0006, 0007,
        0010, 0011, 0012, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0024, 0025, 0026, 0027,
        0030, 0031, 0032, 0033, 0034, 0035, 0036, 0037,
        0040, 0041, 0042, 0043, 0044, 0045, 0046, 0047,
        0050, 0051, 0052, 0053, 0054, 0055, 0056, 0057,
        0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
        0070, 0071, 0072, 0073, 0074, 0075, 0076, 0077,
        0100, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
        0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
        0170, 0171, 0172, 0133, 0134, 0135, 0136, 0137,
        0140, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
        0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
        0170, 0171, 0172, 0173, 0174, 0175, 0176, 0177,
        0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
        0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217,
        0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227,
        0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237,
        0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247,
        0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
        0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
        0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317,
        0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327,
        0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
        0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
        0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357,
        0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
        0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* Table for conversion of ASCII to upper case ASCII    */

static unsigned char ltou[] =
{
        0000, 0001, 0002, 0003, 0004, 0005, 0006, 0007,
        0010, 0011, 0012, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0024, 0025, 0026, 0027,
        0030, 0031, 0032, 0033, 0034, 0035, 0036, 0037,
        0040, 0041, 0042, 0043, 0044, 0045, 0046, 0047,
        0050, 0051, 0052, 0053, 0054, 0055, 0056, 0057,
        0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
        0070, 0071, 0072, 0073, 0074, 0075, 0076, 0077,
        0100, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
        0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
        0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
        0130, 0131, 0132, 0133, 0134, 0135, 0136, 0137,
        0140, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
        0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
        0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
        0130, 0131, 0132, 0173, 0174, 0175, 0176, 0177,
        0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
        0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217,
        0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227,
        0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237,
        0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247,
        0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
        0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
        0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317,
        0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327,
        0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
        0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
        0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357,
        0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
        0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* BSD-compatible EBCDIC to ASCII translate table */

static unsigned char bsd_etoa[] =
{
        0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177,
        0227, 0215, 0216, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207,
        0030, 0031, 0222, 0217, 0034, 0035, 0036, 0037,
        0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033,
        0210, 0211, 0212, 0213, 0214, 0005, 0006, 0007,
        0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004,
        0230, 0231, 0232, 0233, 0024, 0025, 0236, 0032,
        0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
        0247, 0250, 0133, 0056, 0074, 0050, 0053, 0041,
        0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0135, 0044, 0052, 0051, 0073, 0136,
        0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0174, 0054, 0045, 0137, 0076, 0077,
        0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
        0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
        0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
        0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
        0161, 0162, 0313, 0314, 0315, 0316, 0317, 0320,
        0321, 0176, 0163, 0164, 0165, 0166, 0167, 0170,
        0171, 0172, 0322, 0323, 0324, 0325, 0326, 0327,
        0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
        0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
        0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
        0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
        0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
        0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
        0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
        0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
        0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
        0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* BSD-compatible ASCII to EBCDIC translate table */

static unsigned char bsd_atoe[] =
{
        0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
        0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
        0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
        0100, 0117, 0177, 0173, 0133, 0154, 0120, 0175,
        0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
        0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
        0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
        0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
        0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
        0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
        0347, 0350, 0351, 0112, 0340, 0132, 0137, 0155,
        0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
        0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
        0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
        0247, 0250, 0251, 0300, 0152, 0320, 0241, 0007,
        0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
        0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
        0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
        0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
        0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
        0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
        0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
        0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
        0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236,
        0237, 0240, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
        0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
        0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
        0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* BSD-compatible ASCII to IBM translate table */

static unsigned char bsd_atoibm[] =
{
        0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
        0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
        0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
        0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
        0100, 0132, 0177, 0173, 0133, 0154, 0120, 0175,
        0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
        0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
        0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
        0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
        0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
        0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
        0347, 0350, 0351, 0255, 0340, 0275, 0137, 0155,
        0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
        0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
        0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
        0247, 0250, 0251, 0300, 0117, 0320, 0241, 0007,
        0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
        0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
        0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
        0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
        0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
        0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
        0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
        0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
        0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
        0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236,
        0237, 0240, 0252, 0253, 0254, 0255, 0256, 0257,
        0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
        0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
        0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
        0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
        0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
};

/* set up to use SVr4 ascii-ebcdic translation by default */

static unsigned char *atoe = svr4_atoe;
static unsigned char *etoa = svr4_etoa;
static unsigned char *atoibm = svr4_atoibm;

/*ARGSUSED*/
static void
siginfo_handler(int sig, siginfo_t *sip, void *ucp)
{
        nstats = 1;
}

static ssize_t
iread(int fd, char *buf, size_t nbyte)
{
        ssize_t count;

        count = 0;
        while (nbyte != 0) {
                ssize_t nr = read(fd, buf, nbyte);

                if (nr < 0)
                        return (nr);

                if (nr == 0)
                        break;
                buf += nr;
                count += nr;
                nbyte -= nr;

                if ((iflag & FULLBLOCK) == 0)
                        break;
        }
        return (count);
}

int
main(int argc, char **argv)
{
        unsigned char *ip, *op; /* input and output buffer pointers */
        int c;          /* character counter */
        int ic;         /* input character */
        int conv;               /* conversion option code */
        int trunc;              /* whether output file is truncated */
        struct stat file_stat;
        struct sigaction sact;

        /* Set option defaults */

        ibs = BSIZE;
        obs = BSIZE;
        files = 1;
        conv = COPY;
        trunc = 1;                      /* default: truncate output file */
        trantype = SVR4XLATE;  /* use SVR4 EBCDIC by default */

        /* Parse command options */

        (void) setlocale(LC_ALL, "");
#if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
#define TEXT_DOMAIN "SYS_TEST"  /* Use this only if it weren't */
#endif
        (void) textdomain(TEXT_DOMAIN);

        while ((c = getopt(argc, argv, "")) != EOF)
                switch (c) {
                        case '?':
                        (void) fprintf(stderr, USAGE);
                        exit(2);
                }

        /* not getopt()'ed because dd has no options but only operand(s) */

        for (c = optind; c < argc; c++) {
                string = argv[c];
                if (match("ibs=")) {
                        ibs = (unsigned)number(BIG);
                        continue;
                }
                if (match("obs=")) {
                        obs = (unsigned)number(BIG);
                        continue;
                }
                if (match("cbs=")) {
                        cbs = (unsigned)number(BIG);
                        continue;
                }
                if (match("bs=")) {
                        bs = (unsigned)number(BIG);
                        continue;
                }
                if (match("if=")) {
                        ifile = string;
                        continue;
                }
                if (match("of=")) {
                        ofile = string;
                        continue;
                }
                if (match("skip=")) {
                        skip = number(BIG);
                        continue;
                }
                if (match("iseek=")) {
                        iseekn = number(BIG);
                        continue;
                }
                if (match("oseek=")) {
                        oseekn = number(BIG);
                        continue;
                }
                if (match("seek=")) {           /* retained for compatibility */
                        oseekn = number(BIG);
                        continue;
                }
                if (match("ostride=")) {
                        ostriden = ((off_t)number(BIG)) - 1;
                        continue;
                }
                if (match("istride=")) {
                        istriden = ((off_t)number(BIG)) - 1;
                        continue;
                }
                if (match("stride=")) {
                        istriden = ostriden = ((off_t)number(BIG)) - 1;
                        continue;
                }
                if (match("count=")) {
                        count = number(BIG);
                        ecount = B_TRUE;
                        continue;
                }
                if (match("files=")) {
                        files = (int)number(BIG);
                        continue;
                }
                if (match("conv=")) {
                        for (;;) {
                                if (match(",")) {
                                        continue;
                                }
                                if (*string == '\0') {
                                        break;
                                }
                                if (match("block")) {
                                        conv = BLOCK;
                                        continue;
                                }
                                if (match("unblock")) {
                                        conv = UNBLOCK;
                                        continue;
                                }

                                /* ebcdicb, ibmb, and asciib must precede */
                                /* ebcdic, ibm, and ascii in this test */

                                if (match("ebcdicb")) {
                                        conv = EBCDIC;
                                        trantype = BSDXLATE;
                                        continue;
                                }
                                if (match("ibmb")) {
                                        conv = IBM;
                                        trantype = BSDXLATE;
                                        continue;
                                }
                                if (match("asciib")) {
                                        conv = ASCII;
                                        trantype = BSDXLATE;
                                        continue;
                                }
                                if (match("ebcdic")) {
                                        conv = EBCDIC;
                                        trantype = SVR4XLATE;
                                        continue;
                                }
                                if (match("ibm")) {
                                        conv = IBM;
                                        trantype = SVR4XLATE;
                                        continue;
                                }
                                if (match("ascii")) {
                                        conv = ASCII;
                                        trantype = SVR4XLATE;
                                        continue;
                                }
                                if (match("lcase")) {
                                        cflag |= LCASE;
                                        continue;
                                }
                                if (match("ucase")) {
                                        cflag |= UCASE;
                                        continue;
                                }
                                if (match("swab")) {
                                        cflag |= SWAB;
                                        continue;
                                }
                                if (match("noerror")) {
                                        cflag |= NERR;
                                        continue;
                                }
                                if (match("notrunc")) {
                                        trunc = 0;
                                        continue;
                                }
                                if (match("sync")) {
                                        cflag |= SYNC;
                                        continue;
                                }
                                goto badarg;
                        }
                        continue;
                }
                if (match("iflag=")) {
                        for (;;) {
                                if (match(",")) {
                                        continue;
                                }
                                if (*string == '\0') {
                                        break;
                                }
                                if (match("fullblock")) {
                                        iflag |= FULLBLOCK;
                                        continue;
                                }
                                goto badarg;
                        }
                        continue;
                }
                if (match("oflag=")) {
                        for (;;) {
                                if (match(",")) {
                                        continue;
                                }
                                if (*string == '\0') {
                                        break;
                                }
                                if (match("dsync")) {
                                        oflag |= O_DSYNC;
                                        continue;
                                }
                                if (match("sync")) {
                                        oflag |= O_SYNC;
                                        continue;
                                }
                                goto badarg;
                        }
                        continue;
                }
                if (match("status=")) {
                        if (match("none")) {
                                status_arg = DD_STATUS_NONE;
                        } else if (match("noxfer")) {
                                status_arg = DD_STATUS_NOXFER;
                        } else if (match("progress")) {
                                status_arg = DD_STATUS_PROGRESS;
                        } else {
                                goto badarg;
                        }
                        continue;
                }
                badarg:
                (void) fprintf(stderr, "dd: %s \"%s\"\n",
                    gettext("bad argument:"), string);
                exit(2);
        }

        /* Perform consistency checks on options, decode strange conventions */

        if (bs) {
                ibs = obs = bs;
        }
        if ((ibs == 0) || (obs == 0)) {
                (void) fprintf(stderr, "dd: %s\n",
                    gettext("buffer sizes cannot be zero"));
                exit(2);
        }
        if (ostriden == (off_t)-1) {
                (void) fprintf(stderr, "dd: %s\n",
                    gettext("stride must be greater than zero"));
                exit(2);
        }
        if (istriden == (off_t)-1) {
                (void) fprintf(stderr, "dd: %s\n",
                    gettext("stride must be greater than zero"));
                exit(2);
        }
        if (conv == COPY) {
                if ((bs == 0) || (cflag & (LCASE | UCASE))) {
                        conv = REBLOCK;
                }
        }
        if (cbs == 0) {
                switch (conv) {
                case BLOCK:
                case UNBLOCK:
                        conv = REBLOCK;
                        break;

                case ASCII:
                        conv = NBASCII;
                        break;

                case EBCDIC:
                        conv = NBEBCDIC;
                        break;

                case IBM:
                        conv = NBIBM;
                        break;
                }
        }

        /* Expand options into lower and upper case versions if necessary */

        switch (conv) {
        case REBLOCK:
                if (cflag & LCASE)
                        conv = LCREBLOCK;
                else if (cflag & UCASE)
                        conv = UCREBLOCK;
                break;

        case UNBLOCK:
                if (cflag & LCASE)
                        conv = LCUNBLOCK;
                else if (cflag & UCASE)
                        conv = UCUNBLOCK;
                break;

        case BLOCK:
                if (cflag & LCASE)
                        conv = LCBLOCK;
                else if (cflag & UCASE)
                        conv = UCBLOCK;
                break;

        case ASCII:
                if (cflag & LCASE)
                        conv = LCASCII;
                else if (cflag & UCASE)
                        conv = UCASCII;
                break;

        case NBASCII:
                if (cflag & LCASE)
                        conv = LCNBASCII;
                else if (cflag & UCASE)
                        conv = UCNBASCII;
                break;

        case EBCDIC:
                if (cflag & LCASE)
                        conv = LCEBCDIC;
                else if (cflag & UCASE)
                        conv = UCEBCDIC;
                break;

        case NBEBCDIC:
                if (cflag & LCASE)
                        conv = LCNBEBCDIC;
                else if (cflag & UCASE)
                        conv = UCNBEBCDIC;
                break;

        case IBM:
                if (cflag & LCASE)
                        conv = LCIBM;
                else if (cflag & UCASE)
                        conv = UCIBM;
                break;

        case NBIBM:
                if (cflag & LCASE)
                        conv = LCNBIBM;
                else if (cflag & UCASE)
                        conv = UCNBIBM;
                break;
        }

        /* If BSD-compatible translation is selected, change the tables */

        if (trantype == BSDXLATE) {
                atoe = bsd_atoe;
                atoibm = bsd_atoibm;
                etoa = bsd_etoa;
        }
        /* Open the input file, or duplicate standard input */

        ibf = -1;
        if (ifile) {
                ibf = open(ifile, 0);
        } else {
                ifile = "";
                ibf = dup(STDIN_FILENO);
        }

        if (ibf == -1) {
                (void) fprintf(stderr, "dd: %s: ", ifile);
                perror("open");
                exit(2);
        }

        /* Open the output file, or duplicate standard output */

        obf = -1;
        if (ofile) {
                if (trunc == 0) {       /* do not truncate output file */
                        obf = open(ofile, (O_WRONLY | O_CREAT | oflag),
                            (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
                            S_IROTH | S_IWOTH));
                } else if (oseekn && (trunc == 1)) {
                        obf = open(ofile, O_WRONLY | O_CREAT | oflag,
                            (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
                            S_IROTH | S_IWOTH));
                        if (obf == -1) {
                                (void) fprintf(stderr, "dd: %s: ", ofile);
                                perror("open");
                                exit(2);
                        }
                        (void) fstat(obf, &file_stat);
                        if (((file_stat.st_mode & S_IFMT) == S_IFREG) &&
                            (ftruncate(obf, (((off_t)oseekn) * ((off_t)obs)))
                            == -1)) {
                                perror("ftruncate");
                                exit(2);
                        }
                } else {
                        obf = open(ofile, O_WRONLY | O_CREAT | O_TRUNC | oflag,
                            (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
                            S_IROTH | S_IWOTH));
                }
        } else {
                ofile = "";
                obf = dup(STDOUT_FILENO);
        }

        if (obf == -1) {
                (void) fprintf(stderr, "dd: %s: ", ofile);
                perror("open");
                exit(2);
        }

        /* Expand memory to get an input buffer */

        ibuf = (unsigned char *)valloc(ibs + 10);

        /* If no conversions, the input buffer is the output buffer */

        if (conv == COPY) {
                obuf = ibuf;
        } else {

                /*
                 * Expand memory to get an output buffer. Leave enough room
                 * at the end to convert a logical record when doing block
                 * conversions.
                 */

                obuf = (unsigned char *)valloc(obs + cbs + 10);
        }
        if ((ibuf == NULL) || (obuf == NULL)) {
                (void) fprintf(stderr,
                    "dd: %s\n", gettext("not enough memory"));
                exit(2);
        }

        /*
         * Enable a statistics message when we terminate on SIGINT
         * Also enable it to be queried via SIGINFO and SIGUSR1
         */

        if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
                (void) signal(SIGINT, term);
        }

        bzero(&sact, sizeof (struct sigaction));
        sact.sa_flags = SA_SIGINFO;
        sact.sa_sigaction = siginfo_handler;
        (void) sigemptyset(&sact.sa_mask);
        if (sigaction(SIGINFO, &sact, NULL) != 0) {
                (void) fprintf(stderr, "dd: %s: %s\n",
                    gettext("failed to enable siginfo handler"),
                    gettext(strerror(errno)));
                exit(2);
        }
        if (sigaction(SIGUSR1, &sact, NULL) != 0) {
                (void) fprintf(stderr, "dd: %s: %s\n",
                    gettext("failed to enable sigusr1 handler"),
                    gettext(strerror(errno)));
                exit(2);
        }

        /*
         * Determine if stderr is a tty in case someone has invoked
         * status=progress
         */
        if (isatty(STDERR_FILENO) == 1) {
                stderr_tty = B_TRUE;
        }

        /* Skip input blocks */

        while (skip) {
                ibc = iread(ibf, (char *)ibuf, ibs);
                if (ibc == (unsigned)-1) {
                        if (++nbad > BADLIMIT) {
                                (void) fprintf(stderr, "dd: %s\n",
                                    gettext("skip failed"));
                                exit(2);
                        } else {
                                perror("read");
                        }
                } else {
                        if (ibc == 0) {
                                (void) fprintf(stderr, "dd: %s\n",
                                gettext("cannot skip past end-of-file"));
                                exit(3);
                        } else {
                                nbad = 0;
                        }
                }
                skip--;
        }

        /* Seek past input blocks */

        if (iseekn && lseek(ibf, (((off_t)iseekn) * ((off_t)ibs)), 1) == -1) {
                perror("lseek");
                exit(2);
        }

        /* Seek past output blocks */

        if (oseekn && lseek(obf, (((off_t)oseekn) * ((off_t)obs)), 1) == -1) {
                perror("lseek");
                exit(2);
        }

        /* Initialize all buffer pointers */

        skipf = 0;      /* not skipping an input line */
        ibc = 0;        /* no input characters yet */
        obc = 0;        /* no output characters yet */
        cbc = 0;        /* the conversion buffer is empty */
        op = obuf;      /* point to the output buffer */

        /* Read and convert input blocks until end of file(s) */

        /* Grab our start time for siginfo purposes */
        startt = gethrtime();

        for (;;) {
                /*
                 * Always call into the stats function which will check for
                 * siginfo and related processing that needs to happen.
                 */
                stats(B_TRUE);

                if ((count == 0 && ecount == B_FALSE) || (nifr+nipr < count)) {
                /* If proceed on error is enabled, zero the input buffer */

                        if (cflag & NERR) {
                                ip = ibuf + ibs;
                                c = ibs;
                                if (c & 1)      /* if the size is odd, */
                                {
                                        *--ip = 0;      /* clear the odd byte */
                                }
                                if (c >>= 1)            /* divide by two */
                                {
                                        do {    /* clear two at a time */
                                                *--ip = 0;
                                                *--ip = 0;
                                        } while (--c);
                                }
                        }

                        /* Read the next input block */

                        ibc = iread(ibf, (char *)ibuf, ibs);

                        if (istriden > 0 && lseek(ibf, istriden * ((off_t)ibs),
                            SEEK_CUR) == -1) {
                                perror("lseek");
                                exit(2);
                        }

                        /* Process input errors */

                        if (ibc == (unsigned)-1) {
                                perror("read");
                                if (((cflag & NERR) == 0) ||
                                    (++nbad > BADLIMIT)) {
                                        while (obc) {
                                                (void) flsh();
                                        }
                                        term(2);
                                } else {
                                        stats(B_FALSE);
                                        ibc = ibs; /* assume a full block */
                                }
                        } else {
                                nbad = 0;
                        }
                } else {
                        /* Record count satisfied, simulate end of file */
                        ibc = 0;
                        files = 1;
                }

                /* Process end of file */

                if (ibc == 0) {
                        switch (conv) {
                        case UNBLOCK:
                        case LCUNBLOCK:
                        case UCUNBLOCK:
                        case ASCII:
                        case LCASCII:
                        case UCASCII:

                                /* Trim trailing blanks from the last line */

                                if ((c = cbc) != 0) {
                                        do {
                                                if ((*--op) != ' ') {
                                                        op++;
                                                        break;
                                                }
                                        } while (--c);
                                        *op++ = '\n';
                                        obc -= cbc - c - 1;
                                        cbc = 0;

                                        /* Flush the output buffer if full */

                                        while (obc >= obs) {
                                                op = flsh();
                                        }
                                }
                                break;

                        case BLOCK:
                        case LCBLOCK:
                        case UCBLOCK:
                        case EBCDIC:
                        case LCEBCDIC:
                        case UCEBCDIC:
                        case IBM:
                        case LCIBM:
                        case UCIBM:

                        /* Pad trailing blanks if the last line is short */

                                if (cbc) {
                                        obc += c = cbs - cbc;
                                        cbc = 0;
                                        if (c > 0) {
                                        /* Use the right kind of blank */

                                                switch (conv) {
                                                case BLOCK:
                                                case LCBLOCK:
                                                case UCBLOCK:
                                                        ic = ' ';
                                                        break;

                                                case EBCDIC:
                                                case LCEBCDIC:
                                                case UCEBCDIC:
                                                        ic = atoe[' '];
                                                        break;

                                                case IBM:
                                                case LCIBM:
                                                case UCIBM:
                                                        ic = atoibm[' '];
                                                        break;
                                                }

                                                /* Pad with trailing blanks */

                                                do {
                                                        *op++ = ic;
                                                } while (--c);
                                        }
                                }


                                /* Flush the output buffer if full */

                                while (obc >= obs) {
                                        op = flsh();
                                }
                                break;
                        }

                        /* If no more files to read, flush the output buffer */

                        if (--files <= 0) {
                                (void) flsh();
                                if ((close(obf) != 0) ||
                                    (fclose(stdout) != 0)) {
                                        perror(gettext("dd: close error"));
                                        exit(2);
                                }
                                term(0);        /* successful exit */
                        } else {
                                continue;       /* read the next file */
                        }
                } else if (ibc == ibs) {
                        /* Normal read, check for special cases */
                        nifr++;         /* count another full input record */
                } else {
                        nipr++;         /* count a partial input record */

                        /* If `sync' enabled, pad nulls */

                        if ((cflag & SYNC) && ((cflag & NERR) == 0)) {
                                c = ibs - ibc;
                                ip = ibuf + ibs;
                                do {
                                        if ((conv == BLOCK) ||
                                            (conv == UNBLOCK))
                                                *--ip = ' ';
                                        else
                                                *--ip = '\0';
                                } while (--c);
                                ibc = ibs;
                        }
                }

                /* Swap the bytes in the input buffer if necessary */

                if (cflag & SWAB) {
                        ip = ibuf;
                        if (ibc & 1) {  /* if the byte count is odd, */
                                ip[ibc] = 0;  /* make it even, pad with zero */
                        }
                        c = ibc >> 1;   /* compute the pair count */
                        do {
                                ic = *ip++;
                                ip[-1] = *ip;
                                *ip++ = ic;
                        } while (--c);          /* do two bytes at a time */
                }

                /* Select the appropriate conversion loop */

                ip = ibuf;
                switch (conv) {

                /* Simple copy: no conversion, preserve the input block size */

                case COPY:
                        obc = ibc;
                        (void) flsh();
                        break;

                /* Simple copy: pack all output into equal sized blocks */

                case REBLOCK:
                case LCREBLOCK:
                case UCREBLOCK:
                case NBASCII:
                case LCNBASCII:
                case UCNBASCII:
                case NBEBCDIC:
                case LCNBEBCDIC:
                case UCNBEBCDIC:
                case NBIBM:
                case LCNBIBM:
                case UCNBIBM:
                        while ((c = ibc) != 0) {
                                if (c > (obs - obc)) {
                                        c = obs - obc;
                                }
                                ibc -= c;
                                obc += c;
                                switch (conv) {
                                case REBLOCK:
                                        do {
                                                *op++ = *ip++;
                                        } while (--c);
                                        break;

                                case LCREBLOCK:
                                        do {
                                                *op++ = utol[*ip++];
                                        } while (--c);
                                        break;

                                case UCREBLOCK:
                                        do {
                                                *op++ = ltou[*ip++];
                                        } while (--c);
                                        break;

                                case NBASCII:
                                        do {
                                                *op++ = etoa[*ip++];
                                        } while (--c);
                                        break;

                                case LCNBASCII:
                                        do {
                                                *op++ = utol[etoa[*ip++]];
                                        } while (--c);
                                        break;

                                case UCNBASCII:
                                        do {
                                                *op++ = ltou[etoa[*ip++]];
                                        } while (--c);
                                        break;

                                case NBEBCDIC:
                                        do {
                                                *op++ = atoe[*ip++];
                                        } while (--c);
                                        break;

                                case LCNBEBCDIC:
                                        do {
                                                *op++ = atoe[utol[*ip++]];
                                        } while (--c);
                                        break;

                                case UCNBEBCDIC:
                                        do {
                                                *op++ = atoe[ltou[*ip++]];
                                        } while (--c);
                                        break;

                                case NBIBM:
                                        do {
                                                *op++ = atoibm[*ip++];
                                        } while (--c);
                                        break;

                                case LCNBIBM:
                                        do {
                                                *op++ = atoibm[utol[*ip++]];
                                        } while (--c);
                                        break;

                                case UCNBIBM:
                                        do {
                                                *op++ = atoibm[ltou[*ip++]];
                                        } while (--c);
                                        break;
                                }
                                if (obc >= obs) {
                                        op = flsh();
                                }
                        }
                        break;

        /* Convert from blocked records to lines terminated by newline */

                case UNBLOCK:
                case LCUNBLOCK:
                case UCUNBLOCK:
                case ASCII:
                case LCASCII:
                case UCASCII:
                        while ((c = ibc) != 0) {
                                if (c > (cbs - cbc)) {
                                        /* if more than one record, */
                                        c = cbs - cbc;
                                        /* only copy one record */
                                }
                                ibc -= c;
                                cbc += c;
                                obc += c;
                                switch (conv) {
                                case UNBLOCK:
                                        do {
                                                *op++ = *ip++;
                                        } while (--c);
                                        break;

                                case LCUNBLOCK:
                                        do {
                                                *op++ = utol[*ip++];
                                        } while (--c);
                                        break;

                                case UCUNBLOCK:
                                        do {
                                                *op++ = ltou[*ip++];
                                        } while (--c);
                                        break;

                                case ASCII:
                                        do {
                                                *op++ = etoa[*ip++];
                                        } while (--c);
                                        break;

                                case LCASCII:
                                        do {
                                                *op++ = utol[etoa[*ip++]];
                                        } while (--c);
                                        break;

                                case UCASCII:
                                        do {
                                                *op++ = ltou[etoa[*ip++]];
                                        } while (--c);
                                        break;
                                }

                                /* Trim trailing blanks if the line is full */

                                if (cbc == cbs) {
                                        c = cbs; /* `do - while' is usually */
                                        do {            /* faster than `for' */
                                                if ((*--op) != ' ') {
                                                        op++;
                                                        break;
                                                }
                                        } while (--c);
                                        *op++ = '\n';
                                        obc -= cbs - c - 1;
                                        cbc = 0;

                                        /* Flush the output buffer if full */

                                        while (obc >= obs) {
                                                op = flsh();
                                        }
                                }
                        }
                        break;

                /* Convert to blocked records */

                case BLOCK:
                case LCBLOCK:
                case UCBLOCK:
                case EBCDIC:
                case LCEBCDIC:
                case UCEBCDIC:
                case IBM:
                case LCIBM:
                case UCIBM:
                        while ((c = ibc) != 0) {
                                int nlflag = 0;

                                /*
                                 * We may have to skip to the end of a long
                                 * line.
                                 */

                                if (skipf) {
                                        do {
                                                if ((ic = *ip++) == '\n') {
                                                        skipf = 0;
                                                        c--;
                                                        break;
                                                }
                                        } while (--c);
                                        if ((ibc = c) == 0) {
                                                continue;
                                                /* read another block */
                                        }
                                }

                                /* If anything left, copy until newline */

                                if (c > (cbs - cbc + 1)) {
                                        c = cbs - cbc + 1;
                                }
                                ibc -= c;
                                cbc += c;
                                obc += c;

                                switch (conv) {
                                case BLOCK:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = ic;
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case LCBLOCK:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = utol[ic];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case UCBLOCK:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = ltou[ic];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case EBCDIC:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = atoe[ic];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case LCEBCDIC:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = atoe[utol[ic]];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case UCEBCDIC:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = atoe[ltou[ic]];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case IBM:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ = atoibm[ic];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case LCIBM:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ =
                                                            atoibm[utol[ic]];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;

                                case UCIBM:
                                        do {
                                                if ((ic = *ip++) != '\n') {
                                                        *op++ =
                                                            atoibm[ltou[ic]];
                                                } else {
                                                        nlflag = 1;
                                                        break;
                                                }
                                        } while (--c);
                                        break;
                                }

                        /* If newline found, update all the counters and */
                        /* pointers, pad with trailing blanks if necessary */

                                if (nlflag) {
                                        ibc += c - 1;
                                        obc += cbs - cbc;
                                        c += cbs - cbc;
                                        cbc = 0;
                                        if (c > 0) {
                                        /* Use the right kind of blank */

                                                switch (conv) {
                                                case BLOCK:
                                                case LCBLOCK:
                                                case UCBLOCK:
                                                        ic = ' ';
                                                        break;

                                                case EBCDIC:
                                                case LCEBCDIC:
                                                case UCEBCDIC:
                                                        ic = atoe[' '];
                                                        break;

                                                case IBM:
                                                case LCIBM:
                                                case UCIBM:
                                                        ic = atoibm[' '];
                                                        break;
                                                }

                                                /* Pad with trailing blanks */

                                                do {
                                                        *op++ = ic;
                                                } while (--c);
                                        }
                                }

                        /* If not end of line, this line may be too long */

                                else if (cbc > cbs) {
                                        skipf = 1; /* note skip in progress */
                                        obc--;
                                        op--;
                                        cbc = 0;
                                        ntrunc++;  /* count another long line */
                                }

                                /* Flush the output buffer if full */

                                while (obc >= obs) {
                                        op = flsh();
                                }
                        }
                        break;
                }
        }
        /* NOTREACHED */
        return (0);
}

/* match ************************************************************** */
/*                                                                      */
/* Compare two text strings for equality                                */
/*                                                                      */
/* Arg:         s - pointer to string to match with a command arg       */
/* Global arg:  string - pointer to command arg                         */
/*                                                                      */
/* Return:      1 if match, 0 if no match                               */
/*              If match, also reset `string' to point to the text      */
/*              that follows the matching text.                         */
/*                                                                      */
/* ******************************************************************** */

static int
match(char *s)
{
        char *cs;

        cs = string;
        while (*cs++ == *s) {
                if (*s++ == '\0') {
                        goto true;
                }
        }
        if (*s != '\0') {
                return (0);
        }

true:
        cs--;
        string = cs;
        return (1);
}

/* number ************************************************************* */
/*                                                                      */
/* Convert a numeric arg to binary                                      */
/*                                                                      */
/* Arg:         big - maximum valid input number                        */
/* Global arg:  string - pointer to command arg                         */
/*                                                                      */
/* Valid forms: 123 | 123k | 123M | 123G | 123T | 123P | 123E | 123Z |  */
/*              123w | 123b | 123*123 | 123x123                         */
/*              plus combinations such as 2b*3kw*4w                     */
/*                                                                      */
/* Return:      converted number                                        */
/*                                                                      */
/* ******************************************************************** */

static unsigned long long
number(long long big)
{
        char *cs;
        long long n;
        long long cut = BIG / 10;       /* limit to avoid overflow */

        cs = string;
        n = 0;
        while ((*cs >= '0') && (*cs <= '9') && (n <= cut)) {
                n = n * 10 + *cs++ - '0';
        }
        for (;;) {
                switch (*cs++) {

                case 'Z':
                        n *= 1024;
                        /* FALLTHROUGH */

                case 'E':
                        n *= 1024;
                        /* FALLTHROUGH */

                case 'P':
                        n *= 1024;
                        /* FALLTHROUGH */

                case 'T':
                        n *= 1024;
                        /* FALLTHROUGH */

                case 'G':
                        n *= 1024;
                        /* FALLTHROUGH */

                case 'M':
                        n *= 1024;
                        /* FALLTHROUGH */

                case 'k':
                        n *= 1024;
                        continue;

                case 'w':
                        n *= 2;
                        continue;

                case 'b':
                        n *= BSIZE;
                        continue;

                case '*':
                case 'x':
                        string = cs;
                        n *= number(BIG);

                /* FALLTHROUGH */
                /* Fall into exit test, recursion has read rest of string */
                /* End of string, check for a valid number */

                case '\0':
                        if ((n > big) || (n < 0)) {
                                (void) fprintf(stderr, "dd: %s \"%llu\"\n",
                                    gettext("argument out of range:"), n);
                                exit(2);
                        }
                        return (n);

                default:
                        (void) fprintf(stderr, "dd: %s \"%s\"\n",
                            gettext("bad numeric argument:"), string);
                        exit(2);
                }
        } /* never gets here */
}

/* flsh *************************************************************** */
/*                                                                      */
/* Flush the output buffer, move any excess bytes down to the beginning */
/*                                                                      */
/* Arg:         none                                                    */
/* Global args: obuf, obc, obs, nofr, nopr, ostriden                    */
/*                                                                      */
/* Return:      Pointer to the first free byte in the output buffer.    */
/*              Also reset `obc' to account for moved bytes.            */
/*                                                                      */
/* ******************************************************************** */

static unsigned char *
flsh(void)
{
        unsigned char *op, *cp;
        int bc;
        unsigned int oc;

        if (obc) {                      /* don't flush if the buffer is empty */
                if (obc >= obs) {
                        oc = obs;
                        nofr++;         /* count a full output buffer */
                } else {
                        oc = obc;
                        nopr++;         /* count a partial output buffer */
                }
                bc = write(obf, (char *)obuf, oc);
                if (bc != oc) {
                        if (bc < 0) {
                                perror("write");
                        } else {
                                (void) fprintf(stderr,
                                    gettext("dd: unexpected short write, "
                                    "wrote %d bytes, expected %d\n"), bc, oc);
                        }
                        term(2);
                }

                if (ostriden > 0 && lseek(obf, ostriden * ((off_t)obs),
                    SEEK_CUR) == -1) {
                        perror("lseek");
                        exit(2);
                }

                obc -= oc;
                op = obuf;
                obytes += bc;

                /* If any data in the conversion buffer, move it into */
                /* the output buffer */

                if (obc) {
                        cp = obuf + obs;
                        bc = obc;
                        do {
                                *op++ = *cp++;
                        } while (--bc);
                }
                return (op);
        }
        return (obuf);
}

/* term *************************************************************** */
/*                                                                      */
/* Write record statistics, then exit                                   */
/*                                                                      */
/* Arg:         c - exit status code                                    */
/*                                                                      */
/* Return:      no return, calls exit                                   */
/*                                                                      */
/* ******************************************************************** */

static void
term(int c)
{
        stats(B_FALSE);
        exit(c);
}

/* stats ************************************************************** */
/*                                                                      */
/* Write record statistics onto standard error                          */
/*                                                                      */
/* Args:        main_loop - whether or not we were called from the main */
/*                          loop and need to consider the siginfo       */
/*                          handler or status=progress output           */
/* Global args: nifr, nipr, nofr, nopr, ntrunc, obytes                  */
/*                                                                      */
/* Return:      void                                                    */
/*                                                                      */
/* ******************************************************************** */

static void
stats(boolean_t main_loop)
{
        hrtime_t delta = gethrtime() - startt;
        double secs = delta * 1e-9;
        char bps[NN_NUMBUF_SZ], hobytes[NN_NUMBUF_SZ];
        boolean_t is_progress = B_FALSE;
        const char *head = "";
        const char *tail = "\n";

        /*
         * If we've been asked to not print this, then never do.
         */
        if (status_arg == DD_STATUS_NONE) {
                return;
        }

        /*
         * If we came here from the main loop, then we need to go through and
         * determine if we need to do anything at all. There are two cases that
         * we will have to do something:
         *
         * 1) We were asked to by the siginfo handler
         * 2) We are here from the status=progress handler and enough time has
         *    elapsed since the last time we printed (e.g. 1s)
         *
         * We always let the siginfo handler take priority here.
         */
        if (main_loop) {
                if (nstats == 0 && status_arg != DD_STATUS_PROGRESS) {
                        return;
                }

                if (nstats == 0 && status_arg == DD_STATUS_PROGRESS) {
                        uint64_t num_secs = delta / NANOSEC;

                        if (num_secs <= prog_secs) {
                                return;
                        }

                        prog_secs = num_secs;
                        is_progress = B_TRUE;
                        if (stderr_tty) {
                                head = "\r";
                                tail = "";
                        }
                }

                if (nstats == 1) {
                        nstats = 0;
                }
        }

        /*
         * When we output to a tty with status=progress we do so by only
         * emitting carriage returns and overwriting. This means that when we
         * come in here for any other reason we need to emit a new line so we
         * don't end up clobbering anything.
         *
         * The progress_printed boolean is basically here to make sure we have
         * actually printed out a status line that would cause us to need a new
         * line. If we finished say after a SIGINFO output but before the next
         * progress output this would result in an extraneous newline.
         */
        if (!is_progress && status_arg == DD_STATUS_PROGRESS && stderr_tty &&
            progress_printed) {
                (void) fputc('\n', stderr);
        }

        if (!is_progress) {
                (void) fprintf(stderr, gettext("%llu+%llu records in\n"),
                    nifr, nipr);
                (void) fprintf(stderr, gettext("%llu+%llu records out\n"),
                    nofr, nopr);
                if (ntrunc) {
                        (void) fprintf(stderr,
                            gettext("%llu truncated record(s)\n"), ntrunc);
                }
        }

        /*
         * If we got here before we started copying somehow, don't bother
         * printing the rest.
         */
        if (startt == 0 || status_arg == DD_STATUS_NOXFER)
                return;

        nicenum_scale((uint64_t)obytes / secs, 1, bps, sizeof (bps),
            NN_UNIT_SPACE);
        nicenum_scale(obytes, 1, hobytes, sizeof (hobytes), NN_UNIT_SPACE);
        (void) fprintf(stderr,
            gettext("%s%llu bytes (%siB) transferred in %.6f secs "
            "(%siB/sec)%s"), head, obytes, hobytes, secs, bps, tail);

        progress_printed = is_progress;
}