Add the DragonFly cvs id and perform general cleanups on cvs/rcs/sccs ids. Most
[dragonfly.git] / bin / dd / dd.c
CommitLineData
984263bc
MD
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.
1de703da
MD
36 *
37 * @(#) Copyright (c) 1991, 1993, 1994 The Regents of the University of California. All rights reserved.
38 * @(#)dd.c 8.5 (Berkeley) 4/2/94
39 * $FreeBSD: src/bin/dd/dd.c,v 1.27.2.3 2001/08/01 01:37:35 obrien Exp $
40 * $DragonFly: src/bin/dd/dd.c,v 1.2 2003/06/17 04:22:49 dillon Exp $
984263bc
MD
41 */
42
984263bc
MD
43#include <sys/param.h>
44#include <sys/stat.h>
45#include <sys/conf.h>
46#include <sys/disklabel.h>
47#include <sys/filio.h>
48#include <sys/time.h>
49
50#include <ctype.h>
51#include <err.h>
52#include <errno.h>
53#include <fcntl.h>
54#include <locale.h>
55#include <stdio.h>
56#include <stdlib.h>
57#include <string.h>
58#include <unistd.h>
59
60#include "dd.h"
61#include "extern.h"
62
63static void dd_close __P((void));
64static void dd_in __P((void));
65int main __P((int, char *[]));
66static void getfdtype __P((IO *));
67static void setup __P((void));
68
69IO in, out; /* input/output state */
70STAT st; /* statistics */
71void (*cfunc) __P((void)); /* conversion function */
72quad_t cpy_cnt; /* # of blocks to copy */
73off_t pending = 0; /* pending seek if sparse */
74u_int ddflags; /* conversion options */
75size_t cbsz; /* conversion block size */
76quad_t files_cnt = 1; /* # of files to copy */
77const u_char *ctab; /* conversion table */
78
79int
80main(argc, argv)
81 int argc __unused;
82 char *argv[];
83{
84 (void)setlocale(LC_CTYPE, "");
85 jcl(argv);
86 setup();
87
88 (void)signal(SIGINFO, summaryx);
89 (void)signal(SIGINT, terminate);
90
91 atexit(summary);
92
93 while (files_cnt--)
94 dd_in();
95
96 dd_close();
97 exit(0);
98}
99
100static void
101setup()
102{
103 u_int cnt;
104 struct timeval tv;
105
106 if (in.name == NULL) {
107 in.name = "stdin";
108 in.fd = STDIN_FILENO;
109 } else {
110 in.fd = open(in.name, O_RDONLY, 0);
111 if (in.fd == -1)
112 err(1, "%s", in.name);
113 }
114
115 getfdtype(&in);
116
117 if (files_cnt > 1 && !(in.flags & ISTAPE))
118 errx(1, "files is not supported for non-tape devices");
119
120 if (out.name == NULL) {
121 /* No way to check for read access here. */
122 out.fd = STDOUT_FILENO;
123 out.name = "stdout";
124 } else {
125#define OFLAGS \
126 (O_CREAT | (ddflags & (C_SEEK | C_NOTRUNC) ? 0 : O_TRUNC))
127 out.fd = open(out.name, O_RDWR | OFLAGS, DEFFILEMODE);
128 /*
129 * May not have read access, so try again with write only.
130 * Without read we may have a problem if output also does
131 * not support seeks.
132 */
133 if (out.fd == -1) {
134 out.fd = open(out.name, O_WRONLY | OFLAGS, DEFFILEMODE);
135 out.flags |= NOREAD;
136 }
137 if (out.fd == -1)
138 err(1, "%s", out.name);
139 }
140
141 getfdtype(&out);
142
143 /*
144 * Allocate space for the input and output buffers. If not doing
145 * record oriented I/O, only need a single buffer.
146 */
147 if (!(ddflags & (C_BLOCK | C_UNBLOCK))) {
148 if ((in.db = malloc(out.dbsz + in.dbsz - 1)) == NULL)
149 err(1, "input buffer");
150 out.db = in.db;
151 } else if ((in.db = malloc(MAX(in.dbsz, cbsz) + cbsz)) == NULL ||
152 (out.db = malloc(out.dbsz + cbsz)) == NULL)
153 err(1, "output buffer");
154 in.dbp = in.db;
155 out.dbp = out.db;
156
157 /* Position the input/output streams. */
158 if (in.offset)
159 pos_in();
160 if (out.offset)
161 pos_out();
162
163 /*
164 * Truncate the output file. If it fails on a type of output file
165 * that it should _not_ fail on, error out.
166 */
167 if ((ddflags & (C_OF | C_SEEK | C_NOTRUNC)) == (C_OF | C_SEEK) &&
168 out.flags & ISTRUNC)
169 if (ftruncate(out.fd, out.offset * out.dbsz) == -1)
170 err(1, "truncating %s", out.name);
171
172 /*
173 * If converting case at the same time as another conversion, build a
174 * table that does both at once. If just converting case, use the
175 * built-in tables.
176 */
177 if (ddflags & (C_LCASE | C_UCASE)) {
178 if (ddflags & (C_ASCII | C_EBCDIC)) {
179 if (ddflags & C_LCASE) {
180 for (cnt = 0; cnt <= 0377; ++cnt)
181 casetab[cnt] = tolower(ctab[cnt]);
182 } else {
183 for (cnt = 0; cnt <= 0377; ++cnt)
184 casetab[cnt] = toupper(ctab[cnt]);
185 }
186 } else {
187 if (ddflags & C_LCASE) {
188 for (cnt = 0; cnt <= 0377; ++cnt)
189 casetab[cnt] = tolower((int)cnt);
190 } else {
191 for (cnt = 0; cnt <= 0377; ++cnt)
192 casetab[cnt] = toupper((int)cnt);
193 }
194 }
195 ctab = casetab;
196 }
197
198 (void)gettimeofday(&tv, (struct timezone *)NULL);
199 st.start = tv.tv_sec + tv.tv_usec * 1e-6;
200}
201
202static void
203getfdtype(io)
204 IO *io;
205{
206 struct stat sb;
207 int type;
208
209 if (fstat(io->fd, &sb) == -1)
210 err(1, "%s", io->name);
211 if (S_ISREG(sb.st_mode))
212 io->flags |= ISTRUNC;
213 if (S_ISCHR(sb.st_mode) || S_ISBLK(sb.st_mode)) {
214 if (ioctl(io->fd, FIODTYPE, &type) == -1) {
215 err(1, "%s", io->name);
216 } else {
217 if (type & D_TAPE)
218 io->flags |= ISTAPE;
219 else if (type & (D_DISK | D_MEM)) {
220 if (type & D_DISK) {
221 const int one = 1;
222
223 (void)ioctl(io->fd, DIOCWLABEL, &one);
224 }
225 io->flags |= ISSEEK;
226 }
227 if (S_ISCHR(sb.st_mode) && (type & D_TAPE) == 0)
228 io->flags |= ISCHR;
229 }
230 return;
231 }
232 errno = 0;
233 if (lseek(io->fd, (off_t)0, SEEK_CUR) == -1 && errno == ESPIPE)
234 io->flags |= ISPIPE;
235 else
236 io->flags |= ISSEEK;
237}
238
239static void
240dd_in()
241{
242 ssize_t n;
243
244 for (;;) {
245 switch (cpy_cnt) {
246 case -1: /* count=0 was specified */
247 return;
248 case 0:
249 break;
250 default:
251 if (st.in_full + st.in_part >= (u_quad_t)cpy_cnt)
252 return;
253 break;
254 }
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 a seekable file descriptor, 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 & ISSEEK &&
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 ((size_t)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, (size_t)n);
335 }
336
337 in.dbp += in.dbrcnt;
338 (*cfunc)();
339 }
340}
341
342/*
343 * Clean up any remaining I/O and flush output. If necessary, the output file
344 * is truncated.
345 */
346static void
347dd_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
366void
367dd_out(force)
368 int force;
369{
370 u_char *outp;
371 size_t cnt, i, n;
372 ssize_t nw;
373 static int warned;
374 int sparse;
375
376 /*
377 * Write one or more blocks out. The common case is writing a full
378 * output block in a single write; increment the full block stats.
379 * Otherwise, we're into partial block writes. If a partial write,
380 * and it's a character device, just warn. If a tape device, quit.
381 *
382 * The partial writes represent two cases. 1: Where the input block
383 * was less than expected so the output block was less than expected.
384 * 2: Where the input block was the right size but we were forced to
385 * write the block in multiple chunks. The original versions of dd(1)
386 * never wrote a block in more than a single write, so the latter case
387 * never happened.
388 *
389 * One special case is if we're forced to do the write -- in that case
390 * we play games with the buffer size, and it's usually a partial write.
391 */
392 outp = out.db;
393 for (n = force ? out.dbcnt : out.dbsz;; n = out.dbsz) {
394 for (cnt = n;; cnt -= nw) {
395 sparse = 0;
396 if (ddflags & C_SPARSE) {
397 sparse = 1; /* Is buffer sparse? */
398 for (i = 0; i < cnt; i++)
399 if (outp[i] != 0) {
400 sparse = 0;
401 break;
402 }
403 }
404 if (sparse && !force) {
405 pending += cnt;
406 nw = cnt;
407 } else {
408 if (pending != 0) {
409 if (force)
410 pending--;
411 if (lseek(out.fd, pending, SEEK_CUR) ==
412 -1)
413 err(2, "%s: seek error creating sparse file",
414 out.name);
415 if (force)
416 write(out.fd, outp, 1);
417 pending = 0;
418 }
419 if (cnt)
420 nw = write(out.fd, outp, cnt);
421 else
422 return;
423 }
424
425 if (nw <= 0) {
426 if (nw == 0)
427 errx(1, "%s: end of device", out.name);
428 if (errno != EINTR)
429 err(1, "%s", out.name);
430 nw = 0;
431 }
432 outp += nw;
433 st.bytes += nw;
434 if ((size_t)nw == n) {
435 if (n != out.dbsz)
436 ++st.out_part;
437 else
438 ++st.out_full;
439 break;
440 }
441 ++st.out_part;
442 if ((size_t)nw == cnt)
443 break;
444 if (out.flags & ISTAPE)
445 errx(1, "%s: short write on tape device",
446 out.name);
447 if (out.flags & ISCHR && !warned) {
448 warned = 1;
449 warnx("%s: short write on character device",
450 out.name);
451 }
452 }
453 if ((out.dbcnt -= n) < out.dbsz)
454 break;
455 }
456
457 /* Reassemble the output block. */
458 if (out.dbcnt)
459 (void)memmove(out.db, out.dbp - out.dbcnt, out.dbcnt);
460 out.dbp = out.db + out.dbcnt;
461}