xref: /illumos-gate/usr/src/cmd/dd/dd.c (revision b928ac84)
1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License, Version 1.0 only
6  * (the "License").  You may not use this file except in compliance
7  * with the License.
8  *
9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10  * or http://www.opensolaris.org/os/licensing.
11  * See the License for the specific language governing permissions
12  * and limitations under the License.
13  *
14  * When distributing Covered Code, include this CDDL HEADER in each
15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16  * If applicable, add the following below this CDDL HEADER, with the
17  * fields enclosed by brackets "[]" replaced with your own identifying
18  * information: Portions Copyright [yyyy] [name of copyright owner]
19  *
20  * CDDL HEADER END
21  */
22 
23 /*
24  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
25  * Use is subject to license terms.
26  * Copyright 2012, Josef 'Jeff' Sipek <jeffpc@31bits.net>. All rights reserved.
27  * Copyright (c) 2014, Joyent, Inc.  All rights reserved.
28  * Copyright (c) 2014 by Delphix. All rights reserved.
29  */
30 
31 /*	Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T	*/
32 /*		All Rights Reserved	*/
33 
34 /*
35  *	convert and copy
36  */
37 
38 #include	<stdio.h>
39 #include	<signal.h>
40 #include	<fcntl.h>
41 #include	<sys/param.h>
42 #include	<sys/types.h>
43 #include	<sys/sysmacros.h>
44 #include	<sys/stat.h>
45 #include	<unistd.h>
46 #include	<stdlib.h>
47 #include	<locale.h>
48 #include	<string.h>
49 #include	<sys/time.h>
50 #include	<errno.h>
51 #include	<strings.h>
52 #include	<libcmdutils.h>
53 
54 /* The BIG parameter is machine dependent.  It should be a long integer	*/
55 /* constant that can be used by the number parser to check the validity	*/
56 /* of numeric parameters.  On 16-bit machines, it should probably be	*/
57 /* the maximum unsigned integer, 0177777L.  On 32-bit machines where	*/
58 /* longs are the same size as ints, the maximum signed integer is more	*/
59 /* appropriate.  This value is 017777777777L. In 64 bit environments,   */
60 /* the maximum signed integer value is 0777777777777777777777LL		*/
61 
62 #define	BIG	0777777777777777777777LL
63 
64 #define	BSIZE	512
65 
66 /* Option parameters */
67 
68 #define	COPY		0	/* file copy, preserve input block size */
69 #define	REBLOCK		1	/* file copy, change block size */
70 #define	LCREBLOCK	2	/* file copy, convert to lower case */
71 #define	UCREBLOCK	3	/* file copy, convert to upper case */
72 #define	NBASCII		4	/* file copy, convert from EBCDIC to ASCII */
73 #define	LCNBASCII	5	/* file copy, EBCDIC to lower case ASCII */
74 #define	UCNBASCII	6	/* file copy, EBCDIC to upper case ASCII */
75 #define	NBEBCDIC	7	/* file copy, convert from ASCII to EBCDIC */
76 #define	LCNBEBCDIC	8	/* file copy, ASCII to lower case EBCDIC */
77 #define	UCNBEBCDIC	9	/* file copy, ASCII to upper case EBCDIC */
78 #define	NBIBM		10	/* file copy, convert from ASCII to IBM */
79 #define	LCNBIBM		11	/* file copy, ASCII to lower case IBM */
80 #define	UCNBIBM		12	/* file copy, ASCII to upper case IBM */
81 #define	UNBLOCK		13	/* convert blocked ASCII to ASCII */
82 #define	LCUNBLOCK	14	/* convert blocked ASCII to lower case ASCII */
83 #define	UCUNBLOCK	15	/* convert blocked ASCII to upper case ASCII */
84 #define	ASCII		16	/* convert blocked EBCDIC to ASCII */
85 #define	LCASCII		17	/* convert blocked EBCDIC to lower case ASCII */
86 #define	UCASCII		18	/* convert blocked EBCDIC to upper case ASCII */
87 #define	BLOCK		19	/* convert ASCII to blocked ASCII */
88 #define	LCBLOCK		20	/* convert ASCII to lower case blocked ASCII */
89 #define	UCBLOCK		21	/* convert ASCII to upper case blocked ASCII */
90 #define	EBCDIC		22	/* convert ASCII to blocked EBCDIC */
91 #define	LCEBCDIC	23	/* convert ASCII to lower case blocked EBCDIC */
92 #define	UCEBCDIC	24	/* convert ASCII to upper case blocked EBCDIC */
93 #define	IBM		25	/* convert ASCII to blocked IBM */
94 #define	LCIBM		26	/* convert ASCII to lower case blocked IBM */
95 #define	UCIBM		27	/* convert ASCII to upper case blocked IBM */
96 #define	LCASE		01	/* flag - convert to lower case */
97 #define	UCASE		02	/* flag - convert to upper case */
98 #define	SWAB		04	/* flag - swap bytes before conversion */
99 #define	NERR		010	/* flag - proceed on input errors */
100 #define	SYNC		020	/* flag - pad short input blocks with nulls */
101 #define	BADLIMIT	5	/* give up if no progress after BADLIMIT trys */
102 #define	SVR4XLATE	0	/* use default EBCDIC translation */
103 #define	BSDXLATE	1	/* use BSD-compatible EBCDIC translation */
104 
105 #define	USAGE\
106 	"usage: dd [if=file] [of=file] [ibs=n|nk|nb|nxm] [obs=n|nk|nb|nxm]\n"\
107 	"	   [bs=n|nk|nb|nxm] [cbs=n|nk|nb|nxm] [files=n] [skip=n]\n"\
108 	"	   [iseek=n] [oseek=n] [seek=n] [stride=n] [istride=n]\n"\
109 	"	   [ostride=n] [count=n] [conv=[ascii] [,ebcdic][,ibm]\n"\
110 	"	   [,asciib][,ebcdicb][,ibmb][,block|unblock][,lcase|ucase]\n"\
111 	"	   [,swab][,noerror][,notrunc][,sync]]\n"\
112 	"	   [oflag=[dsync][sync]]\n"
113 
114 /* Global references */
115 
116 /* Local routine declarations */
117 
118 static int	match(char *);
119 static void		term();
120 static unsigned long long	number();
121 static unsigned char	*flsh();
122 static void		stats();
123 
124 /* Local data definitions */
125 
126 static unsigned ibs;	/* input buffer size */
127 static unsigned obs;	/* output buffer size */
128 static unsigned bs;	/* buffer size, overrules ibs and obs */
129 static unsigned cbs;	/* conversion buffer size, used for block conversions */
130 static unsigned ibc;	/* number of bytes still in the input buffer */
131 static unsigned obc;	/* number of bytes in the output buffer */
132 static unsigned cbc;	/* number of bytes in the conversion buffer */
133 
134 static int	ibf;	/* input file descriptor */
135 static int	obf;	/* output file descriptor */
136 static int	cflag;	/* conversion option flags */
137 static int	oflag;	/* output flag options */
138 static int	skipf;	/* if skipf == 1, skip rest of input line */
139 static unsigned long long	nifr;	/* count of full input records */
140 static unsigned long long	nipr;	/* count of partial input records */
141 static unsigned long long	nofr;	/* count of full output records */
142 static unsigned long long	nopr;	/* count of partial output records */
143 static unsigned long long	ntrunc;	/* count of truncated input lines */
144 static unsigned long long	nbad;	/* count of bad records since last */
145 					/* good one */
146 static int	files;	/* number of input files to concatenate (tape only) */
147 static off_t	skip;	/* number of input records to skip */
148 static off_t	iseekn;	/* number of input records to seek past */
149 static off_t	oseekn;	/* number of output records to seek past */
150 static unsigned long long	count;	/* number of input records to copy */
151 			/* (0 = all) */
152 static boolean_t ecount;	/* explicit count given */
153 static off_t	ostriden;	/* number of output blocks to skip between */
154 				/* records */
155 static off_t	istriden;	/* number of input blocks to skip between */
156 				/* records */
157 
158 static int	trantype; /* BSD or SVr4 compatible EBCDIC */
159 
160 static char		*string;	/* command arg pointer */
161 static char		*ifile;		/* input file name pointer */
162 static char		*ofile;		/* output file name pointer */
163 static unsigned char	*ibuf;		/* input buffer pointer */
164 static unsigned char	*obuf;		/* output buffer pointer */
165 
166 static hrtime_t		startt;		/* hrtime copy started */
167 static unsigned long long	obytes;	/* output bytes */
168 static sig_atomic_t	nstats;		/* do we need to output stats */
169 
170 /* This is an EBCDIC to ASCII conversion table	*/
171 /* from a proposed BTL standard April 16, 1979	*/
172 
173 static unsigned char svr4_etoa[] =
174 {
175 	0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177,
176 	0227, 0215, 0216, 0013, 0014, 0015, 0016, 0017,
177 	0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207,
178 	0030, 0031, 0222, 0217, 0034, 0035, 0036, 0037,
179 	0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033,
180 	0210, 0211, 0212, 0213, 0214, 0005, 0006, 0007,
181 	0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004,
182 	0230, 0231, 0232, 0233, 0024, 0025, 0236, 0032,
183 	0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
184 	0247, 0250, 0325, 0056, 0074, 0050, 0053, 0174,
185 	0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
186 	0260, 0261, 0041, 0044, 0052, 0051, 0073, 0176,
187 	0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
188 	0270, 0271, 0313, 0054, 0045, 0137, 0076, 0077,
189 	0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
190 	0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
191 	0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
192 	0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
193 	0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
194 	0161, 0162, 0136, 0314, 0315, 0316, 0317, 0320,
195 	0321, 0345, 0163, 0164, 0165, 0166, 0167, 0170,
196 	0171, 0172, 0322, 0323, 0324, 0133, 0326, 0327,
197 	0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
198 	0340, 0341, 0342, 0343, 0344, 0135, 0346, 0347,
199 	0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
200 	0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
201 	0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
202 	0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
203 	0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
204 	0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
205 	0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
206 	0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377,
207 };
208 
209 /* This is an ASCII to EBCDIC conversion table	*/
210 /* from a proposed BTL standard April 16, 1979	*/
211 
212 static unsigned char svr4_atoe[] =
213 {
214 	0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
215 	0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
216 	0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
217 	0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
218 	0100, 0132, 0177, 0173, 0133, 0154, 0120, 0175,
219 	0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
220 	0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
221 	0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
222 	0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
223 	0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
224 	0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
225 	0347, 0350, 0351, 0255, 0340, 0275, 0232, 0155,
226 	0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
227 	0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
228 	0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
229 	0247, 0250, 0251, 0300, 0117, 0320, 0137, 0007,
230 	0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
231 	0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
232 	0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
233 	0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
234 	0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
235 	0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
236 	0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
237 	0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
238 	0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
239 	0216, 0217, 0220, 0152, 0233, 0234, 0235, 0236,
240 	0237, 0240, 0252, 0253, 0254, 0112, 0256, 0257,
241 	0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
242 	0270, 0271, 0272, 0273, 0274, 0241, 0276, 0277,
243 	0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
244 	0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
245 	0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
246 };
247 
248 /* Table for ASCII to IBM (alternate EBCDIC) code conversion	*/
249 
250 static unsigned char svr4_atoibm[] =
251 {
252 	0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
253 	0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
254 	0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
255 	0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
256 	0100, 0132, 0177, 0173, 0133, 0154, 0120, 0175,
257 	0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
258 	0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
259 	0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
260 	0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
261 	0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
262 	0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
263 	0347, 0350, 0351, 0255, 0340, 0275, 0137, 0155,
264 	0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
265 	0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
266 	0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
267 	0247, 0250, 0251, 0300, 0117, 0320, 0241, 0007,
268 	0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
269 	0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
270 	0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
271 	0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
272 	0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
273 	0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
274 	0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
275 	0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
276 	0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
277 	0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236,
278 	0237, 0240, 0252, 0253, 0254, 0255, 0256, 0257,
279 	0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
280 	0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
281 	0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
282 	0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
283 	0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
284 };
285 
286 /* Table for conversion of ASCII to lower case ASCII	*/
287 
288 static unsigned char utol[] =
289 {
290 	0000, 0001, 0002, 0003, 0004, 0005, 0006, 0007,
291 	0010, 0011, 0012, 0013, 0014, 0015, 0016, 0017,
292 	0020, 0021, 0022, 0023, 0024, 0025, 0026, 0027,
293 	0030, 0031, 0032, 0033, 0034, 0035, 0036, 0037,
294 	0040, 0041, 0042, 0043, 0044, 0045, 0046, 0047,
295 	0050, 0051, 0052, 0053, 0054, 0055, 0056, 0057,
296 	0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
297 	0070, 0071, 0072, 0073, 0074, 0075, 0076, 0077,
298 	0100, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
299 	0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
300 	0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
301 	0170, 0171, 0172, 0133, 0134, 0135, 0136, 0137,
302 	0140, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
303 	0150, 0151, 0152, 0153, 0154, 0155, 0156, 0157,
304 	0160, 0161, 0162, 0163, 0164, 0165, 0166, 0167,
305 	0170, 0171, 0172, 0173, 0174, 0175, 0176, 0177,
306 	0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
307 	0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217,
308 	0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227,
309 	0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237,
310 	0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247,
311 	0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
312 	0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
313 	0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
314 	0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
315 	0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317,
316 	0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327,
317 	0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
318 	0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
319 	0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357,
320 	0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
321 	0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377,
322 };
323 
324 /* Table for conversion of ASCII to upper case ASCII	*/
325 
326 static unsigned char ltou[] =
327 {
328 	0000, 0001, 0002, 0003, 0004, 0005, 0006, 0007,
329 	0010, 0011, 0012, 0013, 0014, 0015, 0016, 0017,
330 	0020, 0021, 0022, 0023, 0024, 0025, 0026, 0027,
331 	0030, 0031, 0032, 0033, 0034, 0035, 0036, 0037,
332 	0040, 0041, 0042, 0043, 0044, 0045, 0046, 0047,
333 	0050, 0051, 0052, 0053, 0054, 0055, 0056, 0057,
334 	0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
335 	0070, 0071, 0072, 0073, 0074, 0075, 0076, 0077,
336 	0100, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
337 	0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
338 	0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
339 	0130, 0131, 0132, 0133, 0134, 0135, 0136, 0137,
340 	0140, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
341 	0110, 0111, 0112, 0113, 0114, 0115, 0116, 0117,
342 	0120, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
343 	0130, 0131, 0132, 0173, 0174, 0175, 0176, 0177,
344 	0200, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
345 	0210, 0211, 0212, 0213, 0214, 0215, 0216, 0217,
346 	0220, 0221, 0222, 0223, 0224, 0225, 0226, 0227,
347 	0230, 0231, 0232, 0233, 0234, 0235, 0236, 0237,
348 	0240, 0241, 0242, 0243, 0244, 0245, 0246, 0247,
349 	0250, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
350 	0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
351 	0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
352 	0300, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
353 	0310, 0311, 0312, 0313, 0314, 0315, 0316, 0317,
354 	0320, 0321, 0322, 0323, 0324, 0325, 0326, 0327,
355 	0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
356 	0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
357 	0350, 0351, 0352, 0353, 0354, 0355, 0356, 0357,
358 	0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
359 	0370, 0371, 0372, 0373, 0374, 0375, 0376, 0377,
360 };
361 
362 /* BSD-compatible EBCDIC to ASCII translate table */
363 
364 static unsigned char bsd_etoa[] =
365 {
366 	0000, 0001, 0002, 0003, 0234, 0011, 0206, 0177,
367 	0227, 0215, 0216, 0013, 0014, 0015, 0016, 0017,
368 	0020, 0021, 0022, 0023, 0235, 0205, 0010, 0207,
369 	0030, 0031, 0222, 0217, 0034, 0035, 0036, 0037,
370 	0200, 0201, 0202, 0203, 0204, 0012, 0027, 0033,
371 	0210, 0211, 0212, 0213, 0214, 0005, 0006, 0007,
372 	0220, 0221, 0026, 0223, 0224, 0225, 0226, 0004,
373 	0230, 0231, 0232, 0233, 0024, 0025, 0236, 0032,
374 	0040, 0240, 0241, 0242, 0243, 0244, 0245, 0246,
375 	0247, 0250, 0133, 0056, 0074, 0050, 0053, 0041,
376 	0046, 0251, 0252, 0253, 0254, 0255, 0256, 0257,
377 	0260, 0261, 0135, 0044, 0052, 0051, 0073, 0136,
378 	0055, 0057, 0262, 0263, 0264, 0265, 0266, 0267,
379 	0270, 0271, 0174, 0054, 0045, 0137, 0076, 0077,
380 	0272, 0273, 0274, 0275, 0276, 0277, 0300, 0301,
381 	0302, 0140, 0072, 0043, 0100, 0047, 0075, 0042,
382 	0303, 0141, 0142, 0143, 0144, 0145, 0146, 0147,
383 	0150, 0151, 0304, 0305, 0306, 0307, 0310, 0311,
384 	0312, 0152, 0153, 0154, 0155, 0156, 0157, 0160,
385 	0161, 0162, 0313, 0314, 0315, 0316, 0317, 0320,
386 	0321, 0176, 0163, 0164, 0165, 0166, 0167, 0170,
387 	0171, 0172, 0322, 0323, 0324, 0325, 0326, 0327,
388 	0330, 0331, 0332, 0333, 0334, 0335, 0336, 0337,
389 	0340, 0341, 0342, 0343, 0344, 0345, 0346, 0347,
390 	0173, 0101, 0102, 0103, 0104, 0105, 0106, 0107,
391 	0110, 0111, 0350, 0351, 0352, 0353, 0354, 0355,
392 	0175, 0112, 0113, 0114, 0115, 0116, 0117, 0120,
393 	0121, 0122, 0356, 0357, 0360, 0361, 0362, 0363,
394 	0134, 0237, 0123, 0124, 0125, 0126, 0127, 0130,
395 	0131, 0132, 0364, 0365, 0366, 0367, 0370, 0371,
396 	0060, 0061, 0062, 0063, 0064, 0065, 0066, 0067,
397 	0070, 0071, 0372, 0373, 0374, 0375, 0376, 0377,
398 };
399 
400 /* BSD-compatible ASCII to EBCDIC translate table */
401 
402 static unsigned char bsd_atoe[] =
403 {
404 	0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
405 	0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
406 	0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
407 	0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
408 	0100, 0117, 0177, 0173, 0133, 0154, 0120, 0175,
409 	0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
410 	0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
411 	0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
412 	0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
413 	0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
414 	0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
415 	0347, 0350, 0351, 0112, 0340, 0132, 0137, 0155,
416 	0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
417 	0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
418 	0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
419 	0247, 0250, 0251, 0300, 0152, 0320, 0241, 0007,
420 	0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
421 	0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
422 	0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
423 	0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
424 	0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
425 	0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
426 	0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
427 	0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
428 	0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
429 	0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236,
430 	0237, 0240, 0252, 0253, 0254, 0255, 0256, 0257,
431 	0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
432 	0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
433 	0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
434 	0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
435 	0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
436 };
437 
438 /* BSD-compatible ASCII to IBM translate table */
439 
440 static unsigned char bsd_atoibm[] =
441 {
442 	0000, 0001, 0002, 0003, 0067, 0055, 0056, 0057,
443 	0026, 0005, 0045, 0013, 0014, 0015, 0016, 0017,
444 	0020, 0021, 0022, 0023, 0074, 0075, 0062, 0046,
445 	0030, 0031, 0077, 0047, 0034, 0035, 0036, 0037,
446 	0100, 0132, 0177, 0173, 0133, 0154, 0120, 0175,
447 	0115, 0135, 0134, 0116, 0153, 0140, 0113, 0141,
448 	0360, 0361, 0362, 0363, 0364, 0365, 0366, 0367,
449 	0370, 0371, 0172, 0136, 0114, 0176, 0156, 0157,
450 	0174, 0301, 0302, 0303, 0304, 0305, 0306, 0307,
451 	0310, 0311, 0321, 0322, 0323, 0324, 0325, 0326,
452 	0327, 0330, 0331, 0342, 0343, 0344, 0345, 0346,
453 	0347, 0350, 0351, 0255, 0340, 0275, 0137, 0155,
454 	0171, 0201, 0202, 0203, 0204, 0205, 0206, 0207,
455 	0210, 0211, 0221, 0222, 0223, 0224, 0225, 0226,
456 	0227, 0230, 0231, 0242, 0243, 0244, 0245, 0246,
457 	0247, 0250, 0251, 0300, 0117, 0320, 0241, 0007,
458 	0040, 0041, 0042, 0043, 0044, 0025, 0006, 0027,
459 	0050, 0051, 0052, 0053, 0054, 0011, 0012, 0033,
460 	0060, 0061, 0032, 0063, 0064, 0065, 0066, 0010,
461 	0070, 0071, 0072, 0073, 0004, 0024, 0076, 0341,
462 	0101, 0102, 0103, 0104, 0105, 0106, 0107, 0110,
463 	0111, 0121, 0122, 0123, 0124, 0125, 0126, 0127,
464 	0130, 0131, 0142, 0143, 0144, 0145, 0146, 0147,
465 	0150, 0151, 0160, 0161, 0162, 0163, 0164, 0165,
466 	0166, 0167, 0170, 0200, 0212, 0213, 0214, 0215,
467 	0216, 0217, 0220, 0232, 0233, 0234, 0235, 0236,
468 	0237, 0240, 0252, 0253, 0254, 0255, 0256, 0257,
469 	0260, 0261, 0262, 0263, 0264, 0265, 0266, 0267,
470 	0270, 0271, 0272, 0273, 0274, 0275, 0276, 0277,
471 	0312, 0313, 0314, 0315, 0316, 0317, 0332, 0333,
472 	0334, 0335, 0336, 0337, 0352, 0353, 0354, 0355,
473 	0356, 0357, 0372, 0373, 0374, 0375, 0376, 0377,
474 };
475 
476 /* set up to use SVr4 ascii-ebcdic translation by default */
477 
478 static unsigned char *atoe = svr4_atoe;
479 static unsigned char *etoa = svr4_etoa;
480 static unsigned char *atoibm = svr4_atoibm;
481 
482 /*ARGSUSED*/
483 static void
484 siginfo_handler(int sig, siginfo_t *sip, void *ucp)
485 {
486 	nstats = 1;
487 }
488 
489 int
490 main(int argc, char **argv)
491 {
492 	unsigned char *ip, *op; /* input and output buffer pointers */
493 	int c;		/* character counter */
494 	int ic;		/* input character */
495 	int conv;		/* conversion option code */
496 	int trunc;		/* whether output file is truncated */
497 	struct stat file_stat;
498 	struct sigaction sact;
499 
500 	/* Set option defaults */
501 
502 	ibs = BSIZE;
503 	obs = BSIZE;
504 	files = 1;
505 	conv = COPY;
506 	trunc = 1;			/* default: truncate output file */
507 	trantype = SVR4XLATE;  /* use SVR4 EBCDIC by default */
508 
509 	/* Parse command options */
510 
511 	(void) setlocale(LC_ALL, "");
512 #if !defined(TEXT_DOMAIN)	/* Should be defined by cc -D */
513 #define	TEXT_DOMAIN "SYS_TEST"	/* Use this only if it weren't */
514 #endif
515 	(void) textdomain(TEXT_DOMAIN);
516 
517 	while ((c = getopt(argc, argv, "")) != EOF)
518 		switch (c) {
519 			case '?':
520 			(void) fprintf(stderr, USAGE);
521 			exit(2);
522 		}
523 
524 	/* not getopt()'ed because dd has no options but only operand(s) */
525 
526 	for (c = optind; c < argc; c++) {
527 		string = argv[c];
528 		if (match("ibs=")) {
529 			ibs = (unsigned)number(BIG);
530 			continue;
531 		}
532 		if (match("obs=")) {
533 			obs = (unsigned)number(BIG);
534 			continue;
535 		}
536 		if (match("cbs=")) {
537 			cbs = (unsigned)number(BIG);
538 			continue;
539 		}
540 		if (match("bs=")) {
541 			bs = (unsigned)number(BIG);
542 			continue;
543 		}
544 		if (match("if=")) {
545 			ifile = string;
546 			continue;
547 		}
548 		if (match("of=")) {
549 			ofile = string;
550 			continue;
551 		}
552 		if (match("skip=")) {
553 			skip = number(BIG);
554 			continue;
555 		}
556 		if (match("iseek=")) {
557 			iseekn = number(BIG);
558 			continue;
559 		}
560 		if (match("oseek=")) {
561 			oseekn = number(BIG);
562 			continue;
563 		}
564 		if (match("seek=")) {		/* retained for compatibility */
565 			oseekn = number(BIG);
566 			continue;
567 		}
568 		if (match("ostride=")) {
569 			ostriden = ((off_t)number(BIG)) - 1;
570 			continue;
571 		}
572 		if (match("istride=")) {
573 			istriden = ((off_t)number(BIG)) - 1;
574 			continue;
575 		}
576 		if (match("stride=")) {
577 			istriden = ostriden = ((off_t)number(BIG)) - 1;
578 			continue;
579 		}
580 		if (match("count=")) {
581 			count = number(BIG);
582 			ecount = B_TRUE;
583 			continue;
584 		}
585 		if (match("files=")) {
586 			files = (int)number(BIG);
587 			continue;
588 		}
589 		if (match("conv=")) {
590 			for (;;) {
591 				if (match(",")) {
592 					continue;
593 				}
594 				if (*string == '\0') {
595 					break;
596 				}
597 				if (match("block")) {
598 					conv = BLOCK;
599 					continue;
600 				}
601 				if (match("unblock")) {
602 					conv = UNBLOCK;
603 					continue;
604 				}
605 
606 				/* ebcdicb, ibmb, and asciib must precede */
607 				/* ebcdic, ibm, and ascii in this test */
608 
609 				if (match("ebcdicb")) {
610 					conv = EBCDIC;
611 					trantype = BSDXLATE;
612 					continue;
613 				}
614 				if (match("ibmb")) {
615 					conv = IBM;
616 					trantype = BSDXLATE;
617 					continue;
618 				}
619 				if (match("asciib")) {
620 					conv = ASCII;
621 					trantype = BSDXLATE;
622 					continue;
623 				}
624 				if (match("ebcdic")) {
625 					conv = EBCDIC;
626 					trantype = SVR4XLATE;
627 					continue;
628 				}
629 				if (match("ibm")) {
630 					conv = IBM;
631 					trantype = SVR4XLATE;
632 					continue;
633 				}
634 				if (match("ascii")) {
635 					conv = ASCII;
636 					trantype = SVR4XLATE;
637 					continue;
638 				}
639 				if (match("lcase")) {
640 					cflag |= LCASE;
641 					continue;
642 				}
643 				if (match("ucase")) {
644 					cflag |= UCASE;
645 					continue;
646 				}
647 				if (match("swab")) {
648 					cflag |= SWAB;
649 					continue;
650 				}
651 				if (match("noerror")) {
652 					cflag |= NERR;
653 					continue;
654 				}
655 				if (match("notrunc")) {
656 					trunc = 0;
657 					continue;
658 				}
659 				if (match("sync")) {
660 					cflag |= SYNC;
661 					continue;
662 				}
663 				goto badarg;
664 			}
665 			continue;
666 		}
667 		if (match("oflag=")) {
668 			for (;;) {
669 				if (match(",")) {
670 					continue;
671 				}
672 				if (*string == '\0') {
673 					break;
674 				}
675 				if (match("dsync")) {
676 					oflag |= O_DSYNC;
677 					continue;
678 				}
679 				if (match("sync")) {
680 					oflag |= O_SYNC;
681 					continue;
682 				}
683 				goto badarg;
684 			}
685 			continue;
686 		}
687 		badarg:
688 		(void) fprintf(stderr, "dd: %s \"%s\"\n",
689 		    gettext("bad argument:"), string);
690 		exit(2);
691 	}
692 
693 	/* Perform consistency checks on options, decode strange conventions */
694 
695 	if (bs) {
696 		ibs = obs = bs;
697 	}
698 	if ((ibs == 0) || (obs == 0)) {
699 		(void) fprintf(stderr, "dd: %s\n",
700 		    gettext("buffer sizes cannot be zero"));
701 		exit(2);
702 	}
703 	if (ostriden == (off_t)-1) {
704 		(void) fprintf(stderr, "dd: %s\n",
705 		    gettext("stride must be greater than zero"));
706 		exit(2);
707 	}
708 	if (istriden == (off_t)-1) {
709 		(void) fprintf(stderr, "dd: %s\n",
710 		    gettext("stride must be greater than zero"));
711 		exit(2);
712 	}
713 	if (conv == COPY) {
714 		if ((bs == 0) || (cflag & (LCASE | UCASE))) {
715 			conv = REBLOCK;
716 		}
717 	}
718 	if (cbs == 0) {
719 		switch (conv) {
720 		case BLOCK:
721 		case UNBLOCK:
722 			conv = REBLOCK;
723 			break;
724 
725 		case ASCII:
726 			conv = NBASCII;
727 			break;
728 
729 		case EBCDIC:
730 			conv = NBEBCDIC;
731 			break;
732 
733 		case IBM:
734 			conv = NBIBM;
735 			break;
736 		}
737 	}
738 
739 	/* Expand options into lower and upper case versions if necessary */
740 
741 	switch (conv) {
742 	case REBLOCK:
743 		if (cflag & LCASE)
744 			conv = LCREBLOCK;
745 		else if (cflag & UCASE)
746 			conv = UCREBLOCK;
747 		break;
748 
749 	case UNBLOCK:
750 		if (cflag & LCASE)
751 			conv = LCUNBLOCK;
752 		else if (cflag & UCASE)
753 			conv = UCUNBLOCK;
754 		break;
755 
756 	case BLOCK:
757 		if (cflag & LCASE)
758 			conv = LCBLOCK;
759 		else if (cflag & UCASE)
760 			conv = UCBLOCK;
761 		break;
762 
763 	case ASCII:
764 		if (cflag & LCASE)
765 			conv = LCASCII;
766 		else if (cflag & UCASE)
767 			conv = UCASCII;
768 		break;
769 
770 	case NBASCII:
771 		if (cflag & LCASE)
772 			conv = LCNBASCII;
773 		else if (cflag & UCASE)
774 			conv = UCNBASCII;
775 		break;
776 
777 	case EBCDIC:
778 		if (cflag & LCASE)
779 			conv = LCEBCDIC;
780 		else if (cflag & UCASE)
781 			conv = UCEBCDIC;
782 		break;
783 
784 	case NBEBCDIC:
785 		if (cflag & LCASE)
786 			conv = LCNBEBCDIC;
787 		else if (cflag & UCASE)
788 			conv = UCNBEBCDIC;
789 		break;
790 
791 	case IBM:
792 		if (cflag & LCASE)
793 			conv = LCIBM;
794 		else if (cflag & UCASE)
795 			conv = UCIBM;
796 		break;
797 
798 	case NBIBM:
799 		if (cflag & LCASE)
800 			conv = LCNBIBM;
801 		else if (cflag & UCASE)
802 			conv = UCNBIBM;
803 		break;
804 	}
805 
806 	/* If BSD-compatible translation is selected, change the tables */
807 
808 	if (trantype == BSDXLATE) {
809 		atoe = bsd_atoe;
810 		atoibm = bsd_atoibm;
811 		etoa = bsd_etoa;
812 	}
813 	/* Open the input file, or duplicate standard input */
814 
815 	ibf = -1;
816 	if (ifile) {
817 		ibf = open(ifile, 0);
818 	} else {
819 		ifile = "";
820 		ibf = dup(STDIN_FILENO);
821 	}
822 
823 	if (ibf == -1) {
824 		(void) fprintf(stderr, "dd: %s: ", ifile);
825 		perror("open");
826 		exit(2);
827 	}
828 
829 	/* Open the output file, or duplicate standard output */
830 
831 	obf = -1;
832 	if (ofile) {
833 		if (trunc == 0)	{	/* do not truncate output file */
834 			obf = open(ofile, (O_WRONLY | O_CREAT | oflag),
835 			    (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
836 			    S_IROTH | S_IWOTH));
837 		} else if (oseekn && (trunc == 1)) {
838 			obf = open(ofile, O_WRONLY | O_CREAT | oflag,
839 			    (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
840 			    S_IROTH | S_IWOTH));
841 			if (obf == -1) {
842 				(void) fprintf(stderr, "dd: %s: ", ofile);
843 				perror("open");
844 				exit(2);
845 			}
846 			(void) fstat(obf, &file_stat);
847 			if (((file_stat.st_mode & S_IFMT) == S_IFREG) &&
848 			    (ftruncate(obf, (((off_t)oseekn) * ((off_t)obs)))
849 			    == -1)) {
850 				perror("ftruncate");
851 				exit(2);
852 			}
853 		} else {
854 			obf = open(ofile, O_WRONLY | O_CREAT | O_TRUNC | oflag,
855 			    (S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP |
856 			    S_IROTH | S_IWOTH));
857 		}
858 	} else {
859 		ofile = "";
860 		obf = dup(STDOUT_FILENO);
861 	}
862 
863 	if (obf == -1) {
864 		(void) fprintf(stderr, "dd: %s: ", ofile);
865 		perror("open");
866 		exit(2);
867 	}
868 
869 	/* Expand memory to get an input buffer */
870 
871 	ibuf = (unsigned char *)valloc(ibs + 10);
872 
873 	/* If no conversions, the input buffer is the output buffer */
874 
875 	if (conv == COPY) {
876 		obuf = ibuf;
877 	} else {
878 
879 		/*
880 		 * Expand memory to get an output buffer. Leave enough room
881 		 * at the end to convert a logical record when doing block
882 		 * conversions.
883 		 */
884 
885 		obuf = (unsigned char *)valloc(obs + cbs + 10);
886 	}
887 	if ((ibuf == NULL) || (obuf == NULL)) {
888 		(void) fprintf(stderr,
889 		    "dd: %s\n", gettext("not enough memory"));
890 		exit(2);
891 	}
892 
893 	/*
894 	 * Enable a statistics message when we terminate on SIGINT
895 	 * Also enable it to be queried via SIGINFO and SIGUSR1
896 	 */
897 
898 	if (signal(SIGINT, SIG_IGN) != SIG_IGN) {
899 		(void) signal(SIGINT, term);
900 	}
901 
902 	bzero(&sact, sizeof (struct sigaction));
903 	sact.sa_flags = SA_SIGINFO;
904 	sact.sa_sigaction = siginfo_handler;
905 	(void) sigemptyset(&sact.sa_mask);
906 	if (sigaction(SIGINFO, &sact, NULL) != 0) {
907 		(void) fprintf(stderr, "dd: %s: %s\n",
908 		    gettext("failed to enable siginfo handler"),
909 		    gettext(strerror(errno)));
910 		exit(2);
911 	}
912 	if (sigaction(SIGUSR1, &sact, NULL) != 0) {
913 		(void) fprintf(stderr, "dd: %s: %s\n",
914 		    gettext("failed to enable sigusr1 handler"),
915 		    gettext(strerror(errno)));
916 		exit(2);
917 	}
918 
919 	/* Skip input blocks */
920 
921 	while (skip) {
922 		ibc = read(ibf, (char *)ibuf, ibs);
923 		if (ibc == (unsigned)-1) {
924 			if (++nbad > BADLIMIT) {
925 				(void) fprintf(stderr, "dd: %s\n",
926 				    gettext("skip failed"));
927 				exit(2);
928 			} else {
929 				perror("read");
930 			}
931 		} else {
932 			if (ibc == 0) {
933 				(void) fprintf(stderr, "dd: %s\n",
934 				gettext("cannot skip past end-of-file"));
935 				exit(3);
936 			} else {
937 				nbad = 0;
938 			}
939 		}
940 		skip--;
941 	}
942 
943 	/* Seek past input blocks */
944 
945 	if (iseekn && lseek(ibf, (((off_t)iseekn) * ((off_t)ibs)), 1) == -1) {
946 		perror("lseek");
947 		exit(2);
948 	}
949 
950 	/* Seek past output blocks */
951 
952 	if (oseekn && lseek(obf, (((off_t)oseekn) * ((off_t)obs)), 1) == -1) {
953 		perror("lseek");
954 		exit(2);
955 	}
956 
957 	/* Initialize all buffer pointers */
958 
959 	skipf = 0;	/* not skipping an input line */
960 	ibc = 0;	/* no input characters yet */
961 	obc = 0;	/* no output characters yet */
962 	cbc = 0;	/* the conversion buffer is empty */
963 	op = obuf;	/* point to the output buffer */
964 
965 	/* Read and convert input blocks until end of file(s) */
966 
967 	/* Grab our start time for siginfo purposes */
968 	startt = gethrtime();
969 
970 	for (;;) {
971 		if (nstats != 0) {
972 			stats();
973 			nstats = 0;
974 		}
975 
976 		if ((count == 0 && ecount == B_FALSE) || (nifr+nipr < count)) {
977 		/* If proceed on error is enabled, zero the input buffer */
978 
979 			if (cflag & NERR) {
980 				ip = ibuf + ibs;
981 				c = ibs;
982 				if (c & 1)	/* if the size is odd, */
983 				{
984 					*--ip = 0;	/* clear the odd byte */
985 				}
986 				if (c >>= 1)		/* divide by two */
987 				{
988 					do {	/* clear two at a time */
989 						*--ip = 0;
990 						*--ip = 0;
991 					} while (--c);
992 				}
993 			}
994 
995 			/* Read the next input block */
996 
997 			ibc = read(ibf, (char *)ibuf, ibs);
998 
999 			if (istriden > 0 && lseek(ibf, istriden * ((off_t)ibs),
1000 			    SEEK_CUR) == -1) {
1001 				perror("lseek");
1002 				exit(2);
1003 			}
1004 
1005 			/* Process input errors */
1006 
1007 			if (ibc == (unsigned)-1) {
1008 				perror("read");
1009 				if (((cflag & NERR) == 0) ||
1010 				    (++nbad > BADLIMIT)) {
1011 					while (obc) {
1012 						(void) flsh();
1013 					}
1014 					term(2);
1015 				} else {
1016 					stats();
1017 					ibc = ibs; /* assume a full block */
1018 				}
1019 			} else {
1020 				nbad = 0;
1021 			}
1022 		} else {
1023 			/* Record count satisfied, simulate end of file */
1024 			ibc = 0;
1025 			files = 1;
1026 		}
1027 
1028 		/* Process end of file */
1029 
1030 		if (ibc == 0) {
1031 			switch (conv) {
1032 			case UNBLOCK:
1033 			case LCUNBLOCK:
1034 			case UCUNBLOCK:
1035 			case ASCII:
1036 			case LCASCII:
1037 			case UCASCII:
1038 
1039 				/* Trim trailing blanks from the last line */
1040 
1041 				if ((c = cbc) != 0) {
1042 					do {
1043 						if ((*--op) != ' ') {
1044 							op++;
1045 							break;
1046 						}
1047 					} while (--c);
1048 					*op++ = '\n';
1049 					obc -= cbc - c - 1;
1050 					cbc = 0;
1051 
1052 					/* Flush the output buffer if full */
1053 
1054 					while (obc >= obs) {
1055 						op = flsh();
1056 					}
1057 				}
1058 				break;
1059 
1060 			case BLOCK:
1061 			case LCBLOCK:
1062 			case UCBLOCK:
1063 			case EBCDIC:
1064 			case LCEBCDIC:
1065 			case UCEBCDIC:
1066 			case IBM:
1067 			case LCIBM:
1068 			case UCIBM:
1069 
1070 			/* Pad trailing blanks if the last line is short */
1071 
1072 				if (cbc) {
1073 					obc += c = cbs - cbc;
1074 					cbc = 0;
1075 					if (c > 0) {
1076 					/* Use the right kind of blank */
1077 
1078 						switch (conv) {
1079 						case BLOCK:
1080 						case LCBLOCK:
1081 						case UCBLOCK:
1082 							ic = ' ';
1083 							break;
1084 
1085 						case EBCDIC:
1086 						case LCEBCDIC:
1087 						case UCEBCDIC:
1088 							ic = atoe[' '];
1089 							break;
1090 
1091 						case IBM:
1092 						case LCIBM:
1093 						case UCIBM:
1094 							ic = atoibm[' '];
1095 							break;
1096 						}
1097 
1098 						/* Pad with trailing blanks */
1099 
1100 						do {
1101 							*op++ = ic;
1102 						} while (--c);
1103 					}
1104 				}
1105 
1106 
1107 				/* Flush the output buffer if full */
1108 
1109 				while (obc >= obs) {
1110 					op = flsh();
1111 				}
1112 				break;
1113 			}
1114 
1115 			/* If no more files to read, flush the output buffer */
1116 
1117 			if (--files <= 0) {
1118 				(void) flsh();
1119 				if ((close(obf) != 0) ||
1120 				    (fclose(stdout) != 0)) {
1121 					perror(gettext("dd: close error"));
1122 					exit(2);
1123 				}
1124 				term(0);	/* successful exit */
1125 			} else {
1126 				continue;	/* read the next file */
1127 			}
1128 		} else if (ibc == ibs) {
1129 			/* Normal read, check for special cases */
1130 			nifr++;		/* count another full input record */
1131 		} else {
1132 			nipr++;		/* count a partial input record */
1133 
1134 			/* If `sync' enabled, pad nulls */
1135 
1136 			if ((cflag & SYNC) && ((cflag & NERR) == 0)) {
1137 				c = ibs - ibc;
1138 				ip = ibuf + ibs;
1139 				do {
1140 					if ((conv == BLOCK) ||
1141 					    (conv == UNBLOCK))
1142 						*--ip = ' ';
1143 					else
1144 						*--ip = '\0';
1145 				} while (--c);
1146 				ibc = ibs;
1147 			}
1148 		}
1149 
1150 		/* Swap the bytes in the input buffer if necessary */
1151 
1152 		if (cflag & SWAB) {
1153 			ip = ibuf;
1154 			if (ibc & 1) {	/* if the byte count is odd, */
1155 				ip[ibc] = 0;  /* make it even, pad with zero */
1156 			}
1157 			c = ibc >> 1;	/* compute the pair count */
1158 			do {
1159 				ic = *ip++;
1160 				ip[-1] = *ip;
1161 				*ip++ = ic;
1162 			} while (--c);		/* do two bytes at a time */
1163 		}
1164 
1165 		/* Select the appropriate conversion loop */
1166 
1167 		ip = ibuf;
1168 		switch (conv) {
1169 
1170 		/* Simple copy: no conversion, preserve the input block size */
1171 
1172 		case COPY:
1173 			obc = ibc;
1174 			(void) flsh();
1175 			break;
1176 
1177 		/* Simple copy: pack all output into equal sized blocks */
1178 
1179 		case REBLOCK:
1180 		case LCREBLOCK:
1181 		case UCREBLOCK:
1182 		case NBASCII:
1183 		case LCNBASCII:
1184 		case UCNBASCII:
1185 		case NBEBCDIC:
1186 		case LCNBEBCDIC:
1187 		case UCNBEBCDIC:
1188 		case NBIBM:
1189 		case LCNBIBM:
1190 		case UCNBIBM:
1191 			while ((c = ibc) != 0) {
1192 				if (c > (obs - obc)) {
1193 					c = obs - obc;
1194 				}
1195 				ibc -= c;
1196 				obc += c;
1197 				switch (conv) {
1198 				case REBLOCK:
1199 					do {
1200 						*op++ = *ip++;
1201 					} while (--c);
1202 					break;
1203 
1204 				case LCREBLOCK:
1205 					do {
1206 						*op++ = utol[*ip++];
1207 					} while (--c);
1208 					break;
1209 
1210 				case UCREBLOCK:
1211 					do {
1212 						*op++ = ltou[*ip++];
1213 					} while (--c);
1214 					break;
1215 
1216 				case NBASCII:
1217 					do {
1218 						*op++ = etoa[*ip++];
1219 					} while (--c);
1220 					break;
1221 
1222 				case LCNBASCII:
1223 					do {
1224 						*op++ = utol[etoa[*ip++]];
1225 					} while (--c);
1226 					break;
1227 
1228 				case UCNBASCII:
1229 					do {
1230 						*op++ = ltou[etoa[*ip++]];
1231 					} while (--c);
1232 					break;
1233 
1234 				case NBEBCDIC:
1235 					do {
1236 						*op++ = atoe[*ip++];
1237 					} while (--c);
1238 					break;
1239 
1240 				case LCNBEBCDIC:
1241 					do {
1242 						*op++ = atoe[utol[*ip++]];
1243 					} while (--c);
1244 					break;
1245 
1246 				case UCNBEBCDIC:
1247 					do {
1248 						*op++ = atoe[ltou[*ip++]];
1249 					} while (--c);
1250 					break;
1251 
1252 				case NBIBM:
1253 					do {
1254 						*op++ = atoibm[*ip++];
1255 					} while (--c);
1256 					break;
1257 
1258 				case LCNBIBM:
1259 					do {
1260 						*op++ = atoibm[utol[*ip++]];
1261 					} while (--c);
1262 					break;
1263 
1264 				case UCNBIBM:
1265 					do {
1266 						*op++ = atoibm[ltou[*ip++]];
1267 					} while (--c);
1268 					break;
1269 				}
1270 				if (obc >= obs) {
1271 					op = flsh();
1272 				}
1273 			}
1274 			break;
1275 
1276 	/* Convert from blocked records to lines terminated by newline */
1277 
1278 		case UNBLOCK:
1279 		case LCUNBLOCK:
1280 		case UCUNBLOCK:
1281 		case ASCII:
1282 		case LCASCII:
1283 		case UCASCII:
1284 			while ((c = ibc) != 0) {
1285 				if (c > (cbs - cbc)) {
1286 					/* if more than one record, */
1287 					c = cbs - cbc;
1288 					/* only copy one record */
1289 				}
1290 				ibc -= c;
1291 				cbc += c;
1292 				obc += c;
1293 				switch (conv) {
1294 				case UNBLOCK:
1295 					do {
1296 						*op++ = *ip++;
1297 					} while (--c);
1298 					break;
1299 
1300 				case LCUNBLOCK:
1301 					do {
1302 						*op++ = utol[*ip++];
1303 					} while (--c);
1304 					break;
1305 
1306 				case UCUNBLOCK:
1307 					do {
1308 						*op++ = ltou[*ip++];
1309 					} while (--c);
1310 					break;
1311 
1312 				case ASCII:
1313 					do {
1314 						*op++ = etoa[*ip++];
1315 					} while (--c);
1316 					break;
1317 
1318 				case LCASCII:
1319 					do {
1320 						*op++ = utol[etoa[*ip++]];
1321 					} while (--c);
1322 					break;
1323 
1324 				case UCASCII:
1325 					do {
1326 						*op++ = ltou[etoa[*ip++]];
1327 					} while (--c);
1328 					break;
1329 				}
1330 
1331 				/* Trim trailing blanks if the line is full */
1332 
1333 				if (cbc == cbs) {
1334 					c = cbs; /* `do - while' is usually */
1335 					do {		/* faster than `for' */
1336 						if ((*--op) != ' ') {
1337 							op++;
1338 							break;
1339 						}
1340 					} while (--c);
1341 					*op++ = '\n';
1342 					obc -= cbs - c - 1;
1343 					cbc = 0;
1344 
1345 					/* Flush the output buffer if full */
1346 
1347 					while (obc >= obs) {
1348 						op = flsh();
1349 					}
1350 				}
1351 			}
1352 			break;
1353 
1354 		/* Convert to blocked records */
1355 
1356 		case BLOCK:
1357 		case LCBLOCK:
1358 		case UCBLOCK:
1359 		case EBCDIC:
1360 		case LCEBCDIC:
1361 		case UCEBCDIC:
1362 		case IBM:
1363 		case LCIBM:
1364 		case UCIBM:
1365 			while ((c = ibc) != 0) {
1366 				int nlflag = 0;
1367 
1368 				/*
1369 				 * We may have to skip to the end of a long
1370 				 * line.
1371 				 */
1372 
1373 				if (skipf) {
1374 					do {
1375 						if ((ic = *ip++) == '\n') {
1376 							skipf = 0;
1377 							c--;
1378 							break;
1379 						}
1380 					} while (--c);
1381 					if ((ibc = c) == 0) {
1382 						continue;
1383 						/* read another block */
1384 					}
1385 				}
1386 
1387 				/* If anything left, copy until newline */
1388 
1389 				if (c > (cbs - cbc + 1)) {
1390 					c = cbs - cbc + 1;
1391 				}
1392 				ibc -= c;
1393 				cbc += c;
1394 				obc += c;
1395 
1396 				switch (conv) {
1397 				case BLOCK:
1398 					do {
1399 						if ((ic = *ip++) != '\n') {
1400 							*op++ = ic;
1401 						} else {
1402 							nlflag = 1;
1403 							break;
1404 						}
1405 					} while (--c);
1406 					break;
1407 
1408 				case LCBLOCK:
1409 					do {
1410 						if ((ic = *ip++) != '\n') {
1411 							*op++ = utol[ic];
1412 						} else {
1413 							nlflag = 1;
1414 							break;
1415 						}
1416 					} while (--c);
1417 					break;
1418 
1419 				case UCBLOCK:
1420 					do {
1421 						if ((ic = *ip++) != '\n') {
1422 							*op++ = ltou[ic];
1423 						} else {
1424 							nlflag = 1;
1425 							break;
1426 						}
1427 					} while (--c);
1428 					break;
1429 
1430 				case EBCDIC:
1431 					do {
1432 						if ((ic = *ip++) != '\n') {
1433 							*op++ = atoe[ic];
1434 						} else {
1435 							nlflag = 1;
1436 							break;
1437 						}
1438 					} while (--c);
1439 					break;
1440 
1441 				case LCEBCDIC:
1442 					do {
1443 						if ((ic = *ip++) != '\n') {
1444 							*op++ = atoe[utol[ic]];
1445 						} else {
1446 							nlflag = 1;
1447 							break;
1448 						}
1449 					} while (--c);
1450 					break;
1451 
1452 				case UCEBCDIC:
1453 					do {
1454 						if ((ic = *ip++) != '\n') {
1455 							*op++ = atoe[ltou[ic]];
1456 						} else {
1457 							nlflag = 1;
1458 							break;
1459 						}
1460 					} while (--c);
1461 					break;
1462 
1463 				case IBM:
1464 					do {
1465 						if ((ic = *ip++) != '\n') {
1466 							*op++ = atoibm[ic];
1467 						} else {
1468 							nlflag = 1;
1469 							break;
1470 						}
1471 					} while (--c);
1472 					break;
1473 
1474 				case LCIBM:
1475 					do {
1476 						if ((ic = *ip++) != '\n') {
1477 							*op++ =
1478 							    atoibm[utol[ic]];
1479 						} else {
1480 							nlflag = 1;
1481 							break;
1482 						}
1483 					} while (--c);
1484 					break;
1485 
1486 				case UCIBM:
1487 					do {
1488 						if ((ic = *ip++) != '\n') {
1489 							*op++ =
1490 							    atoibm[ltou[ic]];
1491 						} else {
1492 							nlflag = 1;
1493 							break;
1494 						}
1495 					} while (--c);
1496 					break;
1497 				}
1498 
1499 			/* If newline found, update all the counters and */
1500 			/* pointers, pad with trailing blanks if necessary */
1501 
1502 				if (nlflag) {
1503 					ibc += c - 1;
1504 					obc += cbs - cbc;
1505 					c += cbs - cbc;
1506 					cbc = 0;
1507 					if (c > 0) {
1508 					/* Use the right kind of blank */
1509 
1510 						switch (conv) {
1511 						case BLOCK:
1512 						case LCBLOCK:
1513 						case UCBLOCK:
1514 							ic = ' ';
1515 							break;
1516 
1517 						case EBCDIC:
1518 						case LCEBCDIC:
1519 						case UCEBCDIC:
1520 							ic = atoe[' '];
1521 							break;
1522 
1523 						case IBM:
1524 						case LCIBM:
1525 						case UCIBM:
1526 							ic = atoibm[' '];
1527 							break;
1528 						}
1529 
1530 						/* Pad with trailing blanks */
1531 
1532 						do {
1533 							*op++ = ic;
1534 						} while (--c);
1535 					}
1536 				}
1537 
1538 			/* If not end of line, this line may be too long */
1539 
1540 				else if (cbc > cbs) {
1541 					skipf = 1; /* note skip in progress */
1542 					obc--;
1543 					op--;
1544 					cbc = 0;
1545 					ntrunc++;  /* count another long line */
1546 				}
1547 
1548 				/* Flush the output buffer if full */
1549 
1550 				while (obc >= obs) {
1551 					op = flsh();
1552 				}
1553 			}
1554 			break;
1555 		}
1556 	}
1557 	/* NOTREACHED */
1558 	return (0);
1559 }
1560 
1561 /* match ************************************************************** */
1562 /*									*/
1563 /* Compare two text strings for equality				*/
1564 /*									*/
1565 /* Arg:		s - pointer to string to match with a command arg	*/
1566 /* Global arg:	string - pointer to command arg				*/
1567 /*									*/
1568 /* Return:	1 if match, 0 if no match				*/
1569 /*		If match, also reset `string' to point to the text	*/
1570 /*		that follows the matching text.				*/
1571 /*									*/
1572 /* ********************************************************************	*/
1573 
1574 static int
1575 match(char *s)
1576 {
1577 	char *cs;
1578 
1579 	cs = string;
1580 	while (*cs++ == *s) {
1581 		if (*s++ == '\0') {
1582 			goto true;
1583 		}
1584 	}
1585 	if (*s != '\0') {
1586 		return (0);
1587 	}
1588 
1589 true:
1590 	cs--;
1591 	string = cs;
1592 	return (1);
1593 }
1594 
1595 /* number ************************************************************* */
1596 /*									*/
1597 /* Convert a numeric arg to binary					*/
1598 /*									*/
1599 /* Arg:		big - maximum valid input number			*/
1600 /* Global arg:	string - pointer to command arg				*/
1601 /*									*/
1602 /* Valid forms:	123 | 123k | 123M | 123G | 123T | 123P | 123E | 123Z |	*/
1603 /*		123w | 123b | 123*123 | 123x123				*/
1604 /*		plus combinations such as 2b*3kw*4w			*/
1605 /*									*/
1606 /* Return:	converted number					*/
1607 /*									*/
1608 /* ********************************************************************	*/
1609 
1610 static unsigned long long
1611 number(long long big)
1612 {
1613 	char *cs;
1614 	long long n;
1615 	long long cut = BIG / 10;	/* limit to avoid overflow */
1616 
1617 	cs = string;
1618 	n = 0;
1619 	while ((*cs >= '0') && (*cs <= '9') && (n <= cut)) {
1620 		n = n * 10 + *cs++ - '0';
1621 	}
1622 	for (;;) {
1623 		switch (*cs++) {
1624 
1625 		case 'Z':
1626 			n *= 1024;
1627 			/* FALLTHROUGH */
1628 
1629 		case 'E':
1630 			n *= 1024;
1631 			/* FALLTHROUGH */
1632 
1633 		case 'P':
1634 			n *= 1024;
1635 			/* FALLTHROUGH */
1636 
1637 		case 'T':
1638 			n *= 1024;
1639 			/* FALLTHROUGH */
1640 
1641 		case 'G':
1642 			n *= 1024;
1643 			/* FALLTHROUGH */
1644 
1645 		case 'M':
1646 			n *= 1024;
1647 			/* FALLTHROUGH */
1648 
1649 		case 'k':
1650 			n *= 1024;
1651 			continue;
1652 
1653 		case 'w':
1654 			n *= 2;
1655 			continue;
1656 
1657 		case 'b':
1658 			n *= BSIZE;
1659 			continue;
1660 
1661 		case '*':
1662 		case 'x':
1663 			string = cs;
1664 			n *= number(BIG);
1665 
1666 		/* FALLTHROUGH */
1667 		/* Fall into exit test, recursion has read rest of string */
1668 		/* End of string, check for a valid number */
1669 
1670 		case '\0':
1671 			if ((n > big) || (n < 0)) {
1672 				(void) fprintf(stderr, "dd: %s \"%llu\"\n",
1673 				    gettext("argument out of range:"), n);
1674 				exit(2);
1675 			}
1676 			return (n);
1677 
1678 		default:
1679 			(void) fprintf(stderr, "dd: %s \"%s\"\n",
1680 			    gettext("bad numeric argument:"), string);
1681 			exit(2);
1682 		}
1683 	} /* never gets here */
1684 }
1685 
1686 /* flsh *************************************************************** */
1687 /*									*/
1688 /* Flush the output buffer, move any excess bytes down to the beginning	*/
1689 /*									*/
1690 /* Arg:		none							*/
1691 /* Global args:	obuf, obc, obs, nofr, nopr, ostriden			*/
1692 /*									*/
1693 /* Return:	Pointer to the first free byte in the output buffer.	*/
1694 /*		Also reset `obc' to account for moved bytes.		*/
1695 /*									*/
1696 /* ********************************************************************	*/
1697 
1698 static unsigned char *
1699 flsh(void)
1700 {
1701 	unsigned char *op, *cp;
1702 	int bc;
1703 	unsigned int oc;
1704 
1705 	if (obc) {			/* don't flush if the buffer is empty */
1706 		if (obc >= obs) {
1707 			oc = obs;
1708 			nofr++;		/* count a full output buffer */
1709 		} else {
1710 			oc = obc;
1711 			nopr++;		/* count a partial output buffer */
1712 		}
1713 		bc = write(obf, (char *)obuf, oc);
1714 		if (bc != oc) {
1715 			if (bc < 0) {
1716 				perror("write");
1717 			} else {
1718 				(void) fprintf(stderr,
1719 				    gettext("dd: unexpected short write, "
1720 				    "wrote %d bytes, expected %d\n"), bc, oc);
1721 			}
1722 			term(2);
1723 		}
1724 
1725 		if (ostriden > 0 && lseek(obf, ostriden * ((off_t)obs),
1726 		    SEEK_CUR) == -1) {
1727 			perror("lseek");
1728 			exit(2);
1729 		}
1730 
1731 		obc -= oc;
1732 		op = obuf;
1733 		obytes += bc;
1734 
1735 		/* If any data in the conversion buffer, move it into */
1736 		/* the output buffer */
1737 
1738 		if (obc) {
1739 			cp = obuf + obs;
1740 			bc = obc;
1741 			do {
1742 				*op++ = *cp++;
1743 			} while (--bc);
1744 		}
1745 		return (op);
1746 	}
1747 	return (obuf);
1748 }
1749 
1750 /* term *************************************************************** */
1751 /*									*/
1752 /* Write record statistics, then exit					*/
1753 /*									*/
1754 /* Arg:		c - exit status code					*/
1755 /*									*/
1756 /* Return:	no return, calls exit					*/
1757 /*									*/
1758 /* ********************************************************************	*/
1759 
1760 static void
1761 term(int c)
1762 {
1763 	stats();
1764 	exit(c);
1765 }
1766 
1767 /* stats ************************************************************** */
1768 /*									*/
1769 /* Write record statistics onto standard error				*/
1770 /*									*/
1771 /* Args:	none							*/
1772 /* Global args:	nifr, nipr, nofr, nopr, ntrunc, obytes			*/
1773 /*									*/
1774 /* Return:	void							*/
1775 /*									*/
1776 /* ********************************************************************	*/
1777 
1778 static void
1779 stats(void)
1780 {
1781 	hrtime_t delta = gethrtime() - startt;
1782 	double secs = delta * 1e-9;
1783 	char nnum[NN_NUMBUF_SZ];
1784 
1785 	(void) fprintf(stderr, gettext("%llu+%llu records in\n"), nifr, nipr);
1786 	(void) fprintf(stderr, gettext("%llu+%llu records out\n"), nofr, nopr);
1787 	if (ntrunc) {
1788 		(void) fprintf(stderr,
1789 		    gettext("%llu truncated record(s)\n"), ntrunc);
1790 	}
1791 
1792 	/*
1793 	 * If we got here before we started copying somehow, don't bother
1794 	 * printing the rest.
1795 	 */
1796 	if (startt == 0)
1797 		return;
1798 
1799 	nicenum((uint64_t)obytes / secs, nnum, sizeof (nnum));
1800 	(void) fprintf(stderr,
1801 	    gettext("%llu bytes transferred in %.6f secs (%sB/sec)\n"),
1802 	    obytes, secs, nnum);
1803 }
1804