2 * SPDX-License-Identifier: BSD-3-Clause
4 * Copyright (c) 1991, 1993, 1994
5 * The Regents of the University of California. All rights reserved.
7 * This code is derived from software contributed to Berkeley by
8 * Keith Muller of the University of California, San Diego and Lance
9 * Visser of Convex Computer Corporation.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. Neither the name of the University nor the names of its contributors
20 * may be used to endorse or promote products derived from this software
21 * without specific prior written permission.
23 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
24 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
25 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
26 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
27 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
28 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
29 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
30 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
31 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
32 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
35 * @(#)dd.c 8.5 (Berkeley) 4/2/94
36 * $FreeBSD: head/bin/dd/dd.c 341257 2018-11-29 19:28:01Z sobomax $
39 #include <sys/param.h>
43 #include <sys/device.h>
44 #include <sys/filio.h>
63 #define SIGINFO SIGUSR1
66 static void dd_close(void);
67 static void dd_in(void);
68 static void getfdtype(IO
*);
69 static int parity(u_char
);
70 static void setup(void);
71 static void speed_limit(void);
72 static void swapbytes(void *, size_t);
74 IO in
, out
; /* input/output state */
75 STAT st
; /* statistics */
76 void (*cfunc
)(void); /* conversion function */
77 uintmax_t cpy_cnt
; /* # of blocks to copy */
78 u_int ddflags
= 0; /* conversion options */
79 size_t cbsz
; /* conversion block size */
80 uintmax_t files_cnt
= 1; /* # of files to copy */
81 const u_char
*ctab
; /* conversion table */
82 char fill_char
; /* Character to fill with if defined */
83 size_t speed
= 0; /* maximum speed, in bytes per second */
84 volatile sig_atomic_t need_summary
;
85 volatile sig_atomic_t need_progress
;
87 static off_t pending
= 0; /* pending seek if sparse */
90 main(int argc __unused
, char *argv
[])
92 /* SIGALRM every second, if needed */
93 struct itimerval itv
= { { 1, 0 }, { 1, 0 } };
95 setlocale(LC_CTYPE
, "");
99 signal(SIGINFO
, siginfo_handler
);
100 if (ddflags
& C_PROGRESS
) {
101 signal(SIGALRM
, sigalarm_handler
);
102 setitimer(ITIMER_REAL
, &itv
, NULL
);
104 signal(SIGINT
, terminate
);
113 * Some devices such as cfi(4) may perform significant amounts
114 * of work when a write descriptor is closed. Close the out
115 * descriptor explicitly so that the summary handler (called
116 * from an atexit() hook) includes this work.
127 i
= c
^ (c
>> 1) ^ (c
>> 2) ^ (c
>> 3) ^
128 (c
>> 4) ^ (c
>> 5) ^ (c
>> 6) ^ (c
>> 7);
137 if (in
.name
== NULL
) {
139 in
.fd
= STDIN_FILENO
;
141 in
.fd
= open(in
.name
, O_RDONLY
, 0);
143 err(1, "%s", in
.name
);
148 if (files_cnt
> 1 && !(in
.flags
& ISTAPE
))
149 errx(1, "files is not supported for non-tape devices");
151 if (out
.name
== NULL
) {
152 /* No way to check for read access here. */
153 out
.fd
= STDOUT_FILENO
;
157 (O_CREAT | (ddflags & (C_SEEK | C_NOTRUNC) ? 0 : O_TRUNC))
158 out
.fd
= open(out
.name
, O_RDWR
| OFLAGS
, DEFFILEMODE
);
160 * May not have read access, so try again with write only.
161 * Without read we may have a problem if output also does
165 out
.fd
= open(out
.name
, O_WRONLY
| OFLAGS
, DEFFILEMODE
);
169 err(1, "%s", out
.name
);
175 * Allocate space for the input and output buffers. If not doing
176 * record oriented I/O, only need a single buffer.
178 if (!(ddflags
& (C_BLOCK
| C_UNBLOCK
))) {
179 if ((in
.db
= malloc((size_t)out
.dbsz
+ in
.dbsz
- 1)) == NULL
)
180 err(1, "input buffer");
182 } else if ((in
.db
= malloc(MAX((size_t)in
.dbsz
, cbsz
) + cbsz
)) == NULL
||
183 (out
.db
= malloc(out
.dbsz
+ cbsz
)) == NULL
) {
184 err(1, "output buffer");
187 /* dbp is the first free position in each buffer. */
191 /* Position the input/output streams. */
198 * Truncate the output file. If it fails on a type of output file
199 * that it should _not_ fail on, error out.
201 if ((ddflags
& (C_OF
| C_SEEK
| C_NOTRUNC
)) == (C_OF
| C_SEEK
) &&
203 if (ftruncate(out
.fd
, out
.offset
* out
.dbsz
) == -1)
204 err(1, "truncating %s", out
.name
);
206 if (ddflags
& (C_LCASE
| C_UCASE
| C_ASCII
| C_EBCDIC
| C_PARITY
)) {
208 for (cnt
= 0; cnt
<= 0377; ++cnt
)
209 casetab
[cnt
] = ctab
[cnt
];
211 for (cnt
= 0; cnt
<= 0377; ++cnt
)
214 if ((ddflags
& C_PARITY
) && !(ddflags
& C_ASCII
)) {
216 * If the input is not EBCDIC, and we do parity
217 * processing, strip input parity.
219 for (cnt
= 200; cnt
<= 0377; ++cnt
)
220 casetab
[cnt
] = casetab
[cnt
& 0x7f];
222 if (ddflags
& C_LCASE
) {
223 for (cnt
= 0; cnt
<= 0377; ++cnt
)
224 casetab
[cnt
] = tolower(casetab
[cnt
]);
225 } else if (ddflags
& C_UCASE
) {
226 for (cnt
= 0; cnt
<= 0377; ++cnt
)
227 casetab
[cnt
] = toupper(casetab
[cnt
]);
229 if ((ddflags
& C_PARITY
)) {
231 * This should strictly speaking be a no-op, but I
232 * wonder what funny LANG settings could get us.
234 for (cnt
= 0; cnt
<= 0377; ++cnt
)
235 casetab
[cnt
] = casetab
[cnt
] & 0x7f;
237 if ((ddflags
& C_PARSET
)) {
238 for (cnt
= 0; cnt
<= 0377; ++cnt
)
239 casetab
[cnt
] = casetab
[cnt
] | 0x80;
241 if ((ddflags
& C_PAREVEN
)) {
242 for (cnt
= 0; cnt
<= 0377; ++cnt
)
243 if (parity(casetab
[cnt
]))
244 casetab
[cnt
] = casetab
[cnt
] | 0x80;
246 if ((ddflags
& C_PARODD
)) {
247 for (cnt
= 0; cnt
<= 0377; ++cnt
)
248 if (!parity(casetab
[cnt
]))
249 casetab
[cnt
] = casetab
[cnt
] | 0x80;
255 if (clock_gettime(CLOCK_MONOTONIC
, &st
.start
))
256 err(1, "clock_gettime");
263 #ifndef BOOTSTRAPPING
267 if (fstat(io
->fd
, &sb
) == -1)
268 err(1, "%s", io
->name
);
269 if (S_ISREG(sb
.st_mode
))
270 io
->flags
|= ISTRUNC
;
271 if (S_ISCHR(sb
.st_mode
) || S_ISBLK(sb
.st_mode
)) {
273 io
->flags
|= ISSEEK
; /* assume D_DISK|D_MEM in btools */
275 if (ioctl(io
->fd
, FIODTYPE
, &type
) == -1) {
276 err(1, "%s", io
->name
);
280 else if (type
& (D_DISK
| D_MEM
))
282 if (S_ISCHR(sb
.st_mode
) && (type
& D_TAPE
) == 0)
289 if (lseek(io
->fd
, (off_t
)0, SEEK_CUR
) == -1 && errno
== ESPIPE
)
296 * Limit the speed by adding a delay before every block read.
297 * The delay (t_usleep) is equal to the time computed from block
298 * size and the specified speed limit (t_target) minus the time
299 * spent on actual read and write operations (t_io).
304 static double t_prev
, t_usleep
;
305 double t_now
, t_io
, t_target
;
307 t_now
= secs_elapsed();
308 t_io
= t_now
- t_prev
- t_usleep
;
309 t_target
= (double)in
.dbsz
/ (double)speed
;
310 t_usleep
= t_target
- t_io
;
312 usleep(t_usleep
* 1000000);
319 swapbytes(void *v
, size_t len
)
321 unsigned char *p
= v
;
340 case -1: /* count=0 was specified */
345 if (st
.in_full
+ st
.in_part
>= (uintmax_t)cpy_cnt
)
354 * Zero the buffer first if sync; if doing block operations,
357 if (ddflags
& C_SYNC
) {
358 if (ddflags
& C_FILL
)
359 memset(in
.dbp
, fill_char
, in
.dbsz
);
360 else if (ddflags
& (C_BLOCK
| C_UNBLOCK
))
361 memset(in
.dbp
, ' ', in
.dbsz
);
363 memset(in
.dbp
, 0, in
.dbsz
);
366 n
= read(in
.fd
, in
.dbp
, in
.dbsz
);
375 * If noerror not specified, die. POSIX requires that
376 * the warning message be followed by an I/O display.
378 if (!(ddflags
& C_NOERROR
))
379 err(1, "%s", in
.name
);
384 * If it's a seekable file descriptor, seek past the
385 * error. If your OS doesn't do the right thing for
386 * raw disks this section should be modified to re-read
387 * in sector size chunks.
389 if (in
.flags
& ISSEEK
&&
390 lseek(in
.fd
, (off_t
)in
.dbsz
, SEEK_CUR
))
393 /* If sync not specified, omit block and continue. */
394 if (!(ddflags
& C_SYNC
))
397 /* Read errors count as full blocks. */
398 in
.dbcnt
+= in
.dbrcnt
= in
.dbsz
;
401 /* Handle full input blocks. */
402 } else if (n
== in
.dbsz
) {
403 in
.dbcnt
+= in
.dbrcnt
= n
;
406 /* Handle partial input blocks. */
408 /* If sync, use the entire block. */
409 if (ddflags
& C_SYNC
)
410 in
.dbcnt
+= in
.dbrcnt
= in
.dbsz
;
412 in
.dbcnt
+= in
.dbrcnt
= n
;
417 * POSIX states that if bs is set and no other conversions
418 * than noerror, notrunc or sync are specified, the block
419 * is output without buffering as it is read.
421 if ((ddflags
& ~(C_NOERROR
| C_NOTRUNC
| C_SYNC
)) == C_BS
) {
422 out
.dbcnt
= in
.dbcnt
;
428 if (ddflags
& C_SWAB
) {
429 if ((n
= in
.dbrcnt
) & 1) {
433 swapbytes(in
.dbp
, (size_t)n
);
446 * Clean up any remaining I/O and flush output. If necessary, the output file
454 else if (cfunc
== block
)
456 else if (cfunc
== unblock
)
458 if (ddflags
& C_OSYNC
&& out
.dbcnt
&& out
.dbcnt
< out
.dbsz
) {
459 if (ddflags
& C_FILL
)
460 memset(out
.dbp
, fill_char
, out
.dbsz
- out
.dbcnt
);
461 else if (ddflags
& (C_BLOCK
| C_UNBLOCK
))
462 memset(out
.dbp
, ' ', out
.dbsz
- out
.dbcnt
);
464 memset(out
.dbp
, 0, out
.dbsz
- out
.dbcnt
);
465 out
.dbcnt
= out
.dbsz
;
467 if (out
.dbcnt
|| pending
)
471 * If the file ends with a hole, ftruncate it to extend its size
472 * up to the end of the hole (without having to write any data).
474 if (out
.seek_offset
> 0 && (out
.flags
& ISTRUNC
)) {
475 if (ftruncate(out
.fd
, out
.seek_offset
) == -1)
476 err(1, "truncating %s", out
.name
);
490 * Write one or more blocks out. The common case is writing a full
491 * output block in a single write; increment the full block stats.
492 * Otherwise, we're into partial block writes. If a partial write,
493 * and it's a character device, just warn. If a tape device, quit.
495 * The partial writes represent two cases. 1: Where the input block
496 * was less than expected so the output block was less than expected.
497 * 2: Where the input block was the right size but we were forced to
498 * write the block in multiple chunks. The original versions of dd(1)
499 * never wrote a block in more than a single write, so the latter case
502 * One special case is if we're forced to do the write -- in that case
503 * we play games with the buffer size, and it's usually a partial write.
508 * If force, first try to write all pending data, else try to write
509 * just one block. Subsequently always write data one full block at
512 for (n
= force
? out
.dbcnt
: out
.dbsz
;; n
= out
.dbsz
) {
516 if (ddflags
& C_SPARSE
) {
517 /* Is buffer sparse? */
518 sparse
= BISZERO(outp
, cnt
);
520 if (sparse
&& !force
) {
526 * Seek past hole. Note that we need to record the
527 * reached offset, because we might have no more data
528 * to write, in which case we'll need to call
529 * ftruncate to extend the file size.
531 out
.seek_offset
= lseek(out
.fd
, pending
, SEEK_CUR
);
532 if (out
.seek_offset
== -1)
533 err(2, "%s: seek error creating sparse file",
538 nw
= write(out
.fd
, outp
, cnt
);
547 errx(1, "%s: end of device", out
.name
);
549 err(1, "%s", out
.name
);
556 if ((size_t)nw
== n
&& n
== (size_t)out
.dbsz
)
561 if ((size_t) nw
!= cnt
) {
562 if (out
.flags
& ISTAPE
)
563 errx(1, "%s: short write on tape device",
565 if (out
.flags
& ISCHR
&& !warned
) {
567 warnx("%s: short write on character device",
575 if ((out
.dbcnt
-= n
) < out
.dbsz
)
579 /* Reassemble the output block. */
581 memmove(out
.db
, out
.dbp
- out
.dbcnt
, out
.dbcnt
);
582 out
.dbp
= out
.db
+ out
.dbcnt
;