1 /* dd -- convert a file while copying it.
2 Copyright (C) 85, 90, 91, 1995-2006 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 2, or (at your option)
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, write to the Free Software Foundation,
16 Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */
18 /* Written by Paul Rubin, David MacKenzie, and Stuart Kemp. */
22 #define SWAB_ALIGN_OFFSET 2
24 #include <sys/types.h>
30 #include "fd-reopen.h"
31 #include "gethrxtime.h"
32 #include "getpagesize.h"
34 #include "long-options.h"
39 static void process_signals (void);
41 /* The official name of this program (e.g., no `g' prefix). */
42 #define PROGRAM_NAME "dd"
44 #define AUTHORS "Paul Rubin", "David MacKenzie", "Stuart Kemp"
46 /* Use SA_NOCLDSTOP as a proxy for whether the sigaction machinery is
47 present. SA_NODEFER and SA_RESETHAND are XSI extensions. */
49 # define SA_NOCLDSTOP 0
50 # define sigprocmask(How, Set, Oset) /* empty */
52 # if ! HAVE_SIGINTERRUPT
53 # define siginterrupt(sig, flag) /* empty */
60 # define SA_RESETHAND 0
64 # define SIGINFO SIGUSR1
68 # define fdatasync(fd) (errno = ENOSYS, -1)
71 #define max(a, b) ((a) > (b) ? (a) : (b))
72 #define output_char(c) \
76 if (oc >= output_blocksize) \
81 /* Default input and output blocksize. */
82 #define DEFAULT_BLOCKSIZE 512
84 /* How many bytes to add to the input and output block sizes before invoking
85 malloc. See dd_copy for details. INPUT_BLOCK_SLOP must be no less than
87 #define INPUT_BLOCK_SLOP (2 * SWAB_ALIGN_OFFSET + 2 * page_size - 1)
88 #define OUTPUT_BLOCK_SLOP (page_size - 1)
90 /* Maximum blocksize for the given SLOP.
91 Keep it smaller than SIZE_MAX - SLOP, so that we can
92 allocate buffers that size. Keep it smaller than SSIZE_MAX, for
93 the benefit of system calls like "read". And keep it smaller than
94 OFF_T_MAX, for the benefit of the large-offset seek code. */
95 #define MAX_BLOCKSIZE(slop) MIN (SIZE_MAX - (slop), MIN (SSIZE_MAX, OFF_T_MAX))
97 /* Conversions bit masks. */
113 /* Use separate input and output buffers, and combine partial
119 C_FDATASYNC = 040000,
123 /* Status bit masks. */
129 /* The name this program was run with. */
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. The offset is valid only if the input is
199 seekable and if the offset has not overflowed. */
200 static uintmax_t input_offset;
201 static bool input_offset_overflow;
203 /* Records truncated by conv=block. */
204 static uintmax_t r_truncate = 0;
206 /* Output representation of newline and space characters.
207 They change if we're converting to EBCDIC. */
208 static char newline_character = '\n';
209 static char space_character = ' ';
214 /* Current index into `obuf'. */
215 static size_t oc = 0;
217 /* Index into current line, for `conv=block' and `conv=unblock'. */
218 static size_t col = 0;
220 /* The set of signals that are caught. */
221 static sigset_t caught_signals;
223 /* If nonzero, the value of the pending fatal signal. */
224 static sig_atomic_t volatile interrupt_signal;
226 /* A count of the number of pending info signals that have been received. */
227 static sig_atomic_t volatile info_signal_count;
229 /* A longest symbol in the struct symbol_values tables below. */
230 #define LONGEST_SYMBOL "fdatasync"
232 /* A symbol and the corresponding integer value. */
235 char symbol[sizeof LONGEST_SYMBOL];
239 /* Conversion symbols, for conv="...". */
240 static struct symbol_value const conversions[] =
242 {"ascii", C_ASCII | C_TWOBUFS}, /* EBCDIC to ASCII. */
243 {"ebcdic", C_EBCDIC | C_TWOBUFS}, /* ASCII to EBCDIC. */
244 {"ibm", C_IBM | C_TWOBUFS}, /* Slightly different ASCII to EBCDIC. */
245 {"block", C_BLOCK | C_TWOBUFS}, /* Variable to fixed length records. */
246 {"unblock", C_UNBLOCK | C_TWOBUFS}, /* Fixed to variable length records. */
247 {"lcase", C_LCASE | C_TWOBUFS}, /* Translate upper to lower case. */
248 {"ucase", C_UCASE | C_TWOBUFS}, /* Translate lower to upper case. */
249 {"swab", C_SWAB | C_TWOBUFS}, /* Swap bytes of input. */
250 {"noerror", C_NOERROR}, /* Ignore i/o errors. */
251 {"nocreat", C_NOCREAT}, /* Do not create output file. */
252 {"excl", C_EXCL}, /* Fail if the output file already exists. */
253 {"notrunc", C_NOTRUNC}, /* Do not truncate output file. */
254 {"sync", C_SYNC}, /* Pad input records to ibs with NULs. */
255 {"fdatasync", C_FDATASYNC}, /* Synchronize output data before finishing. */
256 {"fsync", C_FSYNC}, /* Also synchronize output metadata. */
260 /* Flags, for iflag="..." and oflag="...". */
261 static struct symbol_value const flags[] =
263 {"append", O_APPEND},
264 {"binary", O_BINARY},
265 {"direct", O_DIRECT},
266 {"directory", O_DIRECTORY},
268 {"noatime", HAVE_WORKING_O_NOATIME ? O_NOATIME : 0},
269 {"noctty", O_NOCTTY},
270 {"nofollow", HAVE_WORKING_O_NOFOLLOW ? O_NOFOLLOW : 0},
271 {"nolinks", O_NOLINKS},
272 {"nonblock", O_NONBLOCK},
278 /* Status, for status="...". */
279 static struct symbol_value const statuses[] =
281 {"noxfer", STATUS_NOXFER},
285 /* Translation table formed by applying successive transformations. */
286 static unsigned char trans_table[256];
288 static char const ascii_to_ebcdic[] =
290 '\000', '\001', '\002', '\003', '\067', '\055', '\056', '\057',
291 '\026', '\005', '\045', '\013', '\014', '\015', '\016', '\017',
292 '\020', '\021', '\022', '\023', '\074', '\075', '\062', '\046',
293 '\030', '\031', '\077', '\047', '\034', '\035', '\036', '\037',
294 '\100', '\117', '\177', '\173', '\133', '\154', '\120', '\175',
295 '\115', '\135', '\134', '\116', '\153', '\140', '\113', '\141',
296 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
297 '\370', '\371', '\172', '\136', '\114', '\176', '\156', '\157',
298 '\174', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
299 '\310', '\311', '\321', '\322', '\323', '\324', '\325', '\326',
300 '\327', '\330', '\331', '\342', '\343', '\344', '\345', '\346',
301 '\347', '\350', '\351', '\112', '\340', '\132', '\137', '\155',
302 '\171', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
303 '\210', '\211', '\221', '\222', '\223', '\224', '\225', '\226',
304 '\227', '\230', '\231', '\242', '\243', '\244', '\245', '\246',
305 '\247', '\250', '\251', '\300', '\152', '\320', '\241', '\007',
306 '\040', '\041', '\042', '\043', '\044', '\025', '\006', '\027',
307 '\050', '\051', '\052', '\053', '\054', '\011', '\012', '\033',
308 '\060', '\061', '\032', '\063', '\064', '\065', '\066', '\010',
309 '\070', '\071', '\072', '\073', '\004', '\024', '\076', '\341',
310 '\101', '\102', '\103', '\104', '\105', '\106', '\107', '\110',
311 '\111', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
312 '\130', '\131', '\142', '\143', '\144', '\145', '\146', '\147',
313 '\150', '\151', '\160', '\161', '\162', '\163', '\164', '\165',
314 '\166', '\167', '\170', '\200', '\212', '\213', '\214', '\215',
315 '\216', '\217', '\220', '\232', '\233', '\234', '\235', '\236',
316 '\237', '\240', '\252', '\253', '\254', '\255', '\256', '\257',
317 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
318 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
319 '\312', '\313', '\314', '\315', '\316', '\317', '\332', '\333',
320 '\334', '\335', '\336', '\337', '\352', '\353', '\354', '\355',
321 '\356', '\357', '\372', '\373', '\374', '\375', '\376', '\377'
324 static char const ascii_to_ibm[] =
326 '\000', '\001', '\002', '\003', '\067', '\055', '\056', '\057',
327 '\026', '\005', '\045', '\013', '\014', '\015', '\016', '\017',
328 '\020', '\021', '\022', '\023', '\074', '\075', '\062', '\046',
329 '\030', '\031', '\077', '\047', '\034', '\035', '\036', '\037',
330 '\100', '\132', '\177', '\173', '\133', '\154', '\120', '\175',
331 '\115', '\135', '\134', '\116', '\153', '\140', '\113', '\141',
332 '\360', '\361', '\362', '\363', '\364', '\365', '\366', '\367',
333 '\370', '\371', '\172', '\136', '\114', '\176', '\156', '\157',
334 '\174', '\301', '\302', '\303', '\304', '\305', '\306', '\307',
335 '\310', '\311', '\321', '\322', '\323', '\324', '\325', '\326',
336 '\327', '\330', '\331', '\342', '\343', '\344', '\345', '\346',
337 '\347', '\350', '\351', '\255', '\340', '\275', '\137', '\155',
338 '\171', '\201', '\202', '\203', '\204', '\205', '\206', '\207',
339 '\210', '\211', '\221', '\222', '\223', '\224', '\225', '\226',
340 '\227', '\230', '\231', '\242', '\243', '\244', '\245', '\246',
341 '\247', '\250', '\251', '\300', '\117', '\320', '\241', '\007',
342 '\040', '\041', '\042', '\043', '\044', '\025', '\006', '\027',
343 '\050', '\051', '\052', '\053', '\054', '\011', '\012', '\033',
344 '\060', '\061', '\032', '\063', '\064', '\065', '\066', '\010',
345 '\070', '\071', '\072', '\073', '\004', '\024', '\076', '\341',
346 '\101', '\102', '\103', '\104', '\105', '\106', '\107', '\110',
347 '\111', '\121', '\122', '\123', '\124', '\125', '\126', '\127',
348 '\130', '\131', '\142', '\143', '\144', '\145', '\146', '\147',
349 '\150', '\151', '\160', '\161', '\162', '\163', '\164', '\165',
350 '\166', '\167', '\170', '\200', '\212', '\213', '\214', '\215',
351 '\216', '\217', '\220', '\232', '\233', '\234', '\235', '\236',
352 '\237', '\240', '\252', '\253', '\254', '\255', '\256', '\257',
353 '\260', '\261', '\262', '\263', '\264', '\265', '\266', '\267',
354 '\270', '\271', '\272', '\273', '\274', '\275', '\276', '\277',
355 '\312', '\313', '\314', '\315', '\316', '\317', '\332', '\333',
356 '\334', '\335', '\336', '\337', '\352', '\353', '\354', '\355',
357 '\356', '\357', '\372', '\373', '\374', '\375', '\376', '\377'
360 static char const ebcdic_to_ascii[] =
362 '\000', '\001', '\002', '\003', '\234', '\011', '\206', '\177',
363 '\227', '\215', '\216', '\013', '\014', '\015', '\016', '\017',
364 '\020', '\021', '\022', '\023', '\235', '\205', '\010', '\207',
365 '\030', '\031', '\222', '\217', '\034', '\035', '\036', '\037',
366 '\200', '\201', '\202', '\203', '\204', '\012', '\027', '\033',
367 '\210', '\211', '\212', '\213', '\214', '\005', '\006', '\007',
368 '\220', '\221', '\026', '\223', '\224', '\225', '\226', '\004',
369 '\230', '\231', '\232', '\233', '\024', '\025', '\236', '\032',
370 '\040', '\240', '\241', '\242', '\243', '\244', '\245', '\246',
371 '\247', '\250', '\133', '\056', '\074', '\050', '\053', '\041',
372 '\046', '\251', '\252', '\253', '\254', '\255', '\256', '\257',
373 '\260', '\261', '\135', '\044', '\052', '\051', '\073', '\136',
374 '\055', '\057', '\262', '\263', '\264', '\265', '\266', '\267',
375 '\270', '\271', '\174', '\054', '\045', '\137', '\076', '\077',
376 '\272', '\273', '\274', '\275', '\276', '\277', '\300', '\301',
377 '\302', '\140', '\072', '\043', '\100', '\047', '\075', '\042',
378 '\303', '\141', '\142', '\143', '\144', '\145', '\146', '\147',
379 '\150', '\151', '\304', '\305', '\306', '\307', '\310', '\311',
380 '\312', '\152', '\153', '\154', '\155', '\156', '\157', '\160',
381 '\161', '\162', '\313', '\314', '\315', '\316', '\317', '\320',
382 '\321', '\176', '\163', '\164', '\165', '\166', '\167', '\170',
383 '\171', '\172', '\322', '\323', '\324', '\325', '\326', '\327',
384 '\330', '\331', '\332', '\333', '\334', '\335', '\336', '\337',
385 '\340', '\341', '\342', '\343', '\344', '\345', '\346', '\347',
386 '\173', '\101', '\102', '\103', '\104', '\105', '\106', '\107',
387 '\110', '\111', '\350', '\351', '\352', '\353', '\354', '\355',
388 '\175', '\112', '\113', '\114', '\115', '\116', '\117', '\120',
389 '\121', '\122', '\356', '\357', '\360', '\361', '\362', '\363',
390 '\134', '\237', '\123', '\124', '\125', '\126', '\127', '\130',
391 '\131', '\132', '\364', '\365', '\366', '\367', '\370', '\371',
392 '\060', '\061', '\062', '\063', '\064', '\065', '\066', '\067',
393 '\070', '\071', '\372', '\373', '\374', '\375', '\376', '\377'
399 if (status != EXIT_SUCCESS)
400 fprintf (stderr, _("Try `%s --help' for more information.\n"),
405 Usage: %s [OPERAND]...\n\
408 program_name, program_name);
410 Copy a file, converting and formatting according to the operands.\n\
412 bs=BYTES force ibs=BYTES and obs=BYTES\n\
413 cbs=BYTES convert BYTES bytes at a time\n\
414 conv=CONVS convert the file as per the comma separated symbol list\n\
415 count=BLOCKS copy only BLOCKS input blocks\n\
416 ibs=BYTES read BYTES bytes at a time\n\
419 if=FILE read from FILE instead of stdin\n\
420 iflag=FLAGS read as per the comma separated symbol list\n\
421 obs=BYTES write BYTES bytes at a time\n\
422 of=FILE write to FILE instead of stdout\n\
423 oflag=FLAGS write as per the comma separated symbol list\n\
424 seek=BLOCKS skip BLOCKS obs-sized blocks at start of output\n\
425 skip=BLOCKS skip BLOCKS ibs-sized blocks at start of input\n\
426 status=noxfer suppress transfer statistics\n\
430 BLOCKS and BYTES may be followed by the following multiplicative suffixes:\n\
431 xM M, c 1, w 2, b 512, kB 1000, K 1024, MB 1000*1000, M 1024*1024,\n\
432 GB 1000*1000*1000, G 1024*1024*1024, and so on for T, P, E, Z, Y.\n\
434 Each CONV symbol may be:\n\
438 ascii from EBCDIC to ASCII\n\
439 ebcdic from ASCII to EBCDIC\n\
440 ibm from ASCII to alternate EBCDIC\n\
441 block pad newline-terminated records with spaces to cbs-size\n\
442 unblock replace trailing spaces in cbs-size records with newline\n\
443 lcase change upper case to lower case\n\
446 nocreat do not create the output file\n\
447 excl fail if the output file already exists\n\
448 notrunc do not truncate the output file\n\
449 ucase change lower case to upper case\n\
450 swab swap every pair of input bytes\n\
451 noerror continue after read errors\n\
452 sync pad every input block with NULs to ibs-size; when used\n\
453 with block or unblock, pad with spaces rather than NULs\n\
454 fdatasync physically write output file data before finishing\n\
455 fsync likewise, but also write metadata\n\
459 Each FLAG symbol may be:\n\
461 append append mode (makes sense only for output; conv=notrunc suggested)\n\
464 fputs (_(" direct use direct I/O for data\n"), stdout);
466 fputs (_(" directory fail unless a directory\n"), stdout);
468 fputs (_(" dsync use synchronized I/O for data\n"), stdout);
470 fputs (_(" sync likewise, but also for metadata\n"), stdout);
472 fputs (_(" nonblock use non-blocking I/O\n"), stdout);
473 if (HAVE_WORKING_O_NOATIME)
474 fputs (_(" noatime do not update access time\n"), stdout);
476 fputs (_(" noctty do not assign controlling terminal from file\n"),
478 if (HAVE_WORKING_O_NOFOLLOW)
479 fputs (_(" nofollow do not follow symlinks\n"), stdout);
481 fputs (_(" nolinks fail if multiply-linked\n"), stdout);
483 fputs (_(" binary use binary I/O for data\n"), stdout);
485 fputs (_(" text use text I/O for data\n"), stdout);
488 char const *siginfo_name = (SIGINFO == SIGUSR1 ? "USR1" : "INFO");
491 Sending a %s signal to a running `dd' process makes it\n\
492 print I/O statistics to standard error and then resume copying.\n\
494 $ dd if=/dev/zero of=/dev/null& pid=$!\n\
495 $ kill -%s $pid; sleep 1; kill $pid\n\
496 18335302+0 records in\n\
497 18335302+0 records out\n\
498 9387674624 bytes (9.4 GB) copied, 34.6279 seconds, 271 MB/s\n\
503 siginfo_name, siginfo_name);
506 fputs (HELP_OPTION_DESCRIPTION, stdout);
507 fputs (VERSION_OPTION_DESCRIPTION, stdout);
508 printf (_("\nReport bugs to <%s>.\n"), PACKAGE_BUGREPORT);
514 translate_charset (char const *new_trans)
518 for (i = 0; i < 256; i++)
519 trans_table[i] = new_trans[trans_table[i]];
520 translation_needed = true;
523 /* Return true if I has more than one bit set. I must be nonnegative. */
526 multiple_bits_set (int i)
528 return (i & (i - 1)) != 0;
531 /* Print transfer statistics. */
536 xtime_t now = gethrxtime ();
537 char hbuf[LONGEST_HUMAN_READABLE + 1];
539 (human_autoscale | human_round_to_nearest
540 | human_space_before_unit | human_SI | human_B);
542 char const *bytes_per_second;
545 _("%"PRIuMAX"+%"PRIuMAX" records in\n"
546 "%"PRIuMAX"+%"PRIuMAX" records out\n"),
547 r_full, r_partial, w_full, w_partial);
551 ngettext ("%"PRIuMAX" truncated record\n",
552 "%"PRIuMAX" truncated records\n",
553 select_plural (r_truncate)),
556 if (status_flags & STATUS_NOXFER)
559 /* Use integer arithmetic to compute the transfer rate,
560 since that makes it easy to use SI abbreviations. */
563 ngettext ("%"PRIuMAX" byte (%s) copied",
564 "%"PRIuMAX" bytes (%s) copied",
565 select_plural (w_bytes)),
567 human_readable (w_bytes, hbuf, human_opts, 1, 1));
569 if (start_time < now)
571 double XTIME_PRECISIONe0 = XTIME_PRECISION;
572 uintmax_t delta_xtime = now;
573 delta_xtime -= start_time;
574 delta_s = delta_xtime / XTIME_PRECISIONe0;
575 bytes_per_second = human_readable (w_bytes, hbuf, human_opts,
576 XTIME_PRECISION, delta_xtime);
581 bytes_per_second = _("Infinity B");
584 /* TRANSLATORS: The two instances of "s" in this string are the SI
585 symbol "s" (meaning second), and should not be translated.
587 This format used to be:
589 ngettext (", %g second, %s/s\n", ", %g seconds, %s/s\n", delta_s == 1)
591 but that was incorrect for languages like Polish. To fix this
592 bug we now use SI symbols even though they're a bit more
593 confusing in English. */
594 fprintf (stderr, _(", %g s, %s/s\n"), delta_s, bytes_per_second);
600 if (close (STDIN_FILENO) < 0)
601 error (EXIT_FAILURE, errno,
602 _("closing input file %s"), quote (input_file));
604 /* Don't remove this call to close, even though close_stdout
605 closes standard output. This close is necessary when cleanup
606 is called as part of a signal handler. */
607 if (close (STDOUT_FILENO) < 0)
608 error (EXIT_FAILURE, errno,
609 _("closing output file %s"), quote (output_file));
612 static inline void ATTRIBUTE_NORETURN
621 /* An ordinary signal was received; arrange for the program to exit. */
624 interrupt_handler (int sig)
627 signal (sig, SIG_DFL);
628 interrupt_signal = sig;
631 /* An info signal was received; arrange for the program to print status. */
634 siginfo_handler (int sig)
637 signal (sig, siginfo_handler);
641 /* Install the signal handlers. */
644 install_signal_handlers (void)
646 bool catch_siginfo = ! (SIGINFO == SIGUSR1 && getenv ("POSIXLY_CORRECT"));
650 struct sigaction act;
651 sigemptyset (&caught_signals);
654 sigaction (SIGINFO, NULL, &act);
655 if (act.sa_handler != SIG_IGN)
656 sigaddset (&caught_signals, SIGINFO);
658 sigaction (SIGINT, NULL, &act);
659 if (act.sa_handler != SIG_IGN)
660 sigaddset (&caught_signals, SIGINT);
661 act.sa_mask = caught_signals;
663 if (sigismember (&caught_signals, SIGINFO))
665 act.sa_handler = siginfo_handler;
667 sigaction (SIGINFO, &act, NULL);
670 if (sigismember (&caught_signals, SIGINT))
672 /* POSIX 1003.1-2001 says SA_RESETHAND implies SA_NODEFER,
673 but this is not true on Solaris 8 at least. It doesn't
674 hurt to use SA_NODEFER here, so leave it in. */
675 act.sa_handler = interrupt_handler;
676 act.sa_flags = SA_NODEFER | SA_RESETHAND;
677 sigaction (SIGINT, &act, NULL);
682 if (catch_siginfo && signal (SIGINFO, SIG_IGN) != SIG_IGN)
684 signal (SIGINFO, siginfo_handler);
685 siginterrupt (SIGINFO, 1);
687 if (signal (SIGINT, SIG_IGN) != SIG_IGN)
689 signal (SIGINT, interrupt_handler);
690 siginterrupt (SIGINT, 1);
695 /* Process any pending signals. If signals are caught, this function
696 should be called periodically. Ideally there should never be an
697 unbounded amount of time when signals are not being processed. */
700 process_signals (void)
702 while (interrupt_signal | info_signal_count)
708 sigprocmask (SIG_BLOCK, &caught_signals, &oldset);
710 /* Reload interrupt_signal and info_signal_count, in case a new
711 signal was handled before sigprocmask took effect. */
712 interrupt = interrupt_signal;
713 infos = info_signal_count;
716 info_signal_count = infos - 1;
718 sigprocmask (SIG_SETMASK, &oldset, NULL);
728 /* Read from FD into the buffer BUF of size SIZE, processing any
729 signals that arrive before bytes are read. Return the number of
730 bytes read if successful, -1 (setting errno) on failure. */
733 iread (int fd, char *buf, size_t size)
739 nread = read (fd, buf, size);
740 if (! (nread < 0 && errno == EINTR))
745 /* Write to FD the buffer BUF of size SIZE, processing any signals
746 that arrive. Return the number of bytes written, setting errno if
747 this is less than SIZE. Keep trying if there are partial
751 iwrite (int fd, char const *buf, size_t size)
753 size_t total_written = 0;
755 while (total_written < size)
759 nwritten = write (fd, buf + total_written, size - total_written);
765 else if (nwritten == 0)
767 /* Some buggy drivers return 0 when one tries to write beyond
768 a device's end. (Example: Linux 1.2.13 on /dev/fd0.)
769 Set errno to ENOSPC so they get a sensible diagnostic. */
774 total_written += nwritten;
777 return total_written;
780 /* Write, then empty, the output buffer `obuf'. */
785 size_t nwritten = iwrite (STDOUT_FILENO, obuf, output_blocksize);
787 if (nwritten != output_blocksize)
789 error (0, errno, _("writing to %s"), quote (output_file));
799 /* Interpret one "conv=..." or similar operand STR according to the
800 symbols in TABLE, returning the flags specified. If the operand
801 cannot be parsed, use ERROR_MSGID to generate a diagnostic.
802 As a by product, this function replaces each `,' in STR with a NUL byte. */
805 parse_symbols (char *str, struct symbol_value const *table,
806 char const *error_msgid)
812 struct symbol_value const *entry;
813 char *new = strchr (str, ',');
816 for (entry = table; ; entry++)
818 if (! entry->symbol[0])
820 error (0, 0, _(error_msgid), quote (str));
821 usage (EXIT_FAILURE);
823 if (STREQ (entry->symbol, str))
826 error (EXIT_FAILURE, 0, _(error_msgid), quote (str));
827 value |= entry->value;
838 /* Return the value of STR, interpreted as a non-negative decimal integer,
839 optionally multiplied by various values.
840 Set *INVALID if STR does not represent a number in this format. */
843 parse_integer (const char *str, bool *invalid)
847 enum strtol_error e = xstrtoumax (str, &suffix, 10, &n, "bcEGkKMPTwYZ0");
849 if (e == LONGINT_INVALID_SUFFIX_CHAR && *suffix == 'x')
851 uintmax_t multiplier = parse_integer (suffix + 1, invalid);
853 if (multiplier != 0 && n * multiplier / multiplier != n)
861 else if (e != LONGINT_OK)
871 scanargs (int argc, char **argv)
875 for (i = optind; i < argc; i++)
880 val = strchr (name, '=');
883 error (0, 0, _("unrecognized operand %s"), quote (name));
884 usage (EXIT_FAILURE);
888 if (STREQ (name, "if"))
890 else if (STREQ (name, "of"))
892 else if (STREQ (name, "conv"))
893 conversions_mask |= parse_symbols (val, conversions,
894 N_("invalid conversion: %s"));
895 else if (STREQ (name, "iflag"))
896 input_flags |= parse_symbols (val, flags,
897 N_("invalid input flag: %s"));
898 else if (STREQ (name, "oflag"))
899 output_flags |= parse_symbols (val, flags,
900 N_("invalid output flag: %s"));
901 else if (STREQ (name, "status"))
902 status_flags |= parse_symbols (val, statuses,
903 N_("invalid status flag: %s"));
906 bool invalid = false;
907 uintmax_t n = parse_integer (val, &invalid);
909 if (STREQ (name, "ibs"))
911 invalid |= ! (0 < n && n <= MAX_BLOCKSIZE (INPUT_BLOCK_SLOP));
913 conversions_mask |= C_TWOBUFS;
915 else if (STREQ (name, "obs"))
917 invalid |= ! (0 < n && n <= MAX_BLOCKSIZE (OUTPUT_BLOCK_SLOP));
918 output_blocksize = n;
919 conversions_mask |= C_TWOBUFS;
921 else if (STREQ (name, "bs"))
923 invalid |= ! (0 < n && n <= MAX_BLOCKSIZE (INPUT_BLOCK_SLOP));
924 output_blocksize = input_blocksize = n;
926 else if (STREQ (name, "cbs"))
928 invalid |= ! (0 < n && n <= SIZE_MAX);
929 conversion_blocksize = n;
931 else if (STREQ (name, "skip"))
933 else if (STREQ (name, "seek"))
935 else if (STREQ (name, "count"))
939 error (0, 0, _("unrecognized operand %s=%s"),
940 quote_n (0, name), quote_n (1, val));
941 usage (EXIT_FAILURE);
945 error (EXIT_FAILURE, 0, _("invalid number %s"), quote (val));
949 /* If bs= was given, both `input_blocksize' and `output_blocksize' will
950 have been set to positive values. If either has not been set,
951 bs= was not given, so make sure two buffers are used. */
952 if (input_blocksize == 0 || output_blocksize == 0)
953 conversions_mask |= C_TWOBUFS;
954 if (input_blocksize == 0)
955 input_blocksize = DEFAULT_BLOCKSIZE;
956 if (output_blocksize == 0)
957 output_blocksize = DEFAULT_BLOCKSIZE;
958 if (conversion_blocksize == 0)
959 conversions_mask &= ~(C_BLOCK | C_UNBLOCK);
961 if (input_flags & (O_DSYNC | O_SYNC))
962 input_flags |= O_RSYNC;
964 if (multiple_bits_set (conversions_mask & (C_ASCII | C_EBCDIC | C_IBM)))
965 error (EXIT_FAILURE, 0, _("cannot combine any two of {ascii,ebcdic,ibm}"));
966 if (multiple_bits_set (conversions_mask & (C_BLOCK | C_UNBLOCK)))
967 error (EXIT_FAILURE, 0, _("cannot combine block and unblock"));
968 if (multiple_bits_set (conversions_mask & (C_LCASE | C_UCASE)))
969 error (EXIT_FAILURE, 0, _("cannot combine lcase and ucase"));
970 if (multiple_bits_set (conversions_mask & (C_EXCL | C_NOCREAT)))
971 error (EXIT_FAILURE, 0, _("cannot combine excl and nocreat"));
974 /* Fix up translation table. */
977 apply_translations (void)
981 if (conversions_mask & C_ASCII)
982 translate_charset (ebcdic_to_ascii);
984 if (conversions_mask & C_UCASE)
986 for (i = 0; i < 256; i++)
987 trans_table[i] = toupper (trans_table[i]);
988 translation_needed = true;
990 else if (conversions_mask & C_LCASE)
992 for (i = 0; i < 256; i++)
993 trans_table[i] = tolower (trans_table[i]);
994 translation_needed = true;
997 if (conversions_mask & C_EBCDIC)
999 translate_charset (ascii_to_ebcdic);
1000 newline_character = ascii_to_ebcdic['\n'];
1001 space_character = ascii_to_ebcdic[' '];
1003 else if (conversions_mask & C_IBM)
1005 translate_charset (ascii_to_ibm);
1006 newline_character = ascii_to_ibm['\n'];
1007 space_character = ascii_to_ibm[' '];
1011 /* Apply the character-set translations specified by the user
1012 to the NREAD bytes in BUF. */
1015 translate_buffer (char *buf, size_t nread)
1020 for (i = nread, cp = buf; i; i--, cp++)
1021 *cp = trans_table[to_uchar (*cp)];
1024 /* If true, the last char from the previous call to `swab_buffer'
1025 is saved in `saved_char'. */
1026 static bool char_is_saved = false;
1028 /* Odd char from previous call. */
1029 static char saved_char;
1031 /* Swap NREAD bytes in BUF, plus possibly an initial char from the
1032 previous call. If NREAD is odd, save the last char for the
1033 next call. Return the new start of the BUF buffer. */
1036 swab_buffer (char *buf, size_t *nread)
1038 char *bufstart = buf;
1042 /* Is a char left from last time? */
1045 *--bufstart = saved_char;
1047 char_is_saved = false;
1052 /* An odd number of chars are in the buffer. */
1053 saved_char = bufstart[--*nread];
1054 char_is_saved = true;
1057 /* Do the byte-swapping by moving every second character two
1058 positions toward the end, working from the end of the buffer
1059 toward the beginning. This way we only move half of the data. */
1061 cp = bufstart + *nread; /* Start one char past the last. */
1062 for (i = *nread / 2; i; i--, cp -= 2)
1068 /* Add OFFSET to the input offset, setting the overflow flag if
1072 advance_input_offset (uintmax_t offset)
1074 input_offset += offset;
1075 if (input_offset < offset)
1076 input_offset_overflow = true;
1079 /* This is a wrapper for lseek. It detects and warns about a kernel
1080 bug that makes lseek a no-op for tape devices, even though the kernel
1081 lseek return value suggests that the function succeeded.
1083 The parameters are the same as those of the lseek function, but
1084 with the addition of FILENAME, the name of the file associated with
1085 descriptor FDESC. The file name is used solely in the warning that's
1086 printed when the bug is detected. Return the same value that lseek
1087 would have returned, but when the lseek bug is detected, return -1
1088 to indicate that lseek failed.
1090 The offending behavior has been confirmed with an Exabyte SCSI tape
1091 drive accessed via /dev/nst0 on both Linux-2.2.17 and Linux-2.4.16. */
1095 # include <sys/mtio.h>
1097 # define MT_SAME_POSITION(P, Q) \
1098 ((P).mt_resid == (Q).mt_resid \
1099 && (P).mt_fileno == (Q).mt_fileno \
1100 && (P).mt_blkno == (Q).mt_blkno)
1103 skip_via_lseek (char const *filename, int fdesc, off_t offset, int whence)
1107 bool got_original_tape_position = (ioctl (fdesc, MTIOCGET, &s1) == 0);
1108 /* known bad device type */
1109 /* && s.mt_type == MT_ISSCSI2 */
1111 off_t new_position = lseek (fdesc, offset, whence);
1112 if (0 <= new_position
1113 && got_original_tape_position
1114 && ioctl (fdesc, MTIOCGET, &s2) == 0
1115 && MT_SAME_POSITION (s1, s2))
1117 error (0, 0, _("warning: working around lseek kernel bug for file (%s)\n\
1118 of mt_type=0x%0lx -- see <sys/mtio.h> for the list of types"),
1119 filename, s2.mt_type);
1124 return new_position;
1127 # define skip_via_lseek(Filename, Fd, Offset, Whence) lseek (Fd, Offset, Whence)
1130 /* Throw away RECORDS blocks of BLOCKSIZE bytes on file descriptor FDESC,
1131 which is open with read permission for FILE. Store up to BLOCKSIZE
1132 bytes of the data at a time in BUF, if necessary. RECORDS must be
1133 nonzero. If fdesc is STDIN_FILENO, advance the input offset.
1134 Return the number of records remaining, i.e., that were not skipped
1135 because EOF was reached. */
1138 skip (int fdesc, char const *file, uintmax_t records, size_t blocksize,
1141 uintmax_t offset = records * blocksize;
1143 /* Try lseek and if an error indicates it was an inappropriate operation --
1144 or if the file offset is not representable as an off_t --
1145 fall back on using read. */
1148 if (records <= OFF_T_MAX / blocksize
1149 && 0 <= skip_via_lseek (file, fdesc, offset, SEEK_CUR))
1151 if (fdesc == STDIN_FILENO)
1152 advance_input_offset (offset);
1157 int lseek_errno = errno;
1161 ssize_t nread = iread (fdesc, buf, blocksize);
1164 if (fdesc == STDIN_FILENO)
1166 error (0, errno, _("reading %s"), quote (file));
1167 if (conversions_mask & C_NOERROR)
1174 error (0, lseek_errno, _("%s: cannot seek"), quote (file));
1175 quit (EXIT_FAILURE);
1180 if (fdesc == STDIN_FILENO)
1181 advance_input_offset (nread);
1183 while (--records != 0);
1189 /* Advance the input by NBYTES if possible, after a read error.
1190 The input file offset may or may not have advanced after the failed
1191 read; adjust it to point just after the bad record regardless.
1192 Return true if successful, or if the input is already known to not
1196 advance_input_after_read_error (size_t nbytes)
1198 if (! input_seekable)
1200 if (input_seek_errno == ESPIPE)
1202 errno = input_seek_errno;
1207 advance_input_offset (nbytes);
1208 input_offset_overflow |= (OFF_T_MAX < input_offset);
1209 if (input_offset_overflow)
1211 error (0, 0, _("offset overflow while reading file %s"),
1212 quote (input_file));
1215 offset = lseek (STDIN_FILENO, 0, SEEK_CUR);
1219 if (offset == input_offset)
1221 diff = input_offset - offset;
1222 if (! (0 <= diff && diff <= nbytes))
1223 error (0, 0, _("warning: screwy file offset after failed read"));
1224 if (0 <= skip_via_lseek (input_file, STDIN_FILENO, diff, SEEK_CUR))
1227 error (0, 0, _("cannot work around kernel bug after all"));
1231 error (0, errno, _("%s: cannot seek"), quote (input_file));
1235 /* Copy NREAD bytes of BUF, with no conversions. */
1238 copy_simple (char const *buf, size_t nread)
1240 const char *start = buf; /* First uncopied char in BUF. */
1244 size_t nfree = MIN (nread, output_blocksize - oc);
1246 memcpy (obuf + oc, start, nfree);
1248 nread -= nfree; /* Update the number of bytes left to copy. */
1251 if (oc >= output_blocksize)
1257 /* Copy NREAD bytes of BUF, doing conv=block
1258 (pad newline-terminated records to `conversion_blocksize',
1259 replacing the newline with trailing spaces). */
1262 copy_with_block (char const *buf, size_t nread)
1266 for (i = nread; i; i--, buf++)
1268 if (*buf == newline_character)
1270 if (col < conversion_blocksize)
1273 for (j = col; j < conversion_blocksize; j++)
1274 output_char (space_character);
1280 if (col == conversion_blocksize)
1282 else if (col < conversion_blocksize)
1289 /* Copy NREAD bytes of BUF, doing conv=unblock
1290 (replace trailing spaces in `conversion_blocksize'-sized records
1294 copy_with_unblock (char const *buf, size_t nread)
1298 static size_t pending_spaces = 0;
1300 for (i = 0; i < nread; i++)
1304 if (col++ >= conversion_blocksize)
1306 col = pending_spaces = 0; /* Wipe out any pending spaces. */
1307 i--; /* Push the char back; get it later. */
1308 output_char (newline_character);
1310 else if (c == space_character)
1314 /* `c' is the character after a run of spaces that were not
1315 at the end of the conversion buffer. Output them. */
1316 while (pending_spaces)
1318 output_char (space_character);
1326 /* Set the file descriptor flags for FD that correspond to the nonzero bits
1327 in ADD_FLAGS. The file's name is NAME. */
1330 set_fd_flags (int fd, int add_flags, char const *name)
1332 /* Ignore file creation flags that are no-ops on file descriptors. */
1333 add_flags &= ~ (O_NOCTTY | O_NOFOLLOW);
1337 int old_flags = fcntl (fd, F_GETFL);
1338 int new_flags = old_flags | add_flags;
1342 else if (old_flags != new_flags)
1344 if (new_flags & (O_DIRECTORY | O_NOLINKS))
1346 /* NEW_FLAGS contains at least one file creation flag that
1347 requires some checking of the open file descriptor. */
1349 if (fstat (fd, &st) != 0)
1351 else if ((new_flags & O_DIRECTORY) && ! S_ISDIR (st.st_mode))
1356 else if ((new_flags & O_NOLINKS) && 1 < st.st_nlink)
1361 new_flags &= ~ (O_DIRECTORY | O_NOLINKS);
1364 if (ok && old_flags != new_flags
1365 && fcntl (fd, F_SETFL, new_flags) == -1)
1370 error (EXIT_FAILURE, errno, _("setting flags for %s"), quote (name));
1374 /* The main loop. */
1379 char *ibuf, *bufstart; /* Input buffer. */
1380 char *real_buf; /* real buffer address before alignment */
1382 ssize_t nread; /* Bytes read in the current block. */
1384 /* If nonzero, then the previously read block was partial and
1385 PARTREAD was its size. */
1386 size_t partread = 0;
1388 int exit_status = EXIT_SUCCESS;
1389 size_t n_bytes_read;
1391 /* Leave at least one extra byte at the beginning and end of `ibuf'
1392 for conv=swab, but keep the buffer address even. But some peculiar
1393 device drivers work only with word-aligned buffers, so leave an
1396 /* Some devices require alignment on a sector or page boundary
1397 (e.g. character disk devices). Align the input buffer to a
1398 page boundary to cover all bases. Note that due to the swab
1399 algorithm, we must have at least one byte in the page before
1400 the input buffer; thus we allocate 2 pages of slop in the
1401 real buffer. 8k above the blocksize shouldn't bother anyone.
1403 The page alignment is necessary on any linux system that supports
1404 either the SGI raw I/O patch or Steven Tweedies raw I/O patch.
1405 It is necessary when accessing raw (i.e. character special) disk
1406 devices on Unixware or other SVR4-derived system. */
1408 real_buf = xmalloc (input_blocksize + INPUT_BLOCK_SLOP);
1410 ibuf += SWAB_ALIGN_OFFSET; /* allow space for swab */
1412 ibuf = ptr_align (ibuf, page_size);
1414 if (conversions_mask & C_TWOBUFS)
1416 /* Page-align the output buffer, too. */
1417 real_obuf = xmalloc (output_blocksize + OUTPUT_BLOCK_SLOP);
1418 obuf = ptr_align (real_obuf, page_size);
1426 if (skip_records != 0)
1428 skip (STDIN_FILENO, input_file, skip_records, input_blocksize, ibuf);
1429 /* POSIX doesn't say what to do when dd detects it has been
1430 asked to skip past EOF, so I assume it's non-fatal if the
1431 call to 'skip' returns nonzero. FIXME: maybe give a warning. */
1434 if (seek_records != 0)
1436 uintmax_t write_records = skip (STDOUT_FILENO, output_file,
1437 seek_records, output_blocksize, obuf);
1439 if (write_records != 0)
1441 memset (obuf, 0, output_blocksize);
1444 if (iwrite (STDOUT_FILENO, obuf, output_blocksize)
1445 != output_blocksize)
1447 error (0, errno, _("writing to %s"), quote (output_file));
1448 quit (EXIT_FAILURE);
1450 while (--write_records != 0);
1454 if (max_records == 0)
1459 if (r_partial + r_full >= max_records)
1462 /* Zero the buffer before reading, so that if we get a read error,
1463 whatever data we are able to read is followed by zeros.
1464 This minimizes data loss. */
1465 if ((conversions_mask & C_SYNC) && (conversions_mask & C_NOERROR))
1467 (conversions_mask & (C_BLOCK | C_UNBLOCK)) ? ' ' : '\0',
1470 nread = iread (STDIN_FILENO, ibuf, input_blocksize);
1477 error (0, errno, _("reading %s"), quote (input_file));
1478 if (conversions_mask & C_NOERROR)
1481 /* Seek past the bad block if possible. */
1482 if (!advance_input_after_read_error (input_blocksize - partread))
1484 exit_status = EXIT_FAILURE;
1486 /* Suppress duplicate diagnostics. */
1487 input_seekable = false;
1488 input_seek_errno = ESPIPE;
1490 if ((conversions_mask & C_SYNC) && !partread)
1491 /* Replace the missing input with null bytes and
1492 proceed normally. */
1499 /* Write any partial block. */
1500 exit_status = EXIT_FAILURE;
1505 n_bytes_read = nread;
1506 advance_input_offset (nread);
1508 if (n_bytes_read < input_blocksize)
1511 partread = n_bytes_read;
1512 if (conversions_mask & C_SYNC)
1514 if (!(conversions_mask & C_NOERROR))
1515 /* If C_NOERROR, we zeroed the block before reading. */
1516 memset (ibuf + n_bytes_read,
1517 (conversions_mask & (C_BLOCK | C_UNBLOCK)) ? ' ' : '\0',
1518 input_blocksize - n_bytes_read);
1519 n_bytes_read = input_blocksize;
1528 if (ibuf == obuf) /* If not C_TWOBUFS. */
1530 size_t nwritten = iwrite (STDOUT_FILENO, obuf, n_bytes_read);
1531 w_bytes += nwritten;
1532 if (nwritten != n_bytes_read)
1534 error (0, errno, _("writing %s"), quote (output_file));
1535 return EXIT_FAILURE;
1537 else if (n_bytes_read == input_blocksize)
1544 /* Do any translations on the whole buffer at once. */
1546 if (translation_needed)
1547 translate_buffer (ibuf, n_bytes_read);
1549 if (conversions_mask & C_SWAB)
1550 bufstart = swab_buffer (ibuf, &n_bytes_read);
1554 if (conversions_mask & C_BLOCK)
1555 copy_with_block (bufstart, n_bytes_read);
1556 else if (conversions_mask & C_UNBLOCK)
1557 copy_with_unblock (bufstart, n_bytes_read);
1559 copy_simple (bufstart, n_bytes_read);
1562 /* If we have a char left as a result of conv=swab, output it. */
1565 if (conversions_mask & C_BLOCK)
1566 copy_with_block (&saved_char, 1);
1567 else if (conversions_mask & C_UNBLOCK)
1568 copy_with_unblock (&saved_char, 1);
1570 output_char (saved_char);
1573 if ((conversions_mask & C_BLOCK) && col > 0)
1575 /* If the final input line didn't end with a '\n', pad
1576 the output block to `conversion_blocksize' chars. */
1578 for (i = col; i < conversion_blocksize; i++)
1579 output_char (space_character);
1582 if ((conversions_mask & C_UNBLOCK) && col == conversion_blocksize)
1583 /* Add a final '\n' if there are exactly `conversion_blocksize'
1584 characters in the final record. */
1585 output_char (newline_character);
1587 /* Write out the last block. */
1590 size_t nwritten = iwrite (STDOUT_FILENO, obuf, oc);
1591 w_bytes += nwritten;
1596 error (0, errno, _("writing %s"), quote (output_file));
1597 return EXIT_FAILURE;
1604 if ((conversions_mask & C_FDATASYNC) && fdatasync (STDOUT_FILENO) != 0)
1606 if (errno != ENOSYS && errno != EINVAL)
1608 error (0, errno, _("fdatasync failed for %s"), quote (output_file));
1609 exit_status = EXIT_FAILURE;
1611 conversions_mask |= C_FSYNC;
1614 if (conversions_mask & C_FSYNC)
1615 while (fsync (STDOUT_FILENO) != 0)
1618 error (0, errno, _("fsync failed for %s"), quote (output_file));
1619 return EXIT_FAILURE;
1626 main (int argc, char **argv)
1632 initialize_main (&argc, &argv);
1633 program_name = argv[0];
1634 setlocale (LC_ALL, "");
1635 bindtextdomain (PACKAGE, LOCALEDIR);
1636 textdomain (PACKAGE);
1638 /* Arrange to close stdout if parse_long_options exits. */
1639 atexit (close_stdout);
1641 page_size = getpagesize ();
1643 parse_long_options (argc, argv, PROGRAM_NAME, PACKAGE, VERSION,
1644 usage, AUTHORS, (char const *) NULL);
1645 if (getopt_long (argc, argv, "", NULL, NULL) != -1)
1646 usage (EXIT_FAILURE);
1648 /* Initialize translation table to identity translation. */
1649 for (i = 0; i < 256; i++)
1652 /* Decode arguments. */
1653 scanargs (argc, argv);
1655 apply_translations ();
1657 if (input_file == NULL)
1659 input_file = _("standard input");
1660 set_fd_flags (STDIN_FILENO, input_flags, input_file);
1664 if (fd_reopen (STDIN_FILENO, input_file, O_RDONLY | input_flags, 0) < 0)
1665 error (EXIT_FAILURE, errno, _("opening %s"), quote (input_file));
1668 offset = lseek (STDIN_FILENO, 0, SEEK_CUR);
1669 input_seekable = (0 <= offset);
1670 input_offset = offset;
1671 input_seek_errno = errno;
1673 if (output_file == NULL)
1675 output_file = _("standard output");
1676 set_fd_flags (STDOUT_FILENO, output_flags, output_file);
1680 mode_t perms = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;
1683 | (conversions_mask & C_NOCREAT ? 0 : O_CREAT)
1684 | (conversions_mask & C_EXCL ? O_EXCL : 0)
1685 | (seek_records || (conversions_mask & C_NOTRUNC) ? 0 : O_TRUNC));
1687 /* Open the output file with *read* access only if we might
1688 need to read to satisfy a `seek=' request. If we can't read
1689 the file, go ahead with write-only access; it might work. */
1691 || fd_reopen (STDOUT_FILENO, output_file, O_RDWR | opts, perms) < 0)
1692 && (fd_reopen (STDOUT_FILENO, output_file, O_WRONLY | opts, perms)
1694 error (EXIT_FAILURE, errno, _("opening %s"), quote (output_file));
1697 if (seek_records != 0 && !(conversions_mask & C_NOTRUNC))
1699 uintmax_t size = seek_records * output_blocksize;
1700 unsigned long int obs = output_blocksize;
1702 if (OFF_T_MAX / output_blocksize < seek_records)
1703 error (EXIT_FAILURE, 0,
1704 _("offset too large: "
1705 "cannot truncate to a length of seek=%"PRIuMAX""
1706 " (%lu-byte) blocks"),
1709 if (ftruncate (STDOUT_FILENO, size) != 0)
1711 /* Complain only when ftruncate fails on a regular file, a
1712 directory, or a shared memory object, as POSIX 1003.1-2004
1713 specifies ftruncate's behavior only for these file types.
1714 For example, do not complain when Linux 2.4 ftruncate
1715 fails on /dev/fd0. */
1716 int ftruncate_errno = errno;
1717 struct stat stdout_stat;
1718 if (fstat (STDOUT_FILENO, &stdout_stat) != 0)
1719 error (EXIT_FAILURE, errno, _("cannot fstat %s"),
1720 quote (output_file));
1721 if (S_ISREG (stdout_stat.st_mode)
1722 || S_ISDIR (stdout_stat.st_mode)
1723 || S_TYPEISSHM (&stdout_stat))
1724 error (EXIT_FAILURE, ftruncate_errno,
1725 _("truncating at %"PRIuMAX" bytes in output file %s"),
1726 size, quote (output_file));
1732 install_signal_handlers ();
1734 start_time = gethrxtime ();
1736 exit_status = dd_copy ();