1 /* dd -- convert a file while copying it.
2 Copyright (C) 1985, 1990-1991, 1995-2010 Free Software Foundation, Inc.
4 This program is free software: you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation, either version 3 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program. If not, see <http://www.gnu.org/licenses/>. */
17 /* Written by Paul Rubin, David MacKenzie, and Stuart Kemp. */
21 #define SWAB_ALIGN_OFFSET 2
23 #include <sys/types.h>
28 #include "close-stream.h"
30 #include "fd-reopen.h"
31 #include "gethrxtime.h"
33 #include "ignore-value.h"
34 #include "long-options.h"
40 static void process_signals (void);
42 /* The official name of this program (e.g., no `g' prefix). */
43 #define PROGRAM_NAME "dd"
46 proper_name ("Paul Rubin"), \
47 proper_name ("David MacKenzie"), \
48 proper_name ("Stuart Kemp")
50 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
51 present. SA_NODEFER and SA_RESETHAND are XSI extensions. */
53 # define SA_NOCLDSTOP 0
54 # define sigprocmask(How, Set, Oset) /* empty */
56 # if ! HAVE_SIGINTERRUPT
57 # define siginterrupt(sig, flag) /* empty */
62 # define SIGINFO SIGUSR1
65 /* This may belong in GNULIB's fcntl module instead.
66 Define O_CIO to 0 if it is not supported by this OS. */
72 # define fdatasync(fd) (errno = ENOSYS, -1)
75 #define output_char(c) \
79 if (oc >= output_blocksize) \
84 /* Default input and output blocksize. */
85 #define DEFAULT_BLOCKSIZE 512
87 /* How many bytes to add to the input and output block sizes before invoking
88 malloc. See dd_copy for details. INPUT_BLOCK_SLOP must be no less than
90 #define INPUT_BLOCK_SLOP (2 * SWAB_ALIGN_OFFSET + 2 * page_size - 1)
91 #define OUTPUT_BLOCK_SLOP (page_size - 1)
93 /* Maximum blocksize for the given SLOP.
94 Keep it smaller than SIZE_MAX - SLOP, so that we can
95 allocate buffers that size. Keep it smaller than SSIZE_MAX, for
96 the benefit of system calls like "read". And keep it smaller than
97 OFF_T_MAX, for the benefit of the large-offset seek code. */
98 #define MAX_BLOCKSIZE(slop) MIN (SIZE_MAX - (slop), MIN (SSIZE_MAX, OFF_T_MAX))
100 /* Conversions bit masks. */
116 /* Use separate input and output buffers, and combine partial
122 C_FDATASYNC = 040000,
126 /* Status bit masks. */
132 /* The name of the input file, or NULL for the standard input. */
133 static char const *input_file = NULL;
135 /* The name of the output file, or NULL for the standard output. */
136 static char const *output_file = NULL;
138 /* The page size on this host. */
139 static size_t page_size;
141 /* The number of bytes in which atomic reads are done. */
142 static size_t input_blocksize = 0;
144 /* The number of bytes in which atomic writes are done. */
145 static size_t output_blocksize = 0;
147 /* Conversion buffer size, in bytes. 0 prevents conversions. */
148 static size_t conversion_blocksize = 0;
150 /* Skip this many records of `input_blocksize' bytes before input. */
151 static uintmax_t skip_records = 0;
153 /* Skip this many records of `output_blocksize' bytes before output. */
154 static uintmax_t seek_records = 0;
156 /* Copy only this many records. The default is effectively infinity. */
157 static uintmax_t max_records = (uintmax_t) -1;
159 /* Bit vector of conversions to apply. */
160 static int conversions_mask = 0;
162 /* Open flags for the input and output files. */
163 static int input_flags = 0;
164 static int output_flags = 0;
166 /* Status flags for what is printed to stderr. */
167 static int status_flags = 0;
169 /* If nonzero, filter characters through the translation table. */
170 static bool translation_needed = false;
172 /* Number of partial blocks written. */
173 static uintmax_t w_partial = 0;
175 /* Number of full blocks written. */
176 static uintmax_t w_full = 0;
178 /* Number of partial blocks read. */
179 static uintmax_t r_partial = 0;
181 /* Number of full blocks read. */
182 static uintmax_t r_full = 0;
184 /* Number of bytes written. */
185 static uintmax_t w_bytes = 0;
187 /* Time that dd started. */
188 static xtime_t start_time;
190 /* True if input is seekable. */
191 static bool input_seekable;
193 /* Error number corresponding to initial attempt to lseek input.
194 If ESPIPE, do not issue any more diagnostics about it. */
195 static int input_seek_errno;
197 /* File offset of the input, in bytes, along with a flag recording
198 whether it overflowed. */
199 static uintmax_t input_offset;
200 static bool input_offset_overflow;
202 /* Records truncated by conv=block. */
203 static uintmax_t r_truncate = 0;
205 /* Output representation of newline and space characters.
206 They change if we're converting to EBCDIC. */
207 static char newline_character = '\n';
208 static char space_character = ' ';
213 /* Current index into `obuf'. */
214 static size_t oc = 0;
216 /* Index into current line, for `conv=block' and `conv=unblock'. */
217 static size_t col = 0;
219 /* The set of signals that are caught. */
220 static sigset_t caught_signals;
222 /* If nonzero, the value of the pending fatal signal. */
223 static sig_atomic_t volatile interrupt_signal;
225 /* A count of the number of pending info signals that have been received. */
226 static sig_atomic_t volatile info_signal_count;
228 /* Function used for read (to handle iflag=fullblock parameter). */
229 static ssize_t (*iread_fnc) (int fd, char *buf, size_t size);
231 /* A longest symbol in the struct symbol_values tables below. */
232 #define LONGEST_SYMBOL "fdatasync"
234 /* A symbol and the corresponding integer value. */
237 char symbol[sizeof LONGEST_SYMBOL];
241 /* Conversion symbols, for conv="...". */
242 static struct symbol_value const conversions[] =
244 {"ascii", C_ASCII | C_TWOBUFS}, /* EBCDIC to ASCII. */
245 {"ebcdic", C_EBCDIC | C_TWOBUFS}, /* ASCII to EBCDIC. */
246 {"ibm", C_IBM | C_TWOBUFS}, /* Slightly different ASCII to EBCDIC. */
247 {"block", C_BLOCK | C_TWOBUFS}, /* Variable to fixed length records. */
248 {"unblock", C_UNBLOCK | C_TWOBUFS}, /* Fixed to variable length records. */
249 {"lcase", C_LCASE | C_TWOBUFS}, /* Translate upper to lower case. */
250 {"ucase", C_UCASE | C_TWOBUFS}, /* Translate lower to upper case. */
251 {"swab", C_SWAB | C_TWOBUFS}, /* Swap bytes of input. */
252 {"noerror", C_NOERROR}, /* Ignore i/o errors. */
253 {"nocreat", C_NOCREAT}, /* Do not create output file. */
254 {"excl", C_EXCL}, /* Fail if the output file already exists. */
255 {"notrunc", C_NOTRUNC}, /* Do not truncate output file. */
256 {"sync", C_SYNC}, /* Pad input records to ibs with NULs. */
257 {"fdatasync", C_FDATASYNC}, /* Synchronize output data before finishing. */
258 {"fsync", C_FSYNC}, /* Also synchronize output metadata. */
264 /* Compute a value that's bitwise disjoint from the union
281 /* Use its lowest bit. */
282 O_FULLBLOCK = v ^ (v & (v - 1))
285 /* Ensure that we got something. */
286 verify (O_FULLBLOCK != 0);
288 #define MULTIPLE_BITS_SET(i) (((i) & ((i) - 1)) != 0)
290 /* Ensure that this is a single-bit value. */
291 verify ( ! MULTIPLE_BITS_SET (O_FULLBLOCK));
293 /* Flags, for iflag="..." and oflag="...". */
294 static struct symbol_value const flags[] =
296 {"append", O_APPEND},
297 {"binary", O_BINARY},
299 {"direct", O_DIRECT},
300 {"directory", O_DIRECTORY},
302 {"noatime", O_NOATIME},
303 {"noctty", O_NOCTTY},
304 {"nofollow", HAVE_WORKING_O_NOFOLLOW ? O_NOFOLLOW : 0},
305 {"nolinks", O_NOLINKS},
306 {"nonblock", O_NONBLOCK},
309 {"fullblock", O_FULLBLOCK}, /* Accumulate full blocks from input. */
313 /* Status, for status="...". */
314 static struct symbol_value const statuses[] =
316 {"noxfer", STATUS_NOXFER},
320 /* Translation table formed by applying successive transformations. */
321 static unsigned char trans_table[256];
323 static char const ascii_to_ebcdic[] =
325 '\000', '\001', '\002', '\003', '\067', '\055', '\056', '\057',
326 '\026', '\005', '\045', '\013', '\014', '\015', '\016', '\017',
327 '\020', '\021', '\022', '\023', '\074', '\075', '\062', '\046',
328 '\030', '\031', '\077', '\047', '\034', '\035', '\036', '\037',
329 '\100', '\117', '\177', '\173', '\133', '\154', '\120', '\175',
330 '\115', '\135', '\134', '\116', '\153', '\140', '\113', '\141',
331 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
332 '\370', '\371', '\172', '\136', '\114', '\176', '\156', '\157',
333 '\174', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
334 '\310', '\311', '\321', '\322', '\323', '\324', '\325', '\326',
335 '\327', '\330', '\331', '\342', '\343', '\344', '\345', '\346',
336 '\347', '\350', '\351', '\112', '\340', '\132', '\137', '\155',
337 '\171', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
338 '\210', '\211', '\221', '\222', '\223', '\224', '\225', '\226',
339 '\227', '\230', '\231', '\242', '\243', '\244', '\245', '\246',
340 '\247', '\250', '\251', '\300', '\152', '\320', '\241', '\007',
341 '\040', '\041', '\042', '\043', '\044', '\025', '\006', '\027',
342 '\050', '\051', '\052', '\053', '\054', '\011', '\012', '\033',
343 '\060', '\061', '\032', '\063', '\064', '\065', '\066', '\010',
344 '\070', '\071', '\072', '\073', '\004', '\024', '\076', '\341',
345 '\101', '\102', '\103', '\104', '\105', '\106', '\107', '\110',
346 '\111', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
347 '\130', '\131', '\142', '\143', '\144', '\145', '\146', '\147',
348 '\150', '\151', '\160', '\161', '\162', '\163', '\164', '\165',
349 '\166', '\167', '\170', '\200', '\212', '\213', '\214', '\215',
350 '\216', '\217', '\220', '\232', '\233', '\234', '\235', '\236',
351 '\237', '\240', '\252', '\253', '\254', '\255', '\256', '\257',
352 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
353 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
354 '\312', '\313', '\314', '\315', '\316', '\317', '\332', '\333',
355 '\334', '\335', '\336', '\337', '\352', '\353', '\354', '\355',
356 '\356', '\357', '\372', '\373', '\374', '\375', '\376', '\377'
359 static char const ascii_to_ibm[] =
361 '\000', '\001', '\002', '\003', '\067', '\055', '\056', '\057',
362 '\026', '\005', '\045', '\013', '\014', '\015', '\016', '\017',
363 '\020', '\021', '\022', '\023', '\074', '\075', '\062', '\046',
364 '\030', '\031', '\077', '\047', '\034', '\035', '\036', '\037',
365 '\100', '\132', '\177', '\173', '\133', '\154', '\120', '\175',
366 '\115', '\135', '\134', '\116', '\153', '\140', '\113', '\141',
367 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
368 '\370', '\371', '\172', '\136', '\114', '\176', '\156', '\157',
369 '\174', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
370 '\310', '\311', '\321', '\322', '\323', '\324', '\325', '\326',
371 '\327', '\330', '\331', '\342', '\343', '\344', '\345', '\346',
372 '\347', '\350', '\351', '\255', '\340', '\275', '\137', '\155',
373 '\171', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
374 '\210', '\211', '\221', '\222', '\223', '\224', '\225', '\226',
375 '\227', '\230', '\231', '\242', '\243', '\244', '\245', '\246',
376 '\247', '\250', '\251', '\300', '\117', '\320', '\241', '\007',
377 '\040', '\041', '\042', '\043', '\044', '\025', '\006', '\027',
378 '\050', '\051', '\052', '\053', '\054', '\011', '\012', '\033',
379 '\060', '\061', '\032', '\063', '\064', '\065', '\066', '\010',
380 '\070', '\071', '\072', '\073', '\004', '\024', '\076', '\341',
381 '\101', '\102', '\103', '\104', '\105', '\106', '\107', '\110',
382 '\111', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
383 '\130', '\131', '\142', '\143', '\144', '\145', '\146', '\147',
384 '\150', '\151', '\160', '\161', '\162', '\163', '\164', '\165',
385 '\166', '\167', '\170', '\200', '\212', '\213', '\214', '\215',
386 '\216', '\217', '\220', '\232', '\233', '\234', '\235', '\236',
387 '\237', '\240', '\252', '\253', '\254', '\255', '\256', '\257',
388 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
389 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
390 '\312', '\313', '\314', '\315', '\316', '\317', '\332', '\333',
391 '\334', '\335', '\336', '\337', '\352', '\353', '\354', '\355',
392 '\356', '\357', '\372', '\373', '\374', '\375', '\376', '\377'
395 static char const ebcdic_to_ascii[] =
397 '\000', '\001', '\002', '\003', '\234', '\011', '\206', '\177',
398 '\227', '\215', '\216', '\013', '\014', '\015', '\016', '\017',
399 '\020', '\021', '\022', '\023', '\235', '\205', '\010', '\207',
400 '\030', '\031', '\222', '\217', '\034', '\035', '\036', '\037',
401 '\200', '\201', '\202', '\203', '\204', '\012', '\027', '\033',
402 '\210', '\211', '\212', '\213', '\214', '\005', '\006', '\007',
403 '\220', '\221', '\026', '\223', '\224', '\225', '\226', '\004',
404 '\230', '\231', '\232', '\233', '\024', '\025', '\236', '\032',
405 '\040', '\240', '\241', '\242', '\243', '\244', '\245', '\246',
406 '\247', '\250', '\133', '\056', '\074', '\050', '\053', '\041',
407 '\046', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
408 '\260', '\261', '\135', '\044', '\052', '\051', '\073', '\136',
409 '\055', '\057', '\262', '\263', '\264', '\265', '\266', '\267',
410 '\270', '\271', '\174', '\054', '\045', '\137', '\076', '\077',
411 '\272', '\273', '\274', '\275', '\276', '\277', '\300', '\301',
412 '\302', '\140', '\072', '\043', '\100', '\047', '\075', '\042',
413 '\303', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
414 '\150', '\151', '\304', '\305', '\306', '\307', '\310', '\311',
415 '\312', '\152', '\153', '\154', '\155', '\156', '\157', '\160',
416 '\161', '\162', '\313', '\314', '\315', '\316', '\317', '\320',
417 '\321', '\176', '\163', '\164', '\165', '\166', '\167', '\170',
418 '\171', '\172', '\322', '\323', '\324', '\325', '\326', '\327',
419 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
420 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
421 '\173', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
422 '\110', '\111', '\350', '\351', '\352', '\353', '\354', '\355',
423 '\175', '\112', '\113', '\114', '\115', '\116', '\117', '\120',
424 '\121', '\122', '\356', '\357', '\360', '\361', '\362', '\363',
425 '\134', '\237', '\123', '\124', '\125', '\126', '\127', '\130',
426 '\131', '\132', '\364', '\365', '\366', '\367', '\370', '\371',
427 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
428 '\070', '\071', '\372', '\373', '\374', '\375', '\376', '\377'
431 /* True if we need to close the standard output *stream*. */
432 static bool close_stdout_required = true;
434 /* The only reason to close the standard output *stream* is if
435 parse_long_options fails (as it does for --help or --version).
436 In any other case, dd uses only the STDOUT_FILENO file descriptor,
437 and the "cleanup" function calls "close (STDOUT_FILENO)".
438 Closing the file descriptor and then letting the usual atexit-run
439 close_stdout function call "fclose (stdout)" would result in a
440 harmless failure of the close syscall (with errno EBADF).
441 This function serves solely to avoid the unnecessary close_stdout
442 call, once parse_long_options has succeeded.
443 Meanwhile, we guarantee that the standard error stream is flushed,
444 by inlining the last half of close_stdout as needed. */
446 maybe_close_stdout (void)
448 if (close_stdout_required)
450 else if (close_stream (stderr) != 0)
451 _exit (EXIT_FAILURE);
457 if (status != EXIT_SUCCESS)
458 fprintf (stderr, _("Try `%s --help' for more information.\n"),
463 Usage: %s [OPERAND]...\n\
466 program_name, program_name);
468 Copy a file, converting and formatting according to the operands.\n\
470 bs=BYTES read and write BYTES bytes at a time (also see ibs=,obs=)\n\
471 cbs=BYTES convert BYTES bytes at a time\n\
472 conv=CONVS convert the file as per the comma separated symbol list\n\
473 count=BLOCKS copy only BLOCKS input blocks\n\
474 ibs=BYTES read BYTES bytes at a time (default: 512)\n\
477 if=FILE read from FILE instead of stdin\n\
478 iflag=FLAGS read as per the comma separated symbol list\n\
479 obs=BYTES write BYTES bytes at a time (default: 512)\n\
480 of=FILE write to FILE instead of stdout\n\
481 oflag=FLAGS write as per the comma separated symbol list\n\
482 seek=BLOCKS skip BLOCKS obs-sized blocks at start of output\n\
483 skip=BLOCKS skip BLOCKS ibs-sized blocks at start of input\n\
484 status=noxfer suppress transfer statistics\n\
488 BLOCKS and BYTES may be followed by the following multiplicative suffixes:\n\
489 c =1, w =2, b =512, kB =1000, K =1024, MB =1000*1000, M =1024*1024, xM =M\n\
490 GB =1000*1000*1000, G =1024*1024*1024, and so on for T, P, E, Z, Y.\n\
492 Each CONV symbol may be:\n\
496 ascii from EBCDIC to ASCII\n\
497 ebcdic from ASCII to EBCDIC\n\
498 ibm from ASCII to alternate EBCDIC\n\
499 block pad newline-terminated records with spaces to cbs-size\n\
500 unblock replace trailing spaces in cbs-size records with newline\n\
501 lcase change upper case to lower case\n\
504 nocreat do not create the output file\n\
505 excl fail if the output file already exists\n\
506 notrunc do not truncate the output file\n\
507 ucase change lower case to upper case\n\
508 swab swap every pair of input bytes\n\
511 noerror continue after read errors\n\
512 sync pad every input block with NULs to ibs-size; when used\n\
513 with block or unblock, pad with spaces rather than NULs\n\
514 fdatasync physically write output file data before finishing\n\
515 fsync likewise, but also write metadata\n\
519 Each FLAG symbol may be:\n\
521 append append mode (makes sense only for output; conv=notrunc suggested)\n\
524 fputs (_(" cio use concurrent I/O for data\n"), stdout);
526 fputs (_(" direct use direct I/O for data\n"), stdout);
528 fputs (_(" directory fail unless a directory\n"), stdout);
530 fputs (_(" dsync use synchronized I/O for data\n"), stdout);
532 fputs (_(" sync likewise, but also for metadata\n"), stdout);
533 fputs (_(" fullblock accumulate full blocks of input (iflag only)\n"),
536 fputs (_(" nonblock use non-blocking I/O\n"), stdout);
538 fputs (_(" noatime do not update access time\n"), stdout);
540 fputs (_(" noctty do not assign controlling terminal from file\n"),
542 if (HAVE_WORKING_O_NOFOLLOW)
543 fputs (_(" nofollow do not follow symlinks\n"), stdout);
545 fputs (_(" nolinks fail if multiply-linked\n"), stdout);
547 fputs (_(" binary use binary I/O for data\n"), stdout);
549 fputs (_(" text use text I/O for data\n"), stdout);
552 char const *siginfo_name = (SIGINFO == SIGUSR1 ? "USR1" : "INFO");
555 Sending a %s signal to a running `dd' process makes it\n\
556 print I/O statistics to standard error and then resume copying.\n\
558 $ dd if=/dev/zero of=/dev/null& pid=$!\n\
559 $ kill -%s $pid; sleep 1; kill $pid\n\
560 18335302+0 records in\n\
561 18335302+0 records out\n\
562 9387674624 bytes (9.4 GB) copied, 34.6279 seconds, 271 MB/s\n\
567 siginfo_name, siginfo_name);
570 fputs (HELP_OPTION_DESCRIPTION, stdout);
571 fputs (VERSION_OPTION_DESCRIPTION, stdout);
572 emit_ancillary_info ();
578 translate_charset (char const *new_trans)
582 for (i = 0; i < 256; i++)
583 trans_table[i] = new_trans[trans_table[i]];
584 translation_needed = true;
587 /* Return true if I has more than one bit set. I must be nonnegative. */
590 multiple_bits_set (int i)
592 return MULTIPLE_BITS_SET (i);
595 /* Print transfer statistics. */
600 xtime_t now = gethrxtime ();
601 char hbuf[LONGEST_HUMAN_READABLE + 1];
603 (human_autoscale | human_round_to_nearest
604 | human_space_before_unit | human_SI | human_B);
606 char const *bytes_per_second;
609 _("%"PRIuMAX"+%"PRIuMAX" records in\n"
610 "%"PRIuMAX"+%"PRIuMAX" records out\n"),
611 r_full, r_partial, w_full, w_partial);
615 ngettext ("%"PRIuMAX" truncated record\n",
616 "%"PRIuMAX" truncated records\n",
617 select_plural (r_truncate)),
620 if (status_flags & STATUS_NOXFER)
623 /* Use integer arithmetic to compute the transfer rate,
624 since that makes it easy to use SI abbreviations. */
627 ngettext ("%"PRIuMAX" byte (%s) copied",
628 "%"PRIuMAX" bytes (%s) copied",
629 select_plural (w_bytes)),
631 human_readable (w_bytes, hbuf, human_opts, 1, 1));
633 if (start_time < now)
635 double XTIME_PRECISIONe0 = XTIME_PRECISION;
636 uintmax_t delta_xtime = now;
637 delta_xtime -= start_time;
638 delta_s = delta_xtime / XTIME_PRECISIONe0;
639 bytes_per_second = human_readable (w_bytes, hbuf, human_opts,
640 XTIME_PRECISION, delta_xtime);
645 bytes_per_second = _("Infinity B");
648 /* TRANSLATORS: The two instances of "s" in this string are the SI
649 symbol "s" (meaning second), and should not be translated.
651 This format used to be:
653 ngettext (", %g second, %s/s\n", ", %g seconds, %s/s\n", delta_s == 1)
655 but that was incorrect for languages like Polish. To fix this
656 bug we now use SI symbols even though they're a bit more
657 confusing in English. */
658 fprintf (stderr, _(", %g s, %s/s\n"), delta_s, bytes_per_second);
664 if (close (STDIN_FILENO) < 0)
665 error (EXIT_FAILURE, errno,
666 _("closing input file %s"), quote (input_file));
668 /* Don't remove this call to close, even though close_stdout
669 closes standard output. This close is necessary when cleanup
670 is called as part of a signal handler. */
671 if (close (STDOUT_FILENO) < 0)
672 error (EXIT_FAILURE, errno,
673 _("closing output file %s"), quote (output_file));
676 static void ATTRIBUTE_NORETURN
685 /* An ordinary signal was received; arrange for the program to exit. */
688 interrupt_handler (int sig)
691 signal (sig, SIG_DFL);
692 interrupt_signal = sig;
695 /* An info signal was received; arrange for the program to print status. */
698 siginfo_handler (int sig)
701 signal (sig, siginfo_handler);
705 /* Install the signal handlers. */
708 install_signal_handlers (void)
710 bool catch_siginfo = ! (SIGINFO == SIGUSR1 && getenv ("POSIXLY_CORRECT"));
714 struct sigaction act;
715 sigemptyset (&caught_signals);
718 sigaction (SIGINFO, NULL, &act);
719 if (act.sa_handler != SIG_IGN)
720 sigaddset (&caught_signals, SIGINFO);
722 sigaction (SIGINT, NULL, &act);
723 if (act.sa_handler != SIG_IGN)
724 sigaddset (&caught_signals, SIGINT);
725 act.sa_mask = caught_signals;
727 if (sigismember (&caught_signals, SIGINFO))
729 act.sa_handler = siginfo_handler;
731 sigaction (SIGINFO, &act, NULL);
734 if (sigismember (&caught_signals, SIGINT))
736 /* POSIX 1003.1-2001 says SA_RESETHAND implies SA_NODEFER,
737 but this is not true on Solaris 8 at least. It doesn't
738 hurt to use SA_NODEFER here, so leave it in. */
739 act.sa_handler = interrupt_handler;
740 act.sa_flags = SA_NODEFER | SA_RESETHAND;
741 sigaction (SIGINT, &act, NULL);
746 if (catch_siginfo && signal (SIGINFO, SIG_IGN) != SIG_IGN)
748 signal (SIGINFO, siginfo_handler);
749 siginterrupt (SIGINFO, 1);
751 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
753 signal (SIGINT, interrupt_handler);
754 siginterrupt (SIGINT, 1);
759 /* Process any pending signals. If signals are caught, this function
760 should be called periodically. Ideally there should never be an
761 unbounded amount of time when signals are not being processed. */
764 process_signals (void)
766 while (interrupt_signal || info_signal_count)
772 sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
774 /* Reload interrupt_signal and info_signal_count, in case a new
775 signal was handled before sigprocmask took effect. */
776 interrupt = interrupt_signal;
777 infos = info_signal_count;
780 info_signal_count = infos - 1;
782 sigprocmask (SIG_SETMASK, &oldset, NULL);
792 /* Read from FD into the buffer BUF of size SIZE, processing any
793 signals that arrive before bytes are read. Return the number of
794 bytes read if successful, -1 (setting errno) on failure. */
797 iread (int fd, char *buf, size_t size)
803 nread = read (fd, buf, size);
804 if (! (nread < 0 && errno == EINTR))
809 /* Wrapper around iread function to accumulate full blocks. */
811 iread_fullblock (int fd, char *buf, size_t size)
817 ssize_t ncurr = iread (fd, buf, size);
830 /* Write to FD the buffer BUF of size SIZE, processing any signals
831 that arrive. Return the number of bytes written, setting errno if
832 this is less than SIZE. Keep trying if there are partial
836 iwrite (int fd, char const *buf, size_t size)
838 size_t total_written = 0;
840 if ((output_flags & O_DIRECT) && size < output_blocksize)
842 int old_flags = fcntl (STDOUT_FILENO, F_GETFL);
843 if (fcntl (STDOUT_FILENO, F_SETFL, old_flags & ~O_DIRECT) != 0)
844 error (0, errno, _("failed to turn off O_DIRECT: %s"),
845 quote (output_file));
847 /* Since we have just turned off O_DIRECT for the final write,
848 here we try to preserve some of its semantics. First, use
849 posix_fadvise to tell the system not to pollute the buffer
850 cache with this data. Don't bother to diagnose lseek or
851 posix_fadvise failure. */
852 #ifdef POSIX_FADV_DONTNEED
853 off_t off = lseek (STDOUT_FILENO, 0, SEEK_CUR);
855 ignore_value (posix_fadvise (STDOUT_FILENO,
856 off, 0, POSIX_FADV_DONTNEED));
859 /* Attempt to ensure that that final block is committed
860 to disk as quickly as possible. */
861 conversions_mask |= C_FSYNC;
864 while (total_written < size)
868 nwritten = write (fd, buf + total_written, size - total_written);
874 else if (nwritten == 0)
876 /* Some buggy drivers return 0 when one tries to write beyond
877 a device's end. (Example: Linux kernel 1.2.13 on /dev/fd0.)
878 Set errno to ENOSPC so they get a sensible diagnostic. */
883 total_written += nwritten;
886 return total_written;
889 /* Write, then empty, the output buffer `obuf'. */
894 size_t nwritten = iwrite (STDOUT_FILENO, obuf, output_blocksize);
896 if (nwritten != output_blocksize)
898 error (0, errno, _("writing to %s"), quote (output_file));
908 /* Return true if STR is of the form "PATTERN" or "PATTERNDELIM...". */
911 operand_matches (char const *str, char const *pattern, char delim)
914 if (*str++ != *pattern++)
916 return !*str || *str == delim;
919 /* Interpret one "conv=..." or similar operand STR according to the
920 symbols in TABLE, returning the flags specified. If the operand
921 cannot be parsed, use ERROR_MSGID to generate a diagnostic. */
924 parse_symbols (char const *str, struct symbol_value const *table,
925 char const *error_msgid)
931 char const *strcomma = strchr (str, ',');
932 struct symbol_value const *entry;
935 ! (operand_matches (str, entry->symbol, ',') && entry->value);
938 if (! entry->symbol[0])
940 size_t slen = strcomma ? strcomma - str : strlen (str);
941 error (0, 0, "%s: %s", _(error_msgid),
942 quotearg_n_style_mem (0, locale_quoting_style, str, slen));
943 usage (EXIT_FAILURE);
947 value |= entry->value;
956 /* Return the value of STR, interpreted as a non-negative decimal integer,
957 optionally multiplied by various values.
958 Set *INVALID if STR does not represent a number in this format. */
961 parse_integer (const char *str, bool *invalid)
965 enum strtol_error e = xstrtoumax (str, &suffix, 10, &n, "bcEGkKMPTwYZ0");
967 if (e == LONGINT_INVALID_SUFFIX_CHAR && *suffix == 'x')
969 uintmax_t multiplier = parse_integer (suffix + 1, invalid);
971 if (multiplier != 0 && n * multiplier / multiplier != n)
979 else if (e != LONGINT_OK)
988 /* OPERAND is of the form "X=...". Return true if X is NAME. */
991 operand_is (char const *operand, char const *name)
993 return operand_matches (operand, name, '=');
997 scanargs (int argc, char *const *argv)
1000 size_t blocksize = 0;
1002 for (i = optind; i < argc; i++)
1004 char const *name = argv[i];
1005 char const *val = strchr (name, '=');
1009 error (0, 0, _("unrecognized operand %s"), quote (name));
1010 usage (EXIT_FAILURE);
1014 if (operand_is (name, "if"))
1016 else if (operand_is (name, "of"))
1018 else if (operand_is (name, "conv"))
1019 conversions_mask |= parse_symbols (val, conversions,
1020 N_("invalid conversion"));
1021 else if (operand_is (name, "iflag"))
1022 input_flags |= parse_symbols (val, flags,
1023 N_("invalid input flag"));
1024 else if (operand_is (name, "oflag"))
1025 output_flags |= parse_symbols (val, flags,
1026 N_("invalid output flag"));
1027 else if (operand_is (name, "status"))
1028 status_flags |= parse_symbols (val, statuses,
1029 N_("invalid status flag"));
1032 bool invalid = false;
1033 uintmax_t n = parse_integer (val, &invalid);
1035 if (operand_is (name, "ibs"))
1037 invalid |= ! (0 < n && n <= MAX_BLOCKSIZE (INPUT_BLOCK_SLOP));
1038 input_blocksize = n;
1040 else if (operand_is (name, "obs"))
1042 invalid |= ! (0 < n && n <= MAX_BLOCKSIZE (OUTPUT_BLOCK_SLOP));
1043 output_blocksize = n;
1045 else if (operand_is (name, "bs"))
1047 invalid |= ! (0 < n && n <= MAX_BLOCKSIZE (INPUT_BLOCK_SLOP));
1050 else if (operand_is (name, "cbs"))
1052 invalid |= ! (0 < n && n <= SIZE_MAX);
1053 conversion_blocksize = n;
1055 else if (operand_is (name, "skip"))
1057 else if (operand_is (name, "seek"))
1059 else if (operand_is (name, "count"))
1063 error (0, 0, _("unrecognized operand %s"), quote (name));
1064 usage (EXIT_FAILURE);
1068 error (EXIT_FAILURE, 0, _("invalid number %s"), quote (val));
1073 input_blocksize = output_blocksize = blocksize;
1076 /* POSIX says dd aggregates short reads into
1077 output_blocksize if bs= is not specified. */
1078 conversions_mask |= C_TWOBUFS;
1081 if (input_blocksize == 0)
1082 input_blocksize = DEFAULT_BLOCKSIZE;
1083 if (output_blocksize == 0)
1084 output_blocksize = DEFAULT_BLOCKSIZE;
1085 if (conversion_blocksize == 0)
1086 conversions_mask &= ~(C_BLOCK | C_UNBLOCK);
1088 if (input_flags & (O_DSYNC | O_SYNC))
1089 input_flags |= O_RSYNC;
1091 if (output_flags & O_FULLBLOCK)
1093 error (0, 0, "%s: %s", _("invalid output flag"), "'fullblock'");
1094 usage (EXIT_FAILURE);
1096 iread_fnc = ((input_flags & O_FULLBLOCK)
1099 input_flags &= ~O_FULLBLOCK;
1101 if (multiple_bits_set (conversions_mask & (C_ASCII | C_EBCDIC | C_IBM)))
1102 error (EXIT_FAILURE, 0, _("cannot combine any two of {ascii,ebcdic,ibm}"));
1103 if (multiple_bits_set (conversions_mask & (C_BLOCK | C_UNBLOCK)))
1104 error (EXIT_FAILURE, 0, _("cannot combine block and unblock"));
1105 if (multiple_bits_set (conversions_mask & (C_LCASE | C_UCASE)))
1106 error (EXIT_FAILURE, 0, _("cannot combine lcase and ucase"));
1107 if (multiple_bits_set (conversions_mask & (C_EXCL | C_NOCREAT)))
1108 error (EXIT_FAILURE, 0, _("cannot combine excl and nocreat"));
1111 /* Fix up translation table. */
1114 apply_translations (void)
1118 if (conversions_mask & C_ASCII)
1119 translate_charset (ebcdic_to_ascii);
1121 if (conversions_mask & C_UCASE)
1123 for (i = 0; i < 256; i++)
1124 trans_table[i] = toupper (trans_table[i]);
1125 translation_needed = true;
1127 else if (conversions_mask & C_LCASE)
1129 for (i = 0; i < 256; i++)
1130 trans_table[i] = tolower (trans_table[i]);
1131 translation_needed = true;
1134 if (conversions_mask & C_EBCDIC)
1136 translate_charset (ascii_to_ebcdic);
1137 newline_character = ascii_to_ebcdic['\n'];
1138 space_character = ascii_to_ebcdic[' '];
1140 else if (conversions_mask & C_IBM)
1142 translate_charset (ascii_to_ibm);
1143 newline_character = ascii_to_ibm['\n'];
1144 space_character = ascii_to_ibm[' '];
1148 /* Apply the character-set translations specified by the user
1149 to the NREAD bytes in BUF. */
1152 translate_buffer (char *buf, size_t nread)
1157 for (i = nread, cp = buf; i; i--, cp++)
1158 *cp = trans_table[to_uchar (*cp)];
1161 /* If true, the last char from the previous call to `swab_buffer'
1162 is saved in `saved_char'. */
1163 static bool char_is_saved = false;
1165 /* Odd char from previous call. */
1166 static char saved_char;
1168 /* Swap NREAD bytes in BUF, plus possibly an initial char from the
1169 previous call. If NREAD is odd, save the last char for the
1170 next call. Return the new start of the BUF buffer. */
1173 swab_buffer (char *buf, size_t *nread)
1175 char *bufstart = buf;
1179 /* Is a char left from last time? */
1182 *--bufstart = saved_char;
1184 char_is_saved = false;
1189 /* An odd number of chars are in the buffer. */
1190 saved_char = bufstart[--*nread];
1191 char_is_saved = true;
1194 /* Do the byte-swapping by moving every second character two
1195 positions toward the end, working from the end of the buffer
1196 toward the beginning. This way we only move half of the data. */
1198 cp = bufstart + *nread; /* Start one char past the last. */
1199 for (i = *nread / 2; i; i--, cp -= 2)
1205 /* Add OFFSET to the input offset, setting the overflow flag if
1209 advance_input_offset (uintmax_t offset)
1211 input_offset += offset;
1212 if (input_offset < offset)
1213 input_offset_overflow = true;
1216 /* This is a wrapper for lseek. It detects and warns about a kernel
1217 bug that makes lseek a no-op for tape devices, even though the kernel
1218 lseek return value suggests that the function succeeded.
1220 The parameters are the same as those of the lseek function, but
1221 with the addition of FILENAME, the name of the file associated with
1222 descriptor FDESC. The file name is used solely in the warning that's
1223 printed when the bug is detected. Return the same value that lseek
1224 would have returned, but when the lseek bug is detected, return -1
1225 to indicate that lseek failed.
1227 The offending behavior has been confirmed with an Exabyte SCSI tape
1228 drive accessed via /dev/nst0 on both Linux 2.2.17 and 2.4.16 kernels. */
1232 # include <sys/mtio.h>
1234 # define MT_SAME_POSITION(P, Q) \
1235 ((P).mt_resid == (Q).mt_resid \
1236 && (P).mt_fileno == (Q).mt_fileno \
1237 && (P).mt_blkno == (Q).mt_blkno)
1240 skip_via_lseek (char const *filename, int fdesc, off_t offset, int whence)
1244 bool got_original_tape_position = (ioctl (fdesc, MTIOCGET, &s1) == 0);
1245 /* known bad device type */
1246 /* && s.mt_type == MT_ISSCSI2 */
1248 off_t new_position = lseek (fdesc, offset, whence);
1249 if (0 <= new_position
1250 && got_original_tape_position
1251 && ioctl (fdesc, MTIOCGET, &s2) == 0
1252 && MT_SAME_POSITION (s1, s2))
1254 error (0, 0, _("warning: working around lseek kernel bug for file (%s)\n\
1255 of mt_type=0x%0lx -- see <sys/mtio.h> for the list of types"),
1256 filename, s2.mt_type);
1261 return new_position;
1264 # define skip_via_lseek(Filename, Fd, Offset, Whence) lseek (Fd, Offset, Whence)
1267 /* Throw away RECORDS blocks of BLOCKSIZE bytes on file descriptor FDESC,
1268 which is open with read permission for FILE. Store up to BLOCKSIZE
1269 bytes of the data at a time in BUF, if necessary. RECORDS must be
1270 nonzero. If fdesc is STDIN_FILENO, advance the input offset.
1271 Return the number of records remaining, i.e., that were not skipped
1272 because EOF was reached. */
1275 skip (int fdesc, char const *file, uintmax_t records, size_t blocksize,
1278 uintmax_t offset = records * blocksize;
1280 /* Try lseek and if an error indicates it was an inappropriate operation --
1281 or if the file offset is not representable as an off_t --
1282 fall back on using read. */
1285 if (records <= OFF_T_MAX / blocksize
1286 && 0 <= skip_via_lseek (file, fdesc, offset, SEEK_CUR))
1288 if (fdesc == STDIN_FILENO)
1291 if (fstat (STDIN_FILENO, &st) != 0)
1292 error (EXIT_FAILURE, errno, _("cannot fstat %s"), quote (file));
1293 if (S_ISREG (st.st_mode) && st.st_size < (input_offset + offset))
1295 /* When skipping past EOF, return the number of _full_ blocks
1296 * that are not skipped, and set offset to EOF, so the caller
1297 * can determine the requested skip was not satisfied. */
1298 records = ( offset - st.st_size ) / blocksize;
1299 offset = st.st_size - input_offset;
1303 advance_input_offset (offset);
1311 int lseek_errno = errno;
1313 /* The seek request may have failed above if it was too big
1314 (> device size, > max file size, etc.)
1315 Or it may not have been done at all (> OFF_T_MAX).
1316 Therefore try to seek to the end of the file,
1317 to avoid redundant reading. */
1318 if ((skip_via_lseek (file, fdesc, 0, SEEK_END)) >= 0)
1320 /* File is seekable, and we're at the end of it, and
1321 size <= OFF_T_MAX. So there's no point using read to advance. */
1325 /* The original seek was not attempted as offset > OFF_T_MAX.
1326 We should error for write as can't get to the desired
1327 location, even if OFF_T_MAX < max file size.
1328 For read we're not going to read any data anyway,
1329 so we should error for consistency.
1330 It would be nice to not error for /dev/{zero,null}
1331 for any offset, but that's not a significant issue. */
1332 lseek_errno = EOVERFLOW;
1335 if (fdesc == STDIN_FILENO)
1336 error (0, lseek_errno, _("%s: cannot skip"), quote (file));
1338 error (0, lseek_errno, _("%s: cannot seek"), quote (file));
1339 /* If the file has a specific size and we've asked
1340 to skip/seek beyond the max allowable, then quit. */
1341 quit (EXIT_FAILURE);
1343 /* else file_size && offset > OFF_T_MAX or file ! seekable */
1347 ssize_t nread = iread_fnc (fdesc, buf, blocksize);
1350 if (fdesc == STDIN_FILENO)
1352 error (0, errno, _("reading %s"), quote (file));
1353 if (conversions_mask & C_NOERROR)
1360 error (0, lseek_errno, _("%s: cannot seek"), quote (file));
1361 quit (EXIT_FAILURE);
1366 if (fdesc == STDIN_FILENO)
1367 advance_input_offset (nread);
1369 while (--records != 0);
1375 /* Advance the input by NBYTES if possible, after a read error.
1376 The input file offset may or may not have advanced after the failed
1377 read; adjust it to point just after the bad record regardless.
1378 Return true if successful, or if the input is already known to not
1382 advance_input_after_read_error (size_t nbytes)
1384 if (! input_seekable)
1386 if (input_seek_errno == ESPIPE)
1388 errno = input_seek_errno;
1393 advance_input_offset (nbytes);
1394 input_offset_overflow |= (OFF_T_MAX < input_offset);
1395 if (input_offset_overflow)
1397 error (0, 0, _("offset overflow while reading file %s"),
1398 quote (input_file));
1401 offset = lseek (STDIN_FILENO, 0, SEEK_CUR);
1405 if (offset == input_offset)
1407 diff = input_offset - offset;
1408 if (! (0 <= diff && diff <= nbytes))
1409 error (0, 0, _("warning: invalid file offset after failed read"));
1410 if (0 <= skip_via_lseek (input_file, STDIN_FILENO, diff, SEEK_CUR))
1413 error (0, 0, _("cannot work around kernel bug after all"));
1417 error (0, errno, _("%s: cannot seek"), quote (input_file));
1421 /* Copy NREAD bytes of BUF, with no conversions. */
1424 copy_simple (char const *buf, size_t nread)
1426 const char *start = buf; /* First uncopied char in BUF. */
1430 size_t nfree = MIN (nread, output_blocksize - oc);
1432 memcpy (obuf + oc, start, nfree);
1434 nread -= nfree; /* Update the number of bytes left to copy. */
1437 if (oc >= output_blocksize)
1443 /* Copy NREAD bytes of BUF, doing conv=block
1444 (pad newline-terminated records to `conversion_blocksize',
1445 replacing the newline with trailing spaces). */
1448 copy_with_block (char const *buf, size_t nread)
1452 for (i = nread; i; i--, buf++)
1454 if (*buf == newline_character)
1456 if (col < conversion_blocksize)
1459 for (j = col; j < conversion_blocksize; j++)
1460 output_char (space_character);
1466 if (col == conversion_blocksize)
1468 else if (col < conversion_blocksize)
1475 /* Copy NREAD bytes of BUF, doing conv=unblock
1476 (replace trailing spaces in `conversion_blocksize'-sized records
1480 copy_with_unblock (char const *buf, size_t nread)
1484 static size_t pending_spaces = 0;
1486 for (i = 0; i < nread; i++)
1490 if (col++ >= conversion_blocksize)
1492 col = pending_spaces = 0; /* Wipe out any pending spaces. */
1493 i--; /* Push the char back; get it later. */
1494 output_char (newline_character);
1496 else if (c == space_character)
1500 /* `c' is the character after a run of spaces that were not
1501 at the end of the conversion buffer. Output them. */
1502 while (pending_spaces)
1504 output_char (space_character);
1512 /* Set the file descriptor flags for FD that correspond to the nonzero bits
1513 in ADD_FLAGS. The file's name is NAME. */
1516 set_fd_flags (int fd, int add_flags, char const *name)
1518 /* Ignore file creation flags that are no-ops on file descriptors. */
1519 add_flags &= ~ (O_NOCTTY | O_NOFOLLOW);
1523 int old_flags = fcntl (fd, F_GETFL);
1524 int new_flags = old_flags | add_flags;
1528 else if (old_flags != new_flags)
1530 if (new_flags & (O_DIRECTORY | O_NOLINKS))
1532 /* NEW_FLAGS contains at least one file creation flag that
1533 requires some checking of the open file descriptor. */
1535 if (fstat (fd, &st) != 0)
1537 else if ((new_flags & O_DIRECTORY) && ! S_ISDIR (st.st_mode))
1542 else if ((new_flags & O_NOLINKS) && 1 < st.st_nlink)
1547 new_flags &= ~ (O_DIRECTORY | O_NOLINKS);
1550 if (ok && old_flags != new_flags
1551 && fcntl (fd, F_SETFL, new_flags) == -1)
1556 error (EXIT_FAILURE, errno, _("setting flags for %s"), quote (name));
1560 /* The main loop. */
1565 char *ibuf, *bufstart; /* Input buffer. */
1566 /* These are declared static so that even though we don't free the
1567 buffers, valgrind will recognize that there is no "real" leak. */
1568 static char *real_buf; /* real buffer address before alignment */
1569 static char *real_obuf;
1570 ssize_t nread; /* Bytes read in the current block. */
1572 /* If nonzero, then the previously read block was partial and
1573 PARTREAD was its size. */
1574 size_t partread = 0;
1576 int exit_status = EXIT_SUCCESS;
1577 size_t n_bytes_read;
1579 /* Leave at least one extra byte at the beginning and end of `ibuf'
1580 for conv=swab, but keep the buffer address even. But some peculiar
1581 device drivers work only with word-aligned buffers, so leave an
1584 /* Some devices require alignment on a sector or page boundary
1585 (e.g. character disk devices). Align the input buffer to a
1586 page boundary to cover all bases. Note that due to the swab
1587 algorithm, we must have at least one byte in the page before
1588 the input buffer; thus we allocate 2 pages of slop in the
1589 real buffer. 8k above the blocksize shouldn't bother anyone.
1591 The page alignment is necessary on any Linux kernel that supports
1592 either the SGI raw I/O patch or Steven Tweedies raw I/O patch.
1593 It is necessary when accessing raw (i.e. character special) disk
1594 devices on Unixware or other SVR4-derived system. */
1596 real_buf = xmalloc (input_blocksize + INPUT_BLOCK_SLOP);
1598 ibuf += SWAB_ALIGN_OFFSET; /* allow space for swab */
1600 ibuf = ptr_align (ibuf, page_size);
1602 if (conversions_mask & C_TWOBUFS)
1604 /* Page-align the output buffer, too. */
1605 real_obuf = xmalloc (output_blocksize + OUTPUT_BLOCK_SLOP);
1606 obuf = ptr_align (real_obuf, page_size);
1614 if (skip_records != 0)
1616 uintmax_t us_bytes = input_offset + (skip_records * input_blocksize);
1617 uintmax_t us_blocks = skip (STDIN_FILENO, input_file,
1618 skip_records, input_blocksize, ibuf);
1619 us_bytes -= input_offset;
1621 /* POSIX doesn't say what to do when dd detects it has been
1622 asked to skip past EOF, so I assume it's non-fatal.
1623 There are 3 reasons why there might be unskipped blocks/bytes:
1624 1. file is too small
1625 2. pipe has not enough data
1627 if (us_blocks || (!input_offset_overflow && us_bytes))
1630 _("%s: cannot skip to specified offset"), quote (input_file));
1634 if (seek_records != 0)
1636 uintmax_t write_records = skip (STDOUT_FILENO, output_file,
1637 seek_records, output_blocksize, obuf);
1639 if (write_records != 0)
1641 memset (obuf, 0, output_blocksize);
1644 if (iwrite (STDOUT_FILENO, obuf, output_blocksize)
1645 != output_blocksize)
1647 error (0, errno, _("writing to %s"), quote (output_file));
1648 quit (EXIT_FAILURE);
1650 while (--write_records != 0);
1654 if (max_records == 0)
1659 if (r_partial + r_full >= max_records)
1662 /* Zero the buffer before reading, so that if we get a read error,
1663 whatever data we are able to read is followed by zeros.
1664 This minimizes data loss. */
1665 if ((conversions_mask & C_SYNC) && (conversions_mask & C_NOERROR))
1667 (conversions_mask & (C_BLOCK | C_UNBLOCK)) ? ' ' : '\0',
1670 nread = iread_fnc (STDIN_FILENO, ibuf, input_blocksize);
1677 error (0, errno, _("reading %s"), quote (input_file));
1678 if (conversions_mask & C_NOERROR)
1681 /* Seek past the bad block if possible. */
1682 if (!advance_input_after_read_error (input_blocksize - partread))
1684 exit_status = EXIT_FAILURE;
1686 /* Suppress duplicate diagnostics. */
1687 input_seekable = false;
1688 input_seek_errno = ESPIPE;
1690 if ((conversions_mask & C_SYNC) && !partread)
1691 /* Replace the missing input with null bytes and
1692 proceed normally. */
1699 /* Write any partial block. */
1700 exit_status = EXIT_FAILURE;
1705 n_bytes_read = nread;
1706 advance_input_offset (nread);
1708 if (n_bytes_read < input_blocksize)
1711 partread = n_bytes_read;
1712 if (conversions_mask & C_SYNC)
1714 if (!(conversions_mask & C_NOERROR))
1715 /* If C_NOERROR, we zeroed the block before reading. */
1716 memset (ibuf + n_bytes_read,
1717 (conversions_mask & (C_BLOCK | C_UNBLOCK)) ? ' ' : '\0',
1718 input_blocksize - n_bytes_read);
1719 n_bytes_read = input_blocksize;
1728 if (ibuf == obuf) /* If not C_TWOBUFS. */
1730 size_t nwritten = iwrite (STDOUT_FILENO, obuf, n_bytes_read);
1731 w_bytes += nwritten;
1732 if (nwritten != n_bytes_read)
1734 error (0, errno, _("writing %s"), quote (output_file));
1735 return EXIT_FAILURE;
1737 else if (n_bytes_read == input_blocksize)
1744 /* Do any translations on the whole buffer at once. */
1746 if (translation_needed)
1747 translate_buffer (ibuf, n_bytes_read);
1749 if (conversions_mask & C_SWAB)
1750 bufstart = swab_buffer (ibuf, &n_bytes_read);
1754 if (conversions_mask & C_BLOCK)
1755 copy_with_block (bufstart, n_bytes_read);
1756 else if (conversions_mask & C_UNBLOCK)
1757 copy_with_unblock (bufstart, n_bytes_read);
1759 copy_simple (bufstart, n_bytes_read);
1762 /* If we have a char left as a result of conv=swab, output it. */
1765 if (conversions_mask & C_BLOCK)
1766 copy_with_block (&saved_char, 1);
1767 else if (conversions_mask & C_UNBLOCK)
1768 copy_with_unblock (&saved_char, 1);
1770 output_char (saved_char);
1773 if ((conversions_mask & C_BLOCK) && col > 0)
1775 /* If the final input line didn't end with a '\n', pad
1776 the output block to `conversion_blocksize' chars. */
1778 for (i = col; i < conversion_blocksize; i++)
1779 output_char (space_character);
1782 if (col && (conversions_mask & C_UNBLOCK))
1784 /* If there was any output, add a final '\n'. */
1785 output_char (newline_character);
1788 /* Write out the last block. */
1791 size_t nwritten = iwrite (STDOUT_FILENO, obuf, oc);
1792 w_bytes += nwritten;
1797 error (0, errno, _("writing %s"), quote (output_file));
1798 return EXIT_FAILURE;
1802 if ((conversions_mask & C_FDATASYNC) && fdatasync (STDOUT_FILENO) != 0)
1804 if (errno != ENOSYS && errno != EINVAL)
1806 error (0, errno, _("fdatasync failed for %s"), quote (output_file));
1807 exit_status = EXIT_FAILURE;
1809 conversions_mask |= C_FSYNC;
1812 if (conversions_mask & C_FSYNC)
1813 while (fsync (STDOUT_FILENO) != 0)
1816 error (0, errno, _("fsync failed for %s"), quote (output_file));
1817 return EXIT_FAILURE;
1824 main (int argc, char **argv)
1830 install_signal_handlers ();
1832 initialize_main (&argc, &argv);
1833 set_program_name (argv[0]);
1834 setlocale (LC_ALL, "");
1835 bindtextdomain (PACKAGE, LOCALEDIR);
1836 textdomain (PACKAGE);
1838 /* Arrange to close stdout if parse_long_options exits. */
1839 atexit (maybe_close_stdout);
1841 page_size = getpagesize ();
1843 parse_long_options (argc, argv, PROGRAM_NAME, PACKAGE, Version,
1844 usage, AUTHORS, (char const *) NULL);
1845 close_stdout_required = false;
1847 if (getopt_long (argc, argv, "", NULL, NULL) != -1)
1848 usage (EXIT_FAILURE);
1850 /* Initialize translation table to identity translation. */
1851 for (i = 0; i < 256; i++)
1854 /* Decode arguments. */
1855 scanargs (argc, argv);
1857 apply_translations ();
1859 if (input_file == NULL)
1861 input_file = _("standard input");
1862 set_fd_flags (STDIN_FILENO, input_flags, input_file);
1866 if (fd_reopen (STDIN_FILENO, input_file, O_RDONLY | input_flags, 0) < 0)
1867 error (EXIT_FAILURE, errno, _("opening %s"), quote (input_file));
1870 offset = lseek (STDIN_FILENO, 0, SEEK_CUR);
1871 input_seekable = (0 <= offset);
1872 input_offset = MAX (0, offset);
1873 input_seek_errno = errno;
1875 if (output_file == NULL)
1877 output_file = _("standard output");
1878 set_fd_flags (STDOUT_FILENO, output_flags, output_file);
1882 mode_t perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
1885 | (conversions_mask & C_NOCREAT ? 0 : O_CREAT)
1886 | (conversions_mask & C_EXCL ? O_EXCL : 0)
1887 | (seek_records || (conversions_mask & C_NOTRUNC) ? 0 : O_TRUNC));
1889 /* Open the output file with *read* access only if we might
1890 need to read to satisfy a `seek=' request. If we can't read
1891 the file, go ahead with write-only access; it might work. */
1893 || fd_reopen (STDOUT_FILENO, output_file, O_RDWR | opts, perms) < 0)
1894 && (fd_reopen (STDOUT_FILENO, output_file, O_WRONLY | opts, perms)
1896 error (EXIT_FAILURE, errno, _("opening %s"), quote (output_file));
1898 if (seek_records != 0 && !(conversions_mask & C_NOTRUNC))
1900 uintmax_t size = seek_records * output_blocksize;
1901 unsigned long int obs = output_blocksize;
1903 if (OFF_T_MAX / output_blocksize < seek_records)
1904 error (EXIT_FAILURE, 0,
1905 _("offset too large: "
1906 "cannot truncate to a length of seek=%"PRIuMAX""
1907 " (%lu-byte) blocks"),
1910 if (ftruncate (STDOUT_FILENO, size) != 0)
1912 /* Complain only when ftruncate fails on a regular file, a
1913 directory, or a shared memory object, as POSIX 1003.1-2004
1914 specifies ftruncate's behavior only for these file types.
1915 For example, do not complain when Linux kernel 2.4 ftruncate
1916 fails on /dev/fd0. */
1917 int ftruncate_errno = errno;
1918 struct stat stdout_stat;
1919 if (fstat (STDOUT_FILENO, &stdout_stat) != 0)
1920 error (EXIT_FAILURE, errno, _("cannot fstat %s"),
1921 quote (output_file));
1922 if (S_ISREG (stdout_stat.st_mode)
1923 || S_ISDIR (stdout_stat.st_mode)
1924 || S_TYPEISSHM (&stdout_stat))
1925 error (EXIT_FAILURE, ftruncate_errno,
1926 _("failed to truncate to %"PRIuMAX" bytes in output file %s"),
1927 size, quote (output_file));
1932 start_time = gethrxtime ();
1934 exit_status = dd_copy ();