1 /* cat -- concatenate files and print on the standard output.
2 Copyright (C) 1988-2023 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 <https://www.gnu.org/licenses/>. */
17 /* Differences from the Unix cat:
18 * Always unbuffered, -u is ignored.
19 * Usually much faster than other versions of cat, the difference
20 is especially apparent when using the -v option.
22 By tege@sics.se, Torbjorn Granlund, advised by rms, Richard Stallman. */
26 #include <stdckdint.h>
29 #include <sys/types.h>
34 #include <sys/ioctl.h>
37 #include "alignalloc.h"
38 #include "ioblksize.h"
40 #include "full-write.h"
41 #include "safe-read.h"
42 #include "xbinary-io.h"
44 /* The official name of this program (e.g., no 'g' prefix). */
45 #define PROGRAM_NAME "cat"
48 proper_name ("Torbjorn Granlund"), \
49 proper_name ("Richard M. Stallman")
51 /* Name of input file. May be "-". */
52 static char const *infile
;
54 /* Descriptor on which input file is open. */
55 static int input_desc
;
57 /* Buffer for line numbers.
58 An 11 digit counter may overflow within an hour on a P2/466,
59 an 18 digit counter needs about 1000y */
60 #define LINE_COUNTER_BUF_LEN 20
61 static char line_buf
[LINE_COUNTER_BUF_LEN
] =
63 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ',
64 ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '0',
68 /* Position in 'line_buf' where printing starts. This will not change
69 unless the number of lines is larger than 999999. */
70 static char *line_num_print
= line_buf
+ LINE_COUNTER_BUF_LEN
- 8;
72 /* Position of the first digit in 'line_buf'. */
73 static char *line_num_start
= line_buf
+ LINE_COUNTER_BUF_LEN
- 3;
75 /* Position of the last digit in 'line_buf'. */
76 static char *line_num_end
= line_buf
+ LINE_COUNTER_BUF_LEN
- 3;
78 /* Preserves the 'cat' function's local 'newlines' between invocations. */
79 static int newlines2
= 0;
81 /* Whether there is a pending CR to process. */
82 static bool pending_cr
= false;
87 if (status
!= EXIT_SUCCESS
)
92 Usage: %s [OPTION]... [FILE]...\n\
96 Concatenate FILE(s) to standard output.\n\
103 -A, --show-all equivalent to -vET\n\
104 -b, --number-nonblank number nonempty output lines, overrides -n\n\
105 -e equivalent to -vE\n\
106 -E, --show-ends display $ at end of each line\n\
107 -n, --number number all output lines\n\
108 -s, --squeeze-blank suppress repeated empty output lines\n\
111 -t equivalent to -vT\n\
112 -T, --show-tabs display TAB characters as ^I\n\
114 -v, --show-nonprinting use ^ and M- notation, except for LFD and TAB\n\
116 fputs (HELP_OPTION_DESCRIPTION
, stdout
);
117 fputs (VERSION_OPTION_DESCRIPTION
, stdout
);
121 %s f - g Output f's contents, then standard input, then g's contents.\n\
122 %s Copy standard input to standard output.\n\
124 program_name
, program_name
);
125 emit_ancillary_info (PROGRAM_NAME
);
130 /* Compute the next line number. */
135 char *endp
= line_num_end
;
142 while (endp
>= line_num_start
);
144 if (line_num_start
> line_buf
)
145 *--line_num_start
= '1';
148 if (line_num_start
< line_num_print
)
152 /* Plain cat. Copy the file behind 'input_desc' to STDOUT_FILENO.
153 BUF (of size BUFSIZE) is the I/O buffer, used by reads and writes.
154 Return true if successful. */
157 simple_cat (char *buf
, idx_t bufsize
)
159 /* Loop until the end of the file. */
163 /* Read a block of input. */
165 size_t n_read
= safe_read (input_desc
, buf
, bufsize
);
166 if (n_read
== SAFE_READ_ERROR
)
168 error (0, errno
, "%s", quotef (infile
));
172 /* End of this file? */
177 /* Write this block out. */
179 if (full_write (STDOUT_FILENO
, buf
, n_read
) != n_read
)
184 /* Write any pending output to STDOUT_FILENO.
185 Pending is defined to be the *BPOUT - OUTBUF bytes starting at OUTBUF.
186 Then set *BPOUT to OUTPUT if it's not already that value. */
189 write_pending (char *outbuf
, char **bpout
)
191 idx_t n_write
= *bpout
- outbuf
;
194 if (full_write (STDOUT_FILENO
, outbuf
, n_write
) != n_write
)
200 /* Copy the file behind 'input_desc' to STDOUT_FILENO.
201 Use INBUF and read INSIZE with each call,
202 and OUTBUF and write OUTSIZE with each call.
203 (The buffers are a bit larger than the I/O sizes.)
204 The remaining boolean args say what 'cat' options to use.
206 Return true if successful.
207 Called if any option more than -u was specified.
209 A newline character is always put at the end of the buffer, to make
210 an explicit test for buffer end unnecessary. */
213 cat (char *inbuf
, idx_t insize
, char *outbuf
, idx_t outsize
,
214 bool show_nonprinting
, bool show_tabs
, bool number
, bool number_nonblank
,
215 bool show_ends
, bool squeeze_blank
)
217 /* Last character read from the input buffer. */
220 /* Determines how many consecutive newlines there have been in the
221 input. 0 newlines makes NEWLINES -1, 1 newline makes NEWLINES 1,
222 etc. Initially 0 to indicate that we are at the beginning of a
223 new line. The "state" of the procedure is determined by
225 int newlines
= newlines2
;
228 /* If nonzero, use the FIONREAD ioctl, as an optimization.
229 (On Ultrix, it is not supported on NFS file systems.) */
230 bool use_fionread
= true;
233 /* The inbuf pointers are initialized so that BPIN > EOB, and thereby input
234 is read immediately. */
236 /* Pointer to the first non-valid byte in the input buffer, i.e., the
237 current end of the buffer. */
240 /* Pointer to the next character in the input buffer. */
241 char *bpin
= eob
+ 1;
243 /* Pointer to the position where the next character shall be written. */
244 char *bpout
= outbuf
;
250 /* Write if there are at least OUTSIZE bytes in OUTBUF. */
252 if (outbuf
+ outsize
<= bpout
)
255 idx_t remaining_bytes
;
258 if (full_write (STDOUT_FILENO
, wp
, outsize
) != outsize
)
261 remaining_bytes
= bpout
- wp
;
263 while (outsize
<= remaining_bytes
);
265 /* Move the remaining bytes to the beginning of the
268 memmove (outbuf
, wp
, remaining_bytes
);
269 bpout
= outbuf
+ remaining_bytes
;
272 /* Is INBUF empty? */
276 bool input_pending
= false;
280 /* Is there any input to read immediately?
281 If not, we are about to wait,
282 so write all buffered output before waiting. */
285 && ioctl (input_desc
, FIONREAD
, &n_to_read
) < 0)
287 /* Ultrix returns EOPNOTSUPP on NFS;
288 HP-UX returns ENOTTY on pipes.
289 SunOS returns EINVAL and
290 More/BSD returns ENODEV on special files
292 Irix-5 returns ENOSYS on pipes. */
293 if (errno
== EOPNOTSUPP
|| errno
== ENOTTY
294 || errno
== EINVAL
|| errno
== ENODEV
296 use_fionread
= false;
299 error (0, errno
, _("cannot do ioctl on %s"),
301 newlines2
= newlines
;
306 input_pending
= true;
310 write_pending (outbuf
, &bpout
);
312 /* Read more input into INBUF. */
314 size_t n_read
= safe_read (input_desc
, inbuf
, insize
);
315 if (n_read
== SAFE_READ_ERROR
)
317 error (0, errno
, "%s", quotef (infile
));
318 write_pending (outbuf
, &bpout
);
319 newlines2
= newlines
;
324 write_pending (outbuf
, &bpout
);
325 newlines2
= newlines
;
329 /* Update the pointers and insert a sentinel at the buffer
338 /* It was a real (not a sentinel) newline. */
340 /* Was the last line empty?
341 (i.e., have two or more consecutive newlines been read?) */
347 /* Limit this to 2 here. Otherwise, with lots of
348 consecutive newlines, the counter could wrap
349 around at INT_MAX. */
352 /* Are multiple adjacent empty lines to be substituted
353 by single ditto (-s), and this was the second empty
362 /* Are line numbers to be written at empty lines (-n)? */
364 if (number
&& !number_nonblank
)
367 bpout
= stpcpy (bpout
, line_num_print
);
371 /* Output a currency symbol if requested (-e). */
383 /* Output the newline. */
391 /* Here CH cannot contain a newline character. */
399 /* Are we at the beginning of a line, and line numbers are requested? */
401 if (newlines
>= 0 && number
)
404 bpout
= stpcpy (bpout
, line_num_print
);
407 /* The loops below continue until a newline character is found,
408 which means that the buffer is empty or that a proper newline
411 /* If quoting, i.e., at least one of -v, -e, or -t specified,
412 scan for chars that need conversion. */
413 if (show_nonprinting
)
443 *bpout
++ = ch
- 128 + 64;
447 else if (ch
== '\t' && !show_tabs
)
465 /* Not quoting, neither of -v, -e, or -t specified. */
468 if (ch
== '\t' && show_tabs
)
475 if (ch
== '\r' && *bpin
== '\n' && show_ends
)
500 /* Copy data from input to output using copy_file_range if possible.
501 Return 1 if successful, 0 if ordinary read+write should be tried,
502 -1 if a serious problem has been diagnosed. */
507 /* Copy at most COPY_MAX bytes at a time; this is min
508 (SSIZE_MAX, SIZE_MAX) truncated to a value that is
509 surely aligned well. */
510 ssize_t copy_max
= MIN (SSIZE_MAX
, SIZE_MAX
) >> 30 << 30;
512 /* copy_file_range does not support some cases, and it
513 incorrectly returns 0 when reading from the proc file
514 system on the Linux kernel through at least 5.6.19 (2020),
515 so fall back on read+write if the copy_file_range is
516 unsupported or the input file seems empty. */
518 for (bool some_copied
= false; ; some_copied
= true)
519 switch (copy_file_range (input_desc
, nullptr, STDOUT_FILENO
, nullptr,
526 if (errno
== ENOSYS
|| is_ENOTSUP (errno
) || errno
== EINVAL
527 || errno
== EBADF
|| errno
== EXDEV
|| errno
== ETXTBSY
530 error (0, errno
, "%s", quotef (infile
));
537 main (int argc
, char **argv
)
539 /* Nonzero if we have ever read standard input. */
540 bool have_read_stdin
= false;
542 struct stat stat_buf
;
544 /* Variables that are set according to the specified options. */
546 bool number_nonblank
= false;
547 bool squeeze_blank
= false;
548 bool show_ends
= false;
549 bool show_nonprinting
= false;
550 bool show_tabs
= false;
551 int file_open_mode
= O_RDONLY
;
553 static struct option
const long_options
[] =
555 {"number-nonblank", no_argument
, nullptr, 'b'},
556 {"number", no_argument
, nullptr, 'n'},
557 {"squeeze-blank", no_argument
, nullptr, 's'},
558 {"show-nonprinting", no_argument
, nullptr, 'v'},
559 {"show-ends", no_argument
, nullptr, 'E'},
560 {"show-tabs", no_argument
, nullptr, 'T'},
561 {"show-all", no_argument
, nullptr, 'A'},
562 {GETOPT_HELP_OPTION_DECL
},
563 {GETOPT_VERSION_OPTION_DECL
},
564 {nullptr, 0, nullptr, 0}
567 initialize_main (&argc
, &argv
);
568 set_program_name (argv
[0]);
569 setlocale (LC_ALL
, "");
570 bindtextdomain (PACKAGE
, LOCALEDIR
);
571 textdomain (PACKAGE
);
573 /* Arrange to close stdout if we exit via the
574 case_GETOPT_HELP_CHAR or case_GETOPT_VERSION_CHAR code.
575 Normally STDOUT_FILENO is used rather than stdout, so
576 close_stdout does nothing. */
577 atexit (close_stdout
);
579 /* Parse command line options. */
582 while ((c
= getopt_long (argc
, argv
, "benstuvAET", long_options
, nullptr))
589 number_nonblank
= true;
594 show_nonprinting
= true;
602 squeeze_blank
= true;
607 show_nonprinting
= true;
611 /* We provide the -u feature unconditionally. */
615 show_nonprinting
= true;
619 show_nonprinting
= true;
632 case_GETOPT_HELP_CHAR
;
634 case_GETOPT_VERSION_CHAR (PROGRAM_NAME
, AUTHORS
);
637 usage (EXIT_FAILURE
);
641 /* Get device, i-node number, and optimal blocksize of output. */
643 if (fstat (STDOUT_FILENO
, &stat_buf
) < 0)
644 error (EXIT_FAILURE
, errno
, _("standard output"));
646 /* Optimal size of i/o operations of output. */
647 idx_t outsize
= io_blksize (stat_buf
);
649 /* Device and I-node number of the output. */
650 dev_t out_dev
= stat_buf
.st_dev
;
651 ino_t out_ino
= stat_buf
.st_ino
;
653 /* True if the output is a regular file. */
654 bool out_isreg
= S_ISREG (stat_buf
.st_mode
) != 0;
656 if (! (number
|| show_ends
|| squeeze_blank
))
658 file_open_mode
|= O_BINARY
;
659 xset_binary_mode (STDOUT_FILENO
, O_BINARY
);
667 idx_t page_size
= getpagesize ();
672 infile
= argv
[argind
];
674 bool reading_stdin
= STREQ (infile
, "-");
677 have_read_stdin
= true;
678 input_desc
= STDIN_FILENO
;
679 if (file_open_mode
& O_BINARY
)
680 xset_binary_mode (STDIN_FILENO
, O_BINARY
);
684 input_desc
= open (infile
, file_open_mode
);
687 error (0, errno
, "%s", quotef (infile
));
693 if (fstat (input_desc
, &stat_buf
) < 0)
695 error (0, errno
, "%s", quotef (infile
));
700 /* Optimal size of i/o operations of input. */
701 idx_t insize
= io_blksize (stat_buf
);
703 fdadvise (input_desc
, 0, 0, FADVISE_SEQUENTIAL
);
705 /* Don't copy a nonempty regular file to itself, as that would
706 merely exhaust the output device. It's better to catch this
707 error earlier rather than later. */
710 && stat_buf
.st_dev
== out_dev
&& stat_buf
.st_ino
== out_ino
711 && lseek (input_desc
, 0, SEEK_CUR
) < stat_buf
.st_size
)
713 error (0, 0, _("%s: input file is output file"), quotef (infile
));
718 /* Pointer to the input buffer. */
721 /* Select which version of 'cat' to use. If any format-oriented
722 options were given use 'cat'; if not, use 'copy_cat' if it
723 works, 'simple_cat' otherwise. */
725 if (! (number
|| show_ends
|| show_nonprinting
726 || show_tabs
|| squeeze_blank
))
728 int copy_cat_status
=
729 out_isreg
&& S_ISREG (stat_buf
.st_mode
) ? copy_cat () : 0;
730 if (copy_cat_status
!= 0)
733 ok
&= 0 < copy_cat_status
;
737 insize
= MAX (insize
, outsize
);
738 inbuf
= xalignalloc (page_size
, insize
);
739 ok
&= simple_cat (inbuf
, insize
);
744 /* Allocate, with an extra byte for a newline sentinel. */
745 inbuf
= xalignalloc (page_size
, insize
+ 1);
748 (OUTSIZE - 1 + INSIZE * 4 + LINE_COUNTER_BUF_LEN)
749 bytes allocated for the output buffer?
751 A test whether output needs to be written is done when the input
752 buffer empties or when a newline appears in the input. After
753 output is written, at most (OUTSIZE - 1) bytes will remain in the
754 buffer. Now INSIZE bytes of input is read. Each input character
755 may grow by a factor of 4 (by the prepending of M-^). If all
756 characters do, and no newlines appear in this block of input, we
757 will have at most (OUTSIZE - 1 + INSIZE * 4) bytes in the buffer.
758 If the last character in the preceding block of input was a
759 newline, a line number may be written (according to the given
760 options) as the first thing in the output buffer. (Done after the
761 new input is read, but before processing of the input begins.)
762 A line number requires seldom more than LINE_COUNTER_BUF_LEN
765 Align the output buffer to a page size boundary, for efficiency
766 on some paging implementations. */
769 if (ckd_mul (&bufsize
, insize
, 4)
770 || ckd_add (&bufsize
, bufsize
, outsize
)
771 || ckd_add (&bufsize
, bufsize
, LINE_COUNTER_BUF_LEN
- 1))
773 char *outbuf
= xalignalloc (page_size
, bufsize
);
775 ok
&= cat (inbuf
, insize
, outbuf
, outsize
, show_nonprinting
,
776 show_tabs
, number
, number_nonblank
, show_ends
,
785 if (!reading_stdin
&& close (input_desc
) < 0)
787 error (0, errno
, "%s", quotef (infile
));
791 while (++argind
< argc
);
795 if (full_write (STDOUT_FILENO
, "\r", 1) != 1)
799 if (have_read_stdin
&& close (STDIN_FILENO
) < 0)
800 error (EXIT_FAILURE
, errno
, _("closing standard input"));
802 return ok
? EXIT_SUCCESS
: EXIT_FAILURE
;