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