xref: /freebsd/bin/dd/dd.c (revision 7f3dea244c40159a41ab22da77a434d7c5b5e85a)
1 /*-
2  * Copyright (c) 1991, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Keith Muller of the University of California, San Diego and Lance
7  * Visser of Convex Computer Corporation.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  * 1. Redistributions of source code must retain the above copyright
13  *    notice, this list of conditions and the following disclaimer.
14  * 2. Redistributions in binary form must reproduce the above copyright
15  *    notice, this list of conditions and the following disclaimer in the
16  *    documentation and/or other materials provided with the distribution.
17  * 3. All advertising materials mentioning features or use of this software
18  *    must display the following acknowledgement:
19  *	This product includes software developed by the University of
20  *	California, Berkeley and its contributors.
21  * 4. Neither the name of the University nor the names of its contributors
22  *    may be used to endorse or promote products derived from this software
23  *    without specific prior written permission.
24  *
25  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
26  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
28  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
29  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
30  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
31  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
32  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
33  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
34  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35  * SUCH DAMAGE.
36  */
37 
38 #ifndef lint
39 static char const copyright[] =
40 "@(#) Copyright (c) 1991, 1993, 1994\n\
41 	The Regents of the University of California.  All rights reserved.\n";
42 #endif /* not lint */
43 
44 #ifndef lint
45 #if 0
46 static char sccsid[] = "@(#)dd.c	8.5 (Berkeley) 4/2/94";
47 #endif
48 static const char rcsid[] =
49   "$FreeBSD$";
50 #endif /* not lint */
51 
52 #include <sys/param.h>
53 #include <sys/stat.h>
54 #include <sys/conf.h>
55 #include <sys/diskslice.h>
56 #include <sys/filio.h>
57 #include <sys/mtio.h>
58 
59 #include <ctype.h>
60 #include <err.h>
61 #include <errno.h>
62 #include <fcntl.h>
63 #include <locale.h>
64 #include <stdio.h>
65 #include <stdlib.h>
66 #include <string.h>
67 #include <unistd.h>
68 
69 #include "dd.h"
70 #include "extern.h"
71 
72 static void dd_close __P((void));
73 static void dd_in __P((void));
74 static void getfdtype __P((IO *));
75 static void setup __P((void));
76 
77 IO	in, out;		/* input/output state */
78 STAT	st;			/* statistics */
79 void	(*cfunc) __P((void));	/* conversion function */
80 quad_t	cpy_cnt;		/* # of blocks to copy */
81 off_t	pending = 0;		/* pending seek if sparse */
82 u_int	ddflags;		/* conversion options */
83 int	cbsz;			/* conversion block size */
84 quad_t	files_cnt = 1;		/* # of files to copy */
85 u_char	*ctab;			/* conversion table */
86 
87 int
88 main(argc, argv)
89 	int argc;
90 	char *argv[];
91 {
92 	(void)setlocale(LC_CTYPE, "");
93 	jcl(argv);
94 	setup();
95 
96 	(void)signal(SIGINFO, summaryx);
97 	(void)signal(SIGINT, terminate);
98 
99 	atexit(summary);
100 
101 	while (files_cnt--)
102 		dd_in();
103 
104 	dd_close();
105 	exit(0);
106 }
107 
108 static void
109 setup()
110 {
111 	u_int cnt;
112 	struct timeval tv;
113 
114 	if (in.name == NULL) {
115 		in.name = "stdin";
116 		in.fd = STDIN_FILENO;
117 	} else {
118 		in.fd = open(in.name, O_RDONLY, 0);
119 		if (in.fd == -1)
120 			err(1, "%s", in.name);
121 	}
122 
123 	getfdtype(&in);
124 
125 	if (files_cnt > 1 && !(in.flags & ISTAPE))
126 		errx(1, "files is not supported for non-tape devices");
127 
128 	if (out.name == NULL) {
129 		/* No way to check for read access here. */
130 		out.fd = STDOUT_FILENO;
131 		out.name = "stdout";
132 	} else {
133 #define	OFLAGS \
134     (O_CREAT | (ddflags & (C_SEEK | C_NOTRUNC) ? 0 : O_TRUNC))
135 		out.fd = open(out.name, O_RDWR | OFLAGS, DEFFILEMODE);
136 		/*
137 		 * May not have read access, so try again with write only.
138 		 * Without read we may have a problem if output also does
139 		 * not support seeks.
140 		 */
141 		if (out.fd == -1) {
142 			out.fd = open(out.name, O_WRONLY | OFLAGS, DEFFILEMODE);
143 			out.flags |= NOREAD;
144 		}
145 		if (out.fd == -1)
146 			err(1, "%s", out.name);
147 	}
148 
149 	getfdtype(&out);
150 
151 	/*
152 	 * Allocate space for the input and output buffers.  If not doing
153 	 * record oriented I/O, only need a single buffer.
154 	 */
155 	if (!(ddflags & (C_BLOCK|C_UNBLOCK))) {
156 		if ((in.db = malloc(out.dbsz + in.dbsz - 1)) == NULL)
157 			err(1, NULL);
158 		out.db = in.db;
159 	} else if ((in.db = malloc((u_int)(MAX(in.dbsz, cbsz) + cbsz))) == NULL
160 		   || (out.db = malloc((u_int)(out.dbsz + cbsz))) == NULL)
161 		err(1, NULL);
162 	in.dbp = in.db;
163 	out.dbp = out.db;
164 
165 	/* Position the input/output streams. */
166 	if (in.offset)
167 		pos_in();
168 	if (out.offset)
169 		pos_out();
170 
171 	/*
172 	 * Truncate the output file; ignore errors because it fails on some
173 	 * kinds of output files, tapes, for example.
174 	 */
175 	if ((ddflags & (C_OF | C_SEEK | C_NOTRUNC)) == (C_OF | C_SEEK))
176 		(void)ftruncate(out.fd, out.offset * out.dbsz);
177 
178 	/*
179 	 * If converting case at the same time as another conversion, build a
180 	 * table that does both at once.  If just converting case, use the
181 	 * built-in tables.
182 	 */
183 	if (ddflags & (C_LCASE|C_UCASE)) {
184 		if (ddflags & C_ASCII) {
185 			if (ddflags & C_LCASE) {
186 				for (cnt = 0; cnt <= 0377; ++cnt)
187 					if (isupper(ctab[cnt]))
188 						ctab[cnt] = tolower(ctab[cnt]);
189 			} else {
190 				for (cnt = 0; cnt <= 0377; ++cnt)
191 					if (islower(ctab[cnt]))
192 						ctab[cnt] = toupper(ctab[cnt]);
193 			}
194 		} else if (ddflags & C_EBCDIC) {
195 			if (ddflags & C_LCASE) {
196 				for (cnt = 0; cnt <= 0377; ++cnt)
197 					if (isupper(cnt))
198 						ctab[cnt] = ctab[tolower(cnt)];
199 			} else {
200 				for (cnt = 0; cnt <= 0377; ++cnt)
201 					if (islower(cnt))
202 						ctab[cnt] = ctab[toupper(cnt)];
203 			}
204 		} else {
205 			ctab = ddflags & C_LCASE ? u2l : l2u;
206 			if (ddflags & C_LCASE) {
207 				for (cnt = 0; cnt <= 0377; ++cnt)
208 					if (isupper(cnt))
209 						ctab[cnt] = tolower(cnt);
210 					else
211 						ctab[cnt] = cnt;
212 			} else {
213 				for (cnt = 0; cnt <= 0377; ++cnt)
214 					if (islower(cnt))
215 						ctab[cnt] = toupper(cnt);
216 					else
217 						ctab[cnt] = cnt;
218 			}
219 		}
220 	}
221 	(void)gettimeofday(&tv, (struct timezone *)NULL);
222 	st.start = tv.tv_sec + tv.tv_usec * 1e-6;
223 }
224 
225 static void
226 getfdtype(io)
227 	IO *io;
228 {
229 	struct stat sb;
230 	int type;
231 
232 	if (fstat(io->fd, &sb))
233 		err(1, "%s", io->name);
234 	if (S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) {
235 		if (ioctl(io->fd, FIODTYPE, &type) == -1)
236 			err(1, "%s", io->name);
237 		if (type & D_TAPE)
238 			io->flags |= ISTAPE;
239 		else if (type & D_DISK)
240 			io->flags |= ISDISK;
241 		if (S_ISCHR(sb.st_mode) && (type & D_TAPE) == 0)
242 			io->flags |= ISCHR;
243 	} else if (!S_ISREG(sb.st_mode))
244 		io->flags |= ISPIPE;
245 }
246 
247 static void
248 dd_in()
249 {
250 	ssize_t n;
251 
252 	for (;;) {
253 		if (cpy_cnt && (st.in_full + st.in_part) >= cpy_cnt)
254 			return;
255 
256 		/*
257 		 * Zero the buffer first if sync; If doing block operations
258 		 * use spaces.
259 		 */
260 		if (ddflags & C_SYNC) {
261 			if (ddflags & (C_BLOCK|C_UNBLOCK))
262 				memset(in.dbp, ' ', in.dbsz);
263 			else
264 				memset(in.dbp, 0, in.dbsz);
265 		}
266 
267 		n = read(in.fd, in.dbp, in.dbsz);
268 		if (n == 0) {
269 			in.dbrcnt = 0;
270 			return;
271 		}
272 
273 		/* Read error. */
274 		if (n == -1) {
275 			/*
276 			 * If noerror not specified, die.  POSIX requires that
277 			 * the warning message be followed by an I/O display.
278 			 */
279 			if (!(ddflags & C_NOERROR))
280 				err(1, "%s", in.name);
281 			warn("%s", in.name);
282 			summary();
283 
284 			/*
285 			 * If it's not a tape drive or a pipe, seek past the
286 			 * error.  If your OS doesn't do the right thing for
287 			 * raw disks this section should be modified to re-read
288 			 * in sector size chunks.
289 			 */
290 			if (!(in.flags & (ISPIPE|ISTAPE)) &&
291 			    lseek(in.fd, (off_t)in.dbsz, SEEK_CUR))
292 				warn("%s", in.name);
293 
294 			/* If sync not specified, omit block and continue. */
295 			if (!(ddflags & C_SYNC))
296 				continue;
297 
298 			/* Read errors count as full blocks. */
299 			in.dbcnt += in.dbrcnt = in.dbsz;
300 			++st.in_full;
301 
302 		/* Handle full input blocks. */
303 		} else if (n == in.dbsz) {
304 			in.dbcnt += in.dbrcnt = n;
305 			++st.in_full;
306 
307 		/* Handle partial input blocks. */
308 		} else {
309 			/* If sync, use the entire block. */
310 			if (ddflags & C_SYNC)
311 				in.dbcnt += in.dbrcnt = in.dbsz;
312 			else
313 				in.dbcnt += in.dbrcnt = n;
314 			++st.in_part;
315 		}
316 
317 		/*
318 		 * POSIX states that if bs is set and no other conversions
319 		 * than noerror, notrunc or sync are specified, the block
320 		 * is output without buffering as it is read.
321 		 */
322 		if (ddflags & C_BS) {
323 			out.dbcnt = in.dbcnt;
324 			dd_out(1);
325 			in.dbcnt = 0;
326 			continue;
327 		}
328 
329 		if (ddflags & C_SWAB) {
330 			if ((n = in.dbrcnt) & 1) {
331 				++st.swab;
332 				--n;
333 			}
334 			swab(in.dbp, in.dbp, n);
335 		}
336 
337 		in.dbp += in.dbrcnt;
338 		(*cfunc)();
339 	}
340 }
341 
342 /*
343  * Cleanup any remaining I/O and flush output.  If necesssary, output file
344  * is truncated.
345  */
346 static void
347 dd_close()
348 {
349 	if (cfunc == def)
350 		def_close();
351 	else if (cfunc == block)
352 		block_close();
353 	else if (cfunc == unblock)
354 		unblock_close();
355 	if (ddflags & C_OSYNC && out.dbcnt && out.dbcnt < out.dbsz) {
356 		if (ddflags & (C_BLOCK|C_UNBLOCK))
357 			memset(out.dbp, ' ', out.dbsz - out.dbcnt);
358 		else
359 			memset(out.dbp, 0, out.dbsz - out.dbcnt);
360 		out.dbcnt = out.dbsz;
361 	}
362 	if (out.dbcnt || pending)
363 		dd_out(1);
364 }
365 
366 void
367 dd_out(force)
368 	int force;
369 {
370 	static int warned;
371 	int cnt, n, i, sparse;
372 	ssize_t nw;
373 	u_char *outp;
374 
375 	/*
376 	 * Write one or more blocks out.  The common case is writing a full
377 	 * output block in a single write; increment the full block stats.
378 	 * Otherwise, we're into partial block writes.  If a partial write,
379 	 * and it's a character device, just warn.  If a tape device, quit.
380 	 *
381 	 * The partial writes represent two cases.  1: Where the input block
382 	 * was less than expected so the output block was less than expected.
383 	 * 2: Where the input block was the right size but we were forced to
384 	 * write the block in multiple chunks.  The original versions of dd(1)
385 	 * never wrote a block in more than a single write, so the latter case
386 	 * never happened.
387 	 *
388 	 * One special case is if we're forced to do the write -- in that case
389 	 * we play games with the buffer size, and it's usually a partial write.
390 	 */
391 	outp = out.db;
392 	for (n = force ? out.dbcnt : out.dbsz;; n = out.dbsz) {
393 		for (cnt = n;; cnt -= nw) {
394 			sparse = 0;
395 			if (ddflags & C_SPARSE) {
396 				sparse = 1;	/* Is buffer sparse? */
397 				for (i = 0; i < cnt; i++)
398 					if (outp[i] != 0) {
399 						sparse = 0;
400 						break;
401 					}
402 			}
403 			if (sparse && !force) {
404 				pending += cnt;
405 				nw = cnt;
406 			} else {
407 				if (pending != 0) {
408 					if (force)
409 						pending--;
410 					if (lseek(out.fd, pending, SEEK_CUR) ==
411 					    -1)
412 						err(2, "%s: seek error creating sparse file",
413 						    out.name);
414 					if (force)
415 						write(out.fd, outp, 1);
416 					pending = 0;
417 				}
418 				if (cnt)
419 					nw = write(out.fd, outp, cnt);
420 				else
421 					return;
422 			}
423 
424 			if (nw <= 0) {
425 				if (nw == 0)
426 					errx(1, "%s: end of device", out.name);
427 				if (errno != EINTR)
428 					err(1, "%s", out.name);
429 				nw = 0;
430 			}
431 			outp += nw;
432 			st.bytes += nw;
433 			if (nw == n) {
434 				if (n != out.dbsz)
435 					++st.out_part;
436 				else
437 					++st.out_full;
438 				break;
439 			}
440 			++st.out_part;
441 			if (nw == cnt)
442 				break;
443 			if (out.flags & ISCHR && !warned) {
444 				warned = 1;
445 				warnx("%s: short write on character device",
446 				    out.name);
447 			}
448 			if (out.flags & ISTAPE)
449 				errx(1, "%s: short write on tape device", out.name);
450 		}
451 		if ((out.dbcnt -= n) < out.dbsz)
452 			break;
453 	}
454 
455 	/* Reassemble the output block. */
456 	if (out.dbcnt)
457 		memmove(out.db, out.dbp - out.dbcnt, out.dbcnt);
458 	out.dbp = out.db + out.dbcnt;
459 }
460